From d9969b8c5892eac3f01c1c02f640931f673f7798 Mon Sep 17 00:00:00 2001 From: Tianling Shen Date: Tue, 2 Mar 2021 21:01:25 +0800 Subject: [PATCH 1/8] kernel: 4.14: backport tcp_bbr fixes Pulled from: https://github.com/GZR-Kernels/Optimus_Drunk_Phoenix/commits/4d43b58a4f987282c62e43fee39f37dedaa08d71 Compile-tested on: x86_64 Signed-off-by: Tianling Shen --- ...-RTT-overestimation-from-delayed-ACK.patch | 80 +++ ...loat-by-skipping-R-from-delayed-K-in.patch | 60 ++ ...r-better-deal-with-suboptimal-GSO-II.patch | 138 ++++ ...004-tcp_bbr-remove-bbr-tso_segs_goal.patch | 76 +++ ...nd_ssthresh-to-BDP-upon-STARTUP-exit.patch | 49 ++ ...-bbr-pacing-rate-for-internal-pacing.patch | 88 +++ ...-add-bbr_check_probe_rtt_done-helper.patch | 98 +++ ...art-from-idle,-see-if-we-should-exit.patch | 43 ++ ...-PROBE_RTT-cwnd-cap-even-if-acked==0.patch | 41 ++ ...tcp_bbr-centralize-code-to-set-gains.patch | 112 ++++ ...target_cwnd-for-general-inflight-pro.patch | 144 +++++ ...-based-on-ack-aggregation-estimation.patch | 262 ++++++++ ...-based-on-ack-aggregation-estimation.patch | 611 ------------------ 13 files changed, 1191 insertions(+), 611 deletions(-) create mode 100644 target/linux/generic/backport-4.14/605-0001-tcp-avoid-min-RTT-overestimation-from-delayed-ACK.patch create mode 100644 target/linux/generic/backport-4.14/605-0002-tcp-avoid-min-R-bloat-by-skipping-R-from-delayed-K-in.patch create mode 100644 target/linux/generic/backport-4.14/605-0003-tcp_bbr-better-deal-with-suboptimal-GSO-II.patch create mode 100644 target/linux/generic/backport-4.14/605-0004-tcp_bbr-remove-bbr-tso_segs_goal.patch create mode 100644 target/linux/generic/backport-4.14/605-0005-net-tcp_bbr-set-tp-snd_ssthresh-to-BDP-upon-STARTUP-exit.patch create mode 100644 target/linux/generic/backport-4.14/605-0006-tcp_bbr-fix-bbr-pacing-rate-for-internal-pacing.patch create mode 100644 target/linux/generic/backport-4.14/605-0007-tcp_bbr-add-bbr_check_probe_rtt_done-helper.patch create mode 100644 target/linux/generic/backport-4.14/605-0008-tcp_bbr-in-restart-from-idle,-see-if-we-should-exit.patch create mode 100644 target/linux/generic/backport-4.14/605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked==0.patch create mode 100644 target/linux/generic/backport-4.14/605-0010-tcp_bbr-centralize-code-to-set-gains.patch create mode 100644 target/linux/generic/backport-4.14/605-0011-tcp_bbr-refactor-bbr_target_cwnd-for-general-inflight-pro.patch create mode 100644 target/linux/generic/backport-4.14/605-0012-tcp_bbr-adapt-cwnd-based-on-ack-aggregation-estimation.patch delete mode 100644 target/linux/generic/pending-4.14/607-tcp_bbr-adapt-cwnd-based-on-ack-aggregation-estimation.patch diff --git a/target/linux/generic/backport-4.14/605-0001-tcp-avoid-min-RTT-overestimation-from-delayed-ACK.patch b/target/linux/generic/backport-4.14/605-0001-tcp-avoid-min-RTT-overestimation-from-delayed-ACK.patch new file mode 100644 index 0000000000..151ec1e66b --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0001-tcp-avoid-min-RTT-overestimation-from-delayed-ACK.patch @@ -0,0 +1,80 @@ +From 2a1bc5c57c50a519b02a0a4a827d943db3c0902f Mon Sep 17 00:00:00 2001 +From: Yuchung Cheng +Date: Wed, 17 Jan 2018 12:11:00 -0800 +Subject: [PATCH] tcp: avoid min-RTT overestimation from delayed ACKs + +This patch avoids having TCP sender or congestion control +overestimate the min RTT by orders of magnitude. This happens when +all the samples in the windowed filter are one-packet transfer +like small request and health-check like chit-chat, which is farily +common for applications using persistent connections. This patch +tries to conservatively labels and skip RTT samples obtained from +this type of workload. + +Signed-off-by: Yuchung Cheng +Signed-off-by: Soheil Hassas Yeganeh +Acked-by: Neal Cardwell +Acked-by: Eric Dumazet +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + net/ipv4/tcp_input.c | 23 +++++++++++++++++++++-- + 1 file changed, 21 insertions(+), 2 deletions(-) + +--- a/net/ipv4/tcp_input.c ++++ b/net/ipv4/tcp_input.c +@@ -112,6 +112,7 @@ int sysctl_tcp_invalid_ratelimit __read_ + #define FLAG_SACK_RENEGING 0x2000 /* snd_una advanced to a sacked seq */ + #define FLAG_UPDATE_TS_RECENT 0x4000 /* tcp_replace_ts_recent() */ + #define FLAG_NO_CHALLENGE_ACK 0x8000 /* do not call tcp_send_challenge_ack() */ ++#define FLAG_ACK_MAYBE_DELAYED 0x10000 /* Likely a delayed ACK */ + + #define FLAG_ACKED (FLAG_DATA_ACKED|FLAG_SYN_ACKED) + #define FLAG_NOT_DUP (FLAG_DATA|FLAG_WIN_UPDATE|FLAG_ACKED) +@@ -2938,11 +2939,18 @@ static void tcp_fastretrans_alert(struct + *rexmit = REXMIT_LOST; + } + +-static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us) ++static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us, const int flag) + { + struct tcp_sock *tp = tcp_sk(sk); + u32 wlen = sysctl_tcp_min_rtt_wlen * HZ; + ++ if ((flag & FLAG_ACK_MAYBE_DELAYED) && rtt_us > tcp_min_rtt(tp)) { ++ /* If the remote keeps returning delayed ACKs, eventually ++ * the min filter would pick it up and overestimate the ++ * prop. delay when it expires. Skip suspected delayed ACKs. ++ */ ++ return; ++ } + minmax_running_min(&tp->rtt_min, wlen, tcp_jiffies32, + rtt_us ? : jiffies_to_usecs(1)); + } +@@ -2982,7 +2990,7 @@ static bool tcp_ack_update_rtt(struct so + * always taken together with ACK, SACK, or TS-opts. Any negative + * values will be skipped with the seq_rtt_us < 0 check above. + */ +- tcp_update_rtt_min(sk, ca_rtt_us); ++ tcp_update_rtt_min(sk, ca_rtt_us, flag); + tcp_rtt_estimator(sk, seq_rtt_us); + tcp_set_rto(sk); + +@@ -3203,6 +3211,17 @@ static int tcp_clean_rtx_queue(struct so + if (likely(first_ackt) && !(flag & FLAG_RETRANS_DATA_ACKED)) { + seq_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, first_ackt); + ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, last_ackt); ++ ++ if (pkts_acked == 1 && last_in_flight < tp->mss_cache && ++ last_in_flight && !prior_sacked && fully_acked && ++ sack->rate->prior_delivered + 1 == tp->delivered && ++ !(flag & (FLAG_CA_ALERT | FLAG_SYN_ACKED))) { ++ /* Conservatively mark a delayed ACK. It's typically ++ * from a lone runt packet over the round trip to ++ * a receiver w/o out-of-order or CE events. ++ */ ++ flag |= FLAG_ACK_MAYBE_DELAYED; ++ } + } + if (sack->first_sackt) { + sack_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, sack->first_sackt); diff --git a/target/linux/generic/backport-4.14/605-0002-tcp-avoid-min-R-bloat-by-skipping-R-from-delayed-K-in.patch b/target/linux/generic/backport-4.14/605-0002-tcp-avoid-min-R-bloat-by-skipping-R-from-delayed-K-in.patch new file mode 100644 index 0000000000..7c1cc326e9 --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0002-tcp-avoid-min-R-bloat-by-skipping-R-from-delayed-K-in.patch @@ -0,0 +1,60 @@ +From 6d6008138dcd01ff5489beb90b689da29d92d5b9 Mon Sep 17 00:00:00 2001 +From: Yuchung Cheng +Date: Wed, 17 Jan 2018 12:11:01 -0800 +Subject: [PATCH] tcp: avoid min RTT bloat by skipping RTT from delayed-ACK in + BBR + +A persistent connection may send tiny amount of data (e.g. health-check) +for a long period of time. BBR's windowed min RTT filter may only see +RTT samples from delayed ACKs causing BBR to grossly over-estimate +the path delay depending how much the ACK was delayed at the receiver. + +This patch skips RTT samples that are likely coming from delayed ACKs. Note +that it is possible the sender never obtains a valid measure to set the +min RTT. In this case BBR will continue to set cwnd to initial window +which seems fine because the connection is thin stream. + +Signed-off-by: Yuchung Cheng +Acked-by: Neal Cardwell +Acked-by: Soheil Hassas Yeganeh +Acked-by: Priyaranjan Jha +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + include/net/tcp.h | 1 + + net/ipv4/tcp_bbr.c | 3 ++- + net/ipv4/tcp_input.c | 1 + + 3 files changed, 4 insertions(+), 1 deletion(-) + +--- a/include/net/tcp.h ++++ b/include/net/tcp.h +@@ -998,6 +998,7 @@ struct rate_sample { + u32 prior_in_flight; /* in flight before this ACK */ + bool is_app_limited; /* is sample from packet with bubble in pipe? */ + bool is_retrans; /* is sample from retransmission? */ ++ bool is_ack_delayed; /* is this (likely) a delayed ACK? */ + }; + + struct tcp_congestion_ops { +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -769,7 +769,8 @@ static void bbr_update_min_rtt(struct so + filter_expired = after(tcp_jiffies32, + bbr->min_rtt_stamp + bbr_min_rtt_win_sec * HZ); + if (rs->rtt_us >= 0 && +- (rs->rtt_us < bbr->min_rtt_us || filter_expired)) { ++ (rs->rtt_us < bbr->min_rtt_us || ++ (filter_expired && !rs->is_ack_delayed))) { + bbr->min_rtt_us = rs->rtt_us; + bbr->min_rtt_stamp = tcp_jiffies32; + } +--- a/net/ipv4/tcp_input.c ++++ b/net/ipv4/tcp_input.c +@@ -3723,6 +3723,7 @@ static int tcp_ack(struct sock *sk, cons + + delivered = tp->delivered - delivered; /* freshly ACKed or SACKed */ + lost = tp->lost - lost; /* freshly marked lost */ ++ rs.is_ack_delayed = !!(flag & FLAG_ACK_MAYBE_DELAYED); + tcp_rate_gen(sk, delivered, lost, is_sack_reneg, sack_state.rate); + tcp_cong_control(sk, ack, delivered, flag, sack_state.rate); + tcp_xmit_recovery(sk, rexmit); diff --git a/target/linux/generic/backport-4.14/605-0003-tcp_bbr-better-deal-with-suboptimal-GSO-II.patch b/target/linux/generic/backport-4.14/605-0003-tcp_bbr-better-deal-with-suboptimal-GSO-II.patch new file mode 100644 index 0000000000..437bd91907 --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0003-tcp_bbr-better-deal-with-suboptimal-GSO-II.patch @@ -0,0 +1,138 @@ +From 1fbad3e6fe0e01f071941a5689fb5f72428ca31a Mon Sep 17 00:00:00 2001 +From: Eric Dumazet +Date: Wed, 28 Feb 2018 14:40:46 -0800 +Subject: [PATCH] tcp_bbr: better deal with suboptimal GSO (II) + +This is second part of dealing with suboptimal device gso parameters. +In first patch (350c9f484bde "tcp_bbr: better deal with suboptimal GSO") +we dealt with devices having low gso_max_segs + +Some devices lower gso_max_size from 64KB to 16 KB (r8152 is an example) + +In order to probe an optimal cwnd, we want BBR being not sensitive +to whatever GSO constraint a device can have. + +This patch removes tso_segs_goal() CC callback in favor of +min_tso_segs() for CC wanting to override sysctl_tcp_min_tso_segs + +Next patch will remove bbr->tso_segs_goal since it does not have +to be persistent. + +Signed-off-by: Eric Dumazet +Acked-by: Neal Cardwell +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + include/net/tcp.h | 6 ++---- + net/ipv4/tcp_bbr.c | 23 +++++++++++++---------- + net/ipv4/tcp_output.c | 15 ++++++++------- + 3 files changed, 23 insertions(+), 21 deletions(-) + +--- a/include/net/tcp.h ++++ b/include/net/tcp.h +@@ -551,8 +551,6 @@ __u32 cookie_v6_init_sequence(const stru + #endif + /* tcp_output.c */ + +-u32 tcp_tso_autosize(const struct sock *sk, unsigned int mss_now, +- int min_tso_segs); + void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss, + int nonagle); + int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs); +@@ -1025,8 +1023,8 @@ struct tcp_congestion_ops { + u32 (*undo_cwnd)(struct sock *sk); + /* hook for packet ack accounting (optional) */ + void (*pkts_acked)(struct sock *sk, const struct ack_sample *sample); +- /* suggest number of segments for each skb to transmit (optional) */ +- u32 (*tso_segs_goal)(struct sock *sk); ++ /* override sysctl_tcp_min_tso_segs */ ++ u32 (*min_tso_segs)(struct sock *sk); + /* returns the multiplier used in tcp_sndbuf_expand (optional) */ + u32 (*sndbuf_expand)(struct sock *sk); + /* call when packets are delivered to update cwnd and pacing rate, +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -261,23 +261,26 @@ static void bbr_set_pacing_rate(struct s + sk->sk_pacing_rate = rate; + } + +-/* Return count of segments we want in the skbs we send, or 0 for default. */ +-static u32 bbr_tso_segs_goal(struct sock *sk) ++/* override sysctl_tcp_min_tso_segs */ ++static u32 bbr_min_tso_segs(struct sock *sk) + { +- struct bbr *bbr = inet_csk_ca(sk); +- +- return bbr->tso_segs_goal; ++ return sk->sk_pacing_rate < (bbr_min_tso_rate >> 3) ? 1 : 2; + } + + static void bbr_set_tso_segs_goal(struct sock *sk) + { + struct tcp_sock *tp = tcp_sk(sk); + struct bbr *bbr = inet_csk_ca(sk); +- u32 min_segs; ++ u32 segs, bytes; ++ ++ /* Sort of tcp_tso_autosize() but ignoring ++ * driver provided sk_gso_max_size. ++ */ ++ bytes = min_t(u32, sk->sk_pacing_rate >> sk->sk_pacing_shift, ++ GSO_MAX_SIZE - 1 - MAX_TCP_HEADER); ++ segs = max_t(u32, bytes / tp->mss_cache, bbr_min_tso_segs(sk)); + +- min_segs = sk->sk_pacing_rate < (bbr_min_tso_rate >> 3) ? 1 : 2; +- bbr->tso_segs_goal = min(tcp_tso_autosize(sk, tp->mss_cache, min_segs), +- 0x7FU); ++ bbr->tso_segs_goal = min(segs, 0x7FU); + } + + /* Save "last known good" cwnd so we can restore it after losses or PROBE_RTT */ +@@ -941,7 +944,7 @@ static struct tcp_congestion_ops tcp_bbr + .undo_cwnd = bbr_undo_cwnd, + .cwnd_event = bbr_cwnd_event, + .ssthresh = bbr_ssthresh, +- .tso_segs_goal = bbr_tso_segs_goal, ++ .min_tso_segs = bbr_min_tso_segs, + .get_info = bbr_get_info, + .set_state = bbr_set_state, + }; +--- a/net/ipv4/tcp_output.c ++++ b/net/ipv4/tcp_output.c +@@ -1695,8 +1695,8 @@ static bool tcp_nagle_check(bool partial + /* Return how many segs we'd like on a TSO packet, + * to send one TSO packet per ms + */ +-u32 tcp_tso_autosize(const struct sock *sk, unsigned int mss_now, +- int min_tso_segs) ++static u32 tcp_tso_autosize(const struct sock *sk, unsigned int mss_now, ++ int min_tso_segs) + { + u32 bytes, segs; + +@@ -1712,7 +1712,6 @@ u32 tcp_tso_autosize(const struct sock * + + return segs; + } +-EXPORT_SYMBOL(tcp_tso_autosize); + + /* Return the number of segments we want in the skb we are transmitting. + * See if congestion control module wants to decide; otherwise, autosize. +@@ -1720,11 +1719,13 @@ EXPORT_SYMBOL(tcp_tso_autosize); + static u32 tcp_tso_segs(struct sock *sk, unsigned int mss_now) + { + const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops; +- u32 tso_segs = ca_ops->tso_segs_goal ? ca_ops->tso_segs_goal(sk) : 0; ++ u32 min_tso, tso_segs; + +- if (!tso_segs) +- tso_segs = tcp_tso_autosize(sk, mss_now, +- sysctl_tcp_min_tso_segs); ++ min_tso = ca_ops->min_tso_segs ? ++ ca_ops->min_tso_segs(sk) : ++ sysctl_tcp_min_tso_segs; ++ ++ tso_segs = tcp_tso_autosize(sk, mss_now, min_tso); + return min_t(u32, tso_segs, sk->sk_gso_max_segs); + } + diff --git a/target/linux/generic/backport-4.14/605-0004-tcp_bbr-remove-bbr-tso_segs_goal.patch b/target/linux/generic/backport-4.14/605-0004-tcp_bbr-remove-bbr-tso_segs_goal.patch new file mode 100644 index 0000000000..72f086dcc7 --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0004-tcp_bbr-remove-bbr-tso_segs_goal.patch @@ -0,0 +1,76 @@ +From 5325679a178db78f83fb069aa7bc760867e2eba6 Mon Sep 17 00:00:00 2001 +From: Eric Dumazet +Date: Wed, 28 Feb 2018 14:40:47 -0800 +Subject: [PATCH] tcp_bbr: remove bbr->tso_segs_goal + +Its value is computed then immediately used, +there is no need to store it. + +Signed-off-by: Eric Dumazet +Acked-by: Neal Cardwell +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + net/ipv4/tcp_bbr.c | 12 ++++-------- + 1 file changed, 4 insertions(+), 8 deletions(-) + +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -97,10 +97,9 @@ struct bbr { + packet_conservation:1, /* use packet conservation? */ + restore_cwnd:1, /* decided to revert cwnd to old value */ + round_start:1, /* start of packet-timed tx->ack round? */ +- tso_segs_goal:7, /* segments we want in each skb we send */ + idle_restart:1, /* restarting after idle? */ + probe_rtt_round_done:1, /* a BBR_PROBE_RTT round at 4 pkts? */ +- unused:5, ++ unused:12, + lt_is_sampling:1, /* taking long-term ("LT") samples now? */ + lt_rtt_cnt:7, /* round trips in long-term interval */ + lt_use_bw:1; /* use lt_bw as our bw estimate? */ +@@ -267,10 +266,9 @@ static u32 bbr_min_tso_segs(struct sock + return sk->sk_pacing_rate < (bbr_min_tso_rate >> 3) ? 1 : 2; + } + +-static void bbr_set_tso_segs_goal(struct sock *sk) ++static u32 bbr_tso_segs_goal(struct sock *sk) + { + struct tcp_sock *tp = tcp_sk(sk); +- struct bbr *bbr = inet_csk_ca(sk); + u32 segs, bytes; + + /* Sort of tcp_tso_autosize() but ignoring +@@ -280,7 +278,7 @@ static void bbr_set_tso_segs_goal(struct + GSO_MAX_SIZE - 1 - MAX_TCP_HEADER); + segs = max_t(u32, bytes / tp->mss_cache, bbr_min_tso_segs(sk)); + +- bbr->tso_segs_goal = min(segs, 0x7FU); ++ return min(segs, 0x7FU); + } + + /* Save "last known good" cwnd so we can restore it after losses or PROBE_RTT */ +@@ -351,7 +349,7 @@ static u32 bbr_target_cwnd(struct sock * + cwnd = (((w * gain) >> BBR_SCALE) + BW_UNIT - 1) / BW_UNIT; + + /* Allow enough full-sized skbs in flight to utilize end systems. */ +- cwnd += 3 * bbr->tso_segs_goal; ++ cwnd += 3 * bbr_tso_segs_goal(sk); + + /* Reduce delayed ACKs by rounding up cwnd to the next even number. */ + cwnd = (cwnd + 1) & ~1U; +@@ -832,7 +830,6 @@ static void bbr_main(struct sock *sk, co + + bw = bbr_bw(sk); + bbr_set_pacing_rate(sk, bw, bbr->pacing_gain); +- bbr_set_tso_segs_goal(sk); + bbr_set_cwnd(sk, rs, rs->acked_sacked, bw, bbr->cwnd_gain); + } + +@@ -842,7 +839,6 @@ static void bbr_init(struct sock *sk) + struct bbr *bbr = inet_csk_ca(sk); + + bbr->prior_cwnd = 0; +- bbr->tso_segs_goal = 0; /* default segs per skb until first ACK */ + bbr->rtt_cnt = 0; + bbr->next_rtt_delivered = 0; + bbr->prev_ca_state = TCP_CA_Open; diff --git a/target/linux/generic/backport-4.14/605-0005-net-tcp_bbr-set-tp-snd_ssthresh-to-BDP-upon-STARTUP-exit.patch b/target/linux/generic/backport-4.14/605-0005-net-tcp_bbr-set-tp-snd_ssthresh-to-BDP-upon-STARTUP-exit.patch new file mode 100644 index 0000000000..16a98e0e96 --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0005-net-tcp_bbr-set-tp-snd_ssthresh-to-BDP-upon-STARTUP-exit.patch @@ -0,0 +1,49 @@ +From 1f755aeceaf743d15530e31854395a185c33901e Mon Sep 17 00:00:00 2001 +From: Yousuk Seung +Date: Fri, 16 Mar 2018 10:51:49 -0700 +Subject: [PATCH] net-tcp_bbr: set tp->snd_ssthresh to BDP upon STARTUP exit + +Set tp->snd_ssthresh to BDP upon STARTUP exit. This allows us +to check if a BBR flow exited STARTUP and the BDP at the +time of STARTUP exit with SCM_TIMESTAMPING_OPT_STATS. Since BBR does not +use snd_ssthresh this fix has no impact on BBR's behavior. + +Signed-off-by: Yousuk Seung +Signed-off-by: Neal Cardwell +Signed-off-by: Priyaranjan Jha +Signed-off-by: Soheil Hassas Yeganeh +Signed-off-by: Yuchung Cheng +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + net/ipv4/tcp_bbr.c | 5 ++++- + 1 file changed, 4 insertions(+), 1 deletion(-) + +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -734,6 +734,8 @@ static void bbr_check_drain(struct sock + bbr->mode = BBR_DRAIN; /* drain queue we created */ + bbr->pacing_gain = bbr_drain_gain; /* pace slow to drain */ + bbr->cwnd_gain = bbr_high_gain; /* maintain cwnd */ ++ tcp_sk(sk)->snd_ssthresh = ++ bbr_target_cwnd(sk, bbr_max_bw(sk), BBR_UNIT); + } /* fall through to check if in-flight is already small: */ + if (bbr->mode == BBR_DRAIN && + tcp_packets_in_flight(tcp_sk(sk)) <= +@@ -839,6 +841,7 @@ static void bbr_init(struct sock *sk) + struct bbr *bbr = inet_csk_ca(sk); + + bbr->prior_cwnd = 0; ++ tp->snd_ssthresh = TCP_INFINITE_SSTHRESH; + bbr->rtt_cnt = 0; + bbr->next_rtt_delivered = 0; + bbr->prev_ca_state = TCP_CA_Open; +@@ -891,7 +894,7 @@ static u32 bbr_undo_cwnd(struct sock *sk + static u32 bbr_ssthresh(struct sock *sk) + { + bbr_save_cwnd(sk); +- return TCP_INFINITE_SSTHRESH; /* BBR does not use ssthresh */ ++ return tcp_sk(sk)->snd_ssthresh; + } + + static size_t bbr_get_info(struct sock *sk, u32 ext, int *attr, diff --git a/target/linux/generic/backport-4.14/605-0006-tcp_bbr-fix-bbr-pacing-rate-for-internal-pacing.patch b/target/linux/generic/backport-4.14/605-0006-tcp_bbr-fix-bbr-pacing-rate-for-internal-pacing.patch new file mode 100644 index 0000000000..50fb35efe1 --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0006-tcp_bbr-fix-bbr-pacing-rate-for-internal-pacing.patch @@ -0,0 +1,88 @@ +From 877916ac4797bda7b8b0674d6804bf1200268a2d Mon Sep 17 00:00:00 2001 +From: Eric Dumazet +Date: Wed, 20 Jun 2018 16:07:35 -0400 +Subject: [PATCH] tcp_bbr: fix bbr pacing rate for internal pacing + +This commit makes BBR use only the MSS (without any headers) to +calculate pacing rates when internal TCP-layer pacing is used. + +This is necessary to achieve the correct pacing behavior in this case, +since tcp_internal_pacing() uses only the payload length to calculate +pacing delays. + +Signed-off-by: Kevin Yang +Signed-off-by: Eric Dumazet +Reviewed-by: Neal Cardwell +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + include/net/tcp.h | 11 +++++++++++ + net/ipv4/tcp_bbr.c | 6 +++++- + net/ipv4/tcp_output.c | 14 -------------- + 3 files changed, 16 insertions(+), 15 deletions(-) + +--- a/include/net/tcp.h ++++ b/include/net/tcp.h +@@ -1233,6 +1233,17 @@ static inline bool tcp_is_cwnd_limited(c + return tp->is_cwnd_limited; + } + ++/* BBR congestion control needs pacing. ++ * Same remark for SO_MAX_PACING_RATE. ++ * sch_fq packet scheduler is efficiently handling pacing, ++ * but is not always installed/used. ++ * Return true if TCP stack should pace packets itself. ++ */ ++static inline bool tcp_needs_internal_pacing(const struct sock *sk) ++{ ++ return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED; ++} ++ + /* Something is really bad, we could not queue an additional packet, + * because qdisc is full or receiver sent a 0 window. + * We do not want to add fuel to the fire, or abort too early, +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -205,7 +205,11 @@ static u32 bbr_bw(const struct sock *sk) + */ + static u64 bbr_rate_bytes_per_sec(struct sock *sk, u64 rate, int gain) + { +- rate *= tcp_mss_to_mtu(sk, tcp_sk(sk)->mss_cache); ++ unsigned int mss = tcp_sk(sk)->mss_cache; ++ ++ if (!tcp_needs_internal_pacing(sk)) ++ mss = tcp_mss_to_mtu(sk, mss); ++ rate *= mss; + rate *= gain; + rate >>= BBR_SCALE; + rate *= USEC_PER_SEC; +--- a/net/ipv4/tcp_output.c ++++ b/net/ipv4/tcp_output.c +@@ -949,17 +949,6 @@ enum hrtimer_restart tcp_pace_kick(struc + return HRTIMER_NORESTART; + } + +-/* BBR congestion control needs pacing. +- * Same remark for SO_MAX_PACING_RATE. +- * sch_fq packet scheduler is efficiently handling pacing, +- * but is not always installed/used. +- * Return true if TCP stack should pace packets itself. +- */ +-static bool tcp_needs_internal_pacing(const struct sock *sk) +-{ +- return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED; +-} +- + static void tcp_internal_pacing(struct sock *sk, const struct sk_buff *skb) + { + u64 len_ns; +@@ -971,9 +960,6 @@ static void tcp_internal_pacing(struct s + if (!rate || rate == ~0U) + return; + +- /* Should account for header sizes as sch_fq does, +- * but lets make things simple. +- */ + len_ns = (u64)skb->len * NSEC_PER_SEC; + do_div(len_ns, rate); + hrtimer_start(&tcp_sk(sk)->pacing_timer, diff --git a/target/linux/generic/backport-4.14/605-0007-tcp_bbr-add-bbr_check_probe_rtt_done-helper.patch b/target/linux/generic/backport-4.14/605-0007-tcp_bbr-add-bbr_check_probe_rtt_done-helper.patch new file mode 100644 index 0000000000..4f91ddf854 --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0007-tcp_bbr-add-bbr_check_probe_rtt_done-helper.patch @@ -0,0 +1,98 @@ +From 092d9804a6479f34102f1017f14232a7731ef345 Mon Sep 17 00:00:00 2001 +From: Kevin Yang +Date: Wed, 22 Aug 2018 17:43:14 -0400 +Subject: [PATCH] tcp_bbr: add bbr_check_probe_rtt_done() helper + +This patch add a helper function bbr_check_probe_rtt_done() to + 1. check the condition to see if bbr should exit probe_rtt mode; + 2. process the logic of exiting probe_rtt mode. + +Fixes: 0f8782ea1497 ("tcp_bbr: add BBR congestion control") +Signed-off-by: Kevin Yang +Signed-off-by: Neal Cardwell +Signed-off-by: Yuchung Cheng +Reviewed-by: Soheil Hassas Yeganeh +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + net/ipv4/tcp_bbr.c | 34 ++++++++++++++++++---------------- + 1 file changed, 18 insertions(+), 16 deletions(-) + +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -95,11 +95,10 @@ struct bbr { + u32 mode:3, /* current bbr_mode in state machine */ + prev_ca_state:3, /* CA state on previous ACK */ + packet_conservation:1, /* use packet conservation? */ +- restore_cwnd:1, /* decided to revert cwnd to old value */ + round_start:1, /* start of packet-timed tx->ack round? */ + idle_restart:1, /* restarting after idle? */ + probe_rtt_round_done:1, /* a BBR_PROBE_RTT round at 4 pkts? */ +- unused:12, ++ unused:13, + lt_is_sampling:1, /* taking long-term ("LT") samples now? */ + lt_rtt_cnt:7, /* round trips in long-term interval */ + lt_use_bw:1; /* use lt_bw as our bw estimate? */ +@@ -396,17 +395,11 @@ static bool bbr_set_cwnd_to_recover_or_r + cwnd = tcp_packets_in_flight(tp) + acked; + } else if (prev_state >= TCP_CA_Recovery && state < TCP_CA_Recovery) { + /* Exiting loss recovery; restore cwnd saved before recovery. */ +- bbr->restore_cwnd = 1; ++ cwnd = max(cwnd, bbr->prior_cwnd); + bbr->packet_conservation = 0; + } + bbr->prev_ca_state = state; + +- if (bbr->restore_cwnd) { +- /* Restore cwnd after exiting loss recovery or PROBE_RTT. */ +- cwnd = max(cwnd, bbr->prior_cwnd); +- bbr->restore_cwnd = 0; +- } +- + if (bbr->packet_conservation) { + *new_cwnd = max(cwnd, tcp_packets_in_flight(tp) + acked); + return true; /* yes, using packet conservation */ +@@ -747,6 +740,20 @@ static void bbr_check_drain(struct sock + bbr_reset_probe_bw_mode(sk); /* we estimate queue is drained */ + } + ++static void bbr_check_probe_rtt_done(struct sock *sk) ++{ ++ struct tcp_sock *tp = tcp_sk(sk); ++ struct bbr *bbr = inet_csk_ca(sk); ++ ++ if (!(bbr->probe_rtt_done_stamp && ++ after(tcp_jiffies32, bbr->probe_rtt_done_stamp))) ++ return; ++ ++ bbr->min_rtt_stamp = tcp_jiffies32; /* wait a while until PROBE_RTT */ ++ tp->snd_cwnd = max(tp->snd_cwnd, bbr->prior_cwnd); ++ bbr_reset_mode(sk); ++} ++ + /* The goal of PROBE_RTT mode is to have BBR flows cooperatively and + * periodically drain the bottleneck queue, to converge to measure the true + * min_rtt (unloaded propagation delay). This allows the flows to keep queues +@@ -805,12 +812,8 @@ static void bbr_update_min_rtt(struct so + } else if (bbr->probe_rtt_done_stamp) { + if (bbr->round_start) + bbr->probe_rtt_round_done = 1; +- if (bbr->probe_rtt_round_done && +- after(tcp_jiffies32, bbr->probe_rtt_done_stamp)) { +- bbr->min_rtt_stamp = tcp_jiffies32; +- bbr->restore_cwnd = 1; /* snap to prior_cwnd */ +- bbr_reset_mode(sk); +- } ++ if (bbr->probe_rtt_round_done) ++ bbr_check_probe_rtt_done(sk); + } + } + /* Restart after idle ends only once we process a new S/ACK for data */ +@@ -861,7 +864,6 @@ static void bbr_init(struct sock *sk) + bbr->has_seen_rtt = 0; + bbr_init_pacing_rate_from_rtt(sk); + +- bbr->restore_cwnd = 0; + bbr->round_start = 0; + bbr->idle_restart = 0; + bbr->full_bw_reached = 0; diff --git a/target/linux/generic/backport-4.14/605-0008-tcp_bbr-in-restart-from-idle,-see-if-we-should-exit.patch b/target/linux/generic/backport-4.14/605-0008-tcp_bbr-in-restart-from-idle,-see-if-we-should-exit.patch new file mode 100644 index 0000000000..d1ee051d28 --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0008-tcp_bbr-in-restart-from-idle,-see-if-we-should-exit.patch @@ -0,0 +1,43 @@ +From 2c42bf86a0b5fd29a117b13d8f89f77347c53d51 Mon Sep 17 00:00:00 2001 +From: Kevin Yang +Date: Wed, 22 Aug 2018 17:43:15 -0400 +Subject: [PATCH] tcp_bbr: in restart from idle, see if we should exit + PROBE_RTT + +This patch fix the case where BBR does not exit PROBE_RTT mode when +it restarts from idle. When BBR restarts from idle and if BBR is in +PROBE_RTT mode, BBR should check if it's time to exit PROBE_RTT. If +yes, then BBR should exit PROBE_RTT mode and restore the cwnd to its +full value. + +Fixes: 0f8782ea1497 ("tcp_bbr: add BBR congestion control") +Signed-off-by: Kevin Yang +Signed-off-by: Neal Cardwell +Reviewed-by: Yuchung Cheng +Reviewed-by: Soheil Hassas Yeganeh +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + net/ipv4/tcp_bbr.c | 4 ++++ + 1 file changed, 4 insertions(+) + +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -174,6 +174,8 @@ static const u32 bbr_lt_bw_diff = 4000 / + /* If we estimate we're policed, use lt_bw for this many round trips: */ + static const u32 bbr_lt_bw_max_rtts = 48; + ++static void bbr_check_probe_rtt_done(struct sock *sk); ++ + /* Do we estimate that STARTUP filled the pipe? */ + static bool bbr_full_bw_reached(const struct sock *sk) + { +@@ -308,6 +310,8 @@ static void bbr_cwnd_event(struct sock * + */ + if (bbr->mode == BBR_PROBE_BW) + bbr_set_pacing_rate(sk, bbr_bw(sk), BBR_UNIT); ++ else if (bbr->mode == BBR_PROBE_RTT) ++ bbr_check_probe_rtt_done(sk); + } + } + diff --git a/target/linux/generic/backport-4.14/605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked==0.patch b/target/linux/generic/backport-4.14/605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked==0.patch new file mode 100644 index 0000000000..7a6f6f072d --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked==0.patch @@ -0,0 +1,41 @@ +From 41c14f81721f510b94b75276bcb47b2c3de18cfc Mon Sep 17 00:00:00 2001 +From: Kevin Yang +Date: Wed, 22 Aug 2018 17:43:16 -0400 +Subject: [PATCH] tcp_bbr: apply PROBE_RTT cwnd cap even if acked==0 + +This commit fixes a corner case where TCP BBR would enter PROBE_RTT +mode but not reduce its cwnd. If a TCP receiver ACKed less than one +full segment, the number of delivered/acked packets was 0, so that +bbr_set_cwnd() would short-circuit and exit early, without cutting +cwnd to the value we want for PROBE_RTT. + +The fix is to instead make sure that even when 0 full packets are +ACKed, we do apply all the appropriate caps, including the cap that +applies in PROBE_RTT mode. + +Fixes: 0f8782ea1497 ("tcp_bbr: add BBR congestion control") +Signed-off-by: Kevin Yang +Signed-off-by: Neal Cardwell +Reviewed-by: Yuchung Cheng +Reviewed-by: Soheil Hassas Yeganeh +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + net/ipv4/tcp_bbr.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -420,10 +420,10 @@ static void bbr_set_cwnd(struct sock *sk + { + struct tcp_sock *tp = tcp_sk(sk); + struct bbr *bbr = inet_csk_ca(sk); +- u32 cwnd = 0, target_cwnd = 0; ++ u32 cwnd = tp->snd_cwnd, target_cwnd = 0; + + if (!acked) +- return; ++ goto done; /* no packet fully ACKed; just apply caps */ + + if (bbr_set_cwnd_to_recover_or_restore(sk, rs, acked, &cwnd)) + goto done; diff --git a/target/linux/generic/backport-4.14/605-0010-tcp_bbr-centralize-code-to-set-gains.patch b/target/linux/generic/backport-4.14/605-0010-tcp_bbr-centralize-code-to-set-gains.patch new file mode 100644 index 0000000000..2b91a84c84 --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0010-tcp_bbr-centralize-code-to-set-gains.patch @@ -0,0 +1,112 @@ +From b4d63acbad2e0f829f720b93211321ef381fb2a2 Mon Sep 17 00:00:00 2001 +From: Neal Cardwell +Date: Tue, 16 Oct 2018 20:16:45 -0400 +Subject: [PATCH] tcp_bbr: centralize code to set gains + +Centralize the code that sets gains used for computing cwnd and pacing +rate. This simplifies the code and makes it easier to change the state +machine or (in the future) dynamically change the gain values and +ensure that the correct gain values are always used. + +Signed-off-by: Neal Cardwell +Signed-off-by: Yuchung Cheng +Signed-off-by: Soheil Hassas Yeganeh +Signed-off-by: Priyaranjan Jha +Signed-off-by: Eric Dumazet +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + net/ipv4/tcp_bbr.c | 40 ++++++++++++++++++++++++++++++---------- + 1 file changed, 30 insertions(+), 10 deletions(-) + +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -487,8 +487,6 @@ static void bbr_advance_cycle_phase(stru + + bbr->cycle_idx = (bbr->cycle_idx + 1) & (CYCLE_LEN - 1); + bbr->cycle_mstamp = tp->delivered_mstamp; +- bbr->pacing_gain = bbr->lt_use_bw ? BBR_UNIT : +- bbr_pacing_gain[bbr->cycle_idx]; + } + + /* Gain cycling: cycle pacing gain to converge to fair share of available bw. */ +@@ -506,8 +504,6 @@ static void bbr_reset_startup_mode(struc + struct bbr *bbr = inet_csk_ca(sk); + + bbr->mode = BBR_STARTUP; +- bbr->pacing_gain = bbr_high_gain; +- bbr->cwnd_gain = bbr_high_gain; + } + + static void bbr_reset_probe_bw_mode(struct sock *sk) +@@ -515,8 +511,6 @@ static void bbr_reset_probe_bw_mode(stru + struct bbr *bbr = inet_csk_ca(sk); + + bbr->mode = BBR_PROBE_BW; +- bbr->pacing_gain = BBR_UNIT; +- bbr->cwnd_gain = bbr_cwnd_gain; + bbr->cycle_idx = CYCLE_LEN - 1 - prandom_u32_max(bbr_cycle_rand); + bbr_advance_cycle_phase(sk); /* flip to next phase of gain cycle */ + } +@@ -733,8 +727,6 @@ static void bbr_check_drain(struct sock + + if (bbr->mode == BBR_STARTUP && bbr_full_bw_reached(sk)) { + bbr->mode = BBR_DRAIN; /* drain queue we created */ +- bbr->pacing_gain = bbr_drain_gain; /* pace slow to drain */ +- bbr->cwnd_gain = bbr_high_gain; /* maintain cwnd */ + tcp_sk(sk)->snd_ssthresh = + bbr_target_cwnd(sk, bbr_max_bw(sk), BBR_UNIT); + } /* fall through to check if in-flight is already small: */ +@@ -796,8 +788,6 @@ static void bbr_update_min_rtt(struct so + if (bbr_probe_rtt_mode_ms > 0 && filter_expired && + !bbr->idle_restart && bbr->mode != BBR_PROBE_RTT) { + bbr->mode = BBR_PROBE_RTT; /* dip, drain queue */ +- bbr->pacing_gain = BBR_UNIT; +- bbr->cwnd_gain = BBR_UNIT; + bbr_save_cwnd(sk); /* note cwnd so we can restore it */ + bbr->probe_rtt_done_stamp = 0; + } +@@ -825,6 +815,35 @@ static void bbr_update_min_rtt(struct so + bbr->idle_restart = 0; + } + ++static void bbr_update_gains(struct sock *sk) ++{ ++ struct bbr *bbr = inet_csk_ca(sk); ++ ++ switch (bbr->mode) { ++ case BBR_STARTUP: ++ bbr->pacing_gain = bbr_high_gain; ++ bbr->cwnd_gain = bbr_high_gain; ++ break; ++ case BBR_DRAIN: ++ bbr->pacing_gain = bbr_drain_gain; /* slow, to drain */ ++ bbr->cwnd_gain = bbr_high_gain; /* keep cwnd */ ++ break; ++ case BBR_PROBE_BW: ++ bbr->pacing_gain = (bbr->lt_use_bw ? ++ BBR_UNIT : ++ bbr_pacing_gain[bbr->cycle_idx]); ++ bbr->cwnd_gain = bbr_cwnd_gain; ++ break; ++ case BBR_PROBE_RTT: ++ bbr->pacing_gain = BBR_UNIT; ++ bbr->cwnd_gain = BBR_UNIT; ++ break; ++ default: ++ WARN_ONCE(1, "BBR bad mode: %u\n", bbr->mode); ++ break; ++ } ++} ++ + static void bbr_update_model(struct sock *sk, const struct rate_sample *rs) + { + bbr_update_bw(sk, rs); +@@ -832,6 +851,7 @@ static void bbr_update_model(struct sock + bbr_check_full_bw_reached(sk, rs); + bbr_check_drain(sk, rs); + bbr_update_min_rtt(sk, rs); ++ bbr_update_gains(sk); + } + + static void bbr_main(struct sock *sk, const struct rate_sample *rs) diff --git a/target/linux/generic/backport-4.14/605-0011-tcp_bbr-refactor-bbr_target_cwnd-for-general-inflight-pro.patch b/target/linux/generic/backport-4.14/605-0011-tcp_bbr-refactor-bbr_target_cwnd-for-general-inflight-pro.patch new file mode 100644 index 0000000000..5de70fc79e --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0011-tcp_bbr-refactor-bbr_target_cwnd-for-general-inflight-pro.patch @@ -0,0 +1,144 @@ +From cc9f592b4e2645119629622d6cb90d46a95cec74 Mon Sep 17 00:00:00 2001 +From: Priyaranjan Jha +Date: Wed, 23 Jan 2019 12:04:53 -0800 +Subject: [PATCH] tcp_bbr: refactor bbr_target_cwnd() for general inflight + provisioning + +Because bbr_target_cwnd() is really a general-purpose BBR helper for +computing some volume of inflight data as a function of the estimated +BDP, refactor it into following helper functions: +- bbr_bdp() +- bbr_quantization_budget() +- bbr_inflight() + +Signed-off-by: Priyaranjan Jha +Signed-off-by: Neal Cardwell +Signed-off-by: Yuchung Cheng +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + net/ipv4/tcp_bbr.c | 60 ++++++++++++++++++++++++++++++---------------- + 1 file changed, 39 insertions(+), 21 deletions(-) + +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -315,30 +315,19 @@ static void bbr_cwnd_event(struct sock * + } + } + +-/* Find target cwnd. Right-size the cwnd based on min RTT and the +- * estimated bottleneck bandwidth: ++/* Calculate bdp based on min RTT and the estimated bottleneck bandwidth: + * +- * cwnd = bw * min_rtt * gain = BDP * gain ++ * bdp = bw * min_rtt * gain + * + * The key factor, gain, controls the amount of queue. While a small gain + * builds a smaller queue, it becomes more vulnerable to noise in RTT + * measurements (e.g., delayed ACKs or other ACK compression effects). This + * noise may cause BBR to under-estimate the rate. +- * +- * To achieve full performance in high-speed paths, we budget enough cwnd to +- * fit full-sized skbs in-flight on both end hosts to fully utilize the path: +- * - one skb in sending host Qdisc, +- * - one skb in sending host TSO/GSO engine +- * - one skb being received by receiver host LRO/GRO/delayed-ACK engine +- * Don't worry, at low rates (bbr_min_tso_rate) this won't bloat cwnd because +- * in such cases tso_segs_goal is 1. The minimum cwnd is 4 packets, +- * which allows 2 outstanding 2-packet sequences, to try to keep pipe +- * full even with ACK-every-other-packet delayed ACKs. + */ +-static u32 bbr_target_cwnd(struct sock *sk, u32 bw, int gain) ++static u32 bbr_bdp(struct sock *sk, u32 bw, int gain) + { + struct bbr *bbr = inet_csk_ca(sk); +- u32 cwnd; ++ u32 bdp; + u64 w; + + /* If we've never had a valid RTT sample, cap cwnd at the initial +@@ -353,7 +342,24 @@ static u32 bbr_target_cwnd(struct sock * + w = (u64)bw * bbr->min_rtt_us; + + /* Apply a gain to the given value, then remove the BW_SCALE shift. */ +- cwnd = (((w * gain) >> BBR_SCALE) + BW_UNIT - 1) / BW_UNIT; ++ bdp = (((w * gain) >> BBR_SCALE) + BW_UNIT - 1) / BW_UNIT; ++ ++ return bdp; ++} ++ ++/* To achieve full performance in high-speed paths, we budget enough cwnd to ++ * fit full-sized skbs in-flight on both end hosts to fully utilize the path: ++ * - one skb in sending host Qdisc, ++ * - one skb in sending host TSO/GSO engine ++ * - one skb being received by receiver host LRO/GRO/delayed-ACK engine ++ * Don't worry, at low rates (bbr_min_tso_rate) this won't bloat cwnd because ++ * in such cases tso_segs_goal is 1. The minimum cwnd is 4 packets, ++ * which allows 2 outstanding 2-packet sequences, to try to keep pipe ++ * full even with ACK-every-other-packet delayed ACKs. ++ */ ++static u32 bbr_quantization_budget(struct sock *sk, u32 cwnd, int gain) ++{ ++ struct bbr *bbr = inet_csk_ca(sk); + + /* Allow enough full-sized skbs in flight to utilize end systems. */ + cwnd += 3 * bbr_tso_segs_goal(sk); +@@ -368,6 +374,17 @@ static u32 bbr_target_cwnd(struct sock * + return cwnd; + } + ++/* Find inflight based on min RTT and the estimated bottleneck bandwidth. */ ++static u32 bbr_inflight(struct sock *sk, u32 bw, int gain) ++{ ++ u32 inflight; ++ ++ inflight = bbr_bdp(sk, bw, gain); ++ inflight = bbr_quantization_budget(sk, inflight, gain); ++ ++ return inflight; ++} ++ + /* An optimization in BBR to reduce losses: On the first round of recovery, we + * follow the packet conservation principle: send P packets per P packets acked. + * After that, we slow-start and send at most 2*P packets per P packets acked. +@@ -429,7 +446,8 @@ static void bbr_set_cwnd(struct sock *sk + goto done; + + /* If we're below target cwnd, slow start cwnd toward target cwnd. */ +- target_cwnd = bbr_target_cwnd(sk, bw, gain); ++ target_cwnd = bbr_bdp(sk, bw, gain); ++ target_cwnd = bbr_quantization_budget(sk, target_cwnd, gain); + if (bbr_full_bw_reached(sk)) /* only cut cwnd if we filled the pipe */ + cwnd = min(cwnd + acked, target_cwnd); + else if (cwnd < target_cwnd || tp->delivered < TCP_INIT_CWND) +@@ -470,14 +488,14 @@ static bool bbr_is_next_cycle_phase(stru + if (bbr->pacing_gain > BBR_UNIT) + return is_full_length && + (rs->losses || /* perhaps pacing_gain*BDP won't fit */ +- inflight >= bbr_target_cwnd(sk, bw, bbr->pacing_gain)); ++ inflight >= bbr_inflight(sk, bw, bbr->pacing_gain)); + + /* A pacing_gain < 1.0 tries to drain extra queue we added if bw + * probing didn't find more bw. If inflight falls to match BDP then we + * estimate queue is drained; persisting would underutilize the pipe. + */ + return is_full_length || +- inflight <= bbr_target_cwnd(sk, bw, BBR_UNIT); ++ inflight <= bbr_inflight(sk, bw, BBR_UNIT); + } + + static void bbr_advance_cycle_phase(struct sock *sk) +@@ -728,11 +746,11 @@ static void bbr_check_drain(struct sock + if (bbr->mode == BBR_STARTUP && bbr_full_bw_reached(sk)) { + bbr->mode = BBR_DRAIN; /* drain queue we created */ + tcp_sk(sk)->snd_ssthresh = +- bbr_target_cwnd(sk, bbr_max_bw(sk), BBR_UNIT); ++ bbr_inflight(sk, bbr_max_bw(sk), BBR_UNIT); + } /* fall through to check if in-flight is already small: */ + if (bbr->mode == BBR_DRAIN && + tcp_packets_in_flight(tcp_sk(sk)) <= +- bbr_target_cwnd(sk, bbr_max_bw(sk), BBR_UNIT)) ++ bbr_inflight(sk, bbr_max_bw(sk), BBR_UNIT)) + bbr_reset_probe_bw_mode(sk); /* we estimate queue is drained */ + } + diff --git a/target/linux/generic/backport-4.14/605-0012-tcp_bbr-adapt-cwnd-based-on-ack-aggregation-estimation.patch b/target/linux/generic/backport-4.14/605-0012-tcp_bbr-adapt-cwnd-based-on-ack-aggregation-estimation.patch new file mode 100644 index 0000000000..0579a7352f --- /dev/null +++ b/target/linux/generic/backport-4.14/605-0012-tcp_bbr-adapt-cwnd-based-on-ack-aggregation-estimation.patch @@ -0,0 +1,262 @@ +From 4d43b58a4f987282c62e43fee39f37dedaa08d71 Mon Sep 17 00:00:00 2001 +From: Priyaranjan Jha +Date: Wed, 23 Jan 2019 12:04:54 -0800 +Subject: [PATCH] tcp_bbr: adapt cwnd based on ack aggregation estimation + +Aggregation effects are extremely common with wifi, cellular, and cable +modem link technologies, ACK decimation in middleboxes, and LRO and GRO +in receiving hosts. The aggregation can happen in either direction, +data or ACKs, but in either case the aggregation effect is visible +to the sender in the ACK stream. + +Previously BBR's sending was often limited by cwnd under severe ACK +aggregation/decimation because BBR sized the cwnd at 2*BDP. If packets +were acked in bursts after long delays (e.g. one ACK acking 5*BDP after +5*RTT), BBR's sending was halted after sending 2*BDP over 2*RTT, leaving +the bottleneck idle for potentially long periods. Note that loss-based +congestion control does not have this issue because when facing +aggregation it continues increasing cwnd after bursts of ACKs, growing +cwnd until the buffer is full. + +To achieve good throughput in the presence of aggregation effects, this +algorithm allows the BBR sender to put extra data in flight to keep the +bottleneck utilized during silences in the ACK stream that it has evidence +to suggest were caused by aggregation. + +A summary of the algorithm: when a burst of packets are acked by a +stretched ACK or a burst of ACKs or both, BBR first estimates the expected +amount of data that should have been acked, based on its estimated +bandwidth. Then the surplus ("extra_acked") is recorded in a windowed-max +filter to estimate the recent level of observed ACK aggregation. Then cwnd +is increased by the ACK aggregation estimate. The larger cwnd avoids BBR +being cwnd-limited in the face of ACK silences that recent history suggests +were caused by aggregation. As a sanity check, the ACK aggregation degree +is upper-bounded by the cwnd (at the time of measurement) and a global max +of BW * 100ms. The algorithm is further described by the following +presentation: +https://datatracker.ietf.org/meeting/101/materials/slides-101-iccrg-an-update-on-bbr-work-at-google-00 + +In our internal testing, we observed a significant increase in BBR +throughput (measured using netperf), in a basic wifi setup. +- Host1 (sender on ethernet) -> AP -> Host2 (receiver on wifi) +- 2.4 GHz -> BBR before: ~73 Mbps; BBR after: ~102 Mbps; CUBIC: ~100 Mbps +- 5.0 GHz -> BBR before: ~362 Mbps; BBR after: ~593 Mbps; CUBIC: ~601 Mbps + +Also, this code is running globally on YouTube TCP connections and produced +significant bandwidth increases for YouTube traffic. + +This is based on Ian Swett's max_ack_height_ algorithm from the +QUIC BBR implementation. + +Signed-off-by: Priyaranjan Jha +Signed-off-by: Neal Cardwell +Signed-off-by: Yuchung Cheng +Signed-off-by: David S. Miller +Signed-off-by: UtsavisGreat +--- + include/net/inet_connection_sock.h | 4 +- + net/ipv4/tcp_bbr.c | 122 ++++++++++++++++++++++++++++- + 2 files changed, 123 insertions(+), 3 deletions(-) + +--- a/include/net/inet_connection_sock.h ++++ b/include/net/inet_connection_sock.h +@@ -136,8 +136,8 @@ struct inet_connection_sock { + } icsk_mtup; + u32 icsk_user_timeout; + +- u64 icsk_ca_priv[88 / sizeof(u64)]; +-#define ICSK_CA_PRIV_SIZE (11 * sizeof(u64)) ++ u64 icsk_ca_priv[104 / sizeof(u64)]; ++#define ICSK_CA_PRIV_SIZE (13 * sizeof(u64)) + }; + + #define ICSK_TIME_RETRANS 1 /* Retransmit timer */ +--- a/net/ipv4/tcp_bbr.c ++++ b/net/ipv4/tcp_bbr.c +@@ -115,6 +115,14 @@ struct bbr { + unused_b:5; + u32 prior_cwnd; /* prior cwnd upon entering loss recovery */ + u32 full_bw; /* recent bw, to estimate if pipe is full */ ++ ++ /* For tracking ACK aggregation: */ ++ u64 ack_epoch_mstamp; /* start of ACK sampling epoch */ ++ u16 extra_acked[2]; /* max excess data ACKed in epoch */ ++ u32 ack_epoch_acked:20, /* packets (S)ACKed in sampling epoch */ ++ extra_acked_win_rtts:5, /* age of extra_acked, in round trips */ ++ extra_acked_win_idx:1, /* current index in extra_acked array */ ++ unused_c:6; + }; + + #define CYCLE_LEN 8 /* number of phases in a pacing gain cycle */ +@@ -174,6 +182,15 @@ static const u32 bbr_lt_bw_diff = 4000 / + /* If we estimate we're policed, use lt_bw for this many round trips: */ + static const u32 bbr_lt_bw_max_rtts = 48; + ++/* Gain factor for adding extra_acked to target cwnd: */ ++static const int bbr_extra_acked_gain = BBR_UNIT; ++/* Window length of extra_acked window. */ ++static const u32 bbr_extra_acked_win_rtts = 5; ++/* Max allowed val for ack_epoch_acked, after which sampling epoch is reset */ ++static const u32 bbr_ack_epoch_acked_reset_thresh = 1U << 20; ++/* Time period for clamping cwnd increment due to ack aggregation */ ++static const u32 bbr_extra_acked_max_us = 100 * 1000; ++ + static void bbr_check_probe_rtt_done(struct sock *sk); + + /* Do we estimate that STARTUP filled the pipe? */ +@@ -200,6 +217,16 @@ static u32 bbr_bw(const struct sock *sk) + return bbr->lt_use_bw ? bbr->lt_bw : bbr_max_bw(sk); + } + ++/* Return maximum extra acked in past k-2k round trips, ++ * where k = bbr_extra_acked_win_rtts. ++ */ ++static u16 bbr_extra_acked(const struct sock *sk) ++{ ++ struct bbr *bbr = inet_csk_ca(sk); ++ ++ return max(bbr->extra_acked[0], bbr->extra_acked[1]); ++} ++ + /* Return rate in bytes per second, optionally with a gain. + * The order here is chosen carefully to avoid overflow of u64. This should + * work for input rates of up to 2.9Tbit/sec and gain of 2.89x. +@@ -305,6 +332,8 @@ static void bbr_cwnd_event(struct sock * + + if (event == CA_EVENT_TX_START && tp->app_limited) { + bbr->idle_restart = 1; ++ bbr->ack_epoch_mstamp = tp->tcp_mstamp; ++ bbr->ack_epoch_acked = 0; + /* Avoid pointless buffer overflows: pace at est. bw if we don't + * need more speed (we're restarting from idle and app-limited). + */ +@@ -385,6 +414,22 @@ static u32 bbr_inflight(struct sock *sk, + return inflight; + } + ++/* Find the cwnd increment based on estimate of ack aggregation */ ++static u32 bbr_ack_aggregation_cwnd(struct sock *sk) ++{ ++ u32 max_aggr_cwnd, aggr_cwnd = 0; ++ ++ if (bbr_extra_acked_gain && bbr_full_bw_reached(sk)) { ++ max_aggr_cwnd = ((u64)bbr_bw(sk) * bbr_extra_acked_max_us) ++ / BW_UNIT; ++ aggr_cwnd = (bbr_extra_acked_gain * bbr_extra_acked(sk)) ++ >> BBR_SCALE; ++ aggr_cwnd = min(aggr_cwnd, max_aggr_cwnd); ++ } ++ ++ return aggr_cwnd; ++} ++ + /* An optimization in BBR to reduce losses: On the first round of recovery, we + * follow the packet conservation principle: send P packets per P packets acked. + * After that, we slow-start and send at most 2*P packets per P packets acked. +@@ -445,9 +490,15 @@ static void bbr_set_cwnd(struct sock *sk + if (bbr_set_cwnd_to_recover_or_restore(sk, rs, acked, &cwnd)) + goto done; + +- /* If we're below target cwnd, slow start cwnd toward target cwnd. */ + target_cwnd = bbr_bdp(sk, bw, gain); ++ ++ /* Increment the cwnd to account for excess ACKed data that seems ++ * due to aggregation (of data and/or ACKs) visible in the ACK stream. ++ */ ++ target_cwnd += bbr_ack_aggregation_cwnd(sk); + target_cwnd = bbr_quantization_budget(sk, target_cwnd, gain); ++ ++ /* If we're below target cwnd, slow start cwnd toward target cwnd. */ + if (bbr_full_bw_reached(sk)) /* only cut cwnd if we filled the pipe */ + cwnd = min(cwnd + acked, target_cwnd); + else if (cwnd < target_cwnd || tp->delivered < TCP_INIT_CWND) +@@ -711,6 +762,67 @@ static void bbr_update_bw(struct sock *s + } + } + ++/* Estimates the windowed max degree of ack aggregation. ++ * This is used to provision extra in-flight data to keep sending during ++ * inter-ACK silences. ++ * ++ * Degree of ack aggregation is estimated as extra data acked beyond expected. ++ * ++ * max_extra_acked = "maximum recent excess data ACKed beyond max_bw * interval" ++ * cwnd += max_extra_acked ++ * ++ * Max extra_acked is clamped by cwnd and bw * bbr_extra_acked_max_us (100 ms). ++ * Max filter is an approximate sliding window of 5-10 (packet timed) round ++ * trips. ++ */ ++static void bbr_update_ack_aggregation(struct sock *sk, ++ const struct rate_sample *rs) ++{ ++ u32 epoch_us, expected_acked, extra_acked; ++ struct bbr *bbr = inet_csk_ca(sk); ++ struct tcp_sock *tp = tcp_sk(sk); ++ ++ if (!bbr_extra_acked_gain || rs->acked_sacked <= 0 || ++ rs->delivered < 0 || rs->interval_us <= 0) ++ return; ++ ++ if (bbr->round_start) { ++ bbr->extra_acked_win_rtts = min(0x1F, ++ bbr->extra_acked_win_rtts + 1); ++ if (bbr->extra_acked_win_rtts >= bbr_extra_acked_win_rtts) { ++ bbr->extra_acked_win_rtts = 0; ++ bbr->extra_acked_win_idx = bbr->extra_acked_win_idx ? ++ 0 : 1; ++ bbr->extra_acked[bbr->extra_acked_win_idx] = 0; ++ } ++ } ++ ++ /* Compute how many packets we expected to be delivered over epoch. */ ++ epoch_us = tcp_stamp_us_delta(tp->delivered_mstamp, ++ bbr->ack_epoch_mstamp); ++ expected_acked = ((u64)bbr_bw(sk) * epoch_us) / BW_UNIT; ++ ++ /* Reset the aggregation epoch if ACK rate is below expected rate or ++ * significantly large no. of ack received since epoch (potentially ++ * quite old epoch). ++ */ ++ if (bbr->ack_epoch_acked <= expected_acked || ++ (bbr->ack_epoch_acked + rs->acked_sacked >= ++ bbr_ack_epoch_acked_reset_thresh)) { ++ bbr->ack_epoch_acked = 0; ++ bbr->ack_epoch_mstamp = tp->delivered_mstamp; ++ expected_acked = 0; ++ } ++ ++ /* Compute excess data delivered, beyond what was expected. */ ++ bbr->ack_epoch_acked = min_t(u32, 0xFFFFF, ++ bbr->ack_epoch_acked + rs->acked_sacked); ++ extra_acked = bbr->ack_epoch_acked - expected_acked; ++ extra_acked = min(extra_acked, tp->snd_cwnd); ++ if (extra_acked > bbr->extra_acked[bbr->extra_acked_win_idx]) ++ bbr->extra_acked[bbr->extra_acked_win_idx] = extra_acked; ++} ++ + /* Estimate when the pipe is full, using the change in delivery rate: BBR + * estimates that STARTUP filled the pipe if the estimated bw hasn't changed by + * at least bbr_full_bw_thresh (25%) after bbr_full_bw_cnt (3) non-app-limited +@@ -865,6 +977,7 @@ static void bbr_update_gains(struct sock + static void bbr_update_model(struct sock *sk, const struct rate_sample *rs) + { + bbr_update_bw(sk, rs); ++ bbr_update_ack_aggregation(sk, rs); + bbr_update_cycle_phase(sk, rs); + bbr_check_full_bw_reached(sk, rs); + bbr_check_drain(sk, rs); +@@ -916,6 +1029,13 @@ static void bbr_init(struct sock *sk) + bbr_reset_lt_bw_sampling(sk); + bbr_reset_startup_mode(sk); + ++ bbr->ack_epoch_mstamp = tp->tcp_mstamp; ++ bbr->ack_epoch_acked = 0; ++ bbr->extra_acked_win_rtts = 0; ++ bbr->extra_acked_win_idx = 0; ++ bbr->extra_acked[0] = 0; ++ bbr->extra_acked[1] = 0; ++ + cmpxchg(&sk->sk_pacing_status, SK_PACING_NONE, SK_PACING_NEEDED); + } + diff --git a/target/linux/generic/pending-4.14/607-tcp_bbr-adapt-cwnd-based-on-ack-aggregation-estimation.patch b/target/linux/generic/pending-4.14/607-tcp_bbr-adapt-cwnd-based-on-ack-aggregation-estimation.patch deleted file mode 100644 index 2aaafa19d4..0000000000 --- a/target/linux/generic/pending-4.14/607-tcp_bbr-adapt-cwnd-based-on-ack-aggregation-estimation.patch +++ /dev/null @@ -1,611 +0,0 @@ -From 232aa8ec3ed979d4716891540c03a806ecab0c37 Mon Sep 17 00:00:00 2001 -From: Priyaranjan Jha -Date: Wed, 23 Jan 2019 12:04:53 -0800 -Subject: tcp_bbr: refactor bbr_target_cwnd() for general inflight provisioning - -Because bbr_target_cwnd() is really a general-purpose BBR helper for -computing some volume of inflight data as a function of the estimated -BDP, refactor it into following helper functions: -- bbr_bdp() -- bbr_quantization_budget() -- bbr_inflight() - -Signed-off-by: Priyaranjan Jha -Signed-off-by: Neal Cardwell -Signed-off-by: Yuchung Cheng -Signed-off-by: David S. Miller ---- ---- a/include/net/inet_connection_sock.h -+++ b/include/net/inet_connection_sock.h -@@ -136,8 +136,8 @@ struct inet_connection_sock { - } icsk_mtup; - u32 icsk_user_timeout; - -- u64 icsk_ca_priv[88 / sizeof(u64)]; --#define ICSK_CA_PRIV_SIZE (11 * sizeof(u64)) -+ u64 icsk_ca_priv[104 / sizeof(u64)]; -+#define ICSK_CA_PRIV_SIZE (13 * sizeof(u64)) - }; - - #define ICSK_TIME_RETRANS 1 /* Retransmit timer */ ---- a/net/ipv4/tcp_bbr.c -+++ b/net/ipv4/tcp_bbr.c -@@ -95,12 +95,10 @@ struct bbr { - u32 mode:3, /* current bbr_mode in state machine */ - prev_ca_state:3, /* CA state on previous ACK */ - packet_conservation:1, /* use packet conservation? */ -- restore_cwnd:1, /* decided to revert cwnd to old value */ - round_start:1, /* start of packet-timed tx->ack round? */ -- tso_segs_goal:7, /* segments we want in each skb we send */ - idle_restart:1, /* restarting after idle? */ - probe_rtt_round_done:1, /* a BBR_PROBE_RTT round at 4 pkts? */ -- unused:5, -+ unused:13, - lt_is_sampling:1, /* taking long-term ("LT") samples now? */ - lt_rtt_cnt:7, /* round trips in long-term interval */ - lt_use_bw:1; /* use lt_bw as our bw estimate? */ -@@ -117,6 +115,14 @@ struct bbr { - unused_b:5; - u32 prior_cwnd; /* prior cwnd upon entering loss recovery */ - u32 full_bw; /* recent bw, to estimate if pipe is full */ -+ -+ /* For tracking ACK aggregation: */ -+ u64 ack_epoch_mstamp; /* start of ACK sampling epoch */ -+ u16 extra_acked[2]; /* max excess data ACKed in epoch */ -+ u32 ack_epoch_acked:20, /* packets (S)ACKed in sampling epoch */ -+ extra_acked_win_rtts:5, /* age of extra_acked, in round trips */ -+ extra_acked_win_idx:1, /* current index in extra_acked array */ -+ unused_c:6; - }; - - #define CYCLE_LEN 8 /* number of phases in a pacing gain cycle */ -@@ -176,6 +182,17 @@ static const u32 bbr_lt_bw_diff = 4000 / - /* If we estimate we're policed, use lt_bw for this many round trips: */ - static const u32 bbr_lt_bw_max_rtts = 48; - -+/* Gain factor for adding extra_acked to target cwnd: */ -+static const int bbr_extra_acked_gain = BBR_UNIT; -+/* Window length of extra_acked window. */ -+static const u32 bbr_extra_acked_win_rtts = 5; -+/* Max allowed val for ack_epoch_acked, after which sampling epoch is reset */ -+static const u32 bbr_ack_epoch_acked_reset_thresh = 1U << 20; -+/* Time period for clamping cwnd increment due to ack aggregation */ -+static const u32 bbr_extra_acked_max_us = 100 * 1000; -+ -+static void bbr_check_probe_rtt_done(struct sock *sk); -+ - /* Do we estimate that STARTUP filled the pipe? */ - static bool bbr_full_bw_reached(const struct sock *sk) - { -@@ -200,13 +217,31 @@ static u32 bbr_bw(const struct sock *sk) - return bbr->lt_use_bw ? bbr->lt_bw : bbr_max_bw(sk); - } - -+/* Return maximum extra acked in past k-2k round trips, -+ * where k = bbr_extra_acked_win_rtts. -+ */ -+static u16 bbr_extra_acked(const struct sock *sk) -+{ -+ struct bbr *bbr = inet_csk_ca(sk); -+ -+ return max(bbr->extra_acked[0], bbr->extra_acked[1]); -+} -+ - /* Return rate in bytes per second, optionally with a gain. - * The order here is chosen carefully to avoid overflow of u64. This should - * work for input rates of up to 2.9Tbit/sec and gain of 2.89x. - */ -+static bool tcp_needs_internal_pacing(const struct sock *sk) -+{ -+ return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED; -+} - static u64 bbr_rate_bytes_per_sec(struct sock *sk, u64 rate, int gain) - { -- rate *= tcp_mss_to_mtu(sk, tcp_sk(sk)->mss_cache); -+ unsigned int mss = tcp_sk(sk)->mss_cache; -+ -+ if (!tcp_needs_internal_pacing(sk)) -+ mss = tcp_mss_to_mtu(sk, mss); -+ rate *= mss; - rate *= gain; - rate >>= BBR_SCALE; - rate *= USEC_PER_SEC; -@@ -261,23 +296,25 @@ static void bbr_set_pacing_rate(struct s - sk->sk_pacing_rate = rate; - } - --/* Return count of segments we want in the skbs we send, or 0 for default. */ --static u32 bbr_tso_segs_goal(struct sock *sk) -+/* override sysctl_tcp_min_tso_segs */ -+static u32 bbr_min_tso_segs(struct sock *sk) - { -- struct bbr *bbr = inet_csk_ca(sk); -- -- return bbr->tso_segs_goal; -+ return sk->sk_pacing_rate < (bbr_min_tso_rate >> 3) ? 1 : 2; - } - --static void bbr_set_tso_segs_goal(struct sock *sk) -+static u32 bbr_tso_segs_goal(struct sock *sk) - { - struct tcp_sock *tp = tcp_sk(sk); -- struct bbr *bbr = inet_csk_ca(sk); -- u32 min_segs; -+ u32 segs, bytes; -+ -+ /* Sort of tcp_tso_autosize() but ignoring -+ * driver provided sk_gso_max_size. -+ */ -+ bytes = min_t(u32, sk->sk_pacing_rate >> sk->sk_pacing_shift, -+ GSO_MAX_SIZE - 1 - MAX_TCP_HEADER); -+ segs = max_t(u32, bytes / tp->mss_cache, bbr_min_tso_segs(sk)); - -- min_segs = sk->sk_pacing_rate < (bbr_min_tso_rate >> 3) ? 1 : 2; -- bbr->tso_segs_goal = min(tcp_tso_autosize(sk, tp->mss_cache, min_segs), -- 0x7FU); -+ return min(segs, 0x7FU); - } - - /* Save "last known good" cwnd so we can restore it after losses or PROBE_RTT */ -@@ -299,38 +336,31 @@ static void bbr_cwnd_event(struct sock * - - if (event == CA_EVENT_TX_START && tp->app_limited) { - bbr->idle_restart = 1; -+ bbr->ack_epoch_mstamp = tp->tcp_mstamp; -+ bbr->ack_epoch_acked = 0; - /* Avoid pointless buffer overflows: pace at est. bw if we don't - * need more speed (we're restarting from idle and app-limited). - */ - if (bbr->mode == BBR_PROBE_BW) - bbr_set_pacing_rate(sk, bbr_bw(sk), BBR_UNIT); -+ else if (bbr->mode == BBR_PROBE_RTT) -+ bbr_check_probe_rtt_done(sk); - } - } - --/* Find target cwnd. Right-size the cwnd based on min RTT and the -- * estimated bottleneck bandwidth: -+/* Calculate bdp based on min RTT and the estimated bottleneck bandwidth: - * -- * cwnd = bw * min_rtt * gain = BDP * gain -+ * bdp = bw * min_rtt * gain - * - * The key factor, gain, controls the amount of queue. While a small gain - * builds a smaller queue, it becomes more vulnerable to noise in RTT - * measurements (e.g., delayed ACKs or other ACK compression effects). This - * noise may cause BBR to under-estimate the rate. -- * -- * To achieve full performance in high-speed paths, we budget enough cwnd to -- * fit full-sized skbs in-flight on both end hosts to fully utilize the path: -- * - one skb in sending host Qdisc, -- * - one skb in sending host TSO/GSO engine -- * - one skb being received by receiver host LRO/GRO/delayed-ACK engine -- * Don't worry, at low rates (bbr_min_tso_rate) this won't bloat cwnd because -- * in such cases tso_segs_goal is 1. The minimum cwnd is 4 packets, -- * which allows 2 outstanding 2-packet sequences, to try to keep pipe -- * full even with ACK-every-other-packet delayed ACKs. - */ --static u32 bbr_target_cwnd(struct sock *sk, u32 bw, int gain) -+static u32 bbr_bdp(struct sock *sk, u32 bw, int gain) - { - struct bbr *bbr = inet_csk_ca(sk); -- u32 cwnd; -+ u32 bdp; - u64 w; - - /* If we've never had a valid RTT sample, cap cwnd at the initial -@@ -345,21 +375,65 @@ static u32 bbr_target_cwnd(struct sock * - w = (u64)bw * bbr->min_rtt_us; - - /* Apply a gain to the given value, then remove the BW_SCALE shift. */ -- cwnd = (((w * gain) >> BBR_SCALE) + BW_UNIT - 1) / BW_UNIT; -+ bdp = (((w * gain) >> BBR_SCALE) + BW_UNIT - 1) / BW_UNIT; -+ -+ return bdp; -+} -+ -+/* To achieve full performance in high-speed paths, we budget enough cwnd to -+ * fit full-sized skbs in-flight on both end hosts to fully utilize the path: -+ * - one skb in sending host Qdisc, -+ * - one skb in sending host TSO/GSO engine -+ * - one skb being received by receiver host LRO/GRO/delayed-ACK engine -+ * Don't worry, at low rates (bbr_min_tso_rate) this won't bloat cwnd because -+ * in such cases tso_segs_goal is 1. The minimum cwnd is 4 packets, -+ * which allows 2 outstanding 2-packet sequences, to try to keep pipe -+ * full even with ACK-every-other-packet delayed ACKs. -+ */ -+static u32 bbr_quantization_budget(struct sock *sk, u32 cwnd) -+{ -+ struct bbr *bbr = inet_csk_ca(sk); - - /* Allow enough full-sized skbs in flight to utilize end systems. */ -- cwnd += 3 * bbr->tso_segs_goal; -+ cwnd += 3 * bbr_tso_segs_goal(sk); - - /* Reduce delayed ACKs by rounding up cwnd to the next even number. */ - cwnd = (cwnd + 1) & ~1U; - - /* Ensure gain cycling gets inflight above BDP even for small BDPs. */ -- if (bbr->mode == BBR_PROBE_BW && gain > BBR_UNIT) -+ if (bbr->mode == BBR_PROBE_BW && bbr->cycle_idx == 0) - cwnd += 2; - - return cwnd; - } - -+/* Find inflight based on min RTT and the estimated bottleneck bandwidth. */ -+static u32 bbr_inflight(struct sock *sk, u32 bw, int gain) -+{ -+ u32 inflight; -+ -+ inflight = bbr_bdp(sk, bw, gain); -+ inflight = bbr_quantization_budget(sk, inflight); -+ -+ return inflight; -+} -+ -+/* Find the cwnd increment based on estimate of ack aggregation */ -+static u32 bbr_ack_aggregation_cwnd(struct sock *sk) -+{ -+ u32 max_aggr_cwnd, aggr_cwnd = 0; -+ -+ if (bbr_extra_acked_gain && bbr_full_bw_reached(sk)) { -+ max_aggr_cwnd = ((u64)bbr_bw(sk) * bbr_extra_acked_max_us) -+ / BW_UNIT; -+ aggr_cwnd = (bbr_extra_acked_gain * bbr_extra_acked(sk)) -+ >> BBR_SCALE; -+ aggr_cwnd = min(aggr_cwnd, max_aggr_cwnd); -+ } -+ -+ return aggr_cwnd; -+} -+ - /* An optimization in BBR to reduce losses: On the first round of recovery, we - * follow the packet conservation principle: send P packets per P packets acked. - * After that, we slow-start and send at most 2*P packets per P packets acked. -@@ -391,17 +465,11 @@ static bool bbr_set_cwnd_to_recover_or_r - cwnd = tcp_packets_in_flight(tp) + acked; - } else if (prev_state >= TCP_CA_Recovery && state < TCP_CA_Recovery) { - /* Exiting loss recovery; restore cwnd saved before recovery. */ -- bbr->restore_cwnd = 1; -+ cwnd = max(cwnd, bbr->prior_cwnd); - bbr->packet_conservation = 0; - } - bbr->prev_ca_state = state; - -- if (bbr->restore_cwnd) { -- /* Restore cwnd after exiting loss recovery or PROBE_RTT. */ -- cwnd = max(cwnd, bbr->prior_cwnd); -- bbr->restore_cwnd = 0; -- } -- - if (bbr->packet_conservation) { - *new_cwnd = max(cwnd, tcp_packets_in_flight(tp) + acked); - return true; /* yes, using packet conservation */ -@@ -418,16 +486,23 @@ static void bbr_set_cwnd(struct sock *sk - { - struct tcp_sock *tp = tcp_sk(sk); - struct bbr *bbr = inet_csk_ca(sk); -- u32 cwnd = 0, target_cwnd = 0; -+ u32 cwnd = tp->snd_cwnd, target_cwnd = 0; - - if (!acked) -- return; -+ goto done; /* no packet fully ACKed; just apply caps */ - - if (bbr_set_cwnd_to_recover_or_restore(sk, rs, acked, &cwnd)) - goto done; - -+ target_cwnd = bbr_bdp(sk, bw, gain); -+ -+ /* Increment the cwnd to account for excess ACKed data that seems -+ * due to aggregation (of data and/or ACKs) visible in the ACK stream. -+ */ -+ target_cwnd += bbr_ack_aggregation_cwnd(sk); -+ target_cwnd = bbr_quantization_budget(sk, target_cwnd); -+ - /* If we're below target cwnd, slow start cwnd toward target cwnd. */ -- target_cwnd = bbr_target_cwnd(sk, bw, gain); - if (bbr_full_bw_reached(sk)) /* only cut cwnd if we filled the pipe */ - cwnd = min(cwnd + acked, target_cwnd); - else if (cwnd < target_cwnd || tp->delivered < TCP_INIT_CWND) -@@ -468,14 +543,14 @@ static bool bbr_is_next_cycle_phase(stru - if (bbr->pacing_gain > BBR_UNIT) - return is_full_length && - (rs->losses || /* perhaps pacing_gain*BDP won't fit */ -- inflight >= bbr_target_cwnd(sk, bw, bbr->pacing_gain)); -+ inflight >= bbr_inflight(sk, bw, bbr->pacing_gain)); - - /* A pacing_gain < 1.0 tries to drain extra queue we added if bw - * probing didn't find more bw. If inflight falls to match BDP then we - * estimate queue is drained; persisting would underutilize the pipe. - */ - return is_full_length || -- inflight <= bbr_target_cwnd(sk, bw, BBR_UNIT); -+ inflight <= bbr_inflight(sk, bw, BBR_UNIT); - } - - static void bbr_advance_cycle_phase(struct sock *sk) -@@ -485,8 +560,6 @@ static void bbr_advance_cycle_phase(stru - - bbr->cycle_idx = (bbr->cycle_idx + 1) & (CYCLE_LEN - 1); - bbr->cycle_mstamp = tp->delivered_mstamp; -- bbr->pacing_gain = bbr->lt_use_bw ? BBR_UNIT : -- bbr_pacing_gain[bbr->cycle_idx]; - } - - /* Gain cycling: cycle pacing gain to converge to fair share of available bw. */ -@@ -504,8 +577,6 @@ static void bbr_reset_startup_mode(struc - struct bbr *bbr = inet_csk_ca(sk); - - bbr->mode = BBR_STARTUP; -- bbr->pacing_gain = bbr_high_gain; -- bbr->cwnd_gain = bbr_high_gain; - } - - static void bbr_reset_probe_bw_mode(struct sock *sk) -@@ -513,8 +584,6 @@ static void bbr_reset_probe_bw_mode(stru - struct bbr *bbr = inet_csk_ca(sk); - - bbr->mode = BBR_PROBE_BW; -- bbr->pacing_gain = BBR_UNIT; -- bbr->cwnd_gain = bbr_cwnd_gain; - bbr->cycle_idx = CYCLE_LEN - 1 - prandom_u32_max(bbr_cycle_rand); - bbr_advance_cycle_phase(sk); /* flip to next phase of gain cycle */ - } -@@ -697,6 +766,67 @@ static void bbr_update_bw(struct sock *s - } - } - -+/* Estimates the windowed max degree of ack aggregation. -+ * This is used to provision extra in-flight data to keep sending during -+ * inter-ACK silences. -+ * -+ * Degree of ack aggregation is estimated as extra data acked beyond expected. -+ * -+ * max_extra_acked = "maximum recent excess data ACKed beyond max_bw * interval" -+ * cwnd += max_extra_acked -+ * -+ * Max extra_acked is clamped by cwnd and bw * bbr_extra_acked_max_us (100 ms). -+ * Max filter is an approximate sliding window of 5-10 (packet timed) round -+ * trips. -+ */ -+static void bbr_update_ack_aggregation(struct sock *sk, -+ const struct rate_sample *rs) -+{ -+ u32 epoch_us, expected_acked, extra_acked; -+ struct bbr *bbr = inet_csk_ca(sk); -+ struct tcp_sock *tp = tcp_sk(sk); -+ -+ if (!bbr_extra_acked_gain || rs->acked_sacked <= 0 || -+ rs->delivered < 0 || rs->interval_us <= 0) -+ return; -+ -+ if (bbr->round_start) { -+ bbr->extra_acked_win_rtts = min(0x1F, -+ bbr->extra_acked_win_rtts + 1); -+ if (bbr->extra_acked_win_rtts >= bbr_extra_acked_win_rtts) { -+ bbr->extra_acked_win_rtts = 0; -+ bbr->extra_acked_win_idx = bbr->extra_acked_win_idx ? -+ 0 : 1; -+ bbr->extra_acked[bbr->extra_acked_win_idx] = 0; -+ } -+ } -+ -+ /* Compute how many packets we expected to be delivered over epoch. */ -+ epoch_us = tcp_stamp_us_delta(tp->delivered_mstamp, -+ bbr->ack_epoch_mstamp); -+ expected_acked = ((u64)bbr_bw(sk) * epoch_us) / BW_UNIT; -+ -+ /* Reset the aggregation epoch if ACK rate is below expected rate or -+ * significantly large no. of ack received since epoch (potentially -+ * quite old epoch). -+ */ -+ if (bbr->ack_epoch_acked <= expected_acked || -+ (bbr->ack_epoch_acked + rs->acked_sacked >= -+ bbr_ack_epoch_acked_reset_thresh)) { -+ bbr->ack_epoch_acked = 0; -+ bbr->ack_epoch_mstamp = tp->delivered_mstamp; -+ expected_acked = 0; -+ } -+ -+ /* Compute excess data delivered, beyond what was expected. */ -+ bbr->ack_epoch_acked = min_t(u32, 0xFFFFF, -+ bbr->ack_epoch_acked + rs->acked_sacked); -+ extra_acked = bbr->ack_epoch_acked - expected_acked; -+ extra_acked = min(extra_acked, tp->snd_cwnd); -+ if (extra_acked > bbr->extra_acked[bbr->extra_acked_win_idx]) -+ bbr->extra_acked[bbr->extra_acked_win_idx] = extra_acked; -+} -+ - /* Estimate when the pipe is full, using the change in delivery rate: BBR - * estimates that STARTUP filled the pipe if the estimated bw hasn't changed by - * at least bbr_full_bw_thresh (25%) after bbr_full_bw_cnt (3) non-app-limited -@@ -731,15 +861,29 @@ static void bbr_check_drain(struct sock - - if (bbr->mode == BBR_STARTUP && bbr_full_bw_reached(sk)) { - bbr->mode = BBR_DRAIN; /* drain queue we created */ -- bbr->pacing_gain = bbr_drain_gain; /* pace slow to drain */ -- bbr->cwnd_gain = bbr_high_gain; /* maintain cwnd */ -+ tcp_sk(sk)->snd_ssthresh = -+ bbr_inflight(sk, bbr_max_bw(sk), BBR_UNIT); - } /* fall through to check if in-flight is already small: */ - if (bbr->mode == BBR_DRAIN && - tcp_packets_in_flight(tcp_sk(sk)) <= -- bbr_target_cwnd(sk, bbr_max_bw(sk), BBR_UNIT)) -+ bbr_inflight(sk, bbr_max_bw(sk), BBR_UNIT)) - bbr_reset_probe_bw_mode(sk); /* we estimate queue is drained */ - } - -+static void bbr_check_probe_rtt_done(struct sock *sk) -+{ -+ struct tcp_sock *tp = tcp_sk(sk); -+ struct bbr *bbr = inet_csk_ca(sk); -+ -+ if (!(bbr->probe_rtt_done_stamp && -+ after(tcp_jiffies32, bbr->probe_rtt_done_stamp))) -+ return; -+ -+ bbr->min_rtt_stamp = tcp_jiffies32; /* wait a while until PROBE_RTT */ -+ tp->snd_cwnd = max(tp->snd_cwnd, bbr->prior_cwnd); -+ bbr_reset_mode(sk); -+} -+ - /* The goal of PROBE_RTT mode is to have BBR flows cooperatively and - * periodically drain the bottleneck queue, to converge to measure the true - * min_rtt (unloaded propagation delay). This allows the flows to keep queues -@@ -769,7 +913,8 @@ static void bbr_update_min_rtt(struct so - filter_expired = after(tcp_jiffies32, - bbr->min_rtt_stamp + bbr_min_rtt_win_sec * HZ); - if (rs->rtt_us >= 0 && -- (rs->rtt_us < bbr->min_rtt_us || filter_expired)) { -+ (rs->rtt_us < bbr->min_rtt_us || -+ (filter_expired && !rs->is_ack_delayed))) { - bbr->min_rtt_us = rs->rtt_us; - bbr->min_rtt_stamp = tcp_jiffies32; - } -@@ -777,8 +922,6 @@ static void bbr_update_min_rtt(struct so - if (bbr_probe_rtt_mode_ms > 0 && filter_expired && - !bbr->idle_restart && bbr->mode != BBR_PROBE_RTT) { - bbr->mode = BBR_PROBE_RTT; /* dip, drain queue */ -- bbr->pacing_gain = BBR_UNIT; -- bbr->cwnd_gain = BBR_UNIT; - bbr_save_cwnd(sk); /* note cwnd so we can restore it */ - bbr->probe_rtt_done_stamp = 0; - } -@@ -797,12 +940,8 @@ static void bbr_update_min_rtt(struct so - } else if (bbr->probe_rtt_done_stamp) { - if (bbr->round_start) - bbr->probe_rtt_round_done = 1; -- if (bbr->probe_rtt_round_done && -- after(tcp_jiffies32, bbr->probe_rtt_done_stamp)) { -- bbr->min_rtt_stamp = tcp_jiffies32; -- bbr->restore_cwnd = 1; /* snap to prior_cwnd */ -- bbr_reset_mode(sk); -- } -+ if (bbr->probe_rtt_round_done) -+ bbr_check_probe_rtt_done(sk); - } - } - /* Restart after idle ends only once we process a new S/ACK for data */ -@@ -810,13 +949,44 @@ static void bbr_update_min_rtt(struct so - bbr->idle_restart = 0; - } - -+static void bbr_update_gains(struct sock *sk) -+{ -+ struct bbr *bbr = inet_csk_ca(sk); -+ -+ switch (bbr->mode) { -+ case BBR_STARTUP: -+ bbr->pacing_gain = bbr_high_gain; -+ bbr->cwnd_gain = bbr_high_gain; -+ break; -+ case BBR_DRAIN: -+ bbr->pacing_gain = bbr_drain_gain; /* slow, to drain */ -+ bbr->cwnd_gain = bbr_high_gain; /* keep cwnd */ -+ break; -+ case BBR_PROBE_BW: -+ bbr->pacing_gain = (bbr->lt_use_bw ? -+ BBR_UNIT : -+ bbr_pacing_gain[bbr->cycle_idx]); -+ bbr->cwnd_gain = bbr_cwnd_gain; -+ break; -+ case BBR_PROBE_RTT: -+ bbr->pacing_gain = BBR_UNIT; -+ bbr->cwnd_gain = BBR_UNIT; -+ break; -+ default: -+ WARN_ONCE(1, "BBR bad mode: %u\n", bbr->mode); -+ break; -+ } -+} -+ - static void bbr_update_model(struct sock *sk, const struct rate_sample *rs) - { - bbr_update_bw(sk, rs); -+ bbr_update_ack_aggregation(sk, rs); - bbr_update_cycle_phase(sk, rs); - bbr_check_full_bw_reached(sk, rs); - bbr_check_drain(sk, rs); - bbr_update_min_rtt(sk, rs); -+ bbr_update_gains(sk); - } - - static void bbr_main(struct sock *sk, const struct rate_sample *rs) -@@ -828,7 +998,6 @@ static void bbr_main(struct sock *sk, co - - bw = bbr_bw(sk); - bbr_set_pacing_rate(sk, bw, bbr->pacing_gain); -- bbr_set_tso_segs_goal(sk); - bbr_set_cwnd(sk, rs, rs->acked_sacked, bw, bbr->cwnd_gain); - } - -@@ -838,7 +1007,7 @@ static void bbr_init(struct sock *sk) - struct bbr *bbr = inet_csk_ca(sk); - - bbr->prior_cwnd = 0; -- bbr->tso_segs_goal = 0; /* default segs per skb until first ACK */ -+ tp->snd_ssthresh = TCP_INFINITE_SSTHRESH; - bbr->rtt_cnt = 0; - bbr->next_rtt_delivered = 0; - bbr->prev_ca_state = TCP_CA_Open; -@@ -854,7 +1023,6 @@ static void bbr_init(struct sock *sk) - bbr->has_seen_rtt = 0; - bbr_init_pacing_rate_from_rtt(sk); - -- bbr->restore_cwnd = 0; - bbr->round_start = 0; - bbr->idle_restart = 0; - bbr->full_bw_reached = 0; -@@ -865,6 +1033,13 @@ static void bbr_init(struct sock *sk) - bbr_reset_lt_bw_sampling(sk); - bbr_reset_startup_mode(sk); - -+ bbr->ack_epoch_mstamp = tp->tcp_mstamp; -+ bbr->ack_epoch_acked = 0; -+ bbr->extra_acked_win_rtts = 0; -+ bbr->extra_acked_win_idx = 0; -+ bbr->extra_acked[0] = 0; -+ bbr->extra_acked[1] = 0; -+ - cmpxchg(&sk->sk_pacing_status, SK_PACING_NONE, SK_PACING_NEEDED); - } - -@@ -891,7 +1066,7 @@ static u32 bbr_undo_cwnd(struct sock *sk - static u32 bbr_ssthresh(struct sock *sk) - { - bbr_save_cwnd(sk); -- return TCP_INFINITE_SSTHRESH; /* BBR does not use ssthresh */ -+ return tcp_sk(sk)->snd_ssthresh; - } - - static size_t bbr_get_info(struct sock *sk, u32 ext, int *attr, -@@ -940,7 +1115,7 @@ static struct tcp_congestion_ops tcp_bbr - .undo_cwnd = bbr_undo_cwnd, - .cwnd_event = bbr_cwnd_event, - .ssthresh = bbr_ssthresh, -- .tso_segs_goal = bbr_tso_segs_goal, -+ .min_tso_segs = bbr_min_tso_segs, - .get_info = bbr_get_info, - .set_state = bbr_set_state, - }; ---- a/include/net/tcp.h -+++ b/include/net/tcp.h -@@ -998,6 +998,7 @@ struct rate_sample { - u32 prior_in_flight; /* in flight before this ACK */ - bool is_app_limited; /* is sample from packet with bubble in pipe? */ - bool is_retrans; /* is sample from retransmission? */ -+ bool is_ack_delayed; /* is this (likely) a delayed ACK? */ - }; - - struct tcp_congestion_ops { -@@ -1024,6 +1025,8 @@ struct tcp_congestion_ops { - u32 (*undo_cwnd)(struct sock *sk); - /* hook for packet ack accounting (optional) */ - void (*pkts_acked)(struct sock *sk, const struct ack_sample *sample); -+ /* override sysctl_tcp_min_tso_segs */ -+ u32 (*min_tso_segs)(struct sock *sk); - /* suggest number of segments for each skb to transmit (optional) */ - u32 (*tso_segs_goal)(struct sock *sk); - /* returns the multiplier used in tcp_sndbuf_expand (optional) */ From 859588b171dd3eff7a1ba4e0a9dd84ad9ada1231 Mon Sep 17 00:00:00 2001 From: Daniel Golle Date: Tue, 2 Mar 2021 11:34:18 +0000 Subject: [PATCH 2/8] Revert "toolchain/autoconf-lean: add check for ssize_t" This reverts commit 6b7b064492ddf339d0213779fb84d50ee3dc5eb7. Signed-off-by: Daniel Golle --- toolchain/autoconf-lean/patches/120-add-extra-checks.patch | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/toolchain/autoconf-lean/patches/120-add-extra-checks.patch b/toolchain/autoconf-lean/patches/120-add-extra-checks.patch index 382e6e5ad1..7e81525daf 100644 --- a/toolchain/autoconf-lean/patches/120-add-extra-checks.patch +++ b/toolchain/autoconf-lean/patches/120-add-extra-checks.patch @@ -29,7 +29,7 @@ # Checks for typedefs, structures, and compiler characteristics. AC_TYPE_GETGROUPS -@@ -217,6 +222,17 @@ AC_FUNC_STRTOLD +@@ -217,6 +222,16 @@ AC_FUNC_STRTOLD AC_FUNC_UTIME_NULL AC_FUNC_VPRINTF @@ -42,7 +42,6 @@ +AC_CHECK_SIZEOF(unsigned long long) +AC_CHECK_SIZEOF(off_t) +AC_CHECK_SIZEOF(size_t) -+AC_CHECK_SIZEOF(ssize_t) + # Functions list scraped from musl 0.9.4 x86_64 AC_CHECK_FUNCS([ \ From 818331231e3722a6f4f5bd54051900773ba22b9a Mon Sep 17 00:00:00 2001 From: Daniel Golle Date: Tue, 2 Mar 2021 11:34:22 +0000 Subject: [PATCH 3/8] Revert "build: use config.site generated by autoconf-lean, drop hardcoded sitefiles" This reverts commit f439e291304a93b982e912dc91b80ca950a594f3. Signed-off-by: Daniel Golle --- Makefile | 6 ++++ include/package.mk | 2 +- include/site/aarch64 | 30 ++++++++++++++++ include/site/aarch64_be | 30 ++++++++++++++++ include/site/arc | 30 ++++++++++++++++ include/site/arm | 30 ++++++++++++++++ include/site/armeb | 30 ++++++++++++++++ include/site/i386 | 3 ++ include/site/i486 | 30 ++++++++++++++++ include/site/i686 | 3 ++ include/site/linux | 78 +++++++++++++++++++++++++++++++++++++++++ include/site/m68k | 28 +++++++++++++++ include/site/mips | 30 ++++++++++++++++ include/site/mips64 | 30 ++++++++++++++++ include/site/mips64el | 30 ++++++++++++++++ include/site/mipsel | 30 ++++++++++++++++ include/site/powerpc | 30 ++++++++++++++++ include/site/powerpc64 | 26 ++++++++++++++ include/site/sparc | 30 ++++++++++++++++ include/site/x86_64 | 30 ++++++++++++++++ 20 files changed, 535 insertions(+), 1 deletion(-) create mode 100644 include/site/aarch64 create mode 100644 include/site/aarch64_be create mode 100644 include/site/arc create mode 100644 include/site/arm create mode 100644 include/site/armeb create mode 100644 include/site/i386 create mode 100644 include/site/i486 create mode 100644 include/site/i686 create mode 100644 include/site/linux create mode 100644 include/site/m68k create mode 100644 include/site/mips create mode 100644 include/site/mips64 create mode 100644 include/site/mips64el create mode 100644 include/site/mipsel create mode 100644 include/site/powerpc create mode 100644 include/site/powerpc64 create mode 100644 include/site/sparc create mode 100644 include/site/x86_64 diff --git a/Makefile b/Makefile index d3c51761e9..aecee6929e 100644 --- a/Makefile +++ b/Makefile @@ -82,6 +82,12 @@ endif # check prerequisites before starting to build prereq: $(target/stamp-prereq) tmp/.prereq_packages + @if [ ! -f "$(INCLUDE_DIR)/site/$(ARCH)" ]; then \ + echo 'ERROR: Missing site config for architecture "$(ARCH)" !'; \ + echo ' The missing file will cause configure scripts to fail during compilation.'; \ + echo ' Please provide a "$(INCLUDE_DIR)/site/$(ARCH)" file and restart the build.'; \ + exit 1; \ + fi $(BIN_DIR)/profiles.json: FORCE $(if $(CONFIG_JSON_OVERVIEW_IMAGE_INFO), \ diff --git a/include/package.mk b/include/package.mk index f91785ede2..fc1bb7d67e 100644 --- a/include/package.mk +++ b/include/package.mk @@ -116,7 +116,7 @@ include $(INCLUDE_DIR)/autotools.mk _pkg_target:=$(if $(QUILT),,.) override MAKEFLAGS= -CONFIG_SITE:=$(TOOLCHAIN_DIR)/config.site +CONFIG_SITE:=$(INCLUDE_DIR)/site/$(ARCH) CUR_MAKEFILE:=$(filter-out Makefile,$(firstword $(MAKEFILE_LIST))) SUBMAKE:=$(NO_TRACE_MAKE) $(if $(CUR_MAKEFILE),-f $(CUR_MAKEFILE)) PKG_CONFIG_PATH=$(STAGING_DIR)/usr/lib/pkgconfig:$(STAGING_DIR)/usr/share/pkgconfig diff --git a/include/site/aarch64 b/include/site/aarch64 new file mode 100644 index 0000000000..c5aa9c5543 --- /dev/null +++ b/include/site/aarch64 @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=yes} +ac_cv_c_bigendian=${ac_cv_c_bigendian=no} + +ac_cv_sizeof___int64=8 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=8 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=8 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=8 +ac_cv_sizeof_ssize_t=8 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=8 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=8 diff --git a/include/site/aarch64_be b/include/site/aarch64_be new file mode 100644 index 0000000000..19e75ab991 --- /dev/null +++ b/include/site/aarch64_be @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=no} +ac_cv_c_bigendian=${ac_cv_c_bigendian=yes} + +ac_cv_sizeof___int64=8 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=8 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=8 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=8 +ac_cv_sizeof_ssize_t=8 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=8 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=8 diff --git a/include/site/arc b/include/site/arc new file mode 100644 index 0000000000..72a3805c64 --- /dev/null +++ b/include/site/arc @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=yes} +ac_cv_c_bigendian=${ac_cv_c_bigendian=no} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=4 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=4 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=4 +ac_cv_sizeof_ssize_t=4 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=4 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=4 diff --git a/include/site/arm b/include/site/arm new file mode 100644 index 0000000000..72a3805c64 --- /dev/null +++ b/include/site/arm @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=yes} +ac_cv_c_bigendian=${ac_cv_c_bigendian=no} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=4 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=4 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=4 +ac_cv_sizeof_ssize_t=4 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=4 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=4 diff --git a/include/site/armeb b/include/site/armeb new file mode 100644 index 0000000000..a5626a722b --- /dev/null +++ b/include/site/armeb @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=no} +ac_cv_c_bigendian=${ac_cv_c_bigendian=yes} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=4 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=4 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=4 +ac_cv_sizeof_ssize_t=4 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=4 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=4 diff --git a/include/site/i386 b/include/site/i386 new file mode 100644 index 0000000000..78f1557b79 --- /dev/null +++ b/include/site/i386 @@ -0,0 +1,3 @@ +#!/bin/sh +. $TOPDIR/include/site/i486 + diff --git a/include/site/i486 b/include/site/i486 new file mode 100644 index 0000000000..72a3805c64 --- /dev/null +++ b/include/site/i486 @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=yes} +ac_cv_c_bigendian=${ac_cv_c_bigendian=no} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=4 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=4 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=4 +ac_cv_sizeof_ssize_t=4 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=4 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=4 diff --git a/include/site/i686 b/include/site/i686 new file mode 100644 index 0000000000..78f1557b79 --- /dev/null +++ b/include/site/i686 @@ -0,0 +1,3 @@ +#!/bin/sh +. $TOPDIR/include/site/i486 + diff --git a/include/site/linux b/include/site/linux new file mode 100644 index 0000000000..b193d25c45 --- /dev/null +++ b/include/site/linux @@ -0,0 +1,78 @@ +ac_atomic_add=yes +ac_atomic_sub=yes +ac_cv_c_gettext_without_libintl=yes +ac_cv_c_long_double=no +ac_cv_conv_longlong_to_float=yes +ac_cv_file__dev_zero=yes +ac_cv_func___va_copy=no +ac_cv_func__exit=yes +ac_cv_func_bcopy=yes +ac_cv_func_bzero=yes +ac_cv_func_bcmp=yes +ac_cv_func_creal=yes +ac_cv_func_cimag=yes +ac_cv_func_fchmod=yes +ac_cv_func_getaddrinfo=yes +ac_cv_func_getcwd=yes +ac_cv_func_getdomainname=yes +ac_cv_func_getpgrp_void=yes +ac_cv_func_getpwuid_r=yes +ac_cv_func_gettimeofday=yes +ac_cv_func_index=yes +ac_cv_func_lstat_dereferences_slashed_symlink=yes +ac_cv_func_lstat_empty_string_bug=no +ac_cv_func_lstat=yes +ac_cv_func_malloc_0_nonnull=yes +ac_cv_func_malloc_works=yes +ac_cv_func_memcmp_clean=yes +ac_cv_func_memcmp_working=yes +ac_cv_func_posix_getgrgid_r=yes +ac_cv_func_posix_getpwuid_r=yes +ac_cv_func_psignal=yes +ac_cv_func_pthread_key_delete=yes +ac_cv_func_realloc_0_nonnull=yes +ac_cv_func_realloc_works=yes +ac_cv_func_rename=yes +ac_cv_func_rindex=yes +ac_cv_func_setlocale=yes +ac_cv_func_setgrent_void=yes +ac_cv_func_setpgrp_void=yes +ac_cv_func_setresuid=no +ac_cv_func_setvbuf_reversed=no +ac_cv_func_stat_empty_string_bug=no +ac_cv_func_stat_ignores_trailing_slash=no +ac_cv_func_strerror=yes +ac_cv_func_strftime=yes +ac_cv_func_utimes=yes +ac_cv_func___adjtimex=yes +ac_cv_func_va_copy=no +ac_cv_func_vsnprintf=yes +ac_cv_have_accrights_in_msghdr=no +ac_cv_have_broken_snprintf=no +ac_cv_have_control_in_msghdr=yes +ac_cv_have_decl_sys_siglist=no +ac_cv_have_openpty_ctty_bug=yes +ac_cv_have_space_d_name_in_struct_dirent=yes +ac_cv_header_netinet_sctp_h=no +ac_cv_header_netinet_sctp_uio_h=no +ac_cv_int64_t=yes +ac_cv_lbl_unaligned_fail=no +ac_cv_linux_kernel_pppoe=yes +ac_cv_linux_vers=2 +ac_cv_pack_bitfields_reversed=yes +ac_cv_path_LDCONFIG= +ac_cv_regexec_segfault_emptystr=no +ac_cv_sctp=no +ac_cv_sys_restartable_syscalls=yes +ac_cv_time_r_type=POSIX +ac_cv_type_suseconds_t=yes +ac_cv_uchar=no +ac_cv_uint=yes +ac_cv_uint64_t=yes +ac_cv_ulong=yes +ac_cv_ushort=yes +ac_cv_va_copy=C99 +ac_cv_va_val_copy=yes +as_cv_unaligned_access=yes +ac_cv_func_malloc_0_nonnull=yes +ac_cv_func_realloc_0_nonnull=yes diff --git a/include/site/m68k b/include/site/m68k new file mode 100644 index 0000000000..0037600a09 --- /dev/null +++ b/include/site/m68k @@ -0,0 +1,28 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=no} +ac_cv_c_bigendian=${ac_cv_c_bigendian=yes} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=4 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=4 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=4 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=4 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=4 diff --git a/include/site/mips b/include/site/mips new file mode 100644 index 0000000000..a5626a722b --- /dev/null +++ b/include/site/mips @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=no} +ac_cv_c_bigendian=${ac_cv_c_bigendian=yes} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=4 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=4 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=4 +ac_cv_sizeof_ssize_t=4 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=4 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=4 diff --git a/include/site/mips64 b/include/site/mips64 new file mode 100644 index 0000000000..19e75ab991 --- /dev/null +++ b/include/site/mips64 @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=no} +ac_cv_c_bigendian=${ac_cv_c_bigendian=yes} + +ac_cv_sizeof___int64=8 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=8 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=8 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=8 +ac_cv_sizeof_ssize_t=8 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=8 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=8 diff --git a/include/site/mips64el b/include/site/mips64el new file mode 100644 index 0000000000..c5aa9c5543 --- /dev/null +++ b/include/site/mips64el @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=yes} +ac_cv_c_bigendian=${ac_cv_c_bigendian=no} + +ac_cv_sizeof___int64=8 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=8 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=8 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=8 +ac_cv_sizeof_ssize_t=8 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=8 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=8 diff --git a/include/site/mipsel b/include/site/mipsel new file mode 100644 index 0000000000..72a3805c64 --- /dev/null +++ b/include/site/mipsel @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=yes} +ac_cv_c_bigendian=${ac_cv_c_bigendian=no} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=4 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=4 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=4 +ac_cv_sizeof_ssize_t=4 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=4 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=4 diff --git a/include/site/powerpc b/include/site/powerpc new file mode 100644 index 0000000000..a5626a722b --- /dev/null +++ b/include/site/powerpc @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=no} +ac_cv_c_bigendian=${ac_cv_c_bigendian=yes} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=4 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=4 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=4 +ac_cv_sizeof_ssize_t=4 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=4 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=4 diff --git a/include/site/powerpc64 b/include/site/powerpc64 new file mode 100644 index 0000000000..6a66346b42 --- /dev/null +++ b/include/site/powerpc64 @@ -0,0 +1,26 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=no} +ac_cv_c_bigendian=${ac_cv_c_bigendian=yes} + +ac_cv_sizeof_char=1 +ac_cv_sizeof_char_p=8 +ac_cv_sizeof_double=8 +ac_cv_sizeof_float=4 +ac_cv_sizeof_int=4 +ac_cv_sizeof_long=8 +ac_cv_sizeof_long_double=16 +ac_cv_sizeof_long_int=8 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long_long_int=8 +ac_cv_sizeof_short=2 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_signed_char=1 +ac_cv_sizeof_unsigned_char=1 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=8 +ac_cv_sizeof_unsigned_long_int=8 +ac_cv_sizeof_unsigned_long_long_int=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_unsigned_short_int=2 +ac_cv_sizeof_void_p=8 diff --git a/include/site/sparc b/include/site/sparc new file mode 100644 index 0000000000..a5626a722b --- /dev/null +++ b/include/site/sparc @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=no} +ac_cv_c_bigendian=${ac_cv_c_bigendian=yes} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=4 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=4 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=4 +ac_cv_sizeof_ssize_t=4 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=4 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=4 diff --git a/include/site/x86_64 b/include/site/x86_64 new file mode 100644 index 0000000000..b8d581d448 --- /dev/null +++ b/include/site/x86_64 @@ -0,0 +1,30 @@ +#!/bin/sh +. $TOPDIR/include/site/linux +ac_cv_c_littleendian=${ac_cv_c_littleendian=yes} +ac_cv_c_bigendian=${ac_cv_c_bigendian=no} + +ac_cv_sizeof___int64=0 +ac_cv_sizeof_char=1 +ac_cv_sizeof_int=4 +ac_cv_sizeof_int16_t=2 +ac_cv_sizeof_int32_t=4 +ac_cv_sizeof_int64_t=8 +ac_cv_sizeof_long_int=8 +ac_cv_sizeof_long_long=8 +ac_cv_sizeof_long=8 +ac_cv_sizeof_off_t=8 +ac_cv_sizeof_short_int=2 +ac_cv_sizeof_short=2 +ac_cv_sizeof_size_t=8 +ac_cv_sizeof_ssize_t=8 +ac_cv_sizeof_u_int16_t=2 +ac_cv_sizeof_u_int32_t=4 +ac_cv_sizeof_u_int64_t=8 +ac_cv_sizeof_uint16_t=2 +ac_cv_sizeof_uint32_t=4 +ac_cv_sizeof_uint64_t=8 +ac_cv_sizeof_unsigned_int=4 +ac_cv_sizeof_unsigned_long=8 +ac_cv_sizeof_unsigned_long_long=8 +ac_cv_sizeof_unsigned_short=2 +ac_cv_sizeof_void_p=8 From ae22f0455ef2bbeafd9d2e7f4ebde570ee4e7712 Mon Sep 17 00:00:00 2001 From: Daniel Golle Date: Tue, 2 Mar 2021 11:34:24 +0000 Subject: [PATCH 4/8] Revert "toolchain: add autoconf-lean" autoconf-lean was not ready yet. Revert it until things get sorted. This reverts commit 32c664ff02910bf39a3fbd5a5a4a8bff3191dd03. Signed-off-by: Daniel Golle --- toolchain/Makefile | 3 +- toolchain/autoconf-lean/Makefile | 65 - toolchain/autoconf-lean/config.site | 1630 ----------------- .../patches/100-remove-unused-checks.patch | 93 - .../patches/120-add-extra-checks.patch | 48 - 5 files changed, 1 insertion(+), 1838 deletions(-) delete mode 100644 toolchain/autoconf-lean/Makefile delete mode 100644 toolchain/autoconf-lean/config.site delete mode 100644 toolchain/autoconf-lean/patches/100-remove-unused-checks.patch delete mode 100644 toolchain/autoconf-lean/patches/120-add-extra-checks.patch diff --git a/toolchain/Makefile b/toolchain/Makefile index b095d13ac3..5dccf8f829 100644 --- a/toolchain/Makefile +++ b/toolchain/Makefile @@ -29,7 +29,7 @@ curdir:=toolchain # subdirectories to descend into -$(curdir)/builddirs := $(if $(CONFIG_GDB),gdb) $(if $(CONFIG_EXTERNAL_TOOLCHAIN),wrapper,kernel-headers binutils gcc/initial gcc/final $(LIBC) fortify-headers) $(if $(CONFIG_NASM),nasm) autoconf-lean +$(curdir)/builddirs := $(if $(CONFIG_GDB),gdb) $(if $(CONFIG_EXTERNAL_TOOLCHAIN),wrapper,kernel-headers binutils gcc/initial gcc/final $(LIBC) fortify-headers) $(if $(CONFIG_NASM),nasm) # builddir dependencies ifeq ($(CONFIG_EXTERNAL_TOOLCHAIN),) @@ -48,7 +48,6 @@ ifeq ($(CONFIG_EXTERNAL_TOOLCHAIN),) $(curdir)/$(LIBC)/compile:=$(curdir)/gcc/initial/compile $(curdir)/gcc/final/compile:=$(curdir)/$(LIBC)/compile $(curdir)/kernel-headers/compile $(curdir)/$(LIBC)/utils/compile:=$(curdir)/gcc/final/compile - $(curdir)/autoconf-lean/compile:=$(curdir)/gcc/final/compile endif ifndef DUMP_TARGET_DB diff --git a/toolchain/autoconf-lean/Makefile b/toolchain/autoconf-lean/Makefile deleted file mode 100644 index 5971e9fe5e..0000000000 --- a/toolchain/autoconf-lean/Makefile +++ /dev/null @@ -1,65 +0,0 @@ -# This is free software, licensed under the GNU General Public License v2. -# See /LICENSE for more information. -# - -include $(TOPDIR)/rules.mk - -PKG_NAME:=autoconf-lean -PKG_RELEASE:=1 - -PKG_SOURCE_PROTO:=git -PKG_SOURCE_DATE:=2012-09-01 -PKG_SOURCE_URL:=https://github.com/GregorR/autoconf-lean -PKG_SOURCE_VERSION:=bd81206959881c511b28e16e81b0a281fd15bd02 - -PKG_HASH:=e728ed296fe9f069a0e005003c3d6b2dde3d9cad453422a10d6558616d304cc8 - -HOST_FIXUP := autoreconf - -HOST_BUILD_PREFIX:=$(TOOLCHAIN_DIR) -BUILD_DIR_HOST:=$(BUILD_DIR_TOOLCHAIN) - -include $(INCLUDE_DIR)/host-build.mk - -HOST_CONFIG_SITE:=$(CURDIR)/config.site - -CONFIGURE_PATH := config-site-generator - -HOST_CONFIGURE_VARS := \ - $(TARGET_CONFIGURE_OPTS) \ - CFLAGS="$(TARGET_CFLAGS)" \ - CXXFLAGS="$(TARGET_CXXFLAGS)" \ - CPPFLAGS="$(TARGET_CPPFLAGS)" \ - LDFLAGS="$(TARGET_LDFLAGS)" - -HOST_CONFIGURE_ARGS := \ - --target=$(GNU_TARGET_NAME) \ - --host=$(GNU_TARGET_NAME) \ - --build=$(GNU_HOST_NAME) \ - --program-prefix="" \ - --program-suffix="" \ - --prefix=$(TOOLCHAIN_DIR) \ - --exec-prefix=$(TOOLCHAIN_DIR) \ - --bindir=$(TOOLCHAIN_DIR)/bin \ - --sbindir=$(TOOLCHAIN_DIR)/sbin \ - --libexecdir=$(TOOLCHAIN_DIR)/lib - -HOST_MAKE_VARS := - -HOST_MAKE_FLAGS := - -define Host/Configure - $(call Host/Configure/Default,,,config-site-generator) -endef - -define Host/Compile - $(MAKE) -C $(HOST_BUILD_DIR)/config-site-generator -endef - -define Host/Install - grep -v '/' \ - $(HOST_BUILD_DIR)/config-site-generator/config.site \ - > $(TOOLCHAIN_DIR)/config.site -endef - -$(eval $(call HostBuild)) diff --git a/toolchain/autoconf-lean/config.site b/toolchain/autoconf-lean/config.site deleted file mode 100644 index d2625160ef..0000000000 --- a/toolchain/autoconf-lean/config.site +++ /dev/null @@ -1,1630 +0,0 @@ -# generic defaults for speeding up generating the real config.site -ac_cv_c_backslash_a=${ac_cv_c_backslash_a=yes} -ac_cv_c_compiler_gnu=${ac_cv_c_compiler_gnu=yes} -ac_cv_c_const=${ac_cv_c_const=yes} -ac_cv_c_flexmember=${ac_cv_c_flexmember=yes} -ac_cv_c_inline=${ac_cv_c_inline=inline} -ac_cv_c_int16_t=${ac_cv_c_int16_t=yes} -ac_cv_c_int32_t=${ac_cv_c_int32_t=yes} -ac_cv_c_int64_t=${ac_cv_c_int64_t=yes} -ac_cv_c_int8_t=${ac_cv_c_int8_t=yes} -ac_cv_c_restrict=${ac_cv_c_restrict=__restrict} -ac_cv_c_stringize=${ac_cv_c_stringize=yes} -ac_cv_c_typeof=${ac_cv_c_typeof=typeof} -ac_cv_c_uint16_t=${ac_cv_c_uint16_t=yes} -ac_cv_c_uint32_t=${ac_cv_c_uint32_t=yes} -ac_cv_c_uint64_t=${ac_cv_c_uint64_t=yes} -ac_cv_c_uint8_t=${ac_cv_c_uint8_t=yes} -ac_cv_c_vararrays=${ac_cv_c_vararrays=yes} -ac_cv_c_volatile=${ac_cv_c_volatile=yes} -ac_cv_cxx_compiler_gnu=${ac_cv_cxx_compiler_gnu=yes} -ac_cv_file__dev_zero=${ac_cv_file__dev_zero=yes} -ac_cv_func___adjtimex=${ac_cv_func___adjtimex=yes} -ac_cv_func___va_copy=${ac_cv_func___va_copy=no} -ac_cv_func__doprnt=${ac_cv_func__doprnt=no} -ac_cv_func__exit=${ac_cv_func__exit=yes} -ac_cv_func_a64l=${ac_cv_func_a64l=yes} -ac_cv_func_abort=${ac_cv_func_abort=yes} -ac_cv_func_abs=${ac_cv_func_abs=yes} -ac_cv_func_accept=${ac_cv_func_accept=yes} -ac_cv_func_access=${ac_cv_func_access=yes} -ac_cv_func_acos=${ac_cv_func_acos=yes} -ac_cv_func_acosf=${ac_cv_func_acosf=yes} -ac_cv_func_acosh=${ac_cv_func_acosh=yes} -ac_cv_func_acoshf=${ac_cv_func_acoshf=yes} -ac_cv_func_acoshl=${ac_cv_func_acoshl=yes} -ac_cv_func_acosl=${ac_cv_func_acosl=yes} -ac_cv_func_addmntent=${ac_cv_func_addmntent=yes} -ac_cv_func_adjtime=${ac_cv_func_adjtime=yes} -ac_cv_func_adjtimex=${ac_cv_func_adjtimex=yes} -ac_cv_func_aio_cancel=${ac_cv_func_aio_cancel=yes} -ac_cv_func_aio_error=${ac_cv_func_aio_error=yes} -ac_cv_func_aio_fsync=${ac_cv_func_aio_fsync=yes} -ac_cv_func_aio_read=${ac_cv_func_aio_read=yes} -ac_cv_func_aio_return=${ac_cv_func_aio_return=yes} -ac_cv_func_aio_suspend=${ac_cv_func_aio_suspend=yes} -ac_cv_func_aio_write=${ac_cv_func_aio_write=yes} -ac_cv_func_alarm=${ac_cv_func_alarm=yes} -ac_cv_func_alloca_works=${ac_cv_func_alloca_works=yes} -ac_cv_func_alphasort64=${ac_cv_func_alphasort64=yes} -ac_cv_func_alphasort=${ac_cv_func_alphasort=yes} -ac_cv_func_asctime=${ac_cv_func_asctime=yes} -ac_cv_func_asctime_r=${ac_cv_func_asctime_r=yes} -ac_cv_func_asin=${ac_cv_func_asin=yes} -ac_cv_func_asinf=${ac_cv_func_asinf=yes} -ac_cv_func_asinh=${ac_cv_func_asinh=yes} -ac_cv_func_asinhf=${ac_cv_func_asinhf=yes} -ac_cv_func_asinhl=${ac_cv_func_asinhl=yes} -ac_cv_func_asinl=${ac_cv_func_asinl=yes} -ac_cv_func_asprintf=${ac_cv_func_asprintf=yes} -ac_cv_func_atan2=${ac_cv_func_atan2=yes} -ac_cv_func_atan2f=${ac_cv_func_atan2f=yes} -ac_cv_func_atan2l=${ac_cv_func_atan2l=yes} -ac_cv_func_atan=${ac_cv_func_atan=yes} -ac_cv_func_atanf=${ac_cv_func_atanf=yes} -ac_cv_func_atanh=${ac_cv_func_atanh=yes} -ac_cv_func_atanhf=${ac_cv_func_atanhf=yes} -ac_cv_func_atanhl=${ac_cv_func_atanhl=yes} -ac_cv_func_atanl=${ac_cv_func_atanl=yes} -ac_cv_func_atexit=${ac_cv_func_atexit=yes} -ac_cv_func_atof=${ac_cv_func_atof=yes} -ac_cv_func_atoi=${ac_cv_func_atoi=yes} -ac_cv_func_atol=${ac_cv_func_atol=yes} -ac_cv_func_atoll=${ac_cv_func_atoll=yes} -ac_cv_func_basename=${ac_cv_func_basename=yes} -ac_cv_func_bcmp=${ac_cv_func_bcmp=yes} -ac_cv_func_bcopy=${ac_cv_func_bcopy=yes} -ac_cv_func_bind=${ac_cv_func_bind=yes} -ac_cv_func_bind_textdomain_codeset=${ac_cv_func_bind_textdomain_codeset=yes} -ac_cv_func_bindtextdomain=${ac_cv_func_bindtextdomain=yes} -ac_cv_func_brk=${ac_cv_func_brk=yes} -ac_cv_func_bsd_signal=${ac_cv_func_bsd_signal=yes} -ac_cv_func_bsearch=${ac_cv_func_bsearch=yes} -ac_cv_func_btowc=${ac_cv_func_btowc=yes} -ac_cv_func_bzero=${ac_cv_func_bzero=yes} -ac_cv_func_cabs=${ac_cv_func_cabs=yes} -ac_cv_func_cabsf=${ac_cv_func_cabsf=yes} -ac_cv_func_cabsl=${ac_cv_func_cabsl=yes} -ac_cv_func_cacos=${ac_cv_func_cacos=yes} -ac_cv_func_cacosf=${ac_cv_func_cacosf=yes} -ac_cv_func_cacosh=${ac_cv_func_cacosh=yes} -ac_cv_func_cacoshf=${ac_cv_func_cacoshf=yes} -ac_cv_func_cacoshl=${ac_cv_func_cacoshl=yes} -ac_cv_func_cacosl=${ac_cv_func_cacosl=yes} -ac_cv_func_calloc=${ac_cv_func_calloc=yes} -ac_cv_func_capget=${ac_cv_func_capget=yes} -ac_cv_func_capset=${ac_cv_func_capset=yes} -ac_cv_func_carg=${ac_cv_func_carg=yes} -ac_cv_func_cargf=${ac_cv_func_cargf=yes} -ac_cv_func_cargl=${ac_cv_func_cargl=yes} -ac_cv_func_casin=${ac_cv_func_casin=yes} -ac_cv_func_casinf=${ac_cv_func_casinf=yes} -ac_cv_func_casinh=${ac_cv_func_casinh=yes} -ac_cv_func_casinhf=${ac_cv_func_casinhf=yes} -ac_cv_func_casinhl=${ac_cv_func_casinhl=yes} -ac_cv_func_casinl=${ac_cv_func_casinl=yes} -ac_cv_func_catan=${ac_cv_func_catan=yes} -ac_cv_func_catanf=${ac_cv_func_catanf=yes} -ac_cv_func_catanh=${ac_cv_func_catanh=yes} -ac_cv_func_catanhf=${ac_cv_func_catanhf=yes} -ac_cv_func_catanhl=${ac_cv_func_catanhl=yes} -ac_cv_func_catanl=${ac_cv_func_catanl=yes} -ac_cv_func_catclose=${ac_cv_func_catclose=yes} -ac_cv_func_catgets=${ac_cv_func_catgets=yes} -ac_cv_func_catopen=${ac_cv_func_catopen=yes} -ac_cv_func_cbrt=${ac_cv_func_cbrt=yes} -ac_cv_func_cbrtf=${ac_cv_func_cbrtf=yes} -ac_cv_func_cbrtl=${ac_cv_func_cbrtl=yes} -ac_cv_func_ccos=${ac_cv_func_ccos=yes} -ac_cv_func_ccosf=${ac_cv_func_ccosf=yes} -ac_cv_func_ccosh=${ac_cv_func_ccosh=yes} -ac_cv_func_ccoshf=${ac_cv_func_ccoshf=yes} -ac_cv_func_ccoshl=${ac_cv_func_ccoshl=yes} -ac_cv_func_ccosl=${ac_cv_func_ccosl=yes} -ac_cv_func_ceil=${ac_cv_func_ceil=yes} -ac_cv_func_ceilf=${ac_cv_func_ceilf=yes} -ac_cv_func_ceill=${ac_cv_func_ceill=yes} -ac_cv_func_cexp=${ac_cv_func_cexp=yes} -ac_cv_func_cexpf=${ac_cv_func_cexpf=yes} -ac_cv_func_cexpl=${ac_cv_func_cexpl=yes} -ac_cv_func_cfgetispeed=${ac_cv_func_cfgetispeed=yes} -ac_cv_func_cfgetospeed=${ac_cv_func_cfgetospeed=yes} -ac_cv_func_cfmakeraw=${ac_cv_func_cfmakeraw=yes} -ac_cv_func_cfsetispeed=${ac_cv_func_cfsetispeed=yes} -ac_cv_func_cfsetospeed=${ac_cv_func_cfsetospeed=yes} -ac_cv_func_cfsetspeed=${ac_cv_func_cfsetspeed=yes} -ac_cv_func_chdir=${ac_cv_func_chdir=yes} -ac_cv_func_chmod=${ac_cv_func_chmod=yes} -ac_cv_func_chown=${ac_cv_func_chown=yes} -ac_cv_func_chown_works=${ac_cv_func_chown_works=no} -ac_cv_func_chroot=${ac_cv_func_chroot=yes} -ac_cv_func_cimag=${ac_cv_func_cimag=yes} -ac_cv_func_cimagf=${ac_cv_func_cimagf=yes} -ac_cv_func_cimagl=${ac_cv_func_cimagl=yes} -ac_cv_func_clearenv=${ac_cv_func_clearenv=yes} -ac_cv_func_clearerr=${ac_cv_func_clearerr=yes} -ac_cv_func_clearerr_unlocked=${ac_cv_func_clearerr_unlocked=yes} -ac_cv_func_clock=${ac_cv_func_clock=yes} -ac_cv_func_clock_getcpuclockid=${ac_cv_func_clock_getcpuclockid=yes} -ac_cv_func_clock_getres=${ac_cv_func_clock_getres=yes} -ac_cv_func_clock_gettime=${ac_cv_func_clock_gettime=yes} -ac_cv_func_clock_nanosleep=${ac_cv_func_clock_nanosleep=yes} -ac_cv_func_clock_settime=${ac_cv_func_clock_settime=yes} -ac_cv_func_clog=${ac_cv_func_clog=yes} -ac_cv_func_clogf=${ac_cv_func_clogf=yes} -ac_cv_func_clogl=${ac_cv_func_clogl=yes} -ac_cv_func_clone=${ac_cv_func_clone=yes} -ac_cv_func_close=${ac_cv_func_close=yes} -ac_cv_func_closedir=${ac_cv_func_closedir=yes} -ac_cv_func_closedir_void=${ac_cv_func_closedir_void=yes} -ac_cv_func_closelog=${ac_cv_func_closelog=yes} -ac_cv_func_confstr=${ac_cv_func_confstr=yes} -ac_cv_func_conj=${ac_cv_func_conj=yes} -ac_cv_func_conjf=${ac_cv_func_conjf=yes} -ac_cv_func_conjl=${ac_cv_func_conjl=yes} -ac_cv_func_connect=${ac_cv_func_connect=yes} -ac_cv_func_copysign=${ac_cv_func_copysign=yes} -ac_cv_func_copysignf=${ac_cv_func_copysignf=yes} -ac_cv_func_copysignl=${ac_cv_func_copysignl=yes} -ac_cv_func_cos=${ac_cv_func_cos=yes} -ac_cv_func_cosf=${ac_cv_func_cosf=yes} -ac_cv_func_cosh=${ac_cv_func_cosh=yes} -ac_cv_func_coshf=${ac_cv_func_coshf=yes} -ac_cv_func_coshl=${ac_cv_func_coshl=yes} -ac_cv_func_cosl=${ac_cv_func_cosl=yes} -ac_cv_func_cpow=${ac_cv_func_cpow=yes} -ac_cv_func_cpowf=${ac_cv_func_cpowf=yes} -ac_cv_func_cpowl=${ac_cv_func_cpowl=yes} -ac_cv_func_cproj=${ac_cv_func_cproj=yes} -ac_cv_func_cprojf=${ac_cv_func_cprojf=yes} -ac_cv_func_cprojl=${ac_cv_func_cprojl=yes} -ac_cv_func_creal=${ac_cv_func_creal=yes} -ac_cv_func_crealf=${ac_cv_func_crealf=yes} -ac_cv_func_creall=${ac_cv_func_creall=yes} -ac_cv_func_creat64=${ac_cv_func_creat64=yes} -ac_cv_func_creat=${ac_cv_func_creat=yes} -ac_cv_func_crypt=${ac_cv_func_crypt=yes} -ac_cv_func_crypt_r=${ac_cv_func_crypt_r=yes} -ac_cv_func_csin=${ac_cv_func_csin=yes} -ac_cv_func_csinf=${ac_cv_func_csinf=yes} -ac_cv_func_csinh=${ac_cv_func_csinh=yes} -ac_cv_func_csinhf=${ac_cv_func_csinhf=yes} -ac_cv_func_csinhl=${ac_cv_func_csinhl=yes} -ac_cv_func_csinl=${ac_cv_func_csinl=yes} -ac_cv_func_csqrt=${ac_cv_func_csqrt=yes} -ac_cv_func_csqrtf=${ac_cv_func_csqrtf=yes} -ac_cv_func_csqrtl=${ac_cv_func_csqrtl=yes} -ac_cv_func_ctan=${ac_cv_func_ctan=yes} -ac_cv_func_ctanf=${ac_cv_func_ctanf=yes} -ac_cv_func_ctanh=${ac_cv_func_ctanh=yes} -ac_cv_func_ctanhf=${ac_cv_func_ctanhf=yes} -ac_cv_func_ctanhl=${ac_cv_func_ctanhl=yes} -ac_cv_func_ctanl=${ac_cv_func_ctanl=yes} -ac_cv_func_ctermid=${ac_cv_func_ctermid=yes} -ac_cv_func_ctime=${ac_cv_func_ctime=yes} -ac_cv_func_ctime_r=${ac_cv_func_ctime_r=yes} -ac_cv_func_cuserid=${ac_cv_func_cuserid=yes} -ac_cv_func_daemon=${ac_cv_func_daemon=yes} -ac_cv_func_daylight=${ac_cv_func_daylight=yes} -ac_cv_func_dcgettext=${ac_cv_func_dcgettext=yes} -ac_cv_func_dcngettext=${ac_cv_func_dcngettext=yes} -ac_cv_func_delete_module=${ac_cv_func_delete_module=yes} -ac_cv_func_dgettext=${ac_cv_func_dgettext=yes} -ac_cv_func_difftime=${ac_cv_func_difftime=yes} -ac_cv_func_dirfd=${ac_cv_func_dirfd=yes} -ac_cv_func_dirname=${ac_cv_func_dirname=yes} -ac_cv_func_div=${ac_cv_func_div=yes} -ac_cv_func_dlclose=${ac_cv_func_dlclose=yes} -ac_cv_func_dlerror=${ac_cv_func_dlerror=yes} -ac_cv_func_dlopen=${ac_cv_func_dlopen=yes} -ac_cv_func_dlsym=${ac_cv_func_dlsym=yes} -ac_cv_func_dn_expand=${ac_cv_func_dn_expand=yes} -ac_cv_func_dngettext=${ac_cv_func_dngettext=yes} -ac_cv_func_dprintf=${ac_cv_func_dprintf=yes} -ac_cv_func_drand48=${ac_cv_func_drand48=yes} -ac_cv_func_dup2=${ac_cv_func_dup2=yes} -ac_cv_func_dup=${ac_cv_func_dup=yes} -ac_cv_func_duplocale=${ac_cv_func_duplocale=yes} -ac_cv_func_ecvt=${ac_cv_func_ecvt=yes} -ac_cv_func_endgrent=${ac_cv_func_endgrent=yes} -ac_cv_func_endhostent=${ac_cv_func_endhostent=yes} -ac_cv_func_endmntent=${ac_cv_func_endmntent=yes} -ac_cv_func_endnetent=${ac_cv_func_endnetent=yes} -ac_cv_func_endprotoent=${ac_cv_func_endprotoent=yes} -ac_cv_func_endpwent=${ac_cv_func_endpwent=yes} -ac_cv_func_endservent=${ac_cv_func_endservent=yes} -ac_cv_func_endspent=${ac_cv_func_endspent=yes} -ac_cv_func_endusershell=${ac_cv_func_endusershell=yes} -ac_cv_func_endutent=${ac_cv_func_endutent=yes} -ac_cv_func_endutxent=${ac_cv_func_endutxent=yes} -ac_cv_func_environ=${ac_cv_func_environ=yes} -ac_cv_func_epoll_create1=${ac_cv_func_epoll_create1=yes} -ac_cv_func_epoll_create=${ac_cv_func_epoll_create=yes} -ac_cv_func_epoll_ctl=${ac_cv_func_epoll_ctl=yes} -ac_cv_func_epoll_pwait=${ac_cv_func_epoll_pwait=yes} -ac_cv_func_epoll_wait=${ac_cv_func_epoll_wait=yes} -ac_cv_func_erand48=${ac_cv_func_erand48=yes} -ac_cv_func_erf=${ac_cv_func_erf=yes} -ac_cv_func_erfc=${ac_cv_func_erfc=yes} -ac_cv_func_erfcf=${ac_cv_func_erfcf=yes} -ac_cv_func_erfcl=${ac_cv_func_erfcl=yes} -ac_cv_func_erff=${ac_cv_func_erff=yes} -ac_cv_func_erfl=${ac_cv_func_erfl=yes} -ac_cv_func_err=${ac_cv_func_err=yes} -ac_cv_func_errx=${ac_cv_func_errx=yes} -ac_cv_func_eventfd=${ac_cv_func_eventfd=yes} -ac_cv_func_eventfd_read=${ac_cv_func_eventfd_read=yes} -ac_cv_func_eventfd_write=${ac_cv_func_eventfd_write=yes} -ac_cv_func_execl=${ac_cv_func_execl=yes} -ac_cv_func_execle=${ac_cv_func_execle=yes} -ac_cv_func_execlp=${ac_cv_func_execlp=yes} -ac_cv_func_execv=${ac_cv_func_execv=yes} -ac_cv_func_execve=${ac_cv_func_execve=yes} -ac_cv_func_execvp=${ac_cv_func_execvp=yes} -ac_cv_func_exit=${ac_cv_func_exit=yes} -ac_cv_func_exp10=${ac_cv_func_exp10=yes} -ac_cv_func_exp10f=${ac_cv_func_exp10f=yes} -ac_cv_func_exp10l=${ac_cv_func_exp10l=yes} -ac_cv_func_exp2=${ac_cv_func_exp2=yes} -ac_cv_func_exp2f=${ac_cv_func_exp2f=yes} -ac_cv_func_exp2l=${ac_cv_func_exp2l=yes} -ac_cv_func_exp=${ac_cv_func_exp=yes} -ac_cv_func_expf=${ac_cv_func_expf=yes} -ac_cv_func_expl=${ac_cv_func_expl=yes} -ac_cv_func_expm1=${ac_cv_func_expm1=yes} -ac_cv_func_expm1f=${ac_cv_func_expm1f=yes} -ac_cv_func_expm1l=${ac_cv_func_expm1l=yes} -ac_cv_func_fabs=${ac_cv_func_fabs=yes} -ac_cv_func_fabsf=${ac_cv_func_fabsf=yes} -ac_cv_func_fabsl=${ac_cv_func_fabsl=yes} -ac_cv_func_faccessat=${ac_cv_func_faccessat=yes} -ac_cv_func_fchdir=${ac_cv_func_fchdir=yes} -ac_cv_func_fchmod=${ac_cv_func_fchmod=yes} -ac_cv_func_fchmodat=${ac_cv_func_fchmodat=yes} -ac_cv_func_fchown=${ac_cv_func_fchown=yes} -ac_cv_func_fchownat=${ac_cv_func_fchownat=yes} -ac_cv_func_fclose=${ac_cv_func_fclose=yes} -ac_cv_func_fcntl=${ac_cv_func_fcntl=yes} -ac_cv_func_fcvt=${ac_cv_func_fcvt=yes} -ac_cv_func_fdatasync=${ac_cv_func_fdatasync=yes} -ac_cv_func_fdim=${ac_cv_func_fdim=yes} -ac_cv_func_fdimf=${ac_cv_func_fdimf=yes} -ac_cv_func_fdiml=${ac_cv_func_fdiml=yes} -ac_cv_func_fdopen=${ac_cv_func_fdopen=yes} -ac_cv_func_fdopendir=${ac_cv_func_fdopendir=yes} -ac_cv_func_feclearexcept=${ac_cv_func_feclearexcept=yes} -ac_cv_func_fegetenv=${ac_cv_func_fegetenv=yes} -ac_cv_func_fegetexceptflag=${ac_cv_func_fegetexceptflag=yes} -ac_cv_func_fegetround=${ac_cv_func_fegetround=yes} -ac_cv_func_feholdexcept=${ac_cv_func_feholdexcept=yes} -ac_cv_func_feof=${ac_cv_func_feof=yes} -ac_cv_func_feof_unlocked=${ac_cv_func_feof_unlocked=yes} -ac_cv_func_feraiseexcept=${ac_cv_func_feraiseexcept=yes} -ac_cv_func_ferror=${ac_cv_func_ferror=yes} -ac_cv_func_ferror_unlocked=${ac_cv_func_ferror_unlocked=yes} -ac_cv_func_fesetenv=${ac_cv_func_fesetenv=yes} -ac_cv_func_fesetexceptflag=${ac_cv_func_fesetexceptflag=yes} -ac_cv_func_fesetround=${ac_cv_func_fesetround=yes} -ac_cv_func_fetestexcept=${ac_cv_func_fetestexcept=yes} -ac_cv_func_feupdateenv=${ac_cv_func_feupdateenv=yes} -ac_cv_func_fexecve=${ac_cv_func_fexecve=yes} -ac_cv_func_fflush=${ac_cv_func_fflush=yes} -ac_cv_func_fflush_unlocked=${ac_cv_func_fflush_unlocked=yes} -ac_cv_func_ffs=${ac_cv_func_ffs=yes} -ac_cv_func_fgetc=${ac_cv_func_fgetc=yes} -ac_cv_func_fgetc_unlocked=${ac_cv_func_fgetc_unlocked=yes} -ac_cv_func_fgetln=${ac_cv_func_fgetln=yes} -ac_cv_func_fgetpos64=${ac_cv_func_fgetpos64=yes} -ac_cv_func_fgetpos=${ac_cv_func_fgetpos=yes} -ac_cv_func_fgetpwent=${ac_cv_func_fgetpwent=yes} -ac_cv_func_fgets=${ac_cv_func_fgets=yes} -ac_cv_func_fgets_unlocked=${ac_cv_func_fgets_unlocked=yes} -ac_cv_func_fgetwc=${ac_cv_func_fgetwc=yes} -ac_cv_func_fgetwc_unlocked=${ac_cv_func_fgetwc_unlocked=yes} -ac_cv_func_fgetws=${ac_cv_func_fgetws=yes} -ac_cv_func_fgetws_unlocked=${ac_cv_func_fgetws_unlocked=yes} -ac_cv_func_fgetxattr=${ac_cv_func_fgetxattr=yes} -ac_cv_func_fileno=${ac_cv_func_fileno=yes} -ac_cv_func_fileno_unlocked=${ac_cv_func_fileno_unlocked=yes} -ac_cv_func_flistxattr=${ac_cv_func_flistxattr=yes} -ac_cv_func_flock=${ac_cv_func_flock=yes} -ac_cv_func_flockfile=${ac_cv_func_flockfile=yes} -ac_cv_func_floor=${ac_cv_func_floor=yes} -ac_cv_func_floorf=${ac_cv_func_floorf=yes} -ac_cv_func_floorl=${ac_cv_func_floorl=yes} -ac_cv_func_fma=${ac_cv_func_fma=yes} -ac_cv_func_fmaf=${ac_cv_func_fmaf=yes} -ac_cv_func_fmal=${ac_cv_func_fmal=yes} -ac_cv_func_fmax=${ac_cv_func_fmax=yes} -ac_cv_func_fmaxf=${ac_cv_func_fmaxf=yes} -ac_cv_func_fmaxl=${ac_cv_func_fmaxl=yes} -ac_cv_func_fmemopen=${ac_cv_func_fmemopen=yes} -ac_cv_func_fmin=${ac_cv_func_fmin=yes} -ac_cv_func_fminf=${ac_cv_func_fminf=yes} -ac_cv_func_fminl=${ac_cv_func_fminl=yes} -ac_cv_func_fmod=${ac_cv_func_fmod=yes} -ac_cv_func_fmodf=${ac_cv_func_fmodf=yes} -ac_cv_func_fmodl=${ac_cv_func_fmodl=yes} -ac_cv_func_fnmatch=${ac_cv_func_fnmatch=yes} -ac_cv_func_fnmatch_works=${ac_cv_func_fnmatch_works=cross} -ac_cv_func_fopen64=${ac_cv_func_fopen64=yes} -ac_cv_func_fopen=${ac_cv_func_fopen=yes} -ac_cv_func_fork=${ac_cv_func_fork=yes} -ac_cv_func_fork_works=${ac_cv_func_fork_works=yes} -ac_cv_func_forkpty=${ac_cv_func_forkpty=yes} -ac_cv_func_fpathconf=${ac_cv_func_fpathconf=yes} -ac_cv_func_fprintf=${ac_cv_func_fprintf=yes} -ac_cv_func_fpurge=${ac_cv_func_fpurge=yes} -ac_cv_func_fputc=${ac_cv_func_fputc=yes} -ac_cv_func_fputc_unlocked=${ac_cv_func_fputc_unlocked=yes} -ac_cv_func_fputs=${ac_cv_func_fputs=yes} -ac_cv_func_fputs_unlocked=${ac_cv_func_fputs_unlocked=yes} -ac_cv_func_fputwc=${ac_cv_func_fputwc=yes} -ac_cv_func_fputwc_unlocked=${ac_cv_func_fputwc_unlocked=yes} -ac_cv_func_fputws=${ac_cv_func_fputws=yes} -ac_cv_func_fputws_unlocked=${ac_cv_func_fputws_unlocked=yes} -ac_cv_func_fread=${ac_cv_func_fread=yes} -ac_cv_func_fread_unlocked=${ac_cv_func_fread_unlocked=yes} -ac_cv_func_free=${ac_cv_func_free=yes} -ac_cv_func_freeaddrinfo=${ac_cv_func_freeaddrinfo=yes} -ac_cv_func_freelocale=${ac_cv_func_freelocale=yes} -ac_cv_func_fremovexattr=${ac_cv_func_fremovexattr=yes} -ac_cv_func_freopen64=${ac_cv_func_freopen64=yes} -ac_cv_func_freopen=${ac_cv_func_freopen=yes} -ac_cv_func_frexp=${ac_cv_func_frexp=yes} -ac_cv_func_frexpf=${ac_cv_func_frexpf=yes} -ac_cv_func_frexpl=${ac_cv_func_frexpl=yes} -ac_cv_func_fscanf=${ac_cv_func_fscanf=yes} -ac_cv_func_fseek=${ac_cv_func_fseek=yes} -ac_cv_func_fseeko64=${ac_cv_func_fseeko64=yes} -ac_cv_func_fseeko=${ac_cv_func_fseeko=yes} -ac_cv_func_fsetpos64=${ac_cv_func_fsetpos64=yes} -ac_cv_func_fsetpos=${ac_cv_func_fsetpos=yes} -ac_cv_func_fsetxattr=${ac_cv_func_fsetxattr=yes} -ac_cv_func_fstat64=${ac_cv_func_fstat64=yes} -ac_cv_func_fstat=${ac_cv_func_fstat=yes} -ac_cv_func_fstatat64=${ac_cv_func_fstatat64=yes} -ac_cv_func_fstatat=${ac_cv_func_fstatat=yes} -ac_cv_func_fstatfs64=${ac_cv_func_fstatfs64=yes} -ac_cv_func_fstatfs=${ac_cv_func_fstatfs=yes} -ac_cv_func_fstatvfs64=${ac_cv_func_fstatvfs64=yes} -ac_cv_func_fstatvfs=${ac_cv_func_fstatvfs=yes} -ac_cv_func_fsync=${ac_cv_func_fsync=yes} -ac_cv_func_ftell=${ac_cv_func_ftell=yes} -ac_cv_func_ftello64=${ac_cv_func_ftello64=yes} -ac_cv_func_ftello=${ac_cv_func_ftello=yes} -ac_cv_func_ftok=${ac_cv_func_ftok=yes} -ac_cv_func_ftruncate64=${ac_cv_func_ftruncate64=yes} -ac_cv_func_ftruncate=${ac_cv_func_ftruncate=yes} -ac_cv_func_ftrylockfile=${ac_cv_func_ftrylockfile=yes} -ac_cv_func_ftw64=${ac_cv_func_ftw64=yes} -ac_cv_func_ftw=${ac_cv_func_ftw=yes} -ac_cv_func_funlockfile=${ac_cv_func_funlockfile=yes} -ac_cv_func_futimens=${ac_cv_func_futimens=yes} -ac_cv_func_futimes=${ac_cv_func_futimes=yes} -ac_cv_func_fwide=${ac_cv_func_fwide=yes} -ac_cv_func_fwprintf=${ac_cv_func_fwprintf=yes} -ac_cv_func_fwrite=${ac_cv_func_fwrite=yes} -ac_cv_func_fwrite_unlocked=${ac_cv_func_fwrite_unlocked=yes} -ac_cv_func_fwscanf=${ac_cv_func_fwscanf=yes} -ac_cv_func_gai_strerror=${ac_cv_func_gai_strerror=yes} -ac_cv_func_gcvt=${ac_cv_func_gcvt=yes} -ac_cv_func_get_current_dir_name=${ac_cv_func_get_current_dir_name=yes} -ac_cv_func_getaddrinfo=${ac_cv_func_getaddrinfo=yes} -ac_cv_func_getc=${ac_cv_func_getc=yes} -ac_cv_func_getc_unlocked=${ac_cv_func_getc_unlocked=yes} -ac_cv_func_getchar=${ac_cv_func_getchar=yes} -ac_cv_func_getchar_unlocked=${ac_cv_func_getchar_unlocked=yes} -ac_cv_func_getcwd=${ac_cv_func_getcwd=yes} -ac_cv_func_getdate=${ac_cv_func_getdate=yes} -ac_cv_func_getdate_err=${ac_cv_func_getdate_err=yes} -ac_cv_func_getdelim=${ac_cv_func_getdelim=yes} -ac_cv_func_getdents64=${ac_cv_func_getdents64=yes} -ac_cv_func_getdents=${ac_cv_func_getdents=yes} -ac_cv_func_getdomainname=${ac_cv_func_getdomainname=yes} -ac_cv_func_getdtablesize=${ac_cv_func_getdtablesize=yes} -ac_cv_func_getegid=${ac_cv_func_getegid=yes} -ac_cv_func_getenv=${ac_cv_func_getenv=yes} -ac_cv_func_geteuid=${ac_cv_func_geteuid=yes} -ac_cv_func_getgid=${ac_cv_func_getgid=yes} -ac_cv_func_getgrent=${ac_cv_func_getgrent=yes} -ac_cv_func_getgrgid=${ac_cv_func_getgrgid=yes} -ac_cv_func_getgrgid_r=${ac_cv_func_getgrgid_r=yes} -ac_cv_func_getgrnam=${ac_cv_func_getgrnam=yes} -ac_cv_func_getgrnam_r=${ac_cv_func_getgrnam_r=yes} -ac_cv_func_getgrouplist=${ac_cv_func_getgrouplist=yes} -ac_cv_func_getgroups=${ac_cv_func_getgroups=yes} -ac_cv_func_getgroups_works=${ac_cv_func_getgroups_works=no} -ac_cv_func_gethostbyaddr=${ac_cv_func_gethostbyaddr=yes} -ac_cv_func_gethostbyaddr_r=${ac_cv_func_gethostbyaddr_r=yes} -ac_cv_func_gethostbyname2=${ac_cv_func_gethostbyname2=yes} -ac_cv_func_gethostbyname2_r=${ac_cv_func_gethostbyname2_r=yes} -ac_cv_func_gethostbyname=${ac_cv_func_gethostbyname=yes} -ac_cv_func_gethostbyname_r=${ac_cv_func_gethostbyname_r=yes} -ac_cv_func_gethostent=${ac_cv_func_gethostent=yes} -ac_cv_func_gethostid=${ac_cv_func_gethostid=yes} -ac_cv_func_gethostname=${ac_cv_func_gethostname=yes} -ac_cv_func_getitimer=${ac_cv_func_getitimer=yes} -ac_cv_func_getline=${ac_cv_func_getline=yes} -ac_cv_func_getloadavg=${ac_cv_func_getloadavg=yes} -ac_cv_func_getloadavg_setgid=${ac_cv_func_getloadavg_setgid=no} -ac_cv_func_getlogin=${ac_cv_func_getlogin=yes} -ac_cv_func_getlogin_r=${ac_cv_func_getlogin_r=yes} -ac_cv_func_getmntent=${ac_cv_func_getmntent=yes} -ac_cv_func_getmntent_r=${ac_cv_func_getmntent_r=yes} -ac_cv_func_getnameinfo=${ac_cv_func_getnameinfo=yes} -ac_cv_func_getnetbyaddr=${ac_cv_func_getnetbyaddr=yes} -ac_cv_func_getnetbyname=${ac_cv_func_getnetbyname=yes} -ac_cv_func_getnetent=${ac_cv_func_getnetent=yes} -ac_cv_func_getopt=${ac_cv_func_getopt=yes} -ac_cv_func_getopt_long=${ac_cv_func_getopt_long=yes} -ac_cv_func_getopt_long_only=${ac_cv_func_getopt_long_only=yes} -ac_cv_func_getpagesize=${ac_cv_func_getpagesize=yes} -ac_cv_func_getpass=${ac_cv_func_getpass=yes} -ac_cv_func_getpeername=${ac_cv_func_getpeername=yes} -ac_cv_func_getpgid=${ac_cv_func_getpgid=yes} -ac_cv_func_getpgrp=${ac_cv_func_getpgrp=yes} -ac_cv_func_getpgrp_void=${ac_cv_func_getpgrp_void=yes} -ac_cv_func_getpid=${ac_cv_func_getpid=yes} -ac_cv_func_getppid=${ac_cv_func_getppid=yes} -ac_cv_func_getpriority=${ac_cv_func_getpriority=yes} -ac_cv_func_getprotobyname=${ac_cv_func_getprotobyname=yes} -ac_cv_func_getprotobynumber=${ac_cv_func_getprotobynumber=yes} -ac_cv_func_getprotoent=${ac_cv_func_getprotoent=yes} -ac_cv_func_getpwent=${ac_cv_func_getpwent=yes} -ac_cv_func_getpwnam=${ac_cv_func_getpwnam=yes} -ac_cv_func_getpwnam_r=${ac_cv_func_getpwnam_r=yes} -ac_cv_func_getpwuid=${ac_cv_func_getpwuid=yes} -ac_cv_func_getpwuid_r=${ac_cv_func_getpwuid_r=yes} -ac_cv_func_getresgid=${ac_cv_func_getresgid=yes} -ac_cv_func_getresuid=${ac_cv_func_getresuid=yes} -ac_cv_func_getrlimit64=${ac_cv_func_getrlimit64=yes} -ac_cv_func_getrlimit=${ac_cv_func_getrlimit=yes} -ac_cv_func_getrusage=${ac_cv_func_getrusage=yes} -ac_cv_func_gets=${ac_cv_func_gets=yes} -ac_cv_func_getservbyname=${ac_cv_func_getservbyname=yes} -ac_cv_func_getservbyname_r=${ac_cv_func_getservbyname_r=yes} -ac_cv_func_getservbyport=${ac_cv_func_getservbyport=yes} -ac_cv_func_getservbyport_r=${ac_cv_func_getservbyport_r=yes} -ac_cv_func_getservent=${ac_cv_func_getservent=yes} -ac_cv_func_getsid=${ac_cv_func_getsid=yes} -ac_cv_func_getsockname=${ac_cv_func_getsockname=yes} -ac_cv_func_getsockopt=${ac_cv_func_getsockopt=yes} -ac_cv_func_getspent=${ac_cv_func_getspent=yes} -ac_cv_func_getspnam=${ac_cv_func_getspnam=yes} -ac_cv_func_getspnam_r=${ac_cv_func_getspnam_r=yes} -ac_cv_func_getsubopt=${ac_cv_func_getsubopt=yes} -ac_cv_func_gettext=${ac_cv_func_gettext=yes} -ac_cv_func_gettimeofday=${ac_cv_func_gettimeofday=yes} -ac_cv_func_getuid=${ac_cv_func_getuid=yes} -ac_cv_func_getusershell=${ac_cv_func_getusershell=yes} -ac_cv_func_getutent=${ac_cv_func_getutent=yes} -ac_cv_func_getutid=${ac_cv_func_getutid=yes} -ac_cv_func_getutline=${ac_cv_func_getutline=yes} -ac_cv_func_getutxent=${ac_cv_func_getutxent=yes} -ac_cv_func_getutxid=${ac_cv_func_getutxid=yes} -ac_cv_func_getutxline=${ac_cv_func_getutxline=yes} -ac_cv_func_getw=${ac_cv_func_getw=yes} -ac_cv_func_getwc=${ac_cv_func_getwc=yes} -ac_cv_func_getwc_unlocked=${ac_cv_func_getwc_unlocked=yes} -ac_cv_func_getwchar=${ac_cv_func_getwchar=yes} -ac_cv_func_getwchar_unlocked=${ac_cv_func_getwchar_unlocked=yes} -ac_cv_func_getxattr=${ac_cv_func_getxattr=yes} -ac_cv_func_glob64=${ac_cv_func_glob64=yes} -ac_cv_func_glob=${ac_cv_func_glob=yes} -ac_cv_func_globfree64=${ac_cv_func_globfree64=yes} -ac_cv_func_globfree=${ac_cv_func_globfree=yes} -ac_cv_func_gmtime=${ac_cv_func_gmtime=yes} -ac_cv_func_gmtime_r=${ac_cv_func_gmtime_r=yes} -ac_cv_func_grantpt=${ac_cv_func_grantpt=yes} -ac_cv_func_h_errno=${ac_cv_func_h_errno=yes} -ac_cv_func_hasmntopt=${ac_cv_func_hasmntopt=yes} -ac_cv_func_hcreate=${ac_cv_func_hcreate=yes} -ac_cv_func_hdestroy=${ac_cv_func_hdestroy=yes} -ac_cv_func_hsearch=${ac_cv_func_hsearch=yes} -ac_cv_func_hstrerror=${ac_cv_func_hstrerror=yes} -ac_cv_func_htonl=${ac_cv_func_htonl=yes} -ac_cv_func_htons=${ac_cv_func_htons=yes} -ac_cv_func_hypot=${ac_cv_func_hypot=yes} -ac_cv_func_hypotf=${ac_cv_func_hypotf=yes} -ac_cv_func_hypotl=${ac_cv_func_hypotl=yes} -ac_cv_func_iconv=${ac_cv_func_iconv=yes} -ac_cv_func_iconv_close=${ac_cv_func_iconv_close=yes} -ac_cv_func_iconv_open=${ac_cv_func_iconv_open=yes} -ac_cv_func_if_freenameindex=${ac_cv_func_if_freenameindex=yes} -ac_cv_func_if_indextoname=${ac_cv_func_if_indextoname=yes} -ac_cv_func_if_nameindex=${ac_cv_func_if_nameindex=yes} -ac_cv_func_if_nametoindex=${ac_cv_func_if_nametoindex=yes} -ac_cv_func_ilogb=${ac_cv_func_ilogb=yes} -ac_cv_func_ilogbf=${ac_cv_func_ilogbf=yes} -ac_cv_func_ilogbl=${ac_cv_func_ilogbl=yes} -ac_cv_func_imaxabs=${ac_cv_func_imaxabs=yes} -ac_cv_func_imaxdiv=${ac_cv_func_imaxdiv=yes} -ac_cv_func_in6addr_any=${ac_cv_func_in6addr_any=yes} -ac_cv_func_in6addr_loopback=${ac_cv_func_in6addr_loopback=yes} -ac_cv_func_index=${ac_cv_func_index=yes} -ac_cv_func_inet_addr=${ac_cv_func_inet_addr=yes} -ac_cv_func_inet_aton=${ac_cv_func_inet_aton=yes} -ac_cv_func_inet_ntoa=${ac_cv_func_inet_ntoa=yes} -ac_cv_func_inet_ntop=${ac_cv_func_inet_ntop=yes} -ac_cv_func_inet_pton=${ac_cv_func_inet_pton=yes} -ac_cv_func_init_module=${ac_cv_func_init_module=yes} -ac_cv_func_initgroups=${ac_cv_func_initgroups=yes} -ac_cv_func_initstate=${ac_cv_func_initstate=yes} -ac_cv_func_inotify_add_watch=${ac_cv_func_inotify_add_watch=yes} -ac_cv_func_inotify_init1=${ac_cv_func_inotify_init1=yes} -ac_cv_func_inotify_init=${ac_cv_func_inotify_init=yes} -ac_cv_func_inotify_rm_watch=${ac_cv_func_inotify_rm_watch=yes} -ac_cv_func_insque=${ac_cv_func_insque=yes} -ac_cv_func_ioctl=${ac_cv_func_ioctl=yes} -ac_cv_func_ioperm=${ac_cv_func_ioperm=yes} -ac_cv_func_iopl=${ac_cv_func_iopl=yes} -ac_cv_func_isalnum=${ac_cv_func_isalnum=yes} -ac_cv_func_isalnum_l=${ac_cv_func_isalnum_l=yes} -ac_cv_func_isalpha=${ac_cv_func_isalpha=yes} -ac_cv_func_isalpha_l=${ac_cv_func_isalpha_l=yes} -ac_cv_func_isascii=${ac_cv_func_isascii=yes} -ac_cv_func_isastream=${ac_cv_func_isastream=yes} -ac_cv_func_isatty=${ac_cv_func_isatty=yes} -ac_cv_func_isblank=${ac_cv_func_isblank=yes} -ac_cv_func_isblank_l=${ac_cv_func_isblank_l=yes} -ac_cv_func_iscntrl=${ac_cv_func_iscntrl=yes} -ac_cv_func_iscntrl_l=${ac_cv_func_iscntrl_l=yes} -ac_cv_func_isdigit=${ac_cv_func_isdigit=yes} -ac_cv_func_isdigit_l=${ac_cv_func_isdigit_l=yes} -ac_cv_func_isgraph=${ac_cv_func_isgraph=yes} -ac_cv_func_isgraph_l=${ac_cv_func_isgraph_l=yes} -ac_cv_func_islower=${ac_cv_func_islower=yes} -ac_cv_func_islower_l=${ac_cv_func_islower_l=yes} -ac_cv_func_isprint=${ac_cv_func_isprint=yes} -ac_cv_func_isprint_l=${ac_cv_func_isprint_l=yes} -ac_cv_func_ispunct=${ac_cv_func_ispunct=yes} -ac_cv_func_ispunct_l=${ac_cv_func_ispunct_l=yes} -ac_cv_func_isspace=${ac_cv_func_isspace=yes} -ac_cv_func_isspace_l=${ac_cv_func_isspace_l=yes} -ac_cv_func_isupper=${ac_cv_func_isupper=yes} -ac_cv_func_isupper_l=${ac_cv_func_isupper_l=yes} -ac_cv_func_iswalnum=${ac_cv_func_iswalnum=yes} -ac_cv_func_iswalnum_l=${ac_cv_func_iswalnum_l=yes} -ac_cv_func_iswalpha=${ac_cv_func_iswalpha=yes} -ac_cv_func_iswalpha_l=${ac_cv_func_iswalpha_l=yes} -ac_cv_func_iswblank=${ac_cv_func_iswblank=yes} -ac_cv_func_iswblank_l=${ac_cv_func_iswblank_l=yes} -ac_cv_func_iswcntrl=${ac_cv_func_iswcntrl=yes} -ac_cv_func_iswcntrl_l=${ac_cv_func_iswcntrl_l=yes} -ac_cv_func_iswctype=${ac_cv_func_iswctype=yes} -ac_cv_func_iswctype_l=${ac_cv_func_iswctype_l=yes} -ac_cv_func_iswdigit=${ac_cv_func_iswdigit=yes} -ac_cv_func_iswdigit_l=${ac_cv_func_iswdigit_l=yes} -ac_cv_func_iswgraph=${ac_cv_func_iswgraph=yes} -ac_cv_func_iswgraph_l=${ac_cv_func_iswgraph_l=yes} -ac_cv_func_iswlower=${ac_cv_func_iswlower=yes} -ac_cv_func_iswlower_l=${ac_cv_func_iswlower_l=yes} -ac_cv_func_iswprint=${ac_cv_func_iswprint=yes} -ac_cv_func_iswprint_l=${ac_cv_func_iswprint_l=yes} -ac_cv_func_iswpunct=${ac_cv_func_iswpunct=yes} -ac_cv_func_iswpunct_l=${ac_cv_func_iswpunct_l=yes} -ac_cv_func_iswspace=${ac_cv_func_iswspace=yes} -ac_cv_func_iswspace_l=${ac_cv_func_iswspace_l=yes} -ac_cv_func_iswupper=${ac_cv_func_iswupper=yes} -ac_cv_func_iswupper_l=${ac_cv_func_iswupper_l=yes} -ac_cv_func_iswxdigit=${ac_cv_func_iswxdigit=yes} -ac_cv_func_iswxdigit_l=${ac_cv_func_iswxdigit_l=yes} -ac_cv_func_isxdigit=${ac_cv_func_isxdigit=yes} -ac_cv_func_isxdigit_l=${ac_cv_func_isxdigit_l=yes} -ac_cv_func_j0=${ac_cv_func_j0=yes} -ac_cv_func_j0f=${ac_cv_func_j0f=yes} -ac_cv_func_j1=${ac_cv_func_j1=yes} -ac_cv_func_j1f=${ac_cv_func_j1f=yes} -ac_cv_func_jn=${ac_cv_func_jn=yes} -ac_cv_func_jnf=${ac_cv_func_jnf=yes} -ac_cv_func_jrand48=${ac_cv_func_jrand48=yes} -ac_cv_func_kill=${ac_cv_func_kill=yes} -ac_cv_func_killpg=${ac_cv_func_killpg=yes} -ac_cv_func_klogctl=${ac_cv_func_klogctl=yes} -ac_cv_func_l64a=${ac_cv_func_l64a=yes} -ac_cv_func_labs=${ac_cv_func_labs=yes} -ac_cv_func_lchmod=${ac_cv_func_lchmod=yes} -ac_cv_func_lchown=${ac_cv_func_lchown=yes} -ac_cv_func_lckpwdf=${ac_cv_func_lckpwdf=yes} -ac_cv_func_lcong48=${ac_cv_func_lcong48=yes} -ac_cv_func_ldexp=${ac_cv_func_ldexp=yes} -ac_cv_func_ldexpf=${ac_cv_func_ldexpf=yes} -ac_cv_func_ldexpl=${ac_cv_func_ldexpl=yes} -ac_cv_func_ldiv=${ac_cv_func_ldiv=yes} -ac_cv_func_lfind=${ac_cv_func_lfind=yes} -ac_cv_func_lgamma=${ac_cv_func_lgamma=yes} -ac_cv_func_lgamma_r=${ac_cv_func_lgamma_r=yes} -ac_cv_func_lgammaf=${ac_cv_func_lgammaf=yes} -ac_cv_func_lgammaf_r=${ac_cv_func_lgammaf_r=yes} -ac_cv_func_lgammal=${ac_cv_func_lgammal=yes} -ac_cv_func_lgammal_r=${ac_cv_func_lgammal_r=yes} -ac_cv_func_lgetxattr=${ac_cv_func_lgetxattr=yes} -ac_cv_func_link=${ac_cv_func_link=yes} -ac_cv_func_linkat=${ac_cv_func_linkat=yes} -ac_cv_func_lio_listio=${ac_cv_func_lio_listio=yes} -ac_cv_func_listen=${ac_cv_func_listen=yes} -ac_cv_func_listxattr=${ac_cv_func_listxattr=yes} -ac_cv_func_llabs=${ac_cv_func_llabs=yes} -ac_cv_func_lldiv=${ac_cv_func_lldiv=yes} -ac_cv_func_llistxattr=${ac_cv_func_llistxattr=yes} -ac_cv_func_llrint=${ac_cv_func_llrint=yes} -ac_cv_func_llrintf=${ac_cv_func_llrintf=yes} -ac_cv_func_llrintl=${ac_cv_func_llrintl=yes} -ac_cv_func_llround=${ac_cv_func_llround=yes} -ac_cv_func_llroundf=${ac_cv_func_llroundf=yes} -ac_cv_func_llroundl=${ac_cv_func_llroundl=yes} -ac_cv_func_localeconv=${ac_cv_func_localeconv=yes} -ac_cv_func_localtime=${ac_cv_func_localtime=yes} -ac_cv_func_localtime_r=${ac_cv_func_localtime_r=yes} -ac_cv_func_lockf64=${ac_cv_func_lockf64=yes} -ac_cv_func_lockf=${ac_cv_func_lockf=yes} -ac_cv_func_log10=${ac_cv_func_log10=yes} -ac_cv_func_log10f=${ac_cv_func_log10f=yes} -ac_cv_func_log10l=${ac_cv_func_log10l=yes} -ac_cv_func_log1p=${ac_cv_func_log1p=yes} -ac_cv_func_log1pf=${ac_cv_func_log1pf=yes} -ac_cv_func_log1pl=${ac_cv_func_log1pl=yes} -ac_cv_func_log2=${ac_cv_func_log2=yes} -ac_cv_func_log2f=${ac_cv_func_log2f=yes} -ac_cv_func_log2l=${ac_cv_func_log2l=yes} -ac_cv_func_log=${ac_cv_func_log=yes} -ac_cv_func_logb=${ac_cv_func_logb=yes} -ac_cv_func_logbf=${ac_cv_func_logbf=yes} -ac_cv_func_logbl=${ac_cv_func_logbl=yes} -ac_cv_func_logf=${ac_cv_func_logf=yes} -ac_cv_func_logl=${ac_cv_func_logl=yes} -ac_cv_func_longjmp=${ac_cv_func_longjmp=yes} -ac_cv_func_lrand48=${ac_cv_func_lrand48=yes} -ac_cv_func_lremovexattr=${ac_cv_func_lremovexattr=yes} -ac_cv_func_lrint=${ac_cv_func_lrint=yes} -ac_cv_func_lrintf=${ac_cv_func_lrintf=yes} -ac_cv_func_lrintl=${ac_cv_func_lrintl=yes} -ac_cv_func_lround=${ac_cv_func_lround=yes} -ac_cv_func_lroundf=${ac_cv_func_lroundf=yes} -ac_cv_func_lroundl=${ac_cv_func_lroundl=yes} -ac_cv_func_lsearch=${ac_cv_func_lsearch=yes} -ac_cv_func_lseek64=${ac_cv_func_lseek64=yes} -ac_cv_func_lseek=${ac_cv_func_lseek=yes} -ac_cv_func_lsetxattr=${ac_cv_func_lsetxattr=yes} -ac_cv_func_lstat64=${ac_cv_func_lstat64=yes} -ac_cv_func_lstat=${ac_cv_func_lstat=yes} -ac_cv_func_lstat_dereferences_slashed_symlink=${ac_cv_func_lstat_dereferences_slashed_symlink=yes} -ac_cv_func_lstat_empty_string_bug=${ac_cv_func_lstat_empty_string_bug=no} -ac_cv_func_lutimes=${ac_cv_func_lutimes=yes} -ac_cv_func_madvise=${ac_cv_func_madvise=yes} -ac_cv_func_malloc=${ac_cv_func_malloc=yes} -ac_cv_func_malloc_0_nonnull=${ac_cv_func_malloc_0_nonnull=yes} -ac_cv_func_malloc_works=${ac_cv_func_malloc_works=yes} -ac_cv_func_mblen=${ac_cv_func_mblen=yes} -ac_cv_func_mbrlen=${ac_cv_func_mbrlen=yes} -ac_cv_func_mbrtowc=${ac_cv_func_mbrtowc=yes} -ac_cv_func_mbsinit=${ac_cv_func_mbsinit=yes} -ac_cv_func_mbsnrtowcs=${ac_cv_func_mbsnrtowcs=yes} -ac_cv_func_mbsrtowcs=${ac_cv_func_mbsrtowcs=yes} -ac_cv_func_mbstowcs=${ac_cv_func_mbstowcs=yes} -ac_cv_func_mbtowc=${ac_cv_func_mbtowc=yes} -ac_cv_func_memalign=${ac_cv_func_memalign=yes} -ac_cv_func_memccpy=${ac_cv_func_memccpy=yes} -ac_cv_func_memchr=${ac_cv_func_memchr=yes} -ac_cv_func_memcmp=${ac_cv_func_memcmp=yes} -ac_cv_func_memcmp_clean=${ac_cv_func_memcmp_clean=yes} -ac_cv_func_memcmp_working=${ac_cv_func_memcmp_working=yes} -ac_cv_func_memcpy=${ac_cv_func_memcpy=yes} -ac_cv_func_memmove=${ac_cv_func_memmove=yes} -ac_cv_func_mempcpy=${ac_cv_func_mempcpy=yes} -ac_cv_func_memrchr=${ac_cv_func_memrchr=yes} -ac_cv_func_memset=${ac_cv_func_memset=yes} -ac_cv_func_mkdir=${ac_cv_func_mkdir=yes} -ac_cv_func_mkdirat=${ac_cv_func_mkdirat=yes} -ac_cv_func_mkdtemp=${ac_cv_func_mkdtemp=yes} -ac_cv_func_mkfifo=${ac_cv_func_mkfifo=yes} -ac_cv_func_mkfifoat=${ac_cv_func_mkfifoat=yes} -ac_cv_func_mknod=${ac_cv_func_mknod=yes} -ac_cv_func_mknodat=${ac_cv_func_mknodat=yes} -ac_cv_func_mkstemp64=${ac_cv_func_mkstemp64=yes} -ac_cv_func_mkstemp=${ac_cv_func_mkstemp=yes} -ac_cv_func_mktemp=${ac_cv_func_mktemp=yes} -ac_cv_func_mktime=${ac_cv_func_mktime=yes} -ac_cv_func_mlock=${ac_cv_func_mlock=yes} -ac_cv_func_mlockall=${ac_cv_func_mlockall=yes} -ac_cv_func_mmap64=${ac_cv_func_mmap64=yes} -ac_cv_func_mmap=${ac_cv_func_mmap=yes} -ac_cv_func_mmap_fixed_mapped=${ac_cv_func_mmap_fixed_mapped=no} -ac_cv_func_modf=${ac_cv_func_modf=yes} -ac_cv_func_modff=${ac_cv_func_modff=yes} -ac_cv_func_modfl=${ac_cv_func_modfl=yes} -ac_cv_func_mount=${ac_cv_func_mount=yes} -ac_cv_func_mprotect=${ac_cv_func_mprotect=yes} -ac_cv_func_mq_close=${ac_cv_func_mq_close=yes} -ac_cv_func_mq_getattr=${ac_cv_func_mq_getattr=yes} -ac_cv_func_mq_notify=${ac_cv_func_mq_notify=yes} -ac_cv_func_mq_open=${ac_cv_func_mq_open=yes} -ac_cv_func_mq_receive=${ac_cv_func_mq_receive=yes} -ac_cv_func_mq_send=${ac_cv_func_mq_send=yes} -ac_cv_func_mq_setattr=${ac_cv_func_mq_setattr=yes} -ac_cv_func_mq_timedreceive=${ac_cv_func_mq_timedreceive=yes} -ac_cv_func_mq_timedsend=${ac_cv_func_mq_timedsend=yes} -ac_cv_func_mq_unlink=${ac_cv_func_mq_unlink=yes} -ac_cv_func_mrand48=${ac_cv_func_mrand48=yes} -ac_cv_func_mremap=${ac_cv_func_mremap=yes} -ac_cv_func_msgctl=${ac_cv_func_msgctl=yes} -ac_cv_func_msgget=${ac_cv_func_msgget=yes} -ac_cv_func_msgrcv=${ac_cv_func_msgrcv=yes} -ac_cv_func_msgsnd=${ac_cv_func_msgsnd=yes} -ac_cv_func_msync=${ac_cv_func_msync=yes} -ac_cv_func_munlock=${ac_cv_func_munlock=yes} -ac_cv_func_munlockall=${ac_cv_func_munlockall=yes} -ac_cv_func_munmap=${ac_cv_func_munmap=yes} -ac_cv_func_nan=${ac_cv_func_nan=yes} -ac_cv_func_nanf=${ac_cv_func_nanf=yes} -ac_cv_func_nanl=${ac_cv_func_nanl=yes} -ac_cv_func_nanosleep=${ac_cv_func_nanosleep=yes} -ac_cv_func_nearbyint=${ac_cv_func_nearbyint=yes} -ac_cv_func_nearbyintf=${ac_cv_func_nearbyintf=yes} -ac_cv_func_nearbyintl=${ac_cv_func_nearbyintl=yes} -ac_cv_func_newlocale=${ac_cv_func_newlocale=yes} -ac_cv_func_nextafter=${ac_cv_func_nextafter=yes} -ac_cv_func_nextafterf=${ac_cv_func_nextafterf=yes} -ac_cv_func_nextafterl=${ac_cv_func_nextafterl=yes} -ac_cv_func_nexttoward=${ac_cv_func_nexttoward=yes} -ac_cv_func_nexttowardf=${ac_cv_func_nexttowardf=yes} -ac_cv_func_nexttowardl=${ac_cv_func_nexttowardl=yes} -ac_cv_func_nftw64=${ac_cv_func_nftw64=yes} -ac_cv_func_nftw=${ac_cv_func_nftw=yes} -ac_cv_func_ngettext=${ac_cv_func_ngettext=yes} -ac_cv_func_nice=${ac_cv_func_nice=yes} -ac_cv_func_nl_langinfo=${ac_cv_func_nl_langinfo=yes} -ac_cv_func_nl_langinfo_l=${ac_cv_func_nl_langinfo_l=yes} -ac_cv_func_nrand48=${ac_cv_func_nrand48=yes} -ac_cv_func_ntohl=${ac_cv_func_ntohl=yes} -ac_cv_func_ntohs=${ac_cv_func_ntohs=yes} -ac_cv_func_obstack=${ac_cv_func_obstack=no} -ac_cv_func_open64=${ac_cv_func_open64=yes} -ac_cv_func_open=${ac_cv_func_open=yes} -ac_cv_func_open_memstream=${ac_cv_func_open_memstream=yes} -ac_cv_func_open_wmemstream=${ac_cv_func_open_wmemstream=yes} -ac_cv_func_openat64=${ac_cv_func_openat64=yes} -ac_cv_func_openat=${ac_cv_func_openat=yes} -ac_cv_func_opendir=${ac_cv_func_opendir=yes} -ac_cv_func_openlog=${ac_cv_func_openlog=yes} -ac_cv_func_openpty=${ac_cv_func_openpty=yes} -ac_cv_func_optarg=${ac_cv_func_optarg=yes} -ac_cv_func_opterr=${ac_cv_func_opterr=yes} -ac_cv_func_optind=${ac_cv_func_optind=yes} -ac_cv_func_optopt=${ac_cv_func_optopt=yes} -ac_cv_func_pathconf=${ac_cv_func_pathconf=yes} -ac_cv_func_pause=${ac_cv_func_pause=yes} -ac_cv_func_pclose=${ac_cv_func_pclose=yes} -ac_cv_func_perror=${ac_cv_func_perror=yes} -ac_cv_func_pipe2=${ac_cv_func_pipe2=yes} -ac_cv_func_pipe=${ac_cv_func_pipe=yes} -ac_cv_func_pivot_root=${ac_cv_func_pivot_root=yes} -ac_cv_func_poll=${ac_cv_func_poll=yes} -ac_cv_func_popen=${ac_cv_func_popen=yes} -ac_cv_func_posix_fadvise=${ac_cv_func_posix_fadvise=yes} -ac_cv_func_posix_fallocate=${ac_cv_func_posix_fallocate=yes} -ac_cv_func_posix_getgrgid_r=${ac_cv_func_posix_getgrgid_r=yes} -ac_cv_func_posix_getpwuid_r=${ac_cv_func_posix_getpwuid_r=yes} -ac_cv_func_posix_madvise=${ac_cv_func_posix_madvise=yes} -ac_cv_func_posix_memalign=${ac_cv_func_posix_memalign=yes} -ac_cv_func_posix_openpt=${ac_cv_func_posix_openpt=yes} -ac_cv_func_posix_spawn=${ac_cv_func_posix_spawn=yes} -ac_cv_func_posix_spawn_file_actions_addclose=${ac_cv_func_posix_spawn_file_actions_addclose=yes} -ac_cv_func_posix_spawn_file_actions_adddup2=${ac_cv_func_posix_spawn_file_actions_adddup2=yes} -ac_cv_func_posix_spawn_file_actions_addopen=${ac_cv_func_posix_spawn_file_actions_addopen=yes} -ac_cv_func_posix_spawn_file_actions_destroy=${ac_cv_func_posix_spawn_file_actions_destroy=yes} -ac_cv_func_posix_spawn_file_actions_init=${ac_cv_func_posix_spawn_file_actions_init=yes} -ac_cv_func_posix_spawnattr_destroy=${ac_cv_func_posix_spawnattr_destroy=yes} -ac_cv_func_posix_spawnattr_getflags=${ac_cv_func_posix_spawnattr_getflags=yes} -ac_cv_func_posix_spawnattr_getpgroup=${ac_cv_func_posix_spawnattr_getpgroup=yes} -ac_cv_func_posix_spawnattr_getsigdefault=${ac_cv_func_posix_spawnattr_getsigdefault=yes} -ac_cv_func_posix_spawnattr_getsigmask=${ac_cv_func_posix_spawnattr_getsigmask=yes} -ac_cv_func_posix_spawnattr_init=${ac_cv_func_posix_spawnattr_init=yes} -ac_cv_func_posix_spawnattr_setflags=${ac_cv_func_posix_spawnattr_setflags=yes} -ac_cv_func_posix_spawnattr_setpgroup=${ac_cv_func_posix_spawnattr_setpgroup=yes} -ac_cv_func_posix_spawnattr_setsigdefault=${ac_cv_func_posix_spawnattr_setsigdefault=yes} -ac_cv_func_posix_spawnattr_setsigmask=${ac_cv_func_posix_spawnattr_setsigmask=yes} -ac_cv_func_posix_spawnp=${ac_cv_func_posix_spawnp=yes} -ac_cv_func_pow10=${ac_cv_func_pow10=yes} -ac_cv_func_pow10f=${ac_cv_func_pow10f=yes} -ac_cv_func_pow10l=${ac_cv_func_pow10l=yes} -ac_cv_func_pow=${ac_cv_func_pow=yes} -ac_cv_func_powf=${ac_cv_func_powf=yes} -ac_cv_func_powl=${ac_cv_func_powl=yes} -ac_cv_func_prctl=${ac_cv_func_prctl=yes} -ac_cv_func_pread64=${ac_cv_func_pread64=yes} -ac_cv_func_pread=${ac_cv_func_pread=yes} -ac_cv_func_printf=${ac_cv_func_printf=yes} -ac_cv_func_prlimit=${ac_cv_func_prlimit=yes} -ac_cv_func_process_vm_readv=${ac_cv_func_process_vm_readv=yes} -ac_cv_func_process_vm_writev=${ac_cv_func_process_vm_writev=yes} -ac_cv_func_pselect=${ac_cv_func_pselect=yes} -ac_cv_func_psiginfo=${ac_cv_func_psiginfo=yes} -ac_cv_func_psignal=${ac_cv_func_psignal=yes} -ac_cv_func_pstat_getdynamic=${ac_cv_func_pstat_getdynamic=no} -ac_cv_func_pthread_atfork=${ac_cv_func_pthread_atfork=yes} -ac_cv_func_pthread_attr_destroy=${ac_cv_func_pthread_attr_destroy=yes} -ac_cv_func_pthread_attr_getdetachstate=${ac_cv_func_pthread_attr_getdetachstate=yes} -ac_cv_func_pthread_attr_getguardsize=${ac_cv_func_pthread_attr_getguardsize=yes} -ac_cv_func_pthread_attr_getschedparam=${ac_cv_func_pthread_attr_getschedparam=yes} -ac_cv_func_pthread_attr_getscope=${ac_cv_func_pthread_attr_getscope=yes} -ac_cv_func_pthread_attr_getstack=${ac_cv_func_pthread_attr_getstack=yes} -ac_cv_func_pthread_attr_getstacksize=${ac_cv_func_pthread_attr_getstacksize=yes} -ac_cv_func_pthread_attr_init=${ac_cv_func_pthread_attr_init=yes} -ac_cv_func_pthread_attr_setdetachstate=${ac_cv_func_pthread_attr_setdetachstate=yes} -ac_cv_func_pthread_attr_setguardsize=${ac_cv_func_pthread_attr_setguardsize=yes} -ac_cv_func_pthread_attr_setschedparam=${ac_cv_func_pthread_attr_setschedparam=yes} -ac_cv_func_pthread_attr_setscope=${ac_cv_func_pthread_attr_setscope=yes} -ac_cv_func_pthread_attr_setstack=${ac_cv_func_pthread_attr_setstack=yes} -ac_cv_func_pthread_attr_setstacksize=${ac_cv_func_pthread_attr_setstacksize=yes} -ac_cv_func_pthread_barrier_destroy=${ac_cv_func_pthread_barrier_destroy=yes} -ac_cv_func_pthread_barrier_init=${ac_cv_func_pthread_barrier_init=yes} -ac_cv_func_pthread_barrier_wait=${ac_cv_func_pthread_barrier_wait=yes} -ac_cv_func_pthread_barrierattr_destroy=${ac_cv_func_pthread_barrierattr_destroy=yes} -ac_cv_func_pthread_barrierattr_getpshared=${ac_cv_func_pthread_barrierattr_getpshared=yes} -ac_cv_func_pthread_barrierattr_init=${ac_cv_func_pthread_barrierattr_init=yes} -ac_cv_func_pthread_barrierattr_setpshared=${ac_cv_func_pthread_barrierattr_setpshared=yes} -ac_cv_func_pthread_cancel=${ac_cv_func_pthread_cancel=yes} -ac_cv_func_pthread_cond_broadcast=${ac_cv_func_pthread_cond_broadcast=yes} -ac_cv_func_pthread_cond_destroy=${ac_cv_func_pthread_cond_destroy=yes} -ac_cv_func_pthread_cond_init=${ac_cv_func_pthread_cond_init=yes} -ac_cv_func_pthread_cond_signal=${ac_cv_func_pthread_cond_signal=yes} -ac_cv_func_pthread_cond_timedwait=${ac_cv_func_pthread_cond_timedwait=yes} -ac_cv_func_pthread_cond_wait=${ac_cv_func_pthread_cond_wait=yes} -ac_cv_func_pthread_condattr_destroy=${ac_cv_func_pthread_condattr_destroy=yes} -ac_cv_func_pthread_condattr_getclock=${ac_cv_func_pthread_condattr_getclock=yes} -ac_cv_func_pthread_condattr_getpshared=${ac_cv_func_pthread_condattr_getpshared=yes} -ac_cv_func_pthread_condattr_init=${ac_cv_func_pthread_condattr_init=yes} -ac_cv_func_pthread_condattr_setclock=${ac_cv_func_pthread_condattr_setclock=yes} -ac_cv_func_pthread_condattr_setpshared=${ac_cv_func_pthread_condattr_setpshared=yes} -ac_cv_func_pthread_create=${ac_cv_func_pthread_create=yes} -ac_cv_func_pthread_detach=${ac_cv_func_pthread_detach=yes} -ac_cv_func_pthread_equal=${ac_cv_func_pthread_equal=yes} -ac_cv_func_pthread_exit=${ac_cv_func_pthread_exit=yes} -ac_cv_func_pthread_getconcurrency=${ac_cv_func_pthread_getconcurrency=yes} -ac_cv_func_pthread_getspecific=${ac_cv_func_pthread_getspecific=yes} -ac_cv_func_pthread_join=${ac_cv_func_pthread_join=yes} -ac_cv_func_pthread_key_create=${ac_cv_func_pthread_key_create=yes} -ac_cv_func_pthread_key_delete=${ac_cv_func_pthread_key_delete=yes} -ac_cv_func_pthread_kill=${ac_cv_func_pthread_kill=yes} -ac_cv_func_pthread_mutex_consistent=${ac_cv_func_pthread_mutex_consistent=yes} -ac_cv_func_pthread_mutex_destroy=${ac_cv_func_pthread_mutex_destroy=yes} -ac_cv_func_pthread_mutex_init=${ac_cv_func_pthread_mutex_init=yes} -ac_cv_func_pthread_mutex_lock=${ac_cv_func_pthread_mutex_lock=yes} -ac_cv_func_pthread_mutex_timedlock=${ac_cv_func_pthread_mutex_timedlock=yes} -ac_cv_func_pthread_mutex_trylock=${ac_cv_func_pthread_mutex_trylock=yes} -ac_cv_func_pthread_mutex_unlock=${ac_cv_func_pthread_mutex_unlock=yes} -ac_cv_func_pthread_mutexattr_destroy=${ac_cv_func_pthread_mutexattr_destroy=yes} -ac_cv_func_pthread_mutexattr_getpshared=${ac_cv_func_pthread_mutexattr_getpshared=yes} -ac_cv_func_pthread_mutexattr_getrobust=${ac_cv_func_pthread_mutexattr_getrobust=yes} -ac_cv_func_pthread_mutexattr_gettype=${ac_cv_func_pthread_mutexattr_gettype=yes} -ac_cv_func_pthread_mutexattr_init=${ac_cv_func_pthread_mutexattr_init=yes} -ac_cv_func_pthread_mutexattr_setpshared=${ac_cv_func_pthread_mutexattr_setpshared=yes} -ac_cv_func_pthread_mutexattr_setrobust=${ac_cv_func_pthread_mutexattr_setrobust=yes} -ac_cv_func_pthread_mutexattr_settype=${ac_cv_func_pthread_mutexattr_settype=yes} -ac_cv_func_pthread_once=${ac_cv_func_pthread_once=yes} -ac_cv_func_pthread_rwlock_destroy=${ac_cv_func_pthread_rwlock_destroy=yes} -ac_cv_func_pthread_rwlock_init=${ac_cv_func_pthread_rwlock_init=yes} -ac_cv_func_pthread_rwlock_rdlock=${ac_cv_func_pthread_rwlock_rdlock=yes} -ac_cv_func_pthread_rwlock_timedrdlock=${ac_cv_func_pthread_rwlock_timedrdlock=yes} -ac_cv_func_pthread_rwlock_timedwrlock=${ac_cv_func_pthread_rwlock_timedwrlock=yes} -ac_cv_func_pthread_rwlock_tryrdlock=${ac_cv_func_pthread_rwlock_tryrdlock=yes} -ac_cv_func_pthread_rwlock_trywrlock=${ac_cv_func_pthread_rwlock_trywrlock=yes} -ac_cv_func_pthread_rwlock_unlock=${ac_cv_func_pthread_rwlock_unlock=yes} -ac_cv_func_pthread_rwlock_wrlock=${ac_cv_func_pthread_rwlock_wrlock=yes} -ac_cv_func_pthread_rwlockattr_destroy=${ac_cv_func_pthread_rwlockattr_destroy=yes} -ac_cv_func_pthread_rwlockattr_getpshared=${ac_cv_func_pthread_rwlockattr_getpshared=yes} -ac_cv_func_pthread_rwlockattr_init=${ac_cv_func_pthread_rwlockattr_init=yes} -ac_cv_func_pthread_rwlockattr_setpshared=${ac_cv_func_pthread_rwlockattr_setpshared=yes} -ac_cv_func_pthread_self=${ac_cv_func_pthread_self=yes} -ac_cv_func_pthread_setcancelstate=${ac_cv_func_pthread_setcancelstate=yes} -ac_cv_func_pthread_setcanceltype=${ac_cv_func_pthread_setcanceltype=yes} -ac_cv_func_pthread_setconcurrency=${ac_cv_func_pthread_setconcurrency=yes} -ac_cv_func_pthread_setspecific=${ac_cv_func_pthread_setspecific=yes} -ac_cv_func_pthread_sigmask=${ac_cv_func_pthread_sigmask=yes} -ac_cv_func_pthread_spin_destroy=${ac_cv_func_pthread_spin_destroy=yes} -ac_cv_func_pthread_spin_init=${ac_cv_func_pthread_spin_init=yes} -ac_cv_func_pthread_spin_lock=${ac_cv_func_pthread_spin_lock=yes} -ac_cv_func_pthread_spin_trylock=${ac_cv_func_pthread_spin_trylock=yes} -ac_cv_func_pthread_spin_unlock=${ac_cv_func_pthread_spin_unlock=yes} -ac_cv_func_pthread_testcancel=${ac_cv_func_pthread_testcancel=yes} -ac_cv_func_ptrace=${ac_cv_func_ptrace=yes} -ac_cv_func_ptsname=${ac_cv_func_ptsname=yes} -ac_cv_func_ptsname_r=${ac_cv_func_ptsname_r=yes} -ac_cv_func_putc=${ac_cv_func_putc=yes} -ac_cv_func_putc_unlocked=${ac_cv_func_putc_unlocked=yes} -ac_cv_func_putchar=${ac_cv_func_putchar=yes} -ac_cv_func_putchar_unlocked=${ac_cv_func_putchar_unlocked=yes} -ac_cv_func_putenv=${ac_cv_func_putenv=yes} -ac_cv_func_puts=${ac_cv_func_puts=yes} -ac_cv_func_pututline=${ac_cv_func_pututline=yes} -ac_cv_func_pututxline=${ac_cv_func_pututxline=yes} -ac_cv_func_putw=${ac_cv_func_putw=yes} -ac_cv_func_putwc=${ac_cv_func_putwc=yes} -ac_cv_func_putwc_unlocked=${ac_cv_func_putwc_unlocked=yes} -ac_cv_func_putwchar=${ac_cv_func_putwchar=yes} -ac_cv_func_putwchar_unlocked=${ac_cv_func_putwchar_unlocked=yes} -ac_cv_func_pwrite64=${ac_cv_func_pwrite64=yes} -ac_cv_func_pwrite=${ac_cv_func_pwrite=yes} -ac_cv_func_qsort=${ac_cv_func_qsort=yes} -ac_cv_func_raise=${ac_cv_func_raise=yes} -ac_cv_func_rand=${ac_cv_func_rand=yes} -ac_cv_func_rand_r=${ac_cv_func_rand_r=yes} -ac_cv_func_random=${ac_cv_func_random=yes} -ac_cv_func_read=${ac_cv_func_read=yes} -ac_cv_func_readdir64=${ac_cv_func_readdir64=yes} -ac_cv_func_readdir64_r=${ac_cv_func_readdir64_r=yes} -ac_cv_func_readdir=${ac_cv_func_readdir=yes} -ac_cv_func_readdir_r=${ac_cv_func_readdir_r=yes} -ac_cv_func_readlink=${ac_cv_func_readlink=yes} -ac_cv_func_readlinkat=${ac_cv_func_readlinkat=yes} -ac_cv_func_readv=${ac_cv_func_readv=yes} -ac_cv_func_realloc=${ac_cv_func_realloc=yes} -ac_cv_func_realloc_0_nonnull=${ac_cv_func_realloc_0_nonnull=yes} -ac_cv_func_realloc_works=${ac_cv_func_realloc_works=yes} -ac_cv_func_realpath=${ac_cv_func_realpath=yes} -ac_cv_func_reboot=${ac_cv_func_reboot=yes} -ac_cv_func_recv=${ac_cv_func_recv=yes} -ac_cv_func_recvfrom=${ac_cv_func_recvfrom=yes} -ac_cv_func_recvmsg=${ac_cv_func_recvmsg=yes} -ac_cv_func_regcomp=${ac_cv_func_regcomp=yes} -ac_cv_func_regerror=${ac_cv_func_regerror=yes} -ac_cv_func_regexec=${ac_cv_func_regexec=yes} -ac_cv_func_regfree=${ac_cv_func_regfree=yes} -ac_cv_func_remainder=${ac_cv_func_remainder=yes} -ac_cv_func_remainderf=${ac_cv_func_remainderf=yes} -ac_cv_func_remainderl=${ac_cv_func_remainderl=yes} -ac_cv_func_remove=${ac_cv_func_remove=yes} -ac_cv_func_removexattr=${ac_cv_func_removexattr=yes} -ac_cv_func_remque=${ac_cv_func_remque=yes} -ac_cv_func_remquo=${ac_cv_func_remquo=yes} -ac_cv_func_remquof=${ac_cv_func_remquof=yes} -ac_cv_func_remquol=${ac_cv_func_remquol=yes} -ac_cv_func_rename=${ac_cv_func_rename=yes} -ac_cv_func_renameat=${ac_cv_func_renameat=yes} -ac_cv_func_res_init=${ac_cv_func_res_init=yes} -ac_cv_func_res_query=${ac_cv_func_res_query=yes} -ac_cv_func_res_search=${ac_cv_func_res_search=yes} -ac_cv_func_rewind=${ac_cv_func_rewind=yes} -ac_cv_func_rewinddir=${ac_cv_func_rewinddir=yes} -ac_cv_func_rindex=${ac_cv_func_rindex=yes} -ac_cv_func_rint=${ac_cv_func_rint=yes} -ac_cv_func_rintf=${ac_cv_func_rintf=yes} -ac_cv_func_rintl=${ac_cv_func_rintl=yes} -ac_cv_func_rmdir=${ac_cv_func_rmdir=yes} -ac_cv_func_round=${ac_cv_func_round=yes} -ac_cv_func_roundf=${ac_cv_func_roundf=yes} -ac_cv_func_roundl=${ac_cv_func_roundl=yes} -ac_cv_func_sbrk=${ac_cv_func_sbrk=yes} -ac_cv_func_scalb=${ac_cv_func_scalb=yes} -ac_cv_func_scalbf=${ac_cv_func_scalbf=yes} -ac_cv_func_scalbln=${ac_cv_func_scalbln=yes} -ac_cv_func_scalblnf=${ac_cv_func_scalblnf=yes} -ac_cv_func_scalblnl=${ac_cv_func_scalblnl=yes} -ac_cv_func_scalbn=${ac_cv_func_scalbn=yes} -ac_cv_func_scalbnf=${ac_cv_func_scalbnf=yes} -ac_cv_func_scalbnl=${ac_cv_func_scalbnl=yes} -ac_cv_func_scandir64=${ac_cv_func_scandir64=yes} -ac_cv_func_scandir=${ac_cv_func_scandir=yes} -ac_cv_func_scanf=${ac_cv_func_scanf=yes} -ac_cv_func_sched_get_priority_max=${ac_cv_func_sched_get_priority_max=yes} -ac_cv_func_sched_get_priority_min=${ac_cv_func_sched_get_priority_min=yes} -ac_cv_func_sched_getparam=${ac_cv_func_sched_getparam=yes} -ac_cv_func_sched_getscheduler=${ac_cv_func_sched_getscheduler=yes} -ac_cv_func_sched_rr_get_interval=${ac_cv_func_sched_rr_get_interval=yes} -ac_cv_func_sched_setparam=${ac_cv_func_sched_setparam=yes} -ac_cv_func_sched_setscheduler=${ac_cv_func_sched_setscheduler=yes} -ac_cv_func_sched_yield=${ac_cv_func_sched_yield=yes} -ac_cv_func_seed48=${ac_cv_func_seed48=yes} -ac_cv_func_seekdir=${ac_cv_func_seekdir=yes} -ac_cv_func_select=${ac_cv_func_select=yes} -ac_cv_func_select_args=${ac_cv_func_select_args='int,fd_set *,struct timeval *'} -ac_cv_func_sem_close=${ac_cv_func_sem_close=yes} -ac_cv_func_sem_destroy=${ac_cv_func_sem_destroy=yes} -ac_cv_func_sem_getvalue=${ac_cv_func_sem_getvalue=yes} -ac_cv_func_sem_init=${ac_cv_func_sem_init=yes} -ac_cv_func_sem_open=${ac_cv_func_sem_open=yes} -ac_cv_func_sem_post=${ac_cv_func_sem_post=yes} -ac_cv_func_sem_timedwait=${ac_cv_func_sem_timedwait=yes} -ac_cv_func_sem_trywait=${ac_cv_func_sem_trywait=yes} -ac_cv_func_sem_unlink=${ac_cv_func_sem_unlink=yes} -ac_cv_func_sem_wait=${ac_cv_func_sem_wait=yes} -ac_cv_func_semctl=${ac_cv_func_semctl=yes} -ac_cv_func_semget=${ac_cv_func_semget=yes} -ac_cv_func_semop=${ac_cv_func_semop=yes} -ac_cv_func_send=${ac_cv_func_send=yes} -ac_cv_func_sendfile64=${ac_cv_func_sendfile64=yes} -ac_cv_func_sendfile=${ac_cv_func_sendfile=yes} -ac_cv_func_sendmsg=${ac_cv_func_sendmsg=yes} -ac_cv_func_sendto=${ac_cv_func_sendto=yes} -ac_cv_func_setbuf=${ac_cv_func_setbuf=yes} -ac_cv_func_setbuffer=${ac_cv_func_setbuffer=yes} -ac_cv_func_setegid=${ac_cv_func_setegid=yes} -ac_cv_func_setenv=${ac_cv_func_setenv=yes} -ac_cv_func_seteuid=${ac_cv_func_seteuid=yes} -ac_cv_func_setfsgid=${ac_cv_func_setfsgid=yes} -ac_cv_func_setfsuid=${ac_cv_func_setfsuid=yes} -ac_cv_func_setgid=${ac_cv_func_setgid=yes} -ac_cv_func_setgrent=${ac_cv_func_setgrent=yes} -ac_cv_func_setgrent_void=${ac_cv_func_setgrent_void=yes} -ac_cv_func_setgroups=${ac_cv_func_setgroups=yes} -ac_cv_func_sethostent=${ac_cv_func_sethostent=yes} -ac_cv_func_sethostname=${ac_cv_func_sethostname=yes} -ac_cv_func_setitimer=${ac_cv_func_setitimer=yes} -ac_cv_func_setjmp=${ac_cv_func_setjmp=yes} -ac_cv_func_setlinebuf=${ac_cv_func_setlinebuf=yes} -ac_cv_func_setlocale=${ac_cv_func_setlocale=yes} -ac_cv_func_setlogmask=${ac_cv_func_setlogmask=yes} -ac_cv_func_setmntent=${ac_cv_func_setmntent=yes} -ac_cv_func_setnetent=${ac_cv_func_setnetent=yes} -ac_cv_func_setpgid=${ac_cv_func_setpgid=yes} -ac_cv_func_setpgrp=${ac_cv_func_setpgrp=yes} -ac_cv_func_setpgrp_void=${ac_cv_func_setpgrp_void=yes} -ac_cv_func_setpriority=${ac_cv_func_setpriority=yes} -ac_cv_func_setprotoent=${ac_cv_func_setprotoent=yes} -ac_cv_func_setpwent=${ac_cv_func_setpwent=yes} -ac_cv_func_setregid=${ac_cv_func_setregid=yes} -ac_cv_func_setresgid=${ac_cv_func_setresgid=yes} -ac_cv_func_setresuid=${ac_cv_func_setresuid=no} -ac_cv_func_setreuid=${ac_cv_func_setreuid=yes} -ac_cv_func_setrlimit64=${ac_cv_func_setrlimit64=yes} -ac_cv_func_setrlimit=${ac_cv_func_setrlimit=yes} -ac_cv_func_setservent=${ac_cv_func_setservent=yes} -ac_cv_func_setsid=${ac_cv_func_setsid=yes} -ac_cv_func_setsockopt=${ac_cv_func_setsockopt=yes} -ac_cv_func_setspent=${ac_cv_func_setspent=yes} -ac_cv_func_setstate=${ac_cv_func_setstate=yes} -ac_cv_func_settimeofday=${ac_cv_func_settimeofday=yes} -ac_cv_func_setuid=${ac_cv_func_setuid=yes} -ac_cv_func_setusershell=${ac_cv_func_setusershell=yes} -ac_cv_func_setutent=${ac_cv_func_setutent=yes} -ac_cv_func_setutxent=${ac_cv_func_setutxent=yes} -ac_cv_func_setvbuf=${ac_cv_func_setvbuf=yes} -ac_cv_func_setvbuf_reversed=${ac_cv_func_setvbuf_reversed=no} -ac_cv_func_setxattr=${ac_cv_func_setxattr=yes} -ac_cv_func_shm_open=${ac_cv_func_shm_open=yes} -ac_cv_func_shm_unlink=${ac_cv_func_shm_unlink=yes} -ac_cv_func_shmat=${ac_cv_func_shmat=yes} -ac_cv_func_shmctl=${ac_cv_func_shmctl=yes} -ac_cv_func_shmdt=${ac_cv_func_shmdt=yes} -ac_cv_func_shmget=${ac_cv_func_shmget=yes} -ac_cv_func_shutdown=${ac_cv_func_shutdown=yes} -ac_cv_func_sigaction=${ac_cv_func_sigaction=yes} -ac_cv_func_sigaddset=${ac_cv_func_sigaddset=yes} -ac_cv_func_sigaltstack=${ac_cv_func_sigaltstack=yes} -ac_cv_func_sigdelset=${ac_cv_func_sigdelset=yes} -ac_cv_func_sigemptyset=${ac_cv_func_sigemptyset=yes} -ac_cv_func_sigfillset=${ac_cv_func_sigfillset=yes} -ac_cv_func_sighold=${ac_cv_func_sighold=yes} -ac_cv_func_sigignore=${ac_cv_func_sigignore=yes} -ac_cv_func_siginterrupt=${ac_cv_func_siginterrupt=yes} -ac_cv_func_sigisemptyset=${ac_cv_func_sigisemptyset=yes} -ac_cv_func_sigismember=${ac_cv_func_sigismember=yes} -ac_cv_func_siglongjmp=${ac_cv_func_siglongjmp=yes} -ac_cv_func_signal=${ac_cv_func_signal=yes} -ac_cv_func_signalfd=${ac_cv_func_signalfd=yes} -ac_cv_func_signgam=${ac_cv_func_signgam=yes} -ac_cv_func_significand=${ac_cv_func_significand=yes} -ac_cv_func_significandf=${ac_cv_func_significandf=yes} -ac_cv_func_sigpause=${ac_cv_func_sigpause=yes} -ac_cv_func_sigpending=${ac_cv_func_sigpending=yes} -ac_cv_func_sigprocmask=${ac_cv_func_sigprocmask=yes} -ac_cv_func_sigqueue=${ac_cv_func_sigqueue=yes} -ac_cv_func_sigrelse=${ac_cv_func_sigrelse=yes} -ac_cv_func_sigset=${ac_cv_func_sigset=yes} -ac_cv_func_sigsetjmp=${ac_cv_func_sigsetjmp=yes} -ac_cv_func_sigsuspend=${ac_cv_func_sigsuspend=yes} -ac_cv_func_sigtimedwait=${ac_cv_func_sigtimedwait=yes} -ac_cv_func_sigwait=${ac_cv_func_sigwait=yes} -ac_cv_func_sigwaitinfo=${ac_cv_func_sigwaitinfo=yes} -ac_cv_func_sin=${ac_cv_func_sin=yes} -ac_cv_func_sincos=${ac_cv_func_sincos=yes} -ac_cv_func_sincosf=${ac_cv_func_sincosf=yes} -ac_cv_func_sincosl=${ac_cv_func_sincosl=yes} -ac_cv_func_sinf=${ac_cv_func_sinf=yes} -ac_cv_func_sinh=${ac_cv_func_sinh=yes} -ac_cv_func_sinhf=${ac_cv_func_sinhf=yes} -ac_cv_func_sinhl=${ac_cv_func_sinhl=yes} -ac_cv_func_sinl=${ac_cv_func_sinl=yes} -ac_cv_func_sleep=${ac_cv_func_sleep=yes} -ac_cv_func_snprintf=${ac_cv_func_snprintf=yes} -ac_cv_func_sockatmark=${ac_cv_func_sockatmark=yes} -ac_cv_func_socket=${ac_cv_func_socket=yes} -ac_cv_func_socketpair=${ac_cv_func_socketpair=yes} -ac_cv_func_splice=${ac_cv_func_splice=yes} -ac_cv_func_sprintf=${ac_cv_func_sprintf=yes} -ac_cv_func_sqrt=${ac_cv_func_sqrt=yes} -ac_cv_func_sqrtf=${ac_cv_func_sqrtf=yes} -ac_cv_func_sqrtl=${ac_cv_func_sqrtl=yes} -ac_cv_func_srand48=${ac_cv_func_srand48=yes} -ac_cv_func_srand=${ac_cv_func_srand=yes} -ac_cv_func_srandom=${ac_cv_func_srandom=yes} -ac_cv_func_sscanf=${ac_cv_func_sscanf=yes} -ac_cv_func_stat64=${ac_cv_func_stat64=yes} -ac_cv_func_stat=${ac_cv_func_stat=yes} -ac_cv_func_stat_empty_string_bug=${ac_cv_func_stat_empty_string_bug=no} -ac_cv_func_stat_ignores_trailing_slash=${ac_cv_func_stat_ignores_trailing_slash=no} -ac_cv_func_statfs64=${ac_cv_func_statfs64=yes} -ac_cv_func_statfs=${ac_cv_func_statfs=yes} -ac_cv_func_statvfs64=${ac_cv_func_statvfs64=yes} -ac_cv_func_statvfs=${ac_cv_func_statvfs=yes} -ac_cv_func_stderr=${ac_cv_func_stderr=yes} -ac_cv_func_stdin=${ac_cv_func_stdin=yes} -ac_cv_func_stdout=${ac_cv_func_stdout=yes} -ac_cv_func_stime=${ac_cv_func_stime=yes} -ac_cv_func_stpcpy=${ac_cv_func_stpcpy=yes} -ac_cv_func_stpncpy=${ac_cv_func_stpncpy=yes} -ac_cv_func_strcasecmp=${ac_cv_func_strcasecmp=yes} -ac_cv_func_strcasecmp_l=${ac_cv_func_strcasecmp_l=yes} -ac_cv_func_strcasestr=${ac_cv_func_strcasestr=yes} -ac_cv_func_strcat=${ac_cv_func_strcat=yes} -ac_cv_func_strchr=${ac_cv_func_strchr=yes} -ac_cv_func_strchrnul=${ac_cv_func_strchrnul=yes} -ac_cv_func_strcmp=${ac_cv_func_strcmp=yes} -ac_cv_func_strcoll=${ac_cv_func_strcoll=yes} -ac_cv_func_strcoll_l=${ac_cv_func_strcoll_l=yes} -ac_cv_func_strcoll_works=${ac_cv_func_strcoll_works=no} -ac_cv_func_strcpy=${ac_cv_func_strcpy=yes} -ac_cv_func_strcspn=${ac_cv_func_strcspn=yes} -ac_cv_func_strdup=${ac_cv_func_strdup=yes} -ac_cv_func_strerror=${ac_cv_func_strerror=yes} -ac_cv_func_strerror_l=${ac_cv_func_strerror_l=yes} -ac_cv_func_strerror_r=${ac_cv_func_strerror_r=yes} -ac_cv_func_strerror_r_char_p=${ac_cv_func_strerror_r_char_p=no} -ac_cv_func_strfmon=${ac_cv_func_strfmon=yes} -ac_cv_func_strfmon_l=${ac_cv_func_strfmon_l=yes} -ac_cv_func_strftime=${ac_cv_func_strftime=yes} -ac_cv_func_strftime_l=${ac_cv_func_strftime_l=yes} -ac_cv_func_strlcat=${ac_cv_func_strlcat=yes} -ac_cv_func_strlcpy=${ac_cv_func_strlcpy=yes} -ac_cv_func_strlen=${ac_cv_func_strlen=yes} -ac_cv_func_strncasecmp=${ac_cv_func_strncasecmp=yes} -ac_cv_func_strncasecmp_l=${ac_cv_func_strncasecmp_l=yes} -ac_cv_func_strncat=${ac_cv_func_strncat=yes} -ac_cv_func_strncmp=${ac_cv_func_strncmp=yes} -ac_cv_func_strncpy=${ac_cv_func_strncpy=yes} -ac_cv_func_strndup=${ac_cv_func_strndup=yes} -ac_cv_func_strnlen=${ac_cv_func_strnlen=yes} -ac_cv_func_strpbrk=${ac_cv_func_strpbrk=yes} -ac_cv_func_strptime=${ac_cv_func_strptime=yes} -ac_cv_func_strrchr=${ac_cv_func_strrchr=yes} -ac_cv_func_strsep=${ac_cv_func_strsep=yes} -ac_cv_func_strsignal=${ac_cv_func_strsignal=yes} -ac_cv_func_strspn=${ac_cv_func_strspn=yes} -ac_cv_func_strstr=${ac_cv_func_strstr=yes} -ac_cv_func_strtod=${ac_cv_func_strtod=no} -ac_cv_func_strtof=${ac_cv_func_strtof=yes} -ac_cv_func_strtoimax=${ac_cv_func_strtoimax=yes} -ac_cv_func_strtok=${ac_cv_func_strtok=yes} -ac_cv_func_strtok_r=${ac_cv_func_strtok_r=yes} -ac_cv_func_strtol=${ac_cv_func_strtol=yes} -ac_cv_func_strtold=${ac_cv_func_strtold=yes} -ac_cv_func_strtoll=${ac_cv_func_strtoll=yes} -ac_cv_func_strtoul=${ac_cv_func_strtoul=yes} -ac_cv_func_strtoull=${ac_cv_func_strtoull=yes} -ac_cv_func_strtoumax=${ac_cv_func_strtoumax=yes} -ac_cv_func_strverscmp=${ac_cv_func_strverscmp=yes} -ac_cv_func_strxfrm=${ac_cv_func_strxfrm=yes} -ac_cv_func_strxfrm_l=${ac_cv_func_strxfrm_l=yes} -ac_cv_func_swab=${ac_cv_func_swab=yes} -ac_cv_func_swapoff=${ac_cv_func_swapoff=yes} -ac_cv_func_swapon=${ac_cv_func_swapon=yes} -ac_cv_func_swprintf=${ac_cv_func_swprintf=yes} -ac_cv_func_swscanf=${ac_cv_func_swscanf=yes} -ac_cv_func_symlink=${ac_cv_func_symlink=yes} -ac_cv_func_symlinkat=${ac_cv_func_symlinkat=yes} -ac_cv_func_sync=${ac_cv_func_sync=yes} -ac_cv_func_syscall=${ac_cv_func_syscall=yes} -ac_cv_func_sysconf=${ac_cv_func_sysconf=yes} -ac_cv_func_sysinfo=${ac_cv_func_sysinfo=yes} -ac_cv_func_syslog=${ac_cv_func_syslog=yes} -ac_cv_func_system=${ac_cv_func_system=yes} -ac_cv_func_tan=${ac_cv_func_tan=yes} -ac_cv_func_tanf=${ac_cv_func_tanf=yes} -ac_cv_func_tanh=${ac_cv_func_tanh=yes} -ac_cv_func_tanhf=${ac_cv_func_tanhf=yes} -ac_cv_func_tanhl=${ac_cv_func_tanhl=yes} -ac_cv_func_tanl=${ac_cv_func_tanl=yes} -ac_cv_func_tcdrain=${ac_cv_func_tcdrain=yes} -ac_cv_func_tcflow=${ac_cv_func_tcflow=yes} -ac_cv_func_tcflush=${ac_cv_func_tcflush=yes} -ac_cv_func_tcgetattr=${ac_cv_func_tcgetattr=yes} -ac_cv_func_tcgetpgrp=${ac_cv_func_tcgetpgrp=yes} -ac_cv_func_tcgetsid=${ac_cv_func_tcgetsid=yes} -ac_cv_func_tcsendbreak=${ac_cv_func_tcsendbreak=yes} -ac_cv_func_tcsetattr=${ac_cv_func_tcsetattr=yes} -ac_cv_func_tcsetpgrp=${ac_cv_func_tcsetpgrp=yes} -ac_cv_func_tdelete=${ac_cv_func_tdelete=yes} -ac_cv_func_tdestroy=${ac_cv_func_tdestroy=yes} -ac_cv_func_telldir=${ac_cv_func_telldir=yes} -ac_cv_func_tempnam=${ac_cv_func_tempnam=yes} -ac_cv_func_textdomain=${ac_cv_func_textdomain=yes} -ac_cv_func_tfind=${ac_cv_func_tfind=yes} -ac_cv_func_tgamma=${ac_cv_func_tgamma=yes} -ac_cv_func_tgammaf=${ac_cv_func_tgammaf=yes} -ac_cv_func_tgammal=${ac_cv_func_tgammal=yes} -ac_cv_func_time=${ac_cv_func_time=yes} -ac_cv_func_timegm=${ac_cv_func_timegm=yes} -ac_cv_func_timer_create=${ac_cv_func_timer_create=yes} -ac_cv_func_timer_delete=${ac_cv_func_timer_delete=yes} -ac_cv_func_timer_getoverrun=${ac_cv_func_timer_getoverrun=yes} -ac_cv_func_timer_gettime=${ac_cv_func_timer_gettime=yes} -ac_cv_func_timer_settime=${ac_cv_func_timer_settime=yes} -ac_cv_func_times=${ac_cv_func_times=yes} -ac_cv_func_timezone=${ac_cv_func_timezone=yes} -ac_cv_func_tmpfile64=${ac_cv_func_tmpfile64=yes} -ac_cv_func_tmpfile=${ac_cv_func_tmpfile=yes} -ac_cv_func_tmpnam=${ac_cv_func_tmpnam=yes} -ac_cv_func_toascii=${ac_cv_func_toascii=yes} -ac_cv_func_tolower=${ac_cv_func_tolower=yes} -ac_cv_func_tolower_l=${ac_cv_func_tolower_l=yes} -ac_cv_func_toupper=${ac_cv_func_toupper=yes} -ac_cv_func_toupper_l=${ac_cv_func_toupper_l=yes} -ac_cv_func_towctrans=${ac_cv_func_towctrans=yes} -ac_cv_func_towctrans_l=${ac_cv_func_towctrans_l=yes} -ac_cv_func_towlower=${ac_cv_func_towlower=yes} -ac_cv_func_towlower_l=${ac_cv_func_towlower_l=yes} -ac_cv_func_towupper=${ac_cv_func_towupper=yes} -ac_cv_func_towupper_l=${ac_cv_func_towupper_l=yes} -ac_cv_func_trunc=${ac_cv_func_trunc=yes} -ac_cv_func_truncate64=${ac_cv_func_truncate64=yes} -ac_cv_func_truncate=${ac_cv_func_truncate=yes} -ac_cv_func_truncf=${ac_cv_func_truncf=yes} -ac_cv_func_truncl=${ac_cv_func_truncl=yes} -ac_cv_func_tsearch=${ac_cv_func_tsearch=yes} -ac_cv_func_ttyname=${ac_cv_func_ttyname=yes} -ac_cv_func_ttyname_r=${ac_cv_func_ttyname_r=yes} -ac_cv_func_twalk=${ac_cv_func_twalk=yes} -ac_cv_func_tzname=${ac_cv_func_tzname=yes} -ac_cv_func_tzset=${ac_cv_func_tzset=yes} -ac_cv_func_ualarm=${ac_cv_func_ualarm=yes} -ac_cv_func_ulckpwdf=${ac_cv_func_ulckpwdf=yes} -ac_cv_func_ulimit=${ac_cv_func_ulimit=yes} -ac_cv_func_umask=${ac_cv_func_umask=yes} -ac_cv_func_umount2=${ac_cv_func_umount2=yes} -ac_cv_func_umount=${ac_cv_func_umount=yes} -ac_cv_func_uname=${ac_cv_func_uname=yes} -ac_cv_func_ungetc=${ac_cv_func_ungetc=yes} -ac_cv_func_ungetwc=${ac_cv_func_ungetwc=yes} -ac_cv_func_unlink=${ac_cv_func_unlink=yes} -ac_cv_func_unlinkat=${ac_cv_func_unlinkat=yes} -ac_cv_func_unlockpt=${ac_cv_func_unlockpt=yes} -ac_cv_func_unsetenv=${ac_cv_func_unsetenv=yes} -ac_cv_func_unshare=${ac_cv_func_unshare=yes} -ac_cv_func_updwtmp=${ac_cv_func_updwtmp=yes} -ac_cv_func_updwtmpx=${ac_cv_func_updwtmpx=yes} -ac_cv_func_uselocale=${ac_cv_func_uselocale=yes} -ac_cv_func_usleep=${ac_cv_func_usleep=yes} -ac_cv_func_utime=${ac_cv_func_utime=yes} -ac_cv_func_utime_null=${ac_cv_func_utime_null=yes} -ac_cv_func_utimensat=${ac_cv_func_utimensat=yes} -ac_cv_func_utimes=${ac_cv_func_utimes=yes} -ac_cv_func_va_copy=${ac_cv_func_va_copy=no} -ac_cv_func_vasprintf=${ac_cv_func_vasprintf=yes} -ac_cv_func_vdprintf=${ac_cv_func_vdprintf=yes} -ac_cv_func_verr=${ac_cv_func_verr=yes} -ac_cv_func_verrx=${ac_cv_func_verrx=yes} -ac_cv_func_versionsort=${ac_cv_func_versionsort=yes} -ac_cv_func_vfork=${ac_cv_func_vfork=yes} -ac_cv_func_vfork_works=${ac_cv_func_vfork_works=yes} -ac_cv_func_vfprintf=${ac_cv_func_vfprintf=yes} -ac_cv_func_vfscanf=${ac_cv_func_vfscanf=yes} -ac_cv_func_vfwprintf=${ac_cv_func_vfwprintf=yes} -ac_cv_func_vfwscanf=${ac_cv_func_vfwscanf=yes} -ac_cv_func_vhangup=${ac_cv_func_vhangup=yes} -ac_cv_func_vmsplice=${ac_cv_func_vmsplice=yes} -ac_cv_func_vprintf=${ac_cv_func_vprintf=yes} -ac_cv_func_vscanf=${ac_cv_func_vscanf=yes} -ac_cv_func_vsnprintf=${ac_cv_func_vsnprintf=yes} -ac_cv_func_vsprintf=${ac_cv_func_vsprintf=yes} -ac_cv_func_vsscanf=${ac_cv_func_vsscanf=yes} -ac_cv_func_vswprintf=${ac_cv_func_vswprintf=yes} -ac_cv_func_vswscanf=${ac_cv_func_vswscanf=yes} -ac_cv_func_vsyslog=${ac_cv_func_vsyslog=yes} -ac_cv_func_vwarn=${ac_cv_func_vwarn=yes} -ac_cv_func_vwarnx=${ac_cv_func_vwarnx=yes} -ac_cv_func_vwprintf=${ac_cv_func_vwprintf=yes} -ac_cv_func_vwscanf=${ac_cv_func_vwscanf=yes} -ac_cv_func_wait3=${ac_cv_func_wait3=yes} -ac_cv_func_wait4=${ac_cv_func_wait4=yes} -ac_cv_func_wait=${ac_cv_func_wait=yes} -ac_cv_func_waitid=${ac_cv_func_waitid=yes} -ac_cv_func_waitpid=${ac_cv_func_waitpid=yes} -ac_cv_func_warn=${ac_cv_func_warn=yes} -ac_cv_func_warnx=${ac_cv_func_warnx=yes} -ac_cv_func_wcpcpy=${ac_cv_func_wcpcpy=yes} -ac_cv_func_wcpncpy=${ac_cv_func_wcpncpy=yes} -ac_cv_func_wcrtomb=${ac_cv_func_wcrtomb=yes} -ac_cv_func_wcscasecmp=${ac_cv_func_wcscasecmp=yes} -ac_cv_func_wcscasecmp_l=${ac_cv_func_wcscasecmp_l=yes} -ac_cv_func_wcscat=${ac_cv_func_wcscat=yes} -ac_cv_func_wcschr=${ac_cv_func_wcschr=yes} -ac_cv_func_wcscmp=${ac_cv_func_wcscmp=yes} -ac_cv_func_wcscoll=${ac_cv_func_wcscoll=yes} -ac_cv_func_wcscoll_l=${ac_cv_func_wcscoll_l=yes} -ac_cv_func_wcscpy=${ac_cv_func_wcscpy=yes} -ac_cv_func_wcscspn=${ac_cv_func_wcscspn=yes} -ac_cv_func_wcsdup=${ac_cv_func_wcsdup=yes} -ac_cv_func_wcsftime=${ac_cv_func_wcsftime=yes} -ac_cv_func_wcslen=${ac_cv_func_wcslen=yes} -ac_cv_func_wcsncasecmp=${ac_cv_func_wcsncasecmp=yes} -ac_cv_func_wcsncasecmp_l=${ac_cv_func_wcsncasecmp_l=yes} -ac_cv_func_wcsncat=${ac_cv_func_wcsncat=yes} -ac_cv_func_wcsncmp=${ac_cv_func_wcsncmp=yes} -ac_cv_func_wcsncpy=${ac_cv_func_wcsncpy=yes} -ac_cv_func_wcsnlen=${ac_cv_func_wcsnlen=yes} -ac_cv_func_wcsnrtombs=${ac_cv_func_wcsnrtombs=yes} -ac_cv_func_wcspbrk=${ac_cv_func_wcspbrk=yes} -ac_cv_func_wcsrchr=${ac_cv_func_wcsrchr=yes} -ac_cv_func_wcsrtombs=${ac_cv_func_wcsrtombs=yes} -ac_cv_func_wcsspn=${ac_cv_func_wcsspn=yes} -ac_cv_func_wcsstr=${ac_cv_func_wcsstr=yes} -ac_cv_func_wcstod=${ac_cv_func_wcstod=yes} -ac_cv_func_wcstof=${ac_cv_func_wcstof=yes} -ac_cv_func_wcstoimax=${ac_cv_func_wcstoimax=yes} -ac_cv_func_wcstok=${ac_cv_func_wcstok=yes} -ac_cv_func_wcstol=${ac_cv_func_wcstol=yes} -ac_cv_func_wcstold=${ac_cv_func_wcstold=yes} -ac_cv_func_wcstoll=${ac_cv_func_wcstoll=yes} -ac_cv_func_wcstombs=${ac_cv_func_wcstombs=yes} -ac_cv_func_wcstoul=${ac_cv_func_wcstoul=yes} -ac_cv_func_wcstoull=${ac_cv_func_wcstoull=yes} -ac_cv_func_wcstoumax=${ac_cv_func_wcstoumax=yes} -ac_cv_func_wcswcs=${ac_cv_func_wcswcs=yes} -ac_cv_func_wcswidth=${ac_cv_func_wcswidth=yes} -ac_cv_func_wcsxfrm=${ac_cv_func_wcsxfrm=yes} -ac_cv_func_wcsxfrm_l=${ac_cv_func_wcsxfrm_l=yes} -ac_cv_func_wctob=${ac_cv_func_wctob=yes} -ac_cv_func_wctomb=${ac_cv_func_wctomb=yes} -ac_cv_func_wctrans=${ac_cv_func_wctrans=yes} -ac_cv_func_wctrans_l=${ac_cv_func_wctrans_l=yes} -ac_cv_func_wctype=${ac_cv_func_wctype=yes} -ac_cv_func_wctype_l=${ac_cv_func_wctype_l=yes} -ac_cv_func_wcwidth=${ac_cv_func_wcwidth=yes} -ac_cv_func_wmemchr=${ac_cv_func_wmemchr=yes} -ac_cv_func_wmemcmp=${ac_cv_func_wmemcmp=yes} -ac_cv_func_wmemcpy=${ac_cv_func_wmemcpy=yes} -ac_cv_func_wmemmove=${ac_cv_func_wmemmove=yes} -ac_cv_func_wmemset=${ac_cv_func_wmemset=yes} -ac_cv_func_wordexp=${ac_cv_func_wordexp=yes} -ac_cv_func_wordfree=${ac_cv_func_wordfree=yes} -ac_cv_func_working_mktime=${ac_cv_func_working_mktime=no} -ac_cv_func_wprintf=${ac_cv_func_wprintf=yes} -ac_cv_func_write=${ac_cv_func_write=yes} -ac_cv_func_writev=${ac_cv_func_writev=yes} -ac_cv_func_wscanf=${ac_cv_func_wscanf=yes} -ac_cv_func_y0=${ac_cv_func_y0=yes} -ac_cv_func_y0f=${ac_cv_func_y0f=yes} -ac_cv_func_y1=${ac_cv_func_y1=yes} -ac_cv_func_y1f=${ac_cv_func_y1f=yes} -ac_cv_func_yn=${ac_cv_func_yn=yes} -ac_cv_func_ynf=${ac_cv_func_ynf=yes} -ac_cv_have_accrights_in_msghdr=${ac_cv_have_accrights_in_msghdr=no} -ac_cv_have_broken_snprintf=${ac_cv_have_broken_snprintf=no} -ac_cv_have_control_in_msghdr=${ac_cv_have_control_in_msghdr=yes} -ac_cv_have_decl_strerror_r=${ac_cv_have_decl_strerror_r=yes} -ac_cv_have_decl_sys_siglist=${ac_cv_have_decl_sys_siglist=no} -ac_cv_have_openpty_ctty_bug=${ac_cv_have_openpty_ctty_bug=yes} -ac_cv_have_space_d_name_in_struct_dirent=${ac_cv_have_space_d_name_in_struct_dirent=yes} -ac_cv_header_aio_h=${ac_cv_header_aio_h=yes} -ac_cv_header_alloca_h=${ac_cv_header_alloca_h=yes} -ac_cv_header_ar_h=${ac_cv_header_ar_h=yes} -ac_cv_header_arpa_inet_h=${ac_cv_header_arpa_inet_h=yes} -ac_cv_header_arpa_nameser_h=${ac_cv_header_arpa_nameser_h=yes} -ac_cv_header_arpa_telnet_h=${ac_cv_header_arpa_telnet_h=yes} -ac_cv_header_assert_h=${ac_cv_header_assert_h=yes} -ac_cv_header_byteswap_h=${ac_cv_header_byteswap_h=yes} -ac_cv_header_complex_h=${ac_cv_header_complex_h=yes} -ac_cv_header_cpio_h=${ac_cv_header_cpio_h=yes} -ac_cv_header_crypt_h=${ac_cv_header_crypt_h=yes} -ac_cv_header_ctype_h=${ac_cv_header_ctype_h=yes} -ac_cv_header_dirent_dirent_h=${ac_cv_header_dirent_dirent_h=yes} -ac_cv_header_dirent_h=${ac_cv_header_dirent_h=yes} -ac_cv_header_dlfcn_h=${ac_cv_header_dlfcn_h=yes} -ac_cv_header_elf_h=${ac_cv_header_elf_h=yes} -ac_cv_header_endian_h=${ac_cv_header_endian_h=yes} -ac_cv_header_err_h=${ac_cv_header_err_h=yes} -ac_cv_header_errno_h=${ac_cv_header_errno_h=yes} -ac_cv_header_fcntl_h=${ac_cv_header_fcntl_h=yes} -ac_cv_header_features_h=${ac_cv_header_features_h=yes} -ac_cv_header_fenv_h=${ac_cv_header_fenv_h=yes} -ac_cv_header_float_h=${ac_cv_header_float_h=yes} -ac_cv_header_fnmatch_h=${ac_cv_header_fnmatch_h=yes} -ac_cv_header_ftw_h=${ac_cv_header_ftw_h=yes} -ac_cv_header_getopt_h=${ac_cv_header_getopt_h=yes} -ac_cv_header_glob_h=${ac_cv_header_glob_h=yes} -ac_cv_header_grp_h=${ac_cv_header_grp_h=yes} -ac_cv_header_iconv_h=${ac_cv_header_iconv_h=yes} -ac_cv_header_inttypes_h=${ac_cv_header_inttypes_h=yes} -ac_cv_header_iso646_h=${ac_cv_header_iso646_h=yes} -ac_cv_header_langinfo_h=${ac_cv_header_langinfo_h=yes} -ac_cv_header_lastlog_h=${ac_cv_header_lastlog_h=yes} -ac_cv_header_libgen_h=${ac_cv_header_libgen_h=yes} -ac_cv_header_libintl_h=${ac_cv_header_libintl_h=yes} -ac_cv_header_limits_h=${ac_cv_header_limits_h=yes} -ac_cv_header_locale_h=${ac_cv_header_locale_h=yes} -ac_cv_header_malloc_h=${ac_cv_header_malloc_h=yes} -ac_cv_header_math_h=${ac_cv_header_math_h=yes} -ac_cv_header_memory_h=${ac_cv_header_memory_h=yes} -ac_cv_header_mntent_h=${ac_cv_header_mntent_h=yes} -ac_cv_header_monetary_h=${ac_cv_header_monetary_h=yes} -ac_cv_header_mqueue_h=${ac_cv_header_mqueue_h=yes} -ac_cv_header_net_ethernet_h=${ac_cv_header_net_ethernet_h=yes} -ac_cv_header_net_if_arp_h=${ac_cv_header_net_if_arp_h=yes} -ac_cv_header_net_if_h=${ac_cv_header_net_if_h=yes} -ac_cv_header_net_route_h=${ac_cv_header_net_route_h=yes} -ac_cv_header_netdb_h=${ac_cv_header_netdb_h=yes} -ac_cv_header_netinet_icmp6_h=${ac_cv_header_netinet_icmp6_h=yes} -ac_cv_header_netinet_if_ether_h=${ac_cv_header_netinet_if_ether_h=yes} -ac_cv_header_netinet_in_h=${ac_cv_header_netinet_in_h=yes} -ac_cv_header_netinet_in_systm_h=${ac_cv_header_netinet_in_systm_h=yes} -ac_cv_header_netinet_ip6_h=${ac_cv_header_netinet_ip6_h=yes} -ac_cv_header_netinet_ip_h=${ac_cv_header_netinet_ip_h=yes} -ac_cv_header_netinet_ip_icmp_h=${ac_cv_header_netinet_ip_icmp_h=yes} -ac_cv_header_netinet_sctp_h=${ac_cv_header_netinet_sctp_h=no} -ac_cv_header_netinet_sctp_uio_h=${ac_cv_header_netinet_sctp_uio_h=no} -ac_cv_header_netinet_tcp_h=${ac_cv_header_netinet_tcp_h=yes} -ac_cv_header_netinet_udp_h=${ac_cv_header_netinet_udp_h=yes} -ac_cv_header_netpacket_packet_h=${ac_cv_header_netpacket_packet_h=yes} -ac_cv_header_nl_types_h=${ac_cv_header_nl_types_h=yes} -ac_cv_header_paths_h=${ac_cv_header_paths_h=yes} -ac_cv_header_poll_h=${ac_cv_header_poll_h=yes} -ac_cv_header_pthread_h=${ac_cv_header_pthread_h=yes} -ac_cv_header_pty_h=${ac_cv_header_pty_h=yes} -ac_cv_header_pwd_h=${ac_cv_header_pwd_h=yes} -ac_cv_header_regex_h=${ac_cv_header_regex_h=yes} -ac_cv_header_resolv_h=${ac_cv_header_resolv_h=yes} -ac_cv_header_sched_h=${ac_cv_header_sched_h=yes} -ac_cv_header_search_h=${ac_cv_header_search_h=yes} -ac_cv_header_semaphore_h=${ac_cv_header_semaphore_h=yes} -ac_cv_header_setjmp_h=${ac_cv_header_setjmp_h=yes} -ac_cv_header_shadow_h=${ac_cv_header_shadow_h=yes} -ac_cv_header_signal_h=${ac_cv_header_signal_h=yes} -ac_cv_header_spawn_h=${ac_cv_header_spawn_h=yes} -ac_cv_header_stat_broken=${ac_cv_header_stat_broken=no} -ac_cv_header_stdarg_h=${ac_cv_header_stdarg_h=yes} -ac_cv_header_stdbool_h=${ac_cv_header_stdbool_h=yes} -ac_cv_header_stdc=${ac_cv_header_stdc=yes} -ac_cv_header_stddef_h=${ac_cv_header_stddef_h=yes} -ac_cv_header_stdint_h=${ac_cv_header_stdint_h=yes} -ac_cv_header_stdio_ext_h=${ac_cv_header_stdio_ext_h=yes} -ac_cv_header_stdio_h=${ac_cv_header_stdio_h=yes} -ac_cv_header_stdlib_h=${ac_cv_header_stdlib_h=yes} -ac_cv_header_string_h=${ac_cv_header_string_h=yes} -ac_cv_header_strings_h=${ac_cv_header_strings_h=yes} -ac_cv_header_stropts_h=${ac_cv_header_stropts_h=yes} -ac_cv_header_sys_cdefs_h=${ac_cv_header_sys_cdefs_h=yes} -ac_cv_header_sys_epoll_h=${ac_cv_header_sys_epoll_h=yes} -ac_cv_header_sys_eventfd_h=${ac_cv_header_sys_eventfd_h=yes} -ac_cv_header_sys_file_h=${ac_cv_header_sys_file_h=yes} -ac_cv_header_sys_fsuid_h=${ac_cv_header_sys_fsuid_h=yes} -ac_cv_header_sys_inotify_h=${ac_cv_header_sys_inotify_h=yes} -ac_cv_header_sys_io_h=${ac_cv_header_sys_io_h=yes} -ac_cv_header_sys_ioctl_h=${ac_cv_header_sys_ioctl_h=yes} -ac_cv_header_sys_ipc_h=${ac_cv_header_sys_ipc_h=yes} -ac_cv_header_sys_kd_h=${ac_cv_header_sys_kd_h=yes} -ac_cv_header_sys_klog_h=${ac_cv_header_sys_klog_h=yes} -ac_cv_header_sys_mman_h=${ac_cv_header_sys_mman_h=yes} -ac_cv_header_sys_mount_h=${ac_cv_header_sys_mount_h=yes} -ac_cv_header_sys_msg_h=${ac_cv_header_sys_msg_h=yes} -ac_cv_header_sys_param_h=${ac_cv_header_sys_param_h=yes} -ac_cv_header_sys_poll_h=${ac_cv_header_sys_poll_h=yes} -ac_cv_header_sys_prctl_h=${ac_cv_header_sys_prctl_h=yes} -ac_cv_header_sys_procfs_h=${ac_cv_header_sys_procfs_h=yes} -ac_cv_header_sys_ptrace_h=${ac_cv_header_sys_ptrace_h=yes} -ac_cv_header_sys_reboot_h=${ac_cv_header_sys_reboot_h=yes} -ac_cv_header_sys_reg_h=${ac_cv_header_sys_reg_h=yes} -ac_cv_header_sys_resource_h=${ac_cv_header_sys_resource_h=yes} -ac_cv_header_sys_select_h=${ac_cv_header_sys_select_h=yes} -ac_cv_header_sys_sem_h=${ac_cv_header_sys_sem_h=yes} -ac_cv_header_sys_sendfile_h=${ac_cv_header_sys_sendfile_h=yes} -ac_cv_header_sys_shm_h=${ac_cv_header_sys_shm_h=yes} -ac_cv_header_sys_signalfd_h=${ac_cv_header_sys_signalfd_h=yes} -ac_cv_header_sys_socket_h=${ac_cv_header_sys_socket_h=yes} -ac_cv_header_sys_soundcard_h=${ac_cv_header_sys_soundcard_h=yes} -ac_cv_header_sys_stat_h=${ac_cv_header_sys_stat_h=yes} -ac_cv_header_sys_statfs_h=${ac_cv_header_sys_statfs_h=yes} -ac_cv_header_sys_statvfs_h=${ac_cv_header_sys_statvfs_h=yes} -ac_cv_header_sys_stropts_h=${ac_cv_header_sys_stropts_h=yes} -ac_cv_header_sys_swap_h=${ac_cv_header_sys_swap_h=yes} -ac_cv_header_sys_syscall_h=${ac_cv_header_sys_syscall_h=yes} -ac_cv_header_sys_sysctl_h=${ac_cv_header_sys_sysctl_h=no} -ac_cv_header_sys_sysinfo_h=${ac_cv_header_sys_sysinfo_h=yes} -ac_cv_header_sys_syslog_h=${ac_cv_header_sys_syslog_h=yes} -ac_cv_header_sys_sysmacros_h=${ac_cv_header_sys_sysmacros_h=yes} -ac_cv_header_sys_time_h=${ac_cv_header_sys_time_h=yes} -ac_cv_header_sys_times_h=${ac_cv_header_sys_times_h=yes} -ac_cv_header_sys_timex_h=${ac_cv_header_sys_timex_h=yes} -ac_cv_header_sys_types_h=${ac_cv_header_sys_types_h=yes} -ac_cv_header_sys_types_h_makedev=${ac_cv_header_sys_types_h_makedev=yes} -ac_cv_header_sys_ucontext_h=${ac_cv_header_sys_ucontext_h=yes} -ac_cv_header_sys_uio_h=${ac_cv_header_sys_uio_h=yes} -ac_cv_header_sys_un_h=${ac_cv_header_sys_un_h=yes} -ac_cv_header_sys_user_h=${ac_cv_header_sys_user_h=yes} -ac_cv_header_sys_utsname_h=${ac_cv_header_sys_utsname_h=yes} -ac_cv_header_sys_vfs_h=${ac_cv_header_sys_vfs_h=yes} -ac_cv_header_sys_vt_h=${ac_cv_header_sys_vt_h=yes} -ac_cv_header_sys_wait_h=${ac_cv_header_sys_wait_h=yes} -ac_cv_header_sys_xattr_h=${ac_cv_header_sys_xattr_h=yes} -ac_cv_header_syscall_h=${ac_cv_header_syscall_h=yes} -ac_cv_header_sysexits_h=${ac_cv_header_sysexits_h=yes} -ac_cv_header_syslog_h=${ac_cv_header_syslog_h=yes} -ac_cv_header_tar_h=${ac_cv_header_tar_h=yes} -ac_cv_header_termios_h=${ac_cv_header_termios_h=yes} -ac_cv_header_tgmath_h=${ac_cv_header_tgmath_h=yes} -ac_cv_header_time=${ac_cv_header_time=yes} -ac_cv_header_time_h=${ac_cv_header_time_h=yes} -ac_cv_header_ucontext_h=${ac_cv_header_ucontext_h=yes} -ac_cv_header_ulimit_h=${ac_cv_header_ulimit_h=yes} -ac_cv_header_unistd_h=${ac_cv_header_unistd_h=yes} -ac_cv_header_utime_h=${ac_cv_header_utime_h=yes} -ac_cv_header_utmp_h=${ac_cv_header_utmp_h=yes} -ac_cv_header_utmpx_h=${ac_cv_header_utmpx_h=yes} -ac_cv_header_vfork_h=${ac_cv_header_vfork_h=no} -ac_cv_header_wchar_h=${ac_cv_header_wchar_h=yes} -ac_cv_header_wctype_h=${ac_cv_header_wctype_h=yes} -ac_cv_header_wordexp_h=${ac_cv_header_wordexp_h=yes} -ac_cv_lib_crypt_main=${ac_cv_lib_crypt_main=yes} -ac_cv_lib_dl_main=${ac_cv_lib_dl_main=yes} -ac_cv_lib_error_at_line=${ac_cv_lib_error_at_line=no} -ac_cv_lib_kstat_kstat_open=${ac_cv_lib_kstat_kstat_open=no} -ac_cv_lib_lex=${ac_cv_lib_lex='none needed'} -ac_cv_lib_m_main=${ac_cv_lib_m_main=yes} -ac_cv_lib_pthread_main=${ac_cv_lib_pthread_main=yes} -ac_cv_lib_resolv_main=${ac_cv_lib_resolv_main=yes} -ac_cv_lib_rt_main=${ac_cv_lib_rt_main=yes} -ac_cv_lib_socket_main=${ac_cv_lib_socket_main=no} -ac_cv_lib_util_main=${ac_cv_lib_util_main=yes} -ac_cv_lib_xnet_main=${ac_cv_lib_xnet_main=yes} -ac_cv_member_struct_dirent_d_ino=${ac_cv_member_struct_dirent_d_ino=yes} -ac_cv_member_struct_dirent_d_type=${ac_cv_member_struct_dirent_d_type=yes} -ac_cv_member_struct_stat_st_blocks=${ac_cv_member_struct_stat_st_blocks=yes} -ac_cv_member_struct_tm_tm_zone=${ac_cv_member_struct_tm_tm_zone=yes} -ac_cv_objext=${ac_cv_objext=o} -ac_cv_prog_AWK=${ac_cv_prog_AWK=gawk} -ac_cv_prog_LEX=${ac_cv_prog_LEX=flex} -ac_cv_prog_cc_c89=${ac_cv_prog_cc_c89=} -ac_cv_prog_cc_c99=${ac_cv_prog_cc_c99=} -ac_cv_prog_cc_g=${ac_cv_prog_cc_g=yes} -ac_cv_prog_cc_stdc=${ac_cv_prog_cc_stdc=} -ac_cv_prog_cxx_c_o=${ac_cv_prog_cxx_c_o=yes} -ac_cv_prog_cxx_g=${ac_cv_prog_cxx_g=yes} -ac_cv_prog_gcc_traditional=${ac_cv_prog_gcc_traditional=no} -ac_cv_prog_lex_root=${ac_cv_prog_lex_root=lex.yy} -ac_cv_prog_lex_yytext_pointer=${ac_cv_prog_lex_yytext_pointer=no} -ac_cv_prog_make_make_set=${ac_cv_prog_make_make_set=yes} -ac_cv_regexec_segfault_emptystr=${ac_cv_regexec_segfault_emptystr=no} -ac_cv_search_getmntent=${ac_cv_search_getmntent='none required'} -ac_cv_search_opendir=${ac_cv_search_opendir='none required'} -ac_cv_struct_tm=${ac_cv_struct_tm=time.h} -ac_cv_sys_file_offset_bits=${ac_cv_sys_file_offset_bits=no} -ac_cv_sys_interpreter=${ac_cv_sys_interpreter=yes} -ac_cv_sys_largefile_CC=${ac_cv_sys_largefile_CC=no} -ac_cv_sys_largefile_source=${ac_cv_sys_largefile_source=no} -ac_cv_sys_long_file_names=${ac_cv_sys_long_file_names=yes} -ac_cv_sys_posix_termios=${ac_cv_sys_posix_termios=yes} -ac_cv_sys_restartable_syscalls=${ac_cv_sys_restartable_syscalls=yes} -ac_cv_sys_tiocgwinsz_in_sys_ioctl_h=${ac_cv_sys_tiocgwinsz_in_sys_ioctl_h=yes} -ac_cv_sys_tiocgwinsz_in_termios_h=${ac_cv_sys_tiocgwinsz_in_termios_h=no} -ac_cv_time_r_type=${ac_cv_time_r_type=POSIX} -ac_cv_type__Bool=${ac_cv_type__Bool=yes} -ac_cv_type_getgroups=${ac_cv_type_getgroups=gid_t} -ac_cv_type_intmax_t=${ac_cv_type_intmax_t=yes} -ac_cv_type_intptr_t=${ac_cv_type_intptr_t=yes} -ac_cv_type_long_double=${ac_cv_type_long_double=yes} -ac_cv_type_long_long_int=${ac_cv_type_long_long_int=yes} -ac_cv_type_mbstate_t=${ac_cv_type_mbstate_t=yes} -ac_cv_type_mode_t=${ac_cv_type_mode_t=yes} -ac_cv_type_off_t=${ac_cv_type_off_t=yes} -ac_cv_type_pid_t=${ac_cv_type_pid_t=yes} -ac_cv_type_size_t=${ac_cv_type_size_t=yes} -ac_cv_type_ssize_t=${ac_cv_type_ssize_t=yes} -ac_cv_type_uid_t=${ac_cv_type_uid_t=yes} -ac_cv_type_uintmax_t=${ac_cv_type_uintmax_t=yes} -ac_cv_type_uintptr_t=${ac_cv_type_uintptr_t=yes} -ac_cv_type_unsigned_long_long_int=${ac_cv_type_unsigned_long_long_int=yes} -ac_cv_working_alloca_h=${ac_cv_working_alloca_h=yes} -am_cv_ar_interface=${am_cv_ar_interface=ar} -am_cv_make_support_nested_variables=${am_cv_make_support_nested_variables=yes} -am_cv_prog_cc_c_o=${am_cv_prog_cc_c_o=yes} diff --git a/toolchain/autoconf-lean/patches/100-remove-unused-checks.patch b/toolchain/autoconf-lean/patches/100-remove-unused-checks.patch deleted file mode 100644 index aa26336fe0..0000000000 --- a/toolchain/autoconf-lean/patches/100-remove-unused-checks.patch +++ /dev/null @@ -1,93 +0,0 @@ ---- a/config-site-generator/configure.ac -+++ b/config-site-generator/configure.ac -@@ -31,16 +31,16 @@ AC_PROG_GCC_TRADITIONAL - AC_PROG_CXX - AC_PROG_CXXCPP - AC_PROG_CXX_C_O --AC_PROG_OBJC --AC_PROG_OBJCPP --AC_PROG_OBJCXX --AC_PROG_OBJCXXCPP -+#AC_PROG_OBJC -+#AC_PROG_OBJCPP -+#AC_PROG_OBJCXX -+#AC_PROG_OBJCXXCPP - #AC_ERLANG_PATH_ERLC - #AC_ERLANG_PATH_ERL --AC_PROG_F77 --AC_PROG_FC --AC_PROG_F77_C_O --AC_PROG_FC_C_O -+#AC_PROG_F77 -+#AC_PROG_FC -+#AC_PROG_F77_C_O -+#AC_PROG_FC_C_O - #AC_PROG_GO - AC_PROG_AWK - AC_PROG_GREP -@@ -52,13 +52,13 @@ AC_PROG_LEX - AC_PROG_LN_S - AC_PROG_RANLIB - AC_PROG_SED --AC_PROG_YACC -+#AC_PROG_YACC - - AM_PROG_AS - - # Checks for system services. --AC_PATH_X --AC_PATH_XTRA -+#AC_PATH_X -+#AC_PATH_XTRA - AC_SYS_INTERPRETER - AC_SYS_LARGEFILE - AC_SYS_LONG_FILE_NAMES -@@ -163,27 +163,27 @@ AC_C_FLEXIBLE_ARRAY_MEMBER - AC_C_VARARRAYS - AC_C_TYPEOF - AC_C_PROTOTYPES --AC_F77_LIBRARY_LDFLAGS --AC_FC_LIBRARY_LDFLAGS --AC_F77_DUMMY_MAIN --AC_FC_DUMMY_MAIN --AC_F77_MAIN --AC_FC_MAIN --AC_F77_WRAPPERS --AC_FC_WRAPPERS --AC_F77_FUNC --AC_FC_FUNC --AC_FC_PP_SRCEXT --AC_FC_PP_DEFINE --AC_FC_FREEFORM --AC_FC_FIXEDFORM --AC_FC_LINE_LENGTH --AC_FC_CHECK_BOUNDS --AC_F77_IMPLICIT_NONE --AC_FC_IMPLICIT_NONE --AC_FC_MODULE_EXTENSION --AC_FC_MODULE_FLAG --AC_FC_MODULE_OUTPUT_FLAG -+#AC_F77_LIBRARY_LDFLAGS -+#AC_FC_LIBRARY_LDFLAGS -+#AC_F77_DUMMY_MAIN -+#AC_FC_DUMMY_MAIN -+#AC_F77_MAIN -+#AC_FC_MAIN -+#AC_F77_WRAPPERS -+#AC_FC_WRAPPERS -+#AC_F77_FUNC -+#AC_FC_FUNC -+#AC_FC_PP_SRCEXT -+#AC_FC_PP_DEFINE -+#AC_FC_FREEFORM -+#AC_FC_FIXEDFORM -+#AC_FC_LINE_LENGTH -+#AC_FC_CHECK_BOUNDS -+#AC_F77_IMPLICIT_NONE -+#AC_FC_IMPLICIT_NONE -+#AC_FC_MODULE_EXTENSION -+#AC_FC_MODULE_FLAG -+#AC_FC_MODULE_OUTPUT_FLAG - - # Checks for library functions. - AC_FUNC_ALLOCA diff --git a/toolchain/autoconf-lean/patches/120-add-extra-checks.patch b/toolchain/autoconf-lean/patches/120-add-extra-checks.patch deleted file mode 100644 index 7e81525daf..0000000000 --- a/toolchain/autoconf-lean/patches/120-add-extra-checks.patch +++ /dev/null @@ -1,48 +0,0 @@ ---- a/config-site-generator/configure.ac -+++ b/config-site-generator/configure.ac -@@ -23,6 +23,7 @@ AC_DEFUN([AC_MSG_ERROR], [ - test -e conftest.dir && rm -rf conftest.dir ]) - - # Checks for programs. -+AC_PROG_CC - AC_PROG_CC_C89 - AC_PROG_CC_C_O - AC_PROG_CPP -@@ -52,9 +53,11 @@ AC_PROG_LEX - AC_PROG_LN_S - AC_PROG_RANLIB - AC_PROG_SED -+AC_PROG_LEX - #AC_PROG_YACC - - AM_PROG_AS -+AM_PROG_AR - - # Checks for system services. - #AC_PATH_X -@@ -118,6 +121,8 @@ sys/ucontext.h sys/uio.h sys/un.h sys/us - sys/wait.h sys/xattr.h tar.h termios.h tgmath.h time.h ucontext.h ulimit.h \ - unistd.h utime.h utmp.h utmpx.h wchar.h wctype.h wordexp.h - ]) -+# extra headers -+AC_CHECK_HEADERS([sys/cdefs.h]) - - # Checks for typedefs, structures, and compiler characteristics. - AC_TYPE_GETGROUPS -@@ -217,6 +222,16 @@ AC_FUNC_STRTOLD - AC_FUNC_UTIME_NULL - AC_FUNC_VPRINTF - -+AC_CHECK_SIZEOF(short) -+AC_CHECK_SIZEOF(int) -+AC_CHECK_SIZEOF(long) -+AC_CHECK_SIZEOF(long long) -+AC_CHECK_SIZEOF(unsigned int) -+AC_CHECK_SIZEOF(unsigned long) -+AC_CHECK_SIZEOF(unsigned long long) -+AC_CHECK_SIZEOF(off_t) -+AC_CHECK_SIZEOF(size_t) -+ - # Functions list scraped from musl 0.9.4 x86_64 - AC_CHECK_FUNCS([ \ - a64l abort abs accept access acos acosf acosh acoshf acoshl acosl addmntent \ From 05131fd251f64d531a6b3cc6936bc19404dd440a Mon Sep 17 00:00:00 2001 From: Tianling Shen Date: Wed, 3 Mar 2021 00:39:33 +0800 Subject: [PATCH 5/8] kernel: bump to 4.9.258, 4.14.222, 4.19.177 Refreshed all patches. Signed-off-by: Tianling Shen --- include/kernel-version.mk | 12 ++++++------ .../patches-4.14/910-unaligned_access_hacks.patch | 2 +- .../patches-4.14/910-unaligned_access_hacks.patch | 2 +- ...ter-nf_conntrack-add-IPS_OFFLOAD-status-bit.patch | 6 +++--- ...-nf_flow_table-fix-offloaded-connection-tim.patch | 4 ++-- ...TT-bloat-by-skipping-RTT-from-delayed-ACK-.patch} | 0 ...in-restart-from-idle-see-if-we-should-exit.patch} | 0 ...r-apply-PROBE_RTT-cwnd-cap-even-if-acked-0.patch} | 0 ...-nf_flow_table-fix-offloaded-connection-tim.patch | 4 ++-- .../generic/hack-4.14/207-disable-modorder.patch | 4 ++-- target/linux/generic/hack-4.14/220-gc_sections.patch | 2 +- .../linux/generic/hack-4.14/221-module_exports.patch | 2 +- target/linux/generic/hack-4.14/930-crashlog.patch | 4 ++-- ...onntrack-events-support-multiple-registrant.patch | 2 +- ...onntrack-events-support-multiple-registrant.patch | 2 +- .../generic/hack-4.9/207-disable-modorder.patch | 4 ++-- .../linux/generic/hack-4.9/221-module_exports.patch | 2 +- target/linux/generic/hack-4.9/930-crashlog.patch | 4 ++-- ...onntrack-events-support-multiple-registrant.patch | 2 +- 19 files changed, 29 insertions(+), 29 deletions(-) rename target/linux/generic/backport-4.14/{605-0002-tcp-avoid-min-R-bloat-by-skipping-R-from-delayed-K-in.patch => 605-0002-tcp-avoid-min-RTT-bloat-by-skipping-RTT-from-delayed-ACK-.patch} (100%) rename target/linux/generic/backport-4.14/{605-0008-tcp_bbr-in-restart-from-idle,-see-if-we-should-exit.patch => 605-0008-tcp_bbr-in-restart-from-idle-see-if-we-should-exit.patch} (100%) rename target/linux/generic/backport-4.14/{605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked==0.patch => 605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked-0.patch} (100%) diff --git a/include/kernel-version.mk b/include/kernel-version.mk index 005ea9120a..3f0b2c2e05 100644 --- a/include/kernel-version.mk +++ b/include/kernel-version.mk @@ -6,13 +6,13 @@ ifdef CONFIG_TESTING_KERNEL KERNEL_PATCHVER:=$(KERNEL_TESTING_PATCHVER) endif -LINUX_VERSION-4.9 = .257 -LINUX_VERSION-4.14 = .221 -LINUX_VERSION-4.19 = .176 +LINUX_VERSION-4.9 = .258 +LINUX_VERSION-4.14 = .222 +LINUX_VERSION-4.19 = .177 -LINUX_KERNEL_HASH-4.9.257 = 95e780fffc81de8217a31a3e6e212b69643f5344e9ba0dabaa6e426126f6d64f -LINUX_KERNEL_HASH-4.14.221 = ce2254075ff4846f13380c1cf4bec1e351e5996a7dd109c200e222e49fd2c7e9 -LINUX_KERNEL_HASH-4.19.176 = e1c3b8d21ba31bd5c50bb3b2a741f62958eb2a116bf13fa0e14f1656c4826073 +LINUX_KERNEL_HASH-4.9.258 = d478f8e069f6d8b86b0a69f99252ea9e7cd7070bf6bdd0e9b3773ee418e5c8cd +LINUX_KERNEL_HASH-4.14.222 = 734082b03d9f8e43b123b0061f08045b70c34e3a4b09f8a8da6a287686dac744 +LINUX_KERNEL_HASH-4.19.177 = ac0eb3794e01eac66bea3ab39b8776dadf15c418ddc534ccfd95a0270302357d remove_uri_prefix=$(subst git://,,$(subst http://,,$(subst https://,,$(1)))) sanitize_uri=$(call qstrip,$(subst @,_,$(subst :,_,$(subst .,_,$(subst -,_,$(subst /,_,$(1))))))) diff --git a/target/linux/ar71xx/patches-4.14/910-unaligned_access_hacks.patch b/target/linux/ar71xx/patches-4.14/910-unaligned_access_hacks.patch index ed32e94239..75bd060a68 100644 --- a/target/linux/ar71xx/patches-4.14/910-unaligned_access_hacks.patch +++ b/target/linux/ar71xx/patches-4.14/910-unaligned_access_hacks.patch @@ -757,7 +757,7 @@ EXPORT_SYMBOL(xfrm_parse_spi); --- a/net/ipv4/tcp_input.c +++ b/net/ipv4/tcp_input.c -@@ -3881,14 +3881,16 @@ static bool tcp_parse_aligned_timestamp( +@@ -3901,14 +3901,16 @@ static bool tcp_parse_aligned_timestamp( { const __be32 *ptr = (const __be32 *)(th + 1); diff --git a/target/linux/ath79/patches-4.14/910-unaligned_access_hacks.patch b/target/linux/ath79/patches-4.14/910-unaligned_access_hacks.patch index d204298662..ea80a1ae61 100644 --- a/target/linux/ath79/patches-4.14/910-unaligned_access_hacks.patch +++ b/target/linux/ath79/patches-4.14/910-unaligned_access_hacks.patch @@ -737,7 +737,7 @@ EXPORT_SYMBOL(xfrm_parse_spi); --- a/net/ipv4/tcp_input.c +++ b/net/ipv4/tcp_input.c -@@ -3881,14 +3881,16 @@ static bool tcp_parse_aligned_timestamp( +@@ -3901,14 +3901,16 @@ static bool tcp_parse_aligned_timestamp( { const __be32 *ptr = (const __be32 *)(th + 1); diff --git a/target/linux/generic/backport-4.14/320-v4.16-netfilter-nf_conntrack-add-IPS_OFFLOAD-status-bit.patch b/target/linux/generic/backport-4.14/320-v4.16-netfilter-nf_conntrack-add-IPS_OFFLOAD-status-bit.patch index 6390cc4f2b..39ef23be2a 100644 --- a/target/linux/generic/backport-4.14/320-v4.16-netfilter-nf_conntrack-add-IPS_OFFLOAD-status-bit.patch +++ b/target/linux/generic/backport-4.14/320-v4.16-netfilter-nf_conntrack-add-IPS_OFFLOAD-status-bit.patch @@ -47,7 +47,7 @@ Signed-off-by: Pablo Neira Ayuso }; --- a/net/netfilter/nf_conntrack_core.c +++ b/net/netfilter/nf_conntrack_core.c -@@ -974,6 +974,9 @@ static unsigned int early_drop_list(stru +@@ -975,6 +975,9 @@ static unsigned int early_drop_list(stru hlist_nulls_for_each_entry_rcu(h, n, head, hnnode) { tmp = nf_ct_tuplehash_to_ctrack(h); @@ -57,7 +57,7 @@ Signed-off-by: Pablo Neira Ayuso if (nf_ct_is_expired(tmp)) { nf_ct_gc_expired(tmp); continue; -@@ -1051,6 +1054,18 @@ static bool gc_worker_can_early_drop(con +@@ -1052,6 +1055,18 @@ static bool gc_worker_can_early_drop(con return false; } @@ -76,7 +76,7 @@ Signed-off-by: Pablo Neira Ayuso static void gc_worker(struct work_struct *work) { unsigned int min_interval = max(HZ / GC_MAX_BUCKETS_DIV, 1u); -@@ -1087,6 +1102,11 @@ static void gc_worker(struct work_struct +@@ -1088,6 +1103,11 @@ static void gc_worker(struct work_struct tmp = nf_ct_tuplehash_to_ctrack(h); scanned++; diff --git a/target/linux/generic/backport-4.14/370-netfilter-nf_flow_table-fix-offloaded-connection-tim.patch b/target/linux/generic/backport-4.14/370-netfilter-nf_flow_table-fix-offloaded-connection-tim.patch index d82854908f..230c90f7c5 100644 --- a/target/linux/generic/backport-4.14/370-netfilter-nf_flow_table-fix-offloaded-connection-tim.patch +++ b/target/linux/generic/backport-4.14/370-netfilter-nf_flow_table-fix-offloaded-connection-tim.patch @@ -21,7 +21,7 @@ Signed-off-by: Felix Fietkau --- a/net/netfilter/nf_conntrack_core.c +++ b/net/netfilter/nf_conntrack_core.c -@@ -1054,18 +1054,6 @@ static bool gc_worker_can_early_drop(con +@@ -1055,18 +1055,6 @@ static bool gc_worker_can_early_drop(con return false; } @@ -40,7 +40,7 @@ Signed-off-by: Felix Fietkau static void gc_worker(struct work_struct *work) { unsigned int min_interval = max(HZ / GC_MAX_BUCKETS_DIV, 1u); -@@ -1102,10 +1090,8 @@ static void gc_worker(struct work_struct +@@ -1103,10 +1091,8 @@ static void gc_worker(struct work_struct tmp = nf_ct_tuplehash_to_ctrack(h); scanned++; diff --git a/target/linux/generic/backport-4.14/605-0002-tcp-avoid-min-R-bloat-by-skipping-R-from-delayed-K-in.patch b/target/linux/generic/backport-4.14/605-0002-tcp-avoid-min-RTT-bloat-by-skipping-RTT-from-delayed-ACK-.patch similarity index 100% rename from target/linux/generic/backport-4.14/605-0002-tcp-avoid-min-R-bloat-by-skipping-R-from-delayed-K-in.patch rename to target/linux/generic/backport-4.14/605-0002-tcp-avoid-min-RTT-bloat-by-skipping-RTT-from-delayed-ACK-.patch diff --git a/target/linux/generic/backport-4.14/605-0008-tcp_bbr-in-restart-from-idle,-see-if-we-should-exit.patch b/target/linux/generic/backport-4.14/605-0008-tcp_bbr-in-restart-from-idle-see-if-we-should-exit.patch similarity index 100% rename from target/linux/generic/backport-4.14/605-0008-tcp_bbr-in-restart-from-idle,-see-if-we-should-exit.patch rename to target/linux/generic/backport-4.14/605-0008-tcp_bbr-in-restart-from-idle-see-if-we-should-exit.patch diff --git a/target/linux/generic/backport-4.14/605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked==0.patch b/target/linux/generic/backport-4.14/605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked-0.patch similarity index 100% rename from target/linux/generic/backport-4.14/605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked==0.patch rename to target/linux/generic/backport-4.14/605-0009-tcp_bbr-apply-PROBE_RTT-cwnd-cap-even-if-acked-0.patch diff --git a/target/linux/generic/backport-4.19/370-netfilter-nf_flow_table-fix-offloaded-connection-tim.patch b/target/linux/generic/backport-4.19/370-netfilter-nf_flow_table-fix-offloaded-connection-tim.patch index 7c10f6f189..5c83457be1 100644 --- a/target/linux/generic/backport-4.19/370-netfilter-nf_flow_table-fix-offloaded-connection-tim.patch +++ b/target/linux/generic/backport-4.19/370-netfilter-nf_flow_table-fix-offloaded-connection-tim.patch @@ -21,7 +21,7 @@ Signed-off-by: Felix Fietkau --- a/net/netfilter/nf_conntrack_core.c +++ b/net/netfilter/nf_conntrack_core.c -@@ -1178,18 +1178,6 @@ static bool gc_worker_can_early_drop(con +@@ -1179,18 +1179,6 @@ static bool gc_worker_can_early_drop(con return false; } @@ -40,7 +40,7 @@ Signed-off-by: Felix Fietkau static void gc_worker(struct work_struct *work) { unsigned int min_interval = max(HZ / GC_MAX_BUCKETS_DIV, 1u); -@@ -1226,10 +1214,8 @@ static void gc_worker(struct work_struct +@@ -1227,10 +1215,8 @@ static void gc_worker(struct work_struct tmp = nf_ct_tuplehash_to_ctrack(h); scanned++; diff --git a/target/linux/generic/hack-4.14/207-disable-modorder.patch b/target/linux/generic/hack-4.14/207-disable-modorder.patch index 2b06be7b1d..8ac07d2377 100644 --- a/target/linux/generic/hack-4.14/207-disable-modorder.patch +++ b/target/linux/generic/hack-4.14/207-disable-modorder.patch @@ -15,7 +15,7 @@ Signed-off-by: Felix Fietkau --- a/Makefile +++ b/Makefile -@@ -1254,7 +1254,6 @@ endif +@@ -1261,7 +1261,6 @@ endif PHONY += modules modules: $(vmlinux-dirs) $(if $(KBUILD_BUILTIN),vmlinux) modules.builtin @@ -23,7 +23,7 @@ Signed-off-by: Felix Fietkau @$(kecho) ' Building modules, stage 2.'; $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost -@@ -1283,7 +1282,6 @@ _modinst_: +@@ -1290,7 +1289,6 @@ _modinst_: rm -f $(MODLIB)/build ; \ ln -s $(CURDIR) $(MODLIB)/build ; \ fi diff --git a/target/linux/generic/hack-4.14/220-gc_sections.patch b/target/linux/generic/hack-4.14/220-gc_sections.patch index fbf49aba90..7f5072c071 100644 --- a/target/linux/generic/hack-4.14/220-gc_sections.patch +++ b/target/linux/generic/hack-4.14/220-gc_sections.patch @@ -33,7 +33,7 @@ Signed-off-by: Gabor Juhos # Read KERNELRELEASE from include/config/kernel.release (if it exists) KERNELRELEASE = $(shell cat include/config/kernel.release 2> /dev/null) KERNELVERSION = $(VERSION)$(if $(PATCHLEVEL),.$(PATCHLEVEL)$(if $(SUBLEVEL),.$(SUBLEVEL)))$(EXTRAVERSION) -@@ -779,11 +784,6 @@ ifdef CONFIG_DEBUG_SECTION_MISMATCH +@@ -786,11 +791,6 @@ ifdef CONFIG_DEBUG_SECTION_MISMATCH KBUILD_CFLAGS += $(call cc-option, -fno-inline-functions-called-once) endif diff --git a/target/linux/generic/hack-4.14/221-module_exports.patch b/target/linux/generic/hack-4.14/221-module_exports.patch index 59a6528dd3..6cbe617d78 100644 --- a/target/linux/generic/hack-4.14/221-module_exports.patch +++ b/target/linux/generic/hack-4.14/221-module_exports.patch @@ -90,7 +90,7 @@ Signed-off-by: Felix Fietkau __used \ --- a/scripts/Makefile.build +++ b/scripts/Makefile.build -@@ -432,7 +432,7 @@ targets += $(extra-y) $(MAKECMDGOALS) $( +@@ -435,7 +435,7 @@ targets += $(extra-y) $(MAKECMDGOALS) $( # Linker scripts preprocessor (.lds.S -> .lds) # --------------------------------------------------------------------------- quiet_cmd_cpp_lds_S = LDS $@ diff --git a/target/linux/generic/hack-4.14/930-crashlog.patch b/target/linux/generic/hack-4.14/930-crashlog.patch index 3100d1fc08..397046ad62 100644 --- a/target/linux/generic/hack-4.14/930-crashlog.patch +++ b/target/linux/generic/hack-4.14/930-crashlog.patch @@ -318,7 +318,7 @@ Signed-off-by: Felix Fietkau #include #include -@@ -483,6 +484,8 @@ static void __init_memblock memblock_ins +@@ -447,6 +448,8 @@ static void __init_memblock memblock_ins memblock_set_region_node(rgn, nid); type->cnt++; type->total_size += size; @@ -327,7 +327,7 @@ Signed-off-by: Felix Fietkau } /** -@@ -522,6 +525,8 @@ int __init_memblock memblock_add_range(s +@@ -486,6 +489,8 @@ int __init_memblock memblock_add_range(s type->regions[0].flags = flags; memblock_set_region_node(&type->regions[0], nid); type->total_size = size; diff --git a/target/linux/generic/hack-4.14/952-net-conntrack-events-support-multiple-registrant.patch b/target/linux/generic/hack-4.14/952-net-conntrack-events-support-multiple-registrant.patch index ed075dc2cf..a84cfdf802 100644 --- a/target/linux/generic/hack-4.14/952-net-conntrack-events-support-multiple-registrant.patch +++ b/target/linux/generic/hack-4.14/952-net-conntrack-events-support-multiple-registrant.patch @@ -98,7 +98,7 @@ depends on NETFILTER_ADVANCED --- a/net/netfilter/nf_conntrack_core.c +++ b/net/netfilter/nf_conntrack_core.c -@@ -2249,6 +2249,10 @@ int nf_conntrack_init_net(struct net *ne +@@ -2250,6 +2250,10 @@ int nf_conntrack_init_net(struct net *ne ret = nf_conntrack_proto_pernet_init(net); if (ret < 0) goto err_proto; diff --git a/target/linux/generic/hack-4.19/952-net-conntrack-events-support-multiple-registrant.patch b/target/linux/generic/hack-4.19/952-net-conntrack-events-support-multiple-registrant.patch index 01b2efc258..266624bdc3 100644 --- a/target/linux/generic/hack-4.19/952-net-conntrack-events-support-multiple-registrant.patch +++ b/target/linux/generic/hack-4.19/952-net-conntrack-events-support-multiple-registrant.patch @@ -98,7 +98,7 @@ depends on NETFILTER_ADVANCED --- a/net/netfilter/nf_conntrack_core.c +++ b/net/netfilter/nf_conntrack_core.c -@@ -2447,6 +2447,10 @@ int nf_conntrack_init_net(struct net *ne +@@ -2448,6 +2448,10 @@ int nf_conntrack_init_net(struct net *ne ret = nf_conntrack_proto_pernet_init(net); if (ret < 0) goto err_proto; diff --git a/target/linux/generic/hack-4.9/207-disable-modorder.patch b/target/linux/generic/hack-4.9/207-disable-modorder.patch index cef8a5af3d..680985a1d3 100644 --- a/target/linux/generic/hack-4.9/207-disable-modorder.patch +++ b/target/linux/generic/hack-4.9/207-disable-modorder.patch @@ -15,7 +15,7 @@ Signed-off-by: Felix Fietkau --- a/Makefile +++ b/Makefile -@@ -1242,7 +1242,6 @@ endif +@@ -1249,7 +1249,6 @@ endif PHONY += modules modules: $(vmlinux-dirs) $(if $(KBUILD_BUILTIN),vmlinux) modules.builtin @@ -23,7 +23,7 @@ Signed-off-by: Felix Fietkau @$(kecho) ' Building modules, stage 2.'; $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.modpost $(Q)$(MAKE) -f $(srctree)/scripts/Makefile.fwinst obj=firmware __fw_modbuild -@@ -1272,7 +1271,6 @@ _modinst_: +@@ -1279,7 +1278,6 @@ _modinst_: rm -f $(MODLIB)/build ; \ ln -s $(CURDIR) $(MODLIB)/build ; \ fi diff --git a/target/linux/generic/hack-4.9/221-module_exports.patch b/target/linux/generic/hack-4.9/221-module_exports.patch index bda3b83f88..3fb5551973 100644 --- a/target/linux/generic/hack-4.9/221-module_exports.patch +++ b/target/linux/generic/hack-4.9/221-module_exports.patch @@ -90,7 +90,7 @@ Signed-off-by: Felix Fietkau __used \ --- a/scripts/Makefile.build +++ b/scripts/Makefile.build -@@ -409,7 +409,7 @@ targets += $(extra-y) $(MAKECMDGOALS) $( +@@ -412,7 +412,7 @@ targets += $(extra-y) $(MAKECMDGOALS) $( # Linker scripts preprocessor (.lds.S -> .lds) # --------------------------------------------------------------------------- quiet_cmd_cpp_lds_S = LDS $@ diff --git a/target/linux/generic/hack-4.9/930-crashlog.patch b/target/linux/generic/hack-4.9/930-crashlog.patch index f864073493..6522ba31d1 100644 --- a/target/linux/generic/hack-4.9/930-crashlog.patch +++ b/target/linux/generic/hack-4.9/930-crashlog.patch @@ -318,7 +318,7 @@ Signed-off-by: Felix Fietkau #include #include -@@ -495,6 +496,8 @@ static void __init_memblock memblock_ins +@@ -459,6 +460,8 @@ static void __init_memblock memblock_ins memblock_set_region_node(rgn, nid); type->cnt++; type->total_size += size; @@ -327,7 +327,7 @@ Signed-off-by: Felix Fietkau } /** -@@ -534,6 +537,8 @@ int __init_memblock memblock_add_range(s +@@ -498,6 +501,8 @@ int __init_memblock memblock_add_range(s type->regions[0].flags = flags; memblock_set_region_node(&type->regions[0], nid); type->total_size = size; diff --git a/target/linux/generic/hack-4.9/952-net-conntrack-events-support-multiple-registrant.patch b/target/linux/generic/hack-4.9/952-net-conntrack-events-support-multiple-registrant.patch index 8d584c63d9..b3ba1cddec 100644 --- a/target/linux/generic/hack-4.9/952-net-conntrack-events-support-multiple-registrant.patch +++ b/target/linux/generic/hack-4.9/952-net-conntrack-events-support-multiple-registrant.patch @@ -115,7 +115,7 @@ Signed-off-by: Zhi Chen depends on NETFILTER_ADVANCED --- a/net/netfilter/nf_conntrack_core.c +++ b/net/netfilter/nf_conntrack_core.c -@@ -2077,6 +2077,10 @@ int nf_conntrack_init_net(struct net *ne +@@ -2078,6 +2078,10 @@ int nf_conntrack_init_net(struct net *ne ret = nf_conntrack_proto_pernet_init(net); if (ret < 0) goto err_proto; From b8786367a0f054eb3a4413563f417fefc0874441 Mon Sep 17 00:00:00 2001 From: Tianling Shen Date: Wed, 3 Mar 2021 12:33:40 +0800 Subject: [PATCH 6/8] r8125: bump PKG_VERSION Fixes: 400288d50f105a665992f17344325b5e10268d46 ("r8125: bump to 9.005.01") Signed-off-by: Tianling Shen --- package/lean/r8125/Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/package/lean/r8125/Makefile b/package/lean/r8125/Makefile index 7424e8af10..add8a25df8 100644 --- a/package/lean/r8125/Makefile +++ b/package/lean/r8125/Makefile @@ -7,8 +7,8 @@ include $(TOPDIR)/rules.mk include $(INCLUDE_DIR)/kernel.mk PKG_NAME:=r8125 -PKG_VERSION:=9.004.01 -PKG_RELEASE:=2 +PKG_VERSION:=9.005.01 +PKG_RELEASE:=1 PKG_BUILD_DIR:=$(KERNEL_BUILD_DIR)/$(PKG_NAME)-$(PKG_VERSION) From 357b8172774b817142bb4a029b68d7a303455cf0 Mon Sep 17 00:00:00 2001 From: Tianling Shen Date: Wed, 3 Mar 2021 14:13:38 +0800 Subject: [PATCH 7/8] baidupcs-web: rename patch dir Signed-off-by: Tianling Shen --- .../baidupcs-web/patches/001-add-missing-go-sum.patch | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename package/{ctcgfw => lean}/baidupcs-web/patches/001-add-missing-go-sum.patch (100%) diff --git a/package/ctcgfw/baidupcs-web/patches/001-add-missing-go-sum.patch b/package/lean/baidupcs-web/patches/001-add-missing-go-sum.patch similarity index 100% rename from package/ctcgfw/baidupcs-web/patches/001-add-missing-go-sum.patch rename to package/lean/baidupcs-web/patches/001-add-missing-go-sum.patch From 8dfc71dc03ade8a0b83341fd4c586ea875b363d9 Mon Sep 17 00:00:00 2001 From: AmadeusGhost <42570690+AmadeusGhost@users.noreply.github.com> Date: Wed, 3 Mar 2021 11:20:08 +0800 Subject: [PATCH 8/8] tinymembench: add package --- package/ctcgfw/tinymembench/Makefile | 37 ++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 package/ctcgfw/tinymembench/Makefile diff --git a/package/ctcgfw/tinymembench/Makefile b/package/ctcgfw/tinymembench/Makefile new file mode 100644 index 0000000000..8d3a07c273 --- /dev/null +++ b/package/ctcgfw/tinymembench/Makefile @@ -0,0 +1,37 @@ +# +# Copyright (C) 2021 ImmortalWrt +# +# This is free software, licensed under the GNU General Public License v3. +# See /LICENSE for more information. +# + +include $(TOPDIR)/rules.mk + +PKG_NAME:=tinymembench +PKG_VERSION:=0.4 +PKG_RELEASE:=1 + +PKG_SOURCE_PROTO:=git +PKG_SOURCE_URL:=https://github.com/ssvb/tinymembench.git +PKG_SOURCE_VERSION:=a2cf6d7e382e3aea1eb39173174d9fa28cad15f3 +PKG_MIRROR_HASH:=b5b69e3d0c19e5a55bfebe386e29196c751612e30bd5aefc2ee1df11c18e0300 + +include $(INCLUDE_DIR)/package.mk + +define Package/tinymembench + SECTION:=utils + CATEGORY:=Utilities + URL:=https://github.com/ssvb/tinymembench + TITLE:=Simple benchmark for memory +endef + +define Package/tinymembench/description + Simple benchmark for memory throughput and latency. +endef + +define Package/tinymembench/install + $(INSTALL_DIR) $(1)/usr/bin + $(INSTALL_BIN) $(PKG_BUILD_DIR)/tinymembench $(1)/usr/bin/ +endef + +$(eval $(call BuildPackage,tinymembench))