From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (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 B64C338F65C for ; Thu, 16 Jul 2026 14:37:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784212651; cv=none; b=Tjf22iU8Orkp2Vm7zt0z8q9n23dh9Cl4PeiOfR3qe50QIOnpz8PvSOEn0NpLUy2lRcr2ALh4wLbyEAhGSEh8ZPbuPARMTa3++hbd/aWujOpeRGrSCLLwsZSOVRQe8hyEdY5objDSkkFNujGUL7Oo7x54KmjfTYd/vJLdgFSeF/Q= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784212651; c=relaxed/simple; bh=hAjH3U6ztveW8945CZCq5QWGsezvoQ8JNbmQmTKRzJo=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=q/0Wgimb9HCgs1rdo81hr71thxC9doadbyNpbUphy5hPPbmxK/vNh7V8y0e8vQqT+FTOD+6JqDuo1yevYOh1ftviQJ8aA/czyQc5C4VnALweu2IcTAi9dZCdJo5LdzipRk6MtO3aswOHa+i8CgQVNjxnB4vIe6bJMYs4yRimDQg= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=X2tafqSP; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="X2tafqSP" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1353E1F000E9; Thu, 16 Jul 2026 14:37:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784212649; bh=4E6rSMFEq2ivH/yK4dEsmzDMGHSbcrhKuTc8PgYnfvM=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=X2tafqSP0NHHXJdBUgZDjGXTof8Zj6F/mxgiZrl5Ci2b+HQdoym1iVgK/S/X0vP8/ XeYhkuTFKjDTe2ZPaMVwPU6Z8uB16o4jtRoGphDZUWzWflgA0xS8j4cMu+lrdbGFsK qJfBNd5mph9j53z/CZXQBWdQZvuuuHFzQkhEDpsli8ecVv1mpbhReLOKNDVL8BMH+v 10lkbXXcD6YevPPO8wMJoWrG1yRHQyhni39Leo2zMDICfmYrFCxo4kRUubE1v5uw+B 8TO7HbyF5smMXNQQN9s8qzfgA2GBUi8zMepM3Be1qzUQoLQXzYlT8xkXb5bBlGFC2M vPhHgqC6EDklw== From: sashiko-bot@kernel.org Subject: Re: [PATCH v3 2/4] nvmem: make all reg_write callbacks take const void * Reply-To: sashiko-reviews@lists.linux.dev To: "Link Mauve" Cc: Frank.Li@kernel.org, ojeda@kernel.org, imx@lists.linux.dev, neil.armstrong@linaro.org, linux-amlogic@lists.infradead.org In-Reply-To: <20260716142415.28718-3-linkmauve@linkmauve.fr> References: <20260716142415.28718-1-linkmauve@linkmauve.fr> <20260716142415.28718-3-linkmauve@linkmauve.fr> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Thu, 16 Jul 2026 14:37:28 +0000 Message-Id: <20260716143729.1353E1F000E9@smtp.kernel.org> Precedence: bulk X-Mailing-List: imx@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: Thank you for your contribution! Sashiko AI review found 7 potential issue(= s) to consider: New issues: - [Medium] Incomplete API migration leaving deprecated reg_write callbacks = active Pre-existing issues: - [High] kCFI panic due to function pointer cast of regmap_bulk_write - [High] Hardware state corruption and out-of-bounds read in sprd_efuse_wri= te - [High] OP-TEE session resource leak on alignment check failure - [High] Missing locking leads to state corruption across multiple backend = drivers - [High] Sleeping in atomic context within sprd-efuse driver - [High] Security check bypass during multi-word writes in zynqmp_nvmem_wri= te -- --- Patch [2]: [PATCH v3 2/4] nvmem: make all reg_write callbacks take cons= t void * --- commit ec203eda05f126cbe777e1158095fb9e39499796 Author: Link Mauve nvmem: make all reg_write callbacks take const void * This patch updates various nvmem drivers to use the new reg_write_const callback instead of reg_write, matching a recent API change that passes immutable data. > The previous commit switched from a pointer to mutable data to a pointer > to immutable data, so let=E2=80=99s fix all users of this API. [Severity: Medium] Are there some drivers missing from this update? It appears several nvmem backend drivers are still assigning the deprecated reg_write callback, which leaves the migration incomplete: drivers/nvmem/at24.c:at24_probe() { nvmem_config.reg_write =3D at24_write; } drivers/nvmem/at25.c:at25_probe() { at25->nvmem_config.reg_write =3D at25_ee_write; } drivers/nvmem/eeprom_93xx46.c:eeprom_93xx46_probe() { edev->nvmem_config.reg_write =3D eeprom_93xx46_write; } drivers/nvmem/m24lr.c:m24lr_probe() { nvmem_conf.reg_write =3D m24lr_nvmem_write; } > diff --git a/drivers/nvmem/apple-spmi-nvmem.c b/drivers/nvmem/apple-spmi-= nvmem.c > index 88614005d5ce1..cbf25c53d048d 100644 > --- a/drivers/nvmem/apple-spmi-nvmem.c > +++ b/drivers/nvmem/apple-spmi-nvmem.c [ ... ] > @@ -29,7 +29,7 @@ static int apple_spmi_nvmem_probe(struct spmi_device *s= dev) > .stride =3D 1, > .size =3D 0xffff, > .reg_read =3D (void *)regmap_bulk_read, > - .reg_write =3D (void *)regmap_bulk_write, > + .reg_write_const =3D (void *)regmap_bulk_write, [Severity: High] This is a pre-existing issue, but does casting regmap_bulk_write to void * trigger a kCFI kernel panic? The actual signature of regmap_bulk_write doesn't match reg_write_const, so calling it via this function pointer could cause a control-flow integrity trap upon execution. > }; [ ... ] > diff --git a/drivers/nvmem/bcm-ocotp.c b/drivers/nvmem/bcm-ocotp.c > index 2490f44caa409..02adfd787de85 100644 > --- a/drivers/nvmem/bcm-ocotp.c > +++ b/drivers/nvmem/bcm-ocotp.c [ ... ] > @@ -179,11 +179,11 @@ static int bcm_otpc_read(void *context, unsigned in= t offset, void *val, > return 0; > } > =20 > -static int bcm_otpc_write(void *context, unsigned int offset, void *val, > - size_t bytes) > +static int bcm_otpc_write(void *context, unsigned int offset, const void= *val, > + size_t bytes) > { [Severity: High] This is a pre-existing issue, but does this function lack locking? Modifying shared command and address registers concurrently without a lock could corrupt the shared state machine: drivers/nvmem/bcm-ocotp.c:bcm_otpc_write() { for (bytes_written =3D 0; bytes_written < bytes;) { set_command(priv->base, OTPC_CMD_PROGRAM); set_cpu_address(priv->base, address++); ... } > struct otpc_priv *priv =3D context; [ ... ] > diff --git a/drivers/nvmem/lan9662-otpc.c b/drivers/nvmem/lan9662-otpc.c > index 62d1d6381bf88..f586ae4cd126b 100644 > --- a/drivers/nvmem/lan9662-otpc.c > +++ b/drivers/nvmem/lan9662-otpc.c [ ... ] > @@ -139,10 +139,10 @@ static int lan9662_otp_read(void *context, unsigned= int offset, > } > =20 > static int lan9662_otp_write(void *context, unsigned int offset, > - void *_val, size_t bytes) > + const void *_val, size_t bytes) > { [Severity: High] This is a pre-existing issue, but does this function perform unprotected read-modify-write operations on OTP bytes? Modifying the OTP bytes without locking could lead to data corruption in concurrent executions: drivers/nvmem/lan9662-otpc.c:lan9662_otp_write() { for (i =3D 0; i < bytes; i++) { if (val[i]) { rc =3D lan9662_otp_read_byte(otp, offset + i, &data); ... rc =3D lan9662_otp_write_byte(otp, offset + i, newdata); } } } > struct lan9662_otp *otp =3D context; [ ... ] > diff --git a/drivers/nvmem/lpc18xx_eeprom.c b/drivers/nvmem/lpc18xx_eepro= m.c > index 504155e30bab2..78a35ef095fbd 100644 > --- a/drivers/nvmem/lpc18xx_eeprom.c > +++ b/drivers/nvmem/lpc18xx_eeprom.c [ ... ] > @@ -87,7 +87,7 @@ static int lpc18xx_eeprom_busywait_until_prog(struct lp= c18xx_eeprom_dev *eeprom) > } > =20 > static int lpc18xx_eeprom_gather_write(void *context, unsigned int reg, > - void *val, size_t bytes) > + const void *val, size_t bytes) > { [Severity: High] This isn't a bug introduced by this patch, but does this function lack locking when modifying shared power and control registers? Concurrent accesses could corrupt the shared state: drivers/nvmem/lpc18xx_eeprom.c:lpc18xx_eeprom_gather_write() { ... lpc18xx_eeprom_writel(eeprom, LPC18XX_EEPROM_PWRDWN, LPC18XX_EEPROM_PWRDWN_NO); ... } > struct lpc18xx_eeprom_dev *eeprom =3D context; [ ... ] > diff --git a/drivers/nvmem/qfprom.c b/drivers/nvmem/qfprom.c > index 1de3435df116d..16b7f647a3f6f 100644 > --- a/drivers/nvmem/qfprom.c > +++ b/drivers/nvmem/qfprom.c [ ... ] > @@ -252,13 +252,13 @@ static int qfprom_enable_fuse_blowing(const struct = qfprom_priv *priv, > * > * Return: 0 or -err. > */ > -static int qfprom_reg_write(void *context, unsigned int reg, void *_val, > +static int qfprom_reg_write(void *context, unsigned int reg, const void = *_val, > size_t bytes) > { [Severity: High] This is a pre-existing issue, but does this function need synchronization? Modifying shared clocks and voltage states without locking could cause state corruption: drivers/nvmem/qfprom.c:qfprom_reg_write() { ... ret =3D qfprom_enable_fuse_blowing(priv, &old); ... } > struct qfprom_priv *priv =3D context; [ ... ] > diff --git a/drivers/nvmem/sprd-efuse.c b/drivers/nvmem/sprd-efuse.c > index 1a7e4e5d8b86c..f960fa8cb25cf 100644 > --- a/drivers/nvmem/sprd-efuse.c > +++ b/drivers/nvmem/sprd-efuse.c [ ... ] > @@ -192,7 +192,7 @@ static void sprd_efuse_set_prog_en(struct sprd_efuse = *efuse, bool en) > } > =20 > static int sprd_efuse_raw_prog(struct sprd_efuse *efuse, u32 blk, bool d= oub, > - bool lock, u32 *data) > + bool lock, const u32 *data) > { [Severity: High] This isn't a bug introduced by this patch, but does this unconditionally dereference the buffer as a u32 pointer? If the payload is smaller than 4 bytes, this could result in an out-of-bounds read: drivers/nvmem/sprd-efuse.c:sprd_efuse_raw_prog() { ... writel(*data, efuse->base + SPRD_EFUSE_MEM(blk)); ... } > u32 status; > int ret =3D 0; [ ... ] > @@ -321,7 +321,7 @@ static int sprd_efuse_read(void *context, u32 offset,= void *val, size_t bytes) > return ret; > } > =20 > -static int sprd_efuse_write(void *context, u32 offset, void *val, size_t= bytes) > +static int sprd_efuse_write(void *context, u32 offset, const void *val, = size_t bytes) > { [Severity: High] This is a pre-existing issue, but can this function sleep in atomic context? If sprd_efuse_lock() acquires a hardware spinlock, calling the sleepable clk_prepare_enable() could trigger a locking violation and soft lockup. This seems to affect both sprd_efuse_write() and sprd_efuse_read(): drivers/nvmem/sprd-efuse.c:sprd_efuse_write() { ret =3D sprd_efuse_lock(efuse); if (ret) return ret; =20 ret =3D clk_prepare_enable(efuse->clk); ... } Additionally, is the raw byte offset passed directly as a block index here? Targeting incorrect addresses could lead to hardware state corruption: drivers/nvmem/sprd-efuse.c:sprd_efuse_write() { ... ret =3D sprd_efuse_raw_prog(efuse, offset, blk_double, lock, val); ... } > struct sprd_efuse *efuse =3D context; [ ... ] > diff --git a/drivers/nvmem/stm32-bsec-optee-ta.c b/drivers/nvmem/stm32-bs= ec-optee-ta.c > index f89ce791dd12a..3184b976b1f91 100644 > --- a/drivers/nvmem/stm32-bsec-optee-ta.c > +++ b/drivers/nvmem/stm32-bsec-optee-ta.c [ ... ] > @@ -203,7 +203,7 @@ int stm32_bsec_optee_ta_read(struct tee_context *ctx,= unsigned int offset, > =20 > /* stm32_bsec_optee_ta_write() - nvmem write access using PTA client dri= ver */ > int stm32_bsec_optee_ta_write(struct tee_context *ctx, unsigned int lowe= r, > - unsigned int offset, void *buf, size_t bytes) > + unsigned int offset, const void *buf, size_t bytes) > { struct tee_shm *shm; [Severity: High] This is a pre-existing issue, but does this function leak the OP-TEE session if the alignment check fails? Returning directly bypasses cleanup: drivers/nvmem/stm32-bsec-optee-ta.c:stm32_bsec_optee_ta_write() { ret =3D stm32_bsec_ta_open_session(ctx, &session_id); if (ret) return ret; /* Allow only writing complete 32-bits aligned words */ if ((bytes % 4) || (offset % 4)) return -EINVAL; ... } [ ... ] > diff --git a/drivers/nvmem/zynqmp_nvmem.c b/drivers/nvmem/zynqmp_nvmem.c > index d297ff150dc02..54905a608157d 100644 > --- a/drivers/nvmem/zynqmp_nvmem.c > +++ b/drivers/nvmem/zynqmp_nvmem.c [ ... ] > @@ -183,7 +183,7 @@ static int zynqmp_nvmem_read(void *context, unsigned = int offset, void *val, size > } > =20 > static int zynqmp_nvmem_write(void *context, > - unsigned int offset, void *val, size_t bytes) > + unsigned int offset, const void *val, size_t bytes) > { [Severity: High] This isn't a bug introduced by this patch, but does zynqmp_efuse_access() bypass local bitmask validations for subsequent words during a multi-word write? The check seems to only happen on the first word: drivers/nvmem/zynqmp_nvmem.c:zynqmp_efuse_access() { if (pufflag =3D=3D 1 && flag =3D=3D EFUSE_WRITE) { memcpy(&value, val, sizeof(value)); if ((offset =3D=3D EFUSE_PUF_START_OFFSET || offset =3D=3D EFUSE_PUF_MID_OFFSET) && value & P_USER_0_64_UPPER_MASK) { ... } ... } > int pufflag =3D 0; --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260716142415.2871= 8-1-linkmauve@linkmauve.fr?part=3D2 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 7154FC4450A for ; Thu, 16 Jul 2026 14:37:33 +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:MIME-Version:Reply-To:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Message-Id:Date: References:In-Reply-To:Cc:To:Subject:From:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=RjxlXeRS5T4af6WOPoI53uoxEDhnA+eDsIUWSAE2U0w=; b=mHKNcoSC9Z+ZsV miPDgMwcmfvln0ku/lJNKAGsGJjUsTQCskaS55xvub3gHMQX4RJFYqcS3HdCxA/WTWG376tdn6cRh wQxwbarVnivij53yb6ZcZnmottN3u7B3JF/CMrvWpKNlY2dF/ip7XcbeDhpa57SWAnjSZmINQr09O JPmwU1yHUlNByag7q1tTGJByELLJRWSjUp6t59adcUqs5bdBe8iXexLEvt/4HRoECZVWYByt2euCW zumBDp9OlgqgCVJV4z/BH4QJuspxHLplP42JA+H1WYYF+OigYziLJaEMjTqjBIkaHcBF9IWDyJxgR gnU9FyKnGjf0+vx4bs9Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wkNDP-0000000HVyu-2ZJW; Thu, 16 Jul 2026 14:37:31 +0000 Received: from tor.source.kernel.org ([2600:3c04:e001:324:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wkNDO-0000000HVyY-1GQY for linux-amlogic@lists.infradead.org; Thu, 16 Jul 2026 14:37:30 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id AD7796001A; Thu, 16 Jul 2026 14:37:29 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 1353E1F000E9; Thu, 16 Jul 2026 14:37:29 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784212649; bh=4E6rSMFEq2ivH/yK4dEsmzDMGHSbcrhKuTc8PgYnfvM=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=X2tafqSP0NHHXJdBUgZDjGXTof8Zj6F/mxgiZrl5Ci2b+HQdoym1iVgK/S/X0vP8/ XeYhkuTFKjDTe2ZPaMVwPU6Z8uB16o4jtRoGphDZUWzWflgA0xS8j4cMu+lrdbGFsK qJfBNd5mph9j53z/CZXQBWdQZvuuuHFzQkhEDpsli8ecVv1mpbhReLOKNDVL8BMH+v 10lkbXXcD6YevPPO8wMJoWrG1yRHQyhni39Leo2zMDICfmYrFCxo4kRUubE1v5uw+B 8TO7HbyF5smMXNQQN9s8qzfgA2GBUi8zMepM3Be1qzUQoLQXzYlT8xkXb5bBlGFC2M vPhHgqC6EDklw== From: sashiko-bot@kernel.org Subject: Re: [PATCH v3 2/4] nvmem: make all reg_write callbacks take const void * To: "Link Mauve" Cc: Frank.Li@kernel.org, ojeda@kernel.org, imx@lists.linux.dev, neil.armstrong@linaro.org, linux-amlogic@lists.infradead.org In-Reply-To: <20260716142415.28718-3-linkmauve@linkmauve.fr> References: <20260716142415.28718-1-linkmauve@linkmauve.fr> <20260716142415.28718-3-linkmauve@linkmauve.fr> Date: Thu, 16 Jul 2026 14:37:28 +0000 Message-Id: <20260716143729.1353E1F000E9@smtp.kernel.org> X-BeenThere: linux-amlogic@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-amlogic" Errors-To: linux-amlogic-bounces+linux-amlogic=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg NyBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6CgpOZXcgaXNzdWVzOgotIFtNZWRpdW1d IEluY29tcGxldGUgQVBJIG1pZ3JhdGlvbiBsZWF2aW5nIGRlcHJlY2F0ZWQgcmVnX3dyaXRlIGNh bGxiYWNrcyBhY3RpdmUKClByZS1leGlzdGluZyBpc3N1ZXM6Ci0gW0hpZ2hdIGtDRkkgcGFuaWMg ZHVlIHRvIGZ1bmN0aW9uIHBvaW50ZXIgY2FzdCBvZiByZWdtYXBfYnVsa193cml0ZQotIFtIaWdo XSBIYXJkd2FyZSBzdGF0ZSBjb3JydXB0aW9uIGFuZCBvdXQtb2YtYm91bmRzIHJlYWQgaW4gc3By ZF9lZnVzZV93cml0ZQotIFtIaWdoXSBPUC1URUUgc2Vzc2lvbiByZXNvdXJjZSBsZWFrIG9uIGFs aWdubWVudCBjaGVjayBmYWlsdXJlCi0gW0hpZ2hdIE1pc3NpbmcgbG9ja2luZyBsZWFkcyB0byBz dGF0ZSBjb3JydXB0aW9uIGFjcm9zcyBtdWx0aXBsZSBiYWNrZW5kIGRyaXZlcnMKLSBbSGlnaF0g U2xlZXBpbmcgaW4gYXRvbWljIGNvbnRleHQgd2l0aGluIHNwcmQtZWZ1c2UgZHJpdmVyCi0gW0hp Z2hdIFNlY3VyaXR5IGNoZWNrIGJ5cGFzcyBkdXJpbmcgbXVsdGktd29yZCB3cml0ZXMgaW4genlu cW1wX252bWVtX3dyaXRlCi0tCgotLS0gUGF0Y2ggWzJdOiBbUEFUQ0ggdjMgMi80XSBudm1lbTog bWFrZSBhbGwgcmVnX3dyaXRlIGNhbGxiYWNrcyB0YWtlIGNvbnN0IHZvaWQgKiAtLS0KY29tbWl0 IGVjMjAzZWRhMDVmMTI2Y2JlNzc3ZTExNTgwOTVmYjllMzk0OTk3OTYKQXV0aG9yOiBMaW5rIE1h dXZlIDxsaW5rbWF1dmVAbGlua21hdXZlLmZyPgoKbnZtZW06IG1ha2UgYWxsIHJlZ193cml0ZSBj YWxsYmFja3MgdGFrZSBjb25zdCB2b2lkICoKClRoaXMgcGF0Y2ggdXBkYXRlcyB2YXJpb3VzIG52 bWVtIGRyaXZlcnMgdG8gdXNlIHRoZSBuZXcgcmVnX3dyaXRlX2NvbnN0CmNhbGxiYWNrIGluc3Rl YWQgb2YgcmVnX3dyaXRlLCBtYXRjaGluZyBhIHJlY2VudCBBUEkgY2hhbmdlIHRoYXQgcGFzc2Vz CmltbXV0YWJsZSBkYXRhLgoKPiBUaGUgcHJldmlvdXMgY29tbWl0IHN3aXRjaGVkIGZyb20gYSBw b2ludGVyIHRvIG11dGFibGUgZGF0YSB0byBhIHBvaW50ZXIKPiB0byBpbW11dGFibGUgZGF0YSwg c28gbGV04oCZcyBmaXggYWxsIHVzZXJzIG9mIHRoaXMgQVBJLgoKW1NldmVyaXR5OiBNZWRpdW1d CkFyZSB0aGVyZSBzb21lIGRyaXZlcnMgbWlzc2luZyBmcm9tIHRoaXMgdXBkYXRlPyBJdCBhcHBl YXJzIHNldmVyYWwgbnZtZW0KYmFja2VuZCBkcml2ZXJzIGFyZSBzdGlsbCBhc3NpZ25pbmcgdGhl IGRlcHJlY2F0ZWQgcmVnX3dyaXRlIGNhbGxiYWNrLAp3aGljaCBsZWF2ZXMgdGhlIG1pZ3JhdGlv biBpbmNvbXBsZXRlOgoKZHJpdmVycy9udm1lbS9hdDI0LmM6YXQyNF9wcm9iZSgpIHsKICAgIG52 bWVtX2NvbmZpZy5yZWdfd3JpdGUgPSBhdDI0X3dyaXRlOwp9Cgpkcml2ZXJzL252bWVtL2F0MjUu YzphdDI1X3Byb2JlKCkgewogICAgYXQyNS0+bnZtZW1fY29uZmlnLnJlZ193cml0ZSA9IGF0MjVf ZWVfd3JpdGU7Cn0KCmRyaXZlcnMvbnZtZW0vZWVwcm9tXzkzeHg0Ni5jOmVlcHJvbV85M3h4NDZf cHJvYmUoKSB7CiAgICBlZGV2LT5udm1lbV9jb25maWcucmVnX3dyaXRlID0gZWVwcm9tXzkzeHg0 Nl93cml0ZTsKfQoKZHJpdmVycy9udm1lbS9tMjRsci5jOm0yNGxyX3Byb2JlKCkgewogICAgbnZt ZW1fY29uZi5yZWdfd3JpdGUgPSBtMjRscl9udm1lbV93cml0ZTsKfQoKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9udm1lbS9hcHBsZS1zcG1pLW52bWVtLmMgYi9kcml2ZXJzL252bWVtL2FwcGxlLXNw bWktbnZtZW0uYwo+IGluZGV4IDg4NjE0MDA1ZDVjZTEuLmNiZjI1YzUzZDA0OGQgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9udm1lbS9hcHBsZS1zcG1pLW52bWVtLmMKPiArKysgYi9kcml2ZXJzL252 bWVtL2FwcGxlLXNwbWktbnZtZW0uYwoKWyAuLi4gXQoKPiBAQCAtMjksNyArMjksNyBAQCBzdGF0 aWMgaW50IGFwcGxlX3NwbWlfbnZtZW1fcHJvYmUoc3RydWN0IHNwbWlfZGV2aWNlICpzZGV2KQo+ ICAJCS5zdHJpZGUgPSAxLAo+ICAJCS5zaXplID0gMHhmZmZmLAo+ICAJCS5yZWdfcmVhZCA9ICh2 b2lkICopcmVnbWFwX2J1bGtfcmVhZCwKPiAtCQkucmVnX3dyaXRlID0gKHZvaWQgKilyZWdtYXBf YnVsa193cml0ZSwKPiArCQkucmVnX3dyaXRlX2NvbnN0ID0gKHZvaWQgKilyZWdtYXBfYnVsa193 cml0ZSwKCltTZXZlcml0eTogSGlnaF0KVGhpcyBpcyBhIHByZS1leGlzdGluZyBpc3N1ZSwgYnV0 IGRvZXMgY2FzdGluZyByZWdtYXBfYnVsa193cml0ZSB0byB2b2lkICoKdHJpZ2dlciBhIGtDRkkg a2VybmVsIHBhbmljPyBUaGUgYWN0dWFsIHNpZ25hdHVyZSBvZiByZWdtYXBfYnVsa193cml0ZQpk b2Vzbid0IG1hdGNoIHJlZ193cml0ZV9jb25zdCwgc28gY2FsbGluZyBpdCB2aWEgdGhpcyBmdW5j dGlvbiBwb2ludGVyCmNvdWxkIGNhdXNlIGEgY29udHJvbC1mbG93IGludGVncml0eSB0cmFwIHVw b24gZXhlY3V0aW9uLgoKPiAgCX07CgpbIC4uLiBdCgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL252 bWVtL2JjbS1vY290cC5jIGIvZHJpdmVycy9udm1lbS9iY20tb2NvdHAuYwo+IGluZGV4IDI0OTBm NDRjYWE0MDkuLjAyYWRmZDc4N2RlODUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9udm1lbS9iY20t b2NvdHAuYwo+ICsrKyBiL2RyaXZlcnMvbnZtZW0vYmNtLW9jb3RwLmMKClsgLi4uIF0KCj4gQEAg LTE3OSwxMSArMTc5LDExIEBAIHN0YXRpYyBpbnQgYmNtX290cGNfcmVhZCh2b2lkICpjb250ZXh0 LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LCB2b2lkICp2YWwsCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAK PiAtc3RhdGljIGludCBiY21fb3RwY193cml0ZSh2b2lkICpjb250ZXh0LCB1bnNpZ25lZCBpbnQg b2Zmc2V0LCB2b2lkICp2YWwsCj4gLQlzaXplX3QgYnl0ZXMpCj4gK3N0YXRpYyBpbnQgYmNtX290 cGNfd3JpdGUodm9pZCAqY29udGV4dCwgdW5zaWduZWQgaW50IG9mZnNldCwgY29uc3Qgdm9pZCAq dmFsLAo+ICsJCQkgIHNpemVfdCBieXRlcykKPiAgewoKW1NldmVyaXR5OiBIaWdoXQpUaGlzIGlz IGEgcHJlLWV4aXN0aW5nIGlzc3VlLCBidXQgZG9lcyB0aGlzIGZ1bmN0aW9uIGxhY2sgbG9ja2lu Zz8KTW9kaWZ5aW5nIHNoYXJlZCBjb21tYW5kIGFuZCBhZGRyZXNzIHJlZ2lzdGVycyBjb25jdXJy ZW50bHkgd2l0aG91dCBhIGxvY2sKY291bGQgY29ycnVwdCB0aGUgc2hhcmVkIHN0YXRlIG1hY2hp bmU6Cgpkcml2ZXJzL252bWVtL2JjbS1vY290cC5jOmJjbV9vdHBjX3dyaXRlKCkgewogICAgZm9y IChieXRlc193cml0dGVuID0gMDsgYnl0ZXNfd3JpdHRlbiA8IGJ5dGVzOykgewogICAgICAgIHNl dF9jb21tYW5kKHByaXYtPmJhc2UsIE9UUENfQ01EX1BST0dSQU0pOwogICAgICAgIHNldF9jcHVf YWRkcmVzcyhwcml2LT5iYXNlLCBhZGRyZXNzKyspOwogICAgICAgIC4uLgp9Cgo+ICAJc3RydWN0 IG90cGNfcHJpdiAqcHJpdiA9IGNvbnRleHQ7CgpbIC4uLiBdCgo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL252bWVtL2xhbjk2NjItb3RwYy5jIGIvZHJpdmVycy9udm1lbS9sYW45NjYyLW90cGMuYwo+ IGluZGV4IDYyZDFkNjM4MWJmODguLmY1ODZhZTRjZDEyNmIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9udm1lbS9sYW45NjYyLW90cGMuYwo+ICsrKyBiL2RyaXZlcnMvbnZtZW0vbGFuOTY2Mi1vdHBj LmMKClsgLi4uIF0KCj4gQEAgLTEzOSwxMCArMTM5LDEwIEBAIHN0YXRpYyBpbnQgbGFuOTY2Ml9v dHBfcmVhZCh2b2lkICpjb250ZXh0LCB1bnNpZ25lZCBpbnQgb2Zmc2V0LAo+ICB9Cj4gIAo+ICBz dGF0aWMgaW50IGxhbjk2NjJfb3RwX3dyaXRlKHZvaWQgKmNvbnRleHQsIHVuc2lnbmVkIGludCBv ZmZzZXQsCj4gLQkJCSAgICAgdm9pZCAqX3ZhbCwgc2l6ZV90IGJ5dGVzKQo+ICsJCQkgICAgIGNv bnN0IHZvaWQgKl92YWwsIHNpemVfdCBieXRlcykKPiAgewoKW1NldmVyaXR5OiBIaWdoXQpUaGlz IGlzIGEgcHJlLWV4aXN0aW5nIGlzc3VlLCBidXQgZG9lcyB0aGlzIGZ1bmN0aW9uIHBlcmZvcm0g dW5wcm90ZWN0ZWQKcmVhZC1tb2RpZnktd3JpdGUgb3BlcmF0aW9ucyBvbiBPVFAgYnl0ZXM/IE1v ZGlmeWluZyB0aGUgT1RQIGJ5dGVzIHdpdGhvdXQKbG9ja2luZyBjb3VsZCBsZWFkIHRvIGRhdGEg Y29ycnVwdGlvbiBpbiBjb25jdXJyZW50IGV4ZWN1dGlvbnM6Cgpkcml2ZXJzL252bWVtL2xhbjk2 NjItb3RwYy5jOmxhbjk2NjJfb3RwX3dyaXRlKCkgewogICAgZm9yIChpID0gMDsgaSA8IGJ5dGVz OyBpKyspIHsKICAgICAgICBpZiAodmFsW2ldKSB7CiAgICAgICAgICAgIHJjID0gbGFuOTY2Ml9v dHBfcmVhZF9ieXRlKG90cCwgb2Zmc2V0ICsgaSwgJmRhdGEpOwogICAgICAgICAgICAuLi4KICAg ICAgICAgICAgcmMgPSBsYW45NjYyX290cF93cml0ZV9ieXRlKG90cCwgb2Zmc2V0ICsgaSwgbmV3 ZGF0YSk7CiAgICAgICAgfQogICAgfQp9Cgo+ICAJc3RydWN0IGxhbjk2NjJfb3RwICpvdHAgPSBj b250ZXh0OwoKWyAuLi4gXQoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9udm1lbS9scGMxOHh4X2Vl cHJvbS5jIGIvZHJpdmVycy9udm1lbS9scGMxOHh4X2VlcHJvbS5jCj4gaW5kZXggNTA0MTU1ZTMw YmFiMi4uNzhhMzVlZjA5NWZiZCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL252bWVtL2xwYzE4eHhf ZWVwcm9tLmMKPiArKysgYi9kcml2ZXJzL252bWVtL2xwYzE4eHhfZWVwcm9tLmMKClsgLi4uIF0K Cj4gQEAgLTg3LDcgKzg3LDcgQEAgc3RhdGljIGludCBscGMxOHh4X2VlcHJvbV9idXN5d2FpdF91 bnRpbF9wcm9nKHN0cnVjdCBscGMxOHh4X2VlcHJvbV9kZXYgKmVlcHJvbSkKPiAgfQo+ICAKPiAg c3RhdGljIGludCBscGMxOHh4X2VlcHJvbV9nYXRoZXJfd3JpdGUodm9pZCAqY29udGV4dCwgdW5z aWduZWQgaW50IHJlZywKPiAtCQkJCSAgICAgICB2b2lkICp2YWwsIHNpemVfdCBieXRlcykKPiAr CQkJCSAgICAgICBjb25zdCB2b2lkICp2YWwsIHNpemVfdCBieXRlcykKPiAgewoKW1NldmVyaXR5 OiBIaWdoXQpUaGlzIGlzbid0IGEgYnVnIGludHJvZHVjZWQgYnkgdGhpcyBwYXRjaCwgYnV0IGRv ZXMgdGhpcyBmdW5jdGlvbiBsYWNrCmxvY2tpbmcgd2hlbiBtb2RpZnlpbmcgc2hhcmVkIHBvd2Vy IGFuZCBjb250cm9sIHJlZ2lzdGVycz8gQ29uY3VycmVudAphY2Nlc3NlcyBjb3VsZCBjb3JydXB0 IHRoZSBzaGFyZWQgc3RhdGU6Cgpkcml2ZXJzL252bWVtL2xwYzE4eHhfZWVwcm9tLmM6bHBjMTh4 eF9lZXByb21fZ2F0aGVyX3dyaXRlKCkgewogICAgLi4uCiAgICBscGMxOHh4X2VlcHJvbV93cml0 ZWwoZWVwcm9tLCBMUEMxOFhYX0VFUFJPTV9QV1JEV04sCiAgICAgICAgICAgICAgICAgICAgICAg ICAgTFBDMThYWF9FRVBST01fUFdSRFdOX05PKTsKICAgIC4uLgp9Cgo+ICAJc3RydWN0IGxwYzE4 eHhfZWVwcm9tX2RldiAqZWVwcm9tID0gY29udGV4dDsKClsgLi4uIF0KCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvbnZtZW0vcWZwcm9tLmMgYi9kcml2ZXJzL252bWVtL3FmcHJvbS5jCj4gaW5kZXgg MWRlMzQzNWRmMTE2ZC4uMTZiN2Y2NDdhM2Y2ZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL252bWVt L3FmcHJvbS5jCj4gKysrIGIvZHJpdmVycy9udm1lbS9xZnByb20uYwoKWyAuLi4gXQoKPiBAQCAt MjUyLDEzICsyNTIsMTMgQEAgc3RhdGljIGludCBxZnByb21fZW5hYmxlX2Z1c2VfYmxvd2luZyhj b25zdCBzdHJ1Y3QgcWZwcm9tX3ByaXYgKnByaXYsCj4gICAqCj4gICAqIFJldHVybjogMCBvciAt ZXJyLgo+ICAgKi8KPiAtc3RhdGljIGludCBxZnByb21fcmVnX3dyaXRlKHZvaWQgKmNvbnRleHQs IHVuc2lnbmVkIGludCByZWcsIHZvaWQgKl92YWwsCj4gK3N0YXRpYyBpbnQgcWZwcm9tX3JlZ193 cml0ZSh2b2lkICpjb250ZXh0LCB1bnNpZ25lZCBpbnQgcmVnLCBjb25zdCB2b2lkICpfdmFsLAo+ ICAJCQkgICAgc2l6ZV90IGJ5dGVzKQo+ICB7CgpbU2V2ZXJpdHk6IEhpZ2hdClRoaXMgaXMgYSBw cmUtZXhpc3RpbmcgaXNzdWUsIGJ1dCBkb2VzIHRoaXMgZnVuY3Rpb24gbmVlZCBzeW5jaHJvbml6 YXRpb24/Ck1vZGlmeWluZyBzaGFyZWQgY2xvY2tzIGFuZCB2b2x0YWdlIHN0YXRlcyB3aXRob3V0 IGxvY2tpbmcgY291bGQgY2F1c2UKc3RhdGUgY29ycnVwdGlvbjoKCmRyaXZlcnMvbnZtZW0vcWZw cm9tLmM6cWZwcm9tX3JlZ193cml0ZSgpIHsKICAgIC4uLgogICAgcmV0ID0gcWZwcm9tX2VuYWJs ZV9mdXNlX2Jsb3dpbmcocHJpdiwgJm9sZCk7CiAgICAuLi4KfQoKPiAgCXN0cnVjdCBxZnByb21f cHJpdiAqcHJpdiA9IGNvbnRleHQ7CgpbIC4uLiBdCgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL252 bWVtL3NwcmQtZWZ1c2UuYyBiL2RyaXZlcnMvbnZtZW0vc3ByZC1lZnVzZS5jCj4gaW5kZXggMWE3 ZTRlNWQ4Yjg2Yy4uZjk2MGZhOGNiMjVjZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL252bWVtL3Nw cmQtZWZ1c2UuYwo+ICsrKyBiL2RyaXZlcnMvbnZtZW0vc3ByZC1lZnVzZS5jCgpbIC4uLiBdCgo+ IEBAIC0xOTIsNyArMTkyLDcgQEAgc3RhdGljIHZvaWQgc3ByZF9lZnVzZV9zZXRfcHJvZ19lbihz dHJ1Y3Qgc3ByZF9lZnVzZSAqZWZ1c2UsIGJvb2wgZW4pCj4gIH0KPiAgCj4gIHN0YXRpYyBpbnQg c3ByZF9lZnVzZV9yYXdfcHJvZyhzdHJ1Y3Qgc3ByZF9lZnVzZSAqZWZ1c2UsIHUzMiBibGssIGJv b2wgZG91YiwKPiAtCQkJICAgICAgIGJvb2wgbG9jaywgdTMyICpkYXRhKQo+ICsJCQkgICAgICAg Ym9vbCBsb2NrLCBjb25zdCB1MzIgKmRhdGEpCj4gIHsKCltTZXZlcml0eTogSGlnaF0KVGhpcyBp c24ndCBhIGJ1ZyBpbnRyb2R1Y2VkIGJ5IHRoaXMgcGF0Y2gsIGJ1dCBkb2VzIHRoaXMgdW5jb25k aXRpb25hbGx5CmRlcmVmZXJlbmNlIHRoZSBidWZmZXIgYXMgYSB1MzIgcG9pbnRlcj8gSWYgdGhl IHBheWxvYWQgaXMgc21hbGxlciB0aGFuIDQKYnl0ZXMsIHRoaXMgY291bGQgcmVzdWx0IGluIGFu IG91dC1vZi1ib3VuZHMgcmVhZDoKCmRyaXZlcnMvbnZtZW0vc3ByZC1lZnVzZS5jOnNwcmRfZWZ1 c2VfcmF3X3Byb2coKSB7CiAgICAuLi4KICAgIHdyaXRlbCgqZGF0YSwgZWZ1c2UtPmJhc2UgKyBT UFJEX0VGVVNFX01FTShibGspKTsKICAgIC4uLgp9Cgo+ICAJdTMyIHN0YXR1czsKPiAgCWludCBy ZXQgPSAwOwoKWyAuLi4gXQoKPiBAQCAtMzIxLDcgKzMyMSw3IEBAIHN0YXRpYyBpbnQgc3ByZF9l ZnVzZV9yZWFkKHZvaWQgKmNvbnRleHQsIHUzMiBvZmZzZXQsIHZvaWQgKnZhbCwgc2l6ZV90IGJ5 dGVzKQo+ICAJcmV0dXJuIHJldDsKPiAgfQo+ICAKPiAtc3RhdGljIGludCBzcHJkX2VmdXNlX3dy aXRlKHZvaWQgKmNvbnRleHQsIHUzMiBvZmZzZXQsIHZvaWQgKnZhbCwgc2l6ZV90IGJ5dGVzKQo+ ICtzdGF0aWMgaW50IHNwcmRfZWZ1c2Vfd3JpdGUodm9pZCAqY29udGV4dCwgdTMyIG9mZnNldCwg Y29uc3Qgdm9pZCAqdmFsLCBzaXplX3QgYnl0ZXMpCj4gIHsKCltTZXZlcml0eTogSGlnaF0KVGhp cyBpcyBhIHByZS1leGlzdGluZyBpc3N1ZSwgYnV0IGNhbiB0aGlzIGZ1bmN0aW9uIHNsZWVwIGlu IGF0b21pYyBjb250ZXh0PwpJZiBzcHJkX2VmdXNlX2xvY2soKSBhY3F1aXJlcyBhIGhhcmR3YXJl IHNwaW5sb2NrLCBjYWxsaW5nIHRoZSBzbGVlcGFibGUKY2xrX3ByZXBhcmVfZW5hYmxlKCkgY291 bGQgdHJpZ2dlciBhIGxvY2tpbmcgdmlvbGF0aW9uIGFuZCBzb2Z0IGxvY2t1cC4KVGhpcyBzZWVt cyB0byBhZmZlY3QgYm90aCBzcHJkX2VmdXNlX3dyaXRlKCkgYW5kIHNwcmRfZWZ1c2VfcmVhZCgp OgoKZHJpdmVycy9udm1lbS9zcHJkLWVmdXNlLmM6c3ByZF9lZnVzZV93cml0ZSgpIHsKICAgIHJl dCA9IHNwcmRfZWZ1c2VfbG9jayhlZnVzZSk7CiAgICBpZiAocmV0KQogICAgICAgIHJldHVybiBy ZXQ7CiAgICAKICAgIHJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShlZnVzZS0+Y2xrKTsKICAgIC4u Lgp9CgpBZGRpdGlvbmFsbHksIGlzIHRoZSByYXcgYnl0ZSBvZmZzZXQgcGFzc2VkIGRpcmVjdGx5 IGFzIGEgYmxvY2sgaW5kZXggaGVyZT8KVGFyZ2V0aW5nIGluY29ycmVjdCBhZGRyZXNzZXMgY291 bGQgbGVhZCB0byBoYXJkd2FyZSBzdGF0ZSBjb3JydXB0aW9uOgoKZHJpdmVycy9udm1lbS9zcHJk LWVmdXNlLmM6c3ByZF9lZnVzZV93cml0ZSgpIHsKICAgIC4uLgogICAgcmV0ID0gc3ByZF9lZnVz ZV9yYXdfcHJvZyhlZnVzZSwgb2Zmc2V0LCBibGtfZG91YmxlLCBsb2NrLCB2YWwpOwogICAgLi4u Cn0KCj4gIAlzdHJ1Y3Qgc3ByZF9lZnVzZSAqZWZ1c2UgPSBjb250ZXh0OwoKWyAuLi4gXQoKPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9udm1lbS9zdG0zMi1ic2VjLW9wdGVlLXRhLmMgYi9kcml2ZXJz L252bWVtL3N0bTMyLWJzZWMtb3B0ZWUtdGEuYwo+IGluZGV4IGY4OWNlNzkxZGQxMmEuLjMxODRi OTc2YjFmOTEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9udm1lbS9zdG0zMi1ic2VjLW9wdGVlLXRh LmMKPiArKysgYi9kcml2ZXJzL252bWVtL3N0bTMyLWJzZWMtb3B0ZWUtdGEuYwoKWyAuLi4gXQoK PiBAQCAtMjAzLDcgKzIwMyw3IEBAIGludCBzdG0zMl9ic2VjX29wdGVlX3RhX3JlYWQoc3RydWN0 IHRlZV9jb250ZXh0ICpjdHgsIHVuc2lnbmVkIGludCBvZmZzZXQsCj4gIAo+ICAvKiBzdG0zMl9i c2VjX29wdGVlX3RhX3dyaXRlKCkgLSBudm1lbSB3cml0ZSBhY2Nlc3MgdXNpbmcgUFRBIGNsaWVu dCBkcml2ZXIgKi8KPiAgaW50IHN0bTMyX2JzZWNfb3B0ZWVfdGFfd3JpdGUoc3RydWN0IHRlZV9j b250ZXh0ICpjdHgsIHVuc2lnbmVkIGludCBsb3dlciwKPiAtCQkJICAgICAgdW5zaWduZWQgaW50 IG9mZnNldCwgdm9pZCAqYnVmLCBzaXplX3QgYnl0ZXMpCj4gKwkJCSAgICAgIHVuc2lnbmVkIGlu dCBvZmZzZXQsIGNvbnN0IHZvaWQgKmJ1Ziwgc2l6ZV90IGJ5dGVzKQo+ICB7CXN0cnVjdCB0ZWVf c2htICpzaG07CgpbU2V2ZXJpdHk6IEhpZ2hdClRoaXMgaXMgYSBwcmUtZXhpc3RpbmcgaXNzdWUs IGJ1dCBkb2VzIHRoaXMgZnVuY3Rpb24gbGVhayB0aGUgT1AtVEVFCnNlc3Npb24gaWYgdGhlIGFs aWdubWVudCBjaGVjayBmYWlscz8gUmV0dXJuaW5nIGRpcmVjdGx5IGJ5cGFzc2VzIGNsZWFudXA6 Cgpkcml2ZXJzL252bWVtL3N0bTMyLWJzZWMtb3B0ZWUtdGEuYzpzdG0zMl9ic2VjX29wdGVlX3Rh X3dyaXRlKCkgewogICAgcmV0ID0gc3RtMzJfYnNlY190YV9vcGVuX3Nlc3Npb24oY3R4LCAmc2Vz c2lvbl9pZCk7CiAgICBpZiAocmV0KQogICAgICAgIHJldHVybiByZXQ7CgogICAgLyogQWxsb3cg b25seSB3cml0aW5nIGNvbXBsZXRlIDMyLWJpdHMgYWxpZ25lZCB3b3JkcyAqLwogICAgaWYgKChi eXRlcyAlIDQpIHx8IChvZmZzZXQgJSA0KSkKICAgICAgICByZXR1cm4gLUVJTlZBTDsKICAgIC4u Lgp9CgpbIC4uLiBdCgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL252bWVtL3p5bnFtcF9udm1lbS5j IGIvZHJpdmVycy9udm1lbS96eW5xbXBfbnZtZW0uYwo+IGluZGV4IGQyOTdmZjE1MGRjMDIuLjU0 OTA1YTYwODE1N2QgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9udm1lbS96eW5xbXBfbnZtZW0uYwo+ ICsrKyBiL2RyaXZlcnMvbnZtZW0venlucW1wX252bWVtLmMKClsgLi4uIF0KCj4gQEAgLTE4Myw3 ICsxODMsNyBAQCBzdGF0aWMgaW50IHp5bnFtcF9udm1lbV9yZWFkKHZvaWQgKmNvbnRleHQsIHVu c2lnbmVkIGludCBvZmZzZXQsIHZvaWQgKnZhbCwgc2l6ZQo+ICB9Cj4gIAo+ICBzdGF0aWMgaW50 IHp5bnFtcF9udm1lbV93cml0ZSh2b2lkICpjb250ZXh0LAo+IC0JCQkgICAgICB1bnNpZ25lZCBp bnQgb2Zmc2V0LCB2b2lkICp2YWwsIHNpemVfdCBieXRlcykKPiArCQkJICAgICAgdW5zaWduZWQg aW50IG9mZnNldCwgY29uc3Qgdm9pZCAqdmFsLCBzaXplX3QgYnl0ZXMpCj4gIHsKCltTZXZlcml0 eTogSGlnaF0KVGhpcyBpc24ndCBhIGJ1ZyBpbnRyb2R1Y2VkIGJ5IHRoaXMgcGF0Y2gsIGJ1dCBk b2VzIHp5bnFtcF9lZnVzZV9hY2Nlc3MoKQpieXBhc3MgbG9jYWwgYml0bWFzayB2YWxpZGF0aW9u cyBmb3Igc3Vic2VxdWVudCB3b3JkcyBkdXJpbmcgYSBtdWx0aS13b3JkCndyaXRlPyBUaGUgY2hl Y2sgc2VlbXMgdG8gb25seSBoYXBwZW4gb24gdGhlIGZpcnN0IHdvcmQ6Cgpkcml2ZXJzL252bWVt L3p5bnFtcF9udm1lbS5jOnp5bnFtcF9lZnVzZV9hY2Nlc3MoKSB7CiAgICBpZiAocHVmZmxhZyA9 PSAxICYmIGZsYWcgPT0gRUZVU0VfV1JJVEUpIHsKICAgICAgICBtZW1jcHkoJnZhbHVlLCB2YWws IHNpemVvZih2YWx1ZSkpOwogICAgICAgIGlmICgob2Zmc2V0ID09IEVGVVNFX1BVRl9TVEFSVF9P RkZTRVQgfHwKICAgICAgICAgICAgIG9mZnNldCA9PSBFRlVTRV9QVUZfTUlEX09GRlNFVCkgJiYK ICAgICAgICAgICAgdmFsdWUgJiBQX1VTRVJfMF82NF9VUFBFUl9NQVNLKSB7CiAgICAgICAgICAg IC4uLgogICAgICAgIH0KICAgIC4uLgp9Cgo+ICAJaW50IHB1ZmZsYWcgPSAwOwoKLS0gClNhc2hp a28gQUkgcmV2aWV3IMK3IGh0dHBzOi8vc2FzaGlrby5kZXYvIy9wYXRjaHNldC8yMDI2MDcxNjE0 MjQxNS4yODcxOC0xLWxpbmttYXV2ZUBsaW5rbWF1dmUuZnI/cGFydD0yCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hbWxvZ2ljIG1haWxpbmcg bGlzdApsaW51eC1hbWxvZ2ljQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJh ZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hbWxvZ2ljCg==