From bdf453e4293886572031b0b291e9f3f3336052e6 Mon Sep 17 00:00:00 2001 From: tfyu Date: Wed, 27 Sep 2017 13:34:30 +0800 Subject: [PATCH] qcacld-3.0: Enable the TX orphan by ini key gEnableTxOrphan Enable the TX orphan by ini key gEnableTxOrphan, which is protected by TX flow control. Change-Id: Ib8e6d88ea0c7fda62f2d13ae3c592866ddc82521 CRs-Fixed: 2115621 --- core/hdd/src/wlan_hdd_softap_tx_rx.c | 52 +++++++++++++++++----------- core/hdd/src/wlan_hdd_tx_rx.c | 52 +++++++++++++++++----------- 2 files changed, 64 insertions(+), 40 deletions(-) diff --git a/core/hdd/src/wlan_hdd_softap_tx_rx.c b/core/hdd/src/wlan_hdd_softap_tx_rx.c index 85a7bc2f1574..d8b90fd5bd87 100644 --- a/core/hdd/src/wlan_hdd_softap_tx_rx.c +++ b/core/hdd/src/wlan_hdd_softap_tx_rx.c @@ -199,7 +199,34 @@ void hdd_softap_tx_resume_cb(void *adapter_context, bool tx_resume) static inline struct sk_buff *hdd_skb_orphan(struct hdd_adapter *pAdapter, struct sk_buff *skb) { - if (pAdapter->tx_flow_low_watermark > 0) +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)) + struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); +#endif + int need_orphan = 0; + + if (pAdapter->tx_flow_low_watermark > 0) { +#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 19, 0)) + /* + * The TCP TX throttling logic is changed a little after + * 3.19-rc1 kernel, the TCP sending limit will be smaller, + * which will throttle the TCP packets to the host driver. + * The TCP UP LINK throughput will drop heavily. In order to + * fix this issue, need to orphan the socket buffer asap, which + * will call skb's destructor to notify the TCP stack that the + * SKB buffer is unowned. And then the TCP stack will pump more + * packets to host driver. + * + * The TX packets might be dropped for UDP case in the iperf + * testing. So need to be protected by follow control. + */ + need_orphan = 1; +#else + if (hdd_ctx->config->tx_orphan_enable) + need_orphan = 1; +#endif + } + + if (need_orphan) skb_orphan(skb); else skb = skb_unshare(skb, GFP_ATOMIC); @@ -219,9 +246,12 @@ static inline struct sk_buff *hdd_skb_orphan(struct hdd_adapter *pAdapter, struct sk_buff *skb) { struct sk_buff *nskb; +#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 19, 0)) struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); +#endif nskb = skb_unshare(skb, GFP_ATOMIC); +#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 19, 0)) if (unlikely(hdd_ctx->config->tx_orphan_enable) && (nskb == skb)) { /* * For UDP packets we want to orphan the packet to allow the app @@ -231,6 +261,7 @@ static inline struct sk_buff *hdd_skb_orphan(struct hdd_adapter *pAdapter, ++pAdapter->hdd_stats.hddTxRxStats.txXmitOrphaned; skb_orphan(skb); } +#endif return nskb; } #endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */ @@ -362,26 +393,7 @@ static int __hdd_softap_hard_start_xmit(struct sk_buff *skb, if (!qdf_nbuf_ipa_owned_get(skb)) { #endif -#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 19, 0)) - /* - * The TCP TX throttling logic is changed a little after - * 3.19-rc1 kernel, the TCP sending limit will be smaller, - * which will throttle the TCP packets to the host driver. - * The TCP UP LINK throughput will drop heavily. In order to - * fix this issue, need to orphan the socket buffer asap, which - * will call skb's destructor to notify the TCP stack that the - * SKB buffer is unowned. And then the TCP stack will pump more - * packets to host driver. - * - * The TX packets might be dropped for UDP case in the iperf - * testing. So need to be protected by follow control. - */ skb = hdd_skb_orphan(pAdapter, skb); -#else - /* Check if the buffer has enough header room */ - skb = skb_unshare(skb, GFP_ATOMIC); -#endif - if (!skb) goto drop_pkt_accounting; diff --git a/core/hdd/src/wlan_hdd_tx_rx.c b/core/hdd/src/wlan_hdd_tx_rx.c index 2c59109d4289..762c96a42d1b 100644 --- a/core/hdd/src/wlan_hdd_tx_rx.c +++ b/core/hdd/src/wlan_hdd_tx_rx.c @@ -162,7 +162,34 @@ hdd_tx_resume_false(struct hdd_adapter *pAdapter, bool tx_resume) static inline struct sk_buff *hdd_skb_orphan(struct hdd_adapter *pAdapter, struct sk_buff *skb) { - if (pAdapter->tx_flow_low_watermark > 0) +#if (LINUX_VERSION_CODE <= KERNEL_VERSION(3, 19, 0)) + struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); +#endif + int need_orphan = 0; + + if (pAdapter->tx_flow_low_watermark > 0) { +#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 19, 0)) + /* + * The TCP TX throttling logic is changed a little after + * 3.19-rc1 kernel, the TCP sending limit will be smaller, + * which will throttle the TCP packets to the host driver. + * The TCP UP LINK throughput will drop heavily. In order to + * fix this issue, need to orphan the socket buffer asap, which + * will call skb's destructor to notify the TCP stack that the + * SKB buffer is unowned. And then the TCP stack will pump more + * packets to host driver. + * + * The TX packets might be dropped for UDP case in the iperf + * testing. So need to be protected by follow control. + */ + need_orphan = 1; +#else + if (hdd_ctx->config->tx_orphan_enable) + need_orphan = 1; +#endif + } + + if (need_orphan) skb_orphan(skb); else skb = skb_unshare(skb, GFP_ATOMIC); @@ -298,9 +325,12 @@ static inline struct sk_buff *hdd_skb_orphan(struct hdd_adapter *pAdapter, struct sk_buff *skb) { struct sk_buff *nskb; +#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 19, 0)) struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); +#endif nskb = skb_unshare(skb, GFP_ATOMIC); +#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 19, 0)) if (unlikely(hdd_ctx->config->tx_orphan_enable) && (nskb == skb)) { /* * For UDP packets we want to orphan the packet to allow the app @@ -310,6 +340,7 @@ static inline struct sk_buff *hdd_skb_orphan(struct hdd_adapter *pAdapter, ++pAdapter->hdd_stats.hddTxRxStats.txXmitOrphaned; skb_orphan(skb); } +#endif return nskb; } #endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */ @@ -571,26 +602,7 @@ static int __hdd_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) ac = hdd_qdisc_ac_to_tl_ac[skb->queue_mapping]; if (!qdf_nbuf_ipa_owned_get(skb)) { -#if (LINUX_VERSION_CODE > KERNEL_VERSION(3, 19, 0)) - /* - * The TCP TX throttling logic is changed a little after - * 3.19-rc1 kernel, the TCP sending limit will be smaller, - * which will throttle the TCP packets to the host driver. - * The TCP UP LINK throughput will drop heavily. In order to - * fix this issue, need to orphan the socket buffer asap, which - * will call skb's destructor to notify the TCP stack that the - * SKB buffer is unowned. And then the TCP stack will pump more - * packets to host driver. - * - * The TX packets might be dropped for UDP case in the iperf - * testing. So need to be protected by follow control. - */ skb = hdd_skb_orphan(pAdapter, skb); -#else - /* Check if the buffer has enough header room */ - skb = skb_unshare(skb, GFP_ATOMIC); -#endif - if (!skb) goto drop_pkt_accounting; }