From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 51CE336A; Fri, 15 Sep 2023 01:05:23 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9789CC433CB; Fri, 15 Sep 2023 01:05:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1694739923; bh=/+T2kHP+yN3i1UHDJJ9EztJ2b09LmvcDHhfaOKfFahQ=; h=From:To:Cc:Subject:Date:From; b=dMzt4disWJkzHTxFN3bUfN7GkEZkVPUtevTTYC1IMRd4ABzfvyI69sjNGYdEhsNwv QzF38iBkEarTp/dWqBHdgdJQLckOoamXtc2Q1Kuori2h6sw9le7Py7PcLVnoNQtloy ij4yg7ZNoULCNxmWNt+z3LPaC4Dx5JAleCy0UxbaxoqBLv00PF92eHr7D01QypXwmb 6/UjYFBYnnhdq9wq+y5MjME2wEio78d9qobbXPQT6xtLjBVQUOr+pXcXWonOpMrqT6 Dko6viiNm/Gx7j4A4AXJ952vHy7bJKF9L3/qnpckNlQPbiIHKLlhIfY86RVxP5KW8/ O+AHF+dStJAvA== From: Jisheng Zhang To: Giuseppe Cavallaro , Alexandre Torgue , Jose Abreu , "David S . Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Maxime Coquelin , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland Cc: netdev@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-sunxi@lists.linux.dev, linux-stm32@st-md-mailman.stormreply.com, johannes@sipsolutions.net, =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= Subject: [PATCH] net: stmmac: fix incorrect rxq|txq_stats reference Date: Fri, 15 Sep 2023 08:53:16 +0800 Message-Id: <20230915005316.592-1-jszhang@kernel.org> X-Mailer: git-send-email 2.40.0 Precedence: bulk X-Mailing-List: linux-sunxi@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit commit 133466c3bbe1 ("net: stmmac: use per-queue 64 bit statistics where necessary") caused one regression as found by Uwe, the backtrace looks like: INFO: trying to register non-static key. The code is fine but needs lockdep annotation, or maybe you didn't initialize this object before use? turning off the locking correctness validator. CPU: 0 PID: 1 Comm: swapper/0 Not tainted 6.5.0-rc1-00449-g133466c3bbe1-dirty #21 Hardware name: STM32 (Device Tree Support) unwind_backtrace from show_stack+0x18/0x1c show_stack from dump_stack_lvl+0x60/0x90 dump_stack_lvl from register_lock_class+0x98c/0x99c register_lock_class from __lock_acquire+0x74/0x293c __lock_acquire from lock_acquire+0x134/0x398 lock_acquire from stmmac_get_stats64+0x2ac/0x2fc stmmac_get_stats64 from dev_get_stats+0x44/0x130 dev_get_stats from rtnl_fill_stats+0x38/0x120 rtnl_fill_stats from rtnl_fill_ifinfo+0x834/0x17f4 rtnl_fill_ifinfo from rtmsg_ifinfo_build_skb+0xc0/0x144 rtmsg_ifinfo_build_skb from rtmsg_ifinfo+0x50/0x88 rtmsg_ifinfo from __dev_notify_flags+0xc0/0xec __dev_notify_flags from dev_change_flags+0x50/0x5c dev_change_flags from ip_auto_config+0x2f4/0x1260 ip_auto_config from do_one_initcall+0x70/0x35c do_one_initcall from kernel_init_freeable+0x2ac/0x308 kernel_init_freeable from kernel_init+0x1c/0x138 kernel_init from ret_from_fork+0x14/0x2c The reason is the rxq|txq_stats structures are not what expected because stmmac_open() -> __stmmac_open() the structure is overwritten by "memcpy(&priv->dma_conf, dma_conf, sizeof(*dma_conf));" This causes the well initialized syncp member of rxq|txq_stats is overwritten unexpectedly as pointed out by Johannes and Uwe. Fix this issue by moving rxq|txq_stats back to stmmac_extra_stats. For SMP cache friendly, we also mark stmmac_txq_stats and stmmac_rxq_stats as ____cacheline_aligned_in_smp. Fixes: 133466c3bbe1 ("net: stmmac: use per-queue 64 bit statistics where necessary") Signed-off-by: Jisheng Zhang Reported-by: Uwe Kleine-König --- drivers/net/ethernet/stmicro/stmmac/common.h | 7 +- .../net/ethernet/stmicro/stmmac/dwmac-sun8i.c | 16 +-- .../net/ethernet/stmicro/stmmac/dwmac4_lib.c | 16 +-- .../net/ethernet/stmicro/stmmac/dwmac_lib.c | 16 +-- .../ethernet/stmicro/stmmac/dwxgmac2_dma.c | 16 +-- drivers/net/ethernet/stmicro/stmmac/stmmac.h | 2 - .../ethernet/stmicro/stmmac/stmmac_ethtool.c | 32 ++--- .../net/ethernet/stmicro/stmmac/stmmac_main.c | 125 ++++++++++-------- 8 files changed, 120 insertions(+), 110 deletions(-) diff --git a/drivers/net/ethernet/stmicro/stmmac/common.h b/drivers/net/ethernet/stmicro/stmmac/common.h index 403cb397d4d3..1e996c29043d 100644 --- a/drivers/net/ethernet/stmicro/stmmac/common.h +++ b/drivers/net/ethernet/stmicro/stmmac/common.h @@ -70,7 +70,7 @@ struct stmmac_txq_stats { u64 tx_tso_frames; u64 tx_tso_nfrags; struct u64_stats_sync syncp; -}; +} ____cacheline_aligned_in_smp; struct stmmac_rxq_stats { u64 rx_bytes; @@ -79,7 +79,7 @@ struct stmmac_rxq_stats { u64 rx_normal_irq_n; u64 napi_poll; struct u64_stats_sync syncp; -}; +} ____cacheline_aligned_in_smp; /* Extra statistic and debug information exposed by ethtool */ struct stmmac_extra_stats { @@ -202,6 +202,9 @@ struct stmmac_extra_stats { unsigned long mtl_est_hlbf; unsigned long mtl_est_btre; unsigned long mtl_est_btrlm; + /* per queue statistics */ + struct stmmac_txq_stats txq_stats[MTL_MAX_TX_QUEUES]; + struct stmmac_rxq_stats rxq_stats[MTL_MAX_RX_QUEUES]; unsigned long rx_dropped; unsigned long rx_errors; unsigned long tx_dropped; diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c index 01e77368eef1..465ff1fd4785 100644 --- a/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c +++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-sun8i.c @@ -441,8 +441,8 @@ static int sun8i_dwmac_dma_interrupt(struct stmmac_priv *priv, struct stmmac_extra_stats *x, u32 chan, u32 dir) { - struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[chan]; - struct stmmac_tx_queue *tx_q = &priv->dma_conf.tx_queue[chan]; + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[chan]; + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[chan]; int ret = 0; u32 v; @@ -455,9 +455,9 @@ static int sun8i_dwmac_dma_interrupt(struct stmmac_priv *priv, if (v & EMAC_TX_INT) { ret |= handle_tx; - u64_stats_update_begin(&tx_q->txq_stats.syncp); - tx_q->txq_stats.tx_normal_irq_n++; - u64_stats_update_end(&tx_q->txq_stats.syncp); + u64_stats_update_begin(&txq_stats->syncp); + txq_stats->tx_normal_irq_n++; + u64_stats_update_end(&txq_stats->syncp); } if (v & EMAC_TX_DMA_STOP_INT) @@ -479,9 +479,9 @@ static int sun8i_dwmac_dma_interrupt(struct stmmac_priv *priv, if (v & EMAC_RX_INT) { ret |= handle_rx; - u64_stats_update_begin(&rx_q->rxq_stats.syncp); - rx_q->rxq_stats.rx_normal_irq_n++; - u64_stats_update_end(&rx_q->rxq_stats.syncp); + u64_stats_update_begin(&rxq_stats->syncp); + rxq_stats->rx_normal_irq_n++; + u64_stats_update_end(&rxq_stats->syncp); } if (v & EMAC_RX_BUF_UA_INT) diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_lib.c b/drivers/net/ethernet/stmicro/stmmac/dwmac4_lib.c index 980e5f8a37ec..9470d3fd2ded 100644 --- a/drivers/net/ethernet/stmicro/stmmac/dwmac4_lib.c +++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_lib.c @@ -171,8 +171,8 @@ int dwmac4_dma_interrupt(struct stmmac_priv *priv, void __iomem *ioaddr, const struct dwmac4_addrs *dwmac4_addrs = priv->plat->dwmac4_addrs; u32 intr_status = readl(ioaddr + DMA_CHAN_STATUS(dwmac4_addrs, chan)); u32 intr_en = readl(ioaddr + DMA_CHAN_INTR_ENA(dwmac4_addrs, chan)); - struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[chan]; - struct stmmac_tx_queue *tx_q = &priv->dma_conf.tx_queue[chan]; + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[chan]; + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[chan]; int ret = 0; if (dir == DMA_DIR_RX) @@ -201,15 +201,15 @@ int dwmac4_dma_interrupt(struct stmmac_priv *priv, void __iomem *ioaddr, } /* TX/RX NORMAL interrupts */ if (likely(intr_status & DMA_CHAN_STATUS_RI)) { - u64_stats_update_begin(&rx_q->rxq_stats.syncp); - rx_q->rxq_stats.rx_normal_irq_n++; - u64_stats_update_end(&rx_q->rxq_stats.syncp); + u64_stats_update_begin(&rxq_stats->syncp); + rxq_stats->rx_normal_irq_n++; + u64_stats_update_end(&rxq_stats->syncp); ret |= handle_rx; } if (likely(intr_status & DMA_CHAN_STATUS_TI)) { - u64_stats_update_begin(&tx_q->txq_stats.syncp); - tx_q->txq_stats.tx_normal_irq_n++; - u64_stats_update_end(&tx_q->txq_stats.syncp); + u64_stats_update_begin(&txq_stats->syncp); + txq_stats->tx_normal_irq_n++; + u64_stats_update_end(&txq_stats->syncp); ret |= handle_tx; } diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac_lib.c b/drivers/net/ethernet/stmicro/stmmac/dwmac_lib.c index aaa09b16b016..7907d62d3437 100644 --- a/drivers/net/ethernet/stmicro/stmmac/dwmac_lib.c +++ b/drivers/net/ethernet/stmicro/stmmac/dwmac_lib.c @@ -162,8 +162,8 @@ static void show_rx_process_state(unsigned int status) int dwmac_dma_interrupt(struct stmmac_priv *priv, void __iomem *ioaddr, struct stmmac_extra_stats *x, u32 chan, u32 dir) { - struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[chan]; - struct stmmac_tx_queue *tx_q = &priv->dma_conf.tx_queue[chan]; + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[chan]; + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[chan]; int ret = 0; /* read the status register (CSR5) */ u32 intr_status = readl(ioaddr + DMA_STATUS); @@ -215,16 +215,16 @@ int dwmac_dma_interrupt(struct stmmac_priv *priv, void __iomem *ioaddr, u32 value = readl(ioaddr + DMA_INTR_ENA); /* to schedule NAPI on real RIE event. */ if (likely(value & DMA_INTR_ENA_RIE)) { - u64_stats_update_begin(&rx_q->rxq_stats.syncp); - rx_q->rxq_stats.rx_normal_irq_n++; - u64_stats_update_end(&rx_q->rxq_stats.syncp); + u64_stats_update_begin(&rxq_stats->syncp); + rxq_stats->rx_normal_irq_n++; + u64_stats_update_end(&rxq_stats->syncp); ret |= handle_rx; } } if (likely(intr_status & DMA_STATUS_TI)) { - u64_stats_update_begin(&tx_q->txq_stats.syncp); - tx_q->txq_stats.tx_normal_irq_n++; - u64_stats_update_end(&tx_q->txq_stats.syncp); + u64_stats_update_begin(&txq_stats->syncp); + txq_stats->tx_normal_irq_n++; + u64_stats_update_end(&txq_stats->syncp); ret |= handle_tx; } if (unlikely(intr_status & DMA_STATUS_ERI)) diff --git a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c index fa69d64a8694..3cde695fec91 100644 --- a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c +++ b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c @@ -337,8 +337,8 @@ static int dwxgmac2_dma_interrupt(struct stmmac_priv *priv, struct stmmac_extra_stats *x, u32 chan, u32 dir) { - struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[chan]; - struct stmmac_tx_queue *tx_q = &priv->dma_conf.tx_queue[chan]; + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[chan]; + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[chan]; u32 intr_status = readl(ioaddr + XGMAC_DMA_CH_STATUS(chan)); u32 intr_en = readl(ioaddr + XGMAC_DMA_CH_INT_EN(chan)); int ret = 0; @@ -367,15 +367,15 @@ static int dwxgmac2_dma_interrupt(struct stmmac_priv *priv, /* TX/RX NORMAL interrupts */ if (likely(intr_status & XGMAC_NIS)) { if (likely(intr_status & XGMAC_RI)) { - u64_stats_update_begin(&rx_q->rxq_stats.syncp); - rx_q->rxq_stats.rx_normal_irq_n++; - u64_stats_update_end(&rx_q->rxq_stats.syncp); + u64_stats_update_begin(&rxq_stats->syncp); + rxq_stats->rx_normal_irq_n++; + u64_stats_update_end(&rxq_stats->syncp); ret |= handle_rx; } if (likely(intr_status & (XGMAC_TI | XGMAC_TBU))) { - u64_stats_update_begin(&tx_q->txq_stats.syncp); - tx_q->txq_stats.tx_normal_irq_n++; - u64_stats_update_end(&tx_q->txq_stats.syncp); + u64_stats_update_begin(&txq_stats->syncp); + txq_stats->tx_normal_irq_n++; + u64_stats_update_end(&txq_stats->syncp); ret |= handle_tx; } } diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac.h b/drivers/net/ethernet/stmicro/stmmac/stmmac.h index 3401e888a9f6..cd7a9768de5f 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac.h +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac.h @@ -78,7 +78,6 @@ struct stmmac_tx_queue { dma_addr_t dma_tx_phy; dma_addr_t tx_tail_addr; u32 mss; - struct stmmac_txq_stats txq_stats; }; struct stmmac_rx_buffer { @@ -123,7 +122,6 @@ struct stmmac_rx_queue { unsigned int len; unsigned int error; } state; - struct stmmac_rxq_stats rxq_stats; }; struct stmmac_channel { diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c index b7ac7abecdd3..6aa5c0556d22 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c @@ -548,14 +548,14 @@ static void stmmac_get_per_qstats(struct stmmac_priv *priv, u64 *data) pos = data; for (q = 0; q < tx_cnt; q++) { - struct stmmac_tx_queue *tx_q = &priv->dma_conf.tx_queue[q]; + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[q]; struct stmmac_txq_stats snapshot; data = pos; do { - start = u64_stats_fetch_begin(&tx_q->txq_stats.syncp); - snapshot = tx_q->txq_stats; - } while (u64_stats_fetch_retry(&tx_q->txq_stats.syncp, start)); + start = u64_stats_fetch_begin(&txq_stats->syncp); + snapshot = *txq_stats; + } while (u64_stats_fetch_retry(&txq_stats->syncp, start)); p = (char *)&snapshot + offsetof(struct stmmac_txq_stats, tx_pkt_n); for (stat = 0; stat < STMMAC_TXQ_STATS; stat++) { @@ -566,14 +566,14 @@ static void stmmac_get_per_qstats(struct stmmac_priv *priv, u64 *data) pos = data; for (q = 0; q < rx_cnt; q++) { - struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[q]; + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[q]; struct stmmac_rxq_stats snapshot; data = pos; do { - start = u64_stats_fetch_begin(&rx_q->rxq_stats.syncp); - snapshot = rx_q->rxq_stats; - } while (u64_stats_fetch_retry(&rx_q->rxq_stats.syncp, start)); + start = u64_stats_fetch_begin(&rxq_stats->syncp); + snapshot = *rxq_stats; + } while (u64_stats_fetch_retry(&rxq_stats->syncp, start)); p = (char *)&snapshot + offsetof(struct stmmac_rxq_stats, rx_pkt_n); for (stat = 0; stat < STMMAC_RXQ_STATS; stat++) { @@ -637,14 +637,14 @@ static void stmmac_get_ethtool_stats(struct net_device *dev, pos = j; for (i = 0; i < rx_queues_count; i++) { - struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[i]; + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[i]; struct stmmac_rxq_stats snapshot; j = pos; do { - start = u64_stats_fetch_begin(&rx_q->rxq_stats.syncp); - snapshot = rx_q->rxq_stats; - } while (u64_stats_fetch_retry(&rx_q->rxq_stats.syncp, start)); + start = u64_stats_fetch_begin(&rxq_stats->syncp); + snapshot = *rxq_stats; + } while (u64_stats_fetch_retry(&rxq_stats->syncp, start)); data[j++] += snapshot.rx_pkt_n; data[j++] += snapshot.rx_normal_irq_n; @@ -654,14 +654,14 @@ static void stmmac_get_ethtool_stats(struct net_device *dev, pos = j; for (i = 0; i < tx_queues_count; i++) { - struct stmmac_tx_queue *tx_q = &priv->dma_conf.tx_queue[i]; + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[i]; struct stmmac_txq_stats snapshot; j = pos; do { - start = u64_stats_fetch_begin(&tx_q->txq_stats.syncp); - snapshot = tx_q->txq_stats; - } while (u64_stats_fetch_retry(&tx_q->txq_stats.syncp, start)); + start = u64_stats_fetch_begin(&txq_stats->syncp); + snapshot = *txq_stats; + } while (u64_stats_fetch_retry(&txq_stats->syncp, start)); data[j++] += snapshot.tx_pkt_n; data[j++] += snapshot.tx_normal_irq_n; diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c index 9a3182b9e767..5a2b06c6e889 100644 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c @@ -2426,6 +2426,7 @@ static bool stmmac_xdp_xmit_zc(struct stmmac_priv *priv, u32 queue, u32 budget) { struct netdev_queue *nq = netdev_get_tx_queue(priv->dev, queue); struct stmmac_tx_queue *tx_q = &priv->dma_conf.tx_queue[queue]; + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[queue]; struct xsk_buff_pool *pool = tx_q->xsk_pool; unsigned int entry = tx_q->cur_tx; struct dma_desc *tx_desc = NULL; @@ -2505,9 +2506,9 @@ static bool stmmac_xdp_xmit_zc(struct stmmac_priv *priv, u32 queue, u32 budget) tx_q->cur_tx = STMMAC_GET_ENTRY(tx_q->cur_tx, priv->dma_conf.dma_tx_size); entry = tx_q->cur_tx; } - flags = u64_stats_update_begin_irqsave(&tx_q->txq_stats.syncp); - tx_q->txq_stats.tx_set_ic_bit += tx_set_ic_bit; - u64_stats_update_end_irqrestore(&tx_q->txq_stats.syncp, flags); + flags = u64_stats_update_begin_irqsave(&txq_stats->syncp); + txq_stats->tx_set_ic_bit += tx_set_ic_bit; + u64_stats_update_end_irqrestore(&txq_stats->syncp, flags); if (tx_desc) { stmmac_flush_tx_descriptors(priv, queue); @@ -2547,6 +2548,7 @@ static void stmmac_bump_dma_threshold(struct stmmac_priv *priv, u32 chan) static int stmmac_tx_clean(struct stmmac_priv *priv, int budget, u32 queue) { struct stmmac_tx_queue *tx_q = &priv->dma_conf.tx_queue[queue]; + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[queue]; unsigned int bytes_compl = 0, pkts_compl = 0; unsigned int entry, xmits = 0, count = 0; u32 tx_packets = 0, tx_errors = 0; @@ -2708,11 +2710,11 @@ static int stmmac_tx_clean(struct stmmac_priv *priv, int budget, u32 queue) STMMAC_COAL_TIMER(priv->tx_coal_timer[queue]), HRTIMER_MODE_REL); - flags = u64_stats_update_begin_irqsave(&tx_q->txq_stats.syncp); - tx_q->txq_stats.tx_packets += tx_packets; - tx_q->txq_stats.tx_pkt_n += tx_packets; - tx_q->txq_stats.tx_clean++; - u64_stats_update_end_irqrestore(&tx_q->txq_stats.syncp, flags); + flags = u64_stats_update_begin_irqsave(&txq_stats->syncp); + txq_stats->tx_packets += tx_packets; + txq_stats->tx_pkt_n += tx_packets; + txq_stats->tx_clean++; + u64_stats_update_end_irqrestore(&txq_stats->syncp, flags); priv->xstats.tx_errors += tx_errors; @@ -4112,6 +4114,7 @@ static netdev_tx_t stmmac_tso_xmit(struct sk_buff *skb, struct net_device *dev) int nfrags = skb_shinfo(skb)->nr_frags; u32 queue = skb_get_queue_mapping(skb); unsigned int first_entry, tx_packets; + struct stmmac_txq_stats *txq_stats; int tmp_pay_len = 0, first_tx; struct stmmac_tx_queue *tx_q; bool has_vlan, set_ic; @@ -4122,6 +4125,7 @@ static netdev_tx_t stmmac_tso_xmit(struct sk_buff *skb, struct net_device *dev) int i; tx_q = &priv->dma_conf.tx_queue[queue]; + txq_stats = &priv->xstats.txq_stats[queue]; first_tx = tx_q->cur_tx; /* Compute header lengths */ @@ -4280,13 +4284,13 @@ static netdev_tx_t stmmac_tso_xmit(struct sk_buff *skb, struct net_device *dev) netif_tx_stop_queue(netdev_get_tx_queue(priv->dev, queue)); } - flags = u64_stats_update_begin_irqsave(&tx_q->txq_stats.syncp); - tx_q->txq_stats.tx_bytes += skb->len; - tx_q->txq_stats.tx_tso_frames++; - tx_q->txq_stats.tx_tso_nfrags += nfrags; + flags = u64_stats_update_begin_irqsave(&txq_stats->syncp); + txq_stats->tx_bytes += skb->len; + txq_stats->tx_tso_frames++; + txq_stats->tx_tso_nfrags += nfrags; if (set_ic) - tx_q->txq_stats.tx_set_ic_bit++; - u64_stats_update_end_irqrestore(&tx_q->txq_stats.syncp, flags); + txq_stats->tx_set_ic_bit++; + u64_stats_update_end_irqrestore(&txq_stats->syncp, flags); if (priv->sarc_type) stmmac_set_desc_sarc(priv, first, priv->sarc_type); @@ -4357,6 +4361,7 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev) u32 queue = skb_get_queue_mapping(skb); int nfrags = skb_shinfo(skb)->nr_frags; int gso = skb_shinfo(skb)->gso_type; + struct stmmac_txq_stats *txq_stats; struct dma_edesc *tbs_desc = NULL; struct dma_desc *desc, *first; struct stmmac_tx_queue *tx_q; @@ -4366,6 +4371,7 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev) dma_addr_t des; tx_q = &priv->dma_conf.tx_queue[queue]; + txq_stats = &priv->xstats.txq_stats[queue]; first_tx = tx_q->cur_tx; if (priv->tx_path_in_lpi_mode && priv->eee_sw_timer_en) @@ -4517,11 +4523,11 @@ static netdev_tx_t stmmac_xmit(struct sk_buff *skb, struct net_device *dev) netif_tx_stop_queue(netdev_get_tx_queue(priv->dev, queue)); } - flags = u64_stats_update_begin_irqsave(&tx_q->txq_stats.syncp); - tx_q->txq_stats.tx_bytes += skb->len; + flags = u64_stats_update_begin_irqsave(&txq_stats->syncp); + txq_stats->tx_bytes += skb->len; if (set_ic) - tx_q->txq_stats.tx_set_ic_bit++; - u64_stats_update_end_irqrestore(&tx_q->txq_stats.syncp, flags); + txq_stats->tx_set_ic_bit++; + u64_stats_update_end_irqrestore(&txq_stats->syncp, flags); if (priv->sarc_type) stmmac_set_desc_sarc(priv, first, priv->sarc_type); @@ -4728,6 +4734,7 @@ static unsigned int stmmac_rx_buf2_len(struct stmmac_priv *priv, static int stmmac_xdp_xmit_xdpf(struct stmmac_priv *priv, int queue, struct xdp_frame *xdpf, bool dma_map) { + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[queue]; struct stmmac_tx_queue *tx_q = &priv->dma_conf.tx_queue[queue]; unsigned int entry = tx_q->cur_tx; struct dma_desc *tx_desc; @@ -4787,9 +4794,9 @@ static int stmmac_xdp_xmit_xdpf(struct stmmac_priv *priv, int queue, unsigned long flags; tx_q->tx_count_frames = 0; stmmac_set_tx_ic(priv, tx_desc); - flags = u64_stats_update_begin_irqsave(&tx_q->txq_stats.syncp); - tx_q->txq_stats.tx_set_ic_bit++; - u64_stats_update_end_irqrestore(&tx_q->txq_stats.syncp, flags); + flags = u64_stats_update_begin_irqsave(&txq_stats->syncp); + txq_stats->tx_set_ic_bit++; + u64_stats_update_end_irqrestore(&txq_stats->syncp, flags); } stmmac_enable_dma_transmission(priv, priv->ioaddr); @@ -4934,7 +4941,7 @@ static void stmmac_dispatch_skb_zc(struct stmmac_priv *priv, u32 queue, struct dma_desc *p, struct dma_desc *np, struct xdp_buff *xdp) { - struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[queue]; + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[queue]; struct stmmac_channel *ch = &priv->channel[queue]; unsigned int len = xdp->data_end - xdp->data; enum pkt_hash_types hash_type; @@ -4964,10 +4971,10 @@ static void stmmac_dispatch_skb_zc(struct stmmac_priv *priv, u32 queue, skb_record_rx_queue(skb, queue); napi_gro_receive(&ch->rxtx_napi, skb); - flags = u64_stats_update_begin_irqsave(&rx_q->rxq_stats.syncp); - rx_q->rxq_stats.rx_pkt_n++; - rx_q->rxq_stats.rx_bytes += len; - u64_stats_update_end_irqrestore(&rx_q->rxq_stats.syncp, flags); + flags = u64_stats_update_begin_irqsave(&rxq_stats->syncp); + rxq_stats->rx_pkt_n++; + rxq_stats->rx_bytes += len; + u64_stats_update_end_irqrestore(&rxq_stats->syncp, flags); } static bool stmmac_rx_refill_zc(struct stmmac_priv *priv, u32 queue, u32 budget) @@ -5040,6 +5047,7 @@ static struct stmmac_xdp_buff *xsk_buff_to_stmmac_ctx(struct xdp_buff *xdp) static int stmmac_rx_zc(struct stmmac_priv *priv, int limit, u32 queue) { + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[queue]; struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[queue]; unsigned int count = 0, error = 0, len = 0; int dirty = stmmac_rx_dirty(priv, queue); @@ -5203,9 +5211,9 @@ static int stmmac_rx_zc(struct stmmac_priv *priv, int limit, u32 queue) stmmac_finalize_xdp_rx(priv, xdp_status); - flags = u64_stats_update_begin_irqsave(&rx_q->rxq_stats.syncp); - rx_q->rxq_stats.rx_pkt_n += count; - u64_stats_update_end_irqrestore(&rx_q->rxq_stats.syncp, flags); + flags = u64_stats_update_begin_irqsave(&rxq_stats->syncp); + rxq_stats->rx_pkt_n += count; + u64_stats_update_end_irqrestore(&rxq_stats->syncp, flags); priv->xstats.rx_dropped += rx_dropped; priv->xstats.rx_errors += rx_errors; @@ -5233,6 +5241,7 @@ static int stmmac_rx_zc(struct stmmac_priv *priv, int limit, u32 queue) static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) { u32 rx_errors = 0, rx_dropped = 0, rx_bytes = 0, rx_packets = 0; + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[queue]; struct stmmac_rx_queue *rx_q = &priv->dma_conf.rx_queue[queue]; struct stmmac_channel *ch = &priv->channel[queue]; unsigned int count = 0, error = 0, len = 0; @@ -5494,11 +5503,11 @@ static int stmmac_rx(struct stmmac_priv *priv, int limit, u32 queue) stmmac_rx_refill(priv, queue); - flags = u64_stats_update_begin_irqsave(&rx_q->rxq_stats.syncp); - rx_q->rxq_stats.rx_packets += rx_packets; - rx_q->rxq_stats.rx_bytes += rx_bytes; - rx_q->rxq_stats.rx_pkt_n += count; - u64_stats_update_end_irqrestore(&rx_q->rxq_stats.syncp, flags); + flags = u64_stats_update_begin_irqsave(&rxq_stats->syncp); + rxq_stats->rx_packets += rx_packets; + rxq_stats->rx_bytes += rx_bytes; + rxq_stats->rx_pkt_n += count; + u64_stats_update_end_irqrestore(&rxq_stats->syncp, flags); priv->xstats.rx_dropped += rx_dropped; priv->xstats.rx_errors += rx_errors; @@ -5511,15 +5520,15 @@ static int stmmac_napi_poll_rx(struct napi_struct *napi, int budget) struct stmmac_channel *ch = container_of(napi, struct stmmac_channel, rx_napi); struct stmmac_priv *priv = ch->priv_data; - struct stmmac_rx_queue *rx_q; + struct stmmac_rxq_stats *rxq_stats; u32 chan = ch->index; unsigned long flags; int work_done; - rx_q = &priv->dma_conf.rx_queue[chan]; - flags = u64_stats_update_begin_irqsave(&rx_q->rxq_stats.syncp); - rx_q->rxq_stats.napi_poll++; - u64_stats_update_end_irqrestore(&rx_q->rxq_stats.syncp, flags); + rxq_stats = &priv->xstats.rxq_stats[chan]; + flags = u64_stats_update_begin_irqsave(&rxq_stats->syncp); + rxq_stats->napi_poll++; + u64_stats_update_end_irqrestore(&rxq_stats->syncp, flags); work_done = stmmac_rx(priv, budget, chan); if (work_done < budget && napi_complete_done(napi, work_done)) { @@ -5538,15 +5547,15 @@ static int stmmac_napi_poll_tx(struct napi_struct *napi, int budget) struct stmmac_channel *ch = container_of(napi, struct stmmac_channel, tx_napi); struct stmmac_priv *priv = ch->priv_data; - struct stmmac_tx_queue *tx_q; + struct stmmac_txq_stats *txq_stats; u32 chan = ch->index; unsigned long flags; int work_done; - tx_q = &priv->dma_conf.tx_queue[chan]; - flags = u64_stats_update_begin_irqsave(&tx_q->txq_stats.syncp); - tx_q->txq_stats.napi_poll++; - u64_stats_update_end_irqrestore(&tx_q->txq_stats.syncp, flags); + txq_stats = &priv->xstats.txq_stats[chan]; + flags = u64_stats_update_begin_irqsave(&txq_stats->syncp); + txq_stats->napi_poll++; + u64_stats_update_end_irqrestore(&txq_stats->syncp, flags); work_done = stmmac_tx_clean(priv, budget, chan); work_done = min(work_done, budget); @@ -5568,20 +5577,20 @@ static int stmmac_napi_poll_rxtx(struct napi_struct *napi, int budget) container_of(napi, struct stmmac_channel, rxtx_napi); struct stmmac_priv *priv = ch->priv_data; int rx_done, tx_done, rxtx_done; - struct stmmac_rx_queue *rx_q; - struct stmmac_tx_queue *tx_q; + struct stmmac_rxq_stats *rxq_stats; + struct stmmac_txq_stats *txq_stats; u32 chan = ch->index; unsigned long flags; - rx_q = &priv->dma_conf.rx_queue[chan]; - flags = u64_stats_update_begin_irqsave(&rx_q->rxq_stats.syncp); - rx_q->rxq_stats.napi_poll++; - u64_stats_update_end_irqrestore(&rx_q->rxq_stats.syncp, flags); + rxq_stats = &priv->xstats.rxq_stats[chan]; + flags = u64_stats_update_begin_irqsave(&rxq_stats->syncp); + rxq_stats->napi_poll++; + u64_stats_update_end_irqrestore(&rxq_stats->syncp, flags); - tx_q = &priv->dma_conf.tx_queue[chan]; - flags = u64_stats_update_begin_irqsave(&tx_q->txq_stats.syncp); - tx_q->txq_stats.napi_poll++; - u64_stats_update_end_irqrestore(&tx_q->txq_stats.syncp, flags); + txq_stats = &priv->xstats.txq_stats[chan]; + flags = u64_stats_update_begin_irqsave(&txq_stats->syncp); + txq_stats->napi_poll++; + u64_stats_update_end_irqrestore(&txq_stats->syncp, flags); tx_done = stmmac_tx_clean(priv, budget, chan); tx_done = min(tx_done, budget); @@ -6924,7 +6933,7 @@ static void stmmac_get_stats64(struct net_device *dev, struct rtnl_link_stats64 int q; for (q = 0; q < tx_cnt; q++) { - struct stmmac_txq_stats *txq_stats = &priv->dma_conf.tx_queue[q].txq_stats; + struct stmmac_txq_stats *txq_stats = &priv->xstats.txq_stats[q]; u64 tx_packets; u64 tx_bytes; @@ -6939,7 +6948,7 @@ static void stmmac_get_stats64(struct net_device *dev, struct rtnl_link_stats64 } for (q = 0; q < rx_cnt; q++) { - struct stmmac_rxq_stats *rxq_stats = &priv->dma_conf.rx_queue[q].rxq_stats; + struct stmmac_rxq_stats *rxq_stats = &priv->xstats.rxq_stats[q]; u64 rx_packets; u64 rx_bytes; @@ -7340,9 +7349,9 @@ int stmmac_dvr_probe(struct device *device, priv->dev = ndev; for (i = 0; i < MTL_MAX_RX_QUEUES; i++) - u64_stats_init(&priv->dma_conf.rx_queue[i].rxq_stats.syncp); + u64_stats_init(&priv->xstats.rxq_stats[i].syncp); for (i = 0; i < MTL_MAX_TX_QUEUES; i++) - u64_stats_init(&priv->dma_conf.tx_queue[i].txq_stats.syncp); + u64_stats_init(&priv->xstats.txq_stats[i].syncp); stmmac_set_ethtool_ops(ndev); priv->pause = pause; -- 2.40.1 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 174DEEEAA7E for ; Fri, 15 Sep 2023 01:06:00 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:Message-Id:Date:Subject:Cc :To:From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To:References: List-Owner; bh=Jio7zBokti67nJFMY/u84KLxA+oO8bOemDIP9o3pJNY=; b=BCCwvUKj9DpinE GOD7o2c6tr5MxW192DKv+MqK2Sds1wBijvD/1ZrlGW0tsT6EFHeRiMWs0TjpR5IXQqvIG2lM8y9hJ 4Yv2+obtlOUmcXjR2oD2cC2H030x32+hp1Y3X4QEWwtNI0nhzjfxl5K9ukEAt+okHWo0c1hph74UG PlSmKfoxzFt0rYdNBhDuU58MiMgS4wCLQjmQ5Ff2ajQ2QzuqOOtjwoc+pE2D1pH8RkmIsQT0aPeZg zlNtemoHjhhcCE8e6+F0lqewPASxBvbp0RJfd4apr6jt3/wtZkB2qfP1Ml8aAA+oESxGvgD5MLMpY SuQBHZ8Cd2eAo9nNZ8DA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qgxH0-009XF1-2t; Fri, 15 Sep 2023 01:05:30 +0000 Received: from dfw.source.kernel.org ([2604:1380:4641:c500::1]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qgxGv-009XEZ-2N for linux-arm-kernel@lists.infradead.org; Fri, 15 Sep 2023 01:05:28 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id E27C561EC4; Fri, 15 Sep 2023 01:05:23 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9789CC433CB; Fri, 15 Sep 2023 01:05:20 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1694739923; bh=/+T2kHP+yN3i1UHDJJ9EztJ2b09LmvcDHhfaOKfFahQ=; h=From:To:Cc:Subject:Date:From; b=dMzt4disWJkzHTxFN3bUfN7GkEZkVPUtevTTYC1IMRd4ABzfvyI69sjNGYdEhsNwv QzF38iBkEarTp/dWqBHdgdJQLckOoamXtc2Q1Kuori2h6sw9le7Py7PcLVnoNQtloy ij4yg7ZNoULCNxmWNt+z3LPaC4Dx5JAleCy0UxbaxoqBLv00PF92eHr7D01QypXwmb 6/UjYFBYnnhdq9wq+y5MjME2wEio78d9qobbXPQT6xtLjBVQUOr+pXcXWonOpMrqT6 Dko6viiNm/Gx7j4A4AXJ952vHy7bJKF9L3/qnpckNlQPbiIHKLlhIfY86RVxP5KW8/ O+AHF+dStJAvA== From: Jisheng Zhang To: Giuseppe Cavallaro , Alexandre Torgue , Jose Abreu , "David S . Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Maxime Coquelin , Chen-Yu Tsai , Jernej Skrabec , Samuel Holland Cc: netdev@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-sunxi@lists.linux.dev, linux-stm32@st-md-mailman.stormreply.com, johannes@sipsolutions.net, =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= Subject: [PATCH] net: stmmac: fix incorrect rxq|txq_stats reference Date: Fri, 15 Sep 2023 08:53:16 +0800 Message-Id: <20230915005316.592-1-jszhang@kernel.org> X-Mailer: git-send-email 2.40.0 MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230914_180525_888606_010EDD6D X-CRM114-Status: GOOD ( 19.62 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Y29tbWl0IDEzMzQ2NmMzYmJlMSAoIm5ldDogc3RtbWFjOiB1c2UgcGVyLXF1ZXVlIDY0IGJpdCBz dGF0aXN0aWNzCndoZXJlIG5lY2Vzc2FyeSIpIGNhdXNlZCBvbmUgcmVncmVzc2lvbiBhcyBmb3Vu ZCBieSBVd2UsIHRoZSBiYWNrdHJhY2UKbG9va3MgbGlrZToKCklORk86IHRyeWluZyB0byByZWdp c3RlciBub24tc3RhdGljIGtleS4KVGhlIGNvZGUgaXMgZmluZSBidXQgbmVlZHMgbG9ja2RlcCBh bm5vdGF0aW9uLCBvciBtYXliZQp5b3UgZGlkbid0IGluaXRpYWxpemUgdGhpcyBvYmplY3QgYmVm b3JlIHVzZT8KdHVybmluZyBvZmYgdGhlIGxvY2tpbmcgY29ycmVjdG5lc3MgdmFsaWRhdG9yLgpD UFU6IDAgUElEOiAxIENvbW06IHN3YXBwZXIvMCBOb3QgdGFpbnRlZCA2LjUuMC1yYzEtMDA0NDkt ZzEzMzQ2NmMzYmJlMS1kaXJ0eSAjMjEKSGFyZHdhcmUgbmFtZTogU1RNMzIgKERldmljZSBUcmVl IFN1cHBvcnQpCiB1bndpbmRfYmFja3RyYWNlIGZyb20gc2hvd19zdGFjaysweDE4LzB4MWMKIHNo b3dfc3RhY2sgZnJvbSBkdW1wX3N0YWNrX2x2bCsweDYwLzB4OTAKIGR1bXBfc3RhY2tfbHZsIGZy b20gcmVnaXN0ZXJfbG9ja19jbGFzcysweDk4Yy8weDk5YwogcmVnaXN0ZXJfbG9ja19jbGFzcyBm cm9tIF9fbG9ja19hY3F1aXJlKzB4NzQvMHgyOTNjCiBfX2xvY2tfYWNxdWlyZSBmcm9tIGxvY2tf YWNxdWlyZSsweDEzNC8weDM5OAogbG9ja19hY3F1aXJlIGZyb20gc3RtbWFjX2dldF9zdGF0czY0 KzB4MmFjLzB4MmZjCiBzdG1tYWNfZ2V0X3N0YXRzNjQgZnJvbSBkZXZfZ2V0X3N0YXRzKzB4NDQv MHgxMzAKIGRldl9nZXRfc3RhdHMgZnJvbSBydG5sX2ZpbGxfc3RhdHMrMHgzOC8weDEyMAogcnRu bF9maWxsX3N0YXRzIGZyb20gcnRubF9maWxsX2lmaW5mbysweDgzNC8weDE3ZjQKIHJ0bmxfZmls bF9pZmluZm8gZnJvbSBydG1zZ19pZmluZm9fYnVpbGRfc2tiKzB4YzAvMHgxNDQKIHJ0bXNnX2lm aW5mb19idWlsZF9za2IgZnJvbSBydG1zZ19pZmluZm8rMHg1MC8weDg4CiBydG1zZ19pZmluZm8g ZnJvbSBfX2Rldl9ub3RpZnlfZmxhZ3MrMHhjMC8weGVjCiBfX2Rldl9ub3RpZnlfZmxhZ3MgZnJv bSBkZXZfY2hhbmdlX2ZsYWdzKzB4NTAvMHg1YwogZGV2X2NoYW5nZV9mbGFncyBmcm9tIGlwX2F1 dG9fY29uZmlnKzB4MmY0LzB4MTI2MAogaXBfYXV0b19jb25maWcgZnJvbSBkb19vbmVfaW5pdGNh bGwrMHg3MC8weDM1YwogZG9fb25lX2luaXRjYWxsIGZyb20ga2VybmVsX2luaXRfZnJlZWFibGUr MHgyYWMvMHgzMDgKIGtlcm5lbF9pbml0X2ZyZWVhYmxlIGZyb20ga2VybmVsX2luaXQrMHgxYy8w eDEzOAoga2VybmVsX2luaXQgZnJvbSByZXRfZnJvbV9mb3JrKzB4MTQvMHgyYwoKVGhlIHJlYXNv biBpcyB0aGUgcnhxfHR4cV9zdGF0cyBzdHJ1Y3R1cmVzIGFyZSBub3Qgd2hhdCBleHBlY3RlZApi ZWNhdXNlIHN0bW1hY19vcGVuKCkgLT4gX19zdG1tYWNfb3BlbigpIHRoZSBzdHJ1Y3R1cmUgaXMg b3ZlcndyaXR0ZW4KYnkgIm1lbWNweSgmcHJpdi0+ZG1hX2NvbmYsIGRtYV9jb25mLCBzaXplb2Yo KmRtYV9jb25mKSk7IgpUaGlzIGNhdXNlcyB0aGUgd2VsbCBpbml0aWFsaXplZCBzeW5jcCBtZW1i ZXIgb2YgcnhxfHR4cV9zdGF0cyBpcwpvdmVyd3JpdHRlbiB1bmV4cGVjdGVkbHkgYXMgcG9pbnRl ZCBvdXQgYnkgSm9oYW5uZXMgYW5kIFV3ZS4KCkZpeCB0aGlzIGlzc3VlIGJ5IG1vdmluZyByeHF8 dHhxX3N0YXRzIGJhY2sgdG8gc3RtbWFjX2V4dHJhX3N0YXRzLiBGb3IKU01QIGNhY2hlIGZyaWVu ZGx5LCB3ZSBhbHNvIG1hcmsgc3RtbWFjX3R4cV9zdGF0cyBhbmQgc3RtbWFjX3J4cV9zdGF0cwph cyBfX19fY2FjaGVsaW5lX2FsaWduZWRfaW5fc21wLgoKRml4ZXM6IDEzMzQ2NmMzYmJlMSAoIm5l dDogc3RtbWFjOiB1c2UgcGVyLXF1ZXVlIDY0IGJpdCBzdGF0aXN0aWNzIHdoZXJlIG5lY2Vzc2Fy eSIpClNpZ25lZC1vZmYtYnk6IEppc2hlbmcgWmhhbmcgPGpzemhhbmdAa2VybmVsLm9yZz4KUmVw b3J0ZWQtYnk6IFV3ZSBLbGVpbmUtS8O2bmlnIDx1LmtsZWluZS1rb2VuaWdAcGVuZ3V0cm9uaXgu ZGU+Ci0tLQogZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvY29tbW9uLmggIHwg ICA3ICstCiAuLi4vbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjLXN1bjhpLmMgfCAg MTYgKy0tCiAuLi4vbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjNF9saWIuYyAgfCAg MTYgKy0tCiAuLi4vbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjX2xpYi5jICAgfCAg MTYgKy0tCiAuLi4vZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvZHd4Z21hYzJfZG1hLmMgICAgfCAg MTYgKy0tCiBkcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWMuaCAgfCAg IDIgLQogLi4uL2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19ldGh0b29sLmMgIHwgIDMy ICsrLS0tCiAuLi4vbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19tYWluLmMgfCAx MjUgKysrKysrKysrKy0tLS0tLS0tCiA4IGZpbGVzIGNoYW5nZWQsIDEyMCBpbnNlcnRpb25zKCsp LCAxMTAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3Rt aWNyby9zdG1tYWMvY29tbW9uLmggYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1h Yy9jb21tb24uaAppbmRleCA0MDNjYjM5N2Q0ZDMuLjFlOTk2YzI5MDQzZCAxMDA2NDQKLS0tIGEv ZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvY29tbW9uLmgKKysrIGIvZHJpdmVy cy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvY29tbW9uLmgKQEAgLTcwLDcgKzcwLDcgQEAg c3RydWN0IHN0bW1hY190eHFfc3RhdHMgewogCXU2NCB0eF90c29fZnJhbWVzOwogCXU2NCB0eF90 c29fbmZyYWdzOwogCXN0cnVjdCB1NjRfc3RhdHNfc3luYyBzeW5jcDsKLX07Cit9IF9fX19jYWNo ZWxpbmVfYWxpZ25lZF9pbl9zbXA7CiAKIHN0cnVjdCBzdG1tYWNfcnhxX3N0YXRzIHsKIAl1NjQg cnhfYnl0ZXM7CkBAIC03OSw3ICs3OSw3IEBAIHN0cnVjdCBzdG1tYWNfcnhxX3N0YXRzIHsKIAl1 NjQgcnhfbm9ybWFsX2lycV9uOwogCXU2NCBuYXBpX3BvbGw7CiAJc3RydWN0IHU2NF9zdGF0c19z eW5jIHN5bmNwOwotfTsKK30gX19fX2NhY2hlbGluZV9hbGlnbmVkX2luX3NtcDsKIAogLyogRXh0 cmEgc3RhdGlzdGljIGFuZCBkZWJ1ZyBpbmZvcm1hdGlvbiBleHBvc2VkIGJ5IGV0aHRvb2wgKi8K IHN0cnVjdCBzdG1tYWNfZXh0cmFfc3RhdHMgewpAQCAtMjAyLDYgKzIwMiw5IEBAIHN0cnVjdCBz dG1tYWNfZXh0cmFfc3RhdHMgewogCXVuc2lnbmVkIGxvbmcgbXRsX2VzdF9obGJmOwogCXVuc2ln bmVkIGxvbmcgbXRsX2VzdF9idHJlOwogCXVuc2lnbmVkIGxvbmcgbXRsX2VzdF9idHJsbTsKKwkv KiBwZXIgcXVldWUgc3RhdGlzdGljcyAqLworCXN0cnVjdCBzdG1tYWNfdHhxX3N0YXRzIHR4cV9z dGF0c1tNVExfTUFYX1RYX1FVRVVFU107CisJc3RydWN0IHN0bW1hY19yeHFfc3RhdHMgcnhxX3N0 YXRzW01UTF9NQVhfUlhfUVVFVUVTXTsKIAl1bnNpZ25lZCBsb25nIHJ4X2Ryb3BwZWQ7CiAJdW5z aWduZWQgbG9uZyByeF9lcnJvcnM7CiAJdW5zaWduZWQgbG9uZyB0eF9kcm9wcGVkOwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvZHdtYWMtc3VuOGkuYyBi L2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjLXN1bjhpLmMKaW5kZXgg MDFlNzczNjhlZWYxLi40NjVmZjFmZDQ3ODUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVy bmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjLXN1bjhpLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJu ZXQvc3RtaWNyby9zdG1tYWMvZHdtYWMtc3VuOGkuYwpAQCAtNDQxLDggKzQ0MSw4IEBAIHN0YXRp YyBpbnQgc3VuOGlfZHdtYWNfZG1hX2ludGVycnVwdChzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYs CiAJCQkJICAgICBzdHJ1Y3Qgc3RtbWFjX2V4dHJhX3N0YXRzICp4LCB1MzIgY2hhbiwKIAkJCQkg ICAgIHUzMiBkaXIpCiB7Ci0Jc3RydWN0IHN0bW1hY19yeF9xdWV1ZSAqcnhfcSA9ICZwcml2LT5k bWFfY29uZi5yeF9xdWV1ZVtjaGFuXTsKLQlzdHJ1Y3Qgc3RtbWFjX3R4X3F1ZXVlICp0eF9xID0g JnByaXYtPmRtYV9jb25mLnR4X3F1ZXVlW2NoYW5dOworCXN0cnVjdCBzdG1tYWNfcnhxX3N0YXRz ICpyeHFfc3RhdHMgPSAmcHJpdi0+eHN0YXRzLnJ4cV9zdGF0c1tjaGFuXTsKKwlzdHJ1Y3Qgc3Rt bWFjX3R4cV9zdGF0cyAqdHhxX3N0YXRzID0gJnByaXYtPnhzdGF0cy50eHFfc3RhdHNbY2hhbl07 CiAJaW50IHJldCA9IDA7CiAJdTMyIHY7CiAKQEAgLTQ1NSw5ICs0NTUsOSBAQCBzdGF0aWMgaW50 IHN1bjhpX2R3bWFjX2RtYV9pbnRlcnJ1cHQoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LAogCiAJ aWYgKHYgJiBFTUFDX1RYX0lOVCkgewogCQlyZXQgfD0gaGFuZGxlX3R4OwotCQl1NjRfc3RhdHNf dXBkYXRlX2JlZ2luKCZ0eF9xLT50eHFfc3RhdHMuc3luY3ApOwotCQl0eF9xLT50eHFfc3RhdHMu dHhfbm9ybWFsX2lycV9uKys7Ci0JCXU2NF9zdGF0c191cGRhdGVfZW5kKCZ0eF9xLT50eHFfc3Rh dHMuc3luY3ApOworCQl1NjRfc3RhdHNfdXBkYXRlX2JlZ2luKCZ0eHFfc3RhdHMtPnN5bmNwKTsK KwkJdHhxX3N0YXRzLT50eF9ub3JtYWxfaXJxX24rKzsKKwkJdTY0X3N0YXRzX3VwZGF0ZV9lbmQo JnR4cV9zdGF0cy0+c3luY3ApOwogCX0KIAogCWlmICh2ICYgRU1BQ19UWF9ETUFfU1RPUF9JTlQp CkBAIC00NzksOSArNDc5LDkgQEAgc3RhdGljIGludCBzdW44aV9kd21hY19kbWFfaW50ZXJydXB0 KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwKIAogCWlmICh2ICYgRU1BQ19SWF9JTlQpIHsKIAkJ cmV0IHw9IGhhbmRsZV9yeDsKLQkJdTY0X3N0YXRzX3VwZGF0ZV9iZWdpbigmcnhfcS0+cnhxX3N0 YXRzLnN5bmNwKTsKLQkJcnhfcS0+cnhxX3N0YXRzLnJ4X25vcm1hbF9pcnFfbisrOwotCQl1NjRf c3RhdHNfdXBkYXRlX2VuZCgmcnhfcS0+cnhxX3N0YXRzLnN5bmNwKTsKKwkJdTY0X3N0YXRzX3Vw ZGF0ZV9iZWdpbigmcnhxX3N0YXRzLT5zeW5jcCk7CisJCXJ4cV9zdGF0cy0+cnhfbm9ybWFsX2ly cV9uKys7CisJCXU2NF9zdGF0c191cGRhdGVfZW5kKCZyeHFfc3RhdHMtPnN5bmNwKTsKIAl9CiAK IAlpZiAodiAmIEVNQUNfUlhfQlVGX1VBX0lOVCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0 aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjNF9saWIuYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0 L3N0bWljcm8vc3RtbWFjL2R3bWFjNF9saWIuYwppbmRleCA5ODBlNWY4YTM3ZWMuLjk0NzBkM2Zk MmRlZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvZHdt YWM0X2xpYi5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFj NF9saWIuYwpAQCAtMTcxLDggKzE3MSw4IEBAIGludCBkd21hYzRfZG1hX2ludGVycnVwdChzdHJ1 Y3Qgc3RtbWFjX3ByaXYgKnByaXYsIHZvaWQgX19pb21lbSAqaW9hZGRyLAogCWNvbnN0IHN0cnVj dCBkd21hYzRfYWRkcnMgKmR3bWFjNF9hZGRycyA9IHByaXYtPnBsYXQtPmR3bWFjNF9hZGRyczsK IAl1MzIgaW50cl9zdGF0dXMgPSByZWFkbChpb2FkZHIgKyBETUFfQ0hBTl9TVEFUVVMoZHdtYWM0 X2FkZHJzLCBjaGFuKSk7CiAJdTMyIGludHJfZW4gPSByZWFkbChpb2FkZHIgKyBETUFfQ0hBTl9J TlRSX0VOQShkd21hYzRfYWRkcnMsIGNoYW4pKTsKLQlzdHJ1Y3Qgc3RtbWFjX3J4X3F1ZXVlICpy eF9xID0gJnByaXYtPmRtYV9jb25mLnJ4X3F1ZXVlW2NoYW5dOwotCXN0cnVjdCBzdG1tYWNfdHhf cXVldWUgKnR4X3EgPSAmcHJpdi0+ZG1hX2NvbmYudHhfcXVldWVbY2hhbl07CisJc3RydWN0IHN0 bW1hY19yeHFfc3RhdHMgKnJ4cV9zdGF0cyA9ICZwcml2LT54c3RhdHMucnhxX3N0YXRzW2NoYW5d OworCXN0cnVjdCBzdG1tYWNfdHhxX3N0YXRzICp0eHFfc3RhdHMgPSAmcHJpdi0+eHN0YXRzLnR4 cV9zdGF0c1tjaGFuXTsKIAlpbnQgcmV0ID0gMDsKIAogCWlmIChkaXIgPT0gRE1BX0RJUl9SWCkK QEAgLTIwMSwxNSArMjAxLDE1IEBAIGludCBkd21hYzRfZG1hX2ludGVycnVwdChzdHJ1Y3Qgc3Rt bWFjX3ByaXYgKnByaXYsIHZvaWQgX19pb21lbSAqaW9hZGRyLAogCX0KIAkvKiBUWC9SWCBOT1JN QUwgaW50ZXJydXB0cyAqLwogCWlmIChsaWtlbHkoaW50cl9zdGF0dXMgJiBETUFfQ0hBTl9TVEFU VVNfUkkpKSB7Ci0JCXU2NF9zdGF0c191cGRhdGVfYmVnaW4oJnJ4X3EtPnJ4cV9zdGF0cy5zeW5j cCk7Ci0JCXJ4X3EtPnJ4cV9zdGF0cy5yeF9ub3JtYWxfaXJxX24rKzsKLQkJdTY0X3N0YXRzX3Vw ZGF0ZV9lbmQoJnJ4X3EtPnJ4cV9zdGF0cy5zeW5jcCk7CisJCXU2NF9zdGF0c191cGRhdGVfYmVn aW4oJnJ4cV9zdGF0cy0+c3luY3ApOworCQlyeHFfc3RhdHMtPnJ4X25vcm1hbF9pcnFfbisrOwor CQl1NjRfc3RhdHNfdXBkYXRlX2VuZCgmcnhxX3N0YXRzLT5zeW5jcCk7CiAJCXJldCB8PSBoYW5k bGVfcng7CiAJfQogCWlmIChsaWtlbHkoaW50cl9zdGF0dXMgJiBETUFfQ0hBTl9TVEFUVVNfVEkp KSB7Ci0JCXU2NF9zdGF0c191cGRhdGVfYmVnaW4oJnR4X3EtPnR4cV9zdGF0cy5zeW5jcCk7Ci0J CXR4X3EtPnR4cV9zdGF0cy50eF9ub3JtYWxfaXJxX24rKzsKLQkJdTY0X3N0YXRzX3VwZGF0ZV9l bmQoJnR4X3EtPnR4cV9zdGF0cy5zeW5jcCk7CisJCXU2NF9zdGF0c191cGRhdGVfYmVnaW4oJnR4 cV9zdGF0cy0+c3luY3ApOworCQl0eHFfc3RhdHMtPnR4X25vcm1hbF9pcnFfbisrOworCQl1NjRf c3RhdHNfdXBkYXRlX2VuZCgmdHhxX3N0YXRzLT5zeW5jcCk7CiAJCXJldCB8PSBoYW5kbGVfdHg7 CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9k d21hY19saWIuYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3bWFjX2xp Yi5jCmluZGV4IGFhYTA5YjE2YjAxNi4uNzkwN2Q2MmQzNDM3IDEwMDY0NAotLS0gYS9kcml2ZXJz L25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9kd21hY19saWIuYworKysgYi9kcml2ZXJzL25l dC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9kd21hY19saWIuYwpAQCAtMTYyLDggKzE2Miw4IEBA IHN0YXRpYyB2b2lkIHNob3dfcnhfcHJvY2Vzc19zdGF0ZSh1bnNpZ25lZCBpbnQgc3RhdHVzKQog aW50IGR3bWFjX2RtYV9pbnRlcnJ1cHQoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCB2b2lkIF9f aW9tZW0gKmlvYWRkciwKIAkJCXN0cnVjdCBzdG1tYWNfZXh0cmFfc3RhdHMgKngsIHUzMiBjaGFu LCB1MzIgZGlyKQogewotCXN0cnVjdCBzdG1tYWNfcnhfcXVldWUgKnJ4X3EgPSAmcHJpdi0+ZG1h X2NvbmYucnhfcXVldWVbY2hhbl07Ci0Jc3RydWN0IHN0bW1hY190eF9xdWV1ZSAqdHhfcSA9ICZw cml2LT5kbWFfY29uZi50eF9xdWV1ZVtjaGFuXTsKKwlzdHJ1Y3Qgc3RtbWFjX3J4cV9zdGF0cyAq cnhxX3N0YXRzID0gJnByaXYtPnhzdGF0cy5yeHFfc3RhdHNbY2hhbl07CisJc3RydWN0IHN0bW1h Y190eHFfc3RhdHMgKnR4cV9zdGF0cyA9ICZwcml2LT54c3RhdHMudHhxX3N0YXRzW2NoYW5dOwog CWludCByZXQgPSAwOwogCS8qIHJlYWQgdGhlIHN0YXR1cyByZWdpc3RlciAoQ1NSNSkgKi8KIAl1 MzIgaW50cl9zdGF0dXMgPSByZWFkbChpb2FkZHIgKyBETUFfU1RBVFVTKTsKQEAgLTIxNSwxNiAr MjE1LDE2IEBAIGludCBkd21hY19kbWFfaW50ZXJydXB0KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJp diwgdm9pZCBfX2lvbWVtICppb2FkZHIsCiAJCQl1MzIgdmFsdWUgPSByZWFkbChpb2FkZHIgKyBE TUFfSU5UUl9FTkEpOwogCQkJLyogdG8gc2NoZWR1bGUgTkFQSSBvbiByZWFsIFJJRSBldmVudC4g Ki8KIAkJCWlmIChsaWtlbHkodmFsdWUgJiBETUFfSU5UUl9FTkFfUklFKSkgewotCQkJCXU2NF9z dGF0c191cGRhdGVfYmVnaW4oJnJ4X3EtPnJ4cV9zdGF0cy5zeW5jcCk7Ci0JCQkJcnhfcS0+cnhx X3N0YXRzLnJ4X25vcm1hbF9pcnFfbisrOwotCQkJCXU2NF9zdGF0c191cGRhdGVfZW5kKCZyeF9x LT5yeHFfc3RhdHMuc3luY3ApOworCQkJCXU2NF9zdGF0c191cGRhdGVfYmVnaW4oJnJ4cV9zdGF0 cy0+c3luY3ApOworCQkJCXJ4cV9zdGF0cy0+cnhfbm9ybWFsX2lycV9uKys7CisJCQkJdTY0X3N0 YXRzX3VwZGF0ZV9lbmQoJnJ4cV9zdGF0cy0+c3luY3ApOwogCQkJCXJldCB8PSBoYW5kbGVfcng7 CiAJCQl9CiAJCX0KIAkJaWYgKGxpa2VseShpbnRyX3N0YXR1cyAmIERNQV9TVEFUVVNfVEkpKSB7 Ci0JCQl1NjRfc3RhdHNfdXBkYXRlX2JlZ2luKCZ0eF9xLT50eHFfc3RhdHMuc3luY3ApOwotCQkJ dHhfcS0+dHhxX3N0YXRzLnR4X25vcm1hbF9pcnFfbisrOwotCQkJdTY0X3N0YXRzX3VwZGF0ZV9l bmQoJnR4X3EtPnR4cV9zdGF0cy5zeW5jcCk7CisJCQl1NjRfc3RhdHNfdXBkYXRlX2JlZ2luKCZ0 eHFfc3RhdHMtPnN5bmNwKTsKKwkJCXR4cV9zdGF0cy0+dHhfbm9ybWFsX2lycV9uKys7CisJCQl1 NjRfc3RhdHNfdXBkYXRlX2VuZCgmdHhxX3N0YXRzLT5zeW5jcCk7CiAJCQlyZXQgfD0gaGFuZGxl X3R4OwogCQl9CiAJCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmIERNQV9TVEFUVVNfRVJJKSkK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3eGdtYWMy X2RtYS5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvZHd4Z21hYzJfZG1h LmMKaW5kZXggZmE2OWQ2NGE4Njk0Li4zY2RlNjk1ZmVjOTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3eGdtYWMyX2RtYS5jCisrKyBiL2RyaXZlcnMv bmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL2R3eGdtYWMyX2RtYS5jCkBAIC0zMzcsOCArMzM3 LDggQEAgc3RhdGljIGludCBkd3hnbWFjMl9kbWFfaW50ZXJydXB0KHN0cnVjdCBzdG1tYWNfcHJp diAqcHJpdiwKIAkJCQkgIHN0cnVjdCBzdG1tYWNfZXh0cmFfc3RhdHMgKngsIHUzMiBjaGFuLAog CQkJCSAgdTMyIGRpcikKIHsKLQlzdHJ1Y3Qgc3RtbWFjX3J4X3F1ZXVlICpyeF9xID0gJnByaXYt PmRtYV9jb25mLnJ4X3F1ZXVlW2NoYW5dOwotCXN0cnVjdCBzdG1tYWNfdHhfcXVldWUgKnR4X3Eg PSAmcHJpdi0+ZG1hX2NvbmYudHhfcXVldWVbY2hhbl07CisJc3RydWN0IHN0bW1hY19yeHFfc3Rh dHMgKnJ4cV9zdGF0cyA9ICZwcml2LT54c3RhdHMucnhxX3N0YXRzW2NoYW5dOworCXN0cnVjdCBz dG1tYWNfdHhxX3N0YXRzICp0eHFfc3RhdHMgPSAmcHJpdi0+eHN0YXRzLnR4cV9zdGF0c1tjaGFu XTsKIAl1MzIgaW50cl9zdGF0dXMgPSByZWFkbChpb2FkZHIgKyBYR01BQ19ETUFfQ0hfU1RBVFVT KGNoYW4pKTsKIAl1MzIgaW50cl9lbiA9IHJlYWRsKGlvYWRkciArIFhHTUFDX0RNQV9DSF9JTlRf RU4oY2hhbikpOwogCWludCByZXQgPSAwOwpAQCAtMzY3LDE1ICszNjcsMTUgQEAgc3RhdGljIGlu dCBkd3hnbWFjMl9kbWFfaW50ZXJydXB0KHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwKIAkvKiBU WC9SWCBOT1JNQUwgaW50ZXJydXB0cyAqLwogCWlmIChsaWtlbHkoaW50cl9zdGF0dXMgJiBYR01B Q19OSVMpKSB7CiAJCWlmIChsaWtlbHkoaW50cl9zdGF0dXMgJiBYR01BQ19SSSkpIHsKLQkJCXU2 NF9zdGF0c191cGRhdGVfYmVnaW4oJnJ4X3EtPnJ4cV9zdGF0cy5zeW5jcCk7Ci0JCQlyeF9xLT5y eHFfc3RhdHMucnhfbm9ybWFsX2lycV9uKys7Ci0JCQl1NjRfc3RhdHNfdXBkYXRlX2VuZCgmcnhf cS0+cnhxX3N0YXRzLnN5bmNwKTsKKwkJCXU2NF9zdGF0c191cGRhdGVfYmVnaW4oJnJ4cV9zdGF0 cy0+c3luY3ApOworCQkJcnhxX3N0YXRzLT5yeF9ub3JtYWxfaXJxX24rKzsKKwkJCXU2NF9zdGF0 c191cGRhdGVfZW5kKCZyeHFfc3RhdHMtPnN5bmNwKTsKIAkJCXJldCB8PSBoYW5kbGVfcng7CiAJ CX0KIAkJaWYgKGxpa2VseShpbnRyX3N0YXR1cyAmIChYR01BQ19USSB8IFhHTUFDX1RCVSkpKSB7 Ci0JCQl1NjRfc3RhdHNfdXBkYXRlX2JlZ2luKCZ0eF9xLT50eHFfc3RhdHMuc3luY3ApOwotCQkJ dHhfcS0+dHhxX3N0YXRzLnR4X25vcm1hbF9pcnFfbisrOwotCQkJdTY0X3N0YXRzX3VwZGF0ZV9l bmQoJnR4X3EtPnR4cV9zdGF0cy5zeW5jcCk7CisJCQl1NjRfc3RhdHNfdXBkYXRlX2JlZ2luKCZ0 eHFfc3RhdHMtPnN5bmNwKTsKKwkJCXR4cV9zdGF0cy0+dHhfbm9ybWFsX2lycV9uKys7CisJCQl1 NjRfc3RhdHNfdXBkYXRlX2VuZCgmdHhxX3N0YXRzLT5zeW5jcCk7CiAJCQlyZXQgfD0gaGFuZGxl X3R4OwogCQl9CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9z dG1tYWMvc3RtbWFjLmggYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1t YWMuaAppbmRleCAzNDAxZTg4OGE5ZjYuLmNkN2E5NzY4ZGU1ZiAxMDA2NDQKLS0tIGEvZHJpdmVy cy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjLmgKKysrIGIvZHJpdmVycy9uZXQv ZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjLmgKQEAgLTc4LDcgKzc4LDYgQEAgc3RydWN0 IHN0bW1hY190eF9xdWV1ZSB7CiAJZG1hX2FkZHJfdCBkbWFfdHhfcGh5OwogCWRtYV9hZGRyX3Qg dHhfdGFpbF9hZGRyOwogCXUzMiBtc3M7Ci0Jc3RydWN0IHN0bW1hY190eHFfc3RhdHMgdHhxX3N0 YXRzOwogfTsKIAogc3RydWN0IHN0bW1hY19yeF9idWZmZXIgewpAQCAtMTIzLDcgKzEyMiw2IEBA IHN0cnVjdCBzdG1tYWNfcnhfcXVldWUgewogCQl1bnNpZ25lZCBpbnQgbGVuOwogCQl1bnNpZ25l ZCBpbnQgZXJyb3I7CiAJfSBzdGF0ZTsKLQlzdHJ1Y3Qgc3RtbWFjX3J4cV9zdGF0cyByeHFfc3Rh dHM7CiB9OwogCiBzdHJ1Y3Qgc3RtbWFjX2NoYW5uZWwgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9u ZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX2V0aHRvb2wuYyBiL2RyaXZlcnMvbmV0 L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL3N0bW1hY19ldGh0b29sLmMKaW5kZXggYjdhYzdhYmVj ZGQzLi42YWE1YzA1NTZkMjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWlj cm8vc3RtbWFjL3N0bW1hY19ldGh0b29sLmMKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3Rt aWNyby9zdG1tYWMvc3RtbWFjX2V0aHRvb2wuYwpAQCAtNTQ4LDE0ICs1NDgsMTQgQEAgc3RhdGlj IHZvaWQgc3RtbWFjX2dldF9wZXJfcXN0YXRzKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwgdTY0 ICpkYXRhKQogCiAJcG9zID0gZGF0YTsKIAlmb3IgKHEgPSAwOyBxIDwgdHhfY250OyBxKyspIHsK LQkJc3RydWN0IHN0bW1hY190eF9xdWV1ZSAqdHhfcSA9ICZwcml2LT5kbWFfY29uZi50eF9xdWV1 ZVtxXTsKKwkJc3RydWN0IHN0bW1hY190eHFfc3RhdHMgKnR4cV9zdGF0cyA9ICZwcml2LT54c3Rh dHMudHhxX3N0YXRzW3FdOwogCQlzdHJ1Y3Qgc3RtbWFjX3R4cV9zdGF0cyBzbmFwc2hvdDsKIAog CQlkYXRhID0gcG9zOwogCQlkbyB7Ci0JCQlzdGFydCA9IHU2NF9zdGF0c19mZXRjaF9iZWdpbigm dHhfcS0+dHhxX3N0YXRzLnN5bmNwKTsKLQkJCXNuYXBzaG90ID0gdHhfcS0+dHhxX3N0YXRzOwot CQl9IHdoaWxlICh1NjRfc3RhdHNfZmV0Y2hfcmV0cnkoJnR4X3EtPnR4cV9zdGF0cy5zeW5jcCwg c3RhcnQpKTsKKwkJCXN0YXJ0ID0gdTY0X3N0YXRzX2ZldGNoX2JlZ2luKCZ0eHFfc3RhdHMtPnN5 bmNwKTsKKwkJCXNuYXBzaG90ID0gKnR4cV9zdGF0czsKKwkJfSB3aGlsZSAodTY0X3N0YXRzX2Zl dGNoX3JldHJ5KCZ0eHFfc3RhdHMtPnN5bmNwLCBzdGFydCkpOwogCiAJCXAgPSAoY2hhciAqKSZz bmFwc2hvdCArIG9mZnNldG9mKHN0cnVjdCBzdG1tYWNfdHhxX3N0YXRzLCB0eF9wa3Rfbik7CiAJ CWZvciAoc3RhdCA9IDA7IHN0YXQgPCBTVE1NQUNfVFhRX1NUQVRTOyBzdGF0KyspIHsKQEAgLTU2 NiwxNCArNTY2LDE0IEBAIHN0YXRpYyB2b2lkIHN0bW1hY19nZXRfcGVyX3FzdGF0cyhzdHJ1Y3Qg c3RtbWFjX3ByaXYgKnByaXYsIHU2NCAqZGF0YSkKIAogCXBvcyA9IGRhdGE7CiAJZm9yIChxID0g MDsgcSA8IHJ4X2NudDsgcSsrKSB7Ci0JCXN0cnVjdCBzdG1tYWNfcnhfcXVldWUgKnJ4X3EgPSAm cHJpdi0+ZG1hX2NvbmYucnhfcXVldWVbcV07CisJCXN0cnVjdCBzdG1tYWNfcnhxX3N0YXRzICpy eHFfc3RhdHMgPSAmcHJpdi0+eHN0YXRzLnJ4cV9zdGF0c1txXTsKIAkJc3RydWN0IHN0bW1hY19y eHFfc3RhdHMgc25hcHNob3Q7CiAKIAkJZGF0YSA9IHBvczsKIAkJZG8gewotCQkJc3RhcnQgPSB1 NjRfc3RhdHNfZmV0Y2hfYmVnaW4oJnJ4X3EtPnJ4cV9zdGF0cy5zeW5jcCk7Ci0JCQlzbmFwc2hv dCA9IHJ4X3EtPnJ4cV9zdGF0czsKLQkJfSB3aGlsZSAodTY0X3N0YXRzX2ZldGNoX3JldHJ5KCZy eF9xLT5yeHFfc3RhdHMuc3luY3AsIHN0YXJ0KSk7CisJCQlzdGFydCA9IHU2NF9zdGF0c19mZXRj aF9iZWdpbigmcnhxX3N0YXRzLT5zeW5jcCk7CisJCQlzbmFwc2hvdCA9ICpyeHFfc3RhdHM7CisJ CX0gd2hpbGUgKHU2NF9zdGF0c19mZXRjaF9yZXRyeSgmcnhxX3N0YXRzLT5zeW5jcCwgc3RhcnQp KTsKIAogCQlwID0gKGNoYXIgKikmc25hcHNob3QgKyBvZmZzZXRvZihzdHJ1Y3Qgc3RtbWFjX3J4 cV9zdGF0cywgcnhfcGt0X24pOwogCQlmb3IgKHN0YXQgPSAwOyBzdGF0IDwgU1RNTUFDX1JYUV9T VEFUUzsgc3RhdCsrKSB7CkBAIC02MzcsMTQgKzYzNywxNCBAQCBzdGF0aWMgdm9pZCBzdG1tYWNf Z2V0X2V0aHRvb2xfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKIAogCXBvcyA9IGo7CiAJ Zm9yIChpID0gMDsgaSA8IHJ4X3F1ZXVlc19jb3VudDsgaSsrKSB7Ci0JCXN0cnVjdCBzdG1tYWNf cnhfcXVldWUgKnJ4X3EgPSAmcHJpdi0+ZG1hX2NvbmYucnhfcXVldWVbaV07CisJCXN0cnVjdCBz dG1tYWNfcnhxX3N0YXRzICpyeHFfc3RhdHMgPSAmcHJpdi0+eHN0YXRzLnJ4cV9zdGF0c1tpXTsK IAkJc3RydWN0IHN0bW1hY19yeHFfc3RhdHMgc25hcHNob3Q7CiAKIAkJaiA9IHBvczsKIAkJZG8g ewotCQkJc3RhcnQgPSB1NjRfc3RhdHNfZmV0Y2hfYmVnaW4oJnJ4X3EtPnJ4cV9zdGF0cy5zeW5j cCk7Ci0JCQlzbmFwc2hvdCA9IHJ4X3EtPnJ4cV9zdGF0czsKLQkJfSB3aGlsZSAodTY0X3N0YXRz X2ZldGNoX3JldHJ5KCZyeF9xLT5yeHFfc3RhdHMuc3luY3AsIHN0YXJ0KSk7CisJCQlzdGFydCA9 IHU2NF9zdGF0c19mZXRjaF9iZWdpbigmcnhxX3N0YXRzLT5zeW5jcCk7CisJCQlzbmFwc2hvdCA9 ICpyeHFfc3RhdHM7CisJCX0gd2hpbGUgKHU2NF9zdGF0c19mZXRjaF9yZXRyeSgmcnhxX3N0YXRz LT5zeW5jcCwgc3RhcnQpKTsKIAogCQlkYXRhW2orK10gKz0gc25hcHNob3QucnhfcGt0X247CiAJ CWRhdGFbaisrXSArPSBzbmFwc2hvdC5yeF9ub3JtYWxfaXJxX247CkBAIC02NTQsMTQgKzY1NCwx NCBAQCBzdGF0aWMgdm9pZCBzdG1tYWNfZ2V0X2V0aHRvb2xfc3RhdHMoc3RydWN0IG5ldF9kZXZp Y2UgKmRldiwKIAogCXBvcyA9IGo7CiAJZm9yIChpID0gMDsgaSA8IHR4X3F1ZXVlc19jb3VudDsg aSsrKSB7Ci0JCXN0cnVjdCBzdG1tYWNfdHhfcXVldWUgKnR4X3EgPSAmcHJpdi0+ZG1hX2NvbmYu dHhfcXVldWVbaV07CisJCXN0cnVjdCBzdG1tYWNfdHhxX3N0YXRzICp0eHFfc3RhdHMgPSAmcHJp di0+eHN0YXRzLnR4cV9zdGF0c1tpXTsKIAkJc3RydWN0IHN0bW1hY190eHFfc3RhdHMgc25hcHNo b3Q7CiAKIAkJaiA9IHBvczsKIAkJZG8gewotCQkJc3RhcnQgPSB1NjRfc3RhdHNfZmV0Y2hfYmVn aW4oJnR4X3EtPnR4cV9zdGF0cy5zeW5jcCk7Ci0JCQlzbmFwc2hvdCA9IHR4X3EtPnR4cV9zdGF0 czsKLQkJfSB3aGlsZSAodTY0X3N0YXRzX2ZldGNoX3JldHJ5KCZ0eF9xLT50eHFfc3RhdHMuc3lu Y3AsIHN0YXJ0KSk7CisJCQlzdGFydCA9IHU2NF9zdGF0c19mZXRjaF9iZWdpbigmdHhxX3N0YXRz LT5zeW5jcCk7CisJCQlzbmFwc2hvdCA9ICp0eHFfc3RhdHM7CisJCX0gd2hpbGUgKHU2NF9zdGF0 c19mZXRjaF9yZXRyeSgmdHhxX3N0YXRzLT5zeW5jcCwgc3RhcnQpKTsKIAogCQlkYXRhW2orK10g Kz0gc25hcHNob3QudHhfcGt0X247CiAJCWRhdGFbaisrXSArPSBzbmFwc2hvdC50eF9ub3JtYWxf aXJxX247CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9z dG1tYWNfbWFpbi5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFj X21haW4uYwppbmRleCA5YTMxODJiOWU3NjcuLjVhMmIwNmM2ZTg4OSAxMDA2NDQKLS0tIGEvZHJp dmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvc3RtbWFjX21haW4uYworKysgYi9kcml2 ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9zdG1tYWNfbWFpbi5jCkBAIC0yNDI2LDYg KzI0MjYsNyBAQCBzdGF0aWMgYm9vbCBzdG1tYWNfeGRwX3htaXRfemMoc3RydWN0IHN0bW1hY19w cml2ICpwcml2LCB1MzIgcXVldWUsIHUzMiBidWRnZXQpCiB7CiAJc3RydWN0IG5ldGRldl9xdWV1 ZSAqbnEgPSBuZXRkZXZfZ2V0X3R4X3F1ZXVlKHByaXYtPmRldiwgcXVldWUpOwogCXN0cnVjdCBz dG1tYWNfdHhfcXVldWUgKnR4X3EgPSAmcHJpdi0+ZG1hX2NvbmYudHhfcXVldWVbcXVldWVdOwor CXN0cnVjdCBzdG1tYWNfdHhxX3N0YXRzICp0eHFfc3RhdHMgPSAmcHJpdi0+eHN0YXRzLnR4cV9z dGF0c1txdWV1ZV07CiAJc3RydWN0IHhza19idWZmX3Bvb2wgKnBvb2wgPSB0eF9xLT54c2tfcG9v bDsKIAl1bnNpZ25lZCBpbnQgZW50cnkgPSB0eF9xLT5jdXJfdHg7CiAJc3RydWN0IGRtYV9kZXNj ICp0eF9kZXNjID0gTlVMTDsKQEAgLTI1MDUsOSArMjUwNiw5IEBAIHN0YXRpYyBib29sIHN0bW1h Y194ZHBfeG1pdF96YyhzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYsIHUzMiBxdWV1ZSwgdTMyIGJ1 ZGdldCkKIAkJdHhfcS0+Y3VyX3R4ID0gU1RNTUFDX0dFVF9FTlRSWSh0eF9xLT5jdXJfdHgsIHBy aXYtPmRtYV9jb25mLmRtYV90eF9zaXplKTsKIAkJZW50cnkgPSB0eF9xLT5jdXJfdHg7CiAJfQot CWZsYWdzID0gdTY0X3N0YXRzX3VwZGF0ZV9iZWdpbl9pcnFzYXZlKCZ0eF9xLT50eHFfc3RhdHMu c3luY3ApOwotCXR4X3EtPnR4cV9zdGF0cy50eF9zZXRfaWNfYml0ICs9IHR4X3NldF9pY19iaXQ7 Ci0JdTY0X3N0YXRzX3VwZGF0ZV9lbmRfaXJxcmVzdG9yZSgmdHhfcS0+dHhxX3N0YXRzLnN5bmNw LCBmbGFncyk7CisJZmxhZ3MgPSB1NjRfc3RhdHNfdXBkYXRlX2JlZ2luX2lycXNhdmUoJnR4cV9z dGF0cy0+c3luY3ApOworCXR4cV9zdGF0cy0+dHhfc2V0X2ljX2JpdCArPSB0eF9zZXRfaWNfYml0 OworCXU2NF9zdGF0c191cGRhdGVfZW5kX2lycXJlc3RvcmUoJnR4cV9zdGF0cy0+c3luY3AsIGZs YWdzKTsKIAogCWlmICh0eF9kZXNjKSB7CiAJCXN0bW1hY19mbHVzaF90eF9kZXNjcmlwdG9ycyhw cml2LCBxdWV1ZSk7CkBAIC0yNTQ3LDYgKzI1NDgsNyBAQCBzdGF0aWMgdm9pZCBzdG1tYWNfYnVt cF9kbWFfdGhyZXNob2xkKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwgdTMyIGNoYW4pCiBzdGF0 aWMgaW50IHN0bW1hY190eF9jbGVhbihzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYsIGludCBidWRn ZXQsIHUzMiBxdWV1ZSkKIHsKIAlzdHJ1Y3Qgc3RtbWFjX3R4X3F1ZXVlICp0eF9xID0gJnByaXYt PmRtYV9jb25mLnR4X3F1ZXVlW3F1ZXVlXTsKKwlzdHJ1Y3Qgc3RtbWFjX3R4cV9zdGF0cyAqdHhx X3N0YXRzID0gJnByaXYtPnhzdGF0cy50eHFfc3RhdHNbcXVldWVdOwogCXVuc2lnbmVkIGludCBi eXRlc19jb21wbCA9IDAsIHBrdHNfY29tcGwgPSAwOwogCXVuc2lnbmVkIGludCBlbnRyeSwgeG1p dHMgPSAwLCBjb3VudCA9IDA7CiAJdTMyIHR4X3BhY2tldHMgPSAwLCB0eF9lcnJvcnMgPSAwOwpA QCAtMjcwOCwxMSArMjcxMCwxMSBAQCBzdGF0aWMgaW50IHN0bW1hY190eF9jbGVhbihzdHJ1Y3Qg c3RtbWFjX3ByaXYgKnByaXYsIGludCBidWRnZXQsIHUzMiBxdWV1ZSkKIAkJCSAgICAgIFNUTU1B Q19DT0FMX1RJTUVSKHByaXYtPnR4X2NvYWxfdGltZXJbcXVldWVdKSwKIAkJCSAgICAgIEhSVElN RVJfTU9ERV9SRUwpOwogCi0JZmxhZ3MgPSB1NjRfc3RhdHNfdXBkYXRlX2JlZ2luX2lycXNhdmUo JnR4X3EtPnR4cV9zdGF0cy5zeW5jcCk7Ci0JdHhfcS0+dHhxX3N0YXRzLnR4X3BhY2tldHMgKz0g dHhfcGFja2V0czsKLQl0eF9xLT50eHFfc3RhdHMudHhfcGt0X24gKz0gdHhfcGFja2V0czsKLQl0 eF9xLT50eHFfc3RhdHMudHhfY2xlYW4rKzsKLQl1NjRfc3RhdHNfdXBkYXRlX2VuZF9pcnFyZXN0 b3JlKCZ0eF9xLT50eHFfc3RhdHMuc3luY3AsIGZsYWdzKTsKKwlmbGFncyA9IHU2NF9zdGF0c191 cGRhdGVfYmVnaW5faXJxc2F2ZSgmdHhxX3N0YXRzLT5zeW5jcCk7CisJdHhxX3N0YXRzLT50eF9w YWNrZXRzICs9IHR4X3BhY2tldHM7CisJdHhxX3N0YXRzLT50eF9wa3RfbiArPSB0eF9wYWNrZXRz OworCXR4cV9zdGF0cy0+dHhfY2xlYW4rKzsKKwl1NjRfc3RhdHNfdXBkYXRlX2VuZF9pcnFyZXN0 b3JlKCZ0eHFfc3RhdHMtPnN5bmNwLCBmbGFncyk7CiAKIAlwcml2LT54c3RhdHMudHhfZXJyb3Jz ICs9IHR4X2Vycm9yczsKIApAQCAtNDExMiw2ICs0MTE0LDcgQEAgc3RhdGljIG5ldGRldl90eF90 IHN0bW1hY190c29feG1pdChzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3QgbmV0X2RldmljZSAq ZGV2KQogCWludCBuZnJhZ3MgPSBza2Jfc2hpbmZvKHNrYiktPm5yX2ZyYWdzOwogCXUzMiBxdWV1 ZSA9IHNrYl9nZXRfcXVldWVfbWFwcGluZyhza2IpOwogCXVuc2lnbmVkIGludCBmaXJzdF9lbnRy eSwgdHhfcGFja2V0czsKKwlzdHJ1Y3Qgc3RtbWFjX3R4cV9zdGF0cyAqdHhxX3N0YXRzOwogCWlu dCB0bXBfcGF5X2xlbiA9IDAsIGZpcnN0X3R4OwogCXN0cnVjdCBzdG1tYWNfdHhfcXVldWUgKnR4 X3E7CiAJYm9vbCBoYXNfdmxhbiwgc2V0X2ljOwpAQCAtNDEyMiw2ICs0MTI1LDcgQEAgc3RhdGlj IG5ldGRldl90eF90IHN0bW1hY190c29feG1pdChzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3Qg bmV0X2RldmljZSAqZGV2KQogCWludCBpOwogCiAJdHhfcSA9ICZwcml2LT5kbWFfY29uZi50eF9x dWV1ZVtxdWV1ZV07CisJdHhxX3N0YXRzID0gJnByaXYtPnhzdGF0cy50eHFfc3RhdHNbcXVldWVd OwogCWZpcnN0X3R4ID0gdHhfcS0+Y3VyX3R4OwogCiAJLyogQ29tcHV0ZSBoZWFkZXIgbGVuZ3Ro cyAqLwpAQCAtNDI4MCwxMyArNDI4NCwxMyBAQCBzdGF0aWMgbmV0ZGV2X3R4X3Qgc3RtbWFjX3Rz b194bWl0KHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiAJCW5l dGlmX3R4X3N0b3BfcXVldWUobmV0ZGV2X2dldF90eF9xdWV1ZShwcml2LT5kZXYsIHF1ZXVlKSk7 CiAJfQogCi0JZmxhZ3MgPSB1NjRfc3RhdHNfdXBkYXRlX2JlZ2luX2lycXNhdmUoJnR4X3EtPnR4 cV9zdGF0cy5zeW5jcCk7Ci0JdHhfcS0+dHhxX3N0YXRzLnR4X2J5dGVzICs9IHNrYi0+bGVuOwot CXR4X3EtPnR4cV9zdGF0cy50eF90c29fZnJhbWVzKys7Ci0JdHhfcS0+dHhxX3N0YXRzLnR4X3Rz b19uZnJhZ3MgKz0gbmZyYWdzOworCWZsYWdzID0gdTY0X3N0YXRzX3VwZGF0ZV9iZWdpbl9pcnFz YXZlKCZ0eHFfc3RhdHMtPnN5bmNwKTsKKwl0eHFfc3RhdHMtPnR4X2J5dGVzICs9IHNrYi0+bGVu OworCXR4cV9zdGF0cy0+dHhfdHNvX2ZyYW1lcysrOworCXR4cV9zdGF0cy0+dHhfdHNvX25mcmFn cyArPSBuZnJhZ3M7CiAJaWYgKHNldF9pYykKLQkJdHhfcS0+dHhxX3N0YXRzLnR4X3NldF9pY19i aXQrKzsKLQl1NjRfc3RhdHNfdXBkYXRlX2VuZF9pcnFyZXN0b3JlKCZ0eF9xLT50eHFfc3RhdHMu c3luY3AsIGZsYWdzKTsKKwkJdHhxX3N0YXRzLT50eF9zZXRfaWNfYml0Kys7CisJdTY0X3N0YXRz X3VwZGF0ZV9lbmRfaXJxcmVzdG9yZSgmdHhxX3N0YXRzLT5zeW5jcCwgZmxhZ3MpOwogCiAJaWYg KHByaXYtPnNhcmNfdHlwZSkKIAkJc3RtbWFjX3NldF9kZXNjX3NhcmMocHJpdiwgZmlyc3QsIHBy aXYtPnNhcmNfdHlwZSk7CkBAIC00MzU3LDYgKzQzNjEsNyBAQCBzdGF0aWMgbmV0ZGV2X3R4X3Qg c3RtbWFjX3htaXQoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IG5ldF9kZXZpY2UgKmRldikK IAl1MzIgcXVldWUgPSBza2JfZ2V0X3F1ZXVlX21hcHBpbmcoc2tiKTsKIAlpbnQgbmZyYWdzID0g c2tiX3NoaW5mbyhza2IpLT5ucl9mcmFnczsKIAlpbnQgZ3NvID0gc2tiX3NoaW5mbyhza2IpLT5n c29fdHlwZTsKKwlzdHJ1Y3Qgc3RtbWFjX3R4cV9zdGF0cyAqdHhxX3N0YXRzOwogCXN0cnVjdCBk bWFfZWRlc2MgKnRic19kZXNjID0gTlVMTDsKIAlzdHJ1Y3QgZG1hX2Rlc2MgKmRlc2MsICpmaXJz dDsKIAlzdHJ1Y3Qgc3RtbWFjX3R4X3F1ZXVlICp0eF9xOwpAQCAtNDM2Niw2ICs0MzcxLDcgQEAg c3RhdGljIG5ldGRldl90eF90IHN0bW1hY194bWl0KHN0cnVjdCBza19idWZmICpza2IsIHN0cnVj dCBuZXRfZGV2aWNlICpkZXYpCiAJZG1hX2FkZHJfdCBkZXM7CiAKIAl0eF9xID0gJnByaXYtPmRt YV9jb25mLnR4X3F1ZXVlW3F1ZXVlXTsKKwl0eHFfc3RhdHMgPSAmcHJpdi0+eHN0YXRzLnR4cV9z dGF0c1txdWV1ZV07CiAJZmlyc3RfdHggPSB0eF9xLT5jdXJfdHg7CiAKIAlpZiAocHJpdi0+dHhf cGF0aF9pbl9scGlfbW9kZSAmJiBwcml2LT5lZWVfc3dfdGltZXJfZW4pCkBAIC00NTE3LDExICs0 NTIzLDExIEBAIHN0YXRpYyBuZXRkZXZfdHhfdCBzdG1tYWNfeG1pdChzdHJ1Y3Qgc2tfYnVmZiAq c2tiLCBzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQogCQluZXRpZl90eF9zdG9wX3F1ZXVlKG5ldGRl dl9nZXRfdHhfcXVldWUocHJpdi0+ZGV2LCBxdWV1ZSkpOwogCX0KIAotCWZsYWdzID0gdTY0X3N0 YXRzX3VwZGF0ZV9iZWdpbl9pcnFzYXZlKCZ0eF9xLT50eHFfc3RhdHMuc3luY3ApOwotCXR4X3Et PnR4cV9zdGF0cy50eF9ieXRlcyArPSBza2ItPmxlbjsKKwlmbGFncyA9IHU2NF9zdGF0c191cGRh dGVfYmVnaW5faXJxc2F2ZSgmdHhxX3N0YXRzLT5zeW5jcCk7CisJdHhxX3N0YXRzLT50eF9ieXRl cyArPSBza2ItPmxlbjsKIAlpZiAoc2V0X2ljKQotCQl0eF9xLT50eHFfc3RhdHMudHhfc2V0X2lj X2JpdCsrOwotCXU2NF9zdGF0c191cGRhdGVfZW5kX2lycXJlc3RvcmUoJnR4X3EtPnR4cV9zdGF0 cy5zeW5jcCwgZmxhZ3MpOworCQl0eHFfc3RhdHMtPnR4X3NldF9pY19iaXQrKzsKKwl1NjRfc3Rh dHNfdXBkYXRlX2VuZF9pcnFyZXN0b3JlKCZ0eHFfc3RhdHMtPnN5bmNwLCBmbGFncyk7CiAKIAlp ZiAocHJpdi0+c2FyY190eXBlKQogCQlzdG1tYWNfc2V0X2Rlc2Nfc2FyYyhwcml2LCBmaXJzdCwg cHJpdi0+c2FyY190eXBlKTsKQEAgLTQ3MjgsNiArNDczNCw3IEBAIHN0YXRpYyB1bnNpZ25lZCBp bnQgc3RtbWFjX3J4X2J1ZjJfbGVuKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwKIHN0YXRpYyBp bnQgc3RtbWFjX3hkcF94bWl0X3hkcGYoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCBpbnQgcXVl dWUsCiAJCQkJc3RydWN0IHhkcF9mcmFtZSAqeGRwZiwgYm9vbCBkbWFfbWFwKQogeworCXN0cnVj dCBzdG1tYWNfdHhxX3N0YXRzICp0eHFfc3RhdHMgPSAmcHJpdi0+eHN0YXRzLnR4cV9zdGF0c1tx dWV1ZV07CiAJc3RydWN0IHN0bW1hY190eF9xdWV1ZSAqdHhfcSA9ICZwcml2LT5kbWFfY29uZi50 eF9xdWV1ZVtxdWV1ZV07CiAJdW5zaWduZWQgaW50IGVudHJ5ID0gdHhfcS0+Y3VyX3R4OwogCXN0 cnVjdCBkbWFfZGVzYyAqdHhfZGVzYzsKQEAgLTQ3ODcsOSArNDc5NCw5IEBAIHN0YXRpYyBpbnQg c3RtbWFjX3hkcF94bWl0X3hkcGYoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCBpbnQgcXVldWUs CiAJCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJCXR4X3EtPnR4X2NvdW50X2ZyYW1lcyA9IDA7CiAJ CXN0bW1hY19zZXRfdHhfaWMocHJpdiwgdHhfZGVzYyk7Ci0JCWZsYWdzID0gdTY0X3N0YXRzX3Vw ZGF0ZV9iZWdpbl9pcnFzYXZlKCZ0eF9xLT50eHFfc3RhdHMuc3luY3ApOwotCQl0eF9xLT50eHFf c3RhdHMudHhfc2V0X2ljX2JpdCsrOwotCQl1NjRfc3RhdHNfdXBkYXRlX2VuZF9pcnFyZXN0b3Jl KCZ0eF9xLT50eHFfc3RhdHMuc3luY3AsIGZsYWdzKTsKKwkJZmxhZ3MgPSB1NjRfc3RhdHNfdXBk YXRlX2JlZ2luX2lycXNhdmUoJnR4cV9zdGF0cy0+c3luY3ApOworCQl0eHFfc3RhdHMtPnR4X3Nl dF9pY19iaXQrKzsKKwkJdTY0X3N0YXRzX3VwZGF0ZV9lbmRfaXJxcmVzdG9yZSgmdHhxX3N0YXRz LT5zeW5jcCwgZmxhZ3MpOwogCX0KIAogCXN0bW1hY19lbmFibGVfZG1hX3RyYW5zbWlzc2lvbihw cml2LCBwcml2LT5pb2FkZHIpOwpAQCAtNDkzNCw3ICs0OTQxLDcgQEAgc3RhdGljIHZvaWQgc3Rt bWFjX2Rpc3BhdGNoX3NrYl96YyhzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYsIHUzMiBxdWV1ZSwK IAkJCQkgICBzdHJ1Y3QgZG1hX2Rlc2MgKnAsIHN0cnVjdCBkbWFfZGVzYyAqbnAsCiAJCQkJICAg c3RydWN0IHhkcF9idWZmICp4ZHApCiB7Ci0Jc3RydWN0IHN0bW1hY19yeF9xdWV1ZSAqcnhfcSA9 ICZwcml2LT5kbWFfY29uZi5yeF9xdWV1ZVtxdWV1ZV07CisJc3RydWN0IHN0bW1hY19yeHFfc3Rh dHMgKnJ4cV9zdGF0cyA9ICZwcml2LT54c3RhdHMucnhxX3N0YXRzW3F1ZXVlXTsKIAlzdHJ1Y3Qg c3RtbWFjX2NoYW5uZWwgKmNoID0gJnByaXYtPmNoYW5uZWxbcXVldWVdOwogCXVuc2lnbmVkIGlu dCBsZW4gPSB4ZHAtPmRhdGFfZW5kIC0geGRwLT5kYXRhOwogCWVudW0gcGt0X2hhc2hfdHlwZXMg aGFzaF90eXBlOwpAQCAtNDk2NCwxMCArNDk3MSwxMCBAQCBzdGF0aWMgdm9pZCBzdG1tYWNfZGlz cGF0Y2hfc2tiX3pjKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiwgdTMyIHF1ZXVlLAogCXNrYl9y ZWNvcmRfcnhfcXVldWUoc2tiLCBxdWV1ZSk7CiAJbmFwaV9ncm9fcmVjZWl2ZSgmY2gtPnJ4dHhf bmFwaSwgc2tiKTsKIAotCWZsYWdzID0gdTY0X3N0YXRzX3VwZGF0ZV9iZWdpbl9pcnFzYXZlKCZy eF9xLT5yeHFfc3RhdHMuc3luY3ApOwotCXJ4X3EtPnJ4cV9zdGF0cy5yeF9wa3RfbisrOwotCXJ4 X3EtPnJ4cV9zdGF0cy5yeF9ieXRlcyArPSBsZW47Ci0JdTY0X3N0YXRzX3VwZGF0ZV9lbmRfaXJx cmVzdG9yZSgmcnhfcS0+cnhxX3N0YXRzLnN5bmNwLCBmbGFncyk7CisJZmxhZ3MgPSB1NjRfc3Rh dHNfdXBkYXRlX2JlZ2luX2lycXNhdmUoJnJ4cV9zdGF0cy0+c3luY3ApOworCXJ4cV9zdGF0cy0+ cnhfcGt0X24rKzsKKwlyeHFfc3RhdHMtPnJ4X2J5dGVzICs9IGxlbjsKKwl1NjRfc3RhdHNfdXBk YXRlX2VuZF9pcnFyZXN0b3JlKCZyeHFfc3RhdHMtPnN5bmNwLCBmbGFncyk7CiB9CiAKIHN0YXRp YyBib29sIHN0bW1hY19yeF9yZWZpbGxfemMoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCB1MzIg cXVldWUsIHUzMiBidWRnZXQpCkBAIC01MDQwLDYgKzUwNDcsNyBAQCBzdGF0aWMgc3RydWN0IHN0 bW1hY194ZHBfYnVmZiAqeHNrX2J1ZmZfdG9fc3RtbWFjX2N0eChzdHJ1Y3QgeGRwX2J1ZmYgKnhk cCkKIAogc3RhdGljIGludCBzdG1tYWNfcnhfemMoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCBp bnQgbGltaXQsIHUzMiBxdWV1ZSkKIHsKKwlzdHJ1Y3Qgc3RtbWFjX3J4cV9zdGF0cyAqcnhxX3N0 YXRzID0gJnByaXYtPnhzdGF0cy5yeHFfc3RhdHNbcXVldWVdOwogCXN0cnVjdCBzdG1tYWNfcnhf cXVldWUgKnJ4X3EgPSAmcHJpdi0+ZG1hX2NvbmYucnhfcXVldWVbcXVldWVdOwogCXVuc2lnbmVk IGludCBjb3VudCA9IDAsIGVycm9yID0gMCwgbGVuID0gMDsKIAlpbnQgZGlydHkgPSBzdG1tYWNf cnhfZGlydHkocHJpdiwgcXVldWUpOwpAQCAtNTIwMyw5ICs1MjExLDkgQEAgc3RhdGljIGludCBz dG1tYWNfcnhfemMoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCBpbnQgbGltaXQsIHUzMiBxdWV1 ZSkKIAogCXN0bW1hY19maW5hbGl6ZV94ZHBfcngocHJpdiwgeGRwX3N0YXR1cyk7CiAKLQlmbGFn cyA9IHU2NF9zdGF0c191cGRhdGVfYmVnaW5faXJxc2F2ZSgmcnhfcS0+cnhxX3N0YXRzLnN5bmNw KTsKLQlyeF9xLT5yeHFfc3RhdHMucnhfcGt0X24gKz0gY291bnQ7Ci0JdTY0X3N0YXRzX3VwZGF0 ZV9lbmRfaXJxcmVzdG9yZSgmcnhfcS0+cnhxX3N0YXRzLnN5bmNwLCBmbGFncyk7CisJZmxhZ3Mg PSB1NjRfc3RhdHNfdXBkYXRlX2JlZ2luX2lycXNhdmUoJnJ4cV9zdGF0cy0+c3luY3ApOworCXJ4 cV9zdGF0cy0+cnhfcGt0X24gKz0gY291bnQ7CisJdTY0X3N0YXRzX3VwZGF0ZV9lbmRfaXJxcmVz dG9yZSgmcnhxX3N0YXRzLT5zeW5jcCwgZmxhZ3MpOwogCiAJcHJpdi0+eHN0YXRzLnJ4X2Ryb3Bw ZWQgKz0gcnhfZHJvcHBlZDsKIAlwcml2LT54c3RhdHMucnhfZXJyb3JzICs9IHJ4X2Vycm9yczsK QEAgLTUyMzMsNiArNTI0MSw3IEBAIHN0YXRpYyBpbnQgc3RtbWFjX3J4X3pjKHN0cnVjdCBzdG1t YWNfcHJpdiAqcHJpdiwgaW50IGxpbWl0LCB1MzIgcXVldWUpCiBzdGF0aWMgaW50IHN0bW1hY19y eChzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYsIGludCBsaW1pdCwgdTMyIHF1ZXVlKQogewogCXUz MiByeF9lcnJvcnMgPSAwLCByeF9kcm9wcGVkID0gMCwgcnhfYnl0ZXMgPSAwLCByeF9wYWNrZXRz ID0gMDsKKwlzdHJ1Y3Qgc3RtbWFjX3J4cV9zdGF0cyAqcnhxX3N0YXRzID0gJnByaXYtPnhzdGF0 cy5yeHFfc3RhdHNbcXVldWVdOwogCXN0cnVjdCBzdG1tYWNfcnhfcXVldWUgKnJ4X3EgPSAmcHJp di0+ZG1hX2NvbmYucnhfcXVldWVbcXVldWVdOwogCXN0cnVjdCBzdG1tYWNfY2hhbm5lbCAqY2gg PSAmcHJpdi0+Y2hhbm5lbFtxdWV1ZV07CiAJdW5zaWduZWQgaW50IGNvdW50ID0gMCwgZXJyb3Ig PSAwLCBsZW4gPSAwOwpAQCAtNTQ5NCwxMSArNTUwMywxMSBAQCBzdGF0aWMgaW50IHN0bW1hY19y eChzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYsIGludCBsaW1pdCwgdTMyIHF1ZXVlKQogCiAJc3Rt bWFjX3J4X3JlZmlsbChwcml2LCBxdWV1ZSk7CiAKLQlmbGFncyA9IHU2NF9zdGF0c191cGRhdGVf YmVnaW5faXJxc2F2ZSgmcnhfcS0+cnhxX3N0YXRzLnN5bmNwKTsKLQlyeF9xLT5yeHFfc3RhdHMu cnhfcGFja2V0cyArPSByeF9wYWNrZXRzOwotCXJ4X3EtPnJ4cV9zdGF0cy5yeF9ieXRlcyArPSBy eF9ieXRlczsKLQlyeF9xLT5yeHFfc3RhdHMucnhfcGt0X24gKz0gY291bnQ7Ci0JdTY0X3N0YXRz X3VwZGF0ZV9lbmRfaXJxcmVzdG9yZSgmcnhfcS0+cnhxX3N0YXRzLnN5bmNwLCBmbGFncyk7CisJ ZmxhZ3MgPSB1NjRfc3RhdHNfdXBkYXRlX2JlZ2luX2lycXNhdmUoJnJ4cV9zdGF0cy0+c3luY3Ap OworCXJ4cV9zdGF0cy0+cnhfcGFja2V0cyArPSByeF9wYWNrZXRzOworCXJ4cV9zdGF0cy0+cnhf Ynl0ZXMgKz0gcnhfYnl0ZXM7CisJcnhxX3N0YXRzLT5yeF9wa3RfbiArPSBjb3VudDsKKwl1NjRf c3RhdHNfdXBkYXRlX2VuZF9pcnFyZXN0b3JlKCZyeHFfc3RhdHMtPnN5bmNwLCBmbGFncyk7CiAK IAlwcml2LT54c3RhdHMucnhfZHJvcHBlZCArPSByeF9kcm9wcGVkOwogCXByaXYtPnhzdGF0cy5y eF9lcnJvcnMgKz0gcnhfZXJyb3JzOwpAQCAtNTUxMSwxNSArNTUyMCwxNSBAQCBzdGF0aWMgaW50 IHN0bW1hY19uYXBpX3BvbGxfcngoc3RydWN0IG5hcGlfc3RydWN0ICpuYXBpLCBpbnQgYnVkZ2V0 KQogCXN0cnVjdCBzdG1tYWNfY2hhbm5lbCAqY2ggPQogCQljb250YWluZXJfb2YobmFwaSwgc3Ry dWN0IHN0bW1hY19jaGFubmVsLCByeF9uYXBpKTsKIAlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYg PSBjaC0+cHJpdl9kYXRhOwotCXN0cnVjdCBzdG1tYWNfcnhfcXVldWUgKnJ4X3E7CisJc3RydWN0 IHN0bW1hY19yeHFfc3RhdHMgKnJ4cV9zdGF0czsKIAl1MzIgY2hhbiA9IGNoLT5pbmRleDsKIAl1 bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCB3b3JrX2RvbmU7CiAKLQlyeF9xID0gJnByaXYtPmRt YV9jb25mLnJ4X3F1ZXVlW2NoYW5dOwotCWZsYWdzID0gdTY0X3N0YXRzX3VwZGF0ZV9iZWdpbl9p cnFzYXZlKCZyeF9xLT5yeHFfc3RhdHMuc3luY3ApOwotCXJ4X3EtPnJ4cV9zdGF0cy5uYXBpX3Bv bGwrKzsKLQl1NjRfc3RhdHNfdXBkYXRlX2VuZF9pcnFyZXN0b3JlKCZyeF9xLT5yeHFfc3RhdHMu c3luY3AsIGZsYWdzKTsKKwlyeHFfc3RhdHMgPSAmcHJpdi0+eHN0YXRzLnJ4cV9zdGF0c1tjaGFu XTsKKwlmbGFncyA9IHU2NF9zdGF0c191cGRhdGVfYmVnaW5faXJxc2F2ZSgmcnhxX3N0YXRzLT5z eW5jcCk7CisJcnhxX3N0YXRzLT5uYXBpX3BvbGwrKzsKKwl1NjRfc3RhdHNfdXBkYXRlX2VuZF9p cnFyZXN0b3JlKCZyeHFfc3RhdHMtPnN5bmNwLCBmbGFncyk7CiAKIAl3b3JrX2RvbmUgPSBzdG1t YWNfcngocHJpdiwgYnVkZ2V0LCBjaGFuKTsKIAlpZiAod29ya19kb25lIDwgYnVkZ2V0ICYmIG5h cGlfY29tcGxldGVfZG9uZShuYXBpLCB3b3JrX2RvbmUpKSB7CkBAIC01NTM4LDE1ICs1NTQ3LDE1 IEBAIHN0YXRpYyBpbnQgc3RtbWFjX25hcGlfcG9sbF90eChzdHJ1Y3QgbmFwaV9zdHJ1Y3QgKm5h cGksIGludCBidWRnZXQpCiAJc3RydWN0IHN0bW1hY19jaGFubmVsICpjaCA9CiAJCWNvbnRhaW5l cl9vZihuYXBpLCBzdHJ1Y3Qgc3RtbWFjX2NoYW5uZWwsIHR4X25hcGkpOwogCXN0cnVjdCBzdG1t YWNfcHJpdiAqcHJpdiA9IGNoLT5wcml2X2RhdGE7Ci0Jc3RydWN0IHN0bW1hY190eF9xdWV1ZSAq dHhfcTsKKwlzdHJ1Y3Qgc3RtbWFjX3R4cV9zdGF0cyAqdHhxX3N0YXRzOwogCXUzMiBjaGFuID0g Y2gtPmluZGV4OwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJaW50IHdvcmtfZG9uZTsKIAotCXR4 X3EgPSAmcHJpdi0+ZG1hX2NvbmYudHhfcXVldWVbY2hhbl07Ci0JZmxhZ3MgPSB1NjRfc3RhdHNf dXBkYXRlX2JlZ2luX2lycXNhdmUoJnR4X3EtPnR4cV9zdGF0cy5zeW5jcCk7Ci0JdHhfcS0+dHhx X3N0YXRzLm5hcGlfcG9sbCsrOwotCXU2NF9zdGF0c191cGRhdGVfZW5kX2lycXJlc3RvcmUoJnR4 X3EtPnR4cV9zdGF0cy5zeW5jcCwgZmxhZ3MpOworCXR4cV9zdGF0cyA9ICZwcml2LT54c3RhdHMu dHhxX3N0YXRzW2NoYW5dOworCWZsYWdzID0gdTY0X3N0YXRzX3VwZGF0ZV9iZWdpbl9pcnFzYXZl KCZ0eHFfc3RhdHMtPnN5bmNwKTsKKwl0eHFfc3RhdHMtPm5hcGlfcG9sbCsrOworCXU2NF9zdGF0 c191cGRhdGVfZW5kX2lycXJlc3RvcmUoJnR4cV9zdGF0cy0+c3luY3AsIGZsYWdzKTsKIAogCXdv cmtfZG9uZSA9IHN0bW1hY190eF9jbGVhbihwcml2LCBidWRnZXQsIGNoYW4pOwogCXdvcmtfZG9u ZSA9IG1pbih3b3JrX2RvbmUsIGJ1ZGdldCk7CkBAIC01NTY4LDIwICs1NTc3LDIwIEBAIHN0YXRp YyBpbnQgc3RtbWFjX25hcGlfcG9sbF9yeHR4KHN0cnVjdCBuYXBpX3N0cnVjdCAqbmFwaSwgaW50 IGJ1ZGdldCkKIAkJY29udGFpbmVyX29mKG5hcGksIHN0cnVjdCBzdG1tYWNfY2hhbm5lbCwgcnh0 eF9uYXBpKTsKIAlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBjaC0+cHJpdl9kYXRhOwogCWlu dCByeF9kb25lLCB0eF9kb25lLCByeHR4X2RvbmU7Ci0Jc3RydWN0IHN0bW1hY19yeF9xdWV1ZSAq cnhfcTsKLQlzdHJ1Y3Qgc3RtbWFjX3R4X3F1ZXVlICp0eF9xOworCXN0cnVjdCBzdG1tYWNfcnhx X3N0YXRzICpyeHFfc3RhdHM7CisJc3RydWN0IHN0bW1hY190eHFfc3RhdHMgKnR4cV9zdGF0czsK IAl1MzIgY2hhbiA9IGNoLT5pbmRleDsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0JcnhfcSA9 ICZwcml2LT5kbWFfY29uZi5yeF9xdWV1ZVtjaGFuXTsKLQlmbGFncyA9IHU2NF9zdGF0c191cGRh dGVfYmVnaW5faXJxc2F2ZSgmcnhfcS0+cnhxX3N0YXRzLnN5bmNwKTsKLQlyeF9xLT5yeHFfc3Rh dHMubmFwaV9wb2xsKys7Ci0JdTY0X3N0YXRzX3VwZGF0ZV9lbmRfaXJxcmVzdG9yZSgmcnhfcS0+ cnhxX3N0YXRzLnN5bmNwLCBmbGFncyk7CisJcnhxX3N0YXRzID0gJnByaXYtPnhzdGF0cy5yeHFf c3RhdHNbY2hhbl07CisJZmxhZ3MgPSB1NjRfc3RhdHNfdXBkYXRlX2JlZ2luX2lycXNhdmUoJnJ4 cV9zdGF0cy0+c3luY3ApOworCXJ4cV9zdGF0cy0+bmFwaV9wb2xsKys7CisJdTY0X3N0YXRzX3Vw ZGF0ZV9lbmRfaXJxcmVzdG9yZSgmcnhxX3N0YXRzLT5zeW5jcCwgZmxhZ3MpOwogCi0JdHhfcSA9 ICZwcml2LT5kbWFfY29uZi50eF9xdWV1ZVtjaGFuXTsKLQlmbGFncyA9IHU2NF9zdGF0c191cGRh dGVfYmVnaW5faXJxc2F2ZSgmdHhfcS0+dHhxX3N0YXRzLnN5bmNwKTsKLQl0eF9xLT50eHFfc3Rh dHMubmFwaV9wb2xsKys7Ci0JdTY0X3N0YXRzX3VwZGF0ZV9lbmRfaXJxcmVzdG9yZSgmdHhfcS0+ dHhxX3N0YXRzLnN5bmNwLCBmbGFncyk7CisJdHhxX3N0YXRzID0gJnByaXYtPnhzdGF0cy50eHFf c3RhdHNbY2hhbl07CisJZmxhZ3MgPSB1NjRfc3RhdHNfdXBkYXRlX2JlZ2luX2lycXNhdmUoJnR4 cV9zdGF0cy0+c3luY3ApOworCXR4cV9zdGF0cy0+bmFwaV9wb2xsKys7CisJdTY0X3N0YXRzX3Vw ZGF0ZV9lbmRfaXJxcmVzdG9yZSgmdHhxX3N0YXRzLT5zeW5jcCwgZmxhZ3MpOwogCiAJdHhfZG9u ZSA9IHN0bW1hY190eF9jbGVhbihwcml2LCBidWRnZXQsIGNoYW4pOwogCXR4X2RvbmUgPSBtaW4o dHhfZG9uZSwgYnVkZ2V0KTsKQEAgLTY5MjQsNyArNjkzMyw3IEBAIHN0YXRpYyB2b2lkIHN0bW1h Y19nZXRfc3RhdHM2NChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgcnRubF9saW5rX3N0 YXRzNjQKIAlpbnQgcTsKIAogCWZvciAocSA9IDA7IHEgPCB0eF9jbnQ7IHErKykgewotCQlzdHJ1 Y3Qgc3RtbWFjX3R4cV9zdGF0cyAqdHhxX3N0YXRzID0gJnByaXYtPmRtYV9jb25mLnR4X3F1ZXVl W3FdLnR4cV9zdGF0czsKKwkJc3RydWN0IHN0bW1hY190eHFfc3RhdHMgKnR4cV9zdGF0cyA9ICZw cml2LT54c3RhdHMudHhxX3N0YXRzW3FdOwogCQl1NjQgdHhfcGFja2V0czsKIAkJdTY0IHR4X2J5 dGVzOwogCkBAIC02OTM5LDcgKzY5NDgsNyBAQCBzdGF0aWMgdm9pZCBzdG1tYWNfZ2V0X3N0YXRz NjQoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgc3RydWN0IHJ0bmxfbGlua19zdGF0czY0CiAJfQog CiAJZm9yIChxID0gMDsgcSA8IHJ4X2NudDsgcSsrKSB7Ci0JCXN0cnVjdCBzdG1tYWNfcnhxX3N0 YXRzICpyeHFfc3RhdHMgPSAmcHJpdi0+ZG1hX2NvbmYucnhfcXVldWVbcV0ucnhxX3N0YXRzOwor CQlzdHJ1Y3Qgc3RtbWFjX3J4cV9zdGF0cyAqcnhxX3N0YXRzID0gJnByaXYtPnhzdGF0cy5yeHFf c3RhdHNbcV07CiAJCXU2NCByeF9wYWNrZXRzOwogCQl1NjQgcnhfYnl0ZXM7CiAKQEAgLTczNDAs OSArNzM0OSw5IEBAIGludCBzdG1tYWNfZHZyX3Byb2JlKHN0cnVjdCBkZXZpY2UgKmRldmljZSwK IAlwcml2LT5kZXYgPSBuZGV2OwogCiAJZm9yIChpID0gMDsgaSA8IE1UTF9NQVhfUlhfUVVFVUVT OyBpKyspCi0JCXU2NF9zdGF0c19pbml0KCZwcml2LT5kbWFfY29uZi5yeF9xdWV1ZVtpXS5yeHFf c3RhdHMuc3luY3ApOworCQl1NjRfc3RhdHNfaW5pdCgmcHJpdi0+eHN0YXRzLnJ4cV9zdGF0c1tp XS5zeW5jcCk7CiAJZm9yIChpID0gMDsgaSA8IE1UTF9NQVhfVFhfUVVFVUVTOyBpKyspCi0JCXU2 NF9zdGF0c19pbml0KCZwcml2LT5kbWFfY29uZi50eF9xdWV1ZVtpXS50eHFfc3RhdHMuc3luY3Ap OworCQl1NjRfc3RhdHNfaW5pdCgmcHJpdi0+eHN0YXRzLnR4cV9zdGF0c1tpXS5zeW5jcCk7CiAK IAlzdG1tYWNfc2V0X2V0aHRvb2xfb3BzKG5kZXYpOwogCXByaXYtPnBhdXNlID0gcGF1c2U7Ci0t IAoyLjQwLjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmlu ZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9s aW51eC1hcm0ta2VybmVsCg==