diff --git a/homa_api.c b/homa_api.c index 4969fac..72b32fe 100644 --- a/homa_api.c +++ b/homa_api.c @@ -38,8 +38,8 @@ ssize_t homa_reply(int sockfd, const void *message_buf, size_t length, const union sockaddr_in_union *dest_addr, uint64_t id) { struct homa_sendmsg_args args; - struct iovec vec; struct msghdr hdr; + struct iovec vec; int result; args.id = id; @@ -117,8 +117,8 @@ int homa_send(int sockfd, const void *message_buf, size_t length, uint64_t completion_cookie) { struct homa_sendmsg_args args; - struct iovec vec; struct msghdr hdr; + struct iovec vec; int result; args.id = 0; diff --git a/homa_grant.c b/homa_grant.c index e152f49..de92507 100644 --- a/homa_grant.c +++ b/homa_grant.c @@ -68,10 +68,10 @@ inline int homa_grant_update_incoming(struct homa_rpc *rpc, struct homa *homa) */ void homa_grant_add_rpc(struct homa_rpc *rpc) { - struct homa_rpc *candidate; + struct homa *homa = rpc->hsk->homa; struct homa_peer *peer = rpc->peer; struct homa_peer *peer_cand; - struct homa *homa = rpc->hsk->homa; + struct homa_rpc *candidate; /* Make sure this message is in the right place in the grantable_rpcs * list for its peer. @@ -158,11 +158,11 @@ void homa_grant_add_rpc(struct homa_rpc *rpc) */ void homa_grant_remove_rpc(struct homa_rpc *rpc) { - struct homa_rpc *head; + struct homa *homa = rpc->hsk->homa; struct homa_peer *peer = rpc->peer; struct homa_rpc *candidate; - struct homa *homa = rpc->hsk->homa; __u64 time = get_cycles(); + struct homa_rpc *head; if (list_empty(&rpc->grantable_links)) return; @@ -382,9 +382,6 @@ void homa_grant_check_rpc(struct homa_rpc *rpc) */ void homa_grant_recalc(struct homa *homa, int locked) { - int i, active, try_again; - __u64 start; - /* The tricky part of this method is that we need to release * homa->grantable_lock before actually sending grants, because * (a) we need to hold the RPC lock while sending grants, and @@ -393,6 +390,8 @@ void homa_grant_recalc(struct homa *homa, int locked) * This array hold a copy of homa->active_rpcs. */ struct homa_rpc *active_rpcs[HOMA_MAX_GRANTS]; + int i, active, try_again; + __u64 start; tt_record("homa_grant_recalc starting"); INC_METRIC(grant_recalc_calls, 1); @@ -423,8 +422,8 @@ void homa_grant_recalc(struct homa *homa, int locked) homa->max_overcommit); homa->num_active_rpcs = active; for (i = 0; i < active; i++) { - int extra_levels; struct homa_rpc *rpc = homa->active_rpcs[i]; + int extra_levels; active_rpcs[i] = rpc; atomic_inc(&rpc->grants_in_progress); @@ -563,10 +562,10 @@ int homa_grant_pick_rpcs(struct homa *homa, struct homa_rpc **rpcs, */ void homa_grant_find_oldest(struct homa *homa) { + int max_incoming = homa->grant_window + 2*homa->fifo_grant_increment; struct homa_rpc *rpc, *oldest; struct homa_peer *peer; __u64 oldest_birth; - int max_incoming = homa->grant_window + 2*homa->fifo_grant_increment; oldest = NULL; oldest_birth = ~0; @@ -647,9 +646,9 @@ void homa_grant_free_rpc(struct homa_rpc *rpc) */ int homa_grantable_lock_slow(struct homa *homa, int recalc) { - int result = 0; - __u64 start = get_cycles(); int starting_count = atomic_read(&homa->grant_recalc_count); + __u64 start = get_cycles(); + int result = 0; tt_record("beginning wait for grantable lock"); while (1) { diff --git a/homa_impl.h b/homa_impl.h index 8e6e000..daefbf1 100644 --- a/homa_impl.h +++ b/homa_impl.h @@ -874,6 +874,7 @@ struct homa { */ int temp[4]; }; + /** * struct homa_skb_info - Additional information needed by Homa for each * outbound DATA packet. Space is allocated for this at the very end of the diff --git a/homa_incoming.c b/homa_incoming.c index 18e511d..41cc9da 100644 --- a/homa_incoming.c +++ b/homa_incoming.c @@ -80,8 +80,8 @@ struct homa_gap *homa_gap_new(struct list_head *next, int start, int end) */ void homa_gap_retry(struct homa_rpc *rpc) { - struct homa_gap *gap; struct resend_header resend; + struct homa_gap *gap; list_for_each_entry(gap, &rpc->msgin.gaps, links) { resend.offset = htonl(gap->start); @@ -103,10 +103,10 @@ 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_gap *gap, *dummy, *gap2; int start = ntohl(h->seg.offset); int length = homa_data_len(skb); int end = start + length; - struct homa_gap *gap, *dummy, *gap2; if ((start + length) > rpc->msgin.length) { tt_record3("Packet extended past message end; id %d, offset %d, length %d", @@ -210,12 +210,12 @@ int homa_copy_to_user(struct homa_rpc *rpc) #define MAX_SKBS 20 #endif struct sk_buff *skbs[MAX_SKBS]; - int n = 0; /* Number of filled entries in skbs. */ - int error = 0; int start_offset = 0; int end_offset = 0; - int i; + int error = 0; __u64 start; + int n = 0; /* Number of filled entries in skbs. */ + int i; /* Tricky note: we can't hold the RPC lock while we're actually * copying to user space, because (a) it's illegal to hold a spinlock @@ -256,12 +256,12 @@ int homa_copy_to_user(struct homa_rpc *rpc) for (i = 0; i < n; i++) { struct data_header *h = (struct data_header *) skbs[i]->data; - int offset = ntohl(h->seg.offset); int pkt_length = homa_data_len(skbs[i]); + int offset = ntohl(h->seg.offset); + int buf_bytes, chunk_size; + struct iov_iter iter; int copied = 0; char *dst; - struct iov_iter iter; - int buf_bytes, chunk_size; /* Each iteration of this loop copies to one * user buffer. @@ -335,19 +335,16 @@ int homa_copy_to_user(struct homa_rpc *rpc) */ void homa_dispatch_pkts(struct sk_buff *skb, struct homa *homa) { - const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); - struct data_header *h = (struct data_header *) skb->data; - __u64 id = homa_local_id(h->common.sender_id); - int dport = ntohs(h->common.dport); - struct homa_sock *hsk; - struct homa_rpc *rpc = NULL; - struct sk_buff *next; - #ifdef __UNIT_TEST__ #define MAX_ACKS 2 #else #define MAX_ACKS 10 #endif + const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); + struct data_header *h = (struct data_header *) skb->data; + __u64 id = homa_local_id(h->common.sender_id); + int dport = ntohs(h->common.dport); + /* Used to collect acks from data packets so we can process them * all at the end (can't process them inline because that may * require locking conflicting RPCs). If we run out of space just @@ -355,6 +352,9 @@ void homa_dispatch_pkts(struct sk_buff *skb, struct homa *homa) * explicit mechanism. */ struct homa_ack acks[MAX_ACKS]; + struct homa_rpc *rpc = NULL; + struct homa_sock *hsk; + struct sk_buff *next; int num_acks = 0; /* Find the appropriate socket.*/ @@ -536,8 +536,8 @@ void homa_dispatch_pkts(struct sk_buff *skb, struct homa *homa) */ void homa_data_pkt(struct sk_buff *skb, struct homa_rpc *rpc) { - struct homa *homa = rpc->hsk->homa; struct data_header *h = (struct data_header *) skb->data; + struct homa *homa = rpc->hsk->homa; tt_record4("incoming data packet, id %d, peer 0x%x, offset %d/%d", homa_local_id(h->common.sender_id), @@ -760,12 +760,12 @@ 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; const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); + struct homa_peer *peer; int i; - struct cutoffs_header *h = (struct cutoffs_header *) skb->data; - struct homa_peer *peer = homa_peer_find(hsk->homa->peers, - &saddr, &hsk->inet); + peer = homa_peer_find(hsk->homa->peers, &saddr, &hsk->inet); if (!IS_ERR(peer)) { peer->unsched_cutoffs[0] = INT_MAX; for (i = 1; i < HOMA_MAX_PRIORITIES; i++) @@ -789,8 +789,8 @@ void homa_need_ack_pkt(struct sk_buff *skb, struct homa_sock *hsk, struct common_header *h = (struct common_header *) skb->data; const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); __u64 id = homa_local_id(h->sender_id); - struct ack_header ack; struct homa_peer *peer; + struct ack_header ack; tt_record1("Received NEED_ACK for id %d", id); @@ -843,8 +843,8 @@ void homa_need_ack_pkt(struct sk_buff *skb, struct homa_sock *hsk, void homa_ack_pkt(struct sk_buff *skb, struct homa_sock *hsk, struct homa_rpc *rpc) { - struct ack_header *h = (struct ack_header *) skb->data; const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); + struct ack_header *h = (struct ack_header *) skb->data; int i, count; if (rpc != NULL) { @@ -983,8 +983,8 @@ void homa_abort_rpcs(struct homa *homa, const struct in6_addr *addr, int port, int error) { struct homa_socktab_scan scan; - struct homa_sock *hsk; struct homa_rpc *rpc, *tmp; + struct homa_sock *hsk; rcu_read_lock(); for (hsk = homa_socktab_start_scan(homa->port_map, &scan); @@ -1181,11 +1181,11 @@ int homa_register_interests(struct homa_interest *interest, struct homa_rpc *homa_wait_for_message(struct homa_sock *hsk, int flags, __u64 id) { + int error, blocked = 0, polled = 0; struct homa_rpc *result = NULL; struct homa_interest interest; struct homa_rpc *rpc = NULL; uint64_t poll_start, now; - int error, blocked = 0, polled = 0; /* Each iteration of this loop finds an RPC, but it might not be * in a state where we can return it (e.g., there might be packets @@ -1375,10 +1375,10 @@ struct homa_rpc *homa_wait_for_message(struct homa_sock *hsk, int flags, struct homa_interest *homa_choose_interest(struct homa *homa, struct list_head *head, int offset) { + __u64 busy_time = get_cycles() - homa->busy_cycles; struct homa_interest *backup = NULL; - struct list_head *pos; struct homa_interest *interest; - __u64 busy_time = get_cycles() - homa->busy_cycles; + struct list_head *pos; list_for_each(pos, head) { interest = (struct homa_interest *) (((char *) pos) - offset); @@ -1405,8 +1405,8 @@ struct homa_interest *homa_choose_interest(struct homa *homa, */ void homa_rpc_handoff(struct homa_rpc *rpc) { - struct homa_interest *interest; struct homa_sock *hsk = rpc->hsk; + struct homa_interest *interest; if ((atomic_read(&rpc->flags) & RPC_HANDING_OFF) || !list_empty(&rpc->ready_links)) diff --git a/homa_offload.c b/homa_offload.c index db813f7..9111c14 100644 --- a/homa_offload.c +++ b/homa_offload.c @@ -74,8 +74,8 @@ int homa_offload_init(void) */ int homa_offload_end(void) { - int res1 = inet_del_offload(&homa_offload, IPPROTO_HOMA); int res2 = inet6_del_offload(&homa_offload, IPPROTO_HOMA); + int res1 = inet_del_offload(&homa_offload, IPPROTO_HOMA); return res1 ? res1 : res2; } @@ -131,6 +131,7 @@ struct sk_buff *homa_tcp_gro_receive(struct list_head *held_list, { struct common_header *h = (struct common_header *) skb_transport_header(skb); + // tt_record4("homa_tcp_gro_receive got type 0x%x, flags 0x%x, " // "urgent 0x%x, id %d", h->type, h->flags, // ntohs(h->urgent), homa_local_id(h->sender_id)); @@ -277,20 +278,21 @@ struct sk_buff *homa_gro_receive(struct list_head *held_list, * gro_list by the caller, so it will be considered for merges * in the future. */ - struct sk_buff *held_skb; - struct sk_buff *result = NULL; - struct homa_offload_core *offload_core = &per_cpu(homa_offload_core, - raw_smp_processor_id()); - __u64 now = get_cycles(); - int busy = (now - offload_core->last_gro) < homa->gro_busy_cycles; - __u32 hash; __u64 saved_softirq_metric, softirq_cycles; + struct homa_offload_core *offload_core; + struct sk_buff *result = NULL; __u64 *softirq_cycles_metric; - struct data_header *h_new = (struct data_header *) - skb_transport_header(skb); + struct data_header *h_new; + struct sk_buff *held_skb; + __u64 now = get_cycles(); int priority; __u32 saddr; + __u32 hash; + int busy; + h_new = (struct data_header *) skb_transport_header(skb); + offload_core = &per_cpu(homa_offload_core, raw_smp_processor_id()); + busy = (now - offload_core->last_gro) < homa->gro_busy_cycles; offload_core->last_active = now; if (skb_is_ipv6(skb)) { priority = ipv6_hdr(skb)->priority; @@ -468,11 +470,11 @@ void homa_gro_gen2(struct sk_buff *skb) * balancing. */ struct data_header *h = (struct data_header *) skb_transport_header(skb); - int i; int this_core = raw_smp_processor_id(); + struct homa_offload_core *offload_core; int candidate = this_core; __u64 now = get_cycles(); - struct homa_offload_core *offload_core; + int i; for (i = CORES_TO_CHECK; i > 0; i--) { candidate++; @@ -523,11 +525,12 @@ void homa_gro_gen3(struct sk_buff *skb) * load balancer. */ struct data_header *h = (struct data_header *) skb_transport_header(skb); - int i, core; __u64 now, busy_time; - int *candidates = per_cpu(homa_offload_core, raw_smp_processor_id()) - .gen3_softirq_cores; + int *candidates; + int i, core; + candidates = per_cpu(homa_offload_core, + raw_smp_processor_id()).gen3_softirq_cores; now = get_cycles(); busy_time = now - homa->busy_cycles; @@ -567,6 +570,7 @@ void homa_gro_gen3(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); + // tt_record4("homa_gro_complete type %d, id %d, offset %d, count %d", // h->common.type, homa_local_id(h->common.sender_id), // ntohl(h->seg.offset), diff --git a/homa_outgoing.c b/homa_outgoing.c index 686c27a..f49b9c8 100644 --- a/homa_outgoing.c +++ b/homa_outgoing.c @@ -122,10 +122,10 @@ struct sk_buff *homa_new_data_packet(struct homa_rpc *rpc, struct iov_iter *iter, int offset, int length, int max_seg_data) { - struct data_header *h; - struct sk_buff *skb; struct homa_skb_info *homa_info; int segs, err, gso_size; + struct data_header *h; + struct sk_buff *skb; /* Initialize the overall skb. */ skb = homa_skb_new_tx(sizeof32(struct data_header)); @@ -225,14 +225,15 @@ int homa_message_out_fill(struct homa_rpc *rpc, struct iov_iter *iter, int xmit) */ int mtu, max_seg_data, max_gso_data; + int overlap_xmit, segs_per_gso; + struct sk_buff **last_link; + struct dst_entry *dst; + /* Bytes of the message that haven't yet been copied into skbs. */ int bytes_left; - int err; - struct sk_buff **last_link; - struct dst_entry *dst; - int overlap_xmit, segs_per_gso; int gso_size; + int err; homa_message_out_init(rpc, iter->count); if (unlikely((rpc->msgout.length > HOMA_MAX_MESSAGE_LENGTH) @@ -371,12 +372,12 @@ int homa_xmit_control(enum homa_packet_type type, void *contents, int __homa_xmit_control(void *contents, size_t length, struct homa_peer *peer, struct homa_sock *hsk) { + struct netdev_queue *txq; struct common_header *h; - int extra_bytes; - int result, priority; struct dst_entry *dst; + int result, priority; struct sk_buff *skb; - struct netdev_queue *txq; + int extra_bytes; dst = homa_get_dst(peer, hsk); skb = homa_skb_new_tx(HOMA_MAX_HEADER); @@ -449,9 +450,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 in6_addr saddr = skb_canonical_ipv6_saddr(skb); struct unknown_header unknown; struct homa_peer *peer; - struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); if (hsk->homa->verbose) pr_notice("sending UNKNOWN to peer %s:%d for id %llu", @@ -548,9 +549,9 @@ void homa_xmit_data(struct homa_rpc *rpc, bool force) */ void __homa_xmit_data(struct sk_buff *skb, struct homa_rpc *rpc, int priority) { - int err; struct homa_skb_info *homa_info = homa_get_skb_info(skb); struct dst_entry *dst; + int err; /* Update info that may have changed since the message was initially * created. @@ -607,8 +608,8 @@ void __homa_xmit_data(struct sk_buff *skb, struct homa_rpc *rpc, int priority) void homa_resend_data(struct homa_rpc *rpc, int start, int end, int priority) { - struct sk_buff *skb; struct homa_skb_info *homa_info; + struct sk_buff *skb; if (end <= start) return; @@ -640,8 +641,8 @@ void homa_resend_data(struct homa_rpc *rpc, int start, int end, for ( ; data_left > 0; data_left -= seg_length, offset += seg_length, seg_offset += skb_shinfo(skb)->gso_size) { - struct sk_buff *new_skb; struct homa_skb_info *new_homa_info; + struct sk_buff *new_skb; int err; if (seg_length > data_left) @@ -740,8 +741,8 @@ void homa_outgoing_sysctl_changed(struct homa *homa) */ int homa_check_nic_queue(struct homa *homa, struct sk_buff *skb, bool force) { - __u64 idle, new_idle, clock; int cycles_for_packet, bytes; + __u64 idle, new_idle, clock; bytes = homa_get_skb_info(skb)->wire_bytes; cycles_for_packet = (bytes * homa->cycles_per_kbyte)/1000; @@ -874,8 +875,8 @@ void homa_pacer_xmit(struct homa *homa) homa_throttle_lock(homa); homa->pacer_fifo_count -= homa->pacer_fifo_fraction; if (homa->pacer_fifo_count <= 0) { - __u64 oldest = ~0; struct homa_rpc *cur; + __u64 oldest = ~0; homa->pacer_fifo_count += 1000; rpc = NULL; @@ -1031,8 +1032,8 @@ void homa_remove_from_throttled(struct homa_rpc *rpc) void homa_log_throttled(struct homa *homa) { struct homa_rpc *rpc; - int rpcs = 0; int64_t bytes = 0; + int rpcs = 0; pr_notice("Printing throttled list\n"); homa_throttle_lock(homa); diff --git a/homa_peer.c b/homa_peer.c index 7736259..60c0989 100644 --- a/homa_peer.c +++ b/homa_peer.c @@ -42,9 +42,9 @@ int homa_peertab_init(struct homa_peertab *peertab) */ void homa_peertab_destroy(struct homa_peertab *peertab) { - int i; - struct homa_peer *peer; struct hlist_node *next; + struct homa_peer *peer; + int i; if (!peertab->buckets) return; @@ -72,10 +72,10 @@ void homa_peertab_destroy(struct homa_peertab *peertab) struct homa_peer **homa_peertab_get_peers(struct homa_peertab *peertab, int *num_peers) { - int i, count; - struct homa_peer *peer; - struct hlist_node *next; struct homa_peer **result; + struct hlist_node *next; + struct homa_peer *peer; + int i, count; *num_peers = 0; if (!peertab->buckets) diff --git a/homa_peer.h b/homa_peer.h index 88955cb..b020a88 100644 --- a/homa_peer.h +++ b/homa_peer.h @@ -199,7 +199,7 @@ extern void homa_dst_refresh(struct homa_peertab *peertab, struct homa_peer *peer, struct homa_sock *hsk); extern void homa_peertab_destroy(struct homa_peertab *peertab); extern struct homa_peer ** - homa_peertab_get_peers(struct homa_peertab *peertab, + homa_peertab_get_peers(struct homa_peertab *peertab, int *num_peers); extern int homa_peertab_init(struct homa_peertab *peertab); extern void homa_peer_add_ack(struct homa_rpc *rpc); diff --git a/homa_plumbing.c b/homa_plumbing.c index 27aeeeb..ddaceb1 100644 --- a/homa_plumbing.c +++ b/homa_plumbing.c @@ -1182,14 +1182,14 @@ int homa_get_port(struct sock *sk, unsigned short snum) */ int homa_softirq(struct sk_buff *skb) { - struct common_header *h; struct sk_buff *packets, *other_pkts, *next; struct sk_buff **prev_link, **other_link; + struct common_header *h; + int first_packet = 1; static __u64 last; - __u64 start; int header_offset; - int first_packet = 1; int pull_length; + __u64 start; start = get_cycles(); INC_METRIC(softirq_calls, 1); @@ -1372,14 +1372,14 @@ int homa_backlog_rcv(struct sock *sk, struct sk_buff *skb) */ int homa_err_handler_v4(struct sk_buff *skb, u32 info) { + const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); const struct iphdr *iph = ip_hdr(skb); int type = icmp_hdr(skb)->type; int code = icmp_hdr(skb)->code; - const struct in6_addr saddr = skb_canonical_ipv6_saddr(skb); if ((type == ICMP_DEST_UNREACH) && (code == ICMP_PORT_UNREACH)) { - struct common_header *h; char *icmp = (char *) icmp_hdr(skb); + struct common_header *h; iph = (struct iphdr *) (icmp + sizeof(struct icmphdr)); h = (struct common_header *) (icmp + sizeof(struct icmphdr) @@ -1420,8 +1420,8 @@ int homa_err_handler_v6(struct sk_buff *skb, struct inet6_skb_parm *opt, const struct ipv6hdr *iph = (const struct ipv6hdr *)skb->data; if ((type == ICMPV6_DEST_UNREACH) && (code == ICMPV6_PORT_UNREACH)) { - struct common_header *h; char *icmp = (char *) icmp_hdr(skb); + struct common_header *h; iph = (struct ipv6hdr *) (icmp + sizeof(struct icmphdr)); h = (struct common_header *) (icmp + sizeof(struct icmphdr) @@ -1567,10 +1567,10 @@ int homa_dointvec(struct ctl_table *table, int write, int homa_sysctl_softirq_cores(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { - int result, i; - struct ctl_table table_copy; struct homa_offload_core *offload_core; + struct ctl_table table_copy; int max_values, *values; + int result, i; max_values = (NUM_GEN3_SOFTIRQ_CORES + 1) * nr_cpu_ids; values = kmalloc_array(max_values, sizeof(int), GFP_KERNEL); @@ -1647,9 +1647,9 @@ enum hrtimer_restart homa_hrtimer(struct hrtimer *timer) int homa_timer_main(void *transportInfo) { struct homa *homa = (struct homa *) transportInfo; - u64 nsec; - ktime_t tick_interval; struct hrtimer hrtimer; + ktime_t tick_interval; + u64 nsec; hrtimer_init(&hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); hrtimer.function = &homa_hrtimer; diff --git a/homa_pool.c b/homa_pool.c index e270032..3863fcf 100644 --- a/homa_pool.c +++ b/homa_pool.c @@ -50,8 +50,8 @@ static inline void set_bpages_needed(struct homa_pool *pool) */ int homa_pool_init(struct homa_sock *hsk, void *region, __u64 region_size) { - int i, result; struct homa_pool *pool = hsk->buffer_pool; + int i, result; if (((__u64) region) & ~PAGE_MASK) return -EINVAL; @@ -135,12 +135,13 @@ void homa_pool_destroy(struct homa_pool *pool) int homa_pool_get_pages(struct homa_pool *pool, int num_pages, __u32 *pages, int set_owner) { - int alloced = 0; + int core_num = raw_smp_processor_id(); + struct homa_pool_core *core; __u64 now = get_cycles(); + int alloced = 0; int limit = 0; - int core_num = raw_smp_processor_id(); - struct homa_pool_core *core = &pool->cores[core_num]; + core = &pool->cores[core_num]; if (atomic_sub_return(num_pages, &pool->free_bpages) < 0) { atomic_add(num_pages, &pool->free_bpages); return -1; diff --git a/homa_receiver.cc b/homa_receiver.cc index 470000f..8aeb841 100644 --- a/homa_receiver.cc +++ b/homa_receiver.cc @@ -52,13 +52,14 @@ homa::receiver::~receiver() */ void homa::receiver::copy_out(void *dest, size_t offset, size_t count) const { - ssize_t limit = offset + count; char *cdest = static_cast(dest); + ssize_t limit = offset + count; if (limit > msg_length) limit = msg_length; while (static_cast(offset) < limit) { size_t chunk_size = contiguous(offset); + memcpy(cdest, get(offset), chunk_size); offset += chunk_size; cdest += chunk_size; diff --git a/homa_receiver.h b/homa_receiver.h index 1554bc7..5480542 100644 --- a/homa_receiver.h +++ b/homa_receiver.h @@ -83,6 +83,7 @@ class receiver { template inline T* get(size_t offset, T* storage = nullptr) const { int buf_num = offset >> HOMA_BPAGE_SHIFT; + if (static_cast(offset + sizeof(T)) > msg_length) return nullptr; if (contiguous(offset) >= sizeof(T)) diff --git a/homa_rpc.c b/homa_rpc.c index c6eb5eb..5dcbc02 100644 --- a/homa_rpc.c +++ b/homa_rpc.c @@ -22,10 +22,10 @@ struct homa_rpc *homa_rpc_new_client(struct homa_sock *hsk, const union sockaddr_in_union *dest) { - int err; - struct homa_rpc *crpc; - struct homa_rpc_bucket *bucket; struct in6_addr dest_addr_as_ipv6 = canonical_ipv6_addr(dest); + struct homa_rpc_bucket *bucket; + struct homa_rpc *crpc; + int err; crpc = kmalloc(sizeof(*crpc), GFP_KERNEL); if (unlikely(!crpc)) @@ -109,14 +109,15 @@ struct homa_rpc *homa_rpc_new_server(struct homa_sock *hsk, const struct in6_addr *source, struct data_header *h, int *created) { - int err; - struct homa_rpc *srpc = NULL; __u64 id = homa_local_id(h->common.sender_id); - struct homa_rpc_bucket *bucket = homa_server_rpc_bucket(hsk, id); + struct homa_rpc_bucket *bucket; + struct homa_rpc *srpc = NULL; + int err; /* Lock the bucket, and make sure no-one else has already created * the desired RPC. */ + bucket = homa_server_rpc_bucket(hsk, id); homa_bucket_lock(bucket, id, "homa_rpc_new_server"); hlist_for_each_entry_rcu(srpc, &bucket->rpcs, hash_links) { if ((srpc->id == id) && @@ -208,11 +209,11 @@ struct homa_rpc *homa_rpc_new_server(struct homa_sock *hsk, void homa_rpc_acked(struct homa_sock *hsk, const struct in6_addr *saddr, struct homa_ack *ack) { - struct homa_rpc *rpc; - struct homa_sock *hsk2 = hsk; - __u64 id = homa_local_id(ack->client_id); __u16 client_port = ntohs(ack->client_port); __u16 server_port = ntohs(ack->server_port); + __u64 id = homa_local_id(ack->client_id); + struct homa_sock *hsk2 = hsk; + struct homa_rpc *rpc; UNIT_LOG("; ", "ack %llu", id); if (hsk2->port != server_port) { @@ -333,8 +334,8 @@ int homa_rpc_reap(struct homa_sock *hsk, int count) #else #define BATCH_MAX 20 #endif - struct sk_buff *skbs[BATCH_MAX]; struct homa_rpc *rpcs[BATCH_MAX]; + struct sk_buff *skbs[BATCH_MAX]; int num_skbs, num_rpcs; struct homa_rpc *rpc; int i, batch_size; @@ -482,8 +483,8 @@ int homa_rpc_reap(struct homa_sock *hsk, int count) */ struct homa_rpc *homa_find_client_rpc(struct homa_sock *hsk, __u64 id) { - struct homa_rpc *crpc; struct homa_rpc_bucket *bucket = homa_client_rpc_bucket(hsk, id); + struct homa_rpc *crpc; homa_bucket_lock(bucket, id, __func__); hlist_for_each_entry_rcu(crpc, &bucket->rpcs, hash_links) { @@ -509,8 +510,8 @@ struct homa_rpc *homa_find_client_rpc(struct homa_sock *hsk, __u64 id) struct homa_rpc *homa_find_server_rpc(struct homa_sock *hsk, const struct in6_addr *saddr, __u16 sport, __u64 id) { - struct homa_rpc *srpc; struct homa_rpc_bucket *bucket = homa_server_rpc_bucket(hsk, id); + struct homa_rpc *srpc; homa_bucket_lock(bucket, id, __func__); hlist_for_each_entry_rcu(srpc, &bucket->rpcs, hash_links) { @@ -691,9 +692,9 @@ void homa_rpc_log_active_tt(struct homa *homa, int freeze_count) int homa_validate_incoming(struct homa *homa, int verbose, int *link_errors) { struct homa_socktab_scan scan; + int total_incoming = 0; struct homa_sock *hsk; struct homa_rpc *rpc; - int total_incoming = 0; int actual; tt_record1("homa_validate_incoming starting, total_incoming %d", diff --git a/homa_skb.c b/homa_skb.c index 2bc9dc1..f4e0776 100644 --- a/homa_skb.c +++ b/homa_skb.c @@ -43,8 +43,8 @@ void homa_skb_init(struct homa *homa) for (i = 0; i < nr_cpu_ids; i++) { struct homa_skb_core *skb_core = &per_cpu(homa_skb_core, i); int numa = cpu_to_node(i); - BUG_ON(numa >= MAX_NUMNODES); + BUG_ON(numa >= MAX_NUMNODES); if (numa > homa->max_numa) homa->max_numa = numa; if (homa->page_pools[numa] == NULL) { @@ -118,8 +118,8 @@ void homa_skb_cleanup(struct homa *homa) */ struct sk_buff *homa_skb_new_tx(int length) { - struct sk_buff *skb; __u64 start = get_cycles(); + struct sk_buff *skb; /* Note: allocate space for an IPv6 header, which is larger than * an IPv4 header. @@ -181,13 +181,14 @@ void homa_skb_stash_pages(struct homa *homa, int length) void *homa_skb_extend_frags(struct homa *homa, struct sk_buff *skb, int *length) { struct skb_shared_info *shinfo = skb_shinfo(skb); - struct homa_skb_core *skb_core = &per_cpu(homa_skb_core, - raw_smp_processor_id()); - skb_frag_t *frag = &shinfo->frags[shinfo->nr_frags - 1]; - char *result; + struct homa_skb_core *skb_core; int actual_size = *length; + skb_frag_t *frag; + char *result; /* Can we just extend the skb's last fragment? */ + skb_core = &per_cpu(homa_skb_core, raw_smp_processor_id()); + frag = &shinfo->frags[shinfo->nr_frags - 1]; if ((shinfo->nr_frags > 0) && (skb_frag_page(frag) == skb_core->skb_page) && (skb_core->page_inuse < skb_core->page_size) && ((frag->offset + skb_frag_size(frag)) @@ -310,8 +311,8 @@ bool homa_skb_page_alloc(struct homa *homa, struct homa_skb_core *skb_core) int homa_skb_append_to_frag(struct homa *homa, struct sk_buff *skb, void *buf, int length) { - int chunk_length; char *src = (char *) buf; + int chunk_length; char *dst; while (length > 0) { @@ -371,9 +372,9 @@ int homa_skb_append_from_iter(struct homa *homa, struct sk_buff *skb, int homa_skb_append_from_skb(struct homa *homa, struct sk_buff *dst_skb, struct sk_buff *src_skb, int offset, int length) { + int src_frag_offset, src_frags_left, chunk_size, err, head_len; struct skb_shared_info *src_shinfo = skb_shinfo(src_skb); struct skb_shared_info *dst_shinfo = skb_shinfo(dst_skb); - int src_frag_offset, src_frags_left, chunk_size, err, head_len; skb_frag_t *src_frag, *dst_frag; /* Copy bytes from the linear part of the source, if any. */ @@ -444,14 +445,15 @@ void homa_skb_free_many_tx(struct homa *homa, struct sk_buff **skbs, int count) #define MAX_PAGES_AT_ONCE 50 #endif struct page *pages_to_cache[MAX_PAGES_AT_ONCE]; - int num_pages = 0; __u64 start = get_cycles(); + int num_pages = 0; int i, j; for (i = 0; i < count; i++) { + struct skb_shared_info *shinfo; struct sk_buff *skb = skbs[i]; - struct skb_shared_info *shinfo = skb_shinfo(skb); + shinfo = skb_shinfo(skb); if (refcount_read(&skb->users) != 1) { /* This sk_buff is still in use somewhere, so can't * reclaim its pages. @@ -504,8 +506,9 @@ void homa_skb_cache_pages(struct homa *homa, struct page **pages, int count) spin_lock_bh(&homa->page_pool_mutex); for (i = 0; i < count; i++) { struct page *page = pages[i]; - struct homa_page_pool *pool = homa->page_pools[ - page_to_nid(page)]; + struct homa_page_pool *pool; + + pool = homa->page_pools[page_to_nid(page)]; if (pool->avail < LIMIT) { pool->pages[pool->avail] = page; pool->avail++; @@ -526,9 +529,9 @@ void homa_skb_cache_pages(struct homa *homa, struct page **pages, int count) */ void homa_skb_get(struct sk_buff *skb, void *dest, int offset, int length) { + int chunk_size, frags_left, frag_offset, head_len; struct skb_shared_info *shinfo = skb_shinfo(skb); char *dst = (char *) dest; - int chunk_size, frags_left, frag_offset, head_len; skb_frag_t *frag; /* Copy bytes from the linear part of the skb, if any. */ @@ -570,10 +573,10 @@ void homa_skb_get(struct sk_buff *skb, void *dest, int offset, int length) */ void homa_skb_release_pages(struct homa *homa) { - __u64 now = get_cycles(); - __s64 interval; int i, max_low_mark, min_pages, release, release_max; struct homa_page_pool *max_pool; + __u64 now = get_cycles(); + __s64 interval; if (now < homa->skb_page_free_time) return; diff --git a/homa_sock.c b/homa_sock.c index d6ce989..9cdf7b3 100644 --- a/homa_sock.c +++ b/homa_sock.c @@ -74,8 +74,8 @@ struct homa_sock *homa_socktab_start_scan(struct homa_socktab *socktab, */ struct homa_sock *homa_socktab_next(struct homa_socktab_scan *scan) { - struct homa_sock *hsk; struct homa_socktab_links *links; + struct homa_sock *hsk; while (1) { while (scan->next == NULL) { @@ -249,8 +249,8 @@ void homa_sock_destroy(struct homa_sock *hsk) int homa_sock_bind(struct homa_socktab *socktab, struct homa_sock *hsk, __u16 port) { - int result = 0; struct homa_sock *owner; + int result = 0; if (port == 0) return result; diff --git a/homa_timer.c b/homa_timer.c index 168863e..9969f53 100644 --- a/homa_timer.c +++ b/homa_timer.c @@ -19,9 +19,9 @@ */ void homa_check_rpc(struct homa_rpc *rpc) { - const char *us, *them; - struct resend_header resend; struct homa *homa = rpc->hsk->homa; + struct resend_header resend; + const char *us, *them; /* See if we need to request an ack for this RPC. */ if (!homa_is_client(rpc->id) && (rpc->state == RPC_OUTGOING) @@ -46,7 +46,7 @@ void homa_check_rpc(struct homa_rpc *rpc) if (rpc->state == RPC_INCOMING) { if ((rpc->msgin.length - rpc->msgin.bytes_remaining) - >= rpc->msgin.granted) { + >= rpc->msgin.granted) { /* We've received everything that we've granted, so we * shouldn't expect to hear anything until we grant more. */ @@ -154,18 +154,18 @@ void homa_check_rpc(struct homa_rpc *rpc) void homa_timer(struct homa *homa) { struct homa_socktab_scan scan; + static __u64 prev_grant_count; + int total_incoming_rpcs = 0; + int sum_incoming_rec = 0; struct homa_sock *hsk; + static int zero_count; struct homa_rpc *rpc; + int sum_incoming = 0; cycles_t start, end; - int rpc_count = 0; + __u64 total_grants; int total_rpcs = 0; - int total_incoming_rpcs = 0; - int sum_incoming = 0; - int sum_incoming_rec = 0; - static __u64 prev_grant_count; - static int zero_count; + int rpc_count = 0; int core; - __u64 total_grants; start = get_cycles(); homa->timer_ticks++; diff --git a/homa_utils.c b/homa_utils.c index 4da1ec7..8fc932b 100644 --- a/homa_utils.c +++ b/homa_utils.c @@ -176,10 +176,11 @@ char *homa_print_ipv4_addr(__be32 addr) #define NUM_BUFS_IPV4 4 #define BUF_SIZE_IPV4 30 static char buffers[NUM_BUFS_IPV4][BUF_SIZE_IPV4]; - static int next_buf; __u32 a2 = ntohl(addr); - char *buffer = buffers[next_buf]; + static int next_buf; + char *buffer; + buffer = buffers[next_buf]; next_buf++; if (next_buf >= NUM_BUFS_IPV4) next_buf = 0; @@ -204,8 +205,9 @@ char *homa_print_ipv6_addr(const struct in6_addr *addr) #define BUF_SIZE 64 static char buffers[NUM_BUFS][BUF_SIZE]; static int next_buf; - char *buffer = buffers[next_buf]; + char *buffer; + buffer = buffers[next_buf]; next_buf++; if (next_buf >= NUM_BUFS) next_buf = 0; @@ -245,10 +247,10 @@ char *homa_print_ipv6_addr(const struct in6_addr *addr) */ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) { - int used = 0; struct common_header *common; - struct in6_addr saddr; char header[HOMA_MAX_HEADER]; + struct in6_addr saddr; + int used = 0; if (skb == NULL) { snprintf(buffer, buf_len, "skb is NULL!"); @@ -267,8 +269,8 @@ char *homa_print_packet(struct sk_buff *skb, char *buffer, int buf_len) be64_to_cpu(common->sender_id)); switch (common->type) { case DATA: { - struct data_header *h = (struct data_header *) header; struct homa_skb_info *homa_info = homa_get_skb_info(skb); + struct data_header *h = (struct data_header *) header; int data_left, i, seg_length, pos, offset; if (skb_shinfo(skb)->gso_segs == 0) { @@ -399,8 +401,9 @@ 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) { char header[HOMA_MAX_HEADER]; - struct common_header *common = (struct common_header *) header; + struct common_header *common; + common = (struct common_header *) header; homa_skb_get(skb, header, 0, HOMA_MAX_HEADER); switch (common->type) { case DATA: { @@ -489,11 +492,11 @@ 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_peer **peers; int num_peers, i, err; - struct freeze_header freeze; struct homa_sock *hsk; - struct homa_socktab_scan scan; /* Find a socket to use (any will do). */ hsk = homa_socktab_start_scan(homa->port_map, &scan); diff --git a/test/ccutils.cc b/test/ccutils.cc index 0cdd201..55d0f00 100644 --- a/test/ccutils.cc +++ b/test/ccutils.cc @@ -160,6 +160,7 @@ void unit_log_clear(void) void unit_fill_data(unsigned char *data, int length, int first_value) { int i; + for (i = 0; i <= length-4; i += 4) { *reinterpret_cast(data + i) = first_value + i; } @@ -193,6 +194,7 @@ void unit_log_add_separator(char *sep) void unit_log_data(const char *separator, unsigned char *data, int length) { int i, range_start, expected_next; + if (length == 0) { unit_log_printf(separator, "empty block"); return; @@ -204,6 +206,7 @@ void unit_log_data(const char *separator, unsigned char *data, int length) expected_next = range_start; for (i = 0; i <= length-4; i += 4) { int current = *reinterpret_cast(data + i); + if (current != expected_next) { unit_log_printf(separator, "%d-%d", range_start, expected_next-1); @@ -247,6 +250,7 @@ const char *unit_log_get(void) void unit_log_printf(const char *separator, const char* format, ...) { va_list ap; + va_start(ap, format); if (!unit_log.empty() && (separator != NULL)) @@ -257,10 +261,12 @@ void unit_log_printf(const char *separator, const char* format, ...) int buf_size = 1024; while (true) { char buf[buf_size]; - // vsnprintf trashes the va_list, so copy it first va_list aq; + int length; + + // vsnprintf trashes the va_list, so copy it first __va_copy(aq, ap); - int length = vsnprintf(buf, buf_size, format, aq); + length = vsnprintf(buf, buf_size, format, aq); assert(length >= 0); // old glibc versions returned -1 if (length < buf_size) { unit_log.append(buf, length); diff --git a/test/main.c b/test/main.c index afe7eef..17a5e1d 100644 --- a/test/main.c +++ b/test/main.c @@ -31,8 +31,9 @@ static char * helpMessage = "double-checking.\n"; int main(int argc, char **argv) { - int i; int verbose = 0; + int i; + mock_ipv6_default = true; for (i = 1; i < argc; i++) { if ((strcmp(argv[i], "-h") == 0) || diff --git a/test/mock.c b/test/mock.c index c027f1e..bea2d82 100644 --- a/test/mock.c +++ b/test/mock.c @@ -199,6 +199,7 @@ struct sk_buff *__alloc_skb(unsigned int size, gfp_t priority, int flags, int node) { int shinfo_size; + if (mock_check_error(&mock_alloc_skb_errors)) return NULL; struct sk_buff *skb = malloc(sizeof(struct sk_buff)); @@ -241,6 +242,7 @@ void __check_object_size(const void *ptr, unsigned long n, bool to_user) {} size_t _copy_from_iter(void *addr, size_t bytes, struct iov_iter *iter) { size_t bytes_left = bytes; + if (mock_check_error(&mock_copy_data_errors)) return false; if (bytes > iter->count) { @@ -306,6 +308,7 @@ unsigned long _copy_from_user(void *to, const void __user *from, unsigned long n) { __u64 int_from = (__u64) from; + if (mock_check_error(&mock_copy_data_errors)) return 1; if (int_from > 200000) @@ -606,8 +609,9 @@ int ip6_xmit(const struct sock *sk, struct sk_buff *skb, struct flowi6 *fl6, int ip_queue_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl) { - char buffer[200]; const char *prefix = " "; + char buffer[200]; + if (mock_check_error(&mock_ip_queue_xmit_errors)) { /* Latest data (as of 1/2019) suggests that ip_queue_xmit * frees packets after errors. @@ -645,6 +649,7 @@ struct rtable *ip_route_output_flow(struct net *net, struct flowi4 *flp4, const struct sock *sk) { struct rtable *route; + if (mock_check_error(&mock_route_errors)) return ERR_PTR(-EHOSTUNREACH); route = malloc(sizeof(struct rtable)); @@ -830,6 +835,7 @@ struct proc_dir_entry *proc_create(const char *name, umode_t mode, const struct proc_ops *proc_ops) { struct proc_dir_entry *entry = malloc(40); + if (!entry) { FAIL("malloc failed"); return ERR_PTR(-ENOMEM); @@ -956,6 +962,7 @@ int skb_copy_datagram_iter(const struct sk_buff *from, int offset, struct iovec *iov = (struct iovec *) iter_iov(iter); __u64 int_base = (__u64) iov->iov_base; size_t chunk_bytes = iov->iov_len; + if (chunk_bytes > bytes_left) chunk_bytes = bytes_left; unit_log_printf("; ", @@ -998,6 +1005,7 @@ void *skb_push(struct sk_buff *skb, unsigned int len) void *skb_put(struct sk_buff *skb, unsigned int len) { unsigned char *result = skb_tail_pointer(skb); + skb->tail += len; skb->len += len; return result; @@ -1006,9 +1014,9 @@ void *skb_put(struct sk_buff *skb, unsigned int len) struct sk_buff *skb_segment(struct sk_buff *head_skb, netdev_features_t features) { + struct sk_buff *skb1, *skb2; struct data_header h; int offset, length; - struct sk_buff *skb1, *skb2; /* Split the existing packet into two packets. */ memcpy(&h, skb_transport_header(head_skb), sizeof(h)); @@ -1131,6 +1139,7 @@ int woken_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, struct page *mock_alloc_pages(gfp_t gfp, unsigned order) { struct page *page; + if (mock_check_error(&mock_alloc_page_errors)) return NULL; page = (struct page *)malloc(PAGE_SIZE << order); @@ -1172,6 +1181,7 @@ void mock_clear_xmit_prios() unsigned int mock_compound_order(struct page *page) { unsigned int result; + if (mock_compound_order_mask & 1) result = 0; else @@ -1228,6 +1238,7 @@ unsigned int mock_get_mtu(const struct dst_entry *dst) void mock_get_page(struct page *page) { int64_t ref_count = (int64_t) unit_hash_get(pages_in_use, page); + if (ref_count == 0) FAIL(" unallocated page passed to mock_get_page"); else @@ -1249,6 +1260,7 @@ int mock_page_refs(struct page *page) int mock_page_to_nid(struct page *page) { int result; + if (mock_page_nid_mask & 1) result = 1; else @@ -1260,6 +1272,7 @@ int mock_page_to_nid(struct page *page) void mock_put_page(struct page *page) { int64_t ref_count = (int64_t) unit_hash_get(pages_in_use, page); + if (ref_count == 0) FAIL(" unallocated page passed to mock_put_page"); else { @@ -1331,6 +1344,7 @@ struct sk_buff *mock_skb_new(struct in6_addr *saddr, struct common_header *h, int extra_bytes, int first_value) { int header_size, ip_size, data_size, shinfo_size; + struct sk_buff *skb; unsigned char *p; switch (h->type) { @@ -1365,7 +1379,7 @@ struct sk_buff *mock_skb_new(struct in6_addr *saddr, struct common_header *h, header_size = sizeof(struct common_header); break; } - struct sk_buff *skb = malloc(sizeof(struct sk_buff)); + skb = malloc(sizeof(struct sk_buff)); memset(skb, 0, sizeof(*skb)); if (!skbs_in_use) skbs_in_use = unit_hash_new(); @@ -1421,9 +1435,10 @@ int mock_skb_count(void) */ void mock_sock_init(struct homa_sock *hsk, struct homa *homa, int port) { + int saved_port = homa->next_client_port; static struct ipv6_pinfo hsk_pinfo; struct sock *sk = &hsk->sock; - int saved_port = homa->next_client_port; + memset(hsk, 0, sizeof(*hsk)); sk->sk_data_ready = mock_data_ready; sk->sk_family = mock_ipv6 ? AF_INET6 : AF_INET; @@ -1460,6 +1475,8 @@ void mock_spin_unlock(spinlock_t *lock) */ void mock_teardown(void) { + int count; + pcpu_hot.cpu_number = 1; cpu_khz = 1000000; mock_alloc_page_errors = 0; @@ -1498,7 +1515,7 @@ void mock_teardown(void) memset(inet_offloads, 0, sizeof(inet_offloads)); memset(inet6_offloads, 0, sizeof(inet6_offloads)); - int count = unit_hash_size(skbs_in_use); + count = unit_hash_size(skbs_in_use); if (count > 0) FAIL(" %u sk_buff(s) still in use after test", count); unit_hash_free(skbs_in_use); diff --git a/test/unit_homa_grant.c b/test/unit_homa_grant.c index f3cfee1..54c0662 100644 --- a/test/unit_homa_grant.c +++ b/test/unit_homa_grant.c @@ -105,6 +105,7 @@ static struct homa_rpc *test_rpc(FIXTURE_DATA(homa_grant) *self, struct homa_rpc *rpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, server_ip, self->server_port, id, 1000, size); + homa_message_in_init(rpc, size, 0); homa_grant_add_rpc(rpc); return rpc; @@ -215,9 +216,11 @@ TEST_F(homa_grant, homa_grant_add_rpc__insert_in_peer_list) } TEST_F(homa_grant, homa_grant_add_rpc__adjust_order_in_peer_list) { + struct homa_rpc *rpc3; + test_rpc(self, 200, self->server_ip, 20000); test_rpc(self, 300, self->server_ip, 30000); - struct homa_rpc *rpc3 = test_rpc(self, 400, self->server_ip, 40000); + rpc3 = test_rpc(self, 400, self->server_ip, 40000); test_rpc(self, 500, self->server_ip, 50000); unit_log_clear(); @@ -267,10 +270,13 @@ TEST_F(homa_grant, homa_grant_add_rpc__insert_peer_in_homa_list) } TEST_F(homa_grant, homa_grant_add_rpc__move_peer_in_homa_list) { + struct homa_rpc *rpc3; + struct homa_rpc *rpc4; + test_rpc(self, 200, self->server_ip, 20000); test_rpc(self, 300, self->server_ip+1, 30000); - struct homa_rpc *rpc3 = test_rpc(self, 400, self->server_ip+2, 40000); - struct homa_rpc *rpc4 = test_rpc(self, 500, self->server_ip+3, 50000); + rpc3 = test_rpc(self, 400, self->server_ip+2, 40000); + rpc4 = test_rpc(self, 500, self->server_ip+3, 50000); unit_log_clear(); unit_log_grantables(&self->homa); @@ -307,6 +313,7 @@ TEST_F(homa_grant, homa_grant_remove_rpc__skip_if_not_linked) struct homa_rpc *rpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 100, 1000, 2000); + unit_log_grantables(&self->homa); EXPECT_EQ(0, self->homa.num_grantable_rpcs); @@ -317,6 +324,7 @@ TEST_F(homa_grant, homa_grant_remove_rpc__clear_oldest_rpc) { struct homa_rpc *rpc1 = test_rpc(self, 200, self->server_ip, 20000); struct homa_rpc *rpc2 = test_rpc(self, 300, self->server_ip, 10000); + EXPECT_EQ(2, self->homa.num_grantable_rpcs); self->homa.oldest_rpc = rpc2; @@ -330,6 +338,7 @@ TEST_F(homa_grant, homa_grant_remove_rpc__clear_oldest_rpc) TEST_F(homa_grant, homa_grant_remove_rpc__update_metrics) { struct homa_rpc *rpc = test_rpc(self, 200, self->server_ip, 20000); + EXPECT_EQ(1, self->homa.num_grantable_rpcs); self->homa.last_grantable_change = 100; self->homa.num_grantable_rpcs = 3; @@ -342,8 +351,10 @@ TEST_F(homa_grant, homa_grant_remove_rpc__update_metrics) } TEST_F(homa_grant, homa_grant_remove_rpc__not_first_in_peer_list) { + struct homa_rpc *rpc2; + test_rpc(self, 200, self->server_ip, 20000); - struct homa_rpc *rpc2 = test_rpc(self, 300, self->server_ip, 30000); + rpc2 = test_rpc(self, 300, self->server_ip, 30000); test_rpc(self, 400, self->server_ip+1, 25000); unit_log_clear(); @@ -364,6 +375,7 @@ TEST_F(homa_grant, homa_grant_remove_rpc__not_first_in_peer_list) TEST_F(homa_grant, homa_grant_remove_rpc__only_entry_in_peer_list) { struct homa_rpc *rpc1 = test_rpc(self, 200, self->server_ip, 30000); + test_rpc(self, 300, self->server_ip+1, 40000); test_rpc(self, 400, self->server_ip+2, 20000); @@ -385,6 +397,7 @@ TEST_F(homa_grant, homa_grant_remove_rpc__only_entry_in_peer_list) TEST_F(homa_grant, homa_grant_remove_rpc__reposition_peer_in_homa_list) { struct homa_rpc *rpc1 = test_rpc(self, 200, self->server_ip, 20000); + test_rpc(self, 300, self->server_ip, 50000); test_rpc(self, 400, self->server_ip+1, 30000); test_rpc(self, 500, self->server_ip+2, 40000); @@ -410,8 +423,8 @@ TEST_F(homa_grant, homa_grant_remove_rpc__reposition_peer_in_homa_list) TEST_F(homa_grant, homa_grant_send__basics) { struct homa_rpc *rpc = test_rpc(self, 100, self->server_ip, 20000); - rpc->msgin.priority = 3; + rpc->msgin.priority = 3; unit_log_clear(); int granted = homa_grant_send(rpc, &self->homa); EXPECT_EQ(1, granted); @@ -421,6 +434,7 @@ TEST_F(homa_grant, homa_grant_send__basics) TEST_F(homa_grant, homa_grant_send__incoming_negative) { struct homa_rpc *rpc = test_rpc(self, 100, self->server_ip, 20000); + rpc->msgin.bytes_remaining = 5000; atomic_set(&self->homa.total_incoming, self->homa.max_incoming); @@ -433,8 +447,8 @@ TEST_F(homa_grant, homa_grant_send__incoming_negative) TEST_F(homa_grant, homa_grant_send__end_of_message) { struct homa_rpc *rpc = test_rpc(self, 100, self->server_ip, 20000); - rpc->msgin.bytes_remaining = 5000; + rpc->msgin.bytes_remaining = 5000; unit_log_clear(); int granted = homa_grant_send(rpc, &self->homa); EXPECT_EQ(1, granted); @@ -444,6 +458,7 @@ TEST_F(homa_grant, homa_grant_send__end_of_message) TEST_F(homa_grant, homa_grant_send__not_enough_available_bytes) { struct homa_rpc *rpc = test_rpc(self, 100, self->server_ip, 20000); + rpc->msgin.granted = 3000; rpc->msgin.rec_incoming = 4000; atomic_set(&self->homa.total_incoming, self->homa.max_incoming - 4000); @@ -457,8 +472,8 @@ TEST_F(homa_grant, homa_grant_send__not_enough_available_bytes) TEST_F(homa_grant, homa_grant_send__nothing_available) { struct homa_rpc *rpc = test_rpc(self, 100, self->server_ip, 20000); - atomic_set(&self->homa.total_incoming, self->homa.max_incoming); + atomic_set(&self->homa.total_incoming, self->homa.max_incoming); unit_log_clear(); int granted = homa_grant_send(rpc, &self->homa); EXPECT_EQ(0, granted); @@ -468,8 +483,8 @@ TEST_F(homa_grant, homa_grant_send__nothing_available) TEST_F(homa_grant, homa_grant_send__skip_because_of_silent_ticks) { struct homa_rpc *rpc = test_rpc(self, 100, self->server_ip, 20000); - rpc->silent_ticks = 2; + rpc->silent_ticks = 2; unit_log_clear(); int granted = homa_grant_send(rpc, &self->homa); EXPECT_EQ(0, granted); @@ -477,8 +492,8 @@ TEST_F(homa_grant, homa_grant_send__skip_because_of_silent_ticks) TEST_F(homa_grant, homa_grant_send__resend_all) { struct homa_rpc *rpc = test_rpc(self, 100, self->server_ip, 20000); - rpc->msgin.resend_all = 1; + rpc->msgin.resend_all = 1; unit_log_clear(); int granted = homa_grant_send(rpc, &self->homa); EXPECT_EQ(1, granted); @@ -492,6 +507,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__msgin_not_initialized) struct homa_rpc *rpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 100, 1000, 2000); + rpc->msgin.bytes_remaining = 500; rpc->msgin.granted = 2000; rpc->msgin.rec_incoming = 0; @@ -505,8 +521,8 @@ TEST_F(homa_grant, homa_grant_check_rpc__rpc_dead) struct homa_rpc *rpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 100, 1000, 2000); - homa_message_in_init(rpc, 2000, 0); + homa_message_in_init(rpc, 2000, 0); homa_rpc_lock(rpc, "test"); homa_grant_check_rpc(rpc); EXPECT_EQ(2000, rpc->msgin.rec_incoming); @@ -526,6 +542,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__message_doesnt_need_grants) struct homa_rpc *rpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 100, 1000, 2000); + homa_message_in_init(rpc, 2000, 0); rpc->msgin.granted = 2000; rpc->msgin.bytes_remaining = 500; @@ -546,6 +563,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__add_new_message_to_grantables) struct homa_rpc *rpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 100, 1000, 20000); + homa_message_in_init(rpc, 20000, 0); rpc->msgin.bytes_remaining = 12000; @@ -559,6 +577,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__add_new_message_to_grantables) TEST_F(homa_grant, homa_grant_check_rpc__new_message_bumps_existing) { struct homa_rpc *rpc1, *rpc2, *rpc3; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); self->homa.max_overcommit = 2; @@ -580,6 +599,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__new_message_bumps_existing) TEST_F(homa_grant, homa_grant_check_rpc__new_message_cant_be_granted) { struct homa_rpc *rpc1, *rpc2, *rpc3; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); self->homa.max_overcommit = 2; @@ -602,6 +622,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__new_message_cant_be_granted) TEST_F(homa_grant, homa_grant_check_rpc__upgrade_priority_from_negative_rank) { struct homa_rpc *rpc1, *rpc2, *rpc3; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); rpc3 = test_rpc(self, 104, self->server_ip, 40000); @@ -624,6 +645,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__upgrade_priority_from_negative_rank) TEST_F(homa_grant, homa_grant_check_rpc__upgrade_priority_from_positive_rank) { struct homa_rpc *rpc1, *rpc2, *rpc3; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); rpc3 = test_rpc(self, 104, self->server_ip, 40000); @@ -648,6 +670,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__upgrade_priority_from_positive_rank) TEST_F(homa_grant, homa_grant_check_rpc__send_new_grant) { struct homa_rpc *rpc; + rpc = test_rpc(self, 100, self->server_ip, 40000); homa_grant_recalc(&self->homa, 0); EXPECT_EQ(0, atomic_read(&rpc->msgin.rank)); @@ -666,6 +689,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__send_new_grant) TEST_F(homa_grant, homa_grant_check_rpc__remove_from_grantable) { struct homa_rpc *rpc; + rpc = test_rpc(self, 100, self->server_ip, 40000); homa_grant_recalc(&self->homa, 0); EXPECT_EQ(0, atomic_read(&rpc->msgin.rank)); @@ -689,6 +713,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__remove_from_grantable) TEST_F(homa_grant, homa_grant_check_rpc__recalc_because_of_headroom) { struct homa_rpc *rpc1, *rpc2; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); self->homa.max_incoming = 15000; @@ -714,6 +739,7 @@ TEST_F(homa_grant, homa_grant_check_rpc__recalc_because_of_headroom) TEST_F(homa_grant, homa_grant_recalc__basics) { struct homa_rpc *rpc1, *rpc2, *rpc3, *rpc4; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); rpc3 = test_rpc(self, 104, self->server_ip+1, 25000); @@ -756,6 +782,7 @@ TEST_F(homa_grant, homa_grant_recalc__already_locked) TEST_F(homa_grant, homa_grant_recalc__skip_recalc) { struct homa_rpc *rpc = test_rpc(self, 100, self->server_ip, 20000); + unit_hook_register(grantable_spinlock_hook); hook_homa = &self->homa; mock_trylock_errors = 0xff; @@ -770,6 +797,7 @@ TEST_F(homa_grant, homa_grant_recalc__skip_recalc) TEST_F(homa_grant, homa_grant_recalc__clear_existing_active_rpcs) { struct homa_rpc *rpc1; + rpc1 = test_rpc(self, 100, self->server_ip, 40000); test_rpc(self, 102, self->server_ip, 30000); test_rpc(self, 104, self->server_ip, 25000); @@ -788,6 +816,7 @@ TEST_F(homa_grant, homa_grant_recalc__clear_existing_active_rpcs) TEST_F(homa_grant, homa_grant_recalc__use_only_lowest_priorities) { struct homa_rpc *rpc1, *rpc2; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); self->homa.max_incoming = 100000; @@ -802,6 +831,7 @@ TEST_F(homa_grant, homa_grant_recalc__use_only_lowest_priorities) TEST_F(homa_grant, homa_grant_recalc__share_lowest_priority_level) { struct homa_rpc *rpc1, *rpc2, *rpc3, *rpc4; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); rpc3 = test_rpc(self, 100, self->server_ip, 40000); @@ -823,6 +853,7 @@ TEST_F(homa_grant, homa_grant_recalc__share_lowest_priority_level) TEST_F(homa_grant, homa_grant_recalc__compute_window_size) { struct homa_rpc *rpc1, *rpc2, *rpc3; + rpc1 = test_rpc(self, 100, self->server_ip, 30000); rpc2 = test_rpc(self, 102, self->server_ip, 40000); rpc3 = test_rpc(self, 100, self->server_ip, 50000); @@ -848,6 +879,7 @@ TEST_F(homa_grant, homa_grant_recalc__compute_window_size) TEST_F(homa_grant, homa_grant_recalc__rpc_fully_granted) { struct homa_rpc *rpc1, *rpc2, *rpc3, *rpc4; + rpc1 = test_rpc(self, 100, self->server_ip, 10000); rpc2 = test_rpc(self, 102, self->server_ip, 10000); rpc3 = test_rpc(self, 104, self->server_ip, 10000); @@ -864,6 +896,7 @@ TEST_F(homa_grant, homa_grant_recalc__rpc_fully_granted) TEST_F(homa_grant, homa_grant_recalc__rpc_fully_granted_but_skip_recalc) { struct homa_rpc *rpc1, *rpc2, *rpc3, *rpc4; + rpc1 = test_rpc(self, 100, self->server_ip, 10000); rpc2 = test_rpc(self, 102, self->server_ip, 10000); rpc3 = test_rpc(self, 104, self->server_ip, 10000); @@ -993,6 +1026,7 @@ TEST_F(homa_grant, homa_grant_find_oldest__basics) TEST_F(homa_grant, homa_grant_find_oldest__fifo_grant_unused) { struct homa_rpc *srpc1, *srpc2; + mock_cycles = ~0; srpc1 = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, 11, 400000, 100); @@ -1028,6 +1062,7 @@ TEST_F(homa_grant, homa_grant_rpc_free__rpc_not_grantable) TEST_F(homa_grant, homa_grant_free_rpc__in_active_list) { struct homa_rpc *rpc1, *rpc2, *rpc3; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); rpc3 = test_rpc(self, 104, self->server_ip, 40000); @@ -1049,6 +1084,7 @@ TEST_F(homa_grant, homa_grant_free_rpc__in_active_list) TEST_F(homa_grant, homa_grant_free_rpc__not_in_active_list) { struct homa_rpc *rpc1, *rpc2, *rpc3; + rpc1 = test_rpc(self, 100, self->server_ip, 20000); rpc2 = test_rpc(self, 102, self->server_ip, 30000); rpc3 = test_rpc(self, 104, self->server_ip, 40000); diff --git a/test/unit_homa_incoming.c b/test/unit_homa_incoming.c index 22754cd..4d0be4e 100644 --- a/test/unit_homa_incoming.c +++ b/test/unit_homa_incoming.c @@ -186,6 +186,7 @@ TEST_F(homa_incoming, homa_message_in_init__basics) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + EXPECT_EQ(0, homa_message_in_init(crpc, 127, 100)); EXPECT_EQ(100, crpc->msgin.granted); EXPECT_EQ(0, homa_message_in_init(crpc, 128, 500)); @@ -197,6 +198,7 @@ TEST_F(homa_incoming, homa_message_in_init__pool_doesnt_exist) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_pool_destroy(self->hsk.buffer_pool); EXPECT_EQ(ENOMEM, -homa_message_in_init(crpc, HOMA_BPAGE_SIZE*2, 0)); EXPECT_EQ(0, crpc->msgin.num_bpages); @@ -206,6 +208,7 @@ TEST_F(homa_incoming, homa_message_in_init__no_buffers_available) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + atomic_set(&self->hsk.buffer_pool->free_bpages, 0); EXPECT_EQ(0, homa_message_in_init(crpc, HOMA_BPAGE_SIZE*2, 10000)); EXPECT_EQ(0, crpc->msgin.num_bpages); @@ -216,6 +219,7 @@ TEST_F(homa_incoming, homa_message_in_init__update_metrics) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + EXPECT_EQ(0, homa_message_in_init(crpc, 140, 0)); EXPECT_EQ(0, homa_message_in_init(crpc, 130, 0)); EXPECT_EQ(0, homa_message_in_init(crpc, 0xfff, 0)); @@ -235,6 +239,7 @@ TEST_F(homa_incoming, homa_gap_retry) struct homa_rpc *srpc = unit_server_rpc(&self->hsk2, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, self->server_id, 10000, 100); + homa_gap_new(&srpc->msgin.gaps, 1000, 2000); homa_gap_new(&srpc->msgin.gaps, 4000, 6000); homa_gap_new(&srpc->msgin.gaps, 7000, 8000); @@ -253,6 +258,7 @@ TEST_F(homa_incoming, homa_add_packet__basics) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); mock_cycles = 5000; @@ -290,6 +296,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_overlaps_message_end) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(9000); @@ -302,6 +309,7 @@ TEST_F(homa_incoming, homa_add_packet__sequential_packets) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); homa_add_packet(crpc, mock_skb_new(self->client_ip, @@ -323,6 +331,7 @@ TEST_F(homa_incoming, homa_add_packet__new_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); homa_add_packet(crpc, mock_skb_new(self->client_ip, @@ -340,6 +349,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_before_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(0); @@ -361,6 +371,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_straddles_start_of_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(0); @@ -382,6 +393,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_extends_past_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(0); @@ -403,6 +415,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_at_start_of_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(0); @@ -426,6 +439,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_covers_entire_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(0); @@ -448,6 +462,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_beyond_end_of_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(0); @@ -469,6 +484,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_straddles_end_of_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(0); @@ -490,6 +506,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_at_end_of_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(0); @@ -512,6 +529,7 @@ TEST_F(homa_incoming, homa_add_packet__packet_in_middle_of_gap) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); mock_cycles = 1000; @@ -539,6 +557,7 @@ TEST_F(homa_incoming, homa_add_packet__scan_multiple_gaps) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(1400); @@ -562,6 +581,7 @@ TEST_F(homa_incoming, homa_add_packet__metrics) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); crpc->msgin.recv_end = 4200; self->data.seg.offset = htonl(0); @@ -760,8 +780,8 @@ TEST_F(homa_incoming, homa_copy_to_user__error_in_skb_copy_datagram_iter) TEST_F(homa_incoming, homa_copy_to_user__timetrace_info) { struct homa_rpc *crpc; - int offset; char traces[1000]; + int offset; crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->server_port, self->client_id, @@ -797,6 +817,7 @@ TEST_F(homa_incoming, homa_copy_to_user__timetrace_info) TEST_F(homa_incoming, homa_dispatch_pkts__unknown_socket_ipv4) { struct sk_buff *skb; + self->data.common.dport = htons(100); // Make sure the test uses IPv4. @@ -812,6 +833,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__unknown_socket_ipv4) TEST_F(homa_incoming, homa_dispatch_pkts__unknown_socket_ipv6) { struct sk_buff *skb; + self->data.common.dport = htons(100); // Make sure the test uses IPv6. @@ -827,6 +849,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__unknown_socket_ipv6) TEST_F(homa_incoming, homa_dispatch_pkts__unknown_socket_free_many_packets) { struct sk_buff *skb, *skb2, *skb3; + self->data.common.dport = htons(100); // Make sure the test uses IPv6. @@ -864,6 +887,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__existing_server_rpc) struct homa_rpc *srpc = unit_server_rpc(&self->hsk2, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, self->server_id, 10000, 100); + ASSERT_NE(NULL, srpc); EXPECT_EQ(8600, srpc->msgin.bytes_remaining); self->data.seg.offset = htonl(1400); @@ -874,6 +898,9 @@ TEST_F(homa_incoming, homa_dispatch_pkts__existing_server_rpc) } TEST_F(homa_incoming, homa_dispatch_pkts__non_data_packet_for_existing_server_rpc) { + 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 = { .sport = htons(self->client_port), .dport = htons(self->server_port), @@ -882,9 +909,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__non_data_packet_for_existing_server_rp .offset = 0, .length = 1000, .priority = 3}; - 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); + ASSERT_NE(NULL, srpc); unit_log_clear(); homa_dispatch_pkts(mock_skb_new(self->client_ip, &resend.common, 0, 0), @@ -896,6 +921,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__existing_client_rpc) 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); + ASSERT_NE(NULL, crpc); EXPECT_EQ(10000, crpc->msgout.granted); unit_log_clear(); @@ -917,6 +943,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__unknown_client_rpc) .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(99991), .type = UNKNOWN}}; + mock_xmit_log_verbose = 1; homa_dispatch_pkts(mock_skb_new(self->client_ip, &h.common, 0, 0), &self->homa); @@ -928,6 +955,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__unknown_server_rpc) .dport = htons(self->server_port), .sender_id = cpu_to_be64(99990), .type = GRANT}}; + mock_xmit_log_verbose = 1; homa_dispatch_pkts(mock_skb_new(self->client_ip, &h.common, 0, 0), &self->homa); @@ -935,7 +963,6 @@ TEST_F(homa_incoming, homa_dispatch_pkts__unknown_server_rpc) } TEST_F(homa_incoming, homa_dispatch_pkts__cutoffs_for_unknown_client_rpc) { - struct homa_peer *peer; struct cutoffs_header h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(99991), @@ -944,6 +971,8 @@ TEST_F(homa_incoming, homa_dispatch_pkts__cutoffs_for_unknown_client_rpc) htonl(7), htonl(6), htonl(5), htonl(4), htonl(3)}, .cutoff_version = 400}; + struct homa_peer *peer; + homa_dispatch_pkts(mock_skb_new(self->server_ip, &h.common, 0, 0), &self->homa); peer = homa_peer_find(self->homa.peers, self->server_ip, @@ -960,6 +989,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__resend_for_unknown_server_rpc) .sender_id = cpu_to_be64(99990), .type = RESEND}, .offset = 0, .length = 2000, .priority = 5}; + homa_dispatch_pkts(mock_skb_new(self->client_ip, &h.common, 0, 0), &self->homa); EXPECT_STREQ("xmit UNKNOWN", unit_log_get()); @@ -969,17 +999,17 @@ 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); - ASSERT_NE(NULL, crpc); - EXPECT_EQ(10000, crpc->msgout.granted); - unit_log_clear(); - crpc->silent_ticks = 5; - crpc->peer->outstanding_resends = 2; - struct grant_header h = {.common = {.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = GRANT}, .offset = htonl(12600), .priority = 3, .resend_all = 0}; + + ASSERT_NE(NULL, crpc); + EXPECT_EQ(10000, crpc->msgout.granted); + unit_log_clear(); + crpc->silent_ticks = 5; + crpc->peer->outstanding_resends = 2; homa_dispatch_pkts(mock_skb_new(self->server_ip, &h.common, 0, 0), &self->homa); EXPECT_EQ(0, crpc->silent_ticks); @@ -999,6 +1029,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__unknown_type) 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); + ASSERT_NE(NULL, crpc); EXPECT_EQ(10000, crpc->msgout.granted); unit_log_clear(); @@ -1014,6 +1045,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__handle_ack) struct homa_rpc *srpc = unit_server_rpc(&self->hsk2, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, self->server_id, 100, 3000); + ASSERT_NE(NULL, srpc); self->data.ack = (struct homa_ack) { .client_port = htons(self->client_port), @@ -1029,6 +1061,7 @@ TEST_F(homa_incoming, homa_dispatch_pkts__handle_ack) TEST_F(homa_incoming, homa_dispatch_pkts__too_many_acks) { struct sk_buff *skb, *skb2, *skb3; + self->data.ack = (struct homa_ack) { .client_port = htons(self->client_port), .server_port = htons(self->server_port), @@ -1061,11 +1094,13 @@ TEST_F(homa_incoming, homa_dispatch_pkts__forced_reap) struct homa_rpc *dead = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 20000); + struct homa_rpc *srpc; + homa_rpc_free(dead); EXPECT_EQ(31, self->hsk.dead_skbs); - struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, - self->client_ip, self->server_ip, self->client_port, - self->server_id, 10000, 5000); + srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->client_port, self->server_id, + 10000, 5000); ASSERT_NE(NULL, srpc); self->homa.dead_buffs_limit = 16; mock_cycles = ~0; @@ -1091,6 +1126,7 @@ TEST_F(homa_incoming, homa_data_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, 1000, 1600); + ASSERT_NE(NULL, crpc); unit_log_clear(); crpc->msgout.next_xmit_offset = crpc->msgout.length; @@ -1109,8 +1145,8 @@ TEST_F(homa_incoming, homa_data_pkt__wrong_client_rpc_state) 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, 1000, 2000); - ASSERT_NE(NULL, crpc); + ASSERT_NE(NULL, crpc); crpc->state = RPC_DEAD; self->data.message_length = htonl(2000); self->data.seg.offset = htonl(1400); @@ -1125,6 +1161,7 @@ TEST_F(homa_incoming, homa_data_pkt__initialize_msgin) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 1600); + ASSERT_NE(NULL, crpc); self->data.message_length = htonl(1600); homa_data_pkt(mock_skb_new(self->server_ip, &self->data.common, @@ -1137,6 +1174,7 @@ TEST_F(homa_incoming, homa_data_pkt__no_buffer_pool) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 1600); + ASSERT_NE(NULL, crpc); homa_pool_destroy(self->hsk.buffer_pool); unit_log_clear(); @@ -1149,6 +1187,7 @@ TEST_F(homa_incoming, homa_data_pkt__wrong_server_rpc_state) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, self->server_id, 1400, 5000); + ASSERT_NE(NULL, srpc); unit_log_clear(); homa_data_pkt(mock_skb_new(self->client_ip, &self->data.common, @@ -1161,6 +1200,7 @@ TEST_F(homa_incoming, homa_data_pkt__no_buffers) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 5000); + EXPECT_NE(NULL, crpc); unit_log_clear(); @@ -1175,6 +1215,7 @@ TEST_F(homa_incoming, homa_data_pkt__update_delta) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 5000); + EXPECT_NE(NULL, crpc); unit_log_clear(); @@ -1199,6 +1240,7 @@ TEST_F(homa_incoming, homa_data_pkt__handoff) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 3000); + ASSERT_NE(NULL, crpc); unit_log_clear(); crpc->msgout.next_xmit_offset = crpc->msgout.length; @@ -1266,10 +1308,6 @@ 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); - ASSERT_NE(NULL, srpc); - homa_xmit_data(srpc, false); - unit_log_clear(); - struct grant_header h = {{.sport = htons(srpc->dport), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->client_id), @@ -1277,6 +1315,11 @@ TEST_F(homa_incoming, homa_grant_pkt__basics) .offset = htonl(11000), .priority = 3, .resend_all = 0}; + + ASSERT_NE(NULL, srpc); + homa_xmit_data(srpc, false); + unit_log_clear(); + homa_dispatch_pkts(mock_skb_new(self->client_ip, &h.common, 0, 0), &self->homa); EXPECT_EQ(11000, srpc->msgout.granted); @@ -1307,12 +1350,6 @@ 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); - ASSERT_NE(NULL, srpc); - homa_xmit_data(srpc, false); - unit_log_clear(); - EXPECT_EQ(10000, srpc->msgout.granted); - EXPECT_EQ(10000, srpc->msgout.next_xmit_offset); - struct grant_header h = {{.sport = htons(srpc->dport), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->client_id), @@ -1320,6 +1357,13 @@ TEST_F(homa_incoming, homa_grant_pkt__reset) .offset = htonl(3000), .priority = 2, .resend_all = 1}; + + ASSERT_NE(NULL, srpc); + homa_xmit_data(srpc, false); + unit_log_clear(); + EXPECT_EQ(10000, srpc->msgout.granted); + EXPECT_EQ(10000, srpc->msgout.next_xmit_offset); + homa_dispatch_pkts(mock_skb_new(self->client_ip, &h.common, 0, 0), &self->homa); EXPECT_EQ(10000, srpc->msgout.granted); @@ -1338,15 +1382,15 @@ 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); - ASSERT_NE(NULL, crpc); - unit_log_clear(); - struct grant_header h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = GRANT}, .offset = htonl(25000), .priority = 3}; + + ASSERT_NE(NULL, crpc); + unit_log_clear(); homa_dispatch_pkts(mock_skb_new(self->client_ip, &h.common, 0, 0), &self->homa); EXPECT_EQ(20000, crpc->msgout.granted); @@ -1378,6 +1422,7 @@ TEST_F(homa_incoming, homa_resend_pkt__rpc_in_service_server_sends_busy) struct homa_rpc *srpc = unit_server_rpc(&self->hsk2, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 2000, 20000); + ASSERT_NE(NULL, srpc); unit_log_clear(); @@ -1400,6 +1445,7 @@ TEST_F(homa_incoming, homa_resend_pkt__rpc_incoming_server_sends_busy) struct homa_rpc *srpc = unit_server_rpc(&self->hsk2, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, self->server_id, 2000, 20000); + ASSERT_NE(NULL, srpc); srpc->msgin.granted = 1400; unit_log_clear(); @@ -1424,6 +1470,7 @@ TEST_F(homa_incoming, homa_resend_pkt__client_not_outgoing) 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, 2000, 3000); + ASSERT_NE(NULL, crpc); unit_log_clear(); @@ -1443,6 +1490,7 @@ TEST_F(homa_incoming, homa_resend_pkt__send_busy_instead_of_data) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 2000, 100); + ASSERT_NE(NULL, crpc); unit_log_clear(); @@ -1462,6 +1510,7 @@ TEST_F(homa_incoming, homa_resend_pkt__client_send_data) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 2000, 100); + ASSERT_NE(NULL, crpc); homa_xmit_data(crpc, false); unit_log_clear(); @@ -1484,6 +1533,7 @@ TEST_F(homa_incoming, homa_resend_pkt__server_send_data) 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); + ASSERT_NE(NULL, srpc); homa_xmit_data(srpc, false); unit_log_clear(); @@ -1505,6 +1555,7 @@ TEST_F(homa_incoming, homa_unknown_pkt__client_resend_all) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 2000, 2000); + ASSERT_NE(NULL, crpc); homa_xmit_data(crpc, false); unit_log_clear(); @@ -1530,6 +1581,7 @@ TEST_F(homa_incoming, homa_unknown_pkt__client_resend_part) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 2000, 2000); + ASSERT_NE(NULL, crpc); crpc->msgout.granted = 1400; homa_xmit_data(crpc, false); @@ -1553,6 +1605,7 @@ TEST_F(homa_incoming, homa_unknown_pkt__free_server_rpc) struct homa_rpc *srpc = unit_server_rpc(&self->hsk2, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, self->server_id, 100, 20000); + ASSERT_NE(NULL, srpc); unit_log_clear(); @@ -1566,10 +1619,6 @@ 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); - ASSERT_NE(NULL, crpc); - EXPECT_EQ(10000, crpc->msgout.granted); - unit_log_clear(); - struct cutoffs_header h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), @@ -1577,6 +1626,11 @@ TEST_F(homa_incoming, homa_cutoffs_pkt_basics) .unsched_cutoffs = {htonl(10), htonl(9), htonl(8), htonl(7), htonl(6), htonl(5), htonl(4), htonl(3)}, .cutoff_version = 400}; + + ASSERT_NE(NULL, crpc); + EXPECT_EQ(10000, crpc->msgout.granted); + unit_log_clear(); + homa_dispatch_pkts(mock_skb_new(self->server_ip, &h.common, 0, 0), &self->homa); EXPECT_EQ(400, crpc->peer->cutoff_version); @@ -1585,7 +1639,6 @@ TEST_F(homa_incoming, homa_cutoffs_pkt_basics) } TEST_F(homa_incoming, homa_cutoffs__cant_find_peer) { - struct homa_peer *peer; struct cutoffs_header h = {{.sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), @@ -1594,6 +1647,8 @@ TEST_F(homa_incoming, homa_cutoffs__cant_find_peer) htonl(7), htonl(6), htonl(5), htonl(4), htonl(3)}, .cutoff_version = 400}; struct sk_buff *skb = mock_skb_new(self->server_ip, &h.common, 0, 0); + struct homa_peer *peer; + mock_kmalloc_errors = 1; homa_cutoffs_pkt(skb, &self->hsk); EXPECT_EQ(1, homa_metrics_per_cpu()->peer_kmalloc_errors); @@ -1608,14 +1663,15 @@ 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); - ASSERT_NE(NULL, crpc); - unit_log_clear(); - mock_xmit_log_verbose = 1; struct need_ack_header h = {.common = { .sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = NEED_ACK}}; + + ASSERT_NE(NULL, crpc); + unit_log_clear(); + mock_xmit_log_verbose = 1; homa_dispatch_pkts(mock_skb_new(self->server_ip, &h.common, 0, 0), &self->homa); EXPECT_STREQ("xmit ACK from 0.0.0.0:32768, dport 99, id 1234, acks", @@ -1628,14 +1684,15 @@ 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); - ASSERT_NE(NULL, crpc); - unit_log_clear(); - mock_xmit_log_verbose = 1; struct need_ack_header h = {.common = { .sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = NEED_ACK}}; + + ASSERT_NE(NULL, crpc); + unit_log_clear(); + mock_xmit_log_verbose = 1; homa_dispatch_pkts(mock_skb_new(self->server_ip, &h.common, 0, 0), &self->homa); EXPECT_STREQ("", unit_log_get()); @@ -1647,14 +1704,15 @@ 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); - ASSERT_NE(NULL, crpc); - unit_log_clear(); - mock_xmit_log_verbose = 1; struct need_ack_header h = {.common = { .sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = NEED_ACK}}; + + ASSERT_NE(NULL, crpc); + unit_log_clear(); + mock_xmit_log_verbose = 1; homa_dispatch_pkts(mock_skb_new(self->server_ip, &h.common, 0, 0), &self->homa); EXPECT_STREQ("", unit_log_get()); @@ -1665,16 +1723,17 @@ 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); - peer->acks[0].client_port = htons(self->client_port); - peer->acks[0].server_port = htons(self->server_port); - peer->acks[0].client_id = cpu_to_be64(self->client_id+2); - peer->num_acks = 1; - mock_xmit_log_verbose = 1; struct need_ack_header h = {.common = { .sport = htons(self->server_port), .dport = htons(self->hsk.port), .sender_id = cpu_to_be64(self->server_id), .type = NEED_ACK}}; + + peer->acks[0].client_port = htons(self->client_port); + peer->acks[0].server_port = htons(self->server_port); + peer->acks[0].client_id = cpu_to_be64(self->client_id+2); + peer->num_acks = 1; + mock_xmit_log_verbose = 1; homa_dispatch_pkts(mock_skb_new(self->server_ip, &h.common, 0, 0), &self->homa); EXPECT_STREQ("xmit ACK from 0.0.0.0:32768, dport 99, id 1234, " @@ -1686,16 +1745,17 @@ 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); - ASSERT_NE(NULL, srpc); - EXPECT_EQ(1, unit_list_length(&self->hsk2.active_rpcs)); - unit_log_clear(); - mock_xmit_log_verbose = 1; struct ack_header h = {.common = { .sport = htons(self->client_port), .dport = htons(self->hsk2.port), .sender_id = cpu_to_be64(self->client_id), .type = ACK}, .num_acks = htons(0)}; + + ASSERT_NE(NULL, srpc); + EXPECT_EQ(1, unit_list_length(&self->hsk2.active_rpcs)); + unit_log_clear(); + mock_xmit_log_verbose = 1; homa_dispatch_pkts(mock_skb_new(self->client_ip, &h.common, 0, 0), &self->homa); EXPECT_EQ(0, unit_list_length(&self->hsk2.active_rpcs)); @@ -1709,17 +1769,18 @@ 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); - ASSERT_NE(NULL, srpc1); - ASSERT_NE(NULL, srpc2); - EXPECT_EQ(2, unit_list_length(&self->hsk2.active_rpcs)); - unit_log_clear(); - mock_xmit_log_verbose = 1; struct ack_header h = {.common = { .sport = htons(self->client_port + 1), .dport = htons(self->hsk2.port), .sender_id = cpu_to_be64(self->client_id), .type = ACK}, .num_acks = htons(2)}; + + ASSERT_NE(NULL, srpc1); + ASSERT_NE(NULL, srpc2); + EXPECT_EQ(2, unit_list_length(&self->hsk2.active_rpcs)); + unit_log_clear(); + mock_xmit_log_verbose = 1; h.acks[0] = (struct homa_ack) {.client_port = htons(self->client_port), .server_port = htons(self->server_port), .client_id = cpu_to_be64(self->server_id+5)}; @@ -1751,6 +1812,7 @@ TEST_F(homa_incoming, homa_rpc_abort__socket_shutdown) 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); + ASSERT_NE(NULL, crpc); unit_log_clear(); self->hsk.shutdown = 1; @@ -1771,6 +1833,7 @@ TEST_F(homa_incoming, homa_abort_rpcs__basics) struct homa_rpc *crpc3 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip+1, self->server_port, self->client_id+4, 5000, 1600); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); ASSERT_NE(NULL, crpc3); @@ -1789,6 +1852,7 @@ TEST_F(homa_incoming, homa_abort_rpcs__multiple_sockets) UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 5000, 1600); struct homa_rpc *crpc2, *crpc3; + crpc2 = unit_client_rpc(&self->hsk2, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id+2, 5000, 1600); @@ -1820,6 +1884,7 @@ TEST_F(homa_incoming, homa_abort_rpcs__select_addr) struct homa_rpc *crpc3 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip+2, self->server_port, self->client_id+4, 5000, 1600); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); ASSERT_NE(NULL, crpc3); @@ -1842,6 +1907,7 @@ TEST_F(homa_incoming, homa_abort_rpcs__select_port) struct homa_rpc *crpc3 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id+4, 5000, 1600); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); ASSERT_NE(NULL, crpc3); @@ -1866,6 +1932,7 @@ TEST_F(homa_incoming, homa_abort_rpcs__any_port) struct homa_rpc *crpc3 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id+4, 5000, 1600); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); ASSERT_NE(NULL, crpc3); @@ -1880,6 +1947,7 @@ TEST_F(homa_incoming, homa_abort_rpcs__ignore_dead_rpcs) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 5000, 1600); + ASSERT_NE(NULL, crpc); homa_rpc_free(crpc); EXPECT_EQ(RPC_DEAD, crpc->state); @@ -1892,6 +1960,7 @@ TEST_F(homa_incoming, homa_abort_rpcs__free_server_rpc) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->client_port, self->server_id, 20000, 100); + ASSERT_NE(NULL, srpc); unit_log_clear(); homa_abort_rpcs(&self->homa, self->client_ip, 0, 0); @@ -1909,6 +1978,7 @@ TEST_F(homa_incoming, homa_abort_sock_rpcs__basics) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, self->server_id, 20000, 100); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); ASSERT_NE(NULL, srpc); @@ -1937,6 +2007,7 @@ TEST_F(homa_incoming, homa_abort_sock_rpcs__rpc_already_dead) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 5000, 1600); + ASSERT_NE(NULL, crpc); homa_rpc_free(crpc); EXPECT_EQ(RPC_DEAD, crpc->state); @@ -1952,6 +2023,7 @@ TEST_F(homa_incoming, homa_abort_sock_rpcs__free_rpcs) struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port+1, self->client_id+2, 5000, 1600); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); unit_log_clear(); @@ -1964,6 +2036,7 @@ TEST_F(homa_incoming, homa_abort_sock_rpcs__free_rpcs) TEST_F(homa_incoming, homa_register_interests__id_not_for_client_rpc) { int result; + result = homa_register_interests(&self->interest, &self->hsk, HOMA_RECVMSG_RESPONSE, 45); EXPECT_EQ(EINVAL, -result); @@ -1971,16 +2044,18 @@ TEST_F(homa_incoming, homa_register_interests__id_not_for_client_rpc) TEST_F(homa_incoming, homa_register_interests__no_rpc_for_id) { int result; + result = homa_register_interests(&self->interest, &self->hsk, HOMA_RECVMSG_RESPONSE, 44); EXPECT_EQ(EINVAL, -result); } TEST_F(homa_incoming, homa_register_interests__id_already_has_interest) { - struct homa_interest interest; struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); + struct homa_interest interest; + ASSERT_NE(NULL, crpc); crpc->interest = &interest; @@ -1994,9 +2069,11 @@ TEST_F(homa_incoming, homa_register_interests__return_response_by_id) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); + int result; + ASSERT_NE(NULL, crpc); - int result = homa_register_interests(&self->interest, &self->hsk, + result = homa_register_interests(&self->interest, &self->hsk, 0, self->client_id); EXPECT_EQ(0, result); EXPECT_EQ(crpc, (struct homa_rpc *) @@ -2006,6 +2083,7 @@ TEST_F(homa_incoming, homa_register_interests__return_response_by_id) TEST_F(homa_incoming, homa_register_interests__socket_shutdown) { int result; + self->hsk.shutdown = 1; result = homa_register_interests(&self->interest, &self->hsk, HOMA_RECVMSG_RESPONSE, 0); @@ -2017,9 +2095,10 @@ TEST_F(homa_incoming, homa_register_interests__specified_id_has_packets) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); - ASSERT_NE(NULL, crpc); + int result; - int result = homa_register_interests(&self->interest, &self->hsk, + ASSERT_NE(NULL, crpc); + result = homa_register_interests(&self->interest, &self->hsk, HOMA_RECVMSG_REQUEST, crpc->id); EXPECT_EQ(0, result); EXPECT_EQ(crpc, (struct homa_rpc *) @@ -2031,10 +2110,12 @@ TEST_F(homa_incoming, homa_register_interests__specified_id_has_error) 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); + int result; + ASSERT_NE(NULL, crpc); crpc->error = -EFAULT; - int result = homa_register_interests(&self->interest, &self->hsk, + result = homa_register_interests(&self->interest, &self->hsk, HOMA_RECVMSG_REQUEST|HOMA_RECVMSG_NONBLOCKING, crpc->id); EXPECT_EQ(0, result); EXPECT_EQ(crpc, (struct homa_rpc *) @@ -2046,9 +2127,10 @@ TEST_F(homa_incoming, homa_register_interests__specified_id_not_ready) 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); - ASSERT_NE(NULL, crpc); + int result; - int result = homa_register_interests(&self->interest, &self->hsk, + ASSERT_NE(NULL, crpc); + result = homa_register_interests(&self->interest, &self->hsk, HOMA_RECVMSG_REQUEST, crpc->id); EXPECT_EQ(0, result); EXPECT_EQ(NULL, (struct homa_rpc *) @@ -2059,9 +2141,10 @@ TEST_F(homa_incoming, homa_register_interests__return_queued_response) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); - ASSERT_NE(NULL, crpc); + int result; - int result = homa_register_interests(&self->interest, &self->hsk, + ASSERT_NE(NULL, crpc); + result = homa_register_interests(&self->interest, &self->hsk, HOMA_RECVMSG_REQUEST|HOMA_RECVMSG_RESPONSE, 0); EXPECT_EQ(0, result); EXPECT_EQ(crpc, (struct homa_rpc *) @@ -2075,9 +2158,10 @@ TEST_F(homa_incoming, homa_register_interests__return_queued_request) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->client_port, 1, 20000, 100); - ASSERT_NE(NULL, srpc); + int result; - int result = homa_register_interests(&self->interest, &self->hsk, + ASSERT_NE(NULL, srpc); + result = homa_register_interests(&self->interest, &self->hsk, HOMA_RECVMSG_REQUEST|HOMA_RECVMSG_RESPONSE, 0); EXPECT_EQ(0, result); EXPECT_EQ(srpc, (struct homa_rpc *) @@ -2094,10 +2178,11 @@ TEST_F(homa_incoming, homa_register_interests__call_sk_data_ready) struct homa_rpc *srpc2 = unit_server_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->client_port, self->server_id+2, 20000, 100); + int result; // First time should call sk_data_ready (for 2nd RPC). unit_log_clear(); - int result = homa_register_interests(&self->interest, &self->hsk, + result = homa_register_interests(&self->interest, &self->hsk, HOMA_RECVMSG_REQUEST|HOMA_RECVMSG_RESPONSE, 0); EXPECT_EQ(0, result); EXPECT_EQ(srpc1, (struct homa_rpc *) @@ -2122,9 +2207,10 @@ TEST_F(homa_incoming, homa_wait_for_message__rpc_from_register_interests) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); - ASSERT_NE(NULL, crpc); + struct homa_rpc *rpc; - struct homa_rpc *rpc = homa_wait_for_message(&self->hsk, + ASSERT_NE(NULL, crpc); + rpc = homa_wait_for_message(&self->hsk, HOMA_RECVMSG_RESPONSE|HOMA_RECVMSG_NONBLOCKING, self->client_id); EXPECT_EQ(crpc, rpc); @@ -2135,10 +2221,11 @@ TEST_F(homa_incoming, homa_wait_for_message__error_from_register_interests) 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, 20000, 1600); - ASSERT_NE(NULL, crpc); + struct homa_rpc *rpc; + ASSERT_NE(NULL, crpc); self->hsk.shutdown = 1; - struct homa_rpc *rpc = homa_wait_for_message(&self->hsk, + rpc = homa_wait_for_message(&self->hsk, HOMA_RECVMSG_RESPONSE|HOMA_RECVMSG_NONBLOCKING, self->client_id); EXPECT_EQ(ESHUTDOWN, -PTR_ERR(rpc)); @@ -2146,12 +2233,12 @@ TEST_F(homa_incoming, homa_wait_for_message__error_from_register_interests) } TEST_F(homa_incoming, homa_wait_for_message__rpc_arrives_while_polling) { - struct homa_rpc *rpc; struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); - ASSERT_NE(NULL, crpc1); + struct homa_rpc *rpc; + ASSERT_NE(NULL, crpc1); hook_rpc = crpc1; poll_count = 5; self->homa.poll_cycles = 1000000; @@ -2166,10 +2253,11 @@ TEST_F(homa_incoming, homa_wait_for_message__rpc_arrives_while_polling) } TEST_F(homa_incoming, homa_wait_for_message__nothing_ready_nonblocking) { - struct homa_rpc *rpc; struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); + struct homa_rpc *rpc; + unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id+2, 20000, 1600); ASSERT_NE(NULL, crpc1); @@ -2180,10 +2268,11 @@ TEST_F(homa_incoming, homa_wait_for_message__nothing_ready_nonblocking) } TEST_F(homa_incoming, homa_wait_for_message__rpc_arrives_while_sleeping) { - struct homa_rpc *rpc; struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); + struct homa_rpc *rpc; + ASSERT_NE(NULL, crpc1); /* Also, check to see that reaping occurs before sleeping. */ @@ -2208,10 +2297,11 @@ TEST_F(homa_incoming, homa_wait_for_message__rpc_arrives_while_sleeping) } TEST_F(homa_incoming, homa_wait_for_message__rpc_arrives_after_giving_up) { - struct homa_rpc *rpc; 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 homa_rpc *rpc; + ASSERT_NE(NULL, crpc); hook_rpc = crpc; @@ -2228,10 +2318,11 @@ TEST_F(homa_incoming, homa_wait_for_message__handoff_rpc_then_delete_after_givin { // A key thing this test does it to ensure that RPC_HANDING_OFF // gets cleared even though the RPC has been deleted. - struct homa_rpc *rpc; 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 homa_rpc *rpc; + ASSERT_NE(NULL, crpc); // Prevent the RPC from being reaped during the test. @@ -2250,13 +2341,13 @@ TEST_F(homa_incoming, homa_wait_for_message__handoff_rpc_then_delete_after_givin } TEST_F(homa_incoming, homa_wait_for_message__explicit_rpc_deleted_while_sleeping) { - struct homa_rpc *rpc; 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 homa_rpc *rpc; + ASSERT_NE(NULL, crpc); unit_log_clear(); - hook_rpc = crpc; unit_hook_register(delete_hook); rpc = homa_wait_for_message(&self->hsk, HOMA_RECVMSG_RESPONSE, @@ -2265,13 +2356,13 @@ TEST_F(homa_incoming, homa_wait_for_message__explicit_rpc_deleted_while_sleeping } TEST_F(homa_incoming, homa_wait_for_message__socket_shutdown_while_sleeping) { - struct homa_rpc *rpc; 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 homa_rpc *rpc; + ASSERT_NE(NULL, crpc); unit_log_clear(); - hook_hsk = &self->hsk; unit_hook_register(shutdown_hook); rpc = homa_wait_for_message(&self->hsk, @@ -2280,14 +2371,14 @@ TEST_F(homa_incoming, homa_wait_for_message__socket_shutdown_while_sleeping) } TEST_F(homa_incoming, homa_wait_for_message__copy_to_user) { - struct homa_rpc *rpc; 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, 20000, 1600); + struct homa_rpc *rpc; + ASSERT_NE(NULL, crpc); mock_copy_to_user_dont_copy = -1; unit_log_clear(); - hook_hsk = &self->hsk; rpc = homa_wait_for_message(&self->hsk, HOMA_RECVMSG_RESPONSE|HOMA_RECVMSG_NONBLOCKING, 0); @@ -2300,14 +2391,15 @@ TEST_F(homa_incoming, homa_wait_for_message__rpc_freed_after_matching) /* Arrange for 2 RPCs to be ready, but delete the first one after * it has matched; this should cause the second one to be matched. */ - struct homa_rpc *rpc; struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 1600); - ASSERT_NE(NULL, crpc1); struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id+2, 20000, 1600); + struct homa_rpc *rpc; + + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); unit_log_clear(); @@ -2321,10 +2413,11 @@ TEST_F(homa_incoming, homa_wait_for_message__rpc_freed_after_matching) } TEST_F(homa_incoming, homa_wait_for_message__copy_to_user_fails) { - struct homa_rpc *rpc; 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, 20000, 1600); + struct homa_rpc *rpc; + ASSERT_NE(NULL, crpc); unit_log_clear(); mock_copy_data_errors = 1; @@ -2340,10 +2433,11 @@ TEST_F(homa_incoming, homa_wait_for_message__copy_to_user_fails) } TEST_F(homa_incoming, homa_wait_for_message__message_complete) { - struct homa_rpc *rpc; struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 20000, 2000); + struct homa_rpc *rpc; + ASSERT_NE(NULL, crpc); mock_copy_to_user_dont_copy = -1; unit_log_clear(); @@ -2371,11 +2465,13 @@ TEST_F(homa_incoming, homa_choose_interest__empty_list) struct homa_interest *result = homa_choose_interest(&self->homa, &self->hsk.request_interests, offsetof(struct homa_interest, request_links)); + EXPECT_EQ(NULL, result); } TEST_F(homa_incoming, homa_choose_interest__find_idle_core) { struct homa_interest interest1, interest2, interest3; + homa_interest_init(&interest1); interest1.core = 1; list_add_tail(&interest1.request_links, &self->hsk.request_interests); @@ -2402,6 +2498,7 @@ TEST_F(homa_incoming, homa_choose_interest__find_idle_core) TEST_F(homa_incoming, homa_choose_interest__all_cores_busy) { struct homa_interest interest1, interest2, interest3; + homa_interest_init(&interest1); interest1.core = 1; list_add_tail(&interest1.request_links, &self->hsk.request_interests); @@ -2428,10 +2525,11 @@ TEST_F(homa_incoming, homa_choose_interest__all_cores_busy) TEST_F(homa_incoming, homa_rpc_handoff__handoff_already_in_progress) { - struct homa_interest interest; 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 homa_interest interest; + ASSERT_NE(NULL, crpc); EXPECT_EQ(NULL, crpc->interest); unit_log_clear(); @@ -2450,10 +2548,11 @@ TEST_F(homa_incoming, homa_rpc_handoff__handoff_already_in_progress) } TEST_F(homa_incoming, homa_rpc_handoff__rpc_already_enqueued) { - struct homa_interest interest; 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 homa_interest interest; + ASSERT_NE(NULL, crpc); EXPECT_EQ(NULL, crpc->interest); unit_log_clear(); @@ -2479,10 +2578,11 @@ TEST_F(homa_incoming, homa_rpc_handoff__rpc_already_enqueued) } TEST_F(homa_incoming, homa_rpc_handoff__interest_on_rpc) { - struct homa_interest interest; 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 homa_interest interest; + ASSERT_NE(NULL, crpc); EXPECT_EQ(NULL, crpc->interest); unit_log_clear(); @@ -2502,10 +2602,11 @@ TEST_F(homa_incoming, homa_rpc_handoff__interest_on_rpc) } TEST_F(homa_incoming, homa_rpc_handoff__response_interests) { - struct homa_interest interest; 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 homa_interest interest; + ASSERT_NE(NULL, crpc); EXPECT_EQ(NULL, crpc->interest); unit_log_clear(); @@ -2525,22 +2626,22 @@ TEST_F(homa_incoming, homa_rpc_handoff__queue_on_ready_responses) 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); + ASSERT_NE(NULL, crpc); unit_log_clear(); - homa_rpc_handoff(crpc); EXPECT_STREQ("sk->sk_data_ready invoked", unit_log_get()); EXPECT_EQ(1, unit_list_length(&self->hsk.ready_responses)); } TEST_F(homa_incoming, homa_rpc_handoff__request_interests) { - struct homa_interest interest; struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, self->server_id, 20000, 100); + struct homa_interest interest; + ASSERT_NE(NULL, srpc); unit_log_clear(); - homa_interest_init(&interest); interest.thread = &mock_task; list_add_tail(&interest.request_links, &self->hsk.request_interests); @@ -2556,6 +2657,7 @@ TEST_F(homa_incoming, homa_rpc_handoff__queue_on_ready_requests) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, 1, 20000, 100); + ASSERT_NE(NULL, srpc); unit_log_clear(); @@ -2565,10 +2667,11 @@ TEST_F(homa_incoming, homa_rpc_handoff__queue_on_ready_requests) } TEST_F(homa_incoming, homa_rpc_handoff__detach_interest) { - struct homa_interest interest; 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 homa_interest interest; + ASSERT_NE(NULL, crpc); EXPECT_EQ(NULL, crpc->interest); unit_log_clear(); @@ -2594,10 +2697,11 @@ TEST_F(homa_incoming, homa_rpc_handoff__detach_interest) } TEST_F(homa_incoming, homa_rpc_handoff__update_last_app_active) { - struct homa_interest interest; 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 homa_interest interest; + ASSERT_NE(NULL, crpc); EXPECT_EQ(NULL, crpc->interest); unit_log_clear(); diff --git a/test/unit_homa_metrics.c b/test/unit_homa_metrics.c index dc5d504..4bcb73c 100644 --- a/test/unit_homa_metrics.c +++ b/test/unit_homa_metrics.c @@ -55,8 +55,9 @@ TEST_F(homa_metrics, homa_metrics_open) } TEST_F(homa_metrics, homa_metrics_read__basics) { - char buffer[1000]; loff_t offset = 10; + char buffer[1000]; + self->homa.metrics = kmalloc(100, GFP_KERNEL); self->homa.metrics_capacity = 100; strcpy(self->homa.metrics, "0123456789abcdefghijklmnop"); @@ -77,8 +78,9 @@ TEST_F(homa_metrics, homa_metrics_read__basics) } TEST_F(homa_metrics, homa_metrics_read__error_copying_to_user) { - char buffer[1000]; loff_t offset = 10; + char buffer[1000]; + self->homa.metrics = kmalloc(100, GFP_KERNEL); self->homa.metrics_capacity = 100; strcpy(self->homa.metrics, "0123456789abcdefghijklmnop"); diff --git a/test/unit_homa_offload.c b/test/unit_homa_offload.c index 9691bed..523ac1e 100644 --- a/test/unit_homa_offload.c +++ b/test/unit_homa_offload.c @@ -43,6 +43,7 @@ static struct sk_buff *tcp6_gro_receive(struct list_head *held_list, FIXTURE_SETUP(homa_offload) { int i; + homa_init(&self->homa); self->homa.flags |= HOMA_FLAG_DONT_THROTTLE; homa = &self->homa; @@ -133,8 +134,9 @@ TEST_F(homa_offload, homa_gro_hook_tcp) TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_tcp) { - struct sk_buff *skb; struct common_header *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); @@ -155,8 +157,9 @@ TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_tcp) } TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_homa_ipv6) { - struct sk_buff *skb; struct common_header *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); @@ -176,8 +179,9 @@ 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 sk_buff *skb; struct common_header *h; + struct sk_buff *skb; + mock_ipv6 = false; homa_gro_hook_tcp(); self->header.seg.offset = htonl(6000); @@ -200,9 +204,10 @@ TEST_F(homa_offload, homa_tcp_gro_receive__pass_to_homa_ipv4) TEST_F(homa_offload, homa_gso_segment_set_ip_ids) { + struct sk_buff *skb; mock_ipv6 = false; - struct sk_buff *skb = mock_skb_new(&self->ip, &self->header.common, - 1400, 2000); + + skb = mock_skb_new(&self->ip, &self->header.common, 1400, 2000); int version = ip_hdr(skb)->version; EXPECT_EQ(4, version); struct sk_buff *segs = homa_gso_segment(skb, 0); @@ -248,22 +253,28 @@ TEST_F(homa_offload, homa_gro_receive__HOMA_GRO_SHORT_BYPASS) { 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, *skb4; int client_port = 40000; - int server_port = 99; __u64 client_id = 1234; __u64 server_id = 1235; - struct data_header h = {.common = { - .sport = htons(40000), .dport = htons(server_port), - .type = DATA, - .sender_id = cpu_to_be64(client_id)}, - .message_length = htonl(10000), - .incoming = htonl(10000), .cutoff_version = 0, - .ack = {0, 0, 0}, - .retransmit = 0, - .seg = {.offset = htonl(2000)}}; - struct sk_buff *skb, *skb2, *skb3, *skb4; - - struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, + struct homa_rpc *srpc; + int server_port = 99; + struct data_header h; + + h.common.sport = htons(40000); + h.common.dport = htons(server_port); + h.common.type = DATA; + h.common.sender_id = cpu_to_be64(client_id); + h.message_length = htonl(10000); + h.incoming = htonl(10000); + h.cutoff_version = 0; + h.ack.client_id = 0; + h.ack.client_port= 0; + h.ack.server_port = 0; + h.retransmit = 0; + h.seg.offset = htonl(2000); + + srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &client_ip, &server_ip, client_port, server_id, 10000, 200); ASSERT_NE(NULL, srpc); @@ -312,20 +323,23 @@ TEST_F(homa_offload, homa_gro_receive__fast_grant_optimization) int client_port = 40000; __u64 client_id = 1234; __u64 server_id = 1235; - struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, + 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, 20000); ASSERT_NE(NULL, srpc); homa_xmit_data(srpc, false); unit_log_clear(); - struct grant_header h = {{.sport = htons(srpc->dport), - .dport = htons(self->hsk.port), - .sender_id = cpu_to_be64(client_id), - .type = GRANT}, - .offset = htonl(11000), - .priority = 3, - .resend_all = 0}; + h.common.sport = htons(srpc->dport); + h.common.dport = htons(self->hsk.port); + h.common.sender_id = cpu_to_be64(client_id); + h.common.type = GRANT; + h.offset = htonl(11000); + h.priority = 3; + h.resend_all = 0; /* First attempt: HOMA_GRO_FAST_GRANTS not enabled. */ self->homa.gro_policy = 0; @@ -357,6 +371,7 @@ TEST_F(homa_offload, homa_gro_receive__no_held_skb) { struct sk_buff *skb; int same_flow; + self->header.seg.offset = htonl(6000); skb = mock_skb_new(&self->ip, &self->header.common, 1400, 0); skb->hash = 2; @@ -374,6 +389,7 @@ TEST_F(homa_offload, homa_gro_receive__empty_merge_list) { struct sk_buff *skb; int same_flow; + self->header.seg.offset = htonl(6000); skb = mock_skb_new(&self->ip, &self->header.common, 1400, 0); skb->hash = 2; @@ -391,6 +407,7 @@ TEST_F(homa_offload, homa_gro_receive__held_skb_not_in_merge_list) { struct sk_buff *skb; int same_flow; + self->header.seg.offset = htonl(6000); skb = mock_skb_new(&self->ip, &self->header.common, 1400, 0); skb->hash = 3; @@ -408,6 +425,7 @@ TEST_F(homa_offload, homa_gro_receive__held_skb__in_merge_list_but_wrong_proto) { struct sk_buff *skb; int same_flow; + self->header.seg.offset = htonl(6000); skb = mock_skb_new(&self->ip, &self->header.common, 1400, 0); skb->hash = 3; @@ -429,6 +447,7 @@ TEST_F(homa_offload, homa_gro_receive__merge) { struct sk_buff *skb, *skb2; int same_flow; + cur_offload_core->held_skb = self->skb2; cur_offload_core->held_bucket = 2; diff --git a/test/unit_homa_outgoing.c b/test/unit_homa_outgoing.c index 1867828..1bf6af8 100644 --- a/test/unit_homa_outgoing.c +++ b/test/unit_homa_outgoing.c @@ -93,6 +93,7 @@ TEST_F(homa_outgoing, homa_fill_data_interleaved) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + homa_rpc_unlock(crpc); struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); homa_message_out_init(crpc, 10000); @@ -118,32 +119,34 @@ TEST_F(homa_outgoing, homa_fill_data_interleaved) TEST_F(homa_outgoing, homa_fill_data_interleaved__error_copying_data) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, - &self->server_addr); - homa_rpc_unlock(crpc); + &self->server_addr); struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); + struct sk_buff *skb; + + homa_rpc_unlock(crpc); homa_message_out_init(crpc, 10000); unit_log_clear(); mock_copy_data_errors = 1; - struct sk_buff *skb = homa_new_data_packet(crpc, iter, 10000, 5000, - 1500); + skb = homa_new_data_packet(crpc, iter, 10000, 5000, 1500); EXPECT_EQ(EFAULT, -PTR_ERR(skb)); } TEST_F(homa_outgoing, homa_new_data_packet__one_segment) { + struct iov_iter *iter = unit_iov_iter((void *) 1000, 5000); struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + struct sk_buff *skb; + char buffer[1000]; + homa_rpc_unlock(crpc); - struct iov_iter *iter = unit_iov_iter((void *) 1000, 5000); homa_message_out_init(crpc, 500); unit_log_clear(); - struct sk_buff *skb = homa_new_data_packet(crpc, iter, 5000, 500, - 2000); + skb = homa_new_data_packet(crpc, iter, 5000, 500, 2000); EXPECT_STREQ("_copy_from_iter 500 bytes at 1000", unit_log_get()); - char buffer[1000]; EXPECT_STREQ("DATA from 0.0.0.0:40000, dport 99, id 2, " "message_length 500, offset 5000, data_length 500, " "incoming 500", @@ -154,29 +157,32 @@ TEST_F(homa_outgoing, homa_new_data_packet__one_segment) } TEST_F(homa_outgoing, homa_new_data_packet__cant_allocate_skb) { + struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + struct sk_buff *skb; + homa_rpc_unlock(crpc); - struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); homa_message_out_init(crpc, 500); unit_log_clear(); mock_alloc_skb_errors = 1; - struct sk_buff *skb = homa_new_data_packet(crpc, iter, 0, 500, 2000); + skb = homa_new_data_packet(crpc, iter, 0, 500, 2000); EXPECT_TRUE(IS_ERR(skb)); EXPECT_EQ(ENOMEM, -PTR_ERR(skb)); } TEST_F(homa_outgoing, homa_new_data_packet__multiple_segments_homa_fill_data_interleaved) { + struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + struct sk_buff *skb; + homa_rpc_unlock(crpc); - struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); homa_message_out_init(crpc, 10000); unit_log_clear(); - struct sk_buff *skb = homa_new_data_packet(crpc, iter, 10000, 5000, - 1500); + skb = homa_new_data_packet(crpc, iter, 10000, 5000, 1500); EXPECT_STREQ("_copy_from_iter 1500 bytes at 1000; " "_copy_from_iter 1500 bytes at 2500; " "_copy_from_iter 1500 bytes at 4000; " @@ -197,10 +203,11 @@ TEST_F(homa_outgoing, homa_new_data_packet__multiple_segments_homa_fill_data_int } TEST_F(homa_outgoing, homa_new_data_packet__error_in_homa_fill_data_interleaved) { + struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, - &self->server_addr); + &self->server_addr); + homa_rpc_unlock(crpc); - struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); homa_message_out_init(crpc, 10000); unit_log_clear(); @@ -212,20 +219,22 @@ TEST_F(homa_outgoing, homa_new_data_packet__error_in_homa_fill_data_interleaved) } TEST_F(homa_outgoing, homa_new_data_packet__multiple_segments_tcp_hijacking) { - self->homa.hijack_tcp = 1; + struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); + struct homa_rpc *crpc; struct homa_sock hsk; + struct sk_buff *skb; + char buffer[1000]; + + self->homa.hijack_tcp = 1; mock_sock_init(&hsk, &self->homa, self->client_port+1); - struct homa_rpc *crpc = homa_rpc_new_client(&hsk, &self->server_addr); + crpc = homa_rpc_new_client(&hsk, &self->server_addr); homa_rpc_unlock(crpc); - struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); homa_message_out_init(crpc, 10000); unit_log_clear(); - struct sk_buff *skb = homa_new_data_packet(crpc, iter, 10000, 5000, - 1500); + skb = homa_new_data_packet(crpc, iter, 10000, 5000, 1500); EXPECT_STREQ("_copy_from_iter 5000 bytes at 1000", unit_log_get()); - char buffer[1000]; EXPECT_STREQ("DATA from 0.0.0.0:40001, dport 99, id 2, " "message_length 10000, offset 10000, data_length 1500, " "incoming 10000, extra segs 1500@11500 1500@13000 " @@ -236,30 +245,32 @@ TEST_F(homa_outgoing, homa_new_data_packet__multiple_segments_tcp_hijacking) } TEST_F(homa_outgoing, homa_new_data_packet__error_copying_data_hijacking_path) { + struct iov_iter *iter = unit_iov_iter((void *) 1000, 5000); struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + struct sk_buff *skb; + homa_rpc_unlock(crpc); - struct iov_iter *iter = unit_iov_iter((void *) 1000, 5000); homa_message_out_init(crpc, 500); unit_log_clear(); mock_copy_data_errors = 1; - struct sk_buff *skb = homa_new_data_packet(crpc, iter, 5000, 500, - 2000); + skb = homa_new_data_packet(crpc, iter, 5000, 500, 2000); EXPECT_TRUE(IS_ERR(skb)); EXPECT_EQ(EFAULT, -PTR_ERR(skb)); } TEST_F(homa_outgoing, homa_new_data_packet__gso_information) { + struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, - &self->server_addr); + &self->server_addr); + struct sk_buff *skb; + homa_rpc_unlock(crpc); - struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); homa_message_out_init(crpc, 10000); unit_log_clear(); - struct sk_buff *skb = homa_new_data_packet(crpc, iter, 10000, 5000, - 1500); + 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), @@ -269,16 +280,17 @@ TEST_F(homa_outgoing, homa_new_data_packet__gso_information) } TEST_F(homa_outgoing, homa_new_data_packet__gso_force_software) { + struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, - &self->server_addr); + &self->server_addr); + struct sk_buff *skb; + homa_rpc_unlock(crpc); - struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); homa_message_out_init(crpc, 10000); self->homa.gso_force_software = 1; unit_log_clear(); - struct sk_buff *skb = homa_new_data_packet(crpc, iter, 10000, 5000, - 1500); + skb = homa_new_data_packet(crpc, iter, 10000, 5000, 1500); EXPECT_EQ(13, skb_shinfo(skb)->gso_type); kfree_skb(skb); } @@ -287,6 +299,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__basics) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + ASSERT_FALSE(crpc == NULL); ASSERT_EQ(0, -homa_message_out_fill(crpc, unit_iov_iter((void *) 1000, 3000), 0)); @@ -316,6 +329,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__message_too_long) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + ASSERT_FALSE(crpc == NULL); EXPECT_EQ(EINVAL, -homa_message_out_fill(crpc, unit_iov_iter((void *) 1000, HOMA_MAX_MESSAGE_LENGTH+1), @@ -326,6 +340,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__zero_length_message) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + ASSERT_FALSE(crpc == NULL); EXPECT_EQ(EINVAL, -homa_message_out_fill(crpc, unit_iov_iter((void *) 1000, 0), 0)); @@ -335,6 +350,8 @@ TEST_F(homa_outgoing, homa_message_out_fill__gso_force_software) { struct homa_rpc *crpc1 = homa_rpc_new_client(&self->hsk, &self->server_addr); + struct homa_rpc *crpc2; + ASSERT_FALSE(crpc1 == NULL); homa_rpc_unlock(crpc1); mock_net_device.gso_max_size = 10000; @@ -347,8 +364,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__gso_force_software) EXPECT_SUBSTR("xmit DATA", unit_log_get()); EXPECT_NOSUBSTR("TSO disabled", unit_log_get()); - struct homa_rpc *crpc2 = homa_rpc_new_client(&self->hsk, - &self->server_addr); + crpc2 = homa_rpc_new_client(&self->hsk, &self->server_addr); ASSERT_FALSE(crpc2 == NULL); homa_rpc_unlock(crpc2); self->homa.gso_force_software = 1; @@ -362,6 +378,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__gso_limit_less_than_mtu) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + ASSERT_FALSE(crpc == NULL); unit_log_clear(); mock_net_device.gso_max_size = 10000; @@ -375,6 +392,8 @@ 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; + ASSERT_FALSE(crpc == NULL); crpc->peer->acks[0] = (struct homa_ack) { .client_port = htons(100), @@ -384,7 +403,6 @@ TEST_F(homa_outgoing, homa_message_out_fill__include_acks) ASSERT_EQ(0, -homa_message_out_fill(crpc, unit_iov_iter((void *) 1000, 500), 0)); homa_rpc_unlock(crpc); - struct data_header h; homa_skb_get(crpc->msgout.packets, &h, 0, sizeof(h)); EXPECT_STREQ("client_port 100, server_port 200, client_id 1000", unit_ack_string(&h.ack)); @@ -393,6 +411,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__multiple_segs_per_skbuff) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + ASSERT_FALSE(crpc == NULL); mock_net_device.gso_max_size = 5000; unit_log_clear(); @@ -420,6 +439,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__rpc_freed_during_copy) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + ASSERT_FALSE(crpc == NULL); unit_hook_register(unlock_hook); hook_rpc = crpc; @@ -433,6 +453,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__add_to_throttled) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + ASSERT_FALSE(crpc == NULL); ASSERT_EQ(0, -homa_message_out_fill(crpc, unit_iov_iter((void *) 1000, 5000), 1)); @@ -451,6 +472,7 @@ TEST_F(homa_outgoing, homa_message_out_fill__too_short_for_pipelining) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + ASSERT_FALSE(crpc == NULL); ASSERT_EQ(0, -homa_message_out_fill(crpc, unit_iov_iter((void *) 1000, 1000), 1)); @@ -591,7 +613,6 @@ TEST_F(homa_outgoing, __homa_xmit_control__ipv6_error) TEST_F(homa_outgoing, homa_xmit_unknown) { - struct sk_buff *skb; struct grant_header h = {{.sport = htons(self->client_port), .dport = htons(self->server_port), .sender_id = cpu_to_be64(99990), @@ -599,6 +620,8 @@ TEST_F(homa_outgoing, homa_xmit_unknown) .offset = htonl(11200), .priority = 3, .resend_all = 0}; + struct sk_buff *skb; + mock_xmit_log_verbose = 1; skb = mock_skb_new(self->client_ip, &h.common, 0, 0); homa_xmit_unknown(skb, &self->hsk); @@ -612,6 +635,7 @@ TEST_F(homa_outgoing, homa_xmit_data__basics) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 6000, 1000); + crpc->msgout.sched_priority = 2; crpc->msgout.unscheduled = 2000; crpc->msgout.granted = 5000; @@ -635,8 +659,8 @@ TEST_F(homa_outgoing, homa_xmit_data__stop_because_no_more_granted) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 6000, 1000); - unit_log_clear(); + unit_log_clear(); crpc->msgout.granted = 1000; homa_xmit_data(crpc, false); EXPECT_STREQ("xmit DATA 1400@0", unit_log_get()); @@ -649,6 +673,7 @@ TEST_F(homa_outgoing, homa_xmit_data__below_throttle_min) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 200, 1000); + unit_log_clear(); atomic64_set(&self->homa.link_idle_time, 11000); self->homa.max_nic_queue_cycles = 500; @@ -693,6 +718,7 @@ TEST_F(homa_outgoing, homa_xmit_data__throttle) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 6000, 1000); + unit_log_clear(); atomic64_set(&self->homa.link_idle_time, 11000); self->homa.max_nic_queue_cycles = 3000; @@ -711,6 +737,7 @@ TEST_F(homa_outgoing, homa_xmit_data__rpc_freed) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 6000, 1000); + crpc->msgout.unscheduled = 2000; crpc->msgout.granted = 5000; @@ -728,6 +755,7 @@ TEST_F(homa_outgoing, __homa_xmit_data__update_cutoff_version) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 1000); + crpc->peer->cutoff_version = htons(123); mock_xmit_log_verbose = 1; unit_log_clear(); @@ -737,11 +765,12 @@ TEST_F(homa_outgoing, __homa_xmit_data__update_cutoff_version) } TEST_F(homa_outgoing, __homa_xmit_data__fill_dst) { - int old_refcount; - struct dst_entry *dst; struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 1000); + struct dst_entry *dst; + int old_refcount; + unit_log_clear(); dst = crpc->peer->dst; old_refcount = atomic_read(&dst->__rcuref.refcnt); @@ -754,14 +783,16 @@ TEST_F(homa_outgoing, __homa_xmit_data__fill_dst) } TEST_F(homa_outgoing, __homa_xmit_data__ipv4_transmit_error) { + struct homa_rpc *crpc; + // Make sure the test uses IPv4. mock_ipv6 = false; homa_sock_destroy(&self->hsk); mock_sock_init(&self->hsk, &self->homa, self->client_port); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id, 1000, 1000); + crpc = unit_client_rpc(&self->hsk,UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id, + 1000, 1000); unit_log_clear(); mock_ip_queue_xmit_errors = 1; skb_get(crpc->msgout.packets); @@ -770,14 +801,16 @@ TEST_F(homa_outgoing, __homa_xmit_data__ipv4_transmit_error) } TEST_F(homa_outgoing, __homa_xmit_data__ipv6_transmit_error) { + struct homa_rpc *crpc; + // Make sure the test uses IPv6. mock_ipv6 = true; homa_sock_destroy(&self->hsk); mock_sock_init(&self->hsk, &self->homa, self->client_port); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id, 100, 1000); + crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id, + 100, 1000); unit_log_clear(); mock_ip6_xmit_errors = 1; skb_get(crpc->msgout.packets); @@ -787,10 +820,12 @@ TEST_F(homa_outgoing, __homa_xmit_data__ipv6_transmit_error) TEST_F(homa_outgoing, homa_resend_data__basics) { + struct homa_rpc *crpc; + mock_net_device.gso_max_size = 5000; - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id, 16000, 1000); + crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id, + 16000, 1000); unit_log_clear(); mock_clear_xmit_prios(); mock_xmit_log_verbose = 1; @@ -842,16 +877,20 @@ TEST_F(homa_outgoing, homa_resend_data__packet_doesnt_use_gso) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 2000); + unit_log_clear(); homa_resend_data(crpc, 500, 1500, 2); EXPECT_STREQ("xmit DATA retrans 1000@0", unit_log_get()); } TEST_F(homa_outgoing, homa_resend_data__cant_allocate_skb) { + struct homa_rpc *crpc; + mock_net_device.gso_max_size = 5000; - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id, 16000, 1000); + crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id, + 16000, 1000); + unit_log_clear(); mock_clear_xmit_prios(); mock_alloc_skb_errors = 1; @@ -860,10 +899,12 @@ TEST_F(homa_outgoing, homa_resend_data__cant_allocate_skb) } TEST_F(homa_outgoing, homa_resend_data__set_incoming) { + struct homa_rpc *crpc; + mock_net_device.gso_max_size = 5000; - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id, 16000, 1000); + crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id, + 16000, 1000); unit_log_clear(); mock_xmit_log_verbose = 1; EXPECT_EQ(10000, crpc->msgout.granted); @@ -880,10 +921,12 @@ TEST_F(homa_outgoing, homa_resend_data__set_incoming) } TEST_F(homa_outgoing, homa_resend_data__error_copying_data) { + struct homa_rpc *crpc; + mock_net_device.gso_max_size = 5000; - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, - self->client_ip, self->server_ip, - self->server_port, self->client_id, 16000, 1000); + crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id, + 16000, 1000); unit_log_clear(); mock_clear_xmit_prios(); mock_max_skb_frags = 0; @@ -893,10 +936,12 @@ TEST_F(homa_outgoing, homa_resend_data__error_copying_data) } TEST_F(homa_outgoing, homa_resend_data__set_homa_info) { + struct homa_rpc *crpc; + mock_net_device.gso_max_size = 5000; - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id, 16000, 1000); + crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id, + 16000, 1000); unit_log_clear(); mock_xmit_log_homa_info = 1; homa_resend_data(crpc, 8400, 8800, 2); @@ -931,6 +976,7 @@ TEST_F(homa_outgoing, homa_check_nic_queue__basics) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 500, 1000); + homa_get_skb_info(crpc->msgout.packets)->wire_bytes = 500; unit_log_clear(); atomic64_set(&self->homa.link_idle_time, 9000); @@ -946,6 +992,7 @@ TEST_F(homa_outgoing, homa_check_nic_queue__queue_full) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 500, 1000); + homa_get_skb_info(crpc->msgout.packets)->wire_bytes = 500; unit_log_clear(); atomic64_set(&self->homa.link_idle_time, 9000); @@ -961,6 +1008,7 @@ TEST_F(homa_outgoing, homa_check_nic_queue__queue_full_but_force) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 500, 1000); + homa_get_skb_info(crpc->msgout.packets)->wire_bytes = 500; unit_log_clear(); atomic64_set(&self->homa.link_idle_time, 9000); @@ -976,6 +1024,7 @@ TEST_F(homa_outgoing, homa_check_nic_queue__pacer_metrics) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 500, 1000); + homa_get_skb_info(crpc->msgout.packets)->wire_bytes = 500; homa_add_to_throttled(crpc); unit_log_clear(); @@ -995,6 +1044,7 @@ TEST_F(homa_outgoing, homa_check_nic_queue__queue_empty) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 500, 1000); + homa_get_skb_info(crpc->msgout.packets)->wire_bytes = 500; unit_log_clear(); atomic64_set(&self->homa.link_idle_time, 9000); @@ -1022,6 +1072,7 @@ TEST_F(homa_outgoing, homa_pacer_xmit__basics) UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id+4, 150000, 1000); + homa_add_to_throttled(crpc1); homa_add_to_throttled(crpc2); homa_add_to_throttled(crpc3); @@ -1039,18 +1090,17 @@ TEST_F(homa_outgoing, homa_pacer_xmit__basics) } TEST_F(homa_outgoing, homa_pacer_xmit__xmit_fifo) { + struct homa_rpc *crpc1, *crpc2, *crpc3; + mock_cycles = 10000; - struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, 2, 20000, 1000); + crpc1 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, 2, 20000, 1000); mock_cycles = 11000; - struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, 4, 10000, 1000); + crpc2 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, 4, 10000, 1000); mock_cycles = 12000; - struct homa_rpc *crpc3 = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, 6, 30000, 1000); + crpc3 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, 6, 30000, 1000); homa_add_to_throttled(crpc1); homa_add_to_throttled(crpc2); homa_add_to_throttled(crpc3); @@ -1093,6 +1143,7 @@ TEST_F(homa_outgoing, homa_pacer_xmit__pacer_busy) UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 10000, 1000); + homa_add_to_throttled(crpc); self->homa.max_nic_queue_cycles = 2000; self->homa.flags &= ~HOMA_FLAG_DONT_THROTTLE; @@ -1119,6 +1170,7 @@ TEST_F(homa_outgoing, homa_pacer_xmit__nic_queue_fills) UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 10000, 1000); + homa_add_to_throttled(crpc); self->homa.max_nic_queue_cycles = 2001; mock_cycles = 10000; @@ -1137,6 +1189,7 @@ TEST_F(homa_outgoing, homa_pacer_xmit__rpc_locked) UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 5000, 1000); + homa_add_to_throttled(crpc); self->homa.max_nic_queue_cycles = 2000; self->homa.flags &= ~HOMA_FLAG_DONT_THROTTLE; @@ -1161,6 +1214,7 @@ TEST_F(homa_outgoing, homa_pacer_xmit__remove_from_queue) UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 4, 10000, 1000); + homa_add_to_throttled(crpc1); homa_add_to_throttled(crpc2); self->homa.max_nic_queue_cycles = 2000; diff --git a/test/unit_homa_peer.c b/test/unit_homa_peer.c index 7bd5cfd..aea66c4 100644 --- a/test/unit_homa_peer.c +++ b/test/unit_homa_peer.c @@ -46,6 +46,7 @@ static int dead_count(struct homa_peertab *peertab) { struct list_head *pos; int count = 0; + list_for_each(pos, &peertab->dead_dsts) count++; return count; @@ -95,6 +96,7 @@ static void peer_lock_hook(char *id) { TEST_F(homa_peer, homa_peertab_init__vmalloc_failed) { struct homa_peertab table; + mock_vmalloc_errors = 1; EXPECT_EQ(ENOMEM, -homa_peertab_init(&table)); @@ -105,6 +107,7 @@ TEST_F(homa_peer, homa_peertab_init__vmalloc_failed) TEST_F(homa_peer, homa_peertab_gc_dsts) { struct homa_peer *peer; + peer = homa_peer_find(&self->peertab, ip3333, &self->hsk.inet); mock_cycles = 0; homa_dst_refresh(&self->peertab, peer, &self->hsk); @@ -124,6 +127,7 @@ TEST_F(homa_peer, homa_peertab_get_peers__not_init) { struct homa_peertab peertab; int num_peers = 45; + memset(&peertab, 0, sizeof(peertab)); EXPECT_EQ(NULL, homa_peertab_get_peers(&peertab, &num_peers)); EXPECT_EQ(0, num_peers); @@ -137,6 +141,7 @@ TEST_F(homa_peer, homa_peertab_get_peers__table_empty) TEST_F(homa_peer, homa_peertab_get_peers__kmalloc_fails) { int num_peers = 45; + mock_kmalloc_errors = 1; homa_peer_find(&self->peertab, ip3333, &self->hsk.inet); EXPECT_EQ(NULL, homa_peertab_get_peers(&self->peertab, &num_peers)); @@ -147,6 +152,7 @@ TEST_F(homa_peer, homa_peertab_get_peers__one_peer) struct homa_peer **peers; struct homa_peer *peer; int num_peers = 45; + peer = homa_peer_find(&self->peertab, ip3333, &self->hsk.inet); peers = homa_peertab_get_peers(&self->peertab, &num_peers); ASSERT_NE(NULL, peers); @@ -156,9 +162,10 @@ TEST_F(homa_peer, homa_peertab_get_peers__one_peer) } TEST_F(homa_peer, homa_peertab_get_peers__multiple_peers) { - struct homa_peer **peers; struct homa_peer *peer1, *peer2, *peer3; + struct homa_peer **peers; int num_peers = 45; + peer1 = homa_peer_find(&self->peertab, ip1111, &self->hsk.inet); peer2 = homa_peer_find(&self->peertab, ip2222, &self->hsk.inet); peer3 = homa_peer_find(&self->peertab, ip3333, &self->hsk.inet); @@ -208,8 +215,9 @@ TEST_F(homa_peer, homa_peer_find__route_error) TEST_F(homa_peer, homa_dst_refresh__basics) { - struct homa_peer *peer; struct dst_entry *old_dst; + struct homa_peer *peer; + peer = homa_peer_find(&self->peertab, ip1111, &self->hsk.inet); ASSERT_NE(NULL, peer); EXPECT_EQ_IP(*ip1111, peer->addr); @@ -221,8 +229,9 @@ TEST_F(homa_peer, homa_dst_refresh__basics) } TEST_F(homa_peer, homa_dst_refresh__routing_error) { - struct homa_peer *peer; struct dst_entry *old_dst; + struct homa_peer *peer; + peer = homa_peer_find(&self->peertab, ip1111, &self->hsk.inet); ASSERT_NE(NULL, peer); EXPECT_EQ_IP(*ip1111, peer->addr); @@ -236,8 +245,9 @@ TEST_F(homa_peer, homa_dst_refresh__routing_error) } TEST_F(homa_peer, homa_dst_refresh__malloc_error) { - struct homa_peer *peer; struct dst_entry *old_dst; + struct homa_peer *peer; + peer = homa_peer_find(&self->peertab, ip1111, &self->hsk.inet); ASSERT_NE(NULL, peer); EXPECT_EQ_IP(*ip1111, peer->addr); @@ -251,6 +261,7 @@ TEST_F(homa_peer, homa_dst_refresh__malloc_error) TEST_F(homa_peer, homa_dst_refresh__free_old_dsts) { struct homa_peer *peer; + peer = homa_peer_find(&self->peertab, ip1111, &self->hsk.inet); ASSERT_NE(NULL, peer); EXPECT_EQ_IP(*ip1111, peer->addr); @@ -267,6 +278,7 @@ TEST_F(homa_peer, homa_dst_refresh__free_old_dsts) TEST_F(homa_peer, homa_unsched_priority) { struct homa_peer peer; + homa_peer_set_cutoffs(&peer, INT_MAX, 0, 0, INT_MAX, 200, 100, 0, 0); EXPECT_EQ(5, homa_unsched_priority(&self->homa, &peer, 10)); @@ -295,9 +307,9 @@ TEST_F(homa_peer, homa_peer_get_dst_ipv4) } TEST_F(homa_peer, homa_peer_get_dst_ipv6) { + struct dst_entry *dst; char buffer[30]; __u32 addr; - struct dst_entry *dst; // Make sure the test uses IPv6. mock_ipv6 = true; @@ -320,11 +332,11 @@ TEST_F(homa_peer, homa_peer_get_dst_ipv6) TEST_F(homa_peer, homa_peer_lock_slow) { - mock_cycles = 10000; struct homa_peer *peer = homa_peer_find(&self->peertab, ip3333, &self->hsk.inet); - ASSERT_NE(NULL, peer); + ASSERT_NE(NULL, peer); + mock_cycles = 10000; homa_peer_lock(peer); EXPECT_EQ(0, homa_metrics_per_cpu()->peer_ack_lock_misses); EXPECT_EQ(0, homa_metrics_per_cpu()->peer_ack_lock_miss_cycles); @@ -350,6 +362,7 @@ TEST_F(homa_peer, homa_peer_add_ack) self->client_ip, self->server_ip, self->server_port, 103, 100, 100); struct homa_peer *peer = crpc1->peer; + EXPECT_EQ(0, peer->num_acks); /* Initialize 3 acks in the peer. */ @@ -395,11 +408,12 @@ TEST_F(homa_peer, homa_peer_get_acks) { struct homa_peer *peer = homa_peer_find(&self->peertab, ip3333, &self->hsk.inet); + struct homa_ack acks[2]; + ASSERT_NE(NULL, peer); EXPECT_EQ(0, peer->num_acks); // First call: nothing available. - struct homa_ack acks[2]; EXPECT_EQ(0, homa_peer_get_acks(peer, 2, acks)); // Second call: retrieve 2 out of 3. diff --git a/test/unit_homa_plumbing.c b/test/unit_homa_plumbing.c index abaf781..fa66581 100644 --- a/test/unit_homa_plumbing.c +++ b/test/unit_homa_plumbing.c @@ -111,85 +111,95 @@ FIXTURE_TEARDOWN(homa_plumbing) TEST_F(homa_plumbing, homa_bind__version_mismatch) { + struct sockaddr addr = {}; + struct socket sock = {}; + int result; + // Make sure the test uses IPv4. mock_ipv6 = false; homa_sock_destroy(&self->hsk); mock_sock_init(&self->hsk, &self->homa, 0); - - struct sockaddr addr = {}; addr.sa_family = AF_INET6; - struct socket sock = {}; sock.sk = &self->hsk.inet.sk; - int result = homa_bind(&sock, &addr, sizeof(addr)); + result = homa_bind(&sock, &addr, sizeof(addr)); EXPECT_EQ(EAFNOSUPPORT, -result); } TEST_F(homa_plumbing, homa_bind__ipv6_address_too_short) { + union sockaddr_in_union addr = {}; + struct socket sock = {}; + int result; + // Make sure the test uses IPv6. mock_ipv6 = true; homa_sock_destroy(&self->hsk); mock_sock_init(&self->hsk, &self->homa, 0); - union sockaddr_in_union addr = {}; addr.in6.sin6_family = AF_INET6; - struct socket sock = {}; sock.sk = &self->hsk.inet.sk; - int result = homa_bind(&sock, &addr.sa, sizeof(addr.in6)-1); + result = homa_bind(&sock, &addr.sa, sizeof(addr.in6)-1); EXPECT_EQ(EINVAL, -result); } TEST_F(homa_plumbing, homa_bind__ipv6_ok) { + union sockaddr_in_union addr = {}; + struct socket sock = {}; + int result; + // Make sure the test uses IPv6. mock_ipv6 = true; homa_sock_destroy(&self->hsk); mock_sock_init(&self->hsk, &self->homa, 0); - union sockaddr_in_union addr = {}; addr.in6.sin6_family = AF_INET6; addr.in6.sin6_port = htons(123); - struct socket sock = {}; sock.sk = &self->hsk.inet.sk; - int result = homa_bind(&sock, &addr.sa, sizeof(addr.in6)); + result = homa_bind(&sock, &addr.sa, sizeof(addr.in6)); EXPECT_EQ(0, -result); EXPECT_EQ(123, self->hsk.port); } TEST_F(homa_plumbing, homa_bind__ipv4_address_too_short) { + union sockaddr_in_union addr = {}; + struct socket sock = {}; + int result; + // Make sure the test uses IPv4. mock_ipv6 = false; homa_sock_destroy(&self->hsk); mock_sock_init(&self->hsk, &self->homa, 0); - union sockaddr_in_union addr = {}; addr.in4.sin_family = AF_INET; - struct socket sock = {}; sock.sk = &self->hsk.inet.sk; - int result = homa_bind(&sock, &addr.sa, sizeof(addr.in4)-1); + result = homa_bind(&sock, &addr.sa, sizeof(addr.in4)-1); EXPECT_EQ(EINVAL, -result); } TEST_F(homa_plumbing, homa_bind__ipv4_ok) { + union sockaddr_in_union addr = {}; + struct socket sock = {}; + int result; + // Make sure the test uses IPv4. mock_ipv6 = false; homa_sock_destroy(&self->hsk); mock_sock_init(&self->hsk, &self->homa, 0); - union sockaddr_in_union addr = {}; addr.in4.sin_family = AF_INET; addr.in4.sin_port = htons(345); - struct socket sock = {}; sock.sk = &self->hsk.inet.sk; - int result = homa_bind(&sock, &addr.sa, sizeof(addr.in4)); + result = homa_bind(&sock, &addr.sa, sizeof(addr.in4)); EXPECT_EQ(0, -result); EXPECT_EQ(345, self->hsk.port); } TEST_F(homa_plumbing, homa_ioc_abort__basics) { - struct homa_abort_args args = {self->client_id, 0}; struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 10000, 200); + struct homa_abort_args args = {self->client_id, 0}; + ASSERT_NE(NULL, crpc); EXPECT_EQ(0, homa_ioc_abort(&self->hsk.inet.sk, (int *) &args)); EXPECT_EQ(RPC_DEAD, crpc->state); @@ -198,18 +208,20 @@ TEST_F(homa_plumbing, homa_ioc_abort__basics) TEST_F(homa_plumbing, homa_ioc_abort__cant_read_user_args) { struct homa_abort_args args = {self->client_id, 0}; + mock_copy_data_errors = 1; EXPECT_EQ(EFAULT, -homa_ioc_abort(&self->hsk.inet.sk, (int *) &args)); } TEST_F(homa_plumbing, homa_ioc_abort__abort_multiple_rpcs) { - struct homa_abort_args args = {0, ECANCELED}; struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 10000, 200); struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 10000, 200); + struct homa_abort_args args = {0, ECANCELED}; + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); EXPECT_EQ(0, homa_ioc_abort(&self->hsk.inet.sk, (int *) &args)); @@ -220,6 +232,7 @@ TEST_F(homa_plumbing, homa_ioc_abort__abort_multiple_rpcs) TEST_F(homa_plumbing, homa_ioc_abort__nonexistent_rpc) { struct homa_abort_args args = {99, 0}; + EXPECT_EQ(EINVAL, -homa_ioc_abort(&self->hsk.inet.sk, (int *) &args)); } @@ -249,6 +262,7 @@ TEST_F(homa_plumbing, homa_set_sock_opt__copy_from_sockptr_fails) TEST_F(homa_plumbing, homa_set_sock_opt__copy_to_user_fails) { struct homa_set_buf_args args = {(void *) 0x100000, 5*HOMA_BPAGE_SIZE}; + self->optval.user = &args; mock_copy_to_user_errors = 1; EXPECT_EQ(EFAULT, -homa_setsockopt(&self->hsk.sock, IPPROTO_HOMA, @@ -336,6 +350,7 @@ TEST_F(homa_plumbing, homa_sendmsg__cant_update_user_arguments) TEST_F(homa_plumbing, homa_sendmsg__request_sent_successfully) { struct homa_rpc *crpc; + atomic64_set(&self->homa.next_outgoing_id, 1234); self->sendmsg_args.completion_cookie = 88888; EXPECT_EQ(0, -homa_sendmsg(&self->hsk.inet.sk, @@ -353,6 +368,7 @@ TEST_F(homa_plumbing, homa_sendmsg__response_nonzero_completion_cookie) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 2000, 100); + self->sendmsg_args.id = self->server_id; self->sendmsg_args.completion_cookie = 12345; EXPECT_EQ(EINVAL, -homa_sendmsg(&self->hsk.inet.sk, @@ -365,6 +381,7 @@ TEST_F(homa_plumbing, homa_sendmsg__response_cant_find_rpc) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 2000, 100); + self->sendmsg_args.id = self->server_id + 1; EXPECT_EQ(0, -homa_sendmsg(&self->hsk.inet.sk, &self->sendmsg_hdr, self->sendmsg_hdr.msg_iter.count)); @@ -376,6 +393,7 @@ TEST_F(homa_plumbing, homa_sendmsg__response_error_in_rpc) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 2000, 100); + self->sendmsg_args.id = srpc->id; srpc->error = -ENOMEM; EXPECT_EQ(ENOMEM, -homa_sendmsg(&self->hsk.inet.sk, @@ -388,6 +406,7 @@ TEST_F(homa_plumbing, homa_sendmsg__response_wrong_state) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, self->server_id, 2000, 100); + self->sendmsg_args.id = self->server_id; EXPECT_EQ(EINVAL, -homa_sendmsg(&self->hsk.inet.sk, &self->sendmsg_hdr, self->sendmsg_hdr.msg_iter.count)); @@ -399,6 +418,7 @@ TEST_F(homa_plumbing, homa_sendmsg__homa_message_out_fill_returns_error) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 2000, 100); + self->sendmsg_args.id = self->server_id; self->sendmsg_hdr.msg_iter.count = HOMA_MAX_MESSAGE_LENGTH + 1; EXPECT_EQ(EINVAL, -homa_sendmsg(&self->hsk.inet.sk, @@ -411,6 +431,7 @@ TEST_F(homa_plumbing, homa_sendmsg__rpc_freed_during_homa_message_out_fill) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 2000, 100); + unit_hook_register(unlock_hook); hook_rpc = srpc; self->sendmsg_args.id = self->server_id; @@ -425,6 +446,7 @@ TEST_F(homa_plumbing, homa_sendmsg__response_succeeds) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 2000, 100); + self->sendmsg_args.id = self->server_id; EXPECT_EQ(0, -homa_sendmsg(&self->hsk.inet.sk, &self->sendmsg_hdr, self->sendmsg_hdr.msg_iter.count)); @@ -502,6 +524,7 @@ TEST_F(homa_plumbing, homa_recvmsg__MSG_DONT_WAIT) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 100, 2000); + EXPECT_NE(NULL, crpc); EXPECT_EQ(EAGAIN, -homa_recvmsg(&self->hsk.inet.sk, @@ -510,16 +533,18 @@ TEST_F(homa_plumbing, homa_recvmsg__MSG_DONT_WAIT) } TEST_F(homa_plumbing, homa_recvmsg__normal_completion_ipv4) { + struct homa_rpc *crpc; + __u32 pages[2]; + // Make sure the test uses IPv4. mock_ipv6 = false; homa_sock_destroy(&self->hsk); mock_sock_init(&self->hsk, &self->homa, 0); - __u32 pages[2]; EXPECT_EQ(0, -homa_pool_get_pages(self->hsk.buffer_pool, 2, pages, 0)); - 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, 2000); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, + self->server_ip, self->server_port, self->client_id, + 100, 2000); EXPECT_NE(NULL, crpc); EXPECT_EQ(1, unit_list_length(&self->hsk.active_rpcs)); crpc->completion_cookie = 44444; @@ -541,15 +566,18 @@ TEST_F(homa_plumbing, homa_recvmsg__normal_completion_ipv4) } TEST_F(homa_plumbing, homa_recvmsg__normal_completion_ipv6) { + struct in6_addr server_ip6; + struct homa_rpc *crpc; + // Make sure the test uses IPv6. mock_ipv6 = true; homa_sock_destroy(&self->hsk); mock_sock_init(&self->hsk, &self->homa, 0); - struct in6_addr server_ip6 = unit_get_in_addr("1::3:5:7"); + server_ip6 = unit_get_in_addr("1::3:5:7"); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, - self->client_ip, &server_ip6, self->server_port, - self->client_id, 100, 2000); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, + &server_ip6, self->server_port, self->client_id, + 100, 2000); EXPECT_NE(NULL, crpc); EXPECT_EQ(1, unit_list_length(&self->hsk.active_rpcs)); crpc->completion_cookie = 44444; @@ -571,6 +599,7 @@ TEST_F(homa_plumbing, homa_recvmsg__rpc_has_error) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 100, 2000); + EXPECT_NE(NULL, crpc); crpc->completion_cookie = 44444; homa_rpc_abort(crpc, -ETIMEDOUT); @@ -591,6 +620,7 @@ TEST_F(homa_plumbing, homa_recvmsg__add_ack) 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, 2000); + EXPECT_NE(NULL, crpc); EXPECT_EQ(1, unit_list_length(&self->hsk.active_rpcs)); crpc->completion_cookie = 44444; @@ -604,8 +634,8 @@ TEST_F(homa_plumbing, homa_recvmsg__server_normal_completion) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->client_port, self->server_id, 100, 200); - EXPECT_NE(NULL, srpc); + EXPECT_NE(NULL, srpc); EXPECT_EQ(100, homa_recvmsg(&self->hsk.inet.sk, &self->recvmsg_hdr, 0, 0, &self->recvmsg_hdr.msg_namelen)); EXPECT_EQ(self->server_id, self->recvmsg_args.id); @@ -618,6 +648,7 @@ TEST_F(homa_plumbing, homa_recvmsg__delete_server_rpc_after_error) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->client_port, self->server_id, 100, 200); + EXPECT_NE(NULL, srpc); srpc->error = -ENOMEM; @@ -632,6 +663,7 @@ TEST_F(homa_plumbing, homa_recvmsg__error_copying_out_args) 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, 2000); + EXPECT_NE(NULL, crpc); EXPECT_EQ(1, unit_list_length(&self->hsk.active_rpcs)); mock_copy_to_user_errors = 1; @@ -659,6 +691,7 @@ TEST_F(homa_plumbing, homa_recvmsg__copy_back_args_even_after_error) TEST_F(homa_plumbing, homa_softirq__basics) { struct sk_buff *skb; + skb = mock_skb_new(self->client_ip, &self->data.common, 1400, 1400); homa_softirq(skb); EXPECT_EQ(1, unit_list_length(&self->hsk.active_rpcs)); @@ -666,6 +699,7 @@ TEST_F(homa_plumbing, homa_softirq__basics) TEST_F(homa_plumbing, homa_softirq__cant_pull_header) { struct sk_buff *skb; + skb = mock_skb_new(self->client_ip, &self->data.common, 1400, 1400); skb->data_len = skb->len - 20; homa_softirq(skb); @@ -674,6 +708,7 @@ TEST_F(homa_plumbing, homa_softirq__cant_pull_header) TEST_F(homa_plumbing, homa_softirq__remove_extra_headers) { struct sk_buff *skb; + skb = mock_skb_new(self->client_ip, &self->data.common, 1400, 1400); __skb_push(skb, 10); homa_softirq(skb); @@ -683,6 +718,7 @@ TEST_F(homa_plumbing, homa_softirq__packet_too_short) { struct sk_buff *skb; struct ack_header h; + h.common.type = ACK; skb = mock_skb_new(self->client_ip, &h.common, 0, 0); skb->len -= 1; @@ -693,6 +729,7 @@ TEST_F(homa_plumbing, homa_softirq__packet_too_short) TEST_F(homa_plumbing, homa_softirq__bogus_packet_type) { struct sk_buff *skb; + self->data.common.type = BOGUS; skb = mock_skb_new(self->client_ip, &self->data.common, 1400, 1400); homa_softirq(skb); @@ -728,13 +765,13 @@ TEST_F(homa_plumbing, homa_softirq__process_short_messages_first) } TEST_F(homa_plumbing, homa_softirq__process_control_first) { - struct sk_buff *skb, *skb2; struct common_header unknown = { .sport = htons(self->client_port), .dport = htons(self->server_port), .type = UNKNOWN, .sender_id = cpu_to_be64(self->client_id) }; + struct sk_buff *skb, *skb2; self->data.common.sender_id = cpu_to_be64(2000); self->data.message_length = htonl(2000); diff --git a/test/unit_homa_pool.c b/test/unit_homa_pool.c index e4dd08e..6ebdc7d 100644 --- a/test/unit_homa_pool.c +++ b/test/unit_homa_pool.c @@ -68,6 +68,7 @@ static void change_owner_hook(char *id) TEST_F(homa_pool, homa_pool_set_bpages_needed) { struct homa_pool *pool = self->hsk.buffer_pool; + atomic_set(&pool->free_bpages, 0); unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, 4000, 98, 1000, 2*HOMA_BPAGE_SIZE+1); @@ -81,6 +82,7 @@ TEST_F(homa_pool, homa_pool_set_bpages_needed) TEST_F(homa_pool, homa_pool_init__basics) { struct homa_pool *pool = self->hsk.buffer_pool; + EXPECT_EQ(100, pool->num_bpages); EXPECT_EQ(-1, pool->descriptors[98].owner); } @@ -122,6 +124,7 @@ TEST_F(homa_pool, homa_pool_get_pages__basics) { struct homa_pool *pool = self->hsk.buffer_pool; __u32 pages[10]; + EXPECT_EQ(0, homa_pool_get_pages(pool, 2, pages, 0)); EXPECT_EQ(0, pages[0]); EXPECT_EQ(1, pages[1]); @@ -134,6 +137,7 @@ TEST_F(homa_pool, homa_pool_get_pages__not_enough_space) { struct homa_pool *pool = self->hsk.buffer_pool; __u32 pages[10]; + atomic_set(&pool->free_bpages, 1); EXPECT_EQ(-1, homa_pool_get_pages(pool, 2, pages, 0)); atomic_set(&pool->free_bpages, 2); @@ -143,6 +147,7 @@ TEST_F(homa_pool, homa_pool_get_pages__set_limit) { struct homa_pool *pool = self->hsk.buffer_pool; __u32 pages[10]; + atomic_set(&pool->free_bpages, 62); pool->cores[raw_smp_processor_id()].next_candidate = 49; EXPECT_EQ(0, homa_pool_get_pages(pool, 2, pages, 0)); @@ -153,6 +158,7 @@ TEST_F(homa_pool, homa_pool_get_pages__set_limit_with_MIN_EXTRA) { struct homa_pool *pool = self->hsk.buffer_pool; __u32 pages[10]; + atomic_set(&pool->free_bpages, 92); pool->cores[raw_smp_processor_id()].next_candidate = 13; EXPECT_EQ(0, homa_pool_get_pages(pool, 2, pages, 0)); @@ -163,6 +169,7 @@ TEST_F(homa_pool, homa_pool_get_pages__skip_unusable_bpages) { struct homa_pool *pool = self->hsk.buffer_pool; __u32 pages[10]; + mock_cycles = 1000; atomic_set(&pool->descriptors[0].refs, 2); atomic_set(&pool->descriptors[1].refs, 1); @@ -180,6 +187,7 @@ TEST_F(homa_pool, homa_pool_get_pages__cant_lock_pages) { struct homa_pool *pool = self->hsk.buffer_pool; __u32 pages[10]; + mock_cycles = 1000; mock_trylock_errors = 3; EXPECT_EQ(0, homa_pool_get_pages(pool, 2, pages, 0)); @@ -190,6 +198,7 @@ TEST_F(homa_pool, homa_pool_get_pages__state_changes_while_locking) { struct homa_pool *pool = self->hsk.buffer_pool; __u32 pages[10]; + mock_cycles = 1000; unit_hook_register(steal_bpages_hook); EXPECT_EQ(0, homa_pool_get_pages(pool, 2, pages, 0)); @@ -200,6 +209,7 @@ TEST_F(homa_pool, homa_pool_get_pages__steal_expired_page) { struct homa_pool *pool = self->hsk.buffer_pool; __u32 pages[10]; + pool->descriptors[0].owner = 5; mock_cycles = 5000; pool->descriptors[0].expiration = mock_cycles - 1; @@ -214,6 +224,7 @@ TEST_F(homa_pool, homa_pool_get_pages__set_owner) { struct homa_pool *pool = self->hsk.buffer_pool; __u32 pages[10]; + self->homa.bpage_lease_cycles = 1000; mock_cycles = 5000; EXPECT_EQ(0, homa_pool_get_pages(pool, 2, pages, 1)); @@ -225,12 +236,12 @@ TEST_F(homa_pool, homa_pool_get_pages__set_owner) TEST_F(homa_pool, homa_pool_allocate__basics) { - struct homa_pool *pool = self->hsk.buffer_pool; struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, 4000, 98, 1000, 150000); - ASSERT_NE(NULL, crpc); + struct homa_pool *pool = self->hsk.buffer_pool; + ASSERT_NE(NULL, crpc); EXPECT_EQ(3, crpc->msgin.num_bpages); EXPECT_EQ(0, crpc->msgin.bpage_offsets[0]); EXPECT_EQ(-1, pool->descriptors[0].owner); @@ -241,10 +252,11 @@ TEST_F(homa_pool, homa_pool_allocate__basics) } TEST_F(homa_pool, homa_pool_no_buffer_pool) { - struct homa_pool *pool = self->hsk.buffer_pool; struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, 4000, 98, 1000, 150000); + struct homa_pool *pool = self->hsk.buffer_pool; + ASSERT_NE(NULL, crpc); homa_pool_destroy(pool); EXPECT_EQ(ENOMEM, -homa_pool_allocate(crpc)); @@ -252,10 +264,11 @@ TEST_F(homa_pool, homa_pool_no_buffer_pool) TEST_F(homa_pool, homa_pool_allocate__cant_allocate_full_bpages) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; + atomic_set(&pool->free_bpages, 1); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 150000); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 150000); ASSERT_NE(NULL, crpc); EXPECT_EQ(0, crpc->msgin.num_bpages); @@ -265,10 +278,12 @@ TEST_F(homa_pool, homa_pool_allocate__cant_allocate_full_bpages) TEST_F(homa_pool, homa_pool_allocate__no_partial_page) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; + atomic_set(&pool->free_bpages, 2); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2*HOMA_BPAGE_SIZE); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, + 2*HOMA_BPAGE_SIZE); ASSERT_NE(NULL, crpc); EXPECT_EQ(2, crpc->msgin.num_bpages); @@ -279,11 +294,12 @@ TEST_F(homa_pool, homa_pool_allocate__no_partial_page) TEST_F(homa_pool, homa_pool_allocate__owned_page_locked_and_page_stolen) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; + pool->cores[raw_smp_processor_id()].next_candidate = 2; atomic_set(&pool->free_bpages, 40); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2000); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2000); ASSERT_NE(NULL, crpc); // First allocation just sets up a partially-allocated bpage. @@ -306,13 +322,14 @@ TEST_F(homa_pool, homa_pool_allocate__owned_page_locked_and_page_stolen) TEST_F(homa_pool, homa_pool_allocate__page_wrap_around) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; + pool->cores[raw_smp_processor_id()].page_hint = 2; pool->cores[raw_smp_processor_id()].allocated = HOMA_BPAGE_SIZE-1900; atomic_set(&pool->descriptors[2].refs, 1); pool->descriptors[2].owner = raw_smp_processor_id(); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2000); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2000); ASSERT_NE(NULL, crpc); EXPECT_EQ(2, pool->cores[raw_smp_processor_id()].page_hint); @@ -325,11 +342,12 @@ TEST_F(homa_pool, homa_pool_allocate__page_wrap_around) TEST_F(homa_pool, homa_pool_allocate__owned_page_overflow) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; + pool->cores[raw_smp_processor_id()].next_candidate = 2; atomic_set(&pool->free_bpages, 50); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2000); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2000); ASSERT_NE(NULL, crpc); EXPECT_EQ(2, pool->cores[raw_smp_processor_id()].page_hint); @@ -348,14 +366,14 @@ TEST_F(homa_pool, homa_pool_allocate__owned_page_overflow) TEST_F(homa_pool, homa_pool_allocate__reuse_owned_page) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc1, *crpc2; + pool->cores[raw_smp_processor_id()].next_candidate = 2; - struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2000); + crpc1 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2000); ASSERT_NE(NULL, crpc1); - struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 100, 1000, 3000); + crpc2 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 100, 1000, 3000); ASSERT_NE(NULL, crpc2); EXPECT_EQ(1, crpc1->msgin.num_bpages); @@ -369,10 +387,12 @@ TEST_F(homa_pool, homa_pool_allocate__reuse_owned_page) TEST_F(homa_pool, homa_pool_allocate__cant_allocate_partial_bpage) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; + atomic_set(&pool->free_bpages, 5); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 5*HOMA_BPAGE_SIZE + 100); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, + 5*HOMA_BPAGE_SIZE + 100); ASSERT_NE(NULL, crpc); EXPECT_EQ(0, crpc->msgin.num_bpages); @@ -383,8 +403,10 @@ TEST_F(homa_pool, homa_pool_allocate__cant_allocate_partial_bpage) } TEST_F(homa_pool, homa_pool_allocate__out_of_space) { - /* Queue up several RPCs to make sure they are properly sorted. */ struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *rpc; + + /* Queue up several RPCs to make sure they are properly sorted. */ atomic_set(&pool->free_bpages, 0); unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, 4000, 98, 1000, 2000); @@ -395,8 +417,8 @@ TEST_F(homa_pool, homa_pool_allocate__out_of_space) ASSERT_EQ(0, atomic_read(&pool->free_bpages)); ASSERT_FALSE(list_empty(&self->hsk.waiting_for_bufs)); - struct homa_rpc *rpc = list_first_entry(&self->hsk.waiting_for_bufs, - struct homa_rpc, buf_links); + rpc = list_first_entry(&self->hsk.waiting_for_bufs, struct homa_rpc, + buf_links); EXPECT_EQ(98, rpc->id); ASSERT_FALSE(list_is_last(&rpc->buf_links, &self->hsk.waiting_for_bufs)); rpc = list_next_entry(rpc, buf_links); @@ -412,12 +434,12 @@ TEST_F(homa_pool, homa_pool_allocate__out_of_space) TEST_F(homa_pool, homa_pool_get_buffer) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; int available; void *buffer; - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 150000); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 150000); ASSERT_NE(NULL, crpc); buffer = homa_pool_get_buffer(crpc, HOMA_BPAGE_SIZE + 1000, &available); EXPECT_EQ(HOMA_BPAGE_SIZE - 1000, available); @@ -430,15 +452,14 @@ TEST_F(homa_pool, homa_pool_get_buffer) TEST_F(homa_pool, homa_pool_release_buffers__basics) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc1, *crpc2; char *saved_region; - struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 150000); + crpc1 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 150000); ASSERT_NE(NULL, crpc1); - struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2000); + crpc2 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2000); ASSERT_NE(NULL, crpc2); EXPECT_EQ(1, atomic_read(&pool->descriptors[0].refs)); @@ -465,19 +486,18 @@ TEST_F(homa_pool, homa_pool_release_buffers__basics) TEST_F(homa_pool, homa_pool_check_waiting__basics) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc2, *crpc3; /* Queue up 2 RPCs that together need a total of 5 bpages. */ atomic_set(&pool->free_bpages, 0); - struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 3*HOMA_BPAGE_SIZE); + crpc2 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 3*HOMA_BPAGE_SIZE); ASSERT_NE(NULL, crpc2); EXPECT_EQ(0, crpc2->msgin.num_bpages); EXPECT_EQ(3, pool->bpages_needed); - struct homa_rpc *crpc3 = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2*HOMA_BPAGE_SIZE); + crpc3 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2*HOMA_BPAGE_SIZE); ASSERT_NE(NULL, crpc3); EXPECT_EQ(0, crpc3->msgin.num_bpages); EXPECT_EQ(2, pool->bpages_needed); @@ -499,6 +519,7 @@ TEST_F(homa_pool, homa_pool_check_waiting__basics) TEST_F(homa_pool, homa_pool_check_waiting__bpages_needed_but_no_queued_rpcs) { struct homa_pool *pool = self->hsk.buffer_pool; + pool->bpages_needed = 1; homa_pool_check_waiting(pool); EXPECT_EQ(100, atomic_read(&pool->free_bpages)); @@ -507,11 +528,11 @@ TEST_F(homa_pool, homa_pool_check_waiting__bpages_needed_but_no_queued_rpcs) TEST_F(homa_pool, homa_pool_check_waiting__rpc_initially_locked) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; atomic_set(&pool->free_bpages, 0); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2000); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2000); ASSERT_NE(NULL, crpc); EXPECT_EQ(0, crpc->msgin.num_bpages); @@ -528,18 +549,17 @@ TEST_F(homa_pool, homa_pool_check_waiting__rpc_initially_locked) TEST_F(homa_pool, homa_pool_check_waiting__reset_bpages_needed) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc1, *crpc2; atomic_set(&pool->free_bpages, 0); - struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2000); + crpc1 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2000); ASSERT_NE(NULL, crpc1); EXPECT_EQ(0, crpc1->msgin.num_bpages); atomic_set(&pool->free_bpages, 0); - struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2*HOMA_BPAGE_SIZE - 1); + crpc2 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2*HOMA_BPAGE_SIZE - 1); ASSERT_NE(NULL, crpc2); EXPECT_EQ(0, crpc2->msgin.num_bpages); EXPECT_EQ(1, pool->bpages_needed); @@ -553,12 +573,12 @@ TEST_F(homa_pool, homa_pool_check_waiting__reset_bpages_needed) TEST_F(homa_pool, homa_pool_check_waiting__wake_up_waiting_rpc) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; /* Queue up an RPC that needs 2 bpages. */ atomic_set(&pool->free_bpages, 0); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 2*HOMA_BPAGE_SIZE); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 2*HOMA_BPAGE_SIZE); ASSERT_NE(NULL, crpc); EXPECT_EQ(0, crpc->msgin.num_bpages); EXPECT_EQ(2, pool->bpages_needed); @@ -573,12 +593,12 @@ TEST_F(homa_pool, homa_pool_check_waiting__wake_up_waiting_rpc) TEST_F(homa_pool, homa_pool_check_waiting__reallocation_fails) { struct homa_pool *pool = self->hsk.buffer_pool; + struct homa_rpc *crpc; /* Queue up an RPC that needs 4 bpages. */ atomic_set(&pool->free_bpages, 0); - struct homa_rpc *crpc = unit_client_rpc(&self->hsk, - UNIT_RCVD_ONE_PKT, &self->client_ip, &self->server_ip, - 4000, 98, 1000, 4*HOMA_BPAGE_SIZE); + crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, &self->client_ip, + &self->server_ip, 4000, 98, 1000, 4*HOMA_BPAGE_SIZE); ASSERT_NE(NULL, crpc); EXPECT_EQ(0, crpc->msgin.num_bpages); pool->bpages_needed = 2; diff --git a/test/unit_homa_rpc.c b/test/unit_homa_rpc.c index 93020fd..dfe662e 100644 --- a/test/unit_homa_rpc.c +++ b/test/unit_homa_rpc.c @@ -72,6 +72,7 @@ FIXTURE_TEARDOWN(homa_rpc) static const char *dead_rpcs(struct homa_sock *hsk) { struct homa_rpc *rpc; + list_for_each_entry_rcu(rpc, &hsk->dead_rpcs, dead_links) UNIT_LOG(" ", "%llu", rpc->id); return unit_log_get(); @@ -81,31 +82,35 @@ TEST_F(homa_rpc, homa_rpc_new_client__normal) { struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); + ASSERT_FALSE(IS_ERR(crpc)); homa_rpc_free(crpc); homa_rpc_unlock(crpc); } TEST_F(homa_rpc, homa_rpc_new_client__malloc_error) { + struct homa_rpc *crpc; + mock_kmalloc_errors = 1; - struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, - &self->server_addr); + crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); EXPECT_TRUE(IS_ERR(crpc)); EXPECT_EQ(ENOMEM, -PTR_ERR(crpc)); } TEST_F(homa_rpc, homa_rpc_new_client__route_error) { + struct homa_rpc *crpc; + mock_route_errors = 1; - struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, - &self->server_addr); + crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); EXPECT_TRUE(IS_ERR(crpc)); EXPECT_EQ(EHOSTUNREACH, -PTR_ERR(crpc)); } TEST_F(homa_rpc, homa_rpc_new_client__socket_shutdown) { + struct homa_rpc *crpc; + self->hsk.shutdown = 1; - struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, - &self->server_addr); + crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); EXPECT_TRUE(IS_ERR(crpc)); EXPECT_EQ(ESHUTDOWN, -PTR_ERR(crpc)); self->hsk.shutdown = 0; @@ -113,9 +118,11 @@ TEST_F(homa_rpc, homa_rpc_new_client__socket_shutdown) TEST_F(homa_rpc, homa_rpc_new_server__normal) { + struct homa_rpc *srpc; int created; - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_FALSE(IS_ERR(srpc)); homa_rpc_unlock(srpc); self->data.message_length = N(1600); @@ -128,16 +135,18 @@ TEST_F(homa_rpc, homa_rpc_new_server__normal) } TEST_F(homa_rpc, homa_rpc_new_server__already_exists) { + struct homa_rpc *srpc1, *srpc2, *srpc3; int created; - struct homa_rpc *srpc1 = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + + srpc1 = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_FALSE(IS_ERR(srpc1)); homa_rpc_unlock(srpc1); self->data.common.sender_id = cpu_to_be64( be64_to_cpu(self->data.common.sender_id) + 2*HOMA_SERVER_RPC_BUCKETS); - struct homa_rpc *srpc2 = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc2 = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_FALSE(IS_ERR(srpc2)); EXPECT_EQ(1, created); homa_rpc_unlock(srpc2); @@ -145,8 +154,8 @@ TEST_F(homa_rpc, homa_rpc_new_server__already_exists) self->data.common.sender_id = cpu_to_be64( be64_to_cpu(self->data.common.sender_id) - 2*HOMA_SERVER_RPC_BUCKETS); - struct homa_rpc *srpc3 = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc3 = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_FALSE(IS_ERR(srpc3)); EXPECT_EQ(0, created); homa_rpc_unlock(srpc3); @@ -154,28 +163,34 @@ TEST_F(homa_rpc, homa_rpc_new_server__already_exists) } TEST_F(homa_rpc, homa_rpc_new_server__malloc_error) { + struct homa_rpc *srpc; int created; + mock_kmalloc_errors = 1; - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); EXPECT_TRUE(IS_ERR(srpc)); EXPECT_EQ(ENOMEM, -PTR_ERR(srpc)); } TEST_F(homa_rpc, homa_rpc_new_server__addr_error) { + struct homa_rpc *srpc; int created; + mock_route_errors = 1; - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); EXPECT_TRUE(IS_ERR(srpc)); EXPECT_EQ(EHOSTUNREACH, -PTR_ERR(srpc)); } TEST_F(homa_rpc, homa_rpc_new_server__socket_shutdown) { + struct homa_rpc *srpc; int created; + self->hsk.shutdown = 1; - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); EXPECT_TRUE(IS_ERR(srpc)); EXPECT_EQ(ESHUTDOWN, -PTR_ERR(srpc)); EXPECT_EQ(0, unit_list_length(&self->hsk.active_rpcs)); @@ -183,10 +198,12 @@ TEST_F(homa_rpc, homa_rpc_new_server__socket_shutdown) } TEST_F(homa_rpc, homa_rpc_new_server__allocate_buffers) { + struct homa_rpc *srpc; int created; + self->data.message_length = N(3*HOMA_BPAGE_SIZE); - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_FALSE(IS_ERR(srpc)); homa_rpc_unlock(srpc); EXPECT_EQ(3, srpc->msgin.num_bpages); @@ -194,20 +211,24 @@ TEST_F(homa_rpc, homa_rpc_new_server__allocate_buffers) } TEST_F(homa_rpc, homa_rpc_new_server__no_buffer_pool) { + struct homa_rpc *srpc; int created; + self->data.message_length = N(1400); homa_pool_destroy(self->hsk.buffer_pool); - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_TRUE(IS_ERR(srpc)); EXPECT_EQ(ENOMEM, -PTR_ERR(srpc)); } TEST_F(homa_rpc, homa_rpc_new_server__handoff_rpc) { + struct homa_rpc *srpc; int created; + self->data.message_length = N(1400); - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_FALSE(IS_ERR(srpc)); homa_rpc_unlock(srpc); EXPECT_EQ(RPC_INCOMING, srpc->state); @@ -217,11 +238,13 @@ TEST_F(homa_rpc, homa_rpc_new_server__handoff_rpc) } TEST_F(homa_rpc, homa_rpc_new_server__dont_handoff_no_buffers) { + struct homa_rpc *srpc; int created; + self->data.message_length = N(1400); atomic_set(&self->hsk.buffer_pool->free_bpages,0 ); - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_FALSE(IS_ERR(srpc)); homa_rpc_unlock(srpc); EXPECT_EQ(0, unit_list_length(&self->hsk.ready_requests)); @@ -229,11 +252,13 @@ TEST_F(homa_rpc, homa_rpc_new_server__dont_handoff_no_buffers) } TEST_F(homa_rpc, homa_rpc_new_server__dont_handoff_rpc) { + struct homa_rpc *srpc; int created; + self->data.message_length = N(2800); self->data.seg.offset = N(1400); - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_FALSE(IS_ERR(srpc)); homa_rpc_unlock(srpc); EXPECT_EQ(RPC_INCOMING, srpc->state); @@ -244,15 +269,16 @@ TEST_F(homa_rpc, homa_rpc_new_server__dont_handoff_rpc) TEST_F(homa_rpc, homa_bucket_lock_slow) { + struct homa_rpc *crpc, *srpc; int created; + mock_cycles = ~0; - struct homa_rpc *crpc = homa_rpc_new_client(&self->hsk, - &self->server_addr); + crpc = homa_rpc_new_client(&self->hsk, &self->server_addr); ASSERT_FALSE(IS_ERR(crpc)); homa_rpc_free(crpc); homa_rpc_unlock(crpc); - struct homa_rpc *srpc = homa_rpc_new_server(&self->hsk, - self->client_ip, &self->data, &created); + srpc = homa_rpc_new_server(&self->hsk, self->client_ip, &self->data, + &created); ASSERT_FALSE(IS_ERR(srpc)); homa_rpc_unlock(srpc); @@ -272,15 +298,18 @@ TEST_F(homa_rpc, homa_bucket_lock_slow) TEST_F(homa_rpc, homa_rpc_acked__basics) { + struct homa_rpc *srpc; struct homa_sock hsk; + struct homa_ack ack = {}; + mock_sock_init(&hsk, &self->homa, self->server_port); - struct homa_rpc *srpc = unit_server_rpc(&hsk, UNIT_OUTGOING, - self->client_ip, self->server_ip, self->client_port, - self->server_id, 100, 3000); + srpc = unit_server_rpc(&hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->client_port, self->server_id, + 100, 3000); ASSERT_NE(NULL, srpc); - struct homa_ack ack = {.client_port = htons(self->client_port), - .server_port = htons(self->server_port), - .client_id = cpu_to_be64(self->client_id)}; + ack.client_port = htons(self->client_port); + ack.server_port = htons(self->server_port); + ack.client_id = cpu_to_be64(self->client_id); homa_rpc_acked(&hsk, self->client_ip, &ack); EXPECT_EQ(0, unit_list_length(&hsk.active_rpcs)); EXPECT_STREQ("DEAD", homa_symbol_for_state(srpc)); @@ -288,15 +317,18 @@ TEST_F(homa_rpc, homa_rpc_acked__basics) } TEST_F(homa_rpc, homa_rpc_acked__lookup_socket) { + struct homa_ack ack = {}; + struct homa_rpc *srpc; struct homa_sock hsk; + mock_sock_init(&hsk, &self->homa, self->server_port); - struct homa_rpc *srpc = unit_server_rpc(&hsk, UNIT_OUTGOING, - self->client_ip, self->server_ip, self->client_port, - self->server_id, 100, 3000); + srpc = unit_server_rpc(&hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->client_port, self->server_id, + 100, 3000); ASSERT_NE(NULL, srpc); - struct homa_ack ack = {.client_port = htons(self->client_port), - .server_port = htons(self->server_port), - .client_id = cpu_to_be64(self->client_id)}; + ack.client_port = htons(self->client_port); + ack.server_port = htons(self->server_port); + ack.client_id = cpu_to_be64(self->client_id); homa_rpc_acked(&self->hsk, self->client_ip, &ack); EXPECT_EQ(0, unit_list_length(&hsk.active_rpcs)); EXPECT_STREQ("DEAD", homa_symbol_for_state(srpc)); @@ -304,15 +336,18 @@ TEST_F(homa_rpc, homa_rpc_acked__lookup_socket) } TEST_F(homa_rpc, homa_rpc_acked__no_such_socket) { + struct homa_ack ack = {}; + struct homa_rpc *srpc; struct homa_sock hsk; + mock_sock_init(&hsk, &self->homa, self->server_port); - struct homa_rpc *srpc = unit_server_rpc(&hsk, UNIT_OUTGOING, - self->client_ip, self->server_ip, self->client_port, - self->server_id, 100, 3000); + srpc = unit_server_rpc(&hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->client_port, self->server_id, + 100, 3000); ASSERT_NE(NULL, srpc); - struct homa_ack ack = {.client_port = htons(self->client_port), - .server_port = htons(self->server_port+1), - .client_id = cpu_to_be64(self->client_id)}; + ack.client_port = htons(self->client_port); + ack.server_port = htons(self->server_port+1); + ack.client_id = cpu_to_be64(self->client_id); homa_rpc_acked(&hsk, self->client_ip, &ack); EXPECT_EQ(1, unit_list_length(&hsk.active_rpcs)); EXPECT_STREQ("OUTGOING", homa_symbol_for_state(srpc)); @@ -320,15 +355,18 @@ TEST_F(homa_rpc, homa_rpc_acked__no_such_socket) } TEST_F(homa_rpc, homa_rpc_acked__no_such_rpc) { + struct homa_ack ack = {}; + struct homa_rpc *srpc; struct homa_sock hsk; + mock_sock_init(&hsk, &self->homa, self->server_port); - struct homa_rpc *srpc = unit_server_rpc(&hsk, UNIT_OUTGOING, - self->client_ip, self->server_ip, self->client_port, - self->server_id, 100, 3000); + srpc = unit_server_rpc(&hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->client_port, self->server_id, + 100, 3000); ASSERT_NE(NULL, srpc); - struct homa_ack ack = {.client_port = htons(self->client_port), - .server_port = htons(self->server_port), - .client_id = cpu_to_be64(self->client_id+10)}; + ack.client_port = htons(self->client_port); + ack.server_port = htons(self->server_port); + ack.client_id = cpu_to_be64(self->client_id+10); homa_rpc_acked(&hsk, self->client_ip, &ack); EXPECT_EQ(1, unit_list_length(&hsk.active_rpcs)); EXPECT_STREQ("OUTGOING", homa_symbol_for_state(srpc)); @@ -340,6 +378,7 @@ TEST_F(homa_rpc, homa_rpc_free__basics) 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, 1000, 20000); + EXPECT_EQ(1, self->homa.num_grantable_rpcs); ASSERT_NE(NULL, crpc); unit_log_clear(); @@ -355,6 +394,7 @@ TEST_F(homa_rpc, homa_rpc_free__already_dead) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 100); + ASSERT_NE(NULL, crpc); unit_log_clear(); homa_rpc_free(crpc); @@ -369,6 +409,7 @@ TEST_F(homa_rpc, homa_rpc_free__state_ready) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 100); + ASSERT_NE(NULL, crpc); EXPECT_EQ(1, unit_list_length(&self->hsk.ready_responses)); homa_rpc_free(crpc); @@ -376,10 +417,11 @@ TEST_F(homa_rpc, homa_rpc_free__state_ready) } TEST_F(homa_rpc, homa_rpc_free__wakeup_interest) { - struct homa_interest interest = {}; struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 1000, 100); + struct homa_interest interest = {}; + ASSERT_NE(NULL, crpc); atomic_long_set(&interest.ready_rpc, 0); interest.reg_rpc = crpc; @@ -395,6 +437,7 @@ TEST_F(homa_rpc, homa_rpc_free__free_gaps) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, 99, 1000, 1000); + homa_message_in_init(crpc, 10000, 0); unit_log_clear(); self->data.seg.offset = htonl(1400); @@ -415,6 +458,7 @@ TEST_F(homa_rpc, homa_rpc_free__dead_buffs) struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 10000, 1000); + ASSERT_NE(NULL, crpc1); homa_rpc_free(crpc1); EXPECT_EQ(9, self->homa.max_dead_buffs); @@ -432,6 +476,7 @@ TEST_F(homa_rpc, homa_rpc_free__remove_from_throttled_list) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 10000, 1000); + homa_add_to_throttled(crpc); EXPECT_EQ(1, unit_list_length(&self->homa.throttled_rpcs)); unit_log_clear(); @@ -450,6 +495,7 @@ TEST_F(homa_rpc, homa_rpc_reap__basics) struct homa_rpc *crpc3 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id+4, 2000, 100); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); ASSERT_NE(NULL, crpc3); @@ -471,6 +517,7 @@ TEST_F(homa_rpc, homa_rpc_reap__protected) struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->server_port, self->client_id, 5000, 2000); + ASSERT_NE(NULL, crpc1); homa_rpc_free(crpc1); unit_log_clear(); @@ -487,6 +534,7 @@ TEST_F(homa_rpc, homa_rpc_reap__skip_rpc_because_of_flags) struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->server_port, self->client_id+2, 1000, 2000); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); homa_rpc_free(crpc1); @@ -510,6 +558,7 @@ TEST_F(homa_rpc, homa_rpc_reap__skip_rpc_because_of_active_xmits) struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->server_port, self->client_id+2, 1000, 2000); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); homa_rpc_free(crpc1); @@ -531,6 +580,7 @@ TEST_F(homa_rpc, homa_rpc_reap__grant_in_progress) struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->server_port, self->client_id+2, 1000, 2000); + ASSERT_NE(NULL, crpc1); ASSERT_NE(NULL, crpc2); homa_rpc_free(crpc1); @@ -551,6 +601,7 @@ TEST_F(homa_rpc, homa_rpc_reap__hit_limit_in_msgout_packets) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 10000, 100); + ASSERT_NE(NULL, crpc); homa_rpc_free(crpc); EXPECT_EQ(9, self->hsk.dead_skbs); @@ -561,12 +612,12 @@ TEST_F(homa_rpc, homa_rpc_reap__hit_limit_in_msgout_packets) } TEST_F(homa_rpc, homa_rpc_reap__release_buffers) { - struct homa_pool *pool = self->hsk.buffer_pool; struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, 4000, 98, 1000, 150000); - ASSERT_NE(NULL, crpc); + struct homa_pool *pool = self->hsk.buffer_pool; + ASSERT_NE(NULL, crpc); EXPECT_EQ(1, atomic_read(&pool->descriptors[1].refs)); homa_rpc_free(crpc); EXPECT_EQ(1, atomic_read(&pool->descriptors[1].refs)); @@ -580,6 +631,7 @@ TEST_F(homa_rpc, homa_rpc_reap__free_gaps) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, 4000, 98, 1000, 150000); + ASSERT_NE(NULL, crpc); homa_gap_new(&crpc->msgin.gaps, 1000, 2000); mock_cycles = 1000; @@ -598,23 +650,25 @@ TEST_F(homa_rpc, homa_rpc_reap__nothing_to_reap) TEST_F(homa_rpc, homa_find_client_rpc) { + struct homa_rpc *crpc1, *crpc2, *crpc3, *crpc4; + atomic64_set(&self->homa.next_outgoing_id, 3); - struct homa_rpc *crpc1 = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id, 10000, 1000); + crpc1 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id, + 10000, 1000); atomic64_set(&self->homa.next_outgoing_id, 3 + 3*HOMA_CLIENT_RPC_BUCKETS); - struct homa_rpc *crpc2 = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id+2, 10000, 1000); + crpc2 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id+2, + 10000, 1000); atomic64_set(&self->homa.next_outgoing_id, 3 + 10*HOMA_CLIENT_RPC_BUCKETS); - struct homa_rpc *crpc3 = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id+4, 10000, 1000); + crpc3 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id+4, + 10000, 1000); atomic64_set(&self->homa.next_outgoing_id, 40); - struct homa_rpc *crpc4 = unit_client_rpc(&self->hsk, - UNIT_OUTGOING, self->client_ip, self->server_ip, - self->server_port, self->client_id+6, 10000, 1000); + crpc4 = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, + self->server_ip, self->server_port, self->client_id+6, + 10000, 1000); EXPECT_EQ(crpc1, homa_find_client_rpc(&self->hsk, crpc1->id)); homa_rpc_unlock(crpc1); @@ -636,20 +690,21 @@ TEST_F(homa_rpc, homa_find_server_rpc) struct homa_rpc *srpc1 = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, self->server_id, 10000, 100); - ASSERT_NE(NULL, srpc1); struct homa_rpc *srpc2 = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port, self->server_id + 30*HOMA_SERVER_RPC_BUCKETS, 10000, 100); - ASSERT_NE(NULL, srpc2); struct homa_rpc *srpc3 = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port+1, self->server_id + 10*HOMA_SERVER_RPC_BUCKETS, 10000, 100); - ASSERT_NE(NULL, srpc3); struct homa_rpc *srpc4 = unit_server_rpc(&self->hsk, UNIT_RCVD_ONE_PKT, self->client_ip, self->server_ip, self->client_port+1, self->server_id + 4, 10000, 100); + + ASSERT_NE(NULL, srpc1); + ASSERT_NE(NULL, srpc2); + ASSERT_NE(NULL, srpc3); ASSERT_NE(NULL, srpc4); EXPECT_EQ(srpc1, homa_find_server_rpc(&self->hsk, self->client_ip, self->client_port, srpc1->id)); diff --git a/test/unit_homa_skb.c b/test/unit_homa_skb.c index 4cfc242..69bf274 100644 --- a/test/unit_homa_skb.c +++ b/test/unit_homa_skb.c @@ -20,9 +20,8 @@ static inline struct homa_skb_core *get_skb_core(int core) */ static struct sk_buff *test_skb(struct homa *homa) { - struct sk_buff *skb = homa_skb_new_tx(100); struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); - + struct sk_buff *skb = homa_skb_new_tx(100); int32_t data[1000]; char *src; int i; @@ -56,6 +55,7 @@ static void add_to_pool(struct homa *homa, int num_pages, int core) { struct homa_page_pool *pool = get_skb_core(core)->pool; int i; + for (i = 0; i < num_pages; i++) { pool->pages[pool->avail] = alloc_pages(GFP_KERNEL, HOMA_SKB_PAGE_ORDER); @@ -114,6 +114,7 @@ TEST_F(homa_skb, homa_skb_init) TEST_F(homa_skb, homa_skb_cleanup) { struct homa_skb_core *skb_core = get_skb_core(2); + skb_core->skb_page = alloc_pages(GFP_KERNEL, 2); add_to_pool(&self->homa, 5, 2); add_to_pool(&self->homa, 4, 3); @@ -135,7 +136,9 @@ TEST_F(homa_skb, homa_skb_cleanup) TEST_F(homa_skb, homa_skb_stash_pages) { int id = raw_smp_processor_id(); - struct homa_skb_core *skb_core = get_skb_core(id); + struct homa_skb_core *skb_core; + + skb_core = get_skb_core(id); add_to_pool(&self->homa, 5, id); EXPECT_EQ(5, skb_core->pool->avail); EXPECT_EQ(0, skb_core->num_stashed_pages); @@ -161,18 +164,20 @@ TEST_F(homa_skb, homa_skb_stash_pages) TEST_F(homa_skb, homa_skb_extend_frags__basics) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); + char *p1, *p2, *p3; int length = 100; - char *p1 = homa_skb_extend_frags(&self->homa, self->skb, &length); + + p1 = homa_skb_extend_frags(&self->homa, self->skb, &length); EXPECT_EQ(100, length); EXPECT_NE(NULL, p1); length = 200; - char *p2 = homa_skb_extend_frags(&self->homa, self->skb, &length); + p2 = homa_skb_extend_frags(&self->homa, self->skb, &length); EXPECT_EQ(200, length); EXPECT_EQ(p1 + 100, p2); length = 300; - char *p3 = homa_skb_extend_frags(&self->homa, self->skb, &length); + p3 = homa_skb_extend_frags(&self->homa, self->skb, &length); EXPECT_EQ(300, length); EXPECT_EQ(p2 + 200, p3); @@ -183,13 +188,15 @@ TEST_F(homa_skb, homa_skb_extend_frags__merge_but_reduce_length) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); int length = 1000; - char *p1 = homa_skb_extend_frags(&self->homa, self->skb, &length); + char *p1, *p2; + + p1 = homa_skb_extend_frags(&self->homa, self->skb, &length); EXPECT_EQ(1000, length); EXPECT_NE(NULL, p1); skb_core->page_size = 2048; length = 2000; - char *p2 = homa_skb_extend_frags(&self->homa, self->skb, &length); + p2 = homa_skb_extend_frags(&self->homa, self->skb, &length); EXPECT_EQ(1048, length); EXPECT_EQ(p1 + 1000, p2); @@ -199,23 +206,24 @@ TEST_F(homa_skb, homa_skb_extend_frags__cant_merge_allocate_new_page) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); struct sk_buff *skb2 = alloc_skb_fclone(200, GFP_KERNEL); - ASSERT_NE(NULL, skb2); + char *p1, *p2, *p3; + ASSERT_NE(NULL, skb2); int length = 1000; - char *p1 = homa_skb_extend_frags(&self->homa, self->skb, &length); + p1 = homa_skb_extend_frags(&self->homa, self->skb, &length); EXPECT_EQ(1000, length); EXPECT_NE(NULL, p1); EXPECT_EQ(1000, self->skb->len); skb_core->page_size = 2048; length = 1000; - char *p2 = homa_skb_extend_frags(&self->homa, skb2, &length); + p2 = homa_skb_extend_frags(&self->homa, skb2, &length); EXPECT_EQ(1000, length); EXPECT_EQ(p1 + 1024, p2); EXPECT_EQ(1000, skb2->len); length = 1000; - char *p3 = homa_skb_extend_frags(&self->homa, self->skb, &length); + p3 = homa_skb_extend_frags(&self->homa, self->skb, &length); EXPECT_NE(NULL, p3); EXPECT_EQ(1000, length); EXPECT_EQ(2, skb_shinfo(self->skb)->nr_frags); @@ -229,21 +237,22 @@ TEST_F(homa_skb, homa_skb_extend_frags__cant_merge_use_same_page_reduce_length) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); struct sk_buff *skb2 = alloc_skb_fclone(200, GFP_KERNEL); - ASSERT_NE(NULL, skb2); + char *p1, *p2, *p3; + ASSERT_NE(NULL, skb2); int length = 1000; - char *p1 = homa_skb_extend_frags(&self->homa, self->skb, &length); + p1 = homa_skb_extend_frags(&self->homa, self->skb, &length); EXPECT_EQ(1000, length); EXPECT_NE(NULL, p1); skb_core->page_size = 2048; length = 500; - char *p2 = homa_skb_extend_frags(&self->homa, skb2, &length); + p2 = homa_skb_extend_frags(&self->homa, skb2, &length); EXPECT_EQ(500, length); EXPECT_EQ(p1 + 1024, p2); length = 2000; - char *p3 = homa_skb_extend_frags(&self->homa, self->skb, &length); + p3 = homa_skb_extend_frags(&self->homa, self->skb, &length); EXPECT_EQ(p2 + 512, p3); EXPECT_EQ(512, length); EXPECT_EQ(2, skb_shinfo(self->skb)->nr_frags); @@ -257,6 +266,7 @@ TEST_F(homa_skb, homa_skb_page_alloc__free_previous_page) { struct homa_skb_core *skb_core = get_skb_core(2); struct page *old_page; + EXPECT_TRUE(homa_skb_page_alloc(&self->homa, skb_core)); EXPECT_NE(NULL, skb_core->skb_page); old_page = skb_core->skb_page; @@ -274,6 +284,7 @@ TEST_F(homa_skb, homa_skb_page_alloc__reuse_existing_page) struct sk_buff *skb = homa_skb_new_tx(100); struct page *page; int length = 100; + homa_skb_extend_frags(&self->homa, skb, &length); EXPECT_EQ(100, skb_core->page_inuse); page = skb_core->skb_page; @@ -287,6 +298,7 @@ TEST_F(homa_skb, homa_skb_page_alloc__reuse_existing_page) TEST_F(homa_skb, homa_skb_page_alloc__from_stash) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); + add_to_pool(&self->homa, 5, raw_smp_processor_id()); homa_skb_stash_pages(&self->homa, 3*HOMA_SKB_PAGE_SIZE - 100); EXPECT_TRUE(homa_skb_page_alloc(&self->homa, skb_core)); @@ -298,6 +310,7 @@ TEST_F(homa_skb, homa_skb_page_alloc__from_stash) TEST_F(homa_skb, homa_skb_page_alloc__from_pool) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); + add_to_pool(&self->homa, 5, raw_smp_processor_id()); EXPECT_EQ(5, skb_core->pool->avail); EXPECT_EQ(0, skb_core->num_stashed_pages); @@ -308,6 +321,7 @@ TEST_F(homa_skb, homa_skb_page_alloc__from_pool) TEST_F(homa_skb, homa_skb_page_alloc__pool_page_taken_while_locking) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); + add_to_pool(&self->homa, 1, raw_smp_processor_id()); EXPECT_EQ(1, skb_core->pool->avail); EXPECT_EQ(0, skb_core->num_stashed_pages); @@ -322,6 +336,7 @@ TEST_F(homa_skb, homa_skb_page_alloc__pool_page_taken_while_locking) TEST_F(homa_skb, homa_skb_page_alloc__new_large_page) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); + mock_cycles = ~0; EXPECT_EQ(0, skb_core->pool->avail); EXPECT_EQ(0, skb_core->num_stashed_pages); @@ -334,6 +349,7 @@ TEST_F(homa_skb, homa_skb_page_alloc__new_large_page) TEST_F(homa_skb, homa_skb_page_alloc__high_order_page_not_available) { struct homa_skb_core *skb_core = get_skb_core(2); + mock_cycles = ~0; mock_alloc_page_errors = 1; EXPECT_TRUE(homa_skb_page_alloc(&self->homa, skb_core)); @@ -347,6 +363,7 @@ TEST_F(homa_skb, homa_skb_page_alloc__high_order_page_not_available) TEST_F(homa_skb, homa_skb_page_alloc__no_pages_available) { struct homa_skb_core *skb_core = get_skb_core(2); + mock_alloc_page_errors = 3; EXPECT_FALSE(homa_skb_page_alloc(&self->homa, skb_core)); EXPECT_EQ(NULL, skb_core->skb_page); @@ -356,6 +373,7 @@ TEST_F(homa_skb, homa_skb_append_to_frag__basics) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); struct skb_shared_info *shinfo = skb_shinfo(self->skb); + char *p; /* First append fits in a single block. */ EXPECT_EQ(0, homa_skb_append_to_frag(&self->homa, self->skb, "abcd", 4)); @@ -367,7 +385,7 @@ TEST_F(homa_skb, homa_skb_append_to_frag__basics) EXPECT_EQ(2, shinfo->nr_frags); EXPECT_EQ(10, skb_frag_size(&shinfo->frags[0])); - char *p = ((char *) page_address(skb_frag_page(&shinfo->frags[0]))) + p = ((char *) page_address(skb_frag_page(&shinfo->frags[0]))) + shinfo->frags[0].offset; p[skb_frag_size(&shinfo->frags[0])] = 0; EXPECT_STREQ("abcd012345", p); @@ -387,8 +405,8 @@ TEST_F(homa_skb, homa_skb_append_to_frag__no_memory) TEST_F(homa_skb, homa_skb_append_from_iter__basics) { struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); - struct skb_shared_info *shinfo = skb_shinfo(self->skb); struct iov_iter *iter = unit_iov_iter((void *) 1000, 5000); + struct skb_shared_info *shinfo = skb_shinfo(self->skb); /* First append fits in a single block. */ unit_log_clear(); @@ -413,6 +431,7 @@ TEST_F(homa_skb, homa_skb_append_from_iter__basics) TEST_F(homa_skb, homa_skb_append_from_iter__no_memory) { struct iov_iter *iter = unit_iov_iter((void *)1000, 5000); + mock_alloc_page_errors = 3; EXPECT_EQ(ENOMEM, -homa_skb_append_from_iter(&self->homa, self->skb, iter, 2000)); @@ -436,9 +455,9 @@ TEST_F(homa_skb, homa_skb_append_from_skb__header_only) } TEST_F(homa_skb, homa_skb_append_from_skb__error_copying_header) { + struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); struct sk_buff *src_skb = test_skb(&self->homa); struct sk_buff *dst_skb = homa_skb_new_tx(100); - struct homa_skb_core *skb_core = get_skb_core(raw_smp_processor_id()); mock_alloc_page_errors = -1; skb_core->page_inuse = skb_core->page_size; @@ -452,9 +471,10 @@ TEST_F(homa_skb, homa_skb_append_from_skb__header_and_first_frag) { struct sk_buff *src_skb = test_skb(&self->homa); struct sk_buff *dst_skb = homa_skb_new_tx(100); - struct skb_shared_info *dst_shinfo = skb_shinfo(dst_skb); + struct skb_shared_info *dst_shinfo; int32_t data[500]; + dst_shinfo = skb_shinfo(dst_skb); EXPECT_EQ(0, homa_skb_append_from_skb(&self->homa, dst_skb, src_skb, 80, 100)); memset(data, 0, sizeof(data)); @@ -471,9 +491,10 @@ TEST_F(homa_skb, homa_skb_append_from_skb__multiple_frags) { struct sk_buff *src_skb = test_skb(&self->homa); struct sk_buff *dst_skb = homa_skb_new_tx(100); - struct skb_shared_info *dst_shinfo = skb_shinfo(dst_skb); + struct skb_shared_info *dst_shinfo; int32_t data[500]; + dst_shinfo = skb_shinfo(dst_skb); EXPECT_EQ(0, homa_skb_append_from_skb(&self->homa, dst_skb, src_skb, 320, 600)); memset(data, 0, sizeof(data)); @@ -490,9 +511,10 @@ TEST_F(homa_skb, homa_skb_append_from_skb__dst_runs_out_of_frags) { struct sk_buff *src_skb = test_skb(&self->homa); struct sk_buff *dst_skb = homa_skb_new_tx(100); - struct skb_shared_info *dst_shinfo = skb_shinfo(dst_skb); + struct skb_shared_info *dst_shinfo; int i, err; + dst_shinfo = skb_shinfo(dst_skb); mock_max_skb_frags = 4; for (i = 0; i < 10; i++) { err = homa_skb_append_from_skb(&self->homa, dst_skb, src_skb, @@ -530,8 +552,8 @@ TEST_F(homa_skb, homa_skb_free_many_tx__basics) TEST_F(homa_skb, homa_skb_free_many_tx__skb_ref_count_not_one) { struct sk_buff *skb; - int length; struct page *page; + int length; skb = homa_skb_new_tx(100); length = HOMA_SKB_PAGE_SIZE; @@ -571,6 +593,7 @@ TEST_F(homa_skb, homa_skb_cache_pages__different_numa_nodes) { struct page *pages[4]; int i; + for (i = 0; i < 4; i++) pages[i] = alloc_pages(GFP_KERNEL, HOMA_SKB_PAGE_ORDER); mock_page_nid_mask = 7; @@ -584,6 +607,7 @@ TEST_F(homa_skb, homa_skb_cache_pages__pool_size_exceeded) { struct page *pages[6]; int i; + for (i = 0; i < 6; i++) pages[i] = alloc_pages(GFP_KERNEL, HOMA_SKB_PAGE_ORDER); homa_skb_cache_pages(&self->homa, pages, 4); diff --git a/test/unit_homa_sock.c b/test/unit_homa_sock.c index e18a37f..54cb5b7 100644 --- a/test/unit_homa_sock.c +++ b/test/unit_homa_sock.c @@ -48,6 +48,7 @@ TEST_F(homa_sock, homa_port_hash) TEST_F(homa_sock, homa_socktab_start_scan) { struct homa_socktab_scan scan; + homa_destroy(&self->homa); homa_init(&self->homa); mock_sock_init(&self->hsk, &self->homa, HOMA_MIN_DEFAULT_PORT+100); @@ -60,6 +61,7 @@ TEST_F(homa_sock, homa_socktab_next__basics) { struct homa_sock hsk1, hsk2, hsk3, hsk4, *hsk; struct homa_socktab_scan scan; + int first_port = 34000; homa_destroy(&self->homa); homa_init(&self->homa); @@ -87,6 +89,7 @@ TEST_F(homa_sock, homa_socktab_next__deleted_socket) struct homa_sock hsk1, hsk2, hsk3, *hsk; struct homa_socktab_scan scan; int first_port = 34000; + homa_destroy(&self->homa); homa_init(&self->homa); mock_sock_init(&hsk1, &self->homa, first_port); @@ -109,6 +112,7 @@ TEST_F(homa_sock, homa_socktab_next__deleted_socket) TEST_F(homa_sock, homa_sock_init__skip_port_in_use) { struct homa_sock hsk2, hsk3; + self->homa.next_client_port = 0xffff; mock_sock_init(&hsk2, &self->homa, 0); mock_sock_init(&hsk3, &self->homa, 0); @@ -120,6 +124,7 @@ TEST_F(homa_sock, homa_sock_init__skip_port_in_use) TEST_F(homa_sock, homa_sock_init__ip_header_length) { struct homa_sock hsk_v4, hsk_v6; + mock_ipv6 = false; mock_sock_init(&hsk_v4, &self->homa, 0); mock_ipv6 = true; @@ -132,6 +137,7 @@ TEST_F(homa_sock, homa_sock_init__ip_header_length) TEST_F(homa_sock, homa_sock_init__hijack_tcp) { struct homa_sock hijack, no_hijack; + self->homa.hijack_tcp = 0; mock_sock_init(&no_hijack, &self->homa, 0); self->homa.hijack_tcp = 1; @@ -144,8 +150,9 @@ TEST_F(homa_sock, homa_sock_init__hijack_tcp) TEST_F(homa_sock, homa_sock_shutdown__basics) { - int client2, client3; struct homa_sock hsk2, hsk3; + int client2, client3; + mock_sock_init(&hsk2, &self->homa, 0); EXPECT_EQ(0, homa_sock_bind(self->homa.port_map, &hsk2, 100)); client2 = hsk2.port; @@ -198,6 +205,7 @@ TEST_F(homa_sock, homa_sock_shutdown__wakeup_interests) { struct homa_interest interest1, interest2, interest3; struct task_struct task1, task2, task3; + interest1.thread = &task1; task1.pid = 100; interest2.thread = &task2; @@ -218,6 +226,7 @@ TEST_F(homa_sock, homa_sock_shutdown__wakeup_interests) TEST_F(homa_sock, homa_sock_bind) { struct homa_sock hsk2; + mock_sock_init(&hsk2, &self->homa, 0); EXPECT_EQ(0, homa_sock_bind(self->homa.port_map, &hsk2, 100)); @@ -251,6 +260,7 @@ TEST_F(homa_sock, homa_sock_bind__socket_shutdown) TEST_F(homa_sock, homa_sock_find__basics) { struct homa_sock hsk2; + mock_sock_init(&hsk2, &self->homa, 0); EXPECT_EQ(0, homa_sock_bind(self->homa.port_map, &hsk2, 100)); EXPECT_EQ(&self->hsk, homa_sock_find(self->homa.port_map, @@ -265,6 +275,7 @@ TEST_F(homa_sock, homa_sock_find__basics) TEST_F(homa_sock, homa_sock_find__long_hash_chain) { struct homa_sock hsk2, hsk3, hsk4; + EXPECT_EQ(0, homa_sock_bind(self->homa.port_map, &self->hsk, 13)); mock_sock_init(&hsk2, &self->homa, 0); EXPECT_EQ(0, homa_sock_bind(self->homa.port_map, &hsk2, diff --git a/test/unit_homa_timer.c b/test/unit_homa_timer.c index 090754a..b552ce6 100644 --- a/test/unit_homa_timer.c +++ b/test/unit_homa_timer.c @@ -51,6 +51,7 @@ TEST_F(homa_timer, homa_check_rpc__request_ack) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->client_port, self->server_id, 100, 100); + ASSERT_NE(NULL, srpc); self->homa.request_ack_ticks = 2; @@ -84,6 +85,7 @@ TEST_F(homa_timer, homa_check_rpc__all_granted_bytes_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, 5000); + ASSERT_NE(NULL, crpc); unit_log_clear(); crpc->msgin.granted = 1400; @@ -97,6 +99,7 @@ TEST_F(homa_timer, homa_check_rpc__no_buffer_space) 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, 5000); + ASSERT_NE(NULL, crpc); unit_log_clear(); crpc->msgin.num_bpages = 0; @@ -110,6 +113,7 @@ TEST_F(homa_timer, homa_check_rpc__server_has_received_request) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 100, 100); + ASSERT_NE(NULL, srpc); unit_log_clear(); srpc->silent_ticks = 10; @@ -122,6 +126,7 @@ TEST_F(homa_timer, homa_check_rpc__granted_bytes_not_sent) struct homa_rpc *crpc = unit_client_rpc(&self->hsk, UNIT_OUTGOING, self->client_ip, self->server_ip, self->server_port, self->client_id, 5000, 200); + ASSERT_NE(NULL, crpc); unit_log_clear(); crpc->silent_ticks = 10; @@ -134,6 +139,7 @@ TEST_F(homa_timer, homa_check_rpc__timeout) 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, 200, 10000); + ASSERT_NE(NULL, crpc); unit_log_clear(); crpc->silent_ticks = self->homa.timeout_ticks-1; @@ -150,6 +156,7 @@ TEST_F(homa_timer, homa_check_rpc__issue_resend) 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, 200, 10000); + ASSERT_NE(NULL, crpc); crpc->msgin.granted = 5000; self->homa.resend_ticks = 3; @@ -185,6 +192,7 @@ TEST_F(homa_timer, homa_check_rpc__request_first_bytes_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, 5000, 10000); + ASSERT_NE(NULL, crpc); crpc->msgout.granted = 5000; crpc->msgout.next_xmit_offset = 5000; @@ -207,6 +215,7 @@ TEST_F(homa_timer, homa_check_rpc__call_homa_gap_retry) 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, 200, 20000); + ASSERT_NE(NULL, crpc); crpc->silent_ticks = 3; crpc->msgin.granted = 10000; @@ -223,13 +232,14 @@ TEST_F(homa_timer, homa_check_rpc__call_homa_gap_retry) TEST_F(homa_timer, homa_timer__basics) { - self->homa.timeout_ticks = 5; - self->homa.resend_ticks = 3; - self->homa.resend_interval = 2; 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, 200, 5000); + ASSERT_NE(NULL, crpc); + self->homa.timeout_ticks = 5; + self->homa.resend_ticks = 3; + self->homa.resend_interval = 2; unit_log_clear(); crpc->silent_ticks = 1; homa_timer(&self->homa); @@ -260,6 +270,7 @@ TEST_F(homa_timer, homa_timer__reap_dead_rpcs) struct homa_rpc *dead = unit_client_rpc(&self->hsk, UNIT_RCVD_MSG, self->client_ip, self->server_ip, self->server_port, self->client_id, 40000, 1000); + ASSERT_NE(NULL, dead); homa_rpc_free(dead); EXPECT_EQ(31, self->hsk.dead_skbs); @@ -279,6 +290,7 @@ TEST_F(homa_timer, homa_timer__rpc_in_service) struct homa_rpc *srpc = unit_server_rpc(&self->hsk, UNIT_IN_SERVICE, self->client_ip, self->server_ip, self->client_port, self->server_id, 5000, 5000); + ASSERT_NE(NULL, srpc); unit_log_clear(); homa_timer(&self->homa); diff --git a/test/unit_homa_utils.c b/test/unit_homa_utils.c index 66f9bd9..8bebb8b 100644 --- a/test/unit_homa_utils.c +++ b/test/unit_homa_utils.c @@ -54,12 +54,12 @@ static void set_cutoffs(struct homa *homa, int c0, int c1, int c2, TEST_F(homa_utils, homa_print_ipv4_addr) { - char *p1, *p2; - int i; - struct in6_addr test_addr1 = unit_get_in_addr("192.168.0.1"); struct in6_addr test_addr2 = unit_get_in_addr("1.2.3.4"); struct in6_addr test_addr3 = unit_get_in_addr("5.6.7.8"); + char *p1, *p2; + int i; + p1 = homa_print_ipv6_addr(&test_addr1); p2 = homa_print_ipv6_addr(&test_addr2); EXPECT_STREQ("192.168.0.1", p1); @@ -75,6 +75,7 @@ TEST_F(homa_utils, homa_snprintf) { char buffer[50]; int used = 0; + used = homa_snprintf(buffer, sizeof32(buffer), used, "Test message with values: %d and %d", 100, 1000); EXPECT_EQ(38, used); diff --git a/test/unit_timetrace.c b/test/unit_timetrace.c index 650e96e..4bb24fa 100644 --- a/test/unit_timetrace.c +++ b/test/unit_timetrace.c @@ -45,6 +45,7 @@ TEST_F(timetrace, tt_freeze) TEST_F(timetrace, tt_record__basics) { char buffer[1000]; + memset(buffer, 0, sizeof(buffer)); tt_record("Message with no args"); mock_cycles++; @@ -69,6 +70,7 @@ TEST_F(timetrace, tt_record__basics) TEST_F(timetrace, tt_record_buf__wraparound) { char buffer[100]; + memset(buffer, 0, sizeof(buffer)); tt_buffer_size = 4; tt_record("Message 1"); @@ -91,8 +93,8 @@ TEST_F(timetrace, tt_record_buf__wraparound) TEST_F(timetrace, tt_find_oldest) { int pos[nr_cpu_ids]; - tt_buffer_size = 4; + tt_buffer_size = 4; tt_record_buf(tt_buffers[0], 1500, "Buf0", 0, 0, 0, 0); tt_record_buf(tt_buffers[0], 1600, "Buf0", 0, 0, 0, 0); tt_record_buf(tt_buffers[0], 1700, "Buf0", 0, 0, 0, 0); @@ -138,6 +140,7 @@ TEST_F(timetrace, tt_proc_open__increment_frozen) TEST_F(timetrace, tt_proc_read__bogus_file) { struct tt_proc_file pf; + pf.file = NULL; int err = -tt_proc_read(&self->file, (char *) 1000, 100, 0); EXPECT_EQ(EINVAL, err); @@ -156,6 +159,7 @@ TEST_F(timetrace, tt_proc_read__uninitialized) TEST_F(timetrace, tt_proc_read__nothing_to_read) { char buffer[1000]; + memset(buffer, 0, sizeof(buffer)); buffer[0] = 0; tt_proc_open(NULL, &self->file); @@ -166,6 +170,7 @@ TEST_F(timetrace, tt_proc_read__nothing_to_read) TEST_F(timetrace, tt_proc_read__leftovers) { char buffer[1000]; + memset(buffer, 0, sizeof(buffer)); tt_pf_storage = 100; tt_record_buf(tt_buffers[0], 1000, @@ -190,6 +195,7 @@ TEST_F(timetrace, tt_proc_read__leftovers) TEST_F(timetrace, tt_proc_read__sort_events_by_time) { char buffer[1000]; + memset(buffer, 0, sizeof(buffer)); tt_record_buf(tt_buffers[0], 1000, "Buf0", 0, 0, 0, 0); tt_record_buf(tt_buffers[0], 1100, "Buf0", 0, 0, 0, 0); @@ -217,6 +223,7 @@ TEST_F(timetrace, tt_proc_read__sort_events_by_time) TEST_F(timetrace, tt_proc_read__event_barely_fits_in_buffer) { char buffer[1000]; + memset(buffer, 0, sizeof(buffer)); tt_pf_storage = 25; tt_record_buf(tt_buffers[0], 1000, @@ -235,6 +242,7 @@ TEST_F(timetrace, tt_proc_read__event_barely_fits_in_buffer) TEST_F(timetrace, tt_proc_read__single_entry_too_large) { char buffer[1000]; + memset(buffer, 0, sizeof(buffer)); tt_pf_storage = 20; tt_record_buf(tt_buffers[0], 1000, @@ -248,6 +256,7 @@ TEST_F(timetrace, tt_proc_read__single_entry_too_large) TEST_F(timetrace, tt_proc_release__bogus_file) { struct tt_proc_file pf; + pf.file = NULL; int err = -tt_proc_release(NULL, &self->file); EXPECT_EQ(EINVAL, err); diff --git a/timetrace.c b/timetrace.c index fdac629..15f490a 100644 --- a/timetrace.c +++ b/timetrace.c @@ -283,8 +283,8 @@ void tt_record_buf(struct tt_buffer *buffer, __u64 timestamp, void tt_find_oldest(int *pos) { struct tt_buffer *buffer; - int i; __u64 start_time = 0; + int i; for (i = 0; i < nr_cpu_ids; i++) { buffer = tt_buffers[i]; @@ -370,11 +370,12 @@ int tt_proc_open(struct inode *inode, struct file *file) ssize_t tt_proc_read(struct file *file, char __user *user_buf, size_t length, loff_t *offset) { + struct tt_proc_file *pf = file->private_data; + /* # bytes of data that have accumulated in pf->msg_storage but * haven't been copied to user space yet. */ int copied_to_user = 0; - struct tt_proc_file *pf = file->private_data; spin_lock(&tt_lock); if ((pf == NULL) || (pf->file != file)) { @@ -499,8 +500,8 @@ loff_t tt_proc_lseek(struct file *file, loff_t offset, int whence) */ int tt_proc_release(struct inode *inode, struct file *file) { - int i; struct tt_proc_file *pf = file->private_data; + int i; if ((pf == NULL) || (pf->file != file)) { pr_err("tt_metrics_release found damaged private_data: 0x%p\n", @@ -550,6 +551,10 @@ int tt_proc_release(struct inode *inode, struct file *file) */ void tt_print_file(char *path) { + /* Static buffer for accumulating output data. */ + static char buffer[10000]; + struct file *filp = NULL; + /* Index of the next entry to return from each tt_buffer. * This array is too large to allocate on the stack, and we don't * want to allocate space dynamically (this function could be @@ -559,13 +564,9 @@ void tt_print_file(char *path) */ static int pos[NR_CPUS]; static atomic_t active; - struct file *filp = NULL; - int err; - - /* Also use a static buffer for accumulating output data. */ - static char buffer[10000]; int bytes_used = 0; loff_t offset = 0; + int err; if (atomic_xchg(&active, 1)) { pr_err("concurrent call to %s aborting\n", __func__); @@ -591,10 +592,10 @@ void tt_print_file(char *path) /* Each iteration of this loop printk's one event. */ while (true) { + __u64 earliest_time = ~0; struct tt_event *event; - int i; int current_core = -1; - __u64 earliest_time = ~0; + int i; /* Check all the traces to find the earliest available event. */ for (i = 0; i < nr_cpu_ids; i++) { @@ -691,11 +692,11 @@ void tt_printk(void) /* Each iteration of this loop printk's one event. */ while (true) { + __u64 earliest_time = ~0; struct tt_event *event; - int i; int current_core = -1; - __u64 earliest_time = ~0; char msg[200]; + int i; /* Check all the traces to find the earliest available event. */ for (i = 0; i < nr_cpu_ids; i++) { @@ -752,10 +753,10 @@ void tt_get_messages(char *buffer, size_t length) /* Each iteration of this loop prints one event. */ while (true) { + __u64 earliest_time = ~0; struct tt_event *event; - int i, result; int current_core = -1; - __u64 earliest_time = ~0; + int i, result; /* Check all the traces to find the earliest available event. */ for (i = 0; i < nr_cpu_ids; i++) {