diff options
Diffstat (limited to 'net')
-rw-r--r-- | net/dccp/ccids/ccid3.c | 149 | ||||
-rw-r--r-- | net/dccp/ccids/ccid3.h | 5 | ||||
-rw-r--r-- | net/dccp/ccids/lib/loss_interval.c | 34 | ||||
-rw-r--r-- | net/dccp/ccids/lib/loss_interval.h | 7 | ||||
-rw-r--r-- | net/dccp/ccids/lib/packet_history.c | 141 | ||||
-rw-r--r-- | net/dccp/ccids/lib/packet_history.h | 11 |
6 files changed, 154 insertions, 193 deletions
diff --git a/net/dccp/ccids/ccid3.c b/net/dccp/ccids/ccid3.c index 0f85970ee6d1..090bc39e8199 100644 --- a/net/dccp/ccids/ccid3.c +++ b/net/dccp/ccids/ccid3.c | |||
@@ -342,6 +342,8 @@ static int ccid3_hc_tx_send_packet(struct sock *sk, | |||
342 | new_packet->dccphtx_ccval = | 342 | new_packet->dccphtx_ccval = |
343 | DCCP_SKB_CB(skb)->dccpd_ccval = | 343 | DCCP_SKB_CB(skb)->dccpd_ccval = |
344 | hctx->ccid3hctx_last_win_count; | 344 | hctx->ccid3hctx_last_win_count; |
345 | timeval_add_usecs(&hctx->ccid3hctx_t_nom, | ||
346 | hctx->ccid3hctx_t_ipi); | ||
345 | } | 347 | } |
346 | out: | 348 | out: |
347 | return rc; | 349 | return rc; |
@@ -413,7 +415,8 @@ static void ccid3_hc_tx_packet_sent(struct sock *sk, int more, int len) | |||
413 | case TFRC_SSTATE_NO_FBACK: | 415 | case TFRC_SSTATE_NO_FBACK: |
414 | case TFRC_SSTATE_FBACK: | 416 | case TFRC_SSTATE_FBACK: |
415 | if (len > 0) { | 417 | if (len > 0) { |
416 | hctx->ccid3hctx_t_nom = now; | 418 | timeval_sub_usecs(&hctx->ccid3hctx_t_nom, |
419 | hctx->ccid3hctx_t_ipi); | ||
417 | ccid3_calc_new_t_ipi(hctx); | 420 | ccid3_calc_new_t_ipi(hctx); |
418 | ccid3_calc_new_delta(hctx); | 421 | ccid3_calc_new_delta(hctx); |
419 | timeval_add_usecs(&hctx->ccid3hctx_t_nom, | 422 | timeval_add_usecs(&hctx->ccid3hctx_t_nom, |
@@ -757,8 +760,7 @@ static void ccid3_hc_rx_send_feedback(struct sock *sk) | |||
757 | } | 760 | } |
758 | 761 | ||
759 | hcrx->ccid3hcrx_tstamp_last_feedback = now; | 762 | hcrx->ccid3hcrx_tstamp_last_feedback = now; |
760 | hcrx->ccid3hcrx_last_counter = packet->dccphrx_ccval; | 763 | hcrx->ccid3hcrx_ccval_last_counter = packet->dccphrx_ccval; |
761 | hcrx->ccid3hcrx_seqno_last_counter = packet->dccphrx_seqno; | ||
762 | hcrx->ccid3hcrx_bytes_recv = 0; | 764 | hcrx->ccid3hcrx_bytes_recv = 0; |
763 | 765 | ||
764 | /* Convert to multiples of 10us */ | 766 | /* Convert to multiples of 10us */ |
@@ -782,7 +784,7 @@ static int ccid3_hc_rx_insert_options(struct sock *sk, struct sk_buff *skb) | |||
782 | if (!(sk->sk_state == DCCP_OPEN || sk->sk_state == DCCP_PARTOPEN)) | 784 | if (!(sk->sk_state == DCCP_OPEN || sk->sk_state == DCCP_PARTOPEN)) |
783 | return 0; | 785 | return 0; |
784 | 786 | ||
785 | DCCP_SKB_CB(skb)->dccpd_ccval = hcrx->ccid3hcrx_last_counter; | 787 | DCCP_SKB_CB(skb)->dccpd_ccval = hcrx->ccid3hcrx_ccval_last_counter; |
786 | 788 | ||
787 | if (dccp_packet_without_ack(skb)) | 789 | if (dccp_packet_without_ack(skb)) |
788 | return 0; | 790 | return 0; |
@@ -854,6 +856,11 @@ static u32 ccid3_hc_rx_calc_first_li(struct sock *sk) | |||
854 | interval = 1; | 856 | interval = 1; |
855 | } | 857 | } |
856 | found: | 858 | found: |
859 | if (!tail) { | ||
860 | LIMIT_NETDEBUG(KERN_WARNING "%s: tail is null\n", | ||
861 | __FUNCTION__); | ||
862 | return ~0; | ||
863 | } | ||
857 | rtt = timeval_delta(&tstamp, &tail->dccphrx_tstamp) * 4 / interval; | 864 | rtt = timeval_delta(&tstamp, &tail->dccphrx_tstamp) * 4 / interval; |
858 | ccid3_pr_debug("%s, sk=%p, approximated RTT to %uus\n", | 865 | ccid3_pr_debug("%s, sk=%p, approximated RTT to %uus\n", |
859 | dccp_role(sk), sk, rtt); | 866 | dccp_role(sk), sk, rtt); |
@@ -864,9 +871,20 @@ found: | |||
864 | delta = timeval_delta(&tstamp, &hcrx->ccid3hcrx_tstamp_last_feedback); | 871 | delta = timeval_delta(&tstamp, &hcrx->ccid3hcrx_tstamp_last_feedback); |
865 | x_recv = usecs_div(hcrx->ccid3hcrx_bytes_recv, delta); | 872 | x_recv = usecs_div(hcrx->ccid3hcrx_bytes_recv, delta); |
866 | 873 | ||
874 | if (x_recv == 0) | ||
875 | x_recv = hcrx->ccid3hcrx_x_recv; | ||
876 | |||
867 | tmp1 = (u64)x_recv * (u64)rtt; | 877 | tmp1 = (u64)x_recv * (u64)rtt; |
868 | do_div(tmp1,10000000); | 878 | do_div(tmp1,10000000); |
869 | tmp2 = (u32)tmp1; | 879 | tmp2 = (u32)tmp1; |
880 | |||
881 | if (!tmp2) { | ||
882 | LIMIT_NETDEBUG(KERN_WARNING "tmp2 = 0 " | ||
883 | "%s: x_recv = %u, rtt =%u\n", | ||
884 | __FUNCTION__, x_recv, rtt); | ||
885 | return ~0; | ||
886 | } | ||
887 | |||
870 | fval = (hcrx->ccid3hcrx_s * 100000) / tmp2; | 888 | fval = (hcrx->ccid3hcrx_s * 100000) / tmp2; |
871 | /* do not alter order above or you will get overflow on 32 bit */ | 889 | /* do not alter order above or you will get overflow on 32 bit */ |
872 | p = tfrc_calc_x_reverse_lookup(fval); | 890 | p = tfrc_calc_x_reverse_lookup(fval); |
@@ -882,31 +900,101 @@ found: | |||
882 | static void ccid3_hc_rx_update_li(struct sock *sk, u64 seq_loss, u8 win_loss) | 900 | static void ccid3_hc_rx_update_li(struct sock *sk, u64 seq_loss, u8 win_loss) |
883 | { | 901 | { |
884 | struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); | 902 | struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); |
903 | struct dccp_li_hist_entry *next, *head; | ||
904 | u64 seq_temp; | ||
885 | 905 | ||
886 | if (seq_loss != DCCP_MAX_SEQNO + 1 && | 906 | if (list_empty(&hcrx->ccid3hcrx_li_hist)) { |
887 | list_empty(&hcrx->ccid3hcrx_li_hist)) { | 907 | if (!dccp_li_hist_interval_new(ccid3_li_hist, |
888 | struct dccp_li_hist_entry *li_tail; | 908 | &hcrx->ccid3hcrx_li_hist, seq_loss, win_loss)) |
909 | return; | ||
889 | 910 | ||
890 | li_tail = dccp_li_hist_interval_new(ccid3_li_hist, | 911 | next = (struct dccp_li_hist_entry *) |
891 | &hcrx->ccid3hcrx_li_hist, | 912 | hcrx->ccid3hcrx_li_hist.next; |
892 | seq_loss, win_loss); | 913 | next->dccplih_interval = ccid3_hc_rx_calc_first_li(sk); |
893 | if (li_tail == NULL) | 914 | } else { |
915 | struct dccp_li_hist_entry *entry; | ||
916 | struct list_head *tail; | ||
917 | |||
918 | head = (struct dccp_li_hist_entry *) | ||
919 | hcrx->ccid3hcrx_li_hist.next; | ||
920 | /* FIXME win count check removed as was wrong */ | ||
921 | /* should make this check with receive history */ | ||
922 | /* and compare there as per section 10.2 of RFC4342 */ | ||
923 | |||
924 | /* new loss event detected */ | ||
925 | /* calculate last interval length */ | ||
926 | seq_temp = dccp_delta_seqno(head->dccplih_seqno, seq_loss); | ||
927 | entry = dccp_li_hist_entry_new(ccid3_li_hist, SLAB_ATOMIC); | ||
928 | |||
929 | if (entry == NULL) { | ||
930 | printk(KERN_CRIT "%s: out of memory\n",__FUNCTION__); | ||
931 | dump_stack(); | ||
894 | return; | 932 | return; |
895 | li_tail->dccplih_interval = ccid3_hc_rx_calc_first_li(sk); | 933 | } |
896 | } else | 934 | |
897 | LIMIT_NETDEBUG(KERN_WARNING "%s: FIXME: find end of " | 935 | list_add(&entry->dccplih_node, &hcrx->ccid3hcrx_li_hist); |
898 | "interval\n", __FUNCTION__); | 936 | |
937 | tail = hcrx->ccid3hcrx_li_hist.prev; | ||
938 | list_del(tail); | ||
939 | kmem_cache_free(ccid3_li_hist->dccplih_slab, tail); | ||
940 | |||
941 | /* Create the newest interval */ | ||
942 | entry->dccplih_seqno = seq_loss; | ||
943 | entry->dccplih_interval = seq_temp; | ||
944 | entry->dccplih_win_count = win_loss; | ||
945 | } | ||
899 | } | 946 | } |
900 | 947 | ||
901 | static void ccid3_hc_rx_detect_loss(struct sock *sk) | 948 | static int ccid3_hc_rx_detect_loss(struct sock *sk, |
949 | struct dccp_rx_hist_entry *packet) | ||
902 | { | 950 | { |
903 | struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); | 951 | struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); |
904 | u8 win_loss; | 952 | struct dccp_rx_hist_entry *rx_hist = dccp_rx_hist_head(&hcrx->ccid3hcrx_hist); |
905 | const u64 seq_loss = dccp_rx_hist_detect_loss(&hcrx->ccid3hcrx_hist, | 953 | u64 seqno = packet->dccphrx_seqno; |
906 | &hcrx->ccid3hcrx_li_hist, | 954 | u64 tmp_seqno; |
907 | &win_loss); | 955 | int loss = 0; |
956 | u8 ccval; | ||
957 | |||
958 | |||
959 | tmp_seqno = hcrx->ccid3hcrx_seqno_nonloss; | ||
960 | |||
961 | if (!rx_hist || | ||
962 | follows48(packet->dccphrx_seqno, hcrx->ccid3hcrx_seqno_nonloss)) { | ||
963 | hcrx->ccid3hcrx_seqno_nonloss = seqno; | ||
964 | hcrx->ccid3hcrx_ccval_nonloss = packet->dccphrx_ccval; | ||
965 | goto detect_out; | ||
966 | } | ||
967 | |||
908 | 968 | ||
909 | ccid3_hc_rx_update_li(sk, seq_loss, win_loss); | 969 | while (dccp_delta_seqno(hcrx->ccid3hcrx_seqno_nonloss, seqno) |
970 | > TFRC_RECV_NUM_LATE_LOSS) { | ||
971 | loss = 1; | ||
972 | ccid3_hc_rx_update_li(sk, hcrx->ccid3hcrx_seqno_nonloss, | ||
973 | hcrx->ccid3hcrx_ccval_nonloss); | ||
974 | tmp_seqno = hcrx->ccid3hcrx_seqno_nonloss; | ||
975 | dccp_inc_seqno(&tmp_seqno); | ||
976 | hcrx->ccid3hcrx_seqno_nonloss = tmp_seqno; | ||
977 | dccp_inc_seqno(&tmp_seqno); | ||
978 | while (dccp_rx_hist_find_entry(&hcrx->ccid3hcrx_hist, | ||
979 | tmp_seqno, &ccval)) { | ||
980 | hcrx->ccid3hcrx_seqno_nonloss = tmp_seqno; | ||
981 | hcrx->ccid3hcrx_ccval_nonloss = ccval; | ||
982 | dccp_inc_seqno(&tmp_seqno); | ||
983 | } | ||
984 | } | ||
985 | |||
986 | /* FIXME - this code could be simplified with above while */ | ||
987 | /* but works at moment */ | ||
988 | if (follows48(packet->dccphrx_seqno, hcrx->ccid3hcrx_seqno_nonloss)) { | ||
989 | hcrx->ccid3hcrx_seqno_nonloss = seqno; | ||
990 | hcrx->ccid3hcrx_ccval_nonloss = packet->dccphrx_ccval; | ||
991 | } | ||
992 | |||
993 | detect_out: | ||
994 | dccp_rx_hist_add_packet(ccid3_rx_hist, &hcrx->ccid3hcrx_hist, | ||
995 | &hcrx->ccid3hcrx_li_hist, packet, | ||
996 | hcrx->ccid3hcrx_seqno_nonloss); | ||
997 | return loss; | ||
910 | } | 998 | } |
911 | 999 | ||
912 | static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) | 1000 | static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) |
@@ -916,8 +1004,8 @@ static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) | |||
916 | struct dccp_rx_hist_entry *packet; | 1004 | struct dccp_rx_hist_entry *packet; |
917 | struct timeval now; | 1005 | struct timeval now; |
918 | u8 win_count; | 1006 | u8 win_count; |
919 | u32 p_prev, r_sample, t_elapsed; | 1007 | u32 p_prev, rtt_prev, r_sample, t_elapsed; |
920 | int ins; | 1008 | int loss; |
921 | 1009 | ||
922 | BUG_ON(hcrx == NULL || | 1010 | BUG_ON(hcrx == NULL || |
923 | !(hcrx->ccid3hcrx_state == TFRC_RSTATE_NO_DATA || | 1011 | !(hcrx->ccid3hcrx_state == TFRC_RSTATE_NO_DATA || |
@@ -932,7 +1020,7 @@ static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) | |||
932 | case DCCP_PKT_DATAACK: | 1020 | case DCCP_PKT_DATAACK: |
933 | if (opt_recv->dccpor_timestamp_echo == 0) | 1021 | if (opt_recv->dccpor_timestamp_echo == 0) |
934 | break; | 1022 | break; |
935 | p_prev = hcrx->ccid3hcrx_rtt; | 1023 | rtt_prev = hcrx->ccid3hcrx_rtt; |
936 | dccp_timestamp(sk, &now); | 1024 | dccp_timestamp(sk, &now); |
937 | timeval_sub_usecs(&now, opt_recv->dccpor_timestamp_echo * 10); | 1025 | timeval_sub_usecs(&now, opt_recv->dccpor_timestamp_echo * 10); |
938 | r_sample = timeval_usecs(&now); | 1026 | r_sample = timeval_usecs(&now); |
@@ -951,8 +1039,8 @@ static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) | |||
951 | hcrx->ccid3hcrx_rtt = (hcrx->ccid3hcrx_rtt * 9) / 10 + | 1039 | hcrx->ccid3hcrx_rtt = (hcrx->ccid3hcrx_rtt * 9) / 10 + |
952 | r_sample / 10; | 1040 | r_sample / 10; |
953 | 1041 | ||
954 | if (p_prev != hcrx->ccid3hcrx_rtt) | 1042 | if (rtt_prev != hcrx->ccid3hcrx_rtt) |
955 | ccid3_pr_debug("%s, New RTT=%luus, elapsed time=%u\n", | 1043 | ccid3_pr_debug("%s, New RTT=%uus, elapsed time=%u\n", |
956 | dccp_role(sk), hcrx->ccid3hcrx_rtt, | 1044 | dccp_role(sk), hcrx->ccid3hcrx_rtt, |
957 | opt_recv->dccpor_elapsed_time); | 1045 | opt_recv->dccpor_elapsed_time); |
958 | break; | 1046 | break; |
@@ -973,8 +1061,7 @@ static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) | |||
973 | 1061 | ||
974 | win_count = packet->dccphrx_ccval; | 1062 | win_count = packet->dccphrx_ccval; |
975 | 1063 | ||
976 | ins = dccp_rx_hist_add_packet(ccid3_rx_hist, &hcrx->ccid3hcrx_hist, | 1064 | loss = ccid3_hc_rx_detect_loss(sk, packet); |
977 | &hcrx->ccid3hcrx_li_hist, packet); | ||
978 | 1065 | ||
979 | if (DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_ACK) | 1066 | if (DCCP_SKB_CB(skb)->dccpd_type == DCCP_PKT_ACK) |
980 | return; | 1067 | return; |
@@ -991,7 +1078,7 @@ static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) | |||
991 | case TFRC_RSTATE_DATA: | 1078 | case TFRC_RSTATE_DATA: |
992 | hcrx->ccid3hcrx_bytes_recv += skb->len - | 1079 | hcrx->ccid3hcrx_bytes_recv += skb->len - |
993 | dccp_hdr(skb)->dccph_doff * 4; | 1080 | dccp_hdr(skb)->dccph_doff * 4; |
994 | if (ins != 0) | 1081 | if (loss) |
995 | break; | 1082 | break; |
996 | 1083 | ||
997 | dccp_timestamp(sk, &now); | 1084 | dccp_timestamp(sk, &now); |
@@ -1012,7 +1099,6 @@ static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) | |||
1012 | ccid3_pr_debug("%s, sk=%p(%s), data loss! Reacting...\n", | 1099 | ccid3_pr_debug("%s, sk=%p(%s), data loss! Reacting...\n", |
1013 | dccp_role(sk), sk, dccp_state_name(sk->sk_state)); | 1100 | dccp_role(sk), sk, dccp_state_name(sk->sk_state)); |
1014 | 1101 | ||
1015 | ccid3_hc_rx_detect_loss(sk); | ||
1016 | p_prev = hcrx->ccid3hcrx_p; | 1102 | p_prev = hcrx->ccid3hcrx_p; |
1017 | 1103 | ||
1018 | /* Calculate loss event rate */ | 1104 | /* Calculate loss event rate */ |
@@ -1022,6 +1108,9 @@ static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb) | |||
1022 | /* Scaling up by 1000000 as fixed decimal */ | 1108 | /* Scaling up by 1000000 as fixed decimal */ |
1023 | if (i_mean != 0) | 1109 | if (i_mean != 0) |
1024 | hcrx->ccid3hcrx_p = 1000000 / i_mean; | 1110 | hcrx->ccid3hcrx_p = 1000000 / i_mean; |
1111 | } else { | ||
1112 | printk(KERN_CRIT "%s: empty loss hist\n",__FUNCTION__); | ||
1113 | dump_stack(); | ||
1025 | } | 1114 | } |
1026 | 1115 | ||
1027 | if (hcrx->ccid3hcrx_p > p_prev) { | 1116 | if (hcrx->ccid3hcrx_p > p_prev) { |
diff --git a/net/dccp/ccids/ccid3.h b/net/dccp/ccids/ccid3.h index 22cb9f80a09d..0a2cb7536d26 100644 --- a/net/dccp/ccids/ccid3.h +++ b/net/dccp/ccids/ccid3.h | |||
@@ -120,9 +120,10 @@ struct ccid3_hc_rx_sock { | |||
120 | #define ccid3hcrx_x_recv ccid3hcrx_tfrc.tfrcrx_x_recv | 120 | #define ccid3hcrx_x_recv ccid3hcrx_tfrc.tfrcrx_x_recv |
121 | #define ccid3hcrx_rtt ccid3hcrx_tfrc.tfrcrx_rtt | 121 | #define ccid3hcrx_rtt ccid3hcrx_tfrc.tfrcrx_rtt |
122 | #define ccid3hcrx_p ccid3hcrx_tfrc.tfrcrx_p | 122 | #define ccid3hcrx_p ccid3hcrx_tfrc.tfrcrx_p |
123 | u64 ccid3hcrx_seqno_last_counter:48, | 123 | u64 ccid3hcrx_seqno_nonloss:48, |
124 | ccid3hcrx_ccval_nonloss:4, | ||
124 | ccid3hcrx_state:8, | 125 | ccid3hcrx_state:8, |
125 | ccid3hcrx_last_counter:4; | 126 | ccid3hcrx_ccval_last_counter:4; |
126 | u32 ccid3hcrx_bytes_recv; | 127 | u32 ccid3hcrx_bytes_recv; |
127 | struct timeval ccid3hcrx_tstamp_last_feedback; | 128 | struct timeval ccid3hcrx_tstamp_last_feedback; |
128 | struct timeval ccid3hcrx_tstamp_last_ack; | 129 | struct timeval ccid3hcrx_tstamp_last_ack; |
diff --git a/net/dccp/ccids/lib/loss_interval.c b/net/dccp/ccids/lib/loss_interval.c index b93d9fc98cb8..906c81ab9d4f 100644 --- a/net/dccp/ccids/lib/loss_interval.c +++ b/net/dccp/ccids/lib/loss_interval.c | |||
@@ -12,6 +12,7 @@ | |||
12 | */ | 12 | */ |
13 | 13 | ||
14 | #include <linux/module.h> | 14 | #include <linux/module.h> |
15 | #include <net/sock.h> | ||
15 | 16 | ||
16 | #include "loss_interval.h" | 17 | #include "loss_interval.h" |
17 | 18 | ||
@@ -90,13 +91,13 @@ u32 dccp_li_hist_calc_i_mean(struct list_head *list) | |||
90 | u32 w_tot = 0; | 91 | u32 w_tot = 0; |
91 | 92 | ||
92 | list_for_each_entry_safe(li_entry, li_next, list, dccplih_node) { | 93 | list_for_each_entry_safe(li_entry, li_next, list, dccplih_node) { |
93 | if (i < DCCP_LI_HIST_IVAL_F_LENGTH) { | 94 | if (li_entry->dccplih_interval != ~0) { |
94 | i_tot0 += li_entry->dccplih_interval * dccp_li_hist_w[i]; | 95 | i_tot0 += li_entry->dccplih_interval * dccp_li_hist_w[i]; |
95 | w_tot += dccp_li_hist_w[i]; | 96 | w_tot += dccp_li_hist_w[i]; |
97 | if (i != 0) | ||
98 | i_tot1 += li_entry->dccplih_interval * dccp_li_hist_w[i - 1]; | ||
96 | } | 99 | } |
97 | 100 | ||
98 | if (i != 0) | ||
99 | i_tot1 += li_entry->dccplih_interval * dccp_li_hist_w[i - 1]; | ||
100 | 101 | ||
101 | if (++i > DCCP_LI_HIST_IVAL_F_LENGTH) | 102 | if (++i > DCCP_LI_HIST_IVAL_F_LENGTH) |
102 | break; | 103 | break; |
@@ -107,37 +108,36 @@ u32 dccp_li_hist_calc_i_mean(struct list_head *list) | |||
107 | 108 | ||
108 | i_tot = max(i_tot0, i_tot1); | 109 | i_tot = max(i_tot0, i_tot1); |
109 | 110 | ||
110 | /* FIXME: Why do we do this? -Ian McDonald */ | 111 | if (!w_tot) { |
111 | if (i_tot * 4 < w_tot) | 112 | LIMIT_NETDEBUG(KERN_WARNING "%s: w_tot = 0\n", __FUNCTION__); |
112 | i_tot = w_tot * 4; | 113 | return 1; |
114 | } | ||
113 | 115 | ||
114 | return i_tot * 4 / w_tot; | 116 | return i_tot / w_tot; |
115 | } | 117 | } |
116 | 118 | ||
117 | EXPORT_SYMBOL_GPL(dccp_li_hist_calc_i_mean); | 119 | EXPORT_SYMBOL_GPL(dccp_li_hist_calc_i_mean); |
118 | 120 | ||
119 | struct dccp_li_hist_entry *dccp_li_hist_interval_new(struct dccp_li_hist *hist, | 121 | int dccp_li_hist_interval_new(struct dccp_li_hist *hist, |
120 | struct list_head *list, | 122 | struct list_head *list, const u64 seq_loss, const u8 win_loss) |
121 | const u64 seq_loss, | ||
122 | const u8 win_loss) | ||
123 | { | 123 | { |
124 | struct dccp_li_hist_entry *tail = NULL, *entry; | 124 | struct dccp_li_hist_entry *entry; |
125 | int i; | 125 | int i; |
126 | 126 | ||
127 | for (i = 0; i <= DCCP_LI_HIST_IVAL_F_LENGTH; ++i) { | 127 | for (i = 0; i < DCCP_LI_HIST_IVAL_F_LENGTH; i++) { |
128 | entry = dccp_li_hist_entry_new(hist, SLAB_ATOMIC); | 128 | entry = dccp_li_hist_entry_new(hist, SLAB_ATOMIC); |
129 | if (entry == NULL) { | 129 | if (entry == NULL) { |
130 | dccp_li_hist_purge(hist, list); | 130 | dccp_li_hist_purge(hist, list); |
131 | return NULL; | 131 | dump_stack(); |
132 | return 0; | ||
132 | } | 133 | } |
133 | if (tail == NULL) | 134 | entry->dccplih_interval = ~0; |
134 | tail = entry; | ||
135 | list_add(&entry->dccplih_node, list); | 135 | list_add(&entry->dccplih_node, list); |
136 | } | 136 | } |
137 | 137 | ||
138 | entry->dccplih_seqno = seq_loss; | 138 | entry->dccplih_seqno = seq_loss; |
139 | entry->dccplih_win_count = win_loss; | 139 | entry->dccplih_win_count = win_loss; |
140 | return tail; | 140 | return 1; |
141 | } | 141 | } |
142 | 142 | ||
143 | EXPORT_SYMBOL_GPL(dccp_li_hist_interval_new); | 143 | EXPORT_SYMBOL_GPL(dccp_li_hist_interval_new); |
diff --git a/net/dccp/ccids/lib/loss_interval.h b/net/dccp/ccids/lib/loss_interval.h index dcb370a53f57..0ae85f0340b2 100644 --- a/net/dccp/ccids/lib/loss_interval.h +++ b/net/dccp/ccids/lib/loss_interval.h | |||
@@ -52,9 +52,6 @@ extern void dccp_li_hist_purge(struct dccp_li_hist *hist, | |||
52 | 52 | ||
53 | extern u32 dccp_li_hist_calc_i_mean(struct list_head *list); | 53 | extern u32 dccp_li_hist_calc_i_mean(struct list_head *list); |
54 | 54 | ||
55 | extern struct dccp_li_hist_entry * | 55 | extern int dccp_li_hist_interval_new(struct dccp_li_hist *hist, |
56 | dccp_li_hist_interval_new(struct dccp_li_hist *hist, | 56 | struct list_head *list, const u64 seq_loss, const u8 win_loss); |
57 | struct list_head *list, | ||
58 | const u64 seq_loss, | ||
59 | const u8 win_loss); | ||
60 | #endif /* _DCCP_LI_HIST_ */ | 57 | #endif /* _DCCP_LI_HIST_ */ |
diff --git a/net/dccp/ccids/lib/packet_history.c b/net/dccp/ccids/lib/packet_history.c index 420c60f8604d..b876c9c81c65 100644 --- a/net/dccp/ccids/lib/packet_history.c +++ b/net/dccp/ccids/lib/packet_history.c | |||
@@ -112,64 +112,27 @@ struct dccp_rx_hist_entry * | |||
112 | 112 | ||
113 | EXPORT_SYMBOL_GPL(dccp_rx_hist_find_data_packet); | 113 | EXPORT_SYMBOL_GPL(dccp_rx_hist_find_data_packet); |
114 | 114 | ||
115 | int dccp_rx_hist_add_packet(struct dccp_rx_hist *hist, | 115 | void dccp_rx_hist_add_packet(struct dccp_rx_hist *hist, |
116 | struct list_head *rx_list, | 116 | struct list_head *rx_list, |
117 | struct list_head *li_list, | 117 | struct list_head *li_list, |
118 | struct dccp_rx_hist_entry *packet) | 118 | struct dccp_rx_hist_entry *packet, |
119 | u64 nonloss_seqno) | ||
119 | { | 120 | { |
120 | struct dccp_rx_hist_entry *entry, *next, *iter; | 121 | struct dccp_rx_hist_entry *entry, *next; |
121 | u8 num_later = 0; | 122 | u8 num_later = 0; |
122 | 123 | ||
123 | iter = dccp_rx_hist_head(rx_list); | 124 | list_add(&packet->dccphrx_node, rx_list); |
124 | if (iter == NULL) | ||
125 | dccp_rx_hist_add_entry(rx_list, packet); | ||
126 | else { | ||
127 | const u64 seqno = packet->dccphrx_seqno; | ||
128 | |||
129 | if (after48(seqno, iter->dccphrx_seqno)) | ||
130 | dccp_rx_hist_add_entry(rx_list, packet); | ||
131 | else { | ||
132 | if (dccp_rx_hist_entry_data_packet(iter)) | ||
133 | num_later = 1; | ||
134 | |||
135 | list_for_each_entry_continue(iter, rx_list, | ||
136 | dccphrx_node) { | ||
137 | if (after48(seqno, iter->dccphrx_seqno)) { | ||
138 | dccp_rx_hist_add_entry(&iter->dccphrx_node, | ||
139 | packet); | ||
140 | goto trim_history; | ||
141 | } | ||
142 | |||
143 | if (dccp_rx_hist_entry_data_packet(iter)) | ||
144 | num_later++; | ||
145 | |||
146 | if (num_later == TFRC_RECV_NUM_LATE_LOSS) { | ||
147 | dccp_rx_hist_entry_delete(hist, packet); | ||
148 | return 1; | ||
149 | } | ||
150 | } | ||
151 | |||
152 | if (num_later < TFRC_RECV_NUM_LATE_LOSS) | ||
153 | dccp_rx_hist_add_entry(rx_list, packet); | ||
154 | /* | ||
155 | * FIXME: else what? should we destroy the packet | ||
156 | * like above? | ||
157 | */ | ||
158 | } | ||
159 | } | ||
160 | 125 | ||
161 | trim_history: | ||
162 | /* | ||
163 | * Trim history (remove all packets after the NUM_LATE_LOSS + 1 | ||
164 | * data packets) | ||
165 | */ | ||
166 | num_later = TFRC_RECV_NUM_LATE_LOSS + 1; | 126 | num_later = TFRC_RECV_NUM_LATE_LOSS + 1; |
167 | 127 | ||
168 | if (!list_empty(li_list)) { | 128 | if (!list_empty(li_list)) { |
169 | list_for_each_entry_safe(entry, next, rx_list, dccphrx_node) { | 129 | list_for_each_entry_safe(entry, next, rx_list, dccphrx_node) { |
170 | if (num_later == 0) { | 130 | if (num_later == 0) { |
171 | list_del_init(&entry->dccphrx_node); | 131 | if (after48(nonloss_seqno, |
172 | dccp_rx_hist_entry_delete(hist, entry); | 132 | entry->dccphrx_seqno)) { |
133 | list_del_init(&entry->dccphrx_node); | ||
134 | dccp_rx_hist_entry_delete(hist, entry); | ||
135 | } | ||
173 | } else if (dccp_rx_hist_entry_data_packet(entry)) | 136 | } else if (dccp_rx_hist_entry_data_packet(entry)) |
174 | --num_later; | 137 | --num_later; |
175 | } | 138 | } |
@@ -217,94 +180,10 @@ trim_history: | |||
217 | --num_later; | 180 | --num_later; |
218 | } | 181 | } |
219 | } | 182 | } |
220 | |||
221 | return 0; | ||
222 | } | 183 | } |
223 | 184 | ||
224 | EXPORT_SYMBOL_GPL(dccp_rx_hist_add_packet); | 185 | EXPORT_SYMBOL_GPL(dccp_rx_hist_add_packet); |
225 | 186 | ||
226 | u64 dccp_rx_hist_detect_loss(struct list_head *rx_list, | ||
227 | struct list_head *li_list, u8 *win_loss) | ||
228 | { | ||
229 | struct dccp_rx_hist_entry *entry, *next, *packet; | ||
230 | struct dccp_rx_hist_entry *a_loss = NULL; | ||
231 | struct dccp_rx_hist_entry *b_loss = NULL; | ||
232 | u64 seq_loss = DCCP_MAX_SEQNO + 1; | ||
233 | u8 num_later = TFRC_RECV_NUM_LATE_LOSS; | ||
234 | |||
235 | list_for_each_entry_safe(entry, next, rx_list, dccphrx_node) { | ||
236 | if (num_later == 0) { | ||
237 | b_loss = entry; | ||
238 | break; | ||
239 | } else if (dccp_rx_hist_entry_data_packet(entry)) | ||
240 | --num_later; | ||
241 | } | ||
242 | |||
243 | if (b_loss == NULL) | ||
244 | goto out; | ||
245 | |||
246 | num_later = 1; | ||
247 | list_for_each_entry_safe_continue(entry, next, rx_list, dccphrx_node) { | ||
248 | if (num_later == 0) { | ||
249 | a_loss = entry; | ||
250 | break; | ||
251 | } else if (dccp_rx_hist_entry_data_packet(entry)) | ||
252 | --num_later; | ||
253 | } | ||
254 | |||
255 | if (a_loss == NULL) { | ||
256 | if (list_empty(li_list)) { | ||
257 | /* no loss event have occured yet */ | ||
258 | LIMIT_NETDEBUG("%s: TODO: find a lost data packet by " | ||
259 | "comparing to initial seqno\n", | ||
260 | __FUNCTION__); | ||
261 | goto out; | ||
262 | } else { | ||
263 | LIMIT_NETDEBUG("%s: Less than 4 data pkts in history!", | ||
264 | __FUNCTION__); | ||
265 | goto out; | ||
266 | } | ||
267 | } | ||
268 | |||
269 | /* Locate a lost data packet */ | ||
270 | entry = packet = b_loss; | ||
271 | list_for_each_entry_safe_continue(entry, next, rx_list, dccphrx_node) { | ||
272 | u64 delta = dccp_delta_seqno(entry->dccphrx_seqno, | ||
273 | packet->dccphrx_seqno); | ||
274 | |||
275 | if (delta != 0) { | ||
276 | if (dccp_rx_hist_entry_data_packet(packet)) | ||
277 | --delta; | ||
278 | /* | ||
279 | * FIXME: check this, probably this % usage is because | ||
280 | * in earlier drafts the ndp count was just 8 bits | ||
281 | * long, but now it cam be up to 24 bits long. | ||
282 | */ | ||
283 | #if 0 | ||
284 | if (delta % DCCP_NDP_LIMIT != | ||
285 | (packet->dccphrx_ndp - | ||
286 | entry->dccphrx_ndp) % DCCP_NDP_LIMIT) | ||
287 | #endif | ||
288 | if (delta != packet->dccphrx_ndp - entry->dccphrx_ndp) { | ||
289 | seq_loss = entry->dccphrx_seqno; | ||
290 | dccp_inc_seqno(&seq_loss); | ||
291 | } | ||
292 | } | ||
293 | packet = entry; | ||
294 | if (packet == a_loss) | ||
295 | break; | ||
296 | } | ||
297 | out: | ||
298 | if (seq_loss != DCCP_MAX_SEQNO + 1) | ||
299 | *win_loss = a_loss->dccphrx_ccval; | ||
300 | else | ||
301 | *win_loss = 0; /* Paranoia */ | ||
302 | |||
303 | return seq_loss; | ||
304 | } | ||
305 | |||
306 | EXPORT_SYMBOL_GPL(dccp_rx_hist_detect_loss); | ||
307 | |||
308 | struct dccp_tx_hist *dccp_tx_hist_new(const char *name) | 187 | struct dccp_tx_hist *dccp_tx_hist_new(const char *name) |
309 | { | 188 | { |
310 | struct dccp_tx_hist *hist = kmalloc(sizeof(*hist), GFP_ATOMIC); | 189 | struct dccp_tx_hist *hist = kmalloc(sizeof(*hist), GFP_ATOMIC); |
diff --git a/net/dccp/ccids/lib/packet_history.h b/net/dccp/ccids/lib/packet_history.h index aea9c5d70910..067cf1c85a37 100644 --- a/net/dccp/ccids/lib/packet_history.h +++ b/net/dccp/ccids/lib/packet_history.h | |||
@@ -166,12 +166,6 @@ static inline void dccp_rx_hist_entry_delete(struct dccp_rx_hist *hist, | |||
166 | extern void dccp_rx_hist_purge(struct dccp_rx_hist *hist, | 166 | extern void dccp_rx_hist_purge(struct dccp_rx_hist *hist, |
167 | struct list_head *list); | 167 | struct list_head *list); |
168 | 168 | ||
169 | static inline void dccp_rx_hist_add_entry(struct list_head *list, | ||
170 | struct dccp_rx_hist_entry *entry) | ||
171 | { | ||
172 | list_add(&entry->dccphrx_node, list); | ||
173 | } | ||
174 | |||
175 | static inline struct dccp_rx_hist_entry * | 169 | static inline struct dccp_rx_hist_entry * |
176 | dccp_rx_hist_head(struct list_head *list) | 170 | dccp_rx_hist_head(struct list_head *list) |
177 | { | 171 | { |
@@ -190,10 +184,11 @@ static inline int | |||
190 | entry->dccphrx_type == DCCP_PKT_DATAACK; | 184 | entry->dccphrx_type == DCCP_PKT_DATAACK; |
191 | } | 185 | } |
192 | 186 | ||
193 | extern int dccp_rx_hist_add_packet(struct dccp_rx_hist *hist, | 187 | extern void dccp_rx_hist_add_packet(struct dccp_rx_hist *hist, |
194 | struct list_head *rx_list, | 188 | struct list_head *rx_list, |
195 | struct list_head *li_list, | 189 | struct list_head *li_list, |
196 | struct dccp_rx_hist_entry *packet); | 190 | struct dccp_rx_hist_entry *packet, |
191 | u64 nonloss_seqno); | ||
197 | 192 | ||
198 | extern u64 dccp_rx_hist_detect_loss(struct list_head *rx_list, | 193 | extern u64 dccp_rx_hist_detect_loss(struct list_head *rx_list, |
199 | struct list_head *li_list, u8 *win_loss); | 194 | struct list_head *li_list, u8 *win_loss); |