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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A9BBAC433FE for ; Tue, 18 Jan 2022 02:34:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240393AbiARCeY (ORCPT ); Mon, 17 Jan 2022 21:34:24 -0500 Received: from ams.source.kernel.org ([145.40.68.75]:43026 "EHLO ams.source.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1344954AbiARCbC (ORCPT ); Mon, 17 Jan 2022 21:31:02 -0500 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 646E2B811FF; Tue, 18 Jan 2022 02:31:00 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8A3B0C36AEB; Tue, 18 Jan 2022 02:30:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1642473059; bh=YnJNeTo90ifTAABEY7p92jRNpjFl46/RYCWhJFRbTJY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=je+Kk4jDANx5SuRvit/AfnpdC77cz2O92U53wqIGHuVXbcNq1A2/qv8g5gy/wJcyV qYzSBqAiZ/kbNNMKYzXYQQHqII7jNbJzmfoMISE2LXq2K8DvSjhuiNG2QmPjXdrlUy KxbtJr29TAfAjoFN9/rVc/IuFL1hCne3ArcJGiFVW9ipJWu8A7XNgwP+YDlI6K2oXD 9en/mkq96r3xFVxmtE5FY5w0AqTGP+hvwjFfpkVeE1fYx1FbLL/Eee5lhGImrDn+PJ i1hjFbyrtSYU1KGv55OyTD5IDEmYHS/tAYGi+inYmwmgJ9w3SbSujYU0QoSqSvLGWK uGcYz2Ol8x/Yg== From: Sasha Levin To: linux-kernel@vger.kernel.org, stable@vger.kernel.org Cc: Vincent Mailhol , Marc Kleine-Budde , Nicolas Ferre , Alexandre Belloni , Ludovic Desroches , Chandrasekar Ramakrishnan , Maxime Ripard , Chen-Yu Tsai , Jernej Skrabec , Appana Durga Kedareswara rao , Naga Sureshkumar Relli , Michal Simek , Stephane Grosjean , Jimmy Assarsson , =?UTF-8?q?Stefan=20M=C3=A4tje?= , Sasha Levin , wg@grandegger.com, davem@davemloft.net, kuba@kernel.org, dariobin@libero.it, linux@rempel-privat.de, dev.kurt@vandijck-laurijssen.be, yoshihiro.shimoda.uh@renesas.com, uli+renesas@fpond.eu, prabhakar.mahadev-lad.rj@bp.renesas.com, biju.das.jz@bp.renesas.com, paskripkin@gmail.com, thunder.leizhen@huawei.com, f.fainelli@gmail.com, leon@kernel.org, arnd@arndb.de, linux-can@vger.kernel.org, netdev@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-sunxi@lists.linux.dev Subject: [PATCH AUTOSEL 5.16 198/217] can: do not increase rx statistics when generating a CAN rx error message frame Date: Mon, 17 Jan 2022 21:19:21 -0500 Message-Id: <20220118021940.1942199-198-sashal@kernel.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20220118021940.1942199-1-sashal@kernel.org> References: <20220118021940.1942199-1-sashal@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 X-stable: review X-Patchwork-Hint: Ignore Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-can@vger.kernel.org From: Vincent Mailhol [ Upstream commit 676068db69b847f06fe054fca15bf6b107bd24da ] The CAN error message frames (i.e. error skb) are an interface specific to socket CAN. The payload of the CAN error message frames does not correspond to any actual data sent on the wire. Only an error flag and a delimiter are transmitted when an error occurs (c.f. ISO 11898-1 section 10.4.4.2 "Error flag"). For this reason, it makes no sense to increment the rx_packets and rx_bytes fields of struct net_device_stats because no actual payload were transmitted on the wire. This patch fixes all the CAN drivers. Link: https://lore.kernel.org/all/20211207121531.42941-2-mailhol.vincent@wanadoo.fr CC: Marc Kleine-Budde CC: Nicolas Ferre CC: Alexandre Belloni CC: Ludovic Desroches CC: Chandrasekar Ramakrishnan CC: Maxime Ripard CC: Chen-Yu Tsai CC: Jernej Skrabec CC: Appana Durga Kedareswara rao CC: Naga Sureshkumar Relli CC: Michal Simek CC: Stephane Grosjean Tested-by: Jimmy Assarsson # kvaser Signed-off-by: Vincent Mailhol Acked-by: Stefan Mätje # esd_usb2 Tested-by: Stefan Mätje # esd_usb2 Signed-off-by: Marc Kleine-Budde Signed-off-by: Sasha Levin --- drivers/net/can/at91_can.c | 6 ------ drivers/net/can/c_can/c_can_main.c | 5 ----- drivers/net/can/cc770/cc770.c | 3 --- drivers/net/can/dev/dev.c | 4 ---- drivers/net/can/dev/rx-offload.c | 6 ++++-- drivers/net/can/ifi_canfd/ifi_canfd.c | 5 ----- drivers/net/can/kvaser_pciefd.c | 5 ----- drivers/net/can/m_can/m_can.c | 7 ------- drivers/net/can/mscan/mscan.c | 9 +++++---- drivers/net/can/pch_can.c | 3 --- drivers/net/can/peak_canfd/peak_canfd.c | 4 ---- drivers/net/can/rcar/rcar_can.c | 6 +----- drivers/net/can/rcar/rcar_canfd.c | 4 ---- drivers/net/can/sja1000/sja1000.c | 2 -- drivers/net/can/sun4i_can.c | 7 ++----- drivers/net/can/usb/ems_usb.c | 2 -- drivers/net/can/usb/esd_usb2.c | 2 -- drivers/net/can/usb/etas_es58x/es58x_core.c | 7 ------- drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c | 2 -- drivers/net/can/usb/kvaser_usb/kvaser_usb_hydra.c | 8 -------- drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c | 4 ---- drivers/net/can/usb/peak_usb/pcan_usb.c | 2 -- drivers/net/can/usb/peak_usb/pcan_usb_fd.c | 3 --- drivers/net/can/usb/peak_usb/pcan_usb_pro.c | 2 -- drivers/net/can/usb/ucan.c | 6 ++++-- drivers/net/can/usb/usb_8dev.c | 2 -- drivers/net/can/xilinx_can.c | 9 +-------- 27 files changed, 17 insertions(+), 108 deletions(-) diff --git a/drivers/net/can/at91_can.c b/drivers/net/can/at91_can.c index 3aea32c9b108f..3cd872cf9be66 100644 --- a/drivers/net/can/at91_can.c +++ b/drivers/net/can/at91_can.c @@ -553,8 +553,6 @@ static void at91_rx_overflow_err(struct net_device *dev) cf->can_id |= CAN_ERR_CRTL; cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_receive_skb(skb); } @@ -779,8 +777,6 @@ static int at91_poll_err(struct net_device *dev, int quota, u32 reg_sr) at91_poll_err_frame(dev, cf, reg_sr); - dev->stats.rx_packets++; - dev->stats.rx_bytes += cf->len; netif_receive_skb(skb); return 1; @@ -1037,8 +1033,6 @@ static void at91_irq_err(struct net_device *dev) at91_irq_err_state(dev, cf, new_state); - dev->stats.rx_packets++; - dev->stats.rx_bytes += cf->len; netif_rx(skb); priv->can.state = new_state; diff --git a/drivers/net/can/c_can/c_can_main.c b/drivers/net/can/c_can/c_can_main.c index 52671d1ea17d5..670754a129846 100644 --- a/drivers/net/can/c_can/c_can_main.c +++ b/drivers/net/can/c_can/c_can_main.c @@ -920,7 +920,6 @@ static int c_can_handle_state_change(struct net_device *dev, unsigned int reg_err_counter; unsigned int rx_err_passive; struct c_can_priv *priv = netdev_priv(dev); - struct net_device_stats *stats = &dev->stats; struct can_frame *cf; struct sk_buff *skb; struct can_berr_counter bec; @@ -996,8 +995,6 @@ static int c_can_handle_state_change(struct net_device *dev, break; } - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_receive_skb(skb); return 1; @@ -1064,8 +1061,6 @@ static int c_can_handle_bus_err(struct net_device *dev, break; } - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_receive_skb(skb); return 1; } diff --git a/drivers/net/can/cc770/cc770.c b/drivers/net/can/cc770/cc770.c index f8a130f594e2e..a5fd8ccedec21 100644 --- a/drivers/net/can/cc770/cc770.c +++ b/drivers/net/can/cc770/cc770.c @@ -499,7 +499,6 @@ static void cc770_rx(struct net_device *dev, unsigned int mo, u8 ctrl1) static int cc770_err(struct net_device *dev, u8 status) { struct cc770_priv *priv = netdev_priv(dev); - struct net_device_stats *stats = &dev->stats; struct can_frame *cf; struct sk_buff *skb; u8 lec; @@ -571,8 +570,6 @@ static int cc770_err(struct net_device *dev, u8 status) } - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); return 0; diff --git a/drivers/net/can/dev/dev.c b/drivers/net/can/dev/dev.c index e3d840b81357d..4845ae6456e19 100644 --- a/drivers/net/can/dev/dev.c +++ b/drivers/net/can/dev/dev.c @@ -136,7 +136,6 @@ EXPORT_SYMBOL_GPL(can_change_state); static void can_restart(struct net_device *dev) { struct can_priv *priv = netdev_priv(dev); - struct net_device_stats *stats = &dev->stats; struct sk_buff *skb; struct can_frame *cf; int err; @@ -155,9 +154,6 @@ static void can_restart(struct net_device *dev) cf->can_id |= CAN_ERR_RESTARTED; - stats->rx_packets++; - stats->rx_bytes += cf->len; - netif_rx_ni(skb); restart: diff --git a/drivers/net/can/dev/rx-offload.c b/drivers/net/can/dev/rx-offload.c index 37b0cc65237b7..7dbf46b9ca5dd 100644 --- a/drivers/net/can/dev/rx-offload.c +++ b/drivers/net/can/dev/rx-offload.c @@ -54,8 +54,10 @@ static int can_rx_offload_napi_poll(struct napi_struct *napi, int quota) struct can_frame *cf = (struct can_frame *)skb->data; work_done++; - stats->rx_packets++; - stats->rx_bytes += cf->len; + if (!(cf->can_id & CAN_ERR_FLAG)) { + stats->rx_packets++; + stats->rx_bytes += cf->len; + } netif_receive_skb(skb); } diff --git a/drivers/net/can/ifi_canfd/ifi_canfd.c b/drivers/net/can/ifi_canfd/ifi_canfd.c index 5bb957a26bc69..e8318e984bf2f 100644 --- a/drivers/net/can/ifi_canfd/ifi_canfd.c +++ b/drivers/net/can/ifi_canfd/ifi_canfd.c @@ -430,8 +430,6 @@ static int ifi_canfd_handle_lec_err(struct net_device *ndev) priv->base + IFI_CANFD_INTERRUPT); writel(IFI_CANFD_ERROR_CTR_ER_ENABLE, priv->base + IFI_CANFD_ERROR_CTR); - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_receive_skb(skb); return 1; @@ -456,7 +454,6 @@ static int ifi_canfd_handle_state_change(struct net_device *ndev, enum can_state new_state) { struct ifi_canfd_priv *priv = netdev_priv(ndev); - struct net_device_stats *stats = &ndev->stats; struct can_frame *cf; struct sk_buff *skb; struct can_berr_counter bec; @@ -522,8 +519,6 @@ static int ifi_canfd_handle_state_change(struct net_device *ndev, break; } - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_receive_skb(skb); return 1; diff --git a/drivers/net/can/kvaser_pciefd.c b/drivers/net/can/kvaser_pciefd.c index eb74cdf26b88c..ab672c92ab078 100644 --- a/drivers/net/can/kvaser_pciefd.c +++ b/drivers/net/can/kvaser_pciefd.c @@ -1310,9 +1310,6 @@ static int kvaser_pciefd_rx_error_frame(struct kvaser_pciefd_can *can, cf->data[6] = bec.txerr; cf->data[7] = bec.rxerr; - stats->rx_packets++; - stats->rx_bytes += cf->len; - netif_rx(skb); return 0; } @@ -1510,8 +1507,6 @@ static void kvaser_pciefd_handle_nack_packet(struct kvaser_pciefd_can *can, if (skb) { cf->can_id |= CAN_ERR_BUSERROR; - stats->rx_bytes += cf->len; - stats->rx_packets++; netif_rx(skb); } else { stats->rx_dropped++; diff --git a/drivers/net/can/m_can/m_can.c b/drivers/net/can/m_can/m_can.c index c2a8421e7845c..30d94cb43113d 100644 --- a/drivers/net/can/m_can/m_can.c +++ b/drivers/net/can/m_can/m_can.c @@ -647,9 +647,6 @@ static int m_can_handle_lec_err(struct net_device *dev, break; } - stats->rx_packets++; - stats->rx_bytes += cf->len; - if (cdev->is_peripheral) timestamp = m_can_get_timestamp(cdev); @@ -706,7 +703,6 @@ static int m_can_handle_state_change(struct net_device *dev, enum can_state new_state) { struct m_can_classdev *cdev = netdev_priv(dev); - struct net_device_stats *stats = &dev->stats; struct can_frame *cf; struct sk_buff *skb; struct can_berr_counter bec; @@ -771,9 +767,6 @@ static int m_can_handle_state_change(struct net_device *dev, break; } - stats->rx_packets++; - stats->rx_bytes += cf->len; - if (cdev->is_peripheral) timestamp = m_can_get_timestamp(cdev); diff --git a/drivers/net/can/mscan/mscan.c b/drivers/net/can/mscan/mscan.c index fa32e418eb296..9e1cce0260da6 100644 --- a/drivers/net/can/mscan/mscan.c +++ b/drivers/net/can/mscan/mscan.c @@ -401,13 +401,14 @@ static int mscan_rx_poll(struct napi_struct *napi, int quota) continue; } - if (canrflg & MSCAN_RXF) + if (canrflg & MSCAN_RXF) { mscan_get_rx_frame(dev, frame); - else if (canrflg & MSCAN_ERR_IF) + stats->rx_packets++; + stats->rx_bytes += frame->len; + } else if (canrflg & MSCAN_ERR_IF) { mscan_get_err_frame(dev, frame, canrflg); + } - stats->rx_packets++; - stats->rx_bytes += frame->len; work_done++; netif_receive_skb(skb); } diff --git a/drivers/net/can/pch_can.c b/drivers/net/can/pch_can.c index 964c8a09226a9..6b45840db1f9b 100644 --- a/drivers/net/can/pch_can.c +++ b/drivers/net/can/pch_can.c @@ -561,9 +561,6 @@ static void pch_can_error(struct net_device *ndev, u32 status) priv->can.state = state; netif_receive_skb(skb); - - stats->rx_packets++; - stats->rx_bytes += cf->len; } static irqreturn_t pch_can_interrupt(int irq, void *dev_id) diff --git a/drivers/net/can/peak_canfd/peak_canfd.c b/drivers/net/can/peak_canfd/peak_canfd.c index d08718e98e110..d5b8bc6d29804 100644 --- a/drivers/net/can/peak_canfd/peak_canfd.c +++ b/drivers/net/can/peak_canfd/peak_canfd.c @@ -409,8 +409,6 @@ static int pucan_handle_status(struct peak_canfd_priv *priv, return -ENOMEM; } - stats->rx_packets++; - stats->rx_bytes += cf->len; pucan_netif_rx(skb, msg->ts_low, msg->ts_high); return 0; @@ -438,8 +436,6 @@ static int pucan_handle_cache_critical(struct peak_canfd_priv *priv) cf->data[6] = priv->bec.txerr; cf->data[7] = priv->bec.rxerr; - stats->rx_bytes += cf->len; - stats->rx_packets++; netif_rx(skb); return 0; diff --git a/drivers/net/can/rcar/rcar_can.c b/drivers/net/can/rcar/rcar_can.c index 8999ec9455ec2..f408ed9a6ccd1 100644 --- a/drivers/net/can/rcar/rcar_can.c +++ b/drivers/net/can/rcar/rcar_can.c @@ -223,7 +223,6 @@ static void tx_failure_cleanup(struct net_device *ndev) static void rcar_can_error(struct net_device *ndev) { struct rcar_can_priv *priv = netdev_priv(ndev); - struct net_device_stats *stats = &ndev->stats; struct can_frame *cf; struct sk_buff *skb; u8 eifr, txerr = 0, rxerr = 0; @@ -362,11 +361,8 @@ static void rcar_can_error(struct net_device *ndev) } } - if (skb) { - stats->rx_packets++; - stats->rx_bytes += cf->len; + if (skb) netif_rx(skb); - } } static void rcar_can_tx_done(struct net_device *ndev) diff --git a/drivers/net/can/rcar/rcar_canfd.c b/drivers/net/can/rcar/rcar_canfd.c index ff9d0f5ae0dd2..db9d62874e151 100644 --- a/drivers/net/can/rcar/rcar_canfd.c +++ b/drivers/net/can/rcar/rcar_canfd.c @@ -1033,8 +1033,6 @@ static void rcar_canfd_error(struct net_device *ndev, u32 cerfl, /* Clear channel error interrupts that are handled */ rcar_canfd_write(priv->base, RCANFD_CERFL(ch), RCANFD_CERFL_ERR(~cerfl)); - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); } @@ -1174,8 +1172,6 @@ static void rcar_canfd_state_change(struct net_device *ndev, rx_state = txerr <= rxerr ? state : 0; can_change_state(ndev, cf, tx_state, rx_state); - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); } } diff --git a/drivers/net/can/sja1000/sja1000.c b/drivers/net/can/sja1000/sja1000.c index 3fad546467461..a65546ca94610 100644 --- a/drivers/net/can/sja1000/sja1000.c +++ b/drivers/net/can/sja1000/sja1000.c @@ -487,8 +487,6 @@ static int sja1000_err(struct net_device *dev, uint8_t isrc, uint8_t status) can_bus_off(dev); } - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); return 0; diff --git a/drivers/net/can/sun4i_can.c b/drivers/net/can/sun4i_can.c index 54aa7c25c4de1..599174098883d 100644 --- a/drivers/net/can/sun4i_can.c +++ b/drivers/net/can/sun4i_can.c @@ -622,13 +622,10 @@ static int sun4i_can_err(struct net_device *dev, u8 isrc, u8 status) can_bus_off(dev); } - if (likely(skb)) { - stats->rx_packets++; - stats->rx_bytes += cf->len; + if (likely(skb)) netif_rx(skb); - } else { + else return -ENOMEM; - } return 0; } diff --git a/drivers/net/can/usb/ems_usb.c b/drivers/net/can/usb/ems_usb.c index 2b5302e724353..7cf65936d02e5 100644 --- a/drivers/net/can/usb/ems_usb.c +++ b/drivers/net/can/usb/ems_usb.c @@ -397,8 +397,6 @@ static void ems_usb_rx_err(struct ems_usb *dev, struct ems_cpc_msg *msg) stats->rx_errors++; } - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); } diff --git a/drivers/net/can/usb/esd_usb2.c b/drivers/net/can/usb/esd_usb2.c index c6068a251fbed..5f6915a27b3d9 100644 --- a/drivers/net/can/usb/esd_usb2.c +++ b/drivers/net/can/usb/esd_usb2.c @@ -293,8 +293,6 @@ static void esd_usb2_rx_event(struct esd_usb2_net_priv *priv, priv->bec.txerr = txerr; priv->bec.rxerr = rxerr; - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); } } diff --git a/drivers/net/can/usb/etas_es58x/es58x_core.c b/drivers/net/can/usb/etas_es58x/es58x_core.c index 24627ab146261..fb07c33ba0c3c 100644 --- a/drivers/net/can/usb/etas_es58x/es58x_core.c +++ b/drivers/net/can/usb/etas_es58x/es58x_core.c @@ -849,13 +849,6 @@ int es58x_rx_err_msg(struct net_device *netdev, enum es58x_err error, break; } - /* driver/net/can/dev.c:can_restart() takes in account error - * messages in the RX stats. Doing the same here for - * consistency. - */ - netdev->stats.rx_packets++; - netdev->stats.rx_bytes += CAN_ERR_DLC; - if (cf) { if (cf->data[1]) cf->can_id |= CAN_ERR_CRTL; diff --git a/drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c b/drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c index 0cc0fc866a2a9..3e682ef43f8ef 100644 --- a/drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c +++ b/drivers/net/can/usb/kvaser_usb/kvaser_usb_core.c @@ -279,8 +279,6 @@ int kvaser_usb_can_rx_over_error(struct net_device *netdev) cf->can_id |= CAN_ERR_CRTL; cf->data[1] = CAN_ERR_CRTL_RX_OVERFLOW; - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); return 0; diff --git a/drivers/net/can/usb/kvaser_usb/kvaser_usb_hydra.c b/drivers/net/can/usb/kvaser_usb/kvaser_usb_hydra.c index dcee8dc828ecc..3398da323126c 100644 --- a/drivers/net/can/usb/kvaser_usb/kvaser_usb_hydra.c +++ b/drivers/net/can/usb/kvaser_usb/kvaser_usb_hydra.c @@ -869,7 +869,6 @@ static void kvaser_usb_hydra_update_state(struct kvaser_usb_net_priv *priv, struct net_device *netdev = priv->netdev; struct can_frame *cf; struct sk_buff *skb; - struct net_device_stats *stats; enum can_state new_state, old_state; old_state = priv->can.state; @@ -919,9 +918,6 @@ static void kvaser_usb_hydra_update_state(struct kvaser_usb_net_priv *priv, cf->data[6] = bec->txerr; cf->data[7] = bec->rxerr; - stats = &netdev->stats; - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); } @@ -1074,8 +1070,6 @@ kvaser_usb_hydra_error_frame(struct kvaser_usb_net_priv *priv, cf->data[6] = bec.txerr; cf->data[7] = bec.rxerr; - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); priv->bec.txerr = bec.txerr; @@ -1109,8 +1103,6 @@ static void kvaser_usb_hydra_one_shot_fail(struct kvaser_usb_net_priv *priv, } stats->tx_errors++; - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); } diff --git a/drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c b/drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c index f7af1bf5ab46d..5434b7386a51e 100644 --- a/drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c +++ b/drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c @@ -641,8 +641,6 @@ static void kvaser_usb_leaf_tx_acknowledge(const struct kvaser_usb *dev, if (skb) { cf->can_id |= CAN_ERR_RESTARTED; - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); } else { netdev_err(priv->netdev, @@ -843,8 +841,6 @@ static void kvaser_usb_leaf_rx_error(const struct kvaser_usb *dev, cf->data[6] = es->txerr; cf->data[7] = es->rxerr; - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); } diff --git a/drivers/net/can/usb/peak_usb/pcan_usb.c b/drivers/net/can/usb/peak_usb/pcan_usb.c index 8762187527669..21b06a7385959 100644 --- a/drivers/net/can/usb/peak_usb/pcan_usb.c +++ b/drivers/net/can/usb/peak_usb/pcan_usb.c @@ -520,8 +520,6 @@ static int pcan_usb_decode_error(struct pcan_usb_msg_context *mc, u8 n, &hwts->hwtstamp); } - mc->netdev->stats.rx_packets++; - mc->netdev->stats.rx_bytes += cf->len; netif_rx(skb); return 0; diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_fd.c b/drivers/net/can/usb/peak_usb/pcan_usb_fd.c index 6bd12549f1014..185f5a98d2177 100644 --- a/drivers/net/can/usb/peak_usb/pcan_usb_fd.c +++ b/drivers/net/can/usb/peak_usb/pcan_usb_fd.c @@ -577,9 +577,6 @@ static int pcan_usb_fd_decode_status(struct pcan_usb_fd_if *usb_if, if (!skb) return -ENOMEM; - netdev->stats.rx_packets++; - netdev->stats.rx_bytes += cf->len; - peak_usb_netif_rx_64(skb, le32_to_cpu(sm->ts_low), le32_to_cpu(sm->ts_high)); diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_pro.c b/drivers/net/can/usb/peak_usb/pcan_usb_pro.c index 858ab22708fcd..f6d19879bf404 100644 --- a/drivers/net/can/usb/peak_usb/pcan_usb_pro.c +++ b/drivers/net/can/usb/peak_usb/pcan_usb_pro.c @@ -660,8 +660,6 @@ static int pcan_usb_pro_handle_error(struct pcan_usb_pro_interface *usb_if, hwts = skb_hwtstamps(skb); peak_usb_get_ts_time(&usb_if->time_ref, le32_to_cpu(er->ts32), &hwts->hwtstamp); - netdev->stats.rx_packets++; - netdev->stats.rx_bytes += can_frame->len; netif_rx(skb); return 0; diff --git a/drivers/net/can/usb/ucan.c b/drivers/net/can/usb/ucan.c index 1679cbe45ded2..d582c39fc8d0e 100644 --- a/drivers/net/can/usb/ucan.c +++ b/drivers/net/can/usb/ucan.c @@ -621,8 +621,10 @@ static void ucan_rx_can_msg(struct ucan_priv *up, struct ucan_message_in *m) memcpy(cf->data, m->msg.can_msg.data, cf->len); /* don't count error frames as real packets */ - stats->rx_packets++; - stats->rx_bytes += cf->len; + if (!(cf->can_id & CAN_ERR_FLAG)) { + stats->rx_packets++; + stats->rx_bytes += cf->len; + } /* pass it to Linux */ netif_rx(skb); diff --git a/drivers/net/can/usb/usb_8dev.c b/drivers/net/can/usb/usb_8dev.c index d1b83bd1b3cb9..040324362b260 100644 --- a/drivers/net/can/usb/usb_8dev.c +++ b/drivers/net/can/usb/usb_8dev.c @@ -449,8 +449,6 @@ static void usb_8dev_rx_err_msg(struct usb_8dev_priv *priv, priv->bec.txerr = txerr; priv->bec.rxerr = rxerr; - stats->rx_packets++; - stats->rx_bytes += cf->len; netif_rx(skb); } diff --git a/drivers/net/can/xilinx_can.c b/drivers/net/can/xilinx_can.c index e2b15d29d15eb..275e240ab293f 100644 --- a/drivers/net/can/xilinx_can.c +++ b/drivers/net/can/xilinx_can.c @@ -965,13 +965,8 @@ static void xcan_update_error_state_after_rxtx(struct net_device *ndev) xcan_set_error_state(ndev, new_state, skb ? cf : NULL); - if (skb) { - struct net_device_stats *stats = &ndev->stats; - - stats->rx_packets++; - stats->rx_bytes += cf->len; + if (skb) netif_rx(skb); - } } } @@ -1095,8 +1090,6 @@ static void xcan_err_interrupt(struct net_device *ndev, u32 isr) if (skb) { skb_cf->can_id |= cf.can_id; memcpy(skb_cf->data, cf.data, CAN_ERR_DLC); - stats->rx_packets++; - stats->rx_bytes += CAN_ERR_DLC; netif_rx(skb); } } -- 2.34.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 C969CC433F5 for ; Tue, 18 Jan 2022 02:46:08 +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:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=vlpBD4QYBVBwBi1iQy1ZHQTWVaZB9LJv+am4JYzb7OM=; b=HPSgdgZwK6sUqi CVinaYNHARDvHuZd8+MSXxrL+rDxwMFnrPLD7tYvkPiCe/5hjr1ChxvmyhGk+qJphb3VgmpBVU+mB 4h6ynz+QzMlcDOSIH4HR32ye8LQM7NuWLa8SJVQ/vlWcTyyVjPPoEKhmtK+/yNFUjvqQlOUlHQMw+ YaayXTzmJtnGd9TaQ90GpdbaroDi28C4jEzQ9vOdRjy9M92AkSLn5mEJkqYwo+bPsK312bBeO4Tbf kTypZ23+xZiQg1JAVMrthhqXYYdfIXrX3Dmng/F6ALa45wxYqZI59ep3P3HEXfq5cfDK0jEEDc6z2 8SVNL4L0wh4fddMNZqRw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1n9eTj-00H5EQ-Ay; Tue, 18 Jan 2022 02:44:12 +0000 Received: from dfw.source.kernel.org ([2604:1380:4641:c500::1]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1n9eGy-00Gy3r-Ls for linux-arm-kernel@lists.infradead.org; Tue, 18 Jan 2022 02:31:03 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id C970660AB6; Tue, 18 Jan 2022 02:30:59 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8A3B0C36AEB; Tue, 18 Jan 2022 02:30:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1642473059; bh=YnJNeTo90ifTAABEY7p92jRNpjFl46/RYCWhJFRbTJY=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=je+Kk4jDANx5SuRvit/AfnpdC77cz2O92U53wqIGHuVXbcNq1A2/qv8g5gy/wJcyV qYzSBqAiZ/kbNNMKYzXYQQHqII7jNbJzmfoMISE2LXq2K8DvSjhuiNG2QmPjXdrlUy KxbtJr29TAfAjoFN9/rVc/IuFL1hCne3ArcJGiFVW9ipJWu8A7XNgwP+YDlI6K2oXD 9en/mkq96r3xFVxmtE5FY5w0AqTGP+hvwjFfpkVeE1fYx1FbLL/Eee5lhGImrDn+PJ i1hjFbyrtSYU1KGv55OyTD5IDEmYHS/tAYGi+inYmwmgJ9w3SbSujYU0QoSqSvLGWK uGcYz2Ol8x/Yg== From: Sasha Levin To: linux-kernel@vger.kernel.org, stable@vger.kernel.org Subject: [PATCH AUTOSEL 5.16 198/217] can: do not increase rx statistics when generating a CAN rx error message frame Date: Mon, 17 Jan 2022 21:19:21 -0500 Message-Id: <20220118021940.1942199-198-sashal@kernel.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20220118021940.1942199-1-sashal@kernel.org> References: <20220118021940.1942199-1-sashal@kernel.org> MIME-Version: 1.0 X-stable: review X-Patchwork-Hint: Ignore X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220117_183100_939360_E3984AAE X-CRM114-Status: GOOD ( 21.17 ) 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: , Cc: Alexandre Belloni , Jimmy Assarsson , Sasha Levin , f.fainelli@gmail.com, dev.kurt@vandijck-laurijssen.be, leon@kernel.org, paskripkin@gmail.com, Michal Simek , Jernej Skrabec , Ludovic Desroches , linux-arm-kernel@lists.infradead.org, kuba@kernel.org, linux-sunxi@lists.linux.dev, dariobin@libero.it, Naga Sureshkumar Relli , arnd@arndb.de, prabhakar.mahadev-lad.rj@bp.renesas.com, Stephane Grosjean , linux-can@vger.kernel.org, Marc Kleine-Budde , Maxime Ripard , Appana Durga Kedareswara rao , thunder.leizhen@huawei.com, biju.das.jz@bp.renesas.com, Chen-Yu Tsai , =?UTF-8?q?Stefan=20M=C3=A4tje?= , Vincent Mailhol , Chandrasekar Ramakrishnan , netdev@vger.kernel.org, yoshihiro.shimoda.uh@renesas.com, linux@rempel-privat.de, wg@grandegger.com, uli+renesas@fpond.eu, davem@davemloft.net 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 RnJvbTogVmluY2VudCBNYWlsaG9sIDxtYWlsaG9sLnZpbmNlbnRAd2FuYWRvby5mcj4KClsgVXBz dHJlYW0gY29tbWl0IDY3NjA2OGRiNjliODQ3ZjA2ZmUwNTRmY2ExNWJmNmIxMDdiZDI0ZGEgXQoK VGhlIENBTiBlcnJvciBtZXNzYWdlIGZyYW1lcyAoaS5lLiBlcnJvciBza2IpIGFyZSBhbiBpbnRl cmZhY2UKc3BlY2lmaWMgdG8gc29ja2V0IENBTi4gVGhlIHBheWxvYWQgb2YgdGhlIENBTiBlcnJv ciBtZXNzYWdlIGZyYW1lcwpkb2VzIG5vdCBjb3JyZXNwb25kIHRvIGFueSBhY3R1YWwgZGF0YSBz ZW50IG9uIHRoZSB3aXJlLiBPbmx5IGFuIGVycm9yCmZsYWcgYW5kIGEgZGVsaW1pdGVyIGFyZSB0 cmFuc21pdHRlZCB3aGVuIGFuIGVycm9yIG9jY3VycyAoYy5mLiBJU08KMTE4OTgtMSBzZWN0aW9u IDEwLjQuNC4yICJFcnJvciBmbGFnIikuCgpGb3IgdGhpcyByZWFzb24sIGl0IG1ha2VzIG5vIHNl bnNlIHRvIGluY3JlbWVudCB0aGUgcnhfcGFja2V0cyBhbmQKcnhfYnl0ZXMgZmllbGRzIG9mIHN0 cnVjdCBuZXRfZGV2aWNlX3N0YXRzIGJlY2F1c2Ugbm8gYWN0dWFsIHBheWxvYWQKd2VyZSB0cmFu c21pdHRlZCBvbiB0aGUgd2lyZS4KClRoaXMgcGF0Y2ggZml4ZXMgYWxsIHRoZSBDQU4gZHJpdmVy cy4KCkxpbms6IGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2FsbC8yMDIxMTIwNzEyMTUzMS40Mjk0 MS0yLW1haWxob2wudmluY2VudEB3YW5hZG9vLmZyCkNDOiBNYXJjIEtsZWluZS1CdWRkZSA8bWts QHBlbmd1dHJvbml4LmRlPgpDQzogTmljb2xhcyBGZXJyZSA8bmljb2xhcy5mZXJyZUBtaWNyb2No aXAuY29tPgpDQzogQWxleGFuZHJlIEJlbGxvbmkgPGFsZXhhbmRyZS5iZWxsb25pQGJvb3RsaW4u Y29tPgpDQzogTHVkb3ZpYyBEZXNyb2NoZXMgPGx1ZG92aWMuZGVzcm9jaGVzQG1pY3JvY2hpcC5j b20+CkNDOiBDaGFuZHJhc2VrYXIgUmFtYWtyaXNobmFuIDxyY3Nla2FyQHNhbXN1bmcuY29tPgpD QzogTWF4aW1lIFJpcGFyZCA8bXJpcGFyZEBrZXJuZWwub3JnPgpDQzogQ2hlbi1ZdSBUc2FpIDx3 ZW5zQGNzaWUub3JnPgpDQzogSmVybmVqIFNrcmFiZWMgPGplcm5lai5za3JhYmVjQGdtYWlsLmNv bT4KQ0M6IEFwcGFuYSBEdXJnYSBLZWRhcmVzd2FyYSByYW8gPGFwcGFuYS5kdXJnYS5yYW9AeGls aW54LmNvbT4KQ0M6IE5hZ2EgU3VyZXNoa3VtYXIgUmVsbGkgPG5hZ2Euc3VyZXNoa3VtYXIucmVs bGlAeGlsaW54LmNvbT4KQ0M6IE1pY2hhbCBTaW1layA8bWljaGFsLnNpbWVrQHhpbGlueC5jb20+ CkNDOiBTdGVwaGFuZSBHcm9zamVhbiA8cy5ncm9zamVhbkBwZWFrLXN5c3RlbS5jb20+ClRlc3Rl ZC1ieTogSmltbXkgQXNzYXJzc29uIDxleHRqYUBrdmFzZXIuY29tPiAjIGt2YXNlcgpTaWduZWQt b2ZmLWJ5OiBWaW5jZW50IE1haWxob2wgPG1haWxob2wudmluY2VudEB3YW5hZG9vLmZyPgpBY2tl ZC1ieTogU3RlZmFuIE3DpHRqZSA8c3RlZmFuLm1hZXRqZUBlc2QuZXU+ICMgZXNkX3VzYjIKVGVz dGVkLWJ5OiBTdGVmYW4gTcOkdGplIDxzdGVmYW4ubWFldGplQGVzZC5ldT4gIyBlc2RfdXNiMgpT aWduZWQtb2ZmLWJ5OiBNYXJjIEtsZWluZS1CdWRkZSA8bWtsQHBlbmd1dHJvbml4LmRlPgpTaWdu ZWQtb2ZmLWJ5OiBTYXNoYSBMZXZpbiA8c2FzaGFsQGtlcm5lbC5vcmc+Ci0tLQogZHJpdmVycy9u ZXQvY2FuL2F0OTFfY2FuLmMgICAgICAgICAgICAgICAgICAgICAgICB8IDYgLS0tLS0tCiBkcml2 ZXJzL25ldC9jYW4vY19jYW4vY19jYW5fbWFpbi5jICAgICAgICAgICAgICAgIHwgNSAtLS0tLQog ZHJpdmVycy9uZXQvY2FuL2NjNzcwL2NjNzcwLmMgICAgICAgICAgICAgICAgICAgICB8IDMgLS0t CiBkcml2ZXJzL25ldC9jYW4vZGV2L2Rldi5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgNCAt LS0tCiBkcml2ZXJzL25ldC9jYW4vZGV2L3J4LW9mZmxvYWQuYyAgICAgICAgICAgICAgICAgIHwg NiArKysrLS0KIGRyaXZlcnMvbmV0L2Nhbi9pZmlfY2FuZmQvaWZpX2NhbmZkLmMgICAgICAgICAg ICAgfCA1IC0tLS0tCiBkcml2ZXJzL25ldC9jYW4va3Zhc2VyX3BjaWVmZC5jICAgICAgICAgICAg ICAgICAgIHwgNSAtLS0tLQogZHJpdmVycy9uZXQvY2FuL21fY2FuL21fY2FuLmMgICAgICAgICAg ICAgICAgICAgICB8IDcgLS0tLS0tLQogZHJpdmVycy9uZXQvY2FuL21zY2FuL21zY2FuLmMgICAg ICAgICAgICAgICAgICAgICB8IDkgKysrKystLS0tCiBkcml2ZXJzL25ldC9jYW4vcGNoX2Nhbi5j ICAgICAgICAgICAgICAgICAgICAgICAgIHwgMyAtLS0KIGRyaXZlcnMvbmV0L2Nhbi9wZWFrX2Nh bmZkL3BlYWtfY2FuZmQuYyAgICAgICAgICAgfCA0IC0tLS0KIGRyaXZlcnMvbmV0L2Nhbi9yY2Fy L3JjYXJfY2FuLmMgICAgICAgICAgICAgICAgICAgfCA2ICstLS0tLQogZHJpdmVycy9uZXQvY2Fu L3JjYXIvcmNhcl9jYW5mZC5jICAgICAgICAgICAgICAgICB8IDQgLS0tLQogZHJpdmVycy9uZXQv Y2FuL3NqYTEwMDAvc2phMTAwMC5jICAgICAgICAgICAgICAgICB8IDIgLS0KIGRyaXZlcnMvbmV0 L2Nhbi9zdW40aV9jYW4uYyAgICAgICAgICAgICAgICAgICAgICAgfCA3ICsrLS0tLS0KIGRyaXZl cnMvbmV0L2Nhbi91c2IvZW1zX3VzYi5jICAgICAgICAgICAgICAgICAgICAgfCAyIC0tCiBkcml2 ZXJzL25ldC9jYW4vdXNiL2VzZF91c2IyLmMgICAgICAgICAgICAgICAgICAgIHwgMiAtLQogZHJp dmVycy9uZXQvY2FuL3VzYi9ldGFzX2VzNTh4L2VzNTh4X2NvcmUuYyAgICAgICB8IDcgLS0tLS0t LQogZHJpdmVycy9uZXQvY2FuL3VzYi9rdmFzZXJfdXNiL2t2YXNlcl91c2JfY29yZS5jICB8IDIg LS0KIGRyaXZlcnMvbmV0L2Nhbi91c2Iva3Zhc2VyX3VzYi9rdmFzZXJfdXNiX2h5ZHJhLmMgfCA4 IC0tLS0tLS0tCiBkcml2ZXJzL25ldC9jYW4vdXNiL2t2YXNlcl91c2Iva3Zhc2VyX3VzYl9sZWFm LmMgIHwgNCAtLS0tCiBkcml2ZXJzL25ldC9jYW4vdXNiL3BlYWtfdXNiL3BjYW5fdXNiLmMgICAg ICAgICAgIHwgMiAtLQogZHJpdmVycy9uZXQvY2FuL3VzYi9wZWFrX3VzYi9wY2FuX3VzYl9mZC5j ICAgICAgICB8IDMgLS0tCiBkcml2ZXJzL25ldC9jYW4vdXNiL3BlYWtfdXNiL3BjYW5fdXNiX3By by5jICAgICAgIHwgMiAtLQogZHJpdmVycy9uZXQvY2FuL3VzYi91Y2FuLmMgICAgICAgICAgICAg ICAgICAgICAgICB8IDYgKysrKy0tCiBkcml2ZXJzL25ldC9jYW4vdXNiL3VzYl84ZGV2LmMgICAg ICAgICAgICAgICAgICAgIHwgMiAtLQogZHJpdmVycy9uZXQvY2FuL3hpbGlueF9jYW4uYyAgICAg ICAgICAgICAgICAgICAgICB8IDkgKy0tLS0tLS0tCiAyNyBmaWxlcyBjaGFuZ2VkLCAxNyBpbnNl cnRpb25zKCspLCAxMDggZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2Fu L2F0OTFfY2FuLmMgYi9kcml2ZXJzL25ldC9jYW4vYXQ5MV9jYW4uYwppbmRleCAzYWVhMzJjOWIx MDhmLi4zY2Q4NzJjZjliZTY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vYXQ5MV9jYW4u YworKysgYi9kcml2ZXJzL25ldC9jYW4vYXQ5MV9jYW4uYwpAQCAtNTUzLDggKzU1Myw2IEBAIHN0 YXRpYyB2b2lkIGF0OTFfcnhfb3ZlcmZsb3dfZXJyKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiAJ Y2YtPmNhbl9pZCB8PSBDQU5fRVJSX0NSVEw7CiAJY2YtPmRhdGFbMV0gPSBDQU5fRVJSX0NSVExf UlhfT1ZFUkZMT1c7CiAKLQlzdGF0cy0+cnhfcGFja2V0cysrOwotCXN0YXRzLT5yeF9ieXRlcyAr PSBjZi0+bGVuOwogCW5ldGlmX3JlY2VpdmVfc2tiKHNrYik7CiB9CiAKQEAgLTc3OSw4ICs3Nzcs NiBAQCBzdGF0aWMgaW50IGF0OTFfcG9sbF9lcnIoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50 IHF1b3RhLCB1MzIgcmVnX3NyKQogCiAJYXQ5MV9wb2xsX2Vycl9mcmFtZShkZXYsIGNmLCByZWdf c3IpOwogCi0JZGV2LT5zdGF0cy5yeF9wYWNrZXRzKys7Ci0JZGV2LT5zdGF0cy5yeF9ieXRlcyAr PSBjZi0+bGVuOwogCW5ldGlmX3JlY2VpdmVfc2tiKHNrYik7CiAKIAlyZXR1cm4gMTsKQEAgLTEw MzcsOCArMTAzMyw2IEBAIHN0YXRpYyB2b2lkIGF0OTFfaXJxX2VycihzdHJ1Y3QgbmV0X2Rldmlj ZSAqZGV2KQogCiAJYXQ5MV9pcnFfZXJyX3N0YXRlKGRldiwgY2YsIG5ld19zdGF0ZSk7CiAKLQlk ZXYtPnN0YXRzLnJ4X3BhY2tldHMrKzsKLQlkZXYtPnN0YXRzLnJ4X2J5dGVzICs9IGNmLT5sZW47 CiAJbmV0aWZfcngoc2tiKTsKIAogCXByaXYtPmNhbi5zdGF0ZSA9IG5ld19zdGF0ZTsKZGlmZiAt LWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9jX2Nhbi9jX2Nhbl9tYWluLmMgYi9kcml2ZXJzL25ldC9j YW4vY19jYW4vY19jYW5fbWFpbi5jCmluZGV4IDUyNjcxZDFlYTE3ZDUuLjY3MDc1NGExMjk4NDYg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi9jX2Nhbi9jX2Nhbl9tYWluLmMKKysrIGIvZHJp dmVycy9uZXQvY2FuL2NfY2FuL2NfY2FuX21haW4uYwpAQCAtOTIwLDcgKzkyMCw2IEBAIHN0YXRp YyBpbnQgY19jYW5faGFuZGxlX3N0YXRlX2NoYW5nZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAog CXVuc2lnbmVkIGludCByZWdfZXJyX2NvdW50ZXI7CiAJdW5zaWduZWQgaW50IHJ4X2Vycl9wYXNz aXZlOwogCXN0cnVjdCBjX2Nhbl9wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKLQlzdHJ1 Y3QgbmV0X2RldmljZV9zdGF0cyAqc3RhdHMgPSAmZGV2LT5zdGF0czsKIAlzdHJ1Y3QgY2FuX2Zy YW1lICpjZjsKIAlzdHJ1Y3Qgc2tfYnVmZiAqc2tiOwogCXN0cnVjdCBjYW5fYmVycl9jb3VudGVy IGJlYzsKQEAgLTk5Niw4ICs5OTUsNiBAQCBzdGF0aWMgaW50IGNfY2FuX2hhbmRsZV9zdGF0ZV9j aGFuZ2Uoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKIAkJYnJlYWs7CiAJfQogCi0Jc3RhdHMtPnJ4 X3BhY2tldHMrKzsKLQlzdGF0cy0+cnhfYnl0ZXMgKz0gY2YtPmxlbjsKIAluZXRpZl9yZWNlaXZl X3NrYihza2IpOwogCiAJcmV0dXJuIDE7CkBAIC0xMDY0LDggKzEwNjEsNiBAQCBzdGF0aWMgaW50 IGNfY2FuX2hhbmRsZV9idXNfZXJyKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJCWJyZWFrOwog CX0KIAotCXN0YXRzLT5yeF9wYWNrZXRzKys7Ci0Jc3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47 CiAJbmV0aWZfcmVjZWl2ZV9za2Ioc2tiKTsKIAlyZXR1cm4gMTsKIH0KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvbmV0L2Nhbi9jYzc3MC9jYzc3MC5jIGIvZHJpdmVycy9uZXQvY2FuL2NjNzcwL2NjNzcw LmMKaW5kZXggZjhhMTMwZjU5NGUyZS4uYTVmZDhjY2VkZWMyMSAxMDA2NDQKLS0tIGEvZHJpdmVy cy9uZXQvY2FuL2NjNzcwL2NjNzcwLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL2NjNzcwL2NjNzcw LmMKQEAgLTQ5OSw3ICs0OTksNiBAQCBzdGF0aWMgdm9pZCBjYzc3MF9yeChzdHJ1Y3QgbmV0X2Rl dmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgbW8sIHU4IGN0cmwxKQogc3RhdGljIGludCBjYzc3MF9l cnIoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgdTggc3RhdHVzKQogewogCXN0cnVjdCBjYzc3MF9w cml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKLQlzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAq c3RhdHMgPSAmZGV2LT5zdGF0czsKIAlzdHJ1Y3QgY2FuX2ZyYW1lICpjZjsKIAlzdHJ1Y3Qgc2tf YnVmZiAqc2tiOwogCXU4IGxlYzsKQEAgLTU3MSw4ICs1NzAsNiBAQCBzdGF0aWMgaW50IGNjNzcw X2VycihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCB1OCBzdGF0dXMpCiAJfQogCiAKLQlzdGF0cy0+ cnhfcGFja2V0cysrOwotCXN0YXRzLT5yeF9ieXRlcyArPSBjZi0+bGVuOwogCW5ldGlmX3J4KHNr Yik7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9kZXYvZGV2LmMg Yi9kcml2ZXJzL25ldC9jYW4vZGV2L2Rldi5jCmluZGV4IGUzZDg0MGI4MTM1N2QuLjQ4NDVhZTY0 NTZlMTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi9kZXYvZGV2LmMKKysrIGIvZHJpdmVy cy9uZXQvY2FuL2Rldi9kZXYuYwpAQCAtMTM2LDcgKzEzNiw2IEBAIEVYUE9SVF9TWU1CT0xfR1BM KGNhbl9jaGFuZ2Vfc3RhdGUpOwogc3RhdGljIHZvaWQgY2FuX3Jlc3RhcnQoc3RydWN0IG5ldF9k ZXZpY2UgKmRldikKIHsKIAlzdHJ1Y3QgY2FuX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYp OwotCXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpzdGF0cyA9ICZkZXYtPnN0YXRzOwogCXN0cnVj dCBza19idWZmICpza2I7CiAJc3RydWN0IGNhbl9mcmFtZSAqY2Y7CiAJaW50IGVycjsKQEAgLTE1 NSw5ICsxNTQsNiBAQCBzdGF0aWMgdm9pZCBjYW5fcmVzdGFydChzdHJ1Y3QgbmV0X2RldmljZSAq ZGV2KQogCiAJY2YtPmNhbl9pZCB8PSBDQU5fRVJSX1JFU1RBUlRFRDsKIAotCXN0YXRzLT5yeF9w YWNrZXRzKys7Ci0Jc3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47Ci0KIAluZXRpZl9yeF9uaShz a2IpOwogCiByZXN0YXJ0OgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL2Rldi9yeC1vZmZs b2FkLmMgYi9kcml2ZXJzL25ldC9jYW4vZGV2L3J4LW9mZmxvYWQuYwppbmRleCAzN2IwY2M2NTIz N2I3Li43ZGJmNDZiOWNhNWRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vZGV2L3J4LW9m ZmxvYWQuYworKysgYi9kcml2ZXJzL25ldC9jYW4vZGV2L3J4LW9mZmxvYWQuYwpAQCAtNTQsOCAr NTQsMTAgQEAgc3RhdGljIGludCBjYW5fcnhfb2ZmbG9hZF9uYXBpX3BvbGwoc3RydWN0IG5hcGlf c3RydWN0ICpuYXBpLCBpbnQgcXVvdGEpCiAJCXN0cnVjdCBjYW5fZnJhbWUgKmNmID0gKHN0cnVj dCBjYW5fZnJhbWUgKilza2ItPmRhdGE7CiAKIAkJd29ya19kb25lKys7Ci0JCXN0YXRzLT5yeF9w YWNrZXRzKys7Ci0JCXN0YXRzLT5yeF9ieXRlcyArPSBjZi0+bGVuOworCQlpZiAoIShjZi0+Y2Fu X2lkICYgQ0FOX0VSUl9GTEFHKSkgeworCQkJc3RhdHMtPnJ4X3BhY2tldHMrKzsKKwkJCXN0YXRz LT5yeF9ieXRlcyArPSBjZi0+bGVuOworCQl9CiAJCW5ldGlmX3JlY2VpdmVfc2tiKHNrYik7CiAJ fQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vaWZpX2NhbmZkL2lmaV9jYW5mZC5jIGIv ZHJpdmVycy9uZXQvY2FuL2lmaV9jYW5mZC9pZmlfY2FuZmQuYwppbmRleCA1YmI5NTdhMjZiYzY5 Li5lODMxOGU5ODRiZjJmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vaWZpX2NhbmZkL2lm aV9jYW5mZC5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi9pZmlfY2FuZmQvaWZpX2NhbmZkLmMKQEAg LTQzMCw4ICs0MzAsNiBAQCBzdGF0aWMgaW50IGlmaV9jYW5mZF9oYW5kbGVfbGVjX2VycihzdHJ1 Y3QgbmV0X2RldmljZSAqbmRldikKIAkgICAgICAgcHJpdi0+YmFzZSArIElGSV9DQU5GRF9JTlRF UlJVUFQpOwogCXdyaXRlbChJRklfQ0FORkRfRVJST1JfQ1RSX0VSX0VOQUJMRSwgcHJpdi0+YmFz ZSArIElGSV9DQU5GRF9FUlJPUl9DVFIpOwogCi0Jc3RhdHMtPnJ4X3BhY2tldHMrKzsKLQlzdGF0 cy0+cnhfYnl0ZXMgKz0gY2YtPmxlbjsKIAluZXRpZl9yZWNlaXZlX3NrYihza2IpOwogCiAJcmV0 dXJuIDE7CkBAIC00NTYsNyArNDU0LDYgQEAgc3RhdGljIGludCBpZmlfY2FuZmRfaGFuZGxlX3N0 YXRlX2NoYW5nZShzdHJ1Y3QgbmV0X2RldmljZSAqbmRldiwKIAkJCQkJIGVudW0gY2FuX3N0YXRl IG5ld19zdGF0ZSkKIHsKIAlzdHJ1Y3QgaWZpX2NhbmZkX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJp dihuZGV2KTsKLQlzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqc3RhdHMgPSAmbmRldi0+c3RhdHM7 CiAJc3RydWN0IGNhbl9mcmFtZSAqY2Y7CiAJc3RydWN0IHNrX2J1ZmYgKnNrYjsKIAlzdHJ1Y3Qg Y2FuX2JlcnJfY291bnRlciBiZWM7CkBAIC01MjIsOCArNTE5LDYgQEAgc3RhdGljIGludCBpZmlf Y2FuZmRfaGFuZGxlX3N0YXRlX2NoYW5nZShzdHJ1Y3QgbmV0X2RldmljZSAqbmRldiwKIAkJYnJl YWs7CiAJfQogCi0Jc3RhdHMtPnJ4X3BhY2tldHMrKzsKLQlzdGF0cy0+cnhfYnl0ZXMgKz0gY2Yt PmxlbjsKIAluZXRpZl9yZWNlaXZlX3NrYihza2IpOwogCiAJcmV0dXJuIDE7CmRpZmYgLS1naXQg YS9kcml2ZXJzL25ldC9jYW4va3Zhc2VyX3BjaWVmZC5jIGIvZHJpdmVycy9uZXQvY2FuL2t2YXNl cl9wY2llZmQuYwppbmRleCBlYjc0Y2RmMjZiODhjLi5hYjY3MmM5MmFiMDc4IDEwMDY0NAotLS0g YS9kcml2ZXJzL25ldC9jYW4va3Zhc2VyX3BjaWVmZC5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi9r dmFzZXJfcGNpZWZkLmMKQEAgLTEzMTAsOSArMTMxMCw2IEBAIHN0YXRpYyBpbnQga3Zhc2VyX3Bj aWVmZF9yeF9lcnJvcl9mcmFtZShzdHJ1Y3Qga3Zhc2VyX3BjaWVmZF9jYW4gKmNhbiwKIAljZi0+ ZGF0YVs2XSA9IGJlYy50eGVycjsKIAljZi0+ZGF0YVs3XSA9IGJlYy5yeGVycjsKIAotCXN0YXRz LT5yeF9wYWNrZXRzKys7Ci0Jc3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47Ci0KIAluZXRpZl9y eChza2IpOwogCXJldHVybiAwOwogfQpAQCAtMTUxMCw4ICsxNTA3LDYgQEAgc3RhdGljIHZvaWQg a3Zhc2VyX3BjaWVmZF9oYW5kbGVfbmFja19wYWNrZXQoc3RydWN0IGt2YXNlcl9wY2llZmRfY2Fu ICpjYW4sCiAKIAlpZiAoc2tiKSB7CiAJCWNmLT5jYW5faWQgfD0gQ0FOX0VSUl9CVVNFUlJPUjsK LQkJc3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47Ci0JCXN0YXRzLT5yeF9wYWNrZXRzKys7CiAJ CW5ldGlmX3J4KHNrYik7CiAJfSBlbHNlIHsKIAkJc3RhdHMtPnJ4X2Ryb3BwZWQrKzsKZGlmZiAt LWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9tX2Nhbi9tX2Nhbi5jIGIvZHJpdmVycy9uZXQvY2FuL21f Y2FuL21fY2FuLmMKaW5kZXggYzJhODQyMWU3ODQ1Yy4uMzBkOTRjYjQzMTEzZCAxMDA2NDQKLS0t IGEvZHJpdmVycy9uZXQvY2FuL21fY2FuL21fY2FuLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL21f Y2FuL21fY2FuLmMKQEAgLTY0Nyw5ICs2NDcsNiBAQCBzdGF0aWMgaW50IG1fY2FuX2hhbmRsZV9s ZWNfZXJyKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJCWJyZWFrOwogCX0KIAotCXN0YXRzLT5y eF9wYWNrZXRzKys7Ci0Jc3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47Ci0KIAlpZiAoY2Rldi0+ aXNfcGVyaXBoZXJhbCkKIAkJdGltZXN0YW1wID0gbV9jYW5fZ2V0X3RpbWVzdGFtcChjZGV2KTsK IApAQCAtNzA2LDcgKzcwMyw2IEBAIHN0YXRpYyBpbnQgbV9jYW5faGFuZGxlX3N0YXRlX2NoYW5n ZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LAogCQkJCSAgICAgZW51bSBjYW5fc3RhdGUgbmV3X3N0 YXRlKQogewogCXN0cnVjdCBtX2Nhbl9jbGFzc2RldiAqY2RldiA9IG5ldGRldl9wcml2KGRldik7 Ci0Jc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKnN0YXRzID0gJmRldi0+c3RhdHM7CiAJc3RydWN0 IGNhbl9mcmFtZSAqY2Y7CiAJc3RydWN0IHNrX2J1ZmYgKnNrYjsKIAlzdHJ1Y3QgY2FuX2JlcnJf Y291bnRlciBiZWM7CkBAIC03NzEsOSArNzY3LDYgQEAgc3RhdGljIGludCBtX2Nhbl9oYW5kbGVf c3RhdGVfY2hhbmdlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCiAJCWJyZWFrOwogCX0KIAotCXN0 YXRzLT5yeF9wYWNrZXRzKys7Ci0Jc3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47Ci0KIAlpZiAo Y2Rldi0+aXNfcGVyaXBoZXJhbCkKIAkJdGltZXN0YW1wID0gbV9jYW5fZ2V0X3RpbWVzdGFtcChj ZGV2KTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL21zY2FuL21zY2FuLmMgYi9kcml2 ZXJzL25ldC9jYW4vbXNjYW4vbXNjYW4uYwppbmRleCBmYTMyZTQxOGViMjk2Li45ZTFjY2UwMjYw ZGE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vbXNjYW4vbXNjYW4uYworKysgYi9kcml2 ZXJzL25ldC9jYW4vbXNjYW4vbXNjYW4uYwpAQCAtNDAxLDEzICs0MDEsMTQgQEAgc3RhdGljIGlu dCBtc2Nhbl9yeF9wb2xsKHN0cnVjdCBuYXBpX3N0cnVjdCAqbmFwaSwgaW50IHF1b3RhKQogCQkJ Y29udGludWU7CiAJCX0KIAotCQlpZiAoY2FucmZsZyAmIE1TQ0FOX1JYRikKKwkJaWYgKGNhbnJm bGcgJiBNU0NBTl9SWEYpIHsKIAkJCW1zY2FuX2dldF9yeF9mcmFtZShkZXYsIGZyYW1lKTsKLQkJ ZWxzZSBpZiAoY2FucmZsZyAmIE1TQ0FOX0VSUl9JRikKKwkJCXN0YXRzLT5yeF9wYWNrZXRzKys7 CisJCQlzdGF0cy0+cnhfYnl0ZXMgKz0gZnJhbWUtPmxlbjsKKwkJfSBlbHNlIGlmIChjYW5yZmxn ICYgTVNDQU5fRVJSX0lGKSB7CiAJCQltc2Nhbl9nZXRfZXJyX2ZyYW1lKGRldiwgZnJhbWUsIGNh bnJmbGcpOworCQl9CiAKLQkJc3RhdHMtPnJ4X3BhY2tldHMrKzsKLQkJc3RhdHMtPnJ4X2J5dGVz ICs9IGZyYW1lLT5sZW47CiAJCXdvcmtfZG9uZSsrOwogCQluZXRpZl9yZWNlaXZlX3NrYihza2Ip OwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9wY2hfY2FuLmMgYi9kcml2ZXJzL25l dC9jYW4vcGNoX2Nhbi5jCmluZGV4IDk2NGM4YTA5MjI2YTkuLjZiNDU4NDBkYjFmOWIgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi9wY2hfY2FuLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL3Bj aF9jYW4uYwpAQCAtNTYxLDkgKzU2MSw2IEBAIHN0YXRpYyB2b2lkIHBjaF9jYW5fZXJyb3Ioc3Ry dWN0IG5ldF9kZXZpY2UgKm5kZXYsIHUzMiBzdGF0dXMpCiAKIAlwcml2LT5jYW4uc3RhdGUgPSBz dGF0ZTsKIAluZXRpZl9yZWNlaXZlX3NrYihza2IpOwotCi0Jc3RhdHMtPnJ4X3BhY2tldHMrKzsK LQlzdGF0cy0+cnhfYnl0ZXMgKz0gY2YtPmxlbjsKIH0KIAogc3RhdGljIGlycXJldHVybl90IHBj aF9jYW5faW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbmV0L2Nhbi9wZWFrX2NhbmZkL3BlYWtfY2FuZmQuYyBiL2RyaXZlcnMvbmV0L2Nhbi9wZWFr X2NhbmZkL3BlYWtfY2FuZmQuYwppbmRleCBkMDg3MThlOThlMTEwLi5kNWI4YmM2ZDI5ODA0IDEw MDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vcGVha19jYW5mZC9wZWFrX2NhbmZkLmMKKysrIGIv ZHJpdmVycy9uZXQvY2FuL3BlYWtfY2FuZmQvcGVha19jYW5mZC5jCkBAIC00MDksOCArNDA5LDYg QEAgc3RhdGljIGludCBwdWNhbl9oYW5kbGVfc3RhdHVzKHN0cnVjdCBwZWFrX2NhbmZkX3ByaXYg KnByaXYsCiAJCXJldHVybiAtRU5PTUVNOwogCX0KIAotCXN0YXRzLT5yeF9wYWNrZXRzKys7Ci0J c3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47CiAJcHVjYW5fbmV0aWZfcngoc2tiLCBtc2ctPnRz X2xvdywgbXNnLT50c19oaWdoKTsKIAogCXJldHVybiAwOwpAQCAtNDM4LDggKzQzNiw2IEBAIHN0 YXRpYyBpbnQgcHVjYW5faGFuZGxlX2NhY2hlX2NyaXRpY2FsKHN0cnVjdCBwZWFrX2NhbmZkX3By aXYgKnByaXYpCiAJY2YtPmRhdGFbNl0gPSBwcml2LT5iZWMudHhlcnI7CiAJY2YtPmRhdGFbN10g PSBwcml2LT5iZWMucnhlcnI7CiAKLQlzdGF0cy0+cnhfYnl0ZXMgKz0gY2YtPmxlbjsKLQlzdGF0 cy0+cnhfcGFja2V0cysrOwogCW5ldGlmX3J4KHNrYik7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdp dCBhL2RyaXZlcnMvbmV0L2Nhbi9yY2FyL3JjYXJfY2FuLmMgYi9kcml2ZXJzL25ldC9jYW4vcmNh ci9yY2FyX2Nhbi5jCmluZGV4IDg5OTllYzk0NTVlYzIuLmY0MDhlZDlhNmNjZDEgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvbmV0L2Nhbi9yY2FyL3JjYXJfY2FuLmMKKysrIGIvZHJpdmVycy9uZXQvY2Fu L3JjYXIvcmNhcl9jYW4uYwpAQCAtMjIzLDcgKzIyMyw2IEBAIHN0YXRpYyB2b2lkIHR4X2ZhaWx1 cmVfY2xlYW51cChzdHJ1Y3QgbmV0X2RldmljZSAqbmRldikKIHN0YXRpYyB2b2lkIHJjYXJfY2Fu X2Vycm9yKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2KQogewogCXN0cnVjdCByY2FyX2Nhbl9wcml2 ICpwcml2ID0gbmV0ZGV2X3ByaXYobmRldik7Ci0Jc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKnN0 YXRzID0gJm5kZXYtPnN0YXRzOwogCXN0cnVjdCBjYW5fZnJhbWUgKmNmOwogCXN0cnVjdCBza19i dWZmICpza2I7CiAJdTggZWlmciwgdHhlcnIgPSAwLCByeGVyciA9IDA7CkBAIC0zNjIsMTEgKzM2 MSw4IEBAIHN0YXRpYyB2b2lkIHJjYXJfY2FuX2Vycm9yKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2 KQogCQl9CiAJfQogCi0JaWYgKHNrYikgewotCQlzdGF0cy0+cnhfcGFja2V0cysrOwotCQlzdGF0 cy0+cnhfYnl0ZXMgKz0gY2YtPmxlbjsKKwlpZiAoc2tiKQogCQluZXRpZl9yeChza2IpOwotCX0K IH0KIAogc3RhdGljIHZvaWQgcmNhcl9jYW5fdHhfZG9uZShzdHJ1Y3QgbmV0X2RldmljZSAqbmRl dikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9yY2FyL3JjYXJfY2FuZmQuYyBiL2RyaXZl cnMvbmV0L2Nhbi9yY2FyL3JjYXJfY2FuZmQuYwppbmRleCBmZjlkMGY1YWUwZGQyLi5kYjlkNjI4 NzRlMTUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vcmNhci9yY2FyX2NhbmZkLmMKKysr IGIvZHJpdmVycy9uZXQvY2FuL3JjYXIvcmNhcl9jYW5mZC5jCkBAIC0xMDMzLDggKzEwMzMsNiBA QCBzdGF0aWMgdm9pZCByY2FyX2NhbmZkX2Vycm9yKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2LCB1 MzIgY2VyZmwsCiAJLyogQ2xlYXIgY2hhbm5lbCBlcnJvciBpbnRlcnJ1cHRzIHRoYXQgYXJlIGhh bmRsZWQgKi8KIAlyY2FyX2NhbmZkX3dyaXRlKHByaXYtPmJhc2UsIFJDQU5GRF9DRVJGTChjaCks CiAJCQkgUkNBTkZEX0NFUkZMX0VSUih+Y2VyZmwpKTsKLQlzdGF0cy0+cnhfcGFja2V0cysrOwot CXN0YXRzLT5yeF9ieXRlcyArPSBjZi0+bGVuOwogCW5ldGlmX3J4KHNrYik7CiB9CiAKQEAgLTEx NzQsOCArMTE3Miw2IEBAIHN0YXRpYyB2b2lkIHJjYXJfY2FuZmRfc3RhdGVfY2hhbmdlKHN0cnVj dCBuZXRfZGV2aWNlICpuZGV2LAogCQlyeF9zdGF0ZSA9IHR4ZXJyIDw9IHJ4ZXJyID8gc3RhdGUg OiAwOwogCiAJCWNhbl9jaGFuZ2Vfc3RhdGUobmRldiwgY2YsIHR4X3N0YXRlLCByeF9zdGF0ZSk7 Ci0JCXN0YXRzLT5yeF9wYWNrZXRzKys7Ci0JCXN0YXRzLT5yeF9ieXRlcyArPSBjZi0+bGVuOwog CQluZXRpZl9yeChza2IpOwogCX0KIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9zamEx MDAwL3NqYTEwMDAuYyBiL2RyaXZlcnMvbmV0L2Nhbi9zamExMDAwL3NqYTEwMDAuYwppbmRleCAz ZmFkNTQ2NDY3NDYxLi5hNjU1NDZjYTk0NjEwIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4v c2phMTAwMC9zamExMDAwLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL3NqYTEwMDAvc2phMTAwMC5j CkBAIC00ODcsOCArNDg3LDYgQEAgc3RhdGljIGludCBzamExMDAwX2VycihzdHJ1Y3QgbmV0X2Rl dmljZSAqZGV2LCB1aW50OF90IGlzcmMsIHVpbnQ4X3Qgc3RhdHVzKQogCQkJY2FuX2J1c19vZmYo ZGV2KTsKIAl9CiAKLQlzdGF0cy0+cnhfcGFja2V0cysrOwotCXN0YXRzLT5yeF9ieXRlcyArPSBj Zi0+bGVuOwogCW5ldGlmX3J4KHNrYik7CiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbmV0L2Nhbi9zdW40aV9jYW4uYyBiL2RyaXZlcnMvbmV0L2Nhbi9zdW40aV9jYW4uYwppbmRl eCA1NGFhN2MyNWM0ZGUxLi41OTkxNzQwOTg4ODNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9j YW4vc3VuNGlfY2FuLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL3N1bjRpX2Nhbi5jCkBAIC02MjIs MTMgKzYyMiwxMCBAQCBzdGF0aWMgaW50IHN1bjRpX2Nhbl9lcnIoc3RydWN0IG5ldF9kZXZpY2Ug KmRldiwgdTggaXNyYywgdTggc3RhdHVzKQogCQkJY2FuX2J1c19vZmYoZGV2KTsKIAl9CiAKLQlp ZiAobGlrZWx5KHNrYikpIHsKLQkJc3RhdHMtPnJ4X3BhY2tldHMrKzsKLQkJc3RhdHMtPnJ4X2J5 dGVzICs9IGNmLT5sZW47CisJaWYgKGxpa2VseShza2IpKQogCQluZXRpZl9yeChza2IpOwotCX0g ZWxzZSB7CisJZWxzZQogCQlyZXR1cm4gLUVOT01FTTsKLQl9CiAKIAlyZXR1cm4gMDsKIH0KZGlm ZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi91c2IvZW1zX3VzYi5jIGIvZHJpdmVycy9uZXQvY2Fu L3VzYi9lbXNfdXNiLmMKaW5kZXggMmI1MzAyZTcyNDM1My4uN2NmNjU5MzZkMDJlNSAxMDA2NDQK LS0tIGEvZHJpdmVycy9uZXQvY2FuL3VzYi9lbXNfdXNiLmMKKysrIGIvZHJpdmVycy9uZXQvY2Fu L3VzYi9lbXNfdXNiLmMKQEAgLTM5Nyw4ICszOTcsNiBAQCBzdGF0aWMgdm9pZCBlbXNfdXNiX3J4 X2VycihzdHJ1Y3QgZW1zX3VzYiAqZGV2LCBzdHJ1Y3QgZW1zX2NwY19tc2cgKm1zZykKIAkJc3Rh dHMtPnJ4X2Vycm9ycysrOwogCX0KIAotCXN0YXRzLT5yeF9wYWNrZXRzKys7Ci0Jc3RhdHMtPnJ4 X2J5dGVzICs9IGNmLT5sZW47CiAJbmV0aWZfcngoc2tiKTsKIH0KIApkaWZmIC0tZ2l0IGEvZHJp dmVycy9uZXQvY2FuL3VzYi9lc2RfdXNiMi5jIGIvZHJpdmVycy9uZXQvY2FuL3VzYi9lc2RfdXNi Mi5jCmluZGV4IGM2MDY4YTI1MWZiZWQuLjVmNjkxNWEyN2IzZDkgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvbmV0L2Nhbi91c2IvZXNkX3VzYjIuYworKysgYi9kcml2ZXJzL25ldC9jYW4vdXNiL2VzZF91 c2IyLmMKQEAgLTI5Myw4ICsyOTMsNiBAQCBzdGF0aWMgdm9pZCBlc2RfdXNiMl9yeF9ldmVudChz dHJ1Y3QgZXNkX3VzYjJfbmV0X3ByaXYgKnByaXYsCiAJCXByaXYtPmJlYy50eGVyciA9IHR4ZXJy OwogCQlwcml2LT5iZWMucnhlcnIgPSByeGVycjsKIAotCQlzdGF0cy0+cnhfcGFja2V0cysrOwot CQlzdGF0cy0+cnhfYnl0ZXMgKz0gY2YtPmxlbjsKIAkJbmV0aWZfcngoc2tiKTsKIAl9CiB9CmRp ZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vdXNiL2V0YXNfZXM1OHgvZXM1OHhfY29yZS5jIGIv ZHJpdmVycy9uZXQvY2FuL3VzYi9ldGFzX2VzNTh4L2VzNTh4X2NvcmUuYwppbmRleCAyNDYyN2Fi MTQ2MjYxLi5mYjA3YzMzYmEwYzNjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vdXNiL2V0 YXNfZXM1OHgvZXM1OHhfY29yZS5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi91c2IvZXRhc19lczU4 eC9lczU4eF9jb3JlLmMKQEAgLTg0OSwxMyArODQ5LDYgQEAgaW50IGVzNTh4X3J4X2Vycl9tc2co c3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgZW51bSBlczU4eF9lcnIgZXJyb3IsCiAJCWJyZWFr OwogCX0KIAotCS8qIGRyaXZlci9uZXQvY2FuL2Rldi5jOmNhbl9yZXN0YXJ0KCkgdGFrZXMgaW4g YWNjb3VudCBlcnJvcgotCSAqIG1lc3NhZ2VzIGluIHRoZSBSWCBzdGF0cy4gRG9pbmcgdGhlIHNh bWUgaGVyZSBmb3IKLQkgKiBjb25zaXN0ZW5jeS4KLQkgKi8KLQluZXRkZXYtPnN0YXRzLnJ4X3Bh Y2tldHMrKzsKLQluZXRkZXYtPnN0YXRzLnJ4X2J5dGVzICs9IENBTl9FUlJfRExDOwotCiAJaWYg KGNmKSB7CiAJCWlmIChjZi0+ZGF0YVsxXSkKIAkJCWNmLT5jYW5faWQgfD0gQ0FOX0VSUl9DUlRM OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL3VzYi9rdmFzZXJfdXNiL2t2YXNlcl91c2Jf Y29yZS5jIGIvZHJpdmVycy9uZXQvY2FuL3VzYi9rdmFzZXJfdXNiL2t2YXNlcl91c2JfY29yZS5j CmluZGV4IDBjYzBmYzg2NmEyYTkuLjNlNjgyZWY0M2Y4ZWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bmV0L2Nhbi91c2Iva3Zhc2VyX3VzYi9rdmFzZXJfdXNiX2NvcmUuYworKysgYi9kcml2ZXJzL25l dC9jYW4vdXNiL2t2YXNlcl91c2Iva3Zhc2VyX3VzYl9jb3JlLmMKQEAgLTI3OSw4ICsyNzksNiBA QCBpbnQga3Zhc2VyX3VzYl9jYW5fcnhfb3Zlcl9lcnJvcihzdHJ1Y3QgbmV0X2RldmljZSAqbmV0 ZGV2KQogCWNmLT5jYW5faWQgfD0gQ0FOX0VSUl9DUlRMOwogCWNmLT5kYXRhWzFdID0gQ0FOX0VS Ul9DUlRMX1JYX09WRVJGTE9XOwogCi0Jc3RhdHMtPnJ4X3BhY2tldHMrKzsKLQlzdGF0cy0+cnhf Ynl0ZXMgKz0gY2YtPmxlbjsKIAluZXRpZl9yeChza2IpOwogCiAJcmV0dXJuIDA7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL25ldC9jYW4vdXNiL2t2YXNlcl91c2Iva3Zhc2VyX3VzYl9oeWRyYS5jIGIv ZHJpdmVycy9uZXQvY2FuL3VzYi9rdmFzZXJfdXNiL2t2YXNlcl91c2JfaHlkcmEuYwppbmRleCBk Y2VlOGRjODI4ZWNjLi4zMzk4ZGEzMjMxMjZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4v dXNiL2t2YXNlcl91c2Iva3Zhc2VyX3VzYl9oeWRyYS5jCisrKyBiL2RyaXZlcnMvbmV0L2Nhbi91 c2Iva3Zhc2VyX3VzYi9rdmFzZXJfdXNiX2h5ZHJhLmMKQEAgLTg2OSw3ICs4NjksNiBAQCBzdGF0 aWMgdm9pZCBrdmFzZXJfdXNiX2h5ZHJhX3VwZGF0ZV9zdGF0ZShzdHJ1Y3Qga3Zhc2VyX3VzYl9u ZXRfcHJpdiAqcHJpdiwKIAlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2ID0gcHJpdi0+bmV0ZGV2 OwogCXN0cnVjdCBjYW5fZnJhbWUgKmNmOwogCXN0cnVjdCBza19idWZmICpza2I7Ci0Jc3RydWN0 IG5ldF9kZXZpY2Vfc3RhdHMgKnN0YXRzOwogCWVudW0gY2FuX3N0YXRlIG5ld19zdGF0ZSwgb2xk X3N0YXRlOwogCiAJb2xkX3N0YXRlID0gcHJpdi0+Y2FuLnN0YXRlOwpAQCAtOTE5LDkgKzkxOCw2 IEBAIHN0YXRpYyB2b2lkIGt2YXNlcl91c2JfaHlkcmFfdXBkYXRlX3N0YXRlKHN0cnVjdCBrdmFz ZXJfdXNiX25ldF9wcml2ICpwcml2LAogCWNmLT5kYXRhWzZdID0gYmVjLT50eGVycjsKIAljZi0+ ZGF0YVs3XSA9IGJlYy0+cnhlcnI7CiAKLQlzdGF0cyA9ICZuZXRkZXYtPnN0YXRzOwotCXN0YXRz LT5yeF9wYWNrZXRzKys7Ci0Jc3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47CiAJbmV0aWZfcngo c2tiKTsKIH0KIApAQCAtMTA3NCw4ICsxMDcwLDYgQEAga3Zhc2VyX3VzYl9oeWRyYV9lcnJvcl9m cmFtZShzdHJ1Y3Qga3Zhc2VyX3VzYl9uZXRfcHJpdiAqcHJpdiwKIAljZi0+ZGF0YVs2XSA9IGJl Yy50eGVycjsKIAljZi0+ZGF0YVs3XSA9IGJlYy5yeGVycjsKIAotCXN0YXRzLT5yeF9wYWNrZXRz Kys7Ci0Jc3RhdHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47CiAJbmV0aWZfcngoc2tiKTsKIAogCXBy aXYtPmJlYy50eGVyciA9IGJlYy50eGVycjsKQEAgLTExMDksOCArMTEwMyw2IEBAIHN0YXRpYyB2 b2lkIGt2YXNlcl91c2JfaHlkcmFfb25lX3Nob3RfZmFpbChzdHJ1Y3Qga3Zhc2VyX3VzYl9uZXRf cHJpdiAqcHJpdiwKIAl9CiAKIAlzdGF0cy0+dHhfZXJyb3JzKys7Ci0Jc3RhdHMtPnJ4X3BhY2tl dHMrKzsKLQlzdGF0cy0+cnhfYnl0ZXMgKz0gY2YtPmxlbjsKIAluZXRpZl9yeChza2IpOwogfQog CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vdXNiL2t2YXNlcl91c2Iva3Zhc2VyX3VzYl9s ZWFmLmMgYi9kcml2ZXJzL25ldC9jYW4vdXNiL2t2YXNlcl91c2Iva3Zhc2VyX3VzYl9sZWFmLmMK aW5kZXggZjdhZjFiZjVhYjQ2ZC4uNTQzNGI3Mzg2YTUxZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9u ZXQvY2FuL3VzYi9rdmFzZXJfdXNiL2t2YXNlcl91c2JfbGVhZi5jCisrKyBiL2RyaXZlcnMvbmV0 L2Nhbi91c2Iva3Zhc2VyX3VzYi9rdmFzZXJfdXNiX2xlYWYuYwpAQCAtNjQxLDggKzY0MSw2IEBA IHN0YXRpYyB2b2lkIGt2YXNlcl91c2JfbGVhZl90eF9hY2tub3dsZWRnZShjb25zdCBzdHJ1Y3Qg a3Zhc2VyX3VzYiAqZGV2LAogCQlpZiAoc2tiKSB7CiAJCQljZi0+Y2FuX2lkIHw9IENBTl9FUlJf UkVTVEFSVEVEOwogCi0JCQlzdGF0cy0+cnhfcGFja2V0cysrOwotCQkJc3RhdHMtPnJ4X2J5dGVz ICs9IGNmLT5sZW47CiAJCQluZXRpZl9yeChza2IpOwogCQl9IGVsc2UgewogCQkJbmV0ZGV2X2Vy cihwcml2LT5uZXRkZXYsCkBAIC04NDMsOCArODQxLDYgQEAgc3RhdGljIHZvaWQga3Zhc2VyX3Vz Yl9sZWFmX3J4X2Vycm9yKGNvbnN0IHN0cnVjdCBrdmFzZXJfdXNiICpkZXYsCiAJY2YtPmRhdGFb Nl0gPSBlcy0+dHhlcnI7CiAJY2YtPmRhdGFbN10gPSBlcy0+cnhlcnI7CiAKLQlzdGF0cy0+cnhf cGFja2V0cysrOwotCXN0YXRzLT5yeF9ieXRlcyArPSBjZi0+bGVuOwogCW5ldGlmX3J4KHNrYik7 CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi91c2IvcGVha191c2IvcGNhbl91c2Iu YyBiL2RyaXZlcnMvbmV0L2Nhbi91c2IvcGVha191c2IvcGNhbl91c2IuYwppbmRleCA4NzYyMTg3 NTI3NjY5Li4yMWIwNmE3Mzg1OTU5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vdXNiL3Bl YWtfdXNiL3BjYW5fdXNiLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL3VzYi9wZWFrX3VzYi9wY2Fu X3VzYi5jCkBAIC01MjAsOCArNTIwLDYgQEAgc3RhdGljIGludCBwY2FuX3VzYl9kZWNvZGVfZXJy b3Ioc3RydWN0IHBjYW5fdXNiX21zZ19jb250ZXh0ICptYywgdTggbiwKIAkJCQkgICAgICZod3Rz LT5od3RzdGFtcCk7CiAJfQogCi0JbWMtPm5ldGRldi0+c3RhdHMucnhfcGFja2V0cysrOwotCW1j LT5uZXRkZXYtPnN0YXRzLnJ4X2J5dGVzICs9IGNmLT5sZW47CiAJbmV0aWZfcngoc2tiKTsKIAog CXJldHVybiAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL3VzYi9wZWFrX3VzYi9wY2Fu X3VzYl9mZC5jIGIvZHJpdmVycy9uZXQvY2FuL3VzYi9wZWFrX3VzYi9wY2FuX3VzYl9mZC5jCmlu ZGV4IDZiZDEyNTQ5ZjEwMTQuLjE4NWY1YTk4ZDIxNzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0 L2Nhbi91c2IvcGVha191c2IvcGNhbl91c2JfZmQuYworKysgYi9kcml2ZXJzL25ldC9jYW4vdXNi L3BlYWtfdXNiL3BjYW5fdXNiX2ZkLmMKQEAgLTU3Nyw5ICs1NzcsNiBAQCBzdGF0aWMgaW50IHBj YW5fdXNiX2ZkX2RlY29kZV9zdGF0dXMoc3RydWN0IHBjYW5fdXNiX2ZkX2lmICp1c2JfaWYsCiAJ aWYgKCFza2IpCiAJCXJldHVybiAtRU5PTUVNOwogCi0JbmV0ZGV2LT5zdGF0cy5yeF9wYWNrZXRz Kys7Ci0JbmV0ZGV2LT5zdGF0cy5yeF9ieXRlcyArPSBjZi0+bGVuOwotCiAJcGVha191c2JfbmV0 aWZfcnhfNjQoc2tiLCBsZTMyX3RvX2NwdShzbS0+dHNfbG93KSwKIAkJCSAgICAgbGUzMl90b19j cHUoc20tPnRzX2hpZ2gpKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL3VzYi9wZWFr X3VzYi9wY2FuX3VzYl9wcm8uYyBiL2RyaXZlcnMvbmV0L2Nhbi91c2IvcGVha191c2IvcGNhbl91 c2JfcHJvLmMKaW5kZXggODU4YWIyMjcwOGZjZC4uZjZkMTk4NzliZjQwNCAxMDA2NDQKLS0tIGEv ZHJpdmVycy9uZXQvY2FuL3VzYi9wZWFrX3VzYi9wY2FuX3VzYl9wcm8uYworKysgYi9kcml2ZXJz L25ldC9jYW4vdXNiL3BlYWtfdXNiL3BjYW5fdXNiX3Byby5jCkBAIC02NjAsOCArNjYwLDYgQEAg c3RhdGljIGludCBwY2FuX3VzYl9wcm9faGFuZGxlX2Vycm9yKHN0cnVjdCBwY2FuX3VzYl9wcm9f aW50ZXJmYWNlICp1c2JfaWYsCiAKIAlod3RzID0gc2tiX2h3dHN0YW1wcyhza2IpOwogCXBlYWtf dXNiX2dldF90c190aW1lKCZ1c2JfaWYtPnRpbWVfcmVmLCBsZTMyX3RvX2NwdShlci0+dHMzMiks ICZod3RzLT5od3RzdGFtcCk7Ci0JbmV0ZGV2LT5zdGF0cy5yeF9wYWNrZXRzKys7Ci0JbmV0ZGV2 LT5zdGF0cy5yeF9ieXRlcyArPSBjYW5fZnJhbWUtPmxlbjsKIAluZXRpZl9yeChza2IpOwogCiAJ cmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4vdXNiL3VjYW4uYyBiL2RyaXZl cnMvbmV0L2Nhbi91c2IvdWNhbi5jCmluZGV4IDE2NzljYmU0NWRlZDIuLmQ1ODJjMzlmYzhkMGUg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi91c2IvdWNhbi5jCisrKyBiL2RyaXZlcnMvbmV0 L2Nhbi91c2IvdWNhbi5jCkBAIC02MjEsOCArNjIxLDEwIEBAIHN0YXRpYyB2b2lkIHVjYW5fcnhf Y2FuX21zZyhzdHJ1Y3QgdWNhbl9wcml2ICp1cCwgc3RydWN0IHVjYW5fbWVzc2FnZV9pbiAqbSkK IAkJbWVtY3B5KGNmLT5kYXRhLCBtLT5tc2cuY2FuX21zZy5kYXRhLCBjZi0+bGVuKTsKIAogCS8q IGRvbid0IGNvdW50IGVycm9yIGZyYW1lcyBhcyByZWFsIHBhY2tldHMgKi8KLQlzdGF0cy0+cnhf cGFja2V0cysrOwotCXN0YXRzLT5yeF9ieXRlcyArPSBjZi0+bGVuOworCWlmICghKGNmLT5jYW5f aWQgJiBDQU5fRVJSX0ZMQUcpKSB7CisJCXN0YXRzLT5yeF9wYWNrZXRzKys7CisJCXN0YXRzLT5y eF9ieXRlcyArPSBjZi0+bGVuOworCX0KIAogCS8qIHBhc3MgaXQgdG8gTGludXggKi8KIAluZXRp Zl9yeChza2IpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvY2FuL3VzYi91c2JfOGRldi5jIGIv ZHJpdmVycy9uZXQvY2FuL3VzYi91c2JfOGRldi5jCmluZGV4IGQxYjgzYmQxYjNjYjkuLjA0MDMy NDM2MmIyNjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2Nhbi91c2IvdXNiXzhkZXYuYworKysg Yi9kcml2ZXJzL25ldC9jYW4vdXNiL3VzYl84ZGV2LmMKQEAgLTQ0OSw4ICs0NDksNiBAQCBzdGF0 aWMgdm9pZCB1c2JfOGRldl9yeF9lcnJfbXNnKHN0cnVjdCB1c2JfOGRldl9wcml2ICpwcml2LAog CXByaXYtPmJlYy50eGVyciA9IHR4ZXJyOwogCXByaXYtPmJlYy5yeGVyciA9IHJ4ZXJyOwogCi0J c3RhdHMtPnJ4X3BhY2tldHMrKzsKLQlzdGF0cy0+cnhfYnl0ZXMgKz0gY2YtPmxlbjsKIAluZXRp Zl9yeChza2IpOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9jYW4veGlsaW54X2Nhbi5j IGIvZHJpdmVycy9uZXQvY2FuL3hpbGlueF9jYW4uYwppbmRleCBlMmIxNWQyOWQxNWViLi4yNzVl MjQwYWIyOTNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4veGlsaW54X2Nhbi5jCisrKyBi L2RyaXZlcnMvbmV0L2Nhbi94aWxpbnhfY2FuLmMKQEAgLTk2NSwxMyArOTY1LDggQEAgc3RhdGlj IHZvaWQgeGNhbl91cGRhdGVfZXJyb3Jfc3RhdGVfYWZ0ZXJfcnh0eChzdHJ1Y3QgbmV0X2Rldmlj ZSAqbmRldikKIAogCQl4Y2FuX3NldF9lcnJvcl9zdGF0ZShuZGV2LCBuZXdfc3RhdGUsIHNrYiA/ IGNmIDogTlVMTCk7CiAKLQkJaWYgKHNrYikgewotCQkJc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMg KnN0YXRzID0gJm5kZXYtPnN0YXRzOwotCi0JCQlzdGF0cy0+cnhfcGFja2V0cysrOwotCQkJc3Rh dHMtPnJ4X2J5dGVzICs9IGNmLT5sZW47CisJCWlmIChza2IpCiAJCQluZXRpZl9yeChza2IpOwot CQl9CiAJfQogfQogCkBAIC0xMDk1LDggKzEwOTAsNiBAQCBzdGF0aWMgdm9pZCB4Y2FuX2Vycl9p bnRlcnJ1cHQoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYsIHUzMiBpc3IpCiAJCWlmIChza2IpIHsK IAkJCXNrYl9jZi0+Y2FuX2lkIHw9IGNmLmNhbl9pZDsKIAkJCW1lbWNweShza2JfY2YtPmRhdGEs IGNmLmRhdGEsIENBTl9FUlJfRExDKTsKLQkJCXN0YXRzLT5yeF9wYWNrZXRzKys7Ci0JCQlzdGF0 cy0+cnhfYnl0ZXMgKz0gQ0FOX0VSUl9ETEM7CiAJCQluZXRpZl9yeChza2IpOwogCQl9CiAJfQot LSAKMi4zNC4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5p bmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8v bGludXgtYXJtLWtlcm5lbAo=