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.6 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 4FBECECDE45 for ; Sat, 20 Oct 2018 11:05:57 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 155E021528 for ; Sat, 20 Oct 2018 11:05:57 +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="EaO/XCOT"; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="KZCLfTuX" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 155E021528 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 S1727532AbeJTTP4 (ORCPT ); Sat, 20 Oct 2018 15:15:56 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:53322 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727292AbeJTTP4 (ORCPT ); Sat, 20 Oct 2018 15:15:56 -0400 Received: by smtp.codeaurora.org (Postfix, from userid 1000) id 0958D60ADB; Sat, 20 Oct 2018 11:05:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1540033550; bh=Km0GrcKzXbBTZM+YnhGdAaAgz81YOIoYUeAAez3smqA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=EaO/XCOTMxUz91RhyNGiy97vA2TF3jsCv2YNwfsJidq1axZV7zIO7q7BS6RjMlleO Qp5yseczdl6E7oW55EtH9ANhZn5c4Oqc5Qbcns18xUHEZoKCI0YRGkFGIHaSAf0UIJ ypW0zwiedptJthy1yCsZo3CaAheQzLzQO8yR23n0= 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 5C7466087F; Sat, 20 Oct 2018 11:05:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1540033547; bh=Km0GrcKzXbBTZM+YnhGdAaAgz81YOIoYUeAAez3smqA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=KZCLfTuXm1ygZUJTbFAYTSjm43flG6eu1IpZrX7TkupAlcIcDJOYDo6RFiacaGE1a +QMpBfBEfd6Zpz0VUmjF79N7sm8mrQfiAt8DR+LEsmTZ5luNxNI3OsPDZf4Uisyqhr qBHWe22dd8IqS0RZl1NHBNQTTiHpJXxAnC/vDZc4= DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org 5C7466087F 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); Sat, 20 Oct 2018 04:05:45 -0700 From: Rajkumar Manoharan To: linux-wireless@vger.kernel.org, ath10k@lists.infradead.org Cc: =?UTF-8?q?Toke=20H=C3=B8iland-J=C3=B8rgensen?= , Rajkumar Manoharan Subject: [PATCH 3/6] mac80211: Add airtime accounting and scheduling to TXQs Date: Sat, 20 Oct 2018 04:05:31 -0700 Message-Id: <1540033534-11211-4-git-send-email-rmanohar@codeaurora.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1540033534-11211-1-git-send-email-rmanohar@codeaurora.org> References: <1540033534-11211-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 airtime accounting and scheduling to the mac80211 TXQ scheduler. A new callback, ieee80211_sta_register_airtime(), is added that drivers can call to report airtime usage for stations. When airtime information is present, mac80211 will schedule TXQs (through ieee80211_next_txq()) in a way that enforces airtime fairness between active stations. This scheduling works the same way as the ath9k in-driver airtime fairness scheduling. If no airtime usage is reported by the driver, the scheduler will default to round-robin scheduling. For drivers that don't control TXQ scheduling in software, a new API function, ieee80211_txq_may_transmit(), is added which the driver can use to check if the TXQ is eligible for transmission, or should be throttled to enforce fairness. Calls to this function must also be enclosed in ieee80211_txq_schedule_{start,end}() calls to ensure proper locking. The API ieee80211_txq_may_transmit() also ensures that TXQ list will be aligned aginst driver's own round-robin scheduler list. i.e it rotates the TXQ list till it makes the requested node becomes the first entry in TXQ list. Thus both the TXQ list and driver's list are in sync. Signed-off-by: Toke Høiland-Jørgensen Signed-off-by: Rajkumar Manoharan --- include/net/mac80211.h | 58 ++++++++++++++++++++++++++++++ net/mac80211/cfg.c | 3 ++ net/mac80211/debugfs.c | 3 ++ net/mac80211/debugfs_sta.c | 50 ++++++++++++++++++++++++-- net/mac80211/ieee80211_i.h | 2 ++ net/mac80211/main.c | 4 +++ net/mac80211/sta_info.c | 45 +++++++++++++++++++++-- net/mac80211/sta_info.h | 13 +++++++ net/mac80211/status.c | 6 ++++ net/mac80211/tx.c | 90 +++++++++++++++++++++++++++++++++++++++++++--- 10 files changed, 264 insertions(+), 10 deletions(-) diff --git a/include/net/mac80211.h b/include/net/mac80211.h index 2f5c0fbd453c..0ced3adb09ac 100644 --- a/include/net/mac80211.h +++ b/include/net/mac80211.h @@ -2334,6 +2334,8 @@ enum ieee80211_hw_flags { * @tx_sk_pacing_shift: Pacing shift to set on TCP sockets when frames from * them are encountered. The default should typically not be changed, * unless the driver has good reasons for needing more buffers. + * + * @airtime_weight: Default airtime weight preferred by driver. */ struct ieee80211_hw { struct ieee80211_conf conf; @@ -2370,6 +2372,7 @@ struct ieee80211_hw { const struct ieee80211_cipher_scheme *cipher_schemes; u8 max_nan_de_entries; u8 tx_sk_pacing_shift; + u32 airtime_weight; }; static inline bool _ieee80211_hw_check(struct ieee80211_hw *hw, @@ -5350,6 +5353,34 @@ void ieee80211_sta_block_awake(struct ieee80211_hw *hw, void ieee80211_send_eosp_nullfunc(struct ieee80211_sta *pubsta, int tid); /** + * ieee80211_sta_register_airtime - register airtime usage for a sta/tid + * + * Register airtime usage for a given sta on a given tid. The driver can call + * this function to notify mac80211 that a station used a certain amount of + * airtime. This information will be used by the TXQ scheduler to schedule + * stations in a way that ensures airtime fairness. + * + * The reported airtime should as a minimum include all time that is spent + * transmitting to the remote station, including overhead and padding, but not + * including time spent waiting for a TXOP. If the time is not reported by the + * hardware it can in some cases be calculated from the rate and known frame + * composition. When possible, the time should include any failed transmission + * attempts. + * + * The driver can either call this function synchronously for every packet or + * aggregate, or asynchronously as airtime usage information becomes available. + * TX and RX airtime can be reported together, or separately by setting one of + * them to 0. + * + * @pubsta: the station + * @tid: the TID to register airtime for + * @tx_airtime: airtime used during TX (in usec) + * @rx_airtime: airtime used during RX (in usec) + */ +void ieee80211_sta_register_airtime(struct ieee80211_sta *pubsta, u8 tid, + u32 tx_airtime, u32 rx_airtime); + +/** * ieee80211_iter_keys - iterate keys programmed into the device * @hw: pointer obtained from ieee80211_alloc_hw() * @vif: virtual interface to iterate, may be %NULL for all @@ -6107,6 +6138,33 @@ struct sk_buff *ieee80211_tx_dequeue(struct ieee80211_hw *hw, void ieee80211_txq_schedule_end(struct ieee80211_hw *hw, u8 ac); /** + * ieee80211_txq_may_transmit - check whether TXQ is allowed to transmit + * + * This function is used to check whether given txq is allowed to transmit by + * the airtime scheduler, and can be used by drivers to access the airtime + * fairness accounting without going using the scheduling order enfored by + * next_txq(). + * + * Returns %true if the airtime scheduler thinks the TXQ should be allowed to + * transmit, and %false if it should be throttled. This function can also have + * the side effect of rotating the TXQ in the scheduler rotation, which will + * eventually bring the deficit to positive and allow the station to transmit + * again. + * + * The API ieee80211_txq_may_transmit() also ensures that TXQ list will be + * aligned aginst driver's own round-robin scheduler list. i.e it rotates + * the TXQ list till it makes the requested node becomes the first entry + * in TXQ list. Thus both the TXQ list and driver's list are in sync. If this + * function returns %true, the driver is expected to schedule packets + * for transmission, and then return the TXQ through ieee80211_return_txq(). + * + * @hw: pointer as obtained from ieee80211_alloc_hw() + * @txq: pointer obtained from station or virtual interface + */ +bool ieee80211_txq_may_transmit(struct ieee80211_hw *hw, + struct ieee80211_txq *txq); + +/** * 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/cfg.c b/net/mac80211/cfg.c index 914aef7e7afd..337ac2b57e59 100644 --- a/net/mac80211/cfg.c +++ b/net/mac80211/cfg.c @@ -1388,6 +1388,9 @@ static int sta_apply_parameters(struct ieee80211_local *local, if (ieee80211_vif_is_mesh(&sdata->vif)) sta_apply_mesh_params(local, sta, params); + if (params->airtime_weight) + sta->airtime_weight = params->airtime_weight; + /* set the STA state after all sta info from usermode has been set */ if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) || set & BIT(NL80211_STA_FLAG_ASSOCIATED)) { diff --git a/net/mac80211/debugfs.c b/net/mac80211/debugfs.c index 3fe541e358f3..81c5fec2eae7 100644 --- a/net/mac80211/debugfs.c +++ b/net/mac80211/debugfs.c @@ -383,6 +383,9 @@ void debugfs_hw_add(struct ieee80211_local *local) if (local->ops->wake_tx_queue) DEBUGFS_ADD_MODE(aqm, 0600); + debugfs_create_u16("airtime_flags", 0600, + phyd, &local->airtime_flags); + statsd = debugfs_create_dir("statistics", phyd); /* if the dir failed, don't put all the other things into the root! */ diff --git a/net/mac80211/debugfs_sta.c b/net/mac80211/debugfs_sta.c index af5185a836e5..446908ab3f5d 100644 --- a/net/mac80211/debugfs_sta.c +++ b/net/mac80211/debugfs_sta.c @@ -181,9 +181,9 @@ static ssize_t sta_aqm_read(struct file *file, char __user *userbuf, txqi->tin.tx_bytes, txqi->tin.tx_packets, txqi->flags, - txqi->flags & (1<flags & (1<flags & (1<flags) ? "STOP" : "RUN", + test_bit(IEEE80211_TXQ_AMPDU, &txqi->flags) ? " AMPDU" : "", + test_bit(IEEE80211_TXQ_NO_AMSDU, &txqi->flags) ? " NO-AMSDU" : ""); } rcu_read_unlock(); @@ -195,6 +195,46 @@ static ssize_t sta_aqm_read(struct file *file, char __user *userbuf, } STA_OPS(aqm); +static ssize_t sta_airtime_read(struct file *file, char __user *userbuf, + size_t count, loff_t *ppos) +{ + struct sta_info *sta = file->private_data; + struct ieee80211_local *local = sta->sdata->local; + size_t bufsz = 200; + char *buf = kzalloc(bufsz, GFP_KERNEL), *p = buf; + u64 rx_airtime = 0, tx_airtime = 0; + s64 deficit[IEEE80211_NUM_ACS]; + ssize_t rv; + int ac; + + if (!buf) + return -ENOMEM; + + for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) { + spin_lock_bh(&local->active_txq_lock[ac]); + rx_airtime += sta->airtime[ac].rx_airtime; + tx_airtime += sta->airtime[ac].tx_airtime; + deficit[ac] = sta->airtime[ac].deficit; + spin_unlock_bh(&local->active_txq_lock[ac]); + } + + p += scnprintf(p, bufsz + buf - p, + "RX: %llu us\nTX: %llu us\nWeight: %u\n" + "Deficit: VO: %lld us VI: %lld us BE: %lld us BK: %lld us\n", + rx_airtime, + tx_airtime, + sta->airtime_weight, + deficit[0], + deficit[1], + deficit[2], + deficit[3]); + + rv = simple_read_from_buffer(userbuf, count, ppos, buf, p - buf); + kfree(buf); + return rv; +} +STA_OPS(airtime); + static ssize_t sta_agg_status_read(struct file *file, char __user *userbuf, size_t count, loff_t *ppos) { @@ -906,6 +946,10 @@ void ieee80211_sta_debugfs_add(struct sta_info *sta) if (local->ops->wake_tx_queue) DEBUGFS_ADD(aqm); + if (wiphy_ext_feature_isset(local->hw.wiphy, + NL80211_EXT_FEATURE_AIRTIME_FAIRNESS)) + DEBUGFS_ADD(airtime); + if (sizeof(sta->driver_buffered_tids) == sizeof(u32)) debugfs_create_x32("driver_buffered_tids", 0400, sta->debugfs_dir, diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h index 976531717902..7abc20c0e47c 100644 --- a/net/mac80211/ieee80211_i.h +++ b/net/mac80211/ieee80211_i.h @@ -1136,6 +1136,8 @@ struct ieee80211_local { struct list_head active_txqs[IEEE80211_NUM_ACS]; u16 schedule_round[IEEE80211_NUM_ACS]; + u16 airtime_flags; + const struct ieee80211_ops *ops; /* diff --git a/net/mac80211/main.c b/net/mac80211/main.c index 3ea2369e0992..3d79f42042dd 100644 --- a/net/mac80211/main.c +++ b/net/mac80211/main.c @@ -667,6 +667,7 @@ struct ieee80211_hw *ieee80211_alloc_hw_nm(size_t priv_data_len, INIT_LIST_HEAD(&local->active_txqs[i]); spin_lock_init(&local->active_txq_lock[i]); } + local->airtime_flags = AIRTIME_USE_TX | AIRTIME_USE_RX; INIT_LIST_HEAD(&local->chanctx_list); mutex_init(&local->chanctx_mtx); @@ -1153,6 +1154,9 @@ int ieee80211_register_hw(struct ieee80211_hw *hw) if (!local->hw.max_nan_de_entries) local->hw.max_nan_de_entries = IEEE80211_MAX_NAN_INSTANCE_ID; + if (!local->hw.airtime_weight) + local->hw.airtime_weight = IEEE80211_DEFAULT_AIRTIME_WEIGHT; + result = ieee80211_wep_init(local); if (result < 0) wiphy_debug(local->hw.wiphy, "Failed to initialize wep: %d\n", diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c index c2f5cb7df54f..5a6d05063341 100644 --- a/net/mac80211/sta_info.c +++ b/net/mac80211/sta_info.c @@ -90,7 +90,6 @@ static void __cleanup_single_sta(struct sta_info *sta) struct tid_ampdu_tx *tid_tx; struct ieee80211_sub_if_data *sdata = sta->sdata; struct ieee80211_local *local = sdata->local; - struct fq *fq = &local->fq; struct ps_data *ps; if (test_sta_flag(sta, WLAN_STA_PS_STA) || @@ -120,9 +119,7 @@ static void __cleanup_single_sta(struct sta_info *sta) txqi = to_txq_info(sta->sta.txq[i]); - spin_lock_bh(&fq->lock); ieee80211_txq_purge(local, txqi); - spin_unlock_bh(&fq->lock); } } @@ -387,9 +384,12 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata, if (sta_prepare_rate_control(local, sta, gfp)) goto free_txq; + sta->airtime_weight = hw->airtime_weight; + for (i = 0; i < IEEE80211_NUM_ACS; i++) { skb_queue_head_init(&sta->ps_tx_buf[i]); skb_queue_head_init(&sta->tx_filtered[i]); + sta->airtime[i].deficit = sta->airtime_weight; } for (i = 0; i < IEEE80211_NUM_TIDS; i++) @@ -1826,6 +1826,28 @@ void ieee80211_sta_set_buffered(struct ieee80211_sta *pubsta, } EXPORT_SYMBOL(ieee80211_sta_set_buffered); +void ieee80211_sta_register_airtime(struct ieee80211_sta *pubsta, u8 tid, + u32 tx_airtime, u32 rx_airtime) +{ + struct sta_info *sta = container_of(pubsta, struct sta_info, sta); + struct ieee80211_local *local = sta->sdata->local; + struct txq_info *txqi; + u8 ac = ieee80211_ac_from_tid(tid); + u32 airtime = 0; + + if (sta->local->airtime_flags & AIRTIME_USE_TX) + airtime += tx_airtime; + if (sta->local->airtime_flags & AIRTIME_USE_RX) + airtime += rx_airtime; + + spin_lock_bh(&local->active_txq_lock[ac]); + sta->airtime[ac].tx_airtime += tx_airtime; + sta->airtime[ac].rx_airtime += rx_airtime; + sta->airtime[ac].deficit -= airtime; + spin_unlock_bh(&local->active_txq_lock[ac]); +} +EXPORT_SYMBOL(ieee80211_sta_register_airtime); + int sta_info_move_state(struct sta_info *sta, enum ieee80211_sta_state new_state) { @@ -2188,6 +2210,23 @@ void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo, sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED); } + if (!(sinfo->filled & BIT(NL80211_STA_INFO_RX_DURATION))) { + for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) + sinfo->rx_duration += sta->airtime[ac].rx_airtime; + sinfo->filled |= BIT(NL80211_STA_INFO_RX_DURATION); + } + + if (!(sinfo->filled & BIT(NL80211_STA_INFO_TX_DURATION))) { + for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) + sinfo->tx_duration += sta->airtime[ac].tx_airtime; + sinfo->filled |= BIT(NL80211_STA_INFO_TX_DURATION); + } + + if (!(sinfo->filled & BIT(NL80211_STA_INFO_AIRTIME_WEIGHT))) { + sinfo->airtime_weight = sta->airtime_weight; + sinfo->filled |= BIT(NL80211_STA_INFO_AIRTIME_WEIGHT); + } + sinfo->rx_dropped_misc = sta->rx_stats.dropped; if (sta->pcpu_rx_stats) { for_each_possible_cpu(cpu) { diff --git a/net/mac80211/sta_info.h b/net/mac80211/sta_info.h index 9a04327d71d1..b1b0fd6a2e21 100644 --- a/net/mac80211/sta_info.h +++ b/net/mac80211/sta_info.h @@ -127,6 +127,16 @@ enum ieee80211_agg_stop_reason { AGG_STOP_DESTROY_STA, }; +/* Debugfs flags to enable/disable use of RX/TX airtime in scheduler */ +#define AIRTIME_USE_TX BIT(0) +#define AIRTIME_USE_RX BIT(1) + +struct airtime_info { + u64 rx_airtime; + u64 tx_airtime; + s64 deficit; +}; + struct sta_info; /** @@ -563,6 +573,9 @@ struct sta_info { } tx_stats; u16 tid_seq[IEEE80211_QOS_CTL_TID_MASK + 1]; + struct airtime_info airtime[IEEE80211_NUM_ACS]; + u16 airtime_weight; + /* * Aggregation information, locked with lock. */ diff --git a/net/mac80211/status.c b/net/mac80211/status.c index 91d7c0cd1882..cd4582f80fea 100644 --- a/net/mac80211/status.c +++ b/net/mac80211/status.c @@ -818,6 +818,12 @@ static void __ieee80211_tx_status(struct ieee80211_hw *hw, ieee80211_sta_tx_notify(sta->sdata, (void *) skb->data, acked, info->status.tx_time); + if (info->status.tx_time && + wiphy_ext_feature_isset(local->hw.wiphy, + NL80211_EXT_FEATURE_AIRTIME_FAIRNESS)) + ieee80211_sta_register_airtime(&sta->sta, tid, + info->status.tx_time, 0); + if (ieee80211_hw_check(&local->hw, REPORTS_TX_ACK_STATUS)) { if (info->flags & IEEE80211_TX_STAT_ACK) { if (sta->status_stats.lost_packets) diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c index 305965283506..dd2354188357 100644 --- a/net/mac80211/tx.c +++ b/net/mac80211/tx.c @@ -1488,8 +1488,11 @@ void ieee80211_txq_purge(struct ieee80211_local *local, struct fq *fq = &local->fq; struct fq_tin *tin = &txqi->tin; + spin_lock_bh(&fq->lock); fq_tin_reset(fq, tin, fq_skb_free_func); ieee80211_purge_tx_queue(&local->hw, &txqi->frags); + spin_unlock_bh(&fq->lock); + 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]); @@ -3638,11 +3641,28 @@ struct ieee80211_txq *ieee80211_next_txq(struct ieee80211_hw *hw, u8 ac) lockdep_assert_held(&local->active_txq_lock[ac]); + begin: txqi = list_first_entry_or_null(&local->active_txqs[ac], struct txq_info, schedule_order); + if (!txqi) + return NULL; + + if (txqi->txq.sta) { + struct sta_info *sta = container_of(txqi->txq.sta, + struct sta_info, sta); + + if (sta->airtime[txqi->txq.ac].deficit < 0) { + sta->airtime[txqi->txq.ac].deficit += + sta->airtime_weight; + list_move_tail(&txqi->schedule_order, + &local->active_txqs[txqi->txq.ac]); + goto begin; + } + } + - if (!txqi || txqi->schedule_round == local->schedule_round[ac]) + if (txqi->schedule_round == local->schedule_round[ac]) return NULL; list_del_init(&txqi->schedule_order); @@ -3660,12 +3680,74 @@ void ieee80211_return_txq(struct ieee80211_hw *hw, 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]); + (!skb_queue_empty(&txqi->frags) || txqi->tin.backlog_packets)) { + /* If airtime accounting is active, always enqueue STAs at the + * head of the list to ensure that they only get moved to the + * back by the airtime DRR scheduler once they have a negative + * deficit. A station that already has a negative deficit will + * get immediately moved to the back of the list on the next + * call to ieee80211_next_txq(). + */ + if (wiphy_ext_feature_isset(local->hw.wiphy, + NL80211_EXT_FEATURE_AIRTIME_FAIRNESS) + && txqi->txq.sta) + list_add(&txqi->schedule_order, + &local->active_txqs[txq->ac]); + else + list_add_tail(&txqi->schedule_order, + &local->active_txqs[txq->ac]); + } } EXPORT_SYMBOL(ieee80211_return_txq); +bool ieee80211_txq_may_transmit(struct ieee80211_hw *hw, + struct ieee80211_txq *txq) +{ + struct ieee80211_local *local = hw_to_local(hw); + struct txq_info *iter, *tmp, *txqi = to_txq_info(txq); + struct sta_info *sta; + u8 ac = txq->ac; + + lockdep_assert_held(&local->active_txq_lock[ac]); + + if (!txqi->txq.sta) + goto out; + + if (list_empty(&txqi->schedule_order)) + goto out; + + list_for_each_entry_safe(iter, tmp, &local->active_txqs[ac], + schedule_order) { + if (iter == txqi) + break; + + if (!iter->txq.sta) { + list_move_tail(&iter->schedule_order, + &local->active_txqs[ac]); + continue; + } + sta = container_of(iter->txq.sta, struct sta_info, sta); + if (sta->airtime[ac].deficit < 0) + sta->airtime[ac].deficit += sta->airtime_weight; + list_move_tail(&iter->schedule_order, &local->active_txqs[ac]); + } + + sta = container_of(txqi->txq.sta, struct sta_info, sta); + if (sta->airtime[ac].deficit >= 0) + goto out; + + sta->airtime[ac].deficit += sta->airtime_weight; + list_move_tail(&txqi->schedule_order, &local->active_txqs[ac]); + + return false; +out: + if (!list_empty(&txqi->schedule_order)) + list_del_init(&txqi->schedule_order); + + return true; +} +EXPORT_SYMBOL(ieee80211_txq_may_transmit); + void ieee80211_txq_schedule_start(struct ieee80211_hw *hw, u8 ac) { struct ieee80211_local *local = hw_to_local(hw); -- 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 bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gDp4y-00085q-Sh for ath10k@lists.infradead.org; Sat, 20 Oct 2018 11:06:52 +0000 From: Rajkumar Manoharan Subject: [PATCH 3/6] mac80211: Add airtime accounting and scheduling to TXQs Date: Sat, 20 Oct 2018 04:05:31 -0700 Message-Id: <1540033534-11211-4-git-send-email-rmanohar@codeaurora.org> In-Reply-To: <1540033534-11211-1-git-send-email-rmanohar@codeaurora.org> References: <1540033534-11211-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: =?UTF-8?q?Toke=20H=C3=B8iland-J=C3=B8rgensen?= , Rajkumar Manoharan RnJvbTogVG9rZSBIw7hpbGFuZC1Kw7hyZ2Vuc2VuIDx0b2tlQHRva2UuZGs+CgpUaGlzIGFkZHMg YWlydGltZSBhY2NvdW50aW5nIGFuZCBzY2hlZHVsaW5nIHRvIHRoZSBtYWM4MDIxMSBUWFEKc2No ZWR1bGVyLiBBIG5ldyBjYWxsYmFjaywgaWVlZTgwMjExX3N0YV9yZWdpc3Rlcl9haXJ0aW1lKCks IGlzIGFkZGVkCnRoYXQgZHJpdmVycyBjYW4gY2FsbCB0byByZXBvcnQgYWlydGltZSB1c2FnZSBm b3Igc3RhdGlvbnMuCgpXaGVuIGFpcnRpbWUgaW5mb3JtYXRpb24gaXMgcHJlc2VudCwgbWFjODAy MTEgd2lsbCBzY2hlZHVsZSBUWFFzCih0aHJvdWdoIGllZWU4MDIxMV9uZXh0X3R4cSgpKSBpbiBh IHdheSB0aGF0IGVuZm9yY2VzIGFpcnRpbWUgZmFpcm5lc3MKYmV0d2VlbiBhY3RpdmUgc3RhdGlv bnMuIFRoaXMgc2NoZWR1bGluZyB3b3JrcyB0aGUgc2FtZSB3YXkgYXMgdGhlIGF0aDlrCmluLWRy aXZlciBhaXJ0aW1lIGZhaXJuZXNzIHNjaGVkdWxpbmcuIElmIG5vIGFpcnRpbWUgdXNhZ2UgaXMg cmVwb3J0ZWQKYnkgdGhlIGRyaXZlciwgdGhlIHNjaGVkdWxlciB3aWxsIGRlZmF1bHQgdG8gcm91 bmQtcm9iaW4gc2NoZWR1bGluZy4KCkZvciBkcml2ZXJzIHRoYXQgZG9uJ3QgY29udHJvbCBUWFEg c2NoZWR1bGluZyBpbiBzb2Z0d2FyZSwgYSBuZXcgQVBJCmZ1bmN0aW9uLCBpZWVlODAyMTFfdHhx X21heV90cmFuc21pdCgpLCBpcyBhZGRlZCB3aGljaCB0aGUgZHJpdmVyIGNhbiB1c2UKdG8gY2hl Y2sgaWYgdGhlIFRYUSBpcyBlbGlnaWJsZSBmb3IgdHJhbnNtaXNzaW9uLCBvciBzaG91bGQgYmUg dGhyb3R0bGVkIHRvCmVuZm9yY2UgZmFpcm5lc3MuIENhbGxzIHRvIHRoaXMgZnVuY3Rpb24gbXVz dCBhbHNvIGJlIGVuY2xvc2VkIGluCmllZWU4MDIxMV90eHFfc2NoZWR1bGVfe3N0YXJ0LGVuZH0o KSBjYWxscyB0byBlbnN1cmUgcHJvcGVyIGxvY2tpbmcuCgpUaGUgQVBJIGllZWU4MDIxMV90eHFf bWF5X3RyYW5zbWl0KCkgYWxzbyBlbnN1cmVzIHRoYXQgVFhRIGxpc3Qgd2lsbCBiZQphbGlnbmVk IGFnaW5zdCBkcml2ZXIncyBvd24gcm91bmQtcm9iaW4gc2NoZWR1bGVyIGxpc3QuIGkuZSBpdCBy b3RhdGVzCnRoZSBUWFEgbGlzdCB0aWxsIGl0IG1ha2VzIHRoZSByZXF1ZXN0ZWQgbm9kZSBiZWNv bWVzIHRoZSBmaXJzdCBlbnRyeQppbiBUWFEgbGlzdC4gVGh1cyBib3RoIHRoZSBUWFEgbGlzdCBh bmQgZHJpdmVyJ3MgbGlzdCBhcmUgaW4gc3luYy4KClNpZ25lZC1vZmYtYnk6IFRva2UgSMO4aWxh bmQtSsO4cmdlbnNlbiA8dG9rZUB0b2tlLmRrPgpTaWduZWQtb2ZmLWJ5OiBSYWprdW1hciBNYW5v aGFyYW4gPHJtYW5vaGFyQGNvZGVhdXJvcmEub3JnPgotLS0KIGluY2x1ZGUvbmV0L21hYzgwMjEx LmggICAgIHwgNTggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBuZXQvbWFjODAyMTEv Y2ZnLmMgICAgICAgICB8ICAzICsrCiBuZXQvbWFjODAyMTEvZGVidWdmcy5jICAgICB8ICAzICsr CiBuZXQvbWFjODAyMTEvZGVidWdmc19zdGEuYyB8IDUwICsrKysrKysrKysrKysrKysrKysrKysr Ky0tCiBuZXQvbWFjODAyMTEvaWVlZTgwMjExX2kuaCB8ICAyICsrCiBuZXQvbWFjODAyMTEvbWFp bi5jICAgICAgICB8ICA0ICsrKwogbmV0L21hYzgwMjExL3N0YV9pbmZvLmMgICAgfCA0NSArKysr KysrKysrKysrKysrKysrKystLQogbmV0L21hYzgwMjExL3N0YV9pbmZvLmggICAgfCAxMyArKysr KysrCiBuZXQvbWFjODAyMTEvc3RhdHVzLmMgICAgICB8ICA2ICsrKysKIG5ldC9tYWM4MDIxMS90 eC5jICAgICAgICAgIHwgOTAgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKy0tLQogMTAgZmlsZXMgY2hhbmdlZCwgMjY0IGluc2VydGlvbnMoKyksIDEwIGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L21hYzgwMjExLmggYi9pbmNsdWRlL25ldC9t YWM4MDIxMS5oCmluZGV4IDJmNWMwZmJkNDUzYy4uMGNlZDNhZGIwOWFjIDEwMDY0NAotLS0gYS9p bmNsdWRlL25ldC9tYWM4MDIxMS5oCisrKyBiL2luY2x1ZGUvbmV0L21hYzgwMjExLmgKQEAgLTIz MzQsNiArMjMzNCw4IEBAIGVudW0gaWVlZTgwMjExX2h3X2ZsYWdzIHsKICAqIEB0eF9za19wYWNp bmdfc2hpZnQ6IFBhY2luZyBzaGlmdCB0byBzZXQgb24gVENQIHNvY2tldHMgd2hlbiBmcmFtZXMg ZnJvbQogICoJdGhlbSBhcmUgZW5jb3VudGVyZWQuIFRoZSBkZWZhdWx0IHNob3VsZCB0eXBpY2Fs bHkgbm90IGJlIGNoYW5nZWQsCiAgKgl1bmxlc3MgdGhlIGRyaXZlciBoYXMgZ29vZCByZWFzb25z IGZvciBuZWVkaW5nIG1vcmUgYnVmZmVycy4KKyAqCisgKiBAYWlydGltZV93ZWlnaHQ6IERlZmF1 bHQgYWlydGltZSB3ZWlnaHQgcHJlZmVycmVkIGJ5IGRyaXZlci4KICAqLwogc3RydWN0IGllZWU4 MDIxMV9odyB7CiAJc3RydWN0IGllZWU4MDIxMV9jb25mIGNvbmY7CkBAIC0yMzcwLDYgKzIzNzIs NyBAQCBzdHJ1Y3QgaWVlZTgwMjExX2h3IHsKIAljb25zdCBzdHJ1Y3QgaWVlZTgwMjExX2NpcGhl cl9zY2hlbWUgKmNpcGhlcl9zY2hlbWVzOwogCXU4IG1heF9uYW5fZGVfZW50cmllczsKIAl1OCB0 eF9za19wYWNpbmdfc2hpZnQ7CisJdTMyIGFpcnRpbWVfd2VpZ2h0OwogfTsKIAogc3RhdGljIGlu bGluZSBib29sIF9pZWVlODAyMTFfaHdfY2hlY2soc3RydWN0IGllZWU4MDIxMV9odyAqaHcsCkBA IC01MzUwLDYgKzUzNTMsMzQgQEAgdm9pZCBpZWVlODAyMTFfc3RhX2Jsb2NrX2F3YWtlKHN0cnVj dCBpZWVlODAyMTFfaHcgKmh3LAogdm9pZCBpZWVlODAyMTFfc2VuZF9lb3NwX251bGxmdW5jKHN0 cnVjdCBpZWVlODAyMTFfc3RhICpwdWJzdGEsIGludCB0aWQpOwogCiAvKioKKyAqIGllZWU4MDIx MV9zdGFfcmVnaXN0ZXJfYWlydGltZSAtIHJlZ2lzdGVyIGFpcnRpbWUgdXNhZ2UgZm9yIGEgc3Rh L3RpZAorICoKKyAqIFJlZ2lzdGVyIGFpcnRpbWUgdXNhZ2UgZm9yIGEgZ2l2ZW4gc3RhIG9uIGEg Z2l2ZW4gdGlkLiBUaGUgZHJpdmVyIGNhbiBjYWxsCisgKiB0aGlzIGZ1bmN0aW9uIHRvIG5vdGlm eSBtYWM4MDIxMSB0aGF0IGEgc3RhdGlvbiB1c2VkIGEgY2VydGFpbiBhbW91bnQgb2YKKyAqIGFp cnRpbWUuIFRoaXMgaW5mb3JtYXRpb24gd2lsbCBiZSB1c2VkIGJ5IHRoZSBUWFEgc2NoZWR1bGVy IHRvIHNjaGVkdWxlCisgKiBzdGF0aW9ucyBpbiBhIHdheSB0aGF0IGVuc3VyZXMgYWlydGltZSBm YWlybmVzcy4KKyAqCisgKiBUaGUgcmVwb3J0ZWQgYWlydGltZSBzaG91bGQgYXMgYSBtaW5pbXVt IGluY2x1ZGUgYWxsIHRpbWUgdGhhdCBpcyBzcGVudAorICogdHJhbnNtaXR0aW5nIHRvIHRoZSBy ZW1vdGUgc3RhdGlvbiwgaW5jbHVkaW5nIG92ZXJoZWFkIGFuZCBwYWRkaW5nLCBidXQgbm90Cisg KiBpbmNsdWRpbmcgdGltZSBzcGVudCB3YWl0aW5nIGZvciBhIFRYT1AuIElmIHRoZSB0aW1lIGlz IG5vdCByZXBvcnRlZCBieSB0aGUKKyAqIGhhcmR3YXJlIGl0IGNhbiBpbiBzb21lIGNhc2VzIGJl IGNhbGN1bGF0ZWQgZnJvbSB0aGUgcmF0ZSBhbmQga25vd24gZnJhbWUKKyAqIGNvbXBvc2l0aW9u LiBXaGVuIHBvc3NpYmxlLCB0aGUgdGltZSBzaG91bGQgaW5jbHVkZSBhbnkgZmFpbGVkIHRyYW5z bWlzc2lvbgorICogYXR0ZW1wdHMuCisgKgorICogVGhlIGRyaXZlciBjYW4gZWl0aGVyIGNhbGwg dGhpcyBmdW5jdGlvbiBzeW5jaHJvbm91c2x5IGZvciBldmVyeSBwYWNrZXQgb3IKKyAqIGFnZ3Jl Z2F0ZSwgb3IgYXN5bmNocm9ub3VzbHkgYXMgYWlydGltZSB1c2FnZSBpbmZvcm1hdGlvbiBiZWNv bWVzIGF2YWlsYWJsZS4KKyAqIFRYIGFuZCBSWCBhaXJ0aW1lIGNhbiBiZSByZXBvcnRlZCB0b2dl dGhlciwgb3Igc2VwYXJhdGVseSBieSBzZXR0aW5nIG9uZSBvZgorICogdGhlbSB0byAwLgorICoK KyAqIEBwdWJzdGE6IHRoZSBzdGF0aW9uCisgKiBAdGlkOiB0aGUgVElEIHRvIHJlZ2lzdGVyIGFp cnRpbWUgZm9yCisgKiBAdHhfYWlydGltZTogYWlydGltZSB1c2VkIGR1cmluZyBUWCAoaW4gdXNl YykKKyAqIEByeF9haXJ0aW1lOiBhaXJ0aW1lIHVzZWQgZHVyaW5nIFJYIChpbiB1c2VjKQorICov Cit2b2lkIGllZWU4MDIxMV9zdGFfcmVnaXN0ZXJfYWlydGltZShzdHJ1Y3QgaWVlZTgwMjExX3N0 YSAqcHVic3RhLCB1OCB0aWQsCisJCQkJICAgIHUzMiB0eF9haXJ0aW1lLCB1MzIgcnhfYWlydGlt ZSk7CisKKy8qKgogICogaWVlZTgwMjExX2l0ZXJfa2V5cyAtIGl0ZXJhdGUga2V5cyBwcm9ncmFt bWVkIGludG8gdGhlIGRldmljZQogICogQGh3OiBwb2ludGVyIG9idGFpbmVkIGZyb20gaWVlZTgw MjExX2FsbG9jX2h3KCkKICAqIEB2aWY6IHZpcnR1YWwgaW50ZXJmYWNlIHRvIGl0ZXJhdGUsIG1h eSBiZSAlTlVMTCBmb3IgYWxsCkBAIC02MTA3LDYgKzYxMzgsMzMgQEAgc3RydWN0IHNrX2J1ZmYg KmllZWU4MDIxMV90eF9kZXF1ZXVlKHN0cnVjdCBpZWVlODAyMTFfaHcgKmh3LAogdm9pZCBpZWVl ODAyMTFfdHhxX3NjaGVkdWxlX2VuZChzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodywgdTggYWMpOwog CiAvKioKKyAqIGllZWU4MDIxMV90eHFfbWF5X3RyYW5zbWl0IC0gY2hlY2sgd2hldGhlciBUWFEg aXMgYWxsb3dlZCB0byB0cmFuc21pdAorICoKKyAqIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB0byBj aGVjayB3aGV0aGVyIGdpdmVuIHR4cSBpcyBhbGxvd2VkIHRvIHRyYW5zbWl0IGJ5CisgKiB0aGUg YWlydGltZSBzY2hlZHVsZXIsIGFuZCBjYW4gYmUgdXNlZCBieSBkcml2ZXJzIHRvIGFjY2VzcyB0 aGUgYWlydGltZQorICogZmFpcm5lc3MgYWNjb3VudGluZyB3aXRob3V0IGdvaW5nIHVzaW5nIHRo ZSBzY2hlZHVsaW5nIG9yZGVyIGVuZm9yZWQgYnkKKyAqIG5leHRfdHhxKCkuCisgKgorICogUmV0 dXJucyAldHJ1ZSBpZiB0aGUgYWlydGltZSBzY2hlZHVsZXIgdGhpbmtzIHRoZSBUWFEgc2hvdWxk IGJlIGFsbG93ZWQgdG8KKyAqIHRyYW5zbWl0LCBhbmQgJWZhbHNlIGlmIGl0IHNob3VsZCBiZSB0 aHJvdHRsZWQuIFRoaXMgZnVuY3Rpb24gY2FuIGFsc28gaGF2ZQorICogdGhlIHNpZGUgZWZmZWN0 IG9mIHJvdGF0aW5nIHRoZSBUWFEgaW4gdGhlIHNjaGVkdWxlciByb3RhdGlvbiwgd2hpY2ggd2ls bAorICogZXZlbnR1YWxseSBicmluZyB0aGUgZGVmaWNpdCB0byBwb3NpdGl2ZSBhbmQgYWxsb3cg dGhlIHN0YXRpb24gdG8gdHJhbnNtaXQKKyAqIGFnYWluLgorICoKKyAqIFRoZSBBUEkgaWVlZTgw MjExX3R4cV9tYXlfdHJhbnNtaXQoKSBhbHNvIGVuc3VyZXMgdGhhdCBUWFEgbGlzdCB3aWxsIGJl CisgKiBhbGlnbmVkIGFnaW5zdCBkcml2ZXIncyBvd24gcm91bmQtcm9iaW4gc2NoZWR1bGVyIGxp c3QuIGkuZSBpdCByb3RhdGVzCisgKiB0aGUgVFhRIGxpc3QgdGlsbCBpdCBtYWtlcyB0aGUgcmVx dWVzdGVkIG5vZGUgYmVjb21lcyB0aGUgZmlyc3QgZW50cnkKKyAqIGluIFRYUSBsaXN0LiBUaHVz IGJvdGggdGhlIFRYUSBsaXN0IGFuZCBkcml2ZXIncyBsaXN0IGFyZSBpbiBzeW5jLiBJZiB0aGlz CisgKiBmdW5jdGlvbiByZXR1cm5zICV0cnVlLCB0aGUgZHJpdmVyIGlzIGV4cGVjdGVkIHRvIHNj aGVkdWxlIHBhY2tldHMKKyAqIGZvciB0cmFuc21pc3Npb24sIGFuZCB0aGVuIHJldHVybiB0aGUg VFhRIHRocm91Z2ggaWVlZTgwMjExX3JldHVybl90eHEoKS4KKyAqCisgKiBAaHc6IHBvaW50ZXIg YXMgb2J0YWluZWQgZnJvbSBpZWVlODAyMTFfYWxsb2NfaHcoKQorICogQHR4cTogcG9pbnRlciBv YnRhaW5lZCBmcm9tIHN0YXRpb24gb3IgdmlydHVhbCBpbnRlcmZhY2UKKyAqLworYm9vbCBpZWVl ODAyMTFfdHhxX21heV90cmFuc21pdChzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodywKKwkJCQlzdHJ1 Y3QgaWVlZTgwMjExX3R4cSAqdHhxKTsKKworLyoqCiAgKiBpZWVlODAyMTFfdHhxX2dldF9kZXB0 aCAtIGdldCBwZW5kaW5nIGZyYW1lL2J5dGUgY291bnQgb2YgZ2l2ZW4gdHhxCiAgKgogICogVGhl IHZhbHVlcyBhcmUgbm90IGd1YXJhbnRlZWQgdG8gYmUgY29oZXJlbnQgd2l0aCByZWdhcmQgdG8g ZWFjaCBvdGhlciwgaS5lLgpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL2NmZy5jIGIvbmV0L21h YzgwMjExL2NmZy5jCmluZGV4IDkxNGFlZjdlN2FmZC4uMzM3YWMyYjU3ZTU5IDEwMDY0NAotLS0g YS9uZXQvbWFjODAyMTEvY2ZnLmMKKysrIGIvbmV0L21hYzgwMjExL2NmZy5jCkBAIC0xMzg4LDYg KzEzODgsOSBAQCBzdGF0aWMgaW50IHN0YV9hcHBseV9wYXJhbWV0ZXJzKHN0cnVjdCBpZWVlODAy MTFfbG9jYWwgKmxvY2FsLAogCWlmIChpZWVlODAyMTFfdmlmX2lzX21lc2goJnNkYXRhLT52aWYp KQogCQlzdGFfYXBwbHlfbWVzaF9wYXJhbXMobG9jYWwsIHN0YSwgcGFyYW1zKTsKIAorCWlmIChw YXJhbXMtPmFpcnRpbWVfd2VpZ2h0KQorCQlzdGEtPmFpcnRpbWVfd2VpZ2h0ID0gcGFyYW1zLT5h aXJ0aW1lX3dlaWdodDsKKwogCS8qIHNldCB0aGUgU1RBIHN0YXRlIGFmdGVyIGFsbCBzdGEgaW5m byBmcm9tIHVzZXJtb2RlIGhhcyBiZWVuIHNldCAqLwogCWlmICh0ZXN0X3N0YV9mbGFnKHN0YSwg V0xBTl9TVEFfVERMU19QRUVSKSB8fAogCSAgICBzZXQgJiBCSVQoTkw4MDIxMV9TVEFfRkxBR19B U1NPQ0lBVEVEKSkgewpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL2RlYnVnZnMuYyBiL25ldC9t YWM4MDIxMS9kZWJ1Z2ZzLmMKaW5kZXggM2ZlNTQxZTM1OGYzLi44MWM1ZmVjMmVhZTcgMTAwNjQ0 Ci0tLSBhL25ldC9tYWM4MDIxMS9kZWJ1Z2ZzLmMKKysrIGIvbmV0L21hYzgwMjExL2RlYnVnZnMu YwpAQCAtMzgzLDYgKzM4Myw5IEBAIHZvaWQgZGVidWdmc19od19hZGQoc3RydWN0IGllZWU4MDIx MV9sb2NhbCAqbG9jYWwpCiAJaWYgKGxvY2FsLT5vcHMtPndha2VfdHhfcXVldWUpCiAJCURFQlVH RlNfQUREX01PREUoYXFtLCAwNjAwKTsKIAorCWRlYnVnZnNfY3JlYXRlX3UxNigiYWlydGltZV9m bGFncyIsIDA2MDAsCisJCQkgICBwaHlkLCAmbG9jYWwtPmFpcnRpbWVfZmxhZ3MpOworCiAJc3Rh dHNkID0gZGVidWdmc19jcmVhdGVfZGlyKCJzdGF0aXN0aWNzIiwgcGh5ZCk7CiAKIAkvKiBpZiB0 aGUgZGlyIGZhaWxlZCwgZG9uJ3QgcHV0IGFsbCB0aGUgb3RoZXIgdGhpbmdzIGludG8gdGhlIHJv b3QhICovCmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvZGVidWdmc19zdGEuYyBiL25ldC9tYWM4 MDIxMS9kZWJ1Z2ZzX3N0YS5jCmluZGV4IGFmNTE4NWE4MzZlNS4uNDQ2OTA4YWIzZjVkIDEwMDY0 NAotLS0gYS9uZXQvbWFjODAyMTEvZGVidWdmc19zdGEuYworKysgYi9uZXQvbWFjODAyMTEvZGVi dWdmc19zdGEuYwpAQCAtMTgxLDkgKzE4MSw5IEBAIHN0YXRpYyBzc2l6ZV90IHN0YV9hcW1fcmVh ZChzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciBfX3VzZXIgKnVzZXJidWYsCiAJCQkgICAgICAgdHhx aS0+dGluLnR4X2J5dGVzLAogCQkJICAgICAgIHR4cWktPnRpbi50eF9wYWNrZXRzLAogCQkJICAg ICAgIHR4cWktPmZsYWdzLAotCQkJICAgICAgIHR4cWktPmZsYWdzICYgKDE8PElFRUU4MDIxMV9U WFFfU1RPUCkgPyAiU1RPUCIgOiAiUlVOIiwKLQkJCSAgICAgICB0eHFpLT5mbGFncyAmICgxPDxJ RUVFODAyMTFfVFhRX0FNUERVKSA/ICIgQU1QRFUiIDogIiIsCi0JCQkgICAgICAgdHhxaS0+Zmxh Z3MgJiAoMTw8SUVFRTgwMjExX1RYUV9OT19BTVNEVSkgPyAiIE5PLUFNU0RVIiA6ICIiKTsKKwkJ CSAgICAgICB0ZXN0X2JpdChJRUVFODAyMTFfVFhRX1NUT1AsICZ0eHFpLT5mbGFncykgPyAiU1RP UCIgOiAiUlVOIiwKKwkJCSAgICAgICB0ZXN0X2JpdChJRUVFODAyMTFfVFhRX0FNUERVLCAmdHhx aS0+ZmxhZ3MpID8gIiBBTVBEVSIgOiAiIiwKKwkJCSAgICAgICB0ZXN0X2JpdChJRUVFODAyMTFf VFhRX05PX0FNU0RVLCAmdHhxaS0+ZmxhZ3MpID8gIiBOTy1BTVNEVSIgOiAiIik7CiAJfQogCiAJ cmN1X3JlYWRfdW5sb2NrKCk7CkBAIC0xOTUsNiArMTk1LDQ2IEBAIHN0YXRpYyBzc2l6ZV90IHN0 YV9hcW1fcmVhZChzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciBfX3VzZXIgKnVzZXJidWYsCiB9CiBT VEFfT1BTKGFxbSk7CiAKK3N0YXRpYyBzc2l6ZV90IHN0YV9haXJ0aW1lX3JlYWQoc3RydWN0IGZp bGUgKmZpbGUsIGNoYXIgX191c2VyICp1c2VyYnVmLAorCQkJCXNpemVfdCBjb3VudCwgbG9mZl90 ICpwcG9zKQoreworCXN0cnVjdCBzdGFfaW5mbyAqc3RhID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwor CXN0cnVjdCBpZWVlODAyMTFfbG9jYWwgKmxvY2FsID0gc3RhLT5zZGF0YS0+bG9jYWw7CisJc2l6 ZV90IGJ1ZnN6ID0gMjAwOworCWNoYXIgKmJ1ZiA9IGt6YWxsb2MoYnVmc3osIEdGUF9LRVJORUwp LCAqcCA9IGJ1ZjsKKwl1NjQgcnhfYWlydGltZSA9IDAsIHR4X2FpcnRpbWUgPSAwOworCXM2NCBk ZWZpY2l0W0lFRUU4MDIxMV9OVU1fQUNTXTsKKwlzc2l6ZV90IHJ2OworCWludCBhYzsKKworCWlm ICghYnVmKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWZvciAoYWMgPSAwOyBhYyA8IElFRUU4MDIx MV9OVU1fQUNTOyBhYysrKSB7CisJCXNwaW5fbG9ja19iaCgmbG9jYWwtPmFjdGl2ZV90eHFfbG9j a1thY10pOworCQlyeF9haXJ0aW1lICs9IHN0YS0+YWlydGltZVthY10ucnhfYWlydGltZTsKKwkJ dHhfYWlydGltZSArPSBzdGEtPmFpcnRpbWVbYWNdLnR4X2FpcnRpbWU7CisJCWRlZmljaXRbYWNd ID0gc3RhLT5haXJ0aW1lW2FjXS5kZWZpY2l0OworCQlzcGluX3VubG9ja19iaCgmbG9jYWwtPmFj dGl2ZV90eHFfbG9ja1thY10pOworCX0KKworCXAgKz0gc2NucHJpbnRmKHAsIGJ1ZnN6ICsgYnVm IC0gcCwKKwkJIlJYOiAlbGx1IHVzXG5UWDogJWxsdSB1c1xuV2VpZ2h0OiAldVxuIgorCQkiRGVm aWNpdDogVk86ICVsbGQgdXMgVkk6ICVsbGQgdXMgQkU6ICVsbGQgdXMgQks6ICVsbGQgdXNcbiIs CisJCXJ4X2FpcnRpbWUsCisJCXR4X2FpcnRpbWUsCisJCXN0YS0+YWlydGltZV93ZWlnaHQsCisJ CWRlZmljaXRbMF0sCisJCWRlZmljaXRbMV0sCisJCWRlZmljaXRbMl0sCisJCWRlZmljaXRbM10p OworCisJcnYgPSBzaW1wbGVfcmVhZF9mcm9tX2J1ZmZlcih1c2VyYnVmLCBjb3VudCwgcHBvcywg YnVmLCBwIC0gYnVmKTsKKwlrZnJlZShidWYpOworCXJldHVybiBydjsKK30KK1NUQV9PUFMoYWly dGltZSk7CisKIHN0YXRpYyBzc2l6ZV90IHN0YV9hZ2dfc3RhdHVzX3JlYWQoc3RydWN0IGZpbGUg KmZpbGUsIGNoYXIgX191c2VyICp1c2VyYnVmLAogCQkJCQlzaXplX3QgY291bnQsIGxvZmZfdCAq cHBvcykKIHsKQEAgLTkwNiw2ICs5NDYsMTAgQEAgdm9pZCBpZWVlODAyMTFfc3RhX2RlYnVnZnNf YWRkKHN0cnVjdCBzdGFfaW5mbyAqc3RhKQogCWlmIChsb2NhbC0+b3BzLT53YWtlX3R4X3F1ZXVl KQogCQlERUJVR0ZTX0FERChhcW0pOwogCisJaWYgKHdpcGh5X2V4dF9mZWF0dXJlX2lzc2V0KGxv Y2FsLT5ody53aXBoeSwKKwkJCQkgICAgTkw4MDIxMV9FWFRfRkVBVFVSRV9BSVJUSU1FX0ZBSVJO RVNTKSkKKwkJREVCVUdGU19BREQoYWlydGltZSk7CisKIAlpZiAoc2l6ZW9mKHN0YS0+ZHJpdmVy X2J1ZmZlcmVkX3RpZHMpID09IHNpemVvZih1MzIpKQogCQlkZWJ1Z2ZzX2NyZWF0ZV94MzIoImRy aXZlcl9idWZmZXJlZF90aWRzIiwgMDQwMCwKIAkJCQkgICBzdGEtPmRlYnVnZnNfZGlyLApkaWZm IC0tZ2l0IGEvbmV0L21hYzgwMjExL2llZWU4MDIxMV9pLmggYi9uZXQvbWFjODAyMTEvaWVlZTgw MjExX2kuaAppbmRleCA5NzY1MzE3MTc5MDIuLjdhYmMyMGMwZTQ3YyAxMDA2NDQKLS0tIGEvbmV0 L21hYzgwMjExL2llZWU4MDIxMV9pLmgKKysrIGIvbmV0L21hYzgwMjExL2llZWU4MDIxMV9pLmgK QEAgLTExMzYsNiArMTEzNiw4IEBAIHN0cnVjdCBpZWVlODAyMTFfbG9jYWwgewogCXN0cnVjdCBs aXN0X2hlYWQgYWN0aXZlX3R4cXNbSUVFRTgwMjExX05VTV9BQ1NdOwogCXUxNiBzY2hlZHVsZV9y b3VuZFtJRUVFODAyMTFfTlVNX0FDU107CiAKKwl1MTYgYWlydGltZV9mbGFnczsKKwogCWNvbnN0 IHN0cnVjdCBpZWVlODAyMTFfb3BzICpvcHM7CiAKIAkvKgpkaWZmIC0tZ2l0IGEvbmV0L21hYzgw MjExL21haW4uYyBiL25ldC9tYWM4MDIxMS9tYWluLmMKaW5kZXggM2VhMjM2OWUwOTkyLi4zZDc5 ZjQyMDQyZGQgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9tYWluLmMKKysrIGIvbmV0L21hYzgw MjExL21haW4uYwpAQCAtNjY3LDYgKzY2Nyw3IEBAIHN0cnVjdCBpZWVlODAyMTFfaHcgKmllZWU4 MDIxMV9hbGxvY19od19ubShzaXplX3QgcHJpdl9kYXRhX2xlbiwKIAkJSU5JVF9MSVNUX0hFQUQo JmxvY2FsLT5hY3RpdmVfdHhxc1tpXSk7CiAJCXNwaW5fbG9ja19pbml0KCZsb2NhbC0+YWN0aXZl X3R4cV9sb2NrW2ldKTsKIAl9CisJbG9jYWwtPmFpcnRpbWVfZmxhZ3MgPSBBSVJUSU1FX1VTRV9U WCB8IEFJUlRJTUVfVVNFX1JYOwogCiAJSU5JVF9MSVNUX0hFQUQoJmxvY2FsLT5jaGFuY3R4X2xp c3QpOwogCW11dGV4X2luaXQoJmxvY2FsLT5jaGFuY3R4X210eCk7CkBAIC0xMTUzLDYgKzExNTQs OSBAQCBpbnQgaWVlZTgwMjExX3JlZ2lzdGVyX2h3KHN0cnVjdCBpZWVlODAyMTFfaHcgKmh3KQog CWlmICghbG9jYWwtPmh3Lm1heF9uYW5fZGVfZW50cmllcykKIAkJbG9jYWwtPmh3Lm1heF9uYW5f ZGVfZW50cmllcyA9IElFRUU4MDIxMV9NQVhfTkFOX0lOU1RBTkNFX0lEOwogCisJaWYgKCFsb2Nh bC0+aHcuYWlydGltZV93ZWlnaHQpCisJCWxvY2FsLT5ody5haXJ0aW1lX3dlaWdodCA9IElFRUU4 MDIxMV9ERUZBVUxUX0FJUlRJTUVfV0VJR0hUOworCiAJcmVzdWx0ID0gaWVlZTgwMjExX3dlcF9p bml0KGxvY2FsKTsKIAlpZiAocmVzdWx0IDwgMCkKIAkJd2lwaHlfZGVidWcobG9jYWwtPmh3Lndp cGh5LCAiRmFpbGVkIHRvIGluaXRpYWxpemUgd2VwOiAlZFxuIiwKZGlmZiAtLWdpdCBhL25ldC9t YWM4MDIxMS9zdGFfaW5mby5jIGIvbmV0L21hYzgwMjExL3N0YV9pbmZvLmMKaW5kZXggYzJmNWNi N2RmNTRmLi41YTZkMDUwNjMzNDEgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9zdGFfaW5mby5j CisrKyBiL25ldC9tYWM4MDIxMS9zdGFfaW5mby5jCkBAIC05MCw3ICs5MCw2IEBAIHN0YXRpYyB2 b2lkIF9fY2xlYW51cF9zaW5nbGVfc3RhKHN0cnVjdCBzdGFfaW5mbyAqc3RhKQogCXN0cnVjdCB0 aWRfYW1wZHVfdHggKnRpZF90eDsKIAlzdHJ1Y3QgaWVlZTgwMjExX3N1Yl9pZl9kYXRhICpzZGF0 YSA9IHN0YS0+c2RhdGE7CiAJc3RydWN0IGllZWU4MDIxMV9sb2NhbCAqbG9jYWwgPSBzZGF0YS0+ bG9jYWw7Ci0Jc3RydWN0IGZxICpmcSA9ICZsb2NhbC0+ZnE7CiAJc3RydWN0IHBzX2RhdGEgKnBz OwogCiAJaWYgKHRlc3Rfc3RhX2ZsYWcoc3RhLCBXTEFOX1NUQV9QU19TVEEpIHx8CkBAIC0xMjAs OSArMTE5LDcgQEAgc3RhdGljIHZvaWQgX19jbGVhbnVwX3NpbmdsZV9zdGEoc3RydWN0IHN0YV9p bmZvICpzdGEpCiAKIAkJCXR4cWkgPSB0b190eHFfaW5mbyhzdGEtPnN0YS50eHFbaV0pOwogCi0J CQlzcGluX2xvY2tfYmgoJmZxLT5sb2NrKTsKIAkJCWllZWU4MDIxMV90eHFfcHVyZ2UobG9jYWws IHR4cWkpOwotCQkJc3Bpbl91bmxvY2tfYmgoJmZxLT5sb2NrKTsKIAkJfQogCX0KIApAQCAtMzg3 LDkgKzM4NCwxMiBAQCBzdHJ1Y3Qgc3RhX2luZm8gKnN0YV9pbmZvX2FsbG9jKHN0cnVjdCBpZWVl ODAyMTFfc3ViX2lmX2RhdGEgKnNkYXRhLAogCWlmIChzdGFfcHJlcGFyZV9yYXRlX2NvbnRyb2wo bG9jYWwsIHN0YSwgZ2ZwKSkKIAkJZ290byBmcmVlX3R4cTsKIAorCXN0YS0+YWlydGltZV93ZWln aHQgPSBody0+YWlydGltZV93ZWlnaHQ7CisKIAlmb3IgKGkgPSAwOyBpIDwgSUVFRTgwMjExX05V TV9BQ1M7IGkrKykgewogCQlza2JfcXVldWVfaGVhZF9pbml0KCZzdGEtPnBzX3R4X2J1ZltpXSk7 CiAJCXNrYl9xdWV1ZV9oZWFkX2luaXQoJnN0YS0+dHhfZmlsdGVyZWRbaV0pOworCQlzdGEtPmFp cnRpbWVbaV0uZGVmaWNpdCA9IHN0YS0+YWlydGltZV93ZWlnaHQ7CiAJfQogCiAJZm9yIChpID0g MDsgaSA8IElFRUU4MDIxMV9OVU1fVElEUzsgaSsrKQpAQCAtMTgyNiw2ICsxODI2LDI4IEBAIHZv aWQgaWVlZTgwMjExX3N0YV9zZXRfYnVmZmVyZWQoc3RydWN0IGllZWU4MDIxMV9zdGEgKnB1YnN0 YSwKIH0KIEVYUE9SVF9TWU1CT0woaWVlZTgwMjExX3N0YV9zZXRfYnVmZmVyZWQpOwogCit2b2lk IGllZWU4MDIxMV9zdGFfcmVnaXN0ZXJfYWlydGltZShzdHJ1Y3QgaWVlZTgwMjExX3N0YSAqcHVi c3RhLCB1OCB0aWQsCisJCQkJICAgIHUzMiB0eF9haXJ0aW1lLCB1MzIgcnhfYWlydGltZSkKK3sK KwlzdHJ1Y3Qgc3RhX2luZm8gKnN0YSA9IGNvbnRhaW5lcl9vZihwdWJzdGEsIHN0cnVjdCBzdGFf aW5mbywgc3RhKTsKKwlzdHJ1Y3QgaWVlZTgwMjExX2xvY2FsICpsb2NhbCA9IHN0YS0+c2RhdGEt PmxvY2FsOworCXN0cnVjdCB0eHFfaW5mbyAqdHhxaTsKKwl1OCBhYyA9IGllZWU4MDIxMV9hY19m cm9tX3RpZCh0aWQpOworCXUzMiBhaXJ0aW1lID0gMDsKKworCWlmIChzdGEtPmxvY2FsLT5haXJ0 aW1lX2ZsYWdzICYgQUlSVElNRV9VU0VfVFgpCisJCWFpcnRpbWUgKz0gdHhfYWlydGltZTsKKwlp ZiAoc3RhLT5sb2NhbC0+YWlydGltZV9mbGFncyAmIEFJUlRJTUVfVVNFX1JYKQorCQlhaXJ0aW1l ICs9IHJ4X2FpcnRpbWU7CisKKwlzcGluX2xvY2tfYmgoJmxvY2FsLT5hY3RpdmVfdHhxX2xvY2tb YWNdKTsKKwlzdGEtPmFpcnRpbWVbYWNdLnR4X2FpcnRpbWUgKz0gdHhfYWlydGltZTsKKwlzdGEt PmFpcnRpbWVbYWNdLnJ4X2FpcnRpbWUgKz0gcnhfYWlydGltZTsKKwlzdGEtPmFpcnRpbWVbYWNd LmRlZmljaXQgLT0gYWlydGltZTsKKwlzcGluX3VubG9ja19iaCgmbG9jYWwtPmFjdGl2ZV90eHFf bG9ja1thY10pOworfQorRVhQT1JUX1NZTUJPTChpZWVlODAyMTFfc3RhX3JlZ2lzdGVyX2FpcnRp bWUpOworCiBpbnQgc3RhX2luZm9fbW92ZV9zdGF0ZShzdHJ1Y3Qgc3RhX2luZm8gKnN0YSwKIAkJ CWVudW0gaWVlZTgwMjExX3N0YV9zdGF0ZSBuZXdfc3RhdGUpCiB7CkBAIC0yMTg4LDYgKzIyMTAs MjMgQEAgdm9pZCBzdGFfc2V0X3NpbmZvKHN0cnVjdCBzdGFfaW5mbyAqc3RhLCBzdHJ1Y3Qgc3Rh dGlvbl9pbmZvICpzaW5mbywKIAkJc2luZm8tPmZpbGxlZCB8PSBCSVRfVUxMKE5MODAyMTFfU1RB X0lORk9fVFhfRkFJTEVEKTsKIAl9CiAKKwlpZiAoIShzaW5mby0+ZmlsbGVkICYgQklUKE5MODAy MTFfU1RBX0lORk9fUlhfRFVSQVRJT04pKSkgeworCQlmb3IgKGFjID0gMDsgYWMgPCBJRUVFODAy MTFfTlVNX0FDUzsgYWMrKykKKwkJCXNpbmZvLT5yeF9kdXJhdGlvbiArPSBzdGEtPmFpcnRpbWVb YWNdLnJ4X2FpcnRpbWU7CisJCXNpbmZvLT5maWxsZWQgfD0gQklUKE5MODAyMTFfU1RBX0lORk9f UlhfRFVSQVRJT04pOworCX0KKworCWlmICghKHNpbmZvLT5maWxsZWQgJiBCSVQoTkw4MDIxMV9T VEFfSU5GT19UWF9EVVJBVElPTikpKSB7CisJCWZvciAoYWMgPSAwOyBhYyA8IElFRUU4MDIxMV9O VU1fQUNTOyBhYysrKQorCQkJc2luZm8tPnR4X2R1cmF0aW9uICs9IHN0YS0+YWlydGltZVthY10u dHhfYWlydGltZTsKKwkJc2luZm8tPmZpbGxlZCB8PSBCSVQoTkw4MDIxMV9TVEFfSU5GT19UWF9E VVJBVElPTik7CisJfQorCisJaWYgKCEoc2luZm8tPmZpbGxlZCAmIEJJVChOTDgwMjExX1NUQV9J TkZPX0FJUlRJTUVfV0VJR0hUKSkpIHsKKwkJc2luZm8tPmFpcnRpbWVfd2VpZ2h0ID0gc3RhLT5h aXJ0aW1lX3dlaWdodDsKKwkJc2luZm8tPmZpbGxlZCB8PSBCSVQoTkw4MDIxMV9TVEFfSU5GT19B SVJUSU1FX1dFSUdIVCk7CisJfQorCiAJc2luZm8tPnJ4X2Ryb3BwZWRfbWlzYyA9IHN0YS0+cnhf c3RhdHMuZHJvcHBlZDsKIAlpZiAoc3RhLT5wY3B1X3J4X3N0YXRzKSB7CiAJCWZvcl9lYWNoX3Bv c3NpYmxlX2NwdShjcHUpIHsKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9zdGFfaW5mby5oIGIv bmV0L21hYzgwMjExL3N0YV9pbmZvLmgKaW5kZXggOWEwNDMyN2Q3MWQxLi5iMWIwZmQ2YTJlMjEg MTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9zdGFfaW5mby5oCisrKyBiL25ldC9tYWM4MDIxMS9z dGFfaW5mby5oCkBAIC0xMjcsNiArMTI3LDE2IEBAIGVudW0gaWVlZTgwMjExX2FnZ19zdG9wX3Jl YXNvbiB7CiAJQUdHX1NUT1BfREVTVFJPWV9TVEEsCiB9OwogCisvKiBEZWJ1Z2ZzIGZsYWdzIHRv IGVuYWJsZS9kaXNhYmxlIHVzZSBvZiBSWC9UWCBhaXJ0aW1lIGluIHNjaGVkdWxlciAqLworI2Rl ZmluZSBBSVJUSU1FX1VTRV9UWAkJQklUKDApCisjZGVmaW5lIEFJUlRJTUVfVVNFX1JYCQlCSVQo MSkKKworc3RydWN0IGFpcnRpbWVfaW5mbyB7CisJdTY0IHJ4X2FpcnRpbWU7CisJdTY0IHR4X2Fp cnRpbWU7CisJczY0IGRlZmljaXQ7Cit9OworCiBzdHJ1Y3Qgc3RhX2luZm87CiAKIC8qKgpAQCAt NTYzLDYgKzU3Myw5IEBAIHN0cnVjdCBzdGFfaW5mbyB7CiAJfSB0eF9zdGF0czsKIAl1MTYgdGlk X3NlcVtJRUVFODAyMTFfUU9TX0NUTF9USURfTUFTSyArIDFdOwogCisJc3RydWN0IGFpcnRpbWVf aW5mbyBhaXJ0aW1lW0lFRUU4MDIxMV9OVU1fQUNTXTsKKwl1MTYgYWlydGltZV93ZWlnaHQ7CisK IAkvKgogCSAqIEFnZ3JlZ2F0aW9uIGluZm9ybWF0aW9uLCBsb2NrZWQgd2l0aCBsb2NrLgogCSAq LwpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL3N0YXR1cy5jIGIvbmV0L21hYzgwMjExL3N0YXR1 cy5jCmluZGV4IDkxZDdjMGNkMTg4Mi4uY2Q0NTgyZjgwZmVhIDEwMDY0NAotLS0gYS9uZXQvbWFj ODAyMTEvc3RhdHVzLmMKKysrIGIvbmV0L21hYzgwMjExL3N0YXR1cy5jCkBAIC04MTgsNiArODE4 LDEyIEBAIHN0YXRpYyB2b2lkIF9faWVlZTgwMjExX3R4X3N0YXR1cyhzdHJ1Y3QgaWVlZTgwMjEx X2h3ICpodywKIAkJCWllZWU4MDIxMV9zdGFfdHhfbm90aWZ5KHN0YS0+c2RhdGEsICh2b2lkICop IHNrYi0+ZGF0YSwKIAkJCQkJCWFja2VkLCBpbmZvLT5zdGF0dXMudHhfdGltZSk7CiAKKwkJaWYg KGluZm8tPnN0YXR1cy50eF90aW1lICYmCisJCSAgICB3aXBoeV9leHRfZmVhdHVyZV9pc3NldChs b2NhbC0+aHcud2lwaHksCisJCQkJCSAgICBOTDgwMjExX0VYVF9GRUFUVVJFX0FJUlRJTUVfRkFJ Uk5FU1MpKQorCQkJaWVlZTgwMjExX3N0YV9yZWdpc3Rlcl9haXJ0aW1lKCZzdGEtPnN0YSwgdGlk LAorCQkJCQkJICAgICAgIGluZm8tPnN0YXR1cy50eF90aW1lLCAwKTsKKwogCQlpZiAoaWVlZTgw MjExX2h3X2NoZWNrKCZsb2NhbC0+aHcsIFJFUE9SVFNfVFhfQUNLX1NUQVRVUykpIHsKIAkJCWlm IChpbmZvLT5mbGFncyAmIElFRUU4MDIxMV9UWF9TVEFUX0FDSykgewogCQkJCWlmIChzdGEtPnN0 YXR1c19zdGF0cy5sb3N0X3BhY2tldHMpCmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvdHguYyBi L25ldC9tYWM4MDIxMS90eC5jCmluZGV4IDMwNTk2NTI4MzUwNi4uZGQyMzU0MTg4MzU3IDEwMDY0 NAotLS0gYS9uZXQvbWFjODAyMTEvdHguYworKysgYi9uZXQvbWFjODAyMTEvdHguYwpAQCAtMTQ4 OCw4ICsxNDg4LDExIEBAIHZvaWQgaWVlZTgwMjExX3R4cV9wdXJnZShzdHJ1Y3QgaWVlZTgwMjEx X2xvY2FsICpsb2NhbCwKIAlzdHJ1Y3QgZnEgKmZxID0gJmxvY2FsLT5mcTsKIAlzdHJ1Y3QgZnFf dGluICp0aW4gPSAmdHhxaS0+dGluOwogCisJc3Bpbl9sb2NrX2JoKCZmcS0+bG9jayk7CiAJZnFf dGluX3Jlc2V0KGZxLCB0aW4sIGZxX3NrYl9mcmVlX2Z1bmMpOwogCWllZWU4MDIxMV9wdXJnZV90 eF9xdWV1ZSgmbG9jYWwtPmh3LCAmdHhxaS0+ZnJhZ3MpOworCXNwaW5fdW5sb2NrX2JoKCZmcS0+ bG9jayk7CisKIAlzcGluX2xvY2tfYmgoJmxvY2FsLT5hY3RpdmVfdHhxX2xvY2tbdHhxaS0+dHhx LmFjXSk7CiAJbGlzdF9kZWxfaW5pdCgmdHhxaS0+c2NoZWR1bGVfb3JkZXIpOwogCXNwaW5fdW5s b2NrX2JoKCZsb2NhbC0+YWN0aXZlX3R4cV9sb2NrW3R4cWktPnR4cS5hY10pOwpAQCAtMzYzOCwx MSArMzY0MSwyOCBAQCBzdHJ1Y3QgaWVlZTgwMjExX3R4cSAqaWVlZTgwMjExX25leHRfdHhxKHN0 cnVjdCBpZWVlODAyMTFfaHcgKmh3LCB1OCBhYykKIAogCWxvY2tkZXBfYXNzZXJ0X2hlbGQoJmxv Y2FsLT5hY3RpdmVfdHhxX2xvY2tbYWNdKTsKIAorIGJlZ2luOgogCXR4cWkgPSBsaXN0X2ZpcnN0 X2VudHJ5X29yX251bGwoJmxvY2FsLT5hY3RpdmVfdHhxc1thY10sCiAJCQkJCXN0cnVjdCB0eHFf aW5mbywKIAkJCQkJc2NoZWR1bGVfb3JkZXIpOworCWlmICghdHhxaSkKKwkJcmV0dXJuIE5VTEw7 CisKKwlpZiAodHhxaS0+dHhxLnN0YSkgeworCQlzdHJ1Y3Qgc3RhX2luZm8gKnN0YSA9IGNvbnRh aW5lcl9vZih0eHFpLT50eHEuc3RhLAorCQkJCQkJc3RydWN0IHN0YV9pbmZvLCBzdGEpOworCisJ CWlmIChzdGEtPmFpcnRpbWVbdHhxaS0+dHhxLmFjXS5kZWZpY2l0IDwgMCkgeworCQkJc3RhLT5h aXJ0aW1lW3R4cWktPnR4cS5hY10uZGVmaWNpdCArPQorCQkJCXN0YS0+YWlydGltZV93ZWlnaHQ7 CisJCQlsaXN0X21vdmVfdGFpbCgmdHhxaS0+c2NoZWR1bGVfb3JkZXIsCisJCQkJICAgICAgICZs b2NhbC0+YWN0aXZlX3R4cXNbdHhxaS0+dHhxLmFjXSk7CisJCQlnb3RvIGJlZ2luOworCQl9CisJ fQorCiAKLQlpZiAoIXR4cWkgfHwgdHhxaS0+c2NoZWR1bGVfcm91bmQgPT0gbG9jYWwtPnNjaGVk dWxlX3JvdW5kW2FjXSkKKwlpZiAodHhxaS0+c2NoZWR1bGVfcm91bmQgPT0gbG9jYWwtPnNjaGVk dWxlX3JvdW5kW2FjXSkKIAkJcmV0dXJuIE5VTEw7CiAKIAlsaXN0X2RlbF9pbml0KCZ0eHFpLT5z Y2hlZHVsZV9vcmRlcik7CkBAIC0zNjYwLDEyICszNjgwLDc0IEBAIHZvaWQgaWVlZTgwMjExX3Jl dHVybl90eHEoc3RydWN0IGllZWU4MDIxMV9odyAqaHcsCiAJbG9ja2RlcF9hc3NlcnRfaGVsZCgm bG9jYWwtPmFjdGl2ZV90eHFfbG9ja1t0eHEtPmFjXSk7CiAKIAlpZiAobGlzdF9lbXB0eSgmdHhx aS0+c2NoZWR1bGVfb3JkZXIpICYmCi0JICAgICghc2tiX3F1ZXVlX2VtcHR5KCZ0eHFpLT5mcmFn cykgfHwgdHhxaS0+dGluLmJhY2tsb2dfcGFja2V0cykpCi0JCWxpc3RfYWRkX3RhaWwoJnR4cWkt PnNjaGVkdWxlX29yZGVyLAotCQkJICAgICAgJmxvY2FsLT5hY3RpdmVfdHhxc1t0eHEtPmFjXSk7 CisJICAgICghc2tiX3F1ZXVlX2VtcHR5KCZ0eHFpLT5mcmFncykgfHwgdHhxaS0+dGluLmJhY2ts b2dfcGFja2V0cykpIHsKKwkJLyogSWYgYWlydGltZSBhY2NvdW50aW5nIGlzIGFjdGl2ZSwgYWx3 YXlzIGVucXVldWUgU1RBcyBhdCB0aGUKKwkJICogaGVhZCBvZiB0aGUgbGlzdCB0byBlbnN1cmUg dGhhdCB0aGV5IG9ubHkgZ2V0IG1vdmVkIHRvIHRoZQorCQkgKiBiYWNrIGJ5IHRoZSBhaXJ0aW1l IERSUiBzY2hlZHVsZXIgb25jZSB0aGV5IGhhdmUgYSBuZWdhdGl2ZQorCQkgKiBkZWZpY2l0LiBB IHN0YXRpb24gdGhhdCBhbHJlYWR5IGhhcyBhIG5lZ2F0aXZlIGRlZmljaXQgd2lsbAorCQkgKiBn ZXQgaW1tZWRpYXRlbHkgbW92ZWQgdG8gdGhlIGJhY2sgb2YgdGhlIGxpc3Qgb24gdGhlIG5leHQK KwkJICogY2FsbCB0byBpZWVlODAyMTFfbmV4dF90eHEoKS4KKwkJICovCisJCWlmICh3aXBoeV9l eHRfZmVhdHVyZV9pc3NldChsb2NhbC0+aHcud2lwaHksCisJCQkJCSAgICBOTDgwMjExX0VYVF9G RUFUVVJFX0FJUlRJTUVfRkFJUk5FU1MpCisJCSAgICAmJiB0eHFpLT50eHEuc3RhKQorCQkJbGlz dF9hZGQoJnR4cWktPnNjaGVkdWxlX29yZGVyLAorCQkJCSAmbG9jYWwtPmFjdGl2ZV90eHFzW3R4 cS0+YWNdKTsKKwkJZWxzZQorCQkJbGlzdF9hZGRfdGFpbCgmdHhxaS0+c2NoZWR1bGVfb3JkZXIs CisJCQkJICAgICAgJmxvY2FsLT5hY3RpdmVfdHhxc1t0eHEtPmFjXSk7CisJfQogfQogRVhQT1JU X1NZTUJPTChpZWVlODAyMTFfcmV0dXJuX3R4cSk7CiAKK2Jvb2wgaWVlZTgwMjExX3R4cV9tYXlf dHJhbnNtaXQoc3RydWN0IGllZWU4MDIxMV9odyAqaHcsCisJCQkJc3RydWN0IGllZWU4MDIxMV90 eHEgKnR4cSkKK3sKKwlzdHJ1Y3QgaWVlZTgwMjExX2xvY2FsICpsb2NhbCA9IGh3X3RvX2xvY2Fs KGh3KTsKKwlzdHJ1Y3QgdHhxX2luZm8gKml0ZXIsICp0bXAsICp0eHFpID0gdG9fdHhxX2luZm8o dHhxKTsKKwlzdHJ1Y3Qgc3RhX2luZm8gKnN0YTsKKwl1OCBhYyA9IHR4cS0+YWM7CisKKwlsb2Nr ZGVwX2Fzc2VydF9oZWxkKCZsb2NhbC0+YWN0aXZlX3R4cV9sb2NrW2FjXSk7CisKKwlpZiAoIXR4 cWktPnR4cS5zdGEpCisJCWdvdG8gb3V0OworCisJaWYgKGxpc3RfZW1wdHkoJnR4cWktPnNjaGVk dWxlX29yZGVyKSkKKwkJZ290byBvdXQ7CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoaXRl ciwgdG1wLCAmbG9jYWwtPmFjdGl2ZV90eHFzW2FjXSwKKwkJCQkgc2NoZWR1bGVfb3JkZXIpIHsK KwkJaWYgKGl0ZXIgPT0gdHhxaSkKKwkJCWJyZWFrOworCisJCWlmICghaXRlci0+dHhxLnN0YSkg eworCQkJbGlzdF9tb3ZlX3RhaWwoJml0ZXItPnNjaGVkdWxlX29yZGVyLAorCQkJCSAgICAgICAm bG9jYWwtPmFjdGl2ZV90eHFzW2FjXSk7CisJCQljb250aW51ZTsKKwkJfQorCQlzdGEgPSBjb250 YWluZXJfb2YoaXRlci0+dHhxLnN0YSwgc3RydWN0IHN0YV9pbmZvLCBzdGEpOworCQlpZiAoc3Rh LT5haXJ0aW1lW2FjXS5kZWZpY2l0IDwgMCkKKwkJCXN0YS0+YWlydGltZVthY10uZGVmaWNpdCAr PSBzdGEtPmFpcnRpbWVfd2VpZ2h0OworCQlsaXN0X21vdmVfdGFpbCgmaXRlci0+c2NoZWR1bGVf b3JkZXIsICZsb2NhbC0+YWN0aXZlX3R4cXNbYWNdKTsKKwl9CisKKwlzdGEgPSBjb250YWluZXJf b2YodHhxaS0+dHhxLnN0YSwgc3RydWN0IHN0YV9pbmZvLCBzdGEpOworCWlmIChzdGEtPmFpcnRp bWVbYWNdLmRlZmljaXQgPj0gMCkKKwkJZ290byBvdXQ7CisKKwlzdGEtPmFpcnRpbWVbYWNdLmRl ZmljaXQgKz0gc3RhLT5haXJ0aW1lX3dlaWdodDsKKwlsaXN0X21vdmVfdGFpbCgmdHhxaS0+c2No ZWR1bGVfb3JkZXIsICZsb2NhbC0+YWN0aXZlX3R4cXNbYWNdKTsKKworCXJldHVybiBmYWxzZTsK K291dDoKKwlpZiAoIWxpc3RfZW1wdHkoJnR4cWktPnNjaGVkdWxlX29yZGVyKSkKKwkJbGlzdF9k ZWxfaW5pdCgmdHhxaS0+c2NoZWR1bGVfb3JkZXIpOworCisJcmV0dXJuIHRydWU7Cit9CitFWFBP UlRfU1lNQk9MKGllZWU4MDIxMV90eHFfbWF5X3RyYW5zbWl0KTsKKwogdm9pZCBpZWVlODAyMTFf dHhxX3NjaGVkdWxlX3N0YXJ0KHN0cnVjdCBpZWVlODAyMTFfaHcgKmh3LCB1OCBhYykKIHsKIAlz dHJ1Y3QgaWVlZTgwMjExX2xvY2FsICpsb2NhbCA9IGh3X3RvX2xvY2FsKGh3KTsKLS0gCjEuOS4x CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KYXRoMTBr IG1haWxpbmcgbGlzdAphdGgxMGtAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5m cmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2F0aDEwawo=