From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.8 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B7EC5C43441 for ; Mon, 12 Nov 2018 22:52:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 61CA3223DD for ; Mon, 12 Nov 2018 22:52:04 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="L/CwvJcZ"; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="V53uK2s8" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 61CA3223DD Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-wireless-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727542AbeKMIrR (ORCPT ); Tue, 13 Nov 2018 03:47:17 -0500 Received: from smtp.codeaurora.org ([198.145.29.96]:44484 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725973AbeKMIrR (ORCPT ); Tue, 13 Nov 2018 03:47:17 -0500 Received: by smtp.codeaurora.org (Postfix, from userid 1000) id 34F1A60881; Mon, 12 Nov 2018 22:52:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1542063122; bh=QgpsoZ6oLWvmNAxjeZev5Z3gqmZmLSRQdJKT9Z4WLG4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=L/CwvJcZ/Ootd0koUA/hw3XNKrEKWutOxcTBaC4XmPuNLuHIkN51Dt3tXxIuS6CD+ mCtKURCVBSFmwr8wbxCY2j0Jy3S3jCuxBssZ4sIuSltw/b3H19wacwTMPHSBbZcIcM +qijOwQLAm1zsOeDOGHPVXWomquzsrpvLyptzwes= Received: from smtp.codeaurora.org (i-global254.qualcomm.com [199.106.103.254]) (using TLSv1 with cipher AES128-SHA (128/128 bits)) (No client certificate requested) (Authenticated sender: rmanohar@smtp.codeaurora.org) by smtp.codeaurora.org (Postfix) with ESMTPSA id 0AB3260600; Mon, 12 Nov 2018 22:51:59 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1542063121; bh=QgpsoZ6oLWvmNAxjeZev5Z3gqmZmLSRQdJKT9Z4WLG4=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=V53uK2s8wlwHwAxuOVd3FNQtx4T9nQZx0COVUUF3DOZ+2b4cViITV3ORYHVJxKGty kaPcyu0MfSBUv8EVEXSDOJAJdfW76LF54fdiAUnizDZ/jWXOTLJxfBvCAuzTjBcavQ pPsJFhS+fL/YuJ/yyloU+1Np1nJiPNBuYdCfAU+Q= DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org 0AB3260600 Authentication-Results: pdx-caf-mail.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: pdx-caf-mail.web.codeaurora.org; spf=none smtp.mailfrom=rmanohar@codeaurora.org Received: by smtp.codeaurora.org (sSMTP sendmail emulation); Mon, 12 Nov 2018 14:51:59 -0800 From: Rajkumar Manoharan To: linux-wireless@vger.kernel.org, ath10k@lists.infradead.org Cc: make-wifi-fast@lists.bufferbloat.net, =?UTF-8?q?Toke=20H=C3=B8iland-J=C3=B8rgensen?= Subject: [PATCH v3 1/6] mac80211: Add TXQ scheduling API Date: Mon, 12 Nov 2018 14:51:48 -0800 Message-Id: <1542063113-22438-2-git-send-email-rmanohar@codeaurora.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1542063113-22438-1-git-send-email-rmanohar@codeaurora.org> References: <1542063113-22438-1-git-send-email-rmanohar@codeaurora.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-wireless-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-wireless@vger.kernel.org From: Toke Høiland-Jørgensen This adds an API to mac80211 to handle scheduling of TXQs. The interface between driver and mac80211 for TXQ handling is changed by adding two new functions: ieee80211_next_txq(), which will return the next TXQ to schedule in the current round-robin rotation, and ieee80211_return_txq(), which the driver uses to indicate that it has finished scheduling a TXQ (which will then be put back in the scheduling rotation if it isn't empty). The driver must call ieee80211_txq_schedule_start() at the start of each scheduling session, and ieee80211_txq_schedule_end() at the end. The API then guarantees that the same TXQ is not returned twice in the same session (so a driver can loop on ieee80211_next_txq() without worrying about breaking the loop. Usage of the new API is optional, so drivers can be ported one at a time. In this patch, the actual scheduling performed by mac80211 is simple round-robin, but a subsequent commit adds airtime fairness awareness to the scheduler. Signed-off-by: Toke Høiland-Jørgensen --- include/net/mac80211.h | 62 +++++++++++++++++++++++++++++++++++++++++++--- net/mac80211/agg-tx.c | 2 +- net/mac80211/driver-ops.h | 9 +++++++ net/mac80211/ieee80211_i.h | 9 +++++++ net/mac80211/main.c | 5 ++++ net/mac80211/sta_info.c | 2 +- net/mac80211/tx.c | 58 ++++++++++++++++++++++++++++++++++++++++++- 7 files changed, 140 insertions(+), 7 deletions(-) diff --git a/include/net/mac80211.h b/include/net/mac80211.h index 71985e95d2d9..18b11c119b7e 100644 --- a/include/net/mac80211.h +++ b/include/net/mac80211.h @@ -108,9 +108,15 @@ * The driver is expected to initialize its private per-queue data for stations * and interfaces in the .add_interface and .sta_add ops. * - * The driver can't access the queue directly. To dequeue a frame, it calls - * ieee80211_tx_dequeue(). Whenever mac80211 adds a new frame to a queue, it - * calls the .wake_tx_queue driver op. + * The driver can't access the queue directly. To dequeue a frame from a + * txq, it calls ieee80211_tx_dequeue(). Whenever mac80211 adds a new frame to a + * queue, it calls the .wake_tx_queue driver op. + * + * Drivers can optionally delegate responsibility for scheduling queues to + * mac80211, to take advantage of airtime fairness accounting. In this case, to + * obtain the next queue to pull frames from, the driver calls + * ieee80211_next_txq(). The driver is then expected to return the txq using + * ieee80211_return_txq(). * * For AP powersave TIM handling, the driver only needs to indicate if it has * buffered packets in the driver specific data structures by calling @@ -6088,7 +6094,8 @@ void ieee80211_tdls_oper_request(struct ieee80211_vif *vif, const u8 *peer, * ieee80211_tx_dequeue - dequeue a packet from a software tx queue * * @hw: pointer as obtained from ieee80211_alloc_hw() - * @txq: pointer obtained from station or virtual interface + * @txq: pointer obtained from station or virtual interface, or from + * ieee80211_next_txq() * * Returns the skb if successful, %NULL if no frame was available. */ @@ -6096,6 +6103,53 @@ struct sk_buff *ieee80211_tx_dequeue(struct ieee80211_hw *hw, struct ieee80211_txq *txq); /** + * ieee80211_next_txq - get next tx queue to pull packets from + * + * @hw: pointer as obtained from ieee80211_alloc_hw() + * @ac: AC number to return packets from. + * + * Should only be called between calls to ieee80211_txq_schedule_start() + * and ieee80211_txq_schedule_end(). + * Returns the next txq if successful, %NULL if no queue is eligible. If a txq + * is returned, it should be returned with ieee80211_return_txq() after the + * driver has finished scheduling it. + */ +struct ieee80211_txq *ieee80211_next_txq(struct ieee80211_hw *hw, u8 ac); + +/** + * ieee80211_return_txq - return a TXQ previously acquired by + * ieee80211_next_txq() + * + * @hw: pointer as obtained from ieee80211_alloc_hw() + * @txq: pointer obtained from station or virtual interface + * + * Should only be called between calls to ieee80211_txq_schedule_start() + * and ieee80211_txq_schedule_end(). + */ +void ieee80211_return_txq(struct ieee80211_hw *hw, struct ieee80211_txq *txq); + +/** + * ieee80211_txq_schedule_start - acquire locks for safe scheduling of an AC + * + * @hw: pointer as obtained from ieee80211_alloc_hw() + * @ac: AC number to acquire locks for + * + * Acquire locks needed to schedule TXQs from the given AC. Should be called + * before ieee80211_next_txq() or ieee80211_return_txq(). + */ +void ieee80211_txq_schedule_start(struct ieee80211_hw *hw, u8 ac); + +/** + * ieee80211_txq_schedule_end - release locks for safe scheduling of an AC + * + * @hw: pointer as obtained from ieee80211_alloc_hw() + * @ac: AC number to acquire locks for + * + * Release locks previously acquired by ieee80211_txq_schedule_end(). + */ +void ieee80211_txq_schedule_end(struct ieee80211_hw *hw, u8 ac); + +/** * ieee80211_txq_get_depth - get pending frame/byte count of given txq * * The values are not guaranteed to be coherent with regard to each other, i.e. diff --git a/net/mac80211/agg-tx.c b/net/mac80211/agg-tx.c index 69e831bc317b..e94b1a0407af 100644 --- a/net/mac80211/agg-tx.c +++ b/net/mac80211/agg-tx.c @@ -229,7 +229,7 @@ static void __releases(agg_queue) clear_bit(IEEE80211_TXQ_STOP, &txqi->flags); local_bh_disable(); rcu_read_lock(); - drv_wake_tx_queue(sta->sdata->local, txqi); + schedule_and_wake_txq(sta->sdata->local, txqi); rcu_read_unlock(); local_bh_enable(); } diff --git a/net/mac80211/driver-ops.h b/net/mac80211/driver-ops.h index 0b1747a2313d..ce4138323820 100644 --- a/net/mac80211/driver-ops.h +++ b/net/mac80211/driver-ops.h @@ -1173,6 +1173,15 @@ static inline void drv_wake_tx_queue(struct ieee80211_local *local, local->ops->wake_tx_queue(&local->hw, &txq->txq); } +static inline void schedule_and_wake_txq(struct ieee80211_local *local, + struct txq_info *txqi) +{ + spin_lock_bh(&local->active_txq_lock[txqi->txq.ac]); + ieee80211_return_txq(&local->hw, &txqi->txq); + spin_unlock_bh(&local->active_txq_lock[txqi->txq.ac]); + drv_wake_tx_queue(local, txqi); +} + static inline int drv_can_aggregate_in_amsdu(struct ieee80211_local *local, struct sk_buff *head, struct sk_buff *skb) diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h index 10a05062e4a0..33763a2eac81 100644 --- a/net/mac80211/ieee80211_i.h +++ b/net/mac80211/ieee80211_i.h @@ -830,6 +830,8 @@ enum txq_info_flags { * a fq_flow which is already owned by a different tin * @def_cvars: codel vars for @def_flow * @frags: used to keep fragments created after dequeue + * @schedule_order: used with ieee80211_local->active_txqs + * @schedule_round: counter to prevent infinite loops on TXQ scheduling */ struct txq_info { struct fq_tin tin; @@ -837,6 +839,8 @@ struct txq_info { struct codel_vars def_cvars; struct codel_stats cstats; struct sk_buff_head frags; + struct list_head schedule_order; + u16 schedule_round; unsigned long flags; /* keep last! */ @@ -1128,6 +1132,11 @@ struct ieee80211_local { struct codel_vars *cvars; struct codel_params cparams; + /* protects active_txqs and txqi->schedule_order */ + spinlock_t active_txq_lock[IEEE80211_NUM_ACS]; + struct list_head active_txqs[IEEE80211_NUM_ACS]; + u16 schedule_round[IEEE80211_NUM_ACS]; + const struct ieee80211_ops *ops; /* diff --git a/net/mac80211/main.c b/net/mac80211/main.c index 83e71e6b2ebe..ba64757afea4 100644 --- a/net/mac80211/main.c +++ b/net/mac80211/main.c @@ -663,6 +663,11 @@ struct ieee80211_hw *ieee80211_alloc_hw_nm(size_t priv_data_len, spin_lock_init(&local->rx_path_lock); spin_lock_init(&local->queue_stop_reason_lock); + for (i = 0; i < IEEE80211_NUM_ACS; i++) { + INIT_LIST_HEAD(&local->active_txqs[i]); + spin_lock_init(&local->active_txq_lock[i]); + } + INIT_LIST_HEAD(&local->chanctx_list); mutex_init(&local->chanctx_mtx); diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c index fb8c2252ac0e..c2f5cb7df54f 100644 --- a/net/mac80211/sta_info.c +++ b/net/mac80211/sta_info.c @@ -1249,7 +1249,7 @@ void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta) if (!sta->sta.txq[i] || !txq_has_queue(sta->sta.txq[i])) continue; - drv_wake_tx_queue(local, to_txq_info(sta->sta.txq[i])); + schedule_and_wake_txq(local, to_txq_info(sta->sta.txq[i])); } skb_queue_head_init(&pending); diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c index e0ccee23fbcd..305965283506 100644 --- a/net/mac80211/tx.c +++ b/net/mac80211/tx.c @@ -1449,6 +1449,7 @@ void ieee80211_txq_init(struct ieee80211_sub_if_data *sdata, codel_vars_init(&txqi->def_cvars); codel_stats_init(&txqi->cstats); __skb_queue_head_init(&txqi->frags); + INIT_LIST_HEAD(&txqi->schedule_order); txqi->txq.vif = &sdata->vif; @@ -1489,6 +1490,9 @@ void ieee80211_txq_purge(struct ieee80211_local *local, fq_tin_reset(fq, tin, fq_skb_free_func); ieee80211_purge_tx_queue(&local->hw, &txqi->frags); + spin_lock_bh(&local->active_txq_lock[txqi->txq.ac]); + list_del_init(&txqi->schedule_order); + spin_unlock_bh(&local->active_txq_lock[txqi->txq.ac]); } void ieee80211_txq_set_params(struct ieee80211_local *local) @@ -1605,7 +1609,7 @@ static bool ieee80211_queue_skb(struct ieee80211_local *local, ieee80211_txq_enqueue(local, txqi, skb); spin_unlock_bh(&fq->lock); - drv_wake_tx_queue(local, txqi); + schedule_and_wake_txq(local, txqi); return true; } @@ -3627,6 +3631,58 @@ struct sk_buff *ieee80211_tx_dequeue(struct ieee80211_hw *hw, } EXPORT_SYMBOL(ieee80211_tx_dequeue); +struct ieee80211_txq *ieee80211_next_txq(struct ieee80211_hw *hw, u8 ac) +{ + struct ieee80211_local *local = hw_to_local(hw); + struct txq_info *txqi = NULL; + + lockdep_assert_held(&local->active_txq_lock[ac]); + + txqi = list_first_entry_or_null(&local->active_txqs[ac], + struct txq_info, + schedule_order); + + if (!txqi || txqi->schedule_round == local->schedule_round[ac]) + return NULL; + + list_del_init(&txqi->schedule_order); + txqi->schedule_round = local->schedule_round[ac]; + return &txqi->txq; +} +EXPORT_SYMBOL(ieee80211_next_txq); + +void ieee80211_return_txq(struct ieee80211_hw *hw, + struct ieee80211_txq *txq) +{ + struct ieee80211_local *local = hw_to_local(hw); + struct txq_info *txqi = to_txq_info(txq); + + lockdep_assert_held(&local->active_txq_lock[txq->ac]); + + if (list_empty(&txqi->schedule_order) && + (!skb_queue_empty(&txqi->frags) || txqi->tin.backlog_packets)) + list_add_tail(&txqi->schedule_order, + &local->active_txqs[txq->ac]); +} +EXPORT_SYMBOL(ieee80211_return_txq); + +void ieee80211_txq_schedule_start(struct ieee80211_hw *hw, u8 ac) +{ + struct ieee80211_local *local = hw_to_local(hw); + + spin_lock_bh(&local->active_txq_lock[ac]); + local->schedule_round[ac]++; +} +EXPORT_SYMBOL(ieee80211_txq_schedule_start); + +void ieee80211_txq_schedule_end(struct ieee80211_hw *hw, u8 ac) +{ + struct ieee80211_local *local = hw_to_local(hw); + + spin_unlock_bh(&local->active_txq_lock[ac]); +} +EXPORT_SYMBOL(ieee80211_txq_schedule_end); + void __ieee80211_subif_start_xmit(struct sk_buff *skb, struct net_device *dev, u32 info_flags) -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from smtp.codeaurora.org ([198.145.29.96]) by casper.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gML40-0001uI-9X for ath10k@lists.infradead.org; Mon, 12 Nov 2018 22:52:22 +0000 From: Rajkumar Manoharan Subject: [PATCH v3 1/6] mac80211: Add TXQ scheduling API Date: Mon, 12 Nov 2018 14:51:48 -0800 Message-Id: <1542063113-22438-2-git-send-email-rmanohar@codeaurora.org> In-Reply-To: <1542063113-22438-1-git-send-email-rmanohar@codeaurora.org> References: <1542063113-22438-1-git-send-email-rmanohar@codeaurora.org> MIME-Version: 1.0 List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "ath10k" Errors-To: ath10k-bounces+kvalo=adurom.com@lists.infradead.org To: linux-wireless@vger.kernel.org, ath10k@lists.infradead.org Cc: make-wifi-fast@lists.bufferbloat.net, =?UTF-8?q?Toke=20H=C3=B8iland-J=C3=B8rgensen?= RnJvbTogVG9rZSBIw7hpbGFuZC1Kw7hyZ2Vuc2VuIDx0b2tlQHRva2UuZGs+CgpUaGlzIGFkZHMg YW4gQVBJIHRvIG1hYzgwMjExIHRvIGhhbmRsZSBzY2hlZHVsaW5nIG9mIFRYUXMuIFRoZSBpbnRl cmZhY2UKYmV0d2VlbiBkcml2ZXIgYW5kIG1hYzgwMjExIGZvciBUWFEgaGFuZGxpbmcgaXMgY2hh bmdlZCBieSBhZGRpbmcgdHdvIG5ldwpmdW5jdGlvbnM6IGllZWU4MDIxMV9uZXh0X3R4cSgpLCB3 aGljaCB3aWxsIHJldHVybiB0aGUgbmV4dCBUWFEgdG8gc2NoZWR1bGUKaW4gdGhlIGN1cnJlbnQg cm91bmQtcm9iaW4gcm90YXRpb24sIGFuZCBpZWVlODAyMTFfcmV0dXJuX3R4cSgpLCB3aGljaCB0 aGUKZHJpdmVyIHVzZXMgdG8gaW5kaWNhdGUgdGhhdCBpdCBoYXMgZmluaXNoZWQgc2NoZWR1bGlu ZyBhIFRYUSAod2hpY2ggd2lsbAp0aGVuIGJlIHB1dCBiYWNrIGluIHRoZSBzY2hlZHVsaW5nIHJv dGF0aW9uIGlmIGl0IGlzbid0IGVtcHR5KS4KClRoZSBkcml2ZXIgbXVzdCBjYWxsIGllZWU4MDIx MV90eHFfc2NoZWR1bGVfc3RhcnQoKSBhdCB0aGUgc3RhcnQgb2YgZWFjaApzY2hlZHVsaW5nIHNl c3Npb24sIGFuZCBpZWVlODAyMTFfdHhxX3NjaGVkdWxlX2VuZCgpIGF0IHRoZSBlbmQuIFRoZSBB UEkKdGhlbiBndWFyYW50ZWVzIHRoYXQgdGhlIHNhbWUgVFhRIGlzIG5vdCByZXR1cm5lZCB0d2lj ZSBpbiB0aGUgc2FtZQpzZXNzaW9uIChzbyBhIGRyaXZlciBjYW4gbG9vcCBvbiBpZWVlODAyMTFf bmV4dF90eHEoKSB3aXRob3V0IHdvcnJ5aW5nCmFib3V0IGJyZWFraW5nIHRoZSBsb29wLgoKVXNh Z2Ugb2YgdGhlIG5ldyBBUEkgaXMgb3B0aW9uYWwsIHNvIGRyaXZlcnMgY2FuIGJlIHBvcnRlZCBv bmUgYXQgYSB0aW1lLgpJbiB0aGlzIHBhdGNoLCB0aGUgYWN0dWFsIHNjaGVkdWxpbmcgcGVyZm9y bWVkIGJ5IG1hYzgwMjExIGlzIHNpbXBsZQpyb3VuZC1yb2JpbiwgYnV0IGEgc3Vic2VxdWVudCBj b21taXQgYWRkcyBhaXJ0aW1lIGZhaXJuZXNzIGF3YXJlbmVzcyB0byB0aGUKc2NoZWR1bGVyLgoK U2lnbmVkLW9mZi1ieTogVG9rZSBIw7hpbGFuZC1Kw7hyZ2Vuc2VuIDx0b2tlQHRva2UuZGs+Ci0t LQogaW5jbHVkZS9uZXQvbWFjODAyMTEuaCAgICAgfCA2MiArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrLS0tCiBuZXQvbWFjODAyMTEvYWdnLXR4LmMgICAgICB8ICAy ICstCiBuZXQvbWFjODAyMTEvZHJpdmVyLW9wcy5oICB8ICA5ICsrKysrKysKIG5ldC9tYWM4MDIx MS9pZWVlODAyMTFfaS5oIHwgIDkgKysrKysrKwogbmV0L21hYzgwMjExL21haW4uYyAgICAgICAg fCAgNSArKysrCiBuZXQvbWFjODAyMTEvc3RhX2luZm8uYyAgICB8ICAyICstCiBuZXQvbWFjODAy MTEvdHguYyAgICAgICAgICB8IDU4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKy0KIDcgZmlsZXMgY2hhbmdlZCwgMTQwIGluc2VydGlvbnMoKyksIDcgZGVsZXRpb25z KC0pCgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9uZXQvbWFjODAyMTEuaCBiL2luY2x1ZGUvbmV0L21h YzgwMjExLmgKaW5kZXggNzE5ODVlOTVkMmQ5Li4xOGIxMWMxMTliN2UgMTAwNjQ0Ci0tLSBhL2lu Y2x1ZGUvbmV0L21hYzgwMjExLmgKKysrIGIvaW5jbHVkZS9uZXQvbWFjODAyMTEuaApAQCAtMTA4 LDkgKzEwOCwxNSBAQAogICogVGhlIGRyaXZlciBpcyBleHBlY3RlZCB0byBpbml0aWFsaXplIGl0 cyBwcml2YXRlIHBlci1xdWV1ZSBkYXRhIGZvciBzdGF0aW9ucwogICogYW5kIGludGVyZmFjZXMg aW4gdGhlIC5hZGRfaW50ZXJmYWNlIGFuZCAuc3RhX2FkZCBvcHMuCiAgKgotICogVGhlIGRyaXZl ciBjYW4ndCBhY2Nlc3MgdGhlIHF1ZXVlIGRpcmVjdGx5LiBUbyBkZXF1ZXVlIGEgZnJhbWUsIGl0 IGNhbGxzCi0gKiBpZWVlODAyMTFfdHhfZGVxdWV1ZSgpLiBXaGVuZXZlciBtYWM4MDIxMSBhZGRz IGEgbmV3IGZyYW1lIHRvIGEgcXVldWUsIGl0Ci0gKiBjYWxscyB0aGUgLndha2VfdHhfcXVldWUg ZHJpdmVyIG9wLgorICogVGhlIGRyaXZlciBjYW4ndCBhY2Nlc3MgdGhlIHF1ZXVlIGRpcmVjdGx5 LiBUbyBkZXF1ZXVlIGEgZnJhbWUgZnJvbSBhCisgKiB0eHEsIGl0IGNhbGxzIGllZWU4MDIxMV90 eF9kZXF1ZXVlKCkuIFdoZW5ldmVyIG1hYzgwMjExIGFkZHMgYSBuZXcgZnJhbWUgdG8gYQorICog cXVldWUsIGl0IGNhbGxzIHRoZSAud2FrZV90eF9xdWV1ZSBkcml2ZXIgb3AuCisgKgorICogRHJp dmVycyBjYW4gb3B0aW9uYWxseSBkZWxlZ2F0ZSByZXNwb25zaWJpbGl0eSBmb3Igc2NoZWR1bGlu ZyBxdWV1ZXMgdG8KKyAqIG1hYzgwMjExLCB0byB0YWtlIGFkdmFudGFnZSBvZiBhaXJ0aW1lIGZh aXJuZXNzIGFjY291bnRpbmcuIEluIHRoaXMgY2FzZSwgdG8KKyAqIG9idGFpbiB0aGUgbmV4dCBx dWV1ZSB0byBwdWxsIGZyYW1lcyBmcm9tLCB0aGUgZHJpdmVyIGNhbGxzCisgKiBpZWVlODAyMTFf bmV4dF90eHEoKS4gVGhlIGRyaXZlciBpcyB0aGVuIGV4cGVjdGVkIHRvIHJldHVybiB0aGUgdHhx IHVzaW5nCisgKiBpZWVlODAyMTFfcmV0dXJuX3R4cSgpLgogICoKICAqIEZvciBBUCBwb3dlcnNh dmUgVElNIGhhbmRsaW5nLCB0aGUgZHJpdmVyIG9ubHkgbmVlZHMgdG8gaW5kaWNhdGUgaWYgaXQg aGFzCiAgKiBidWZmZXJlZCBwYWNrZXRzIGluIHRoZSBkcml2ZXIgc3BlY2lmaWMgZGF0YSBzdHJ1 Y3R1cmVzIGJ5IGNhbGxpbmcKQEAgLTYwODgsNyArNjA5NCw4IEBAIHZvaWQgaWVlZTgwMjExX3Rk bHNfb3Blcl9yZXF1ZXN0KHN0cnVjdCBpZWVlODAyMTFfdmlmICp2aWYsIGNvbnN0IHU4ICpwZWVy LAogICogaWVlZTgwMjExX3R4X2RlcXVldWUgLSBkZXF1ZXVlIGEgcGFja2V0IGZyb20gYSBzb2Z0 d2FyZSB0eCBxdWV1ZQogICoKICAqIEBodzogcG9pbnRlciBhcyBvYnRhaW5lZCBmcm9tIGllZWU4 MDIxMV9hbGxvY19odygpCi0gKiBAdHhxOiBwb2ludGVyIG9idGFpbmVkIGZyb20gc3RhdGlvbiBv ciB2aXJ0dWFsIGludGVyZmFjZQorICogQHR4cTogcG9pbnRlciBvYnRhaW5lZCBmcm9tIHN0YXRp b24gb3IgdmlydHVhbCBpbnRlcmZhY2UsIG9yIGZyb20KKyAqCWllZWU4MDIxMV9uZXh0X3R4cSgp CiAgKgogICogUmV0dXJucyB0aGUgc2tiIGlmIHN1Y2Nlc3NmdWwsICVOVUxMIGlmIG5vIGZyYW1l IHdhcyBhdmFpbGFibGUuCiAgKi8KQEAgLTYwOTYsNiArNjEwMyw1MyBAQCBzdHJ1Y3Qgc2tfYnVm ZiAqaWVlZTgwMjExX3R4X2RlcXVldWUoc3RydWN0IGllZWU4MDIxMV9odyAqaHcsCiAJCQkJICAg ICBzdHJ1Y3QgaWVlZTgwMjExX3R4cSAqdHhxKTsKIAogLyoqCisgKiBpZWVlODAyMTFfbmV4dF90 eHEgLSBnZXQgbmV4dCB0eCBxdWV1ZSB0byBwdWxsIHBhY2tldHMgZnJvbQorICoKKyAqIEBodzog cG9pbnRlciBhcyBvYnRhaW5lZCBmcm9tIGllZWU4MDIxMV9hbGxvY19odygpCisgKiBAYWM6IEFD IG51bWJlciB0byByZXR1cm4gcGFja2V0cyBmcm9tLgorICoKKyAqIFNob3VsZCBvbmx5IGJlIGNh bGxlZCBiZXR3ZWVuIGNhbGxzIHRvIGllZWU4MDIxMV90eHFfc2NoZWR1bGVfc3RhcnQoKQorICog YW5kIGllZWU4MDIxMV90eHFfc2NoZWR1bGVfZW5kKCkuCisgKiBSZXR1cm5zIHRoZSBuZXh0IHR4 cSBpZiBzdWNjZXNzZnVsLCAlTlVMTCBpZiBubyBxdWV1ZSBpcyBlbGlnaWJsZS4gSWYgYSB0eHEK KyAqIGlzIHJldHVybmVkLCBpdCBzaG91bGQgYmUgcmV0dXJuZWQgd2l0aCBpZWVlODAyMTFfcmV0 dXJuX3R4cSgpIGFmdGVyIHRoZQorICogZHJpdmVyIGhhcyBmaW5pc2hlZCBzY2hlZHVsaW5nIGl0 LgorICovCitzdHJ1Y3QgaWVlZTgwMjExX3R4cSAqaWVlZTgwMjExX25leHRfdHhxKHN0cnVjdCBp ZWVlODAyMTFfaHcgKmh3LCB1OCBhYyk7CisKKy8qKgorICogaWVlZTgwMjExX3JldHVybl90eHEg LSByZXR1cm4gYSBUWFEgcHJldmlvdXNseSBhY3F1aXJlZCBieQorICogaWVlZTgwMjExX25leHRf dHhxKCkKKyAqCisgKiBAaHc6IHBvaW50ZXIgYXMgb2J0YWluZWQgZnJvbSBpZWVlODAyMTFfYWxs b2NfaHcoKQorICogQHR4cTogcG9pbnRlciBvYnRhaW5lZCBmcm9tIHN0YXRpb24gb3IgdmlydHVh bCBpbnRlcmZhY2UKKyAqCisgKiBTaG91bGQgb25seSBiZSBjYWxsZWQgYmV0d2VlbiBjYWxscyB0 byBpZWVlODAyMTFfdHhxX3NjaGVkdWxlX3N0YXJ0KCkKKyAqIGFuZCBpZWVlODAyMTFfdHhxX3Nj aGVkdWxlX2VuZCgpLgorICovCit2b2lkIGllZWU4MDIxMV9yZXR1cm5fdHhxKHN0cnVjdCBpZWVl ODAyMTFfaHcgKmh3LCBzdHJ1Y3QgaWVlZTgwMjExX3R4cSAqdHhxKTsKKworLyoqCisgKiBpZWVl ODAyMTFfdHhxX3NjaGVkdWxlX3N0YXJ0IC0gYWNxdWlyZSBsb2NrcyBmb3Igc2FmZSBzY2hlZHVs aW5nIG9mIGFuIEFDCisgKgorICogQGh3OiBwb2ludGVyIGFzIG9idGFpbmVkIGZyb20gaWVlZTgw MjExX2FsbG9jX2h3KCkKKyAqIEBhYzogQUMgbnVtYmVyIHRvIGFjcXVpcmUgbG9ja3MgZm9yCisg KgorICogQWNxdWlyZSBsb2NrcyBuZWVkZWQgdG8gc2NoZWR1bGUgVFhRcyBmcm9tIHRoZSBnaXZl biBBQy4gU2hvdWxkIGJlIGNhbGxlZAorICogYmVmb3JlIGllZWU4MDIxMV9uZXh0X3R4cSgpIG9y IGllZWU4MDIxMV9yZXR1cm5fdHhxKCkuCisgKi8KK3ZvaWQgaWVlZTgwMjExX3R4cV9zY2hlZHVs ZV9zdGFydChzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodywgdTggYWMpOworCisvKioKKyAqIGllZWU4 MDIxMV90eHFfc2NoZWR1bGVfZW5kIC0gcmVsZWFzZSBsb2NrcyBmb3Igc2FmZSBzY2hlZHVsaW5n IG9mIGFuIEFDCisgKgorICogQGh3OiBwb2ludGVyIGFzIG9idGFpbmVkIGZyb20gaWVlZTgwMjEx X2FsbG9jX2h3KCkKKyAqIEBhYzogQUMgbnVtYmVyIHRvIGFjcXVpcmUgbG9ja3MgZm9yCisgKgor ICogUmVsZWFzZSBsb2NrcyBwcmV2aW91c2x5IGFjcXVpcmVkIGJ5IGllZWU4MDIxMV90eHFfc2No ZWR1bGVfZW5kKCkuCisgKi8KK3ZvaWQgaWVlZTgwMjExX3R4cV9zY2hlZHVsZV9lbmQoc3RydWN0 IGllZWU4MDIxMV9odyAqaHcsIHU4IGFjKTsKKworLyoqCiAgKiBpZWVlODAyMTFfdHhxX2dldF9k ZXB0aCAtIGdldCBwZW5kaW5nIGZyYW1lL2J5dGUgY291bnQgb2YgZ2l2ZW4gdHhxCiAgKgogICog VGhlIHZhbHVlcyBhcmUgbm90IGd1YXJhbnRlZWQgdG8gYmUgY29oZXJlbnQgd2l0aCByZWdhcmQg dG8gZWFjaCBvdGhlciwgaS5lLgpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL2FnZy10eC5jIGIv bmV0L21hYzgwMjExL2FnZy10eC5jCmluZGV4IDY5ZTgzMWJjMzE3Yi4uZTk0YjFhMDQwN2FmIDEw MDY0NAotLS0gYS9uZXQvbWFjODAyMTEvYWdnLXR4LmMKKysrIGIvbmV0L21hYzgwMjExL2FnZy10 eC5jCkBAIC0yMjksNyArMjI5LDcgQEAgc3RhdGljIHZvaWQgX19yZWxlYXNlcyhhZ2dfcXVldWUp CiAJY2xlYXJfYml0KElFRUU4MDIxMV9UWFFfU1RPUCwgJnR4cWktPmZsYWdzKTsKIAlsb2NhbF9i aF9kaXNhYmxlKCk7CiAJcmN1X3JlYWRfbG9jaygpOwotCWRydl93YWtlX3R4X3F1ZXVlKHN0YS0+ c2RhdGEtPmxvY2FsLCB0eHFpKTsKKwlzY2hlZHVsZV9hbmRfd2FrZV90eHEoc3RhLT5zZGF0YS0+ bG9jYWwsIHR4cWkpOwogCXJjdV9yZWFkX3VubG9jaygpOwogCWxvY2FsX2JoX2VuYWJsZSgpOwog fQpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL2RyaXZlci1vcHMuaCBiL25ldC9tYWM4MDIxMS9k cml2ZXItb3BzLmgKaW5kZXggMGIxNzQ3YTIzMTNkLi5jZTQxMzgzMjM4MjAgMTAwNjQ0Ci0tLSBh L25ldC9tYWM4MDIxMS9kcml2ZXItb3BzLmgKKysrIGIvbmV0L21hYzgwMjExL2RyaXZlci1vcHMu aApAQCAtMTE3Myw2ICsxMTczLDE1IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBkcnZfd2FrZV90eF9x dWV1ZShzdHJ1Y3QgaWVlZTgwMjExX2xvY2FsICpsb2NhbCwKIAlsb2NhbC0+b3BzLT53YWtlX3R4 X3F1ZXVlKCZsb2NhbC0+aHcsICZ0eHEtPnR4cSk7CiB9CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCBz Y2hlZHVsZV9hbmRfd2FrZV90eHEoc3RydWN0IGllZWU4MDIxMV9sb2NhbCAqbG9jYWwsCisJCQkJ CSBzdHJ1Y3QgdHhxX2luZm8gKnR4cWkpCit7CisJc3Bpbl9sb2NrX2JoKCZsb2NhbC0+YWN0aXZl X3R4cV9sb2NrW3R4cWktPnR4cS5hY10pOworCWllZWU4MDIxMV9yZXR1cm5fdHhxKCZsb2NhbC0+ aHcsICZ0eHFpLT50eHEpOworCXNwaW5fdW5sb2NrX2JoKCZsb2NhbC0+YWN0aXZlX3R4cV9sb2Nr W3R4cWktPnR4cS5hY10pOworCWRydl93YWtlX3R4X3F1ZXVlKGxvY2FsLCB0eHFpKTsKK30KKwog c3RhdGljIGlubGluZSBpbnQgZHJ2X2Nhbl9hZ2dyZWdhdGVfaW5fYW1zZHUoc3RydWN0IGllZWU4 MDIxMV9sb2NhbCAqbG9jYWwsCiAJCQkJCSAgICAgc3RydWN0IHNrX2J1ZmYgKmhlYWQsCiAJCQkJ CSAgICAgc3RydWN0IHNrX2J1ZmYgKnNrYikKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9pZWVl ODAyMTFfaS5oIGIvbmV0L21hYzgwMjExL2llZWU4MDIxMV9pLmgKaW5kZXggMTBhMDUwNjJlNGEw Li4zMzc2M2EyZWFjODEgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9pZWVlODAyMTFfaS5oCisr KyBiL25ldC9tYWM4MDIxMS9pZWVlODAyMTFfaS5oCkBAIC04MzAsNiArODMwLDggQEAgZW51bSB0 eHFfaW5mb19mbGFncyB7CiAgKglhIGZxX2Zsb3cgd2hpY2ggaXMgYWxyZWFkeSBvd25lZCBieSBh IGRpZmZlcmVudCB0aW4KICAqIEBkZWZfY3ZhcnM6IGNvZGVsIHZhcnMgZm9yIEBkZWZfZmxvdwog ICogQGZyYWdzOiB1c2VkIHRvIGtlZXAgZnJhZ21lbnRzIGNyZWF0ZWQgYWZ0ZXIgZGVxdWV1ZQor ICogQHNjaGVkdWxlX29yZGVyOiB1c2VkIHdpdGggaWVlZTgwMjExX2xvY2FsLT5hY3RpdmVfdHhx cworICogQHNjaGVkdWxlX3JvdW5kOiBjb3VudGVyIHRvIHByZXZlbnQgaW5maW5pdGUgbG9vcHMg b24gVFhRIHNjaGVkdWxpbmcKICAqLwogc3RydWN0IHR4cV9pbmZvIHsKIAlzdHJ1Y3QgZnFfdGlu IHRpbjsKQEAgLTgzNyw2ICs4MzksOCBAQCBzdHJ1Y3QgdHhxX2luZm8gewogCXN0cnVjdCBjb2Rl bF92YXJzIGRlZl9jdmFyczsKIAlzdHJ1Y3QgY29kZWxfc3RhdHMgY3N0YXRzOwogCXN0cnVjdCBz a19idWZmX2hlYWQgZnJhZ3M7CisJc3RydWN0IGxpc3RfaGVhZCBzY2hlZHVsZV9vcmRlcjsKKwl1 MTYgc2NoZWR1bGVfcm91bmQ7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCS8qIGtlZXAgbGFz dCEgKi8KQEAgLTExMjgsNiArMTEzMiwxMSBAQCBzdHJ1Y3QgaWVlZTgwMjExX2xvY2FsIHsKIAlz dHJ1Y3QgY29kZWxfdmFycyAqY3ZhcnM7CiAJc3RydWN0IGNvZGVsX3BhcmFtcyBjcGFyYW1zOwog CisJLyogcHJvdGVjdHMgYWN0aXZlX3R4cXMgYW5kIHR4cWktPnNjaGVkdWxlX29yZGVyICovCisJ c3BpbmxvY2tfdCBhY3RpdmVfdHhxX2xvY2tbSUVFRTgwMjExX05VTV9BQ1NdOworCXN0cnVjdCBs aXN0X2hlYWQgYWN0aXZlX3R4cXNbSUVFRTgwMjExX05VTV9BQ1NdOworCXUxNiBzY2hlZHVsZV9y b3VuZFtJRUVFODAyMTFfTlVNX0FDU107CisKIAljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX29wcyAq b3BzOwogCiAJLyoKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9tYWluLmMgYi9uZXQvbWFjODAy MTEvbWFpbi5jCmluZGV4IDgzZTcxZTZiMmViZS4uYmE2NDc1N2FmZWE0IDEwMDY0NAotLS0gYS9u ZXQvbWFjODAyMTEvbWFpbi5jCisrKyBiL25ldC9tYWM4MDIxMS9tYWluLmMKQEAgLTY2Myw2ICs2 NjMsMTEgQEAgc3RydWN0IGllZWU4MDIxMV9odyAqaWVlZTgwMjExX2FsbG9jX2h3X25tKHNpemVf dCBwcml2X2RhdGFfbGVuLAogCXNwaW5fbG9ja19pbml0KCZsb2NhbC0+cnhfcGF0aF9sb2NrKTsK IAlzcGluX2xvY2tfaW5pdCgmbG9jYWwtPnF1ZXVlX3N0b3BfcmVhc29uX2xvY2spOwogCisJZm9y IChpID0gMDsgaSA8IElFRUU4MDIxMV9OVU1fQUNTOyBpKyspIHsKKwkJSU5JVF9MSVNUX0hFQUQo JmxvY2FsLT5hY3RpdmVfdHhxc1tpXSk7CisJCXNwaW5fbG9ja19pbml0KCZsb2NhbC0+YWN0aXZl X3R4cV9sb2NrW2ldKTsKKwl9CisKIAlJTklUX0xJU1RfSEVBRCgmbG9jYWwtPmNoYW5jdHhfbGlz dCk7CiAJbXV0ZXhfaW5pdCgmbG9jYWwtPmNoYW5jdHhfbXR4KTsKIApkaWZmIC0tZ2l0IGEvbmV0 L21hYzgwMjExL3N0YV9pbmZvLmMgYi9uZXQvbWFjODAyMTEvc3RhX2luZm8uYwppbmRleCBmYjhj MjI1MmFjMGUuLmMyZjVjYjdkZjU0ZiAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL3N0YV9pbmZv LmMKKysrIGIvbmV0L21hYzgwMjExL3N0YV9pbmZvLmMKQEAgLTEyNDksNyArMTI0OSw3IEBAIHZv aWQgaWVlZTgwMjExX3N0YV9wc19kZWxpdmVyX3dha2V1cChzdHJ1Y3Qgc3RhX2luZm8gKnN0YSkK IAkJaWYgKCFzdGEtPnN0YS50eHFbaV0gfHwgIXR4cV9oYXNfcXVldWUoc3RhLT5zdGEudHhxW2ld KSkKIAkJCWNvbnRpbnVlOwogCi0JCWRydl93YWtlX3R4X3F1ZXVlKGxvY2FsLCB0b190eHFfaW5m byhzdGEtPnN0YS50eHFbaV0pKTsKKwkJc2NoZWR1bGVfYW5kX3dha2VfdHhxKGxvY2FsLCB0b190 eHFfaW5mbyhzdGEtPnN0YS50eHFbaV0pKTsKIAl9CiAKIAlza2JfcXVldWVfaGVhZF9pbml0KCZw ZW5kaW5nKTsKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS90eC5jIGIvbmV0L21hYzgwMjExL3R4 LmMKaW5kZXggZTBjY2VlMjNmYmNkLi4zMDU5NjUyODM1MDYgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4 MDIxMS90eC5jCisrKyBiL25ldC9tYWM4MDIxMS90eC5jCkBAIC0xNDQ5LDYgKzE0NDksNyBAQCB2 b2lkIGllZWU4MDIxMV90eHFfaW5pdChzdHJ1Y3QgaWVlZTgwMjExX3N1Yl9pZl9kYXRhICpzZGF0 YSwKIAljb2RlbF92YXJzX2luaXQoJnR4cWktPmRlZl9jdmFycyk7CiAJY29kZWxfc3RhdHNfaW5p dCgmdHhxaS0+Y3N0YXRzKTsKIAlfX3NrYl9xdWV1ZV9oZWFkX2luaXQoJnR4cWktPmZyYWdzKTsK KwlJTklUX0xJU1RfSEVBRCgmdHhxaS0+c2NoZWR1bGVfb3JkZXIpOwogCiAJdHhxaS0+dHhxLnZp ZiA9ICZzZGF0YS0+dmlmOwogCkBAIC0xNDg5LDYgKzE0OTAsOSBAQCB2b2lkIGllZWU4MDIxMV90 eHFfcHVyZ2Uoc3RydWN0IGllZWU4MDIxMV9sb2NhbCAqbG9jYWwsCiAKIAlmcV90aW5fcmVzZXQo ZnEsIHRpbiwgZnFfc2tiX2ZyZWVfZnVuYyk7CiAJaWVlZTgwMjExX3B1cmdlX3R4X3F1ZXVlKCZs b2NhbC0+aHcsICZ0eHFpLT5mcmFncyk7CisJc3Bpbl9sb2NrX2JoKCZsb2NhbC0+YWN0aXZlX3R4 cV9sb2NrW3R4cWktPnR4cS5hY10pOworCWxpc3RfZGVsX2luaXQoJnR4cWktPnNjaGVkdWxlX29y ZGVyKTsKKwlzcGluX3VubG9ja19iaCgmbG9jYWwtPmFjdGl2ZV90eHFfbG9ja1t0eHFpLT50eHEu YWNdKTsKIH0KIAogdm9pZCBpZWVlODAyMTFfdHhxX3NldF9wYXJhbXMoc3RydWN0IGllZWU4MDIx MV9sb2NhbCAqbG9jYWwpCkBAIC0xNjA1LDcgKzE2MDksNyBAQCBzdGF0aWMgYm9vbCBpZWVlODAy MTFfcXVldWVfc2tiKHN0cnVjdCBpZWVlODAyMTFfbG9jYWwgKmxvY2FsLAogCWllZWU4MDIxMV90 eHFfZW5xdWV1ZShsb2NhbCwgdHhxaSwgc2tiKTsKIAlzcGluX3VubG9ja19iaCgmZnEtPmxvY2sp OwogCi0JZHJ2X3dha2VfdHhfcXVldWUobG9jYWwsIHR4cWkpOworCXNjaGVkdWxlX2FuZF93YWtl X3R4cShsb2NhbCwgdHhxaSk7CiAKIAlyZXR1cm4gdHJ1ZTsKIH0KQEAgLTM2MjcsNiArMzYzMSw1 OCBAQCBzdHJ1Y3Qgc2tfYnVmZiAqaWVlZTgwMjExX3R4X2RlcXVldWUoc3RydWN0IGllZWU4MDIx MV9odyAqaHcsCiB9CiBFWFBPUlRfU1lNQk9MKGllZWU4MDIxMV90eF9kZXF1ZXVlKTsKIAorc3Ry dWN0IGllZWU4MDIxMV90eHEgKmllZWU4MDIxMV9uZXh0X3R4cShzdHJ1Y3QgaWVlZTgwMjExX2h3 ICpodywgdTggYWMpCit7CisJc3RydWN0IGllZWU4MDIxMV9sb2NhbCAqbG9jYWwgPSBod190b19s b2NhbChodyk7CisJc3RydWN0IHR4cV9pbmZvICp0eHFpID0gTlVMTDsKKworCWxvY2tkZXBfYXNz ZXJ0X2hlbGQoJmxvY2FsLT5hY3RpdmVfdHhxX2xvY2tbYWNdKTsKKworCXR4cWkgPSBsaXN0X2Zp cnN0X2VudHJ5X29yX251bGwoJmxvY2FsLT5hY3RpdmVfdHhxc1thY10sCisJCQkJCXN0cnVjdCB0 eHFfaW5mbywKKwkJCQkJc2NoZWR1bGVfb3JkZXIpOworCisJaWYgKCF0eHFpIHx8IHR4cWktPnNj aGVkdWxlX3JvdW5kID09IGxvY2FsLT5zY2hlZHVsZV9yb3VuZFthY10pCisJCXJldHVybiBOVUxM OworCisJbGlzdF9kZWxfaW5pdCgmdHhxaS0+c2NoZWR1bGVfb3JkZXIpOworCXR4cWktPnNjaGVk dWxlX3JvdW5kID0gbG9jYWwtPnNjaGVkdWxlX3JvdW5kW2FjXTsKKwlyZXR1cm4gJnR4cWktPnR4 cTsKK30KK0VYUE9SVF9TWU1CT0woaWVlZTgwMjExX25leHRfdHhxKTsKKwordm9pZCBpZWVlODAy MTFfcmV0dXJuX3R4cShzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodywKKwkJCSAgc3RydWN0IGllZWU4 MDIxMV90eHEgKnR4cSkKK3sKKwlzdHJ1Y3QgaWVlZTgwMjExX2xvY2FsICpsb2NhbCA9IGh3X3Rv X2xvY2FsKGh3KTsKKwlzdHJ1Y3QgdHhxX2luZm8gKnR4cWkgPSB0b190eHFfaW5mbyh0eHEpOwor CisJbG9ja2RlcF9hc3NlcnRfaGVsZCgmbG9jYWwtPmFjdGl2ZV90eHFfbG9ja1t0eHEtPmFjXSk7 CisKKwlpZiAobGlzdF9lbXB0eSgmdHhxaS0+c2NoZWR1bGVfb3JkZXIpICYmCisJICAgICghc2ti X3F1ZXVlX2VtcHR5KCZ0eHFpLT5mcmFncykgfHwgdHhxaS0+dGluLmJhY2tsb2dfcGFja2V0cykp CisJCWxpc3RfYWRkX3RhaWwoJnR4cWktPnNjaGVkdWxlX29yZGVyLAorCQkJICAgICAgJmxvY2Fs LT5hY3RpdmVfdHhxc1t0eHEtPmFjXSk7Cit9CitFWFBPUlRfU1lNQk9MKGllZWU4MDIxMV9yZXR1 cm5fdHhxKTsKKwordm9pZCBpZWVlODAyMTFfdHhxX3NjaGVkdWxlX3N0YXJ0KHN0cnVjdCBpZWVl ODAyMTFfaHcgKmh3LCB1OCBhYykKK3sKKwlzdHJ1Y3QgaWVlZTgwMjExX2xvY2FsICpsb2NhbCA9 IGh3X3RvX2xvY2FsKGh3KTsKKworCXNwaW5fbG9ja19iaCgmbG9jYWwtPmFjdGl2ZV90eHFfbG9j a1thY10pOworCWxvY2FsLT5zY2hlZHVsZV9yb3VuZFthY10rKzsKK30KK0VYUE9SVF9TWU1CT0wo aWVlZTgwMjExX3R4cV9zY2hlZHVsZV9zdGFydCk7CisKK3ZvaWQgaWVlZTgwMjExX3R4cV9zY2hl ZHVsZV9lbmQoc3RydWN0IGllZWU4MDIxMV9odyAqaHcsIHU4IGFjKQoreworCXN0cnVjdCBpZWVl ODAyMTFfbG9jYWwgKmxvY2FsID0gaHdfdG9fbG9jYWwoaHcpOworCisJc3Bpbl91bmxvY2tfYmgo JmxvY2FsLT5hY3RpdmVfdHhxX2xvY2tbYWNdKTsKK30KK0VYUE9SVF9TWU1CT0woaWVlZTgwMjEx X3R4cV9zY2hlZHVsZV9lbmQpOworCiB2b2lkIF9faWVlZTgwMjExX3N1YmlmX3N0YXJ0X3htaXQo c3RydWN0IHNrX2J1ZmYgKnNrYiwKIAkJCQkgIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJCQkJ ICB1MzIgaW5mb19mbGFncykKLS0gCjEuOS4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KYXRoMTBrIG1haWxpbmcgbGlzdAphdGgxMGtAbGlzdHMuaW5m cmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2F0 aDEwawo=