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=-6.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 CC6E2C432C3 for ; Fri, 15 Nov 2019 13:20:52 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 95D2520740 for ; Fri, 15 Nov 2019 13:20:52 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="cnUa5vs0" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727552AbfKONUw (ORCPT ); Fri, 15 Nov 2019 08:20:52 -0500 Received: from us-smtp-delivery-1.mimecast.com ([207.211.31.120]:55172 "EHLO us-smtp-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1727438AbfKONUv (ORCPT ); Fri, 15 Nov 2019 08:20:51 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1573824049; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=ABqX/4+Qx8L4BwRHEbiGEmTlEagYaiFV0Tg8XI1FKEQ=; b=cnUa5vs0lJNmWVdNry3x7SRjDc1GzKMLANGjsa2FuJDy/K9JAq5blaWeFLNI+iJyq8odfX r0VsEaB3NBTLplb6h68rfyg6HMh0U2QHYHANsoDP2uAh55OD7/vdjTlfqhDdhI4ysDJJGR e5MQoPVMg5BtEMltRIKLObG7ZyqKtg4= Received: from mail-lj1-f197.google.com (mail-lj1-f197.google.com [209.85.208.197]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-399-VJIdaLQGN5GIRBhjIEEmrQ-1; Fri, 15 Nov 2019 08:20:44 -0500 Received: by mail-lj1-f197.google.com with SMTP id r13so1534241ljk.18 for ; Fri, 15 Nov 2019 05:20:44 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:from:to:cc:date:message-id:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=9zAB64m7P+ORU3V1Fb8QxkCq1zL7OXWN/zEiD4RzsPA=; b=LEBKx7UqPgADdV4wBmd25rktBgP6sRVyt7wMO5E2iEKrsp4KCnVcEVH1YZH7Zr/O88 SIYE2ZxFan+QzFVqphm4TNtSH6FOLA1QdO/zSvka63F95rDfAHQyQkcog5Us8r+F+/eh TTFqsg4SpCAA5YFWNwFoNwEpcIX3EgXOqd3AD9zwWWsTYdeDPi3hXObJSCm9b5Gk/EB5 YeZypgy/AKBEnB9JHHdx0SfocWEoZd+T7Jn/ZeSdinRCWEoSiR/vKCXKx2v2s3TXP+Zv YrpcVRdkNI/ktTLMAmrUF1dgupPKq1ljJUEtmYvmjtQvmWiNOriYkkj0C9nMjAaq8Wja taAQ== X-Gm-Message-State: APjAAAWiw8qUsmZlOU6DaQiE+LunxmLhElrXdADtL2Pq1PdO1naywUBP od6zfG3XdB78+aTk+YiXd7vStk9Y4CrwJDCdOTJTLCWF/zMYk5hF8xmjNsJHvqtijKfzt+m8IKu ol8oMMH7Ip7oBR5b40cbHM3pxpE8= X-Received: by 2002:a2e:574d:: with SMTP id r13mr3459397ljd.10.1573824042709; Fri, 15 Nov 2019 05:20:42 -0800 (PST) X-Google-Smtp-Source: APXvYqyK+2fBonjlsQ7URP31p0E5WpJrtFs2Zs9aA/KHqKFl3v1ThH0iL5NbuiJy5ITf2dDk6TUOFg== X-Received: by 2002:a2e:574d:: with SMTP id r13mr3459371ljd.10.1573824042287; Fri, 15 Nov 2019 05:20:42 -0800 (PST) Received: from alrua-x1.borgediget.toke.dk (borgediget.toke.dk. [85.204.121.218]) by smtp.gmail.com with ESMTPSA id k6sm5352254lfc.72.2019.11.15.05.20.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Nov 2019 05:20:41 -0800 (PST) Received: by alrua-x1.borgediget.toke.dk (Postfix, from userid 1000) id 2B58F1818C7; Fri, 15 Nov 2019 14:20:40 +0100 (CET) Subject: [PATCH v9 3/4] mac80211: Implement Airtime-based Queue Limit (AQL) From: =?utf-8?q?Toke_H=C3=B8iland-J=C3=B8rgensen?= To: Johannes Berg Cc: linux-wireless@vger.kernel.org, make-wifi-fast@lists.bufferbloat.net, ath10k@lists.infradead.org, John Crispin , Lorenzo Bianconi , Felix Fietkau , Kan Yan , Rajkumar Manoharan , Kevin Hayes Date: Fri, 15 Nov 2019 14:20:40 +0100 Message-ID: <157382404008.580235.4182653624209779472.stgit@toke.dk> In-Reply-To: <157382403672.580235.12525941420808058808.stgit@toke.dk> References: <157382403672.580235.12525941420808058808.stgit@toke.dk> User-Agent: StGit/0.21 MIME-Version: 1.0 X-MC-Unique: VJIdaLQGN5GIRBhjIEEmrQ-1 X-Mimecast-Spam-Score: 0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Sender: linux-wireless-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-wireless@vger.kernel.org From: Kan Yan In order for the Fq_CoDel algorithm integrated in mac80211 layer to operate effectively to control excessive queueing latency, the CoDel algorithm requires an accurate measure of how long packets stays in the queue, AKA sojourn time. The sojourn time measured at the mac80211 layer doesn't include queueing latency in the lower layer (firmware/hardware) and CoDel expects lower layer to have a short queue. However, most 802.11ac chipsets offload tasks such TX aggregation to firmware or hardware, thus have a deep lower layer queue. Without a mechanism to control the lower layer queue size, packets only stay in mac80211 layer transiently before being sent to firmware queue. As a result, the sojourn time measured by CoDel in the mac80211 layer is almost always lower than the CoDel latency target, hence CoDel does little to control the latency, even when the lower layer queue causes excessive latency. The Byte Queue Limits (BQL) mechanism is commonly used to address the similar issue with wired network interface. However, this method cannot be applied directly to the wireless network interface. "Bytes" is not a suitable measure of queue depth in the wireless network, as the data rate can vary dramatically from station to station in the same network, from a few Mbps to over Gbps. This patch implements an Airtime-based Queue Limit (AQL) to make CoDel work effectively with wireless drivers that utilized firmware/hardware offloading. AQL allows each txq to release just enough packets to the lower layer to form 1-2 large aggregations to keep hardware fully utilized and retains the rest of the frames in mac80211 layer to be controlled by the CoDel algorithm. Signed-off-by: Kan Yan [ Toke: Keep API to set pending airtime internal, fix nits in commit msg ] Signed-off-by: Toke H=C3=B8iland-J=C3=B8rgensen --- include/net/cfg80211.h | 7 ++++ include/net/mac80211.h | 12 ++++++ net/mac80211/debugfs.c | 85 ++++++++++++++++++++++++++++++++++++++++= ++++ net/mac80211/debugfs_sta.c | 43 +++++++++++++++++----- net/mac80211/ieee80211_i.h | 4 ++ net/mac80211/main.c | 10 +++++ net/mac80211/sta_info.c | 38 ++++++++++++++++++++ net/mac80211/sta_info.h | 8 ++++ net/mac80211/tx.c | 47 +++++++++++++++++++++++- 9 files changed, 240 insertions(+), 14 deletions(-) diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h index e309cc826b40..4f75dbdd406a 100644 --- a/include/net/cfg80211.h +++ b/include/net/cfg80211.h @@ -2606,6 +2606,13 @@ enum wiphy_params_flags { =20 #define IEEE80211_DEFAULT_AIRTIME_WEIGHT=09256 =20 +/* The per TXQ device queue limit in airtime */ +#define IEEE80211_DEFAULT_AQL_TXQ_LIMIT_L=094000 +#define IEEE80211_DEFAULT_AQL_TXQ_LIMIT_H=098000 + +/* The per interface airtime threshold to switch to lower queue limit */ +#define IEEE80211_AQL_THRESHOLD=09=09=0924000 + /** * struct cfg80211_pmksa - PMK Security Association * diff --git a/include/net/mac80211.h b/include/net/mac80211.h index 6fc26a051ba0..ba3f33cc41ea 100644 --- a/include/net/mac80211.h +++ b/include/net/mac80211.h @@ -5565,6 +5565,18 @@ void ieee80211_send_eosp_nullfunc(struct ieee80211_s= ta *pubsta, int tid); void ieee80211_sta_register_airtime(struct ieee80211_sta *pubsta, u8 tid, =09=09=09=09 u32 tx_airtime, u32 rx_airtime); =20 +/** + * ieee80211_txq_airtime_check - check if a txq can send frame to device + * + * @hw: pointer obtained from ieee80211_alloc_hw() + * @txq: pointer obtained from station or virtual interface + * + * Return true if the AQL's airtime limit has not been reached and the txq= can + * continue to send more packets to the device. Otherwise return false. + */ +bool +ieee80211_txq_airtime_check(struct ieee80211_hw *hw, struct ieee80211_txq = *txq); + /** * ieee80211_iter_keys - iterate keys programmed into the device * @hw: pointer obtained from ieee80211_alloc_hw() diff --git a/net/mac80211/debugfs.c b/net/mac80211/debugfs.c index 568b3b276931..399d4e8b8546 100644 --- a/net/mac80211/debugfs.c +++ b/net/mac80211/debugfs.c @@ -148,6 +148,87 @@ static const struct file_operations aqm_ops =3D { =09.llseek =3D default_llseek, }; =20 +static ssize_t aql_txq_limit_read(struct file *file, +=09=09=09=09 char __user *user_buf, +=09=09=09=09 size_t count, +=09=09=09=09 loff_t *ppos) +{ +=09struct ieee80211_local *local =3D file->private_data; +=09char buf[400]; +=09int len =3D 0; + +=09len =3D scnprintf(buf, sizeof(buf), +=09=09=09"AC=09AQL limit low=09AQL limit high\n" +=09=09=09"VO=09%u=09=09%u\n" +=09=09=09"VI=09%u=09=09%u\n" +=09=09=09"BE=09%u=09=09%u\n" +=09=09=09"BK=09%u=09=09%u\n", +=09=09=09local->aql_txq_limit_low[IEEE80211_AC_VO], +=09=09=09local->aql_txq_limit_high[IEEE80211_AC_VO], +=09=09=09local->aql_txq_limit_low[IEEE80211_AC_VI], +=09=09=09local->aql_txq_limit_high[IEEE80211_AC_VI], +=09=09=09local->aql_txq_limit_low[IEEE80211_AC_BE], +=09=09=09local->aql_txq_limit_high[IEEE80211_AC_BE], +=09=09=09local->aql_txq_limit_low[IEEE80211_AC_BK], +=09=09=09local->aql_txq_limit_high[IEEE80211_AC_BK]); +=09return simple_read_from_buffer(user_buf, count, ppos, +=09=09=09=09 buf, len); +} + +static ssize_t aql_txq_limit_write(struct file *file, +=09=09=09=09 const char __user *user_buf, +=09=09=09=09 size_t count, +=09=09=09=09 loff_t *ppos) +{ +=09struct ieee80211_local *local =3D file->private_data; +=09char buf[100]; +=09size_t len; +=09u32 ac, q_limit_low, q_limit_high, q_limit_low_old, q_limit_high_old; +=09struct sta_info *sta; + +=09if (count > sizeof(buf)) +=09=09return -EINVAL; + +=09if (copy_from_user(buf, user_buf, count)) +=09=09return -EFAULT; + +=09buf[sizeof(buf) - 1] =3D 0; +=09len =3D strlen(buf); +=09if (len > 0 && buf[len - 1] =3D=3D '\n') +=09=09buf[len - 1] =3D 0; + +=09if (sscanf(buf, "%u %u %u", &ac, &q_limit_low, &q_limit_high) !=3D 3) +=09=09return -EINVAL; + +=09if (ac >=3D IEEE80211_NUM_ACS) +=09=09return -EINVAL; + +=09q_limit_low_old =3D local->aql_txq_limit_low[ac]; +=09q_limit_high_old =3D local->aql_txq_limit_high[ac]; + +=09local->aql_txq_limit_low[ac] =3D q_limit_low; +=09local->aql_txq_limit_high[ac] =3D q_limit_high; + +=09mutex_lock(&local->sta_mtx); +=09list_for_each_entry(sta, &local->sta_list, list) { +=09=09/* If a sta has customized queue limits, keep it */ +=09=09if (sta->airtime[ac].aql_limit_low =3D=3D q_limit_low_old && +=09=09 sta->airtime[ac].aql_limit_high =3D=3D q_limit_high_old) { +=09=09=09sta->airtime[ac].aql_limit_low =3D q_limit_low; +=09=09=09sta->airtime[ac].aql_limit_high =3D q_limit_high; +=09=09} +=09} +=09mutex_unlock(&local->sta_mtx); +=09return count; +} + +static const struct file_operations aql_txq_limit_ops =3D { +=09.write =3D aql_txq_limit_write, +=09.read =3D aql_txq_limit_read, +=09.open =3D simple_open, +=09.llseek =3D default_llseek, +}; + static ssize_t force_tx_status_read(struct file *file, =09=09=09=09 char __user *user_buf, =09=09=09=09 size_t count, @@ -441,6 +522,10 @@ void debugfs_hw_add(struct ieee80211_local *local) =09debugfs_create_u16("airtime_flags", 0600, =09=09=09 phyd, &local->airtime_flags); =20 +=09DEBUGFS_ADD(aql_txq_limit); +=09debugfs_create_u32("aql_threshold", 0600, +=09=09=09 phyd, &local->aql_threshold); + =09statsd =3D debugfs_create_dir("statistics", phyd); =20 =09/* 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 c8ad20c28c43..0185e6e5e5d1 100644 --- a/net/mac80211/debugfs_sta.c +++ b/net/mac80211/debugfs_sta.c @@ -197,10 +197,12 @@ static ssize_t sta_airtime_read(struct file *file, ch= ar __user *userbuf, { =09struct sta_info *sta =3D file->private_data; =09struct ieee80211_local *local =3D sta->sdata->local; -=09size_t bufsz =3D 200; +=09size_t bufsz =3D 400; =09char *buf =3D kzalloc(bufsz, GFP_KERNEL), *p =3D buf; =09u64 rx_airtime =3D 0, tx_airtime =3D 0; =09s64 deficit[IEEE80211_NUM_ACS]; +=09u32 q_depth[IEEE80211_NUM_ACS]; +=09u32 q_limit_l[IEEE80211_NUM_ACS], q_limit_h[IEEE80211_NUM_ACS]; =09ssize_t rv; =09int ac; =20 @@ -212,19 +214,22 @@ static ssize_t sta_airtime_read(struct file *file, ch= ar __user *userbuf, =09=09rx_airtime +=3D sta->airtime[ac].rx_airtime; =09=09tx_airtime +=3D sta->airtime[ac].tx_airtime; =09=09deficit[ac] =3D sta->airtime[ac].deficit; +=09=09q_limit_l[ac] =3D sta->airtime[ac].aql_limit_low; +=09=09q_limit_h[ac] =3D sta->airtime[ac].aql_limit_high; =09=09spin_unlock_bh(&local->active_txq_lock[ac]); +=09=09q_depth[ac] =3D atomic_read(&sta->airtime[ac].aql_tx_pending); =09} =20 =09p +=3D scnprintf(p, bufsz + buf - p, =09=09"RX: %llu us\nTX: %llu us\nWeight: %u\n" -=09=09"Deficit: VO: %lld us VI: %lld us BE: %lld us BK: %lld us\n", -=09=09rx_airtime, -=09=09tx_airtime, -=09=09sta->airtime_weight, -=09=09deficit[0], -=09=09deficit[1], -=09=09deficit[2], -=09=09deficit[3]); +=09=09"Deficit: VO: %lld us VI: %lld us BE: %lld us BK: %lld us\n" +=09=09"Q depth: VO: %u us VI: %u us BE: %u us BK: %u us\n" +=09=09"Q limit[low/high]: VO: %u/%u VI: %u/%u BE: %u/%u BK: %u/%u\n", +=09=09rx_airtime, tx_airtime, sta->airtime_weight, +=09=09deficit[0], deficit[1], deficit[2], deficit[3], +=09=09q_depth[0], q_depth[1], q_depth[2], q_depth[3], +=09=09q_limit_l[0], q_limit_h[0], q_limit_l[1], q_limit_h[1], +=09=09q_limit_l[2], q_limit_h[2], q_limit_l[3], q_limit_h[3]), =20 =09rv =3D simple_read_from_buffer(userbuf, count, ppos, buf, p - buf); =09kfree(buf); @@ -236,7 +241,25 @@ static ssize_t sta_airtime_write(struct file *file, co= nst char __user *userbuf, { =09struct sta_info *sta =3D file->private_data; =09struct ieee80211_local *local =3D sta->sdata->local; -=09int ac; +=09u32 ac, q_limit_l, q_limit_h; +=09char _buf[100] =3D {}, *buf =3D _buf; + +=09if (count > sizeof(_buf)) +=09=09return -EINVAL; + +=09if (copy_from_user(buf, userbuf, count)) +=09=09return -EFAULT; + +=09buf[sizeof(_buf) - 1] =3D '\0'; +=09if (sscanf(buf, "queue limit %u %u %u", &ac, &q_limit_l, &q_limit_h) +=09 !=3D 3) +=09=09return -EINVAL; + +=09if (ac >=3D IEEE80211_NUM_ACS) +=09=09return -EINVAL; + +=09sta->airtime[ac].aql_limit_low =3D q_limit_l; +=09sta->airtime[ac].aql_limit_high =3D q_limit_h; =20 =09for (ac =3D 0; ac < IEEE80211_NUM_ACS; ac++) { =09=09spin_lock_bh(&local->active_txq_lock[ac]); diff --git a/net/mac80211/ieee80211_i.h b/net/mac80211/ieee80211_i.h index 225ea4e3cd76..ad15b3be8bb3 100644 --- a/net/mac80211/ieee80211_i.h +++ b/net/mac80211/ieee80211_i.h @@ -1142,6 +1142,10 @@ struct ieee80211_local { =09u16 schedule_round[IEEE80211_NUM_ACS]; =20 =09u16 airtime_flags; +=09u32 aql_txq_limit_low[IEEE80211_NUM_ACS]; +=09u32 aql_txq_limit_high[IEEE80211_NUM_ACS]; +=09u32 aql_threshold; +=09atomic_t aql_total_pending_airtime; =20 =09const struct ieee80211_ops *ops; =20 diff --git a/net/mac80211/main.c b/net/mac80211/main.c index aba094b4ccfc..071ea92a3748 100644 --- a/net/mac80211/main.c +++ b/net/mac80211/main.c @@ -667,8 +667,16 @@ struct ieee80211_hw *ieee80211_alloc_hw_nm(size_t priv= _data_len, =09for (i =3D 0; i < IEEE80211_NUM_ACS; i++) { =09=09INIT_LIST_HEAD(&local->active_txqs[i]); =09=09spin_lock_init(&local->active_txq_lock[i]); +=09=09local->aql_txq_limit_low[i] =3D IEEE80211_DEFAULT_AQL_TXQ_LIMIT_L; +=09=09local->aql_txq_limit_high[i] =3D +=09=09=09IEEE80211_DEFAULT_AQL_TXQ_LIMIT_H; =09} -=09local->airtime_flags =3D AIRTIME_USE_TX | AIRTIME_USE_RX; + +=09local->airtime_flags =3D AIRTIME_USE_TX | +=09=09=09 AIRTIME_USE_RX | +=09=09=09 AIRTIME_USE_AQL; +=09local->aql_threshold =3D IEEE80211_AQL_THRESHOLD; +=09atomic_set(&local->aql_total_pending_airtime, 0); =20 =09INIT_LIST_HEAD(&local->chanctx_list); =09mutex_init(&local->chanctx_mtx); diff --git a/net/mac80211/sta_info.c b/net/mac80211/sta_info.c index 465d83b13582..1fe02022a31a 100644 --- a/net/mac80211/sta_info.c +++ b/net/mac80211/sta_info.c @@ -416,6 +416,9 @@ struct sta_info *sta_info_alloc(struct ieee80211_sub_if= _data *sdata, =09=09skb_queue_head_init(&sta->ps_tx_buf[i]); =09=09skb_queue_head_init(&sta->tx_filtered[i]); =09=09sta->airtime[i].deficit =3D sta->airtime_weight; +=09=09atomic_set(&sta->airtime[i].aql_tx_pending, 0); +=09=09sta->airtime[i].aql_limit_low =3D local->aql_txq_limit_low[i]; +=09=09sta->airtime[i].aql_limit_high =3D local->aql_txq_limit_high[i]; =09} =20 =09for (i =3D 0; i < IEEE80211_NUM_TIDS; i++) @@ -1913,6 +1916,41 @@ void ieee80211_sta_register_airtime(struct ieee80211= _sta *pubsta, u8 tid, } EXPORT_SYMBOL(ieee80211_sta_register_airtime); =20 +void ieee80211_sta_update_pending_airtime(struct ieee80211_local *local, +=09=09=09=09=09 struct sta_info *sta, u8 ac, +=09=09=09=09=09 u16 tx_airtime, bool tx_completed) +{ +=09int tx_pending; + +=09if (!tx_completed) { +=09=09if (sta) +=09=09=09atomic_add(tx_airtime, +=09=09=09=09 &sta->airtime[ac].aql_tx_pending); + +=09=09atomic_add(tx_airtime, &local->aql_total_pending_airtime); +=09=09return; +=09} + +=09if (sta) { +=09=09tx_pending =3D atomic_sub_return(tx_airtime, +=09=09=09=09=09 &sta->airtime[ac].aql_tx_pending); +=09=09if (WARN_ONCE(tx_pending < 0, +=09=09=09 "STA %pM AC %d txq pending airtime underflow: %u, %u", +=09=09=09 sta->addr, ac, tx_pending, tx_airtime)) +=09=09=09atomic_cmpxchg(&sta->airtime[ac].aql_tx_pending, +=09=09=09=09 tx_pending, 0); +=09} + +=09tx_pending =3D atomic_sub_return(tx_airtime, +=09=09=09=09 &local->aql_total_pending_airtime); +=09if (WARN_ONCE(tx_pending < 0, +=09=09 "Device %s AC %d pending airtime underflow: %u, %u", +=09=09 wiphy_name(local->hw.wiphy), ac, tx_pending, +=09=09 tx_airtime)) +=09=09atomic_cmpxchg(&local->aql_total_pending_airtime, +=09=09=09 tx_pending, 0); +} + int sta_info_move_state(struct sta_info *sta, =09=09=09enum ieee80211_sta_state new_state) { diff --git a/net/mac80211/sta_info.h b/net/mac80211/sta_info.h index 80e76569144e..0608d49b3826 100644 --- a/net/mac80211/sta_info.h +++ b/net/mac80211/sta_info.h @@ -127,13 +127,21 @@ enum ieee80211_agg_stop_reason { /* Debugfs flags to enable/disable use of RX/TX airtime in scheduler */ #define AIRTIME_USE_TX=09=09BIT(0) #define AIRTIME_USE_RX=09=09BIT(1) +#define AIRTIME_USE_AQL=09=09BIT(2) =20 struct airtime_info { =09u64 rx_airtime; =09u64 tx_airtime; =09s64 deficit; +=09atomic_t aql_tx_pending; /* Estimated airtime for frames pending */ +=09u32 aql_limit_low; +=09u32 aql_limit_high; }; =20 +void ieee80211_sta_update_pending_airtime(struct ieee80211_local *local, +=09=09=09=09=09 struct sta_info *sta, u8 ac, +=09=09=09=09=09 u16 tx_airtime, bool tx_completed); + struct sta_info; =20 /** diff --git a/net/mac80211/tx.c b/net/mac80211/tx.c index db38be1b75fa..aafc67b562eb 100644 --- a/net/mac80211/tx.c +++ b/net/mac80211/tx.c @@ -3674,7 +3674,8 @@ struct ieee80211_txq *ieee80211_next_txq(struct ieee8= 0211_hw *hw, u8 ac) { =09struct ieee80211_local *local =3D hw_to_local(hw); =09struct ieee80211_txq *ret =3D NULL; -=09struct txq_info *txqi =3D NULL; +=09struct txq_info *txqi =3D NULL, *head =3D NULL; +=09bool found_eligible_txq =3D false; =20 =09spin_lock_bh(&local->active_txq_lock[ac]); =20 @@ -3685,13 +3686,26 @@ struct ieee80211_txq *ieee80211_next_txq(struct iee= e80211_hw *hw, u8 ac) =09if (!txqi) =09=09goto out; =20 +=09if (txqi =3D=3D head && !found_eligible_txq) +=09=09goto out; + +=09if (!head) +=09=09head =3D txqi; + =09if (txqi->txq.sta) { =09=09struct sta_info *sta =3D container_of(txqi->txq.sta, -=09=09=09=09=09=09struct sta_info, sta); +=09=09=09=09=09=09 struct sta_info, sta); +=09=09bool aql_check =3D ieee80211_txq_airtime_check(hw, &txqi->txq); +=09=09s64 deficit =3D sta->airtime[txqi->txq.ac].deficit; + +=09=09if (aql_check) +=09=09=09found_eligible_txq =3D true; =20 -=09=09if (sta->airtime[txqi->txq.ac].deficit < 0) { +=09=09if (deficit < 0) =09=09=09sta->airtime[txqi->txq.ac].deficit +=3D =09=09=09=09sta->airtime_weight; + +=09=09if (deficit < 0 || !aql_check) { =09=09=09list_move_tail(&txqi->schedule_order, =09=09=09=09 &local->active_txqs[txqi->txq.ac]); =09=09=09goto begin; @@ -3745,6 +3759,33 @@ void __ieee80211_schedule_txq(struct ieee80211_hw *h= w, } EXPORT_SYMBOL(__ieee80211_schedule_txq); =20 +bool ieee80211_txq_airtime_check(struct ieee80211_hw *hw, +=09=09=09=09 struct ieee80211_txq *txq) +{ +=09struct sta_info *sta; +=09struct ieee80211_local *local =3D hw_to_local(hw); + +=09if (!(local->airtime_flags & AIRTIME_USE_AQL)) +=09=09return true; + +=09if (!txq->sta) +=09=09return true; + +=09sta =3D container_of(txq->sta, struct sta_info, sta); +=09if (atomic_read(&sta->airtime[txq->ac].aql_tx_pending) < +=09 sta->airtime[txq->ac].aql_limit_low) +=09=09return true; + +=09if (atomic_read(&local->aql_total_pending_airtime) < +=09 local->aql_threshold && +=09 atomic_read(&sta->airtime[txq->ac].aql_tx_pending) < +=09 sta->airtime[txq->ac].aql_limit_high) +=09=09return true; + +=09return false; +} +EXPORT_SYMBOL(ieee80211_txq_airtime_check); + bool ieee80211_txq_may_transmit(struct ieee80211_hw *hw, =09=09=09=09struct ieee80211_txq *txq) { From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from us-smtp-delivery-1.mimecast.com ([207.211.31.120] helo=us-smtp-1.mimecast.com) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1iVbWp-0000sH-LG for ath10k@lists.infradead.org; Fri, 15 Nov 2019 13:20:50 +0000 Received: by mail-lj1-f198.google.com with SMTP id d16so1544101ljo.11 for ; Fri, 15 Nov 2019 05:20:44 -0800 (PST) Subject: [PATCH v9 3/4] mac80211: Implement Airtime-based Queue Limit (AQL) From: =?utf-8?q?Toke_H=C3=B8iland-J=C3=B8rgensen?= Date: Fri, 15 Nov 2019 14:20:40 +0100 Message-ID: <157382404008.580235.4182653624209779472.stgit@toke.dk> In-Reply-To: <157382403672.580235.12525941420808058808.stgit@toke.dk> References: <157382403672.580235.12525941420808058808.stgit@toke.dk> 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: Johannes Berg Cc: Kan Yan , Rajkumar Manoharan , Kevin Hayes , make-wifi-fast@lists.bufferbloat.net, linux-wireless@vger.kernel.org, ath10k@lists.infradead.org, John Crispin , Lorenzo Bianconi , Felix Fietkau RnJvbTogS2FuIFlhbiA8a3lhbkBnb29nbGUuY29tPgoKSW4gb3JkZXIgZm9yIHRoZSBGcV9Db0Rl bCBhbGdvcml0aG0gaW50ZWdyYXRlZCBpbiBtYWM4MDIxMSBsYXllciB0byBvcGVyYXRlCmVmZmVj dGl2ZWx5IHRvIGNvbnRyb2wgZXhjZXNzaXZlIHF1ZXVlaW5nIGxhdGVuY3ksIHRoZSBDb0RlbCBh bGdvcml0aG0KcmVxdWlyZXMgYW4gYWNjdXJhdGUgbWVhc3VyZSBvZiBob3cgbG9uZyBwYWNrZXRz IHN0YXlzIGluIHRoZSBxdWV1ZSwgQUtBCnNvam91cm4gdGltZS4gVGhlIHNvam91cm4gdGltZSBt ZWFzdXJlZCBhdCB0aGUgbWFjODAyMTEgbGF5ZXIgZG9lc24ndAppbmNsdWRlIHF1ZXVlaW5nIGxh dGVuY3kgaW4gdGhlIGxvd2VyIGxheWVyIChmaXJtd2FyZS9oYXJkd2FyZSkgYW5kIENvRGVsCmV4 cGVjdHMgbG93ZXIgbGF5ZXIgdG8gaGF2ZSBhIHNob3J0IHF1ZXVlLiBIb3dldmVyLCBtb3N0IDgw Mi4xMWFjIGNoaXBzZXRzCm9mZmxvYWQgdGFza3Mgc3VjaCBUWCBhZ2dyZWdhdGlvbiB0byBmaXJt d2FyZSBvciBoYXJkd2FyZSwgdGh1cyBoYXZlIGEgZGVlcApsb3dlciBsYXllciBxdWV1ZS4KCldp dGhvdXQgYSBtZWNoYW5pc20gdG8gY29udHJvbCB0aGUgbG93ZXIgbGF5ZXIgcXVldWUgc2l6ZSwg cGFja2V0cyBvbmx5CnN0YXkgaW4gbWFjODAyMTEgbGF5ZXIgdHJhbnNpZW50bHkgYmVmb3JlIGJl aW5nIHNlbnQgdG8gZmlybXdhcmUgcXVldWUuCkFzIGEgcmVzdWx0LCB0aGUgc29qb3VybiB0aW1l IG1lYXN1cmVkIGJ5IENvRGVsIGluIHRoZSBtYWM4MDIxMSBsYXllciBpcwphbG1vc3QgYWx3YXlz IGxvd2VyIHRoYW4gdGhlIENvRGVsIGxhdGVuY3kgdGFyZ2V0LCBoZW5jZSBDb0RlbCBkb2VzIGxp dHRsZQp0byBjb250cm9sIHRoZSBsYXRlbmN5LCBldmVuIHdoZW4gdGhlIGxvd2VyIGxheWVyIHF1 ZXVlIGNhdXNlcyBleGNlc3NpdmUKbGF0ZW5jeS4KClRoZSBCeXRlIFF1ZXVlIExpbWl0cyAoQlFM KSBtZWNoYW5pc20gaXMgY29tbW9ubHkgdXNlZCB0byBhZGRyZXNzIHRoZQpzaW1pbGFyIGlzc3Vl IHdpdGggd2lyZWQgbmV0d29yayBpbnRlcmZhY2UuIEhvd2V2ZXIsIHRoaXMgbWV0aG9kIGNhbm5v dCBiZQphcHBsaWVkIGRpcmVjdGx5IHRvIHRoZSB3aXJlbGVzcyBuZXR3b3JrIGludGVyZmFjZS4g IkJ5dGVzIiBpcyBub3QgYQpzdWl0YWJsZSBtZWFzdXJlIG9mIHF1ZXVlIGRlcHRoIGluIHRoZSB3 aXJlbGVzcyBuZXR3b3JrLCBhcyB0aGUgZGF0YSByYXRlCmNhbiB2YXJ5IGRyYW1hdGljYWxseSBm cm9tIHN0YXRpb24gdG8gc3RhdGlvbiBpbiB0aGUgc2FtZSBuZXR3b3JrLCBmcm9tIGEKZmV3IE1i cHMgdG8gb3ZlciBHYnBzLgoKVGhpcyBwYXRjaCBpbXBsZW1lbnRzIGFuIEFpcnRpbWUtYmFzZWQg UXVldWUgTGltaXQgKEFRTCkgdG8gbWFrZSBDb0RlbCB3b3JrCmVmZmVjdGl2ZWx5IHdpdGggd2ly ZWxlc3MgZHJpdmVycyB0aGF0IHV0aWxpemVkIGZpcm13YXJlL2hhcmR3YXJlCm9mZmxvYWRpbmcu IEFRTCBhbGxvd3MgZWFjaCB0eHEgdG8gcmVsZWFzZSBqdXN0IGVub3VnaCBwYWNrZXRzIHRvIHRo ZSBsb3dlcgpsYXllciB0byBmb3JtIDEtMiBsYXJnZSBhZ2dyZWdhdGlvbnMgdG8ga2VlcCBoYXJk d2FyZSBmdWxseSB1dGlsaXplZCBhbmQKcmV0YWlucyB0aGUgcmVzdCBvZiB0aGUgZnJhbWVzIGlu IG1hYzgwMjExIGxheWVyIHRvIGJlIGNvbnRyb2xsZWQgYnkgdGhlCkNvRGVsIGFsZ29yaXRobS4K ClNpZ25lZC1vZmYtYnk6IEthbiBZYW4gPGt5YW5AZ29vZ2xlLmNvbT4KWyBUb2tlOiBLZWVwIEFQ SSB0byBzZXQgcGVuZGluZyBhaXJ0aW1lIGludGVybmFsLCBmaXggbml0cyBpbiBjb21taXQgbXNn IF0KU2lnbmVkLW9mZi1ieTogVG9rZSBIw7hpbGFuZC1Kw7hyZ2Vuc2VuIDx0b2tlQHJlZGhhdC5j b20+Ci0tLQogaW5jbHVkZS9uZXQvY2ZnODAyMTEuaCAgICAgfCAgICA3ICsrKysKIGluY2x1ZGUv bmV0L21hYzgwMjExLmggICAgIHwgICAxMiArKysrKysKIG5ldC9tYWM4MDIxMS9kZWJ1Z2ZzLmMg ICAgIHwgICA4NSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwog bmV0L21hYzgwMjExL2RlYnVnZnNfc3RhLmMgfCAgIDQzICsrKysrKysrKysrKysrKysrLS0tLS0K IG5ldC9tYWM4MDIxMS9pZWVlODAyMTFfaS5oIHwgICAgNCArKwogbmV0L21hYzgwMjExL21haW4u YyAgICAgICAgfCAgIDEwICsrKysrCiBuZXQvbWFjODAyMTEvc3RhX2luZm8uYyAgICB8ICAgMzgg KysrKysrKysrKysrKysrKysrKysKIG5ldC9tYWM4MDIxMS9zdGFfaW5mby5oICAgIHwgICAgOCAr KysrCiBuZXQvbWFjODAyMTEvdHguYyAgICAgICAgICB8ICAgNDcgKysrKysrKysrKysrKysrKysr KysrKystCiA5IGZpbGVzIGNoYW5nZWQsIDI0MCBpbnNlcnRpb25zKCspLCAxNCBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9pbmNsdWRlL25ldC9jZmc4MDIxMS5oIGIvaW5jbHVkZS9uZXQvY2Zn ODAyMTEuaAppbmRleCBlMzA5Y2M4MjZiNDAuLjRmNzVkYmRkNDA2YSAxMDA2NDQKLS0tIGEvaW5j bHVkZS9uZXQvY2ZnODAyMTEuaAorKysgYi9pbmNsdWRlL25ldC9jZmc4MDIxMS5oCkBAIC0yNjA2 LDYgKzI2MDYsMTMgQEAgZW51bSB3aXBoeV9wYXJhbXNfZmxhZ3MgewogCiAjZGVmaW5lIElFRUU4 MDIxMV9ERUZBVUxUX0FJUlRJTUVfV0VJR0hUCTI1NgogCisvKiBUaGUgcGVyIFRYUSBkZXZpY2Ug cXVldWUgbGltaXQgaW4gYWlydGltZSAqLworI2RlZmluZSBJRUVFODAyMTFfREVGQVVMVF9BUUxf VFhRX0xJTUlUX0wJNDAwMAorI2RlZmluZSBJRUVFODAyMTFfREVGQVVMVF9BUUxfVFhRX0xJTUlU X0gJODAwMAorCisvKiBUaGUgcGVyIGludGVyZmFjZSBhaXJ0aW1lIHRocmVzaG9sZCB0byBzd2l0 Y2ggdG8gbG93ZXIgcXVldWUgbGltaXQgKi8KKyNkZWZpbmUgSUVFRTgwMjExX0FRTF9USFJFU0hP TEQJCQkyNDAwMAorCiAvKioKICAqIHN0cnVjdCBjZmc4MDIxMV9wbWtzYSAtIFBNSyBTZWN1cml0 eSBBc3NvY2lhdGlvbgogICoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L21hYzgwMjExLmggYi9p bmNsdWRlL25ldC9tYWM4MDIxMS5oCmluZGV4IDZmYzI2YTA1MWJhMC4uYmEzZjMzY2M0MWVhIDEw MDY0NAotLS0gYS9pbmNsdWRlL25ldC9tYWM4MDIxMS5oCisrKyBiL2luY2x1ZGUvbmV0L21hYzgw MjExLmgKQEAgLTU1NjUsNiArNTU2NSwxOCBAQCB2b2lkIGllZWU4MDIxMV9zZW5kX2Vvc3BfbnVs bGZ1bmMoc3RydWN0IGllZWU4MDIxMV9zdGEgKnB1YnN0YSwgaW50IHRpZCk7CiB2b2lkIGllZWU4 MDIxMV9zdGFfcmVnaXN0ZXJfYWlydGltZShzdHJ1Y3QgaWVlZTgwMjExX3N0YSAqcHVic3RhLCB1 OCB0aWQsCiAJCQkJICAgIHUzMiB0eF9haXJ0aW1lLCB1MzIgcnhfYWlydGltZSk7CiAKKy8qKgor ICogaWVlZTgwMjExX3R4cV9haXJ0aW1lX2NoZWNrIC0gY2hlY2sgaWYgYSB0eHEgY2FuIHNlbmQg ZnJhbWUgdG8gZGV2aWNlCisgKgorICogQGh3OiBwb2ludGVyIG9idGFpbmVkIGZyb20gaWVlZTgw MjExX2FsbG9jX2h3KCkKKyAqIEB0eHE6IHBvaW50ZXIgb2J0YWluZWQgZnJvbSBzdGF0aW9uIG9y IHZpcnR1YWwgaW50ZXJmYWNlCisgKgorICogUmV0dXJuIHRydWUgaWYgdGhlIEFRTCdzIGFpcnRp bWUgbGltaXQgaGFzIG5vdCBiZWVuIHJlYWNoZWQgYW5kIHRoZSB0eHEgY2FuCisgKiBjb250aW51 ZSB0byBzZW5kIG1vcmUgcGFja2V0cyB0byB0aGUgZGV2aWNlLiBPdGhlcndpc2UgcmV0dXJuIGZh bHNlLgorICovCitib29sCitpZWVlODAyMTFfdHhxX2FpcnRpbWVfY2hlY2soc3RydWN0IGllZWU4 MDIxMV9odyAqaHcsIHN0cnVjdCBpZWVlODAyMTFfdHhxICp0eHEpOworCiAvKioKICAqIGllZWU4 MDIxMV9pdGVyX2tleXMgLSBpdGVyYXRlIGtleXMgcHJvZ3JhbW1lZCBpbnRvIHRoZSBkZXZpY2UK ICAqIEBodzogcG9pbnRlciBvYnRhaW5lZCBmcm9tIGllZWU4MDIxMV9hbGxvY19odygpCmRpZmYg LS1naXQgYS9uZXQvbWFjODAyMTEvZGVidWdmcy5jIGIvbmV0L21hYzgwMjExL2RlYnVnZnMuYwpp bmRleCA1NjhiM2IyNzY5MzEuLjM5OWQ0ZThiODU0NiAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjEx L2RlYnVnZnMuYworKysgYi9uZXQvbWFjODAyMTEvZGVidWdmcy5jCkBAIC0xNDgsNiArMTQ4LDg3 IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGFxbV9vcHMgPSB7CiAJLmxs c2VlayA9IGRlZmF1bHRfbGxzZWVrLAogfTsKIAorc3RhdGljIHNzaXplX3QgYXFsX3R4cV9saW1p dF9yZWFkKHN0cnVjdCBmaWxlICpmaWxlLAorCQkJCSAgY2hhciBfX3VzZXIgKnVzZXJfYnVmLAor CQkJCSAgc2l6ZV90IGNvdW50LAorCQkJCSAgbG9mZl90ICpwcG9zKQoreworCXN0cnVjdCBpZWVl ODAyMTFfbG9jYWwgKmxvY2FsID0gZmlsZS0+cHJpdmF0ZV9kYXRhOworCWNoYXIgYnVmWzQwMF07 CisJaW50IGxlbiA9IDA7CisKKwlsZW4gPSBzY25wcmludGYoYnVmLCBzaXplb2YoYnVmKSwKKwkJ CSJBQwlBUUwgbGltaXQgbG93CUFRTCBsaW1pdCBoaWdoXG4iCisJCQkiVk8JJXUJCSV1XG4iCisJ CQkiVkkJJXUJCSV1XG4iCisJCQkiQkUJJXUJCSV1XG4iCisJCQkiQksJJXUJCSV1XG4iLAorCQkJ bG9jYWwtPmFxbF90eHFfbGltaXRfbG93W0lFRUU4MDIxMV9BQ19WT10sCisJCQlsb2NhbC0+YXFs X3R4cV9saW1pdF9oaWdoW0lFRUU4MDIxMV9BQ19WT10sCisJCQlsb2NhbC0+YXFsX3R4cV9saW1p dF9sb3dbSUVFRTgwMjExX0FDX1ZJXSwKKwkJCWxvY2FsLT5hcWxfdHhxX2xpbWl0X2hpZ2hbSUVF RTgwMjExX0FDX1ZJXSwKKwkJCWxvY2FsLT5hcWxfdHhxX2xpbWl0X2xvd1tJRUVFODAyMTFfQUNf QkVdLAorCQkJbG9jYWwtPmFxbF90eHFfbGltaXRfaGlnaFtJRUVFODAyMTFfQUNfQkVdLAorCQkJ bG9jYWwtPmFxbF90eHFfbGltaXRfbG93W0lFRUU4MDIxMV9BQ19CS10sCisJCQlsb2NhbC0+YXFs X3R4cV9saW1pdF9oaWdoW0lFRUU4MDIxMV9BQ19CS10pOworCXJldHVybiBzaW1wbGVfcmVhZF9m cm9tX2J1ZmZlcih1c2VyX2J1ZiwgY291bnQsIHBwb3MsCisJCQkJICAgICAgIGJ1ZiwgbGVuKTsK K30KKworc3RhdGljIHNzaXplX3QgYXFsX3R4cV9saW1pdF93cml0ZShzdHJ1Y3QgZmlsZSAqZmls ZSwKKwkJCQkgICBjb25zdCBjaGFyIF9fdXNlciAqdXNlcl9idWYsCisJCQkJICAgc2l6ZV90IGNv dW50LAorCQkJCSAgIGxvZmZfdCAqcHBvcykKK3sKKwlzdHJ1Y3QgaWVlZTgwMjExX2xvY2FsICps b2NhbCA9IGZpbGUtPnByaXZhdGVfZGF0YTsKKwljaGFyIGJ1ZlsxMDBdOworCXNpemVfdCBsZW47 CisJdTMyIGFjLCBxX2xpbWl0X2xvdywgcV9saW1pdF9oaWdoLCBxX2xpbWl0X2xvd19vbGQsIHFf bGltaXRfaGlnaF9vbGQ7CisJc3RydWN0IHN0YV9pbmZvICpzdGE7CisKKwlpZiAoY291bnQgPiBz aXplb2YoYnVmKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoY29weV9mcm9tX3VzZXIoYnVm LCB1c2VyX2J1ZiwgY291bnQpKQorCQlyZXR1cm4gLUVGQVVMVDsKKworCWJ1ZltzaXplb2YoYnVm KSAtIDFdID0gMDsKKwlsZW4gPSBzdHJsZW4oYnVmKTsKKwlpZiAobGVuID4gMCAmJiBidWZbbGVu IC0gMV0gPT0gJ1xuJykKKwkJYnVmW2xlbiAtIDFdID0gMDsKKworCWlmIChzc2NhbmYoYnVmLCAi JXUgJXUgJXUiLCAmYWMsICZxX2xpbWl0X2xvdywgJnFfbGltaXRfaGlnaCkgIT0gMykKKwkJcmV0 dXJuIC1FSU5WQUw7CisKKwlpZiAoYWMgPj0gSUVFRTgwMjExX05VTV9BQ1MpCisJCXJldHVybiAt RUlOVkFMOworCisJcV9saW1pdF9sb3dfb2xkID0gbG9jYWwtPmFxbF90eHFfbGltaXRfbG93W2Fj XTsKKwlxX2xpbWl0X2hpZ2hfb2xkID0gbG9jYWwtPmFxbF90eHFfbGltaXRfaGlnaFthY107CisK Kwlsb2NhbC0+YXFsX3R4cV9saW1pdF9sb3dbYWNdID0gcV9saW1pdF9sb3c7CisJbG9jYWwtPmFx bF90eHFfbGltaXRfaGlnaFthY10gPSBxX2xpbWl0X2hpZ2g7CisKKwltdXRleF9sb2NrKCZsb2Nh bC0+c3RhX210eCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShzdGEsICZsb2NhbC0+c3RhX2xpc3Qs IGxpc3QpIHsKKwkJLyogSWYgYSBzdGEgaGFzIGN1c3RvbWl6ZWQgcXVldWUgbGltaXRzLCBrZWVw IGl0ICovCisJCWlmIChzdGEtPmFpcnRpbWVbYWNdLmFxbF9saW1pdF9sb3cgPT0gcV9saW1pdF9s b3dfb2xkICYmCisJCSAgICBzdGEtPmFpcnRpbWVbYWNdLmFxbF9saW1pdF9oaWdoID09IHFfbGlt aXRfaGlnaF9vbGQpIHsKKwkJCXN0YS0+YWlydGltZVthY10uYXFsX2xpbWl0X2xvdyA9IHFfbGlt aXRfbG93OworCQkJc3RhLT5haXJ0aW1lW2FjXS5hcWxfbGltaXRfaGlnaCA9IHFfbGltaXRfaGln aDsKKwkJfQorCX0KKwltdXRleF91bmxvY2soJmxvY2FsLT5zdGFfbXR4KTsKKwlyZXR1cm4gY291 bnQ7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGFxbF90eHFfbGlt aXRfb3BzID0geworCS53cml0ZSA9IGFxbF90eHFfbGltaXRfd3JpdGUsCisJLnJlYWQgPSBhcWxf dHhxX2xpbWl0X3JlYWQsCisJLm9wZW4gPSBzaW1wbGVfb3BlbiwKKwkubGxzZWVrID0gZGVmYXVs dF9sbHNlZWssCit9OworCiBzdGF0aWMgc3NpemVfdCBmb3JjZV90eF9zdGF0dXNfcmVhZChzdHJ1 Y3QgZmlsZSAqZmlsZSwKIAkJCQkgICAgY2hhciBfX3VzZXIgKnVzZXJfYnVmLAogCQkJCSAgICBz aXplX3QgY291bnQsCkBAIC00NDEsNiArNTIyLDEwIEBAIHZvaWQgZGVidWdmc19od19hZGQoc3Ry dWN0IGllZWU4MDIxMV9sb2NhbCAqbG9jYWwpCiAJZGVidWdmc19jcmVhdGVfdTE2KCJhaXJ0aW1l X2ZsYWdzIiwgMDYwMCwKIAkJCSAgIHBoeWQsICZsb2NhbC0+YWlydGltZV9mbGFncyk7CiAKKwlE RUJVR0ZTX0FERChhcWxfdHhxX2xpbWl0KTsKKwlkZWJ1Z2ZzX2NyZWF0ZV91MzIoImFxbF90aHJl c2hvbGQiLCAwNjAwLAorCQkJICAgcGh5ZCwgJmxvY2FsLT5hcWxfdGhyZXNob2xkKTsKKwogCXN0 YXRzZCA9IGRlYnVnZnNfY3JlYXRlX2Rpcigic3RhdGlzdGljcyIsIHBoeWQpOwogCiAJLyogaWYg dGhlIGRpciBmYWlsZWQsIGRvbid0IHB1dCBhbGwgdGhlIG90aGVyIHRoaW5ncyBpbnRvIHRoZSBy b290ISAqLwpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL2RlYnVnZnNfc3RhLmMgYi9uZXQvbWFj ODAyMTEvZGVidWdmc19zdGEuYwppbmRleCBjOGFkMjBjMjhjNDMuLjAxODVlNmU1ZTVkMSAxMDA2 NDQKLS0tIGEvbmV0L21hYzgwMjExL2RlYnVnZnNfc3RhLmMKKysrIGIvbmV0L21hYzgwMjExL2Rl YnVnZnNfc3RhLmMKQEAgLTE5NywxMCArMTk3LDEyIEBAIHN0YXRpYyBzc2l6ZV90IHN0YV9haXJ0 aW1lX3JlYWQoc3RydWN0IGZpbGUgKmZpbGUsIGNoYXIgX191c2VyICp1c2VyYnVmLAogewogCXN0 cnVjdCBzdGFfaW5mbyAqc3RhID0gZmlsZS0+cHJpdmF0ZV9kYXRhOwogCXN0cnVjdCBpZWVlODAy MTFfbG9jYWwgKmxvY2FsID0gc3RhLT5zZGF0YS0+bG9jYWw7Ci0Jc2l6ZV90IGJ1ZnN6ID0gMjAw OworCXNpemVfdCBidWZzeiA9IDQwMDsKIAljaGFyICpidWYgPSBremFsbG9jKGJ1ZnN6LCBHRlBf S0VSTkVMKSwgKnAgPSBidWY7CiAJdTY0IHJ4X2FpcnRpbWUgPSAwLCB0eF9haXJ0aW1lID0gMDsK IAlzNjQgZGVmaWNpdFtJRUVFODAyMTFfTlVNX0FDU107CisJdTMyIHFfZGVwdGhbSUVFRTgwMjEx X05VTV9BQ1NdOworCXUzMiBxX2xpbWl0X2xbSUVFRTgwMjExX05VTV9BQ1NdLCBxX2xpbWl0X2hb SUVFRTgwMjExX05VTV9BQ1NdOwogCXNzaXplX3QgcnY7CiAJaW50IGFjOwogCkBAIC0yMTIsMTkg KzIxNCwyMiBAQCBzdGF0aWMgc3NpemVfdCBzdGFfYWlydGltZV9yZWFkKHN0cnVjdCBmaWxlICpm aWxlLCBjaGFyIF9fdXNlciAqdXNlcmJ1ZiwKIAkJcnhfYWlydGltZSArPSBzdGEtPmFpcnRpbWVb YWNdLnJ4X2FpcnRpbWU7CiAJCXR4X2FpcnRpbWUgKz0gc3RhLT5haXJ0aW1lW2FjXS50eF9haXJ0 aW1lOwogCQlkZWZpY2l0W2FjXSA9IHN0YS0+YWlydGltZVthY10uZGVmaWNpdDsKKwkJcV9saW1p dF9sW2FjXSA9IHN0YS0+YWlydGltZVthY10uYXFsX2xpbWl0X2xvdzsKKwkJcV9saW1pdF9oW2Fj XSA9IHN0YS0+YWlydGltZVthY10uYXFsX2xpbWl0X2hpZ2g7CiAJCXNwaW5fdW5sb2NrX2JoKCZs b2NhbC0+YWN0aXZlX3R4cV9sb2NrW2FjXSk7CisJCXFfZGVwdGhbYWNdID0gYXRvbWljX3JlYWQo JnN0YS0+YWlydGltZVthY10uYXFsX3R4X3BlbmRpbmcpOwogCX0KIAogCXAgKz0gc2NucHJpbnRm KHAsIGJ1ZnN6ICsgYnVmIC0gcCwKIAkJIlJYOiAlbGx1IHVzXG5UWDogJWxsdSB1c1xuV2VpZ2h0 OiAldVxuIgotCQkiRGVmaWNpdDogVk86ICVsbGQgdXMgVkk6ICVsbGQgdXMgQkU6ICVsbGQgdXMg Qks6ICVsbGQgdXNcbiIsCi0JCXJ4X2FpcnRpbWUsCi0JCXR4X2FpcnRpbWUsCi0JCXN0YS0+YWly dGltZV93ZWlnaHQsCi0JCWRlZmljaXRbMF0sCi0JCWRlZmljaXRbMV0sCi0JCWRlZmljaXRbMl0s Ci0JCWRlZmljaXRbM10pOworCQkiRGVmaWNpdDogVk86ICVsbGQgdXMgVkk6ICVsbGQgdXMgQkU6 ICVsbGQgdXMgQks6ICVsbGQgdXNcbiIKKwkJIlEgZGVwdGg6IFZPOiAldSB1cyBWSTogJXUgdXMg QkU6ICV1IHVzIEJLOiAldSB1c1xuIgorCQkiUSBsaW1pdFtsb3cvaGlnaF06IFZPOiAldS8ldSBW STogJXUvJXUgQkU6ICV1LyV1IEJLOiAldS8ldVxuIiwKKwkJcnhfYWlydGltZSwgdHhfYWlydGlt ZSwgc3RhLT5haXJ0aW1lX3dlaWdodCwKKwkJZGVmaWNpdFswXSwgZGVmaWNpdFsxXSwgZGVmaWNp dFsyXSwgZGVmaWNpdFszXSwKKwkJcV9kZXB0aFswXSwgcV9kZXB0aFsxXSwgcV9kZXB0aFsyXSwg cV9kZXB0aFszXSwKKwkJcV9saW1pdF9sWzBdLCBxX2xpbWl0X2hbMF0sIHFfbGltaXRfbFsxXSwg cV9saW1pdF9oWzFdLAorCQlxX2xpbWl0X2xbMl0sIHFfbGltaXRfaFsyXSwgcV9saW1pdF9sWzNd LCBxX2xpbWl0X2hbM10pLAogCiAJcnYgPSBzaW1wbGVfcmVhZF9mcm9tX2J1ZmZlcih1c2VyYnVm LCBjb3VudCwgcHBvcywgYnVmLCBwIC0gYnVmKTsKIAlrZnJlZShidWYpOwpAQCAtMjM2LDcgKzI0 MSwyNSBAQCBzdGF0aWMgc3NpemVfdCBzdGFfYWlydGltZV93cml0ZShzdHJ1Y3QgZmlsZSAqZmls ZSwgY29uc3QgY2hhciBfX3VzZXIgKnVzZXJidWYsCiB7CiAJc3RydWN0IHN0YV9pbmZvICpzdGEg PSBmaWxlLT5wcml2YXRlX2RhdGE7CiAJc3RydWN0IGllZWU4MDIxMV9sb2NhbCAqbG9jYWwgPSBz dGEtPnNkYXRhLT5sb2NhbDsKLQlpbnQgYWM7CisJdTMyIGFjLCBxX2xpbWl0X2wsIHFfbGltaXRf aDsKKwljaGFyIF9idWZbMTAwXSA9IHt9LCAqYnVmID0gX2J1ZjsKKworCWlmIChjb3VudCA+IHNp emVvZihfYnVmKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoY29weV9mcm9tX3VzZXIoYnVm LCB1c2VyYnVmLCBjb3VudCkpCisJCXJldHVybiAtRUZBVUxUOworCisJYnVmW3NpemVvZihfYnVm KSAtIDFdID0gJ1wwJzsKKwlpZiAoc3NjYW5mKGJ1ZiwgInF1ZXVlIGxpbWl0ICV1ICV1ICV1Iiwg JmFjLCAmcV9saW1pdF9sLCAmcV9saW1pdF9oKQorCSAgICAhPSAzKQorCQlyZXR1cm4gLUVJTlZB TDsKKworCWlmIChhYyA+PSBJRUVFODAyMTFfTlVNX0FDUykKKwkJcmV0dXJuIC1FSU5WQUw7CisK KwlzdGEtPmFpcnRpbWVbYWNdLmFxbF9saW1pdF9sb3cgPSBxX2xpbWl0X2w7CisJc3RhLT5haXJ0 aW1lW2FjXS5hcWxfbGltaXRfaGlnaCA9IHFfbGltaXRfaDsKIAogCWZvciAoYWMgPSAwOyBhYyA8 IElFRUU4MDIxMV9OVU1fQUNTOyBhYysrKSB7CiAJCXNwaW5fbG9ja19iaCgmbG9jYWwtPmFjdGl2 ZV90eHFfbG9ja1thY10pOwpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL2llZWU4MDIxMV9pLmgg Yi9uZXQvbWFjODAyMTEvaWVlZTgwMjExX2kuaAppbmRleCAyMjVlYTRlM2NkNzYuLmFkMTViM2Jl OGJiMyAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL2llZWU4MDIxMV9pLmgKKysrIGIvbmV0L21h YzgwMjExL2llZWU4MDIxMV9pLmgKQEAgLTExNDIsNiArMTE0MiwxMCBAQCBzdHJ1Y3QgaWVlZTgw MjExX2xvY2FsIHsKIAl1MTYgc2NoZWR1bGVfcm91bmRbSUVFRTgwMjExX05VTV9BQ1NdOwogCiAJ dTE2IGFpcnRpbWVfZmxhZ3M7CisJdTMyIGFxbF90eHFfbGltaXRfbG93W0lFRUU4MDIxMV9OVU1f QUNTXTsKKwl1MzIgYXFsX3R4cV9saW1pdF9oaWdoW0lFRUU4MDIxMV9OVU1fQUNTXTsKKwl1MzIg YXFsX3RocmVzaG9sZDsKKwlhdG9taWNfdCBhcWxfdG90YWxfcGVuZGluZ19haXJ0aW1lOwogCiAJ Y29uc3Qgc3RydWN0IGllZWU4MDIxMV9vcHMgKm9wczsKIApkaWZmIC0tZ2l0IGEvbmV0L21hYzgw MjExL21haW4uYyBiL25ldC9tYWM4MDIxMS9tYWluLmMKaW5kZXggYWJhMDk0YjRjY2ZjLi4wNzFl YTkyYTM3NDggMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9tYWluLmMKKysrIGIvbmV0L21hYzgw MjExL21haW4uYwpAQCAtNjY3LDggKzY2NywxNiBAQCBzdHJ1Y3QgaWVlZTgwMjExX2h3ICppZWVl ODAyMTFfYWxsb2NfaHdfbm0oc2l6ZV90IHByaXZfZGF0YV9sZW4sCiAJZm9yIChpID0gMDsgaSA8 IElFRUU4MDIxMV9OVU1fQUNTOyBpKyspIHsKIAkJSU5JVF9MSVNUX0hFQUQoJmxvY2FsLT5hY3Rp dmVfdHhxc1tpXSk7CiAJCXNwaW5fbG9ja19pbml0KCZsb2NhbC0+YWN0aXZlX3R4cV9sb2NrW2ld KTsKKwkJbG9jYWwtPmFxbF90eHFfbGltaXRfbG93W2ldID0gSUVFRTgwMjExX0RFRkFVTFRfQVFM X1RYUV9MSU1JVF9MOworCQlsb2NhbC0+YXFsX3R4cV9saW1pdF9oaWdoW2ldID0KKwkJCUlFRUU4 MDIxMV9ERUZBVUxUX0FRTF9UWFFfTElNSVRfSDsKIAl9Ci0JbG9jYWwtPmFpcnRpbWVfZmxhZ3Mg PSBBSVJUSU1FX1VTRV9UWCB8IEFJUlRJTUVfVVNFX1JYOworCisJbG9jYWwtPmFpcnRpbWVfZmxh Z3MgPSBBSVJUSU1FX1VTRV9UWCB8CisJCQkgICAgICAgQUlSVElNRV9VU0VfUlggfAorCQkJICAg ICAgIEFJUlRJTUVfVVNFX0FRTDsKKwlsb2NhbC0+YXFsX3RocmVzaG9sZCA9IElFRUU4MDIxMV9B UUxfVEhSRVNIT0xEOworCWF0b21pY19zZXQoJmxvY2FsLT5hcWxfdG90YWxfcGVuZGluZ19haXJ0 aW1lLCAwKTsKIAogCUlOSVRfTElTVF9IRUFEKCZsb2NhbC0+Y2hhbmN0eF9saXN0KTsKIAltdXRl eF9pbml0KCZsb2NhbC0+Y2hhbmN0eF9tdHgpOwpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL3N0 YV9pbmZvLmMgYi9uZXQvbWFjODAyMTEvc3RhX2luZm8uYwppbmRleCA0NjVkODNiMTM1ODIuLjFm ZTAyMDIyYTMxYSAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL3N0YV9pbmZvLmMKKysrIGIvbmV0 L21hYzgwMjExL3N0YV9pbmZvLmMKQEAgLTQxNiw2ICs0MTYsOSBAQCBzdHJ1Y3Qgc3RhX2luZm8g KnN0YV9pbmZvX2FsbG9jKHN0cnVjdCBpZWVlODAyMTFfc3ViX2lmX2RhdGEgKnNkYXRhLAogCQlz a2JfcXVldWVfaGVhZF9pbml0KCZzdGEtPnBzX3R4X2J1ZltpXSk7CiAJCXNrYl9xdWV1ZV9oZWFk X2luaXQoJnN0YS0+dHhfZmlsdGVyZWRbaV0pOwogCQlzdGEtPmFpcnRpbWVbaV0uZGVmaWNpdCA9 IHN0YS0+YWlydGltZV93ZWlnaHQ7CisJCWF0b21pY19zZXQoJnN0YS0+YWlydGltZVtpXS5hcWxf dHhfcGVuZGluZywgMCk7CisJCXN0YS0+YWlydGltZVtpXS5hcWxfbGltaXRfbG93ID0gbG9jYWwt PmFxbF90eHFfbGltaXRfbG93W2ldOworCQlzdGEtPmFpcnRpbWVbaV0uYXFsX2xpbWl0X2hpZ2gg PSBsb2NhbC0+YXFsX3R4cV9saW1pdF9oaWdoW2ldOwogCX0KIAogCWZvciAoaSA9IDA7IGkgPCBJ RUVFODAyMTFfTlVNX1RJRFM7IGkrKykKQEAgLTE5MTMsNiArMTkxNiw0MSBAQCB2b2lkIGllZWU4 MDIxMV9zdGFfcmVnaXN0ZXJfYWlydGltZShzdHJ1Y3QgaWVlZTgwMjExX3N0YSAqcHVic3RhLCB1 OCB0aWQsCiB9CiBFWFBPUlRfU1lNQk9MKGllZWU4MDIxMV9zdGFfcmVnaXN0ZXJfYWlydGltZSk7 CiAKK3ZvaWQgaWVlZTgwMjExX3N0YV91cGRhdGVfcGVuZGluZ19haXJ0aW1lKHN0cnVjdCBpZWVl ODAyMTFfbG9jYWwgKmxvY2FsLAorCQkJCQkgIHN0cnVjdCBzdGFfaW5mbyAqc3RhLCB1OCBhYywK KwkJCQkJICB1MTYgdHhfYWlydGltZSwgYm9vbCB0eF9jb21wbGV0ZWQpCit7CisJaW50IHR4X3Bl bmRpbmc7CisKKwlpZiAoIXR4X2NvbXBsZXRlZCkgeworCQlpZiAoc3RhKQorCQkJYXRvbWljX2Fk ZCh0eF9haXJ0aW1lLAorCQkJCSAgICZzdGEtPmFpcnRpbWVbYWNdLmFxbF90eF9wZW5kaW5nKTsK KworCQlhdG9taWNfYWRkKHR4X2FpcnRpbWUsICZsb2NhbC0+YXFsX3RvdGFsX3BlbmRpbmdfYWly dGltZSk7CisJCXJldHVybjsKKwl9CisKKwlpZiAoc3RhKSB7CisJCXR4X3BlbmRpbmcgPSBhdG9t aWNfc3ViX3JldHVybih0eF9haXJ0aW1lLAorCQkJCQkgICAgICAgJnN0YS0+YWlydGltZVthY10u YXFsX3R4X3BlbmRpbmcpOworCQlpZiAoV0FSTl9PTkNFKHR4X3BlbmRpbmcgPCAwLAorCQkJICAg ICAgIlNUQSAlcE0gQUMgJWQgdHhxIHBlbmRpbmcgYWlydGltZSB1bmRlcmZsb3c6ICV1LCAldSIs CisJCQkgICAgICBzdGEtPmFkZHIsIGFjLCB0eF9wZW5kaW5nLCB0eF9haXJ0aW1lKSkKKwkJCWF0 b21pY19jbXB4Y2hnKCZzdGEtPmFpcnRpbWVbYWNdLmFxbF90eF9wZW5kaW5nLAorCQkJCSAgICAg ICB0eF9wZW5kaW5nLCAwKTsKKwl9CisKKwl0eF9wZW5kaW5nID0gYXRvbWljX3N1Yl9yZXR1cm4o dHhfYWlydGltZSwKKwkJCQkgICAgICAgJmxvY2FsLT5hcWxfdG90YWxfcGVuZGluZ19haXJ0aW1l KTsKKwlpZiAoV0FSTl9PTkNFKHR4X3BlbmRpbmcgPCAwLAorCQkgICAgICAiRGV2aWNlICVzIEFD ICVkIHBlbmRpbmcgYWlydGltZSB1bmRlcmZsb3c6ICV1LCAldSIsCisJCSAgICAgIHdpcGh5X25h bWUobG9jYWwtPmh3LndpcGh5KSwgYWMsIHR4X3BlbmRpbmcsCisJCSAgICAgIHR4X2FpcnRpbWUp KQorCQlhdG9taWNfY21weGNoZygmbG9jYWwtPmFxbF90b3RhbF9wZW5kaW5nX2FpcnRpbWUsCisJ CQkgICAgICAgdHhfcGVuZGluZywgMCk7Cit9CisKIGludCBzdGFfaW5mb19tb3ZlX3N0YXRlKHN0 cnVjdCBzdGFfaW5mbyAqc3RhLAogCQkJZW51bSBpZWVlODAyMTFfc3RhX3N0YXRlIG5ld19zdGF0 ZSkKIHsKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9zdGFfaW5mby5oIGIvbmV0L21hYzgwMjEx L3N0YV9pbmZvLmgKaW5kZXggODBlNzY1NjkxNDRlLi4wNjA4ZDQ5YjM4MjYgMTAwNjQ0Ci0tLSBh L25ldC9tYWM4MDIxMS9zdGFfaW5mby5oCisrKyBiL25ldC9tYWM4MDIxMS9zdGFfaW5mby5oCkBA IC0xMjcsMTMgKzEyNywyMSBAQCBlbnVtIGllZWU4MDIxMV9hZ2dfc3RvcF9yZWFzb24gewogLyog RGVidWdmcyBmbGFncyB0byBlbmFibGUvZGlzYWJsZSB1c2Ugb2YgUlgvVFggYWlydGltZSBpbiBz Y2hlZHVsZXIgKi8KICNkZWZpbmUgQUlSVElNRV9VU0VfVFgJCUJJVCgwKQogI2RlZmluZSBBSVJU SU1FX1VTRV9SWAkJQklUKDEpCisjZGVmaW5lIEFJUlRJTUVfVVNFX0FRTAkJQklUKDIpCiAKIHN0 cnVjdCBhaXJ0aW1lX2luZm8gewogCXU2NCByeF9haXJ0aW1lOwogCXU2NCB0eF9haXJ0aW1lOwog CXM2NCBkZWZpY2l0OworCWF0b21pY190IGFxbF90eF9wZW5kaW5nOyAvKiBFc3RpbWF0ZWQgYWly dGltZSBmb3IgZnJhbWVzIHBlbmRpbmcgKi8KKwl1MzIgYXFsX2xpbWl0X2xvdzsKKwl1MzIgYXFs X2xpbWl0X2hpZ2g7CiB9OwogCit2b2lkIGllZWU4MDIxMV9zdGFfdXBkYXRlX3BlbmRpbmdfYWly dGltZShzdHJ1Y3QgaWVlZTgwMjExX2xvY2FsICpsb2NhbCwKKwkJCQkJICBzdHJ1Y3Qgc3RhX2lu Zm8gKnN0YSwgdTggYWMsCisJCQkJCSAgdTE2IHR4X2FpcnRpbWUsIGJvb2wgdHhfY29tcGxldGVk KTsKKwogc3RydWN0IHN0YV9pbmZvOwogCiAvKioKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS90 eC5jIGIvbmV0L21hYzgwMjExL3R4LmMKaW5kZXggZGIzOGJlMWI3NWZhLi5hYWZjNjdiNTYyZWIg MTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS90eC5jCisrKyBiL25ldC9tYWM4MDIxMS90eC5jCkBA IC0zNjc0LDcgKzM2NzQsOCBAQCBzdHJ1Y3QgaWVlZTgwMjExX3R4cSAqaWVlZTgwMjExX25leHRf dHhxKHN0cnVjdCBpZWVlODAyMTFfaHcgKmh3LCB1OCBhYykKIHsKIAlzdHJ1Y3QgaWVlZTgwMjEx X2xvY2FsICpsb2NhbCA9IGh3X3RvX2xvY2FsKGh3KTsKIAlzdHJ1Y3QgaWVlZTgwMjExX3R4cSAq cmV0ID0gTlVMTDsKLQlzdHJ1Y3QgdHhxX2luZm8gKnR4cWkgPSBOVUxMOworCXN0cnVjdCB0eHFf aW5mbyAqdHhxaSA9IE5VTEwsICpoZWFkID0gTlVMTDsKKwlib29sIGZvdW5kX2VsaWdpYmxlX3R4 cSA9IGZhbHNlOwogCiAJc3Bpbl9sb2NrX2JoKCZsb2NhbC0+YWN0aXZlX3R4cV9sb2NrW2FjXSk7 CiAKQEAgLTM2ODUsMTMgKzM2ODYsMjYgQEAgc3RydWN0IGllZWU4MDIxMV90eHEgKmllZWU4MDIx MV9uZXh0X3R4cShzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodywgdTggYWMpCiAJaWYgKCF0eHFpKQog CQlnb3RvIG91dDsKIAorCWlmICh0eHFpID09IGhlYWQgJiYgIWZvdW5kX2VsaWdpYmxlX3R4cSkK KwkJZ290byBvdXQ7CisKKwlpZiAoIWhlYWQpCisJCWhlYWQgPSB0eHFpOworCiAJaWYgKHR4cWkt PnR4cS5zdGEpIHsKIAkJc3RydWN0IHN0YV9pbmZvICpzdGEgPSBjb250YWluZXJfb2YodHhxaS0+ dHhxLnN0YSwKLQkJCQkJCXN0cnVjdCBzdGFfaW5mbywgc3RhKTsKKwkJCQkJCSAgICBzdHJ1Y3Qg c3RhX2luZm8sIHN0YSk7CisJCWJvb2wgYXFsX2NoZWNrID0gaWVlZTgwMjExX3R4cV9haXJ0aW1l X2NoZWNrKGh3LCAmdHhxaS0+dHhxKTsKKwkJczY0IGRlZmljaXQgPSBzdGEtPmFpcnRpbWVbdHhx aS0+dHhxLmFjXS5kZWZpY2l0OworCisJCWlmIChhcWxfY2hlY2spCisJCQlmb3VuZF9lbGlnaWJs ZV90eHEgPSB0cnVlOwogCi0JCWlmIChzdGEtPmFpcnRpbWVbdHhxaS0+dHhxLmFjXS5kZWZpY2l0 IDwgMCkgeworCQlpZiAoZGVmaWNpdCA8IDApCiAJCQlzdGEtPmFpcnRpbWVbdHhxaS0+dHhxLmFj XS5kZWZpY2l0ICs9CiAJCQkJc3RhLT5haXJ0aW1lX3dlaWdodDsKKworCQlpZiAoZGVmaWNpdCA8 IDAgfHwgIWFxbF9jaGVjaykgewogCQkJbGlzdF9tb3ZlX3RhaWwoJnR4cWktPnNjaGVkdWxlX29y ZGVyLAogCQkJCSAgICAgICAmbG9jYWwtPmFjdGl2ZV90eHFzW3R4cWktPnR4cS5hY10pOwogCQkJ Z290byBiZWdpbjsKQEAgLTM3NDUsNiArMzc1OSwzMyBAQCB2b2lkIF9faWVlZTgwMjExX3NjaGVk dWxlX3R4cShzdHJ1Y3QgaWVlZTgwMjExX2h3ICpodywKIH0KIEVYUE9SVF9TWU1CT0woX19pZWVl ODAyMTFfc2NoZWR1bGVfdHhxKTsKIAorYm9vbCBpZWVlODAyMTFfdHhxX2FpcnRpbWVfY2hlY2so c3RydWN0IGllZWU4MDIxMV9odyAqaHcsCisJCQkJIHN0cnVjdCBpZWVlODAyMTFfdHhxICp0eHEp Cit7CisJc3RydWN0IHN0YV9pbmZvICpzdGE7CisJc3RydWN0IGllZWU4MDIxMV9sb2NhbCAqbG9j YWwgPSBod190b19sb2NhbChodyk7CisKKwlpZiAoIShsb2NhbC0+YWlydGltZV9mbGFncyAmIEFJ UlRJTUVfVVNFX0FRTCkpCisJCXJldHVybiB0cnVlOworCisJaWYgKCF0eHEtPnN0YSkKKwkJcmV0 dXJuIHRydWU7CisKKwlzdGEgPSBjb250YWluZXJfb2YodHhxLT5zdGEsIHN0cnVjdCBzdGFfaW5m bywgc3RhKTsKKwlpZiAoYXRvbWljX3JlYWQoJnN0YS0+YWlydGltZVt0eHEtPmFjXS5hcWxfdHhf cGVuZGluZykgPAorCSAgICBzdGEtPmFpcnRpbWVbdHhxLT5hY10uYXFsX2xpbWl0X2xvdykKKwkJ cmV0dXJuIHRydWU7CisKKwlpZiAoYXRvbWljX3JlYWQoJmxvY2FsLT5hcWxfdG90YWxfcGVuZGlu Z19haXJ0aW1lKSA8CisJICAgIGxvY2FsLT5hcWxfdGhyZXNob2xkICYmCisJICAgIGF0b21pY19y ZWFkKCZzdGEtPmFpcnRpbWVbdHhxLT5hY10uYXFsX3R4X3BlbmRpbmcpIDwKKwkgICAgc3RhLT5h aXJ0aW1lW3R4cS0+YWNdLmFxbF9saW1pdF9oaWdoKQorCQlyZXR1cm4gdHJ1ZTsKKworCXJldHVy biBmYWxzZTsKK30KK0VYUE9SVF9TWU1CT0woaWVlZTgwMjExX3R4cV9haXJ0aW1lX2NoZWNrKTsK KwogYm9vbCBpZWVlODAyMTFfdHhxX21heV90cmFuc21pdChzdHJ1Y3QgaWVlZTgwMjExX2h3ICpo dywKIAkJCQlzdHJ1Y3QgaWVlZTgwMjExX3R4cSAqdHhxKQogewoKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmF0aDEwayBtYWlsaW5nIGxpc3QKYXRoMTBr QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9s aXN0aW5mby9hdGgxMGsK