From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.1 (2015-04-28) on archive.lwn.net X-Spam-Level: X-Spam-Status: No, score=-5.7 required=5.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,RCVD_IN_DNSWL_HI autolearn=unavailable autolearn_force=no version=3.4.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by archive.lwn.net (Postfix) with ESMTP id BDC427D87A for ; Wed, 5 Sep 2018 21:49:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727750AbeIFCVY (ORCPT ); Wed, 5 Sep 2018 22:21:24 -0400 Received: from mail-lf1-f66.google.com ([209.85.167.66]:34802 "EHLO mail-lf1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727257AbeIFCVX (ORCPT ); Wed, 5 Sep 2018 22:21:23 -0400 Received: by mail-lf1-f66.google.com with SMTP id c29-v6so7323069lfj.1; Wed, 05 Sep 2018 14:49:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=pjB1F9VFMoVRKevm18azlwRknOzqwsiDaYhNHxorPLU=; b=UvDtY9Ld3JhnUEFv+zq+seM5QouRH6iOxVLYTQRj191a5BteCjcgmyMqopLeXwaayR oMv7V6jhC7NSBUUCZK4xZNcfOZgoOmbwr+rJ/xkl5X17uRRUaazQp/vRC+5zA1n33rI/ +Lp1CBdYW864i23grow5ckQbs0FyCukxn7/P0gD6HtB447zE6sJqFdO/k47fo0KnU84R br2clDj5xkPVB2u6Uc19mAXgeEZxYDwtNh9I2x4cUCXgKkvTVbNN81Xy07xAVymrhKm3 zH9jyeW1oMas79Wyt0RLj+2AlhHzgKrJdatW5QDjpgPLn6xkuoGTF0/oTt6x5mVNo2DN MVgg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=pjB1F9VFMoVRKevm18azlwRknOzqwsiDaYhNHxorPLU=; b=SJhi21grBfOfCNXy3SO4UUwUgo0cqlMZqM4eRqN43Sgf22pU+4ZmWAeHPzFG3iTtOU IyNMMxpTbMlgxwYAcV1wMzsGe6DjQVoZR8Wh1YNsxo5YTKL8VGLJAwt//I+br9CqVIKk 8nHM/+wV8sDNRfLm7OEjyTaAmOTQ9Mb5BxkuoMnJqDBsCQ95ZA2q2PtRB6Aczm3i7XP4 /asJSi2O65nLt1PU8BCxNvw6BjxEXRWXRV9WKkSddtO/D6CsqzBtsnCI1DEtFjNqgoSN VVrpRj1zxuh+42UdCeyWmFq4f68BhcHskg7cD8WnJobQ7oZfClWn8DBmV5Fp4TRJTLK6 r07A== X-Gm-Message-State: APzg51C0hbE6OCfw0/eHI3boXFnUKaHrJl+ZDFXNO7VWEaa0ZjUMx+gX kkah8WPgG6wxmLNDPonXKik= X-Google-Smtp-Source: ANB0Vdb8CzSggQiWeHhoYFlb8q7vQKai5ZpLMQOjGlHGV3S0mY8mfue9Crzr5GvzRvNUeQtLnMKYhA== X-Received: by 2002:a19:134f:: with SMTP id j76-v6mr24160085lfi.61.1536184151346; Wed, 05 Sep 2018 14:49:11 -0700 (PDT) Received: from z50.lan (93-181-165-181.internetia.net.pl. [93.181.165.181]) by smtp.gmail.com with ESMTPSA id i2-v6sm491873lfa.78.2018.09.05.14.49.09 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 05 Sep 2018 14:49:10 -0700 (PDT) From: Janusz Krzysztofik To: Linus Walleij Cc: Jonathan Corbet , Miguel Ojeda Sandonis , Peter Korsgaard , Peter Rosin , Ulf Hansson , Andrew Lunn , Florian Fainelli , "David S. Miller" , Dominik Brodowski , Greg Kroah-Hartman , Kishon Vijay Abraham I , Lars-Peter Clausen , Michael Hennerich , Jonathan Cameron , Hartmut Knaack , Peter Meerwald-Stadler , Jiri Slaby , Willy Tarreau , Geert Uytterhoeven , Sebastien Bourdelin , Lukas Wunner , Rojhalat Ibrahim , Russell King , Tony Lindgren , Yegor Yefremov , =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= , Janusz Krzysztofik , linux-doc@vger.kernel.org, linux-i2c@vger.kernel.org, linux-mmc@vger.kernel.org, netdev@vger.kernel.org, linux-iio@vger.kernel.org, devel@driverdev.osuosl.org, linux-serial@vger.kernel.org, linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v8 1/4] gpiolib: Pass bitmaps, not integer arrays, to get/set array Date: Wed, 5 Sep 2018 23:50:05 +0200 Message-Id: <20180905215008.1649-2-jmkrzyszt@gmail.com> X-Mailer: git-send-email 2.16.4 In-Reply-To: <20180905215008.1649-1-jmkrzyszt@gmail.com> References: <20180902120144.6855-1-jmkrzyszt@gmail.com> <20180905215008.1649-1-jmkrzyszt@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-doc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-doc@vger.kernel.org Most users of get/set array functions iterate consecutive bits of data, usually a single integer, while processing array of results obtained from, or building an array of values to be passed to those functions. Save time wasted on those iterations by changing the functions' API to accept bitmaps. All current users are updated as well. More benefits from the change are expected as soon as planned support for accepting/passing those bitmaps directly from/to respective GPIO chip callbacks if applicable is implemented. Cc: Jonathan Corbet Cc: Miguel Ojeda Sandonis Cc: Sebastien Bourdelin Cc: Lukas Wunner Cc: Peter Korsgaard Cc: Peter Rosin Cc: Andrew Lunn Cc: Florian Fainelli Cc: "David S. Miller" Cc: Rojhalat Ibrahim Cc: Dominik Brodowski Cc: Russell King Cc: Kishon Vijay Abraham I Cc: Tony Lindgren Cc: Lars-Peter Clausen Cc: Michael Hennerich Cc: Jonathan Cameron Cc: Hartmut Knaack Cc: Peter Meerwald-Stadler Cc: Greg Kroah-Hartman Cc: Jiri Slaby Cc: Yegor Yefremov Cc: Uwe Kleine-König Signed-off-by: Janusz Krzysztofik Acked-by: Ulf Hansson Reviewed-by: Geert Uytterhoeven Tested-by: Geert Uytterhoeven --- Documentation/driver-api/gpio/consumer.rst | 22 ++++---- drivers/auxdisplay/hd44780.c | 59 +++++++-------------- drivers/bus/ts-nbus.c | 15 ++---- drivers/gpio/gpio-max3191x.c | 10 ++-- drivers/gpio/gpiolib.c | 82 +++++++++++++++-------------- drivers/gpio/gpiolib.h | 4 +- drivers/i2c/muxes/i2c-mux-gpio.c | 13 ++--- drivers/mmc/core/pwrseq_simple.c | 13 ++--- drivers/mux/gpio.c | 13 ++--- drivers/net/phy/mdio-mux-gpio.c | 11 ++-- drivers/pcmcia/soc_common.c | 7 +-- drivers/phy/motorola/phy-mapphone-mdm6600.c | 15 +++--- drivers/staging/iio/adc/ad7606.c | 9 ++-- drivers/tty/serial/serial_mctrl_gpio.c | 7 +-- include/linux/gpio/consumer.h | 34 ++++++------ 15 files changed, 137 insertions(+), 177 deletions(-) diff --git a/Documentation/driver-api/gpio/consumer.rst b/Documentation/driver-api/gpio/consumer.rst index aa03f389d41d..ed68042ddccf 100644 --- a/Documentation/driver-api/gpio/consumer.rst +++ b/Documentation/driver-api/gpio/consumer.rst @@ -323,29 +323,29 @@ The following functions get or set the values of an array of GPIOs:: int gpiod_get_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); int gpiod_get_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); int gpiod_get_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); int gpiod_get_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); void gpiod_set_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) void gpiod_set_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) void gpiod_set_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) void gpiod_set_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) The array can be an arbitrary set of GPIOs. The functions will try to access GPIOs belonging to the same bank or chip simultaneously if supported by the @@ -356,8 +356,8 @@ accessed sequentially. The functions take three arguments: * array_size - the number of array elements * desc_array - an array of GPIO descriptors - * value_array - an array to store the GPIOs' values (get) or - an array of values to assign to the GPIOs (set) + * value_bitmap - a bitmap to store the GPIOs' values (get) or + a bitmap of values to assign to the GPIOs (set) The descriptor array can be obtained using the gpiod_get_array() function or one of its variants. If the group of descriptors returned by that function @@ -366,7 +366,7 @@ the struct gpio_descs returned by gpiod_get_array():: struct gpio_descs *my_gpio_descs = gpiod_get_array(...); gpiod_set_array_value(my_gpio_descs->ndescs, my_gpio_descs->desc, - my_gpio_values); + my_gpio_value_bitmap); It is also possible to access a completely arbitrary array of descriptors. The descriptors may be obtained using any combination of gpiod_get() and diff --git a/drivers/auxdisplay/hd44780.c b/drivers/auxdisplay/hd44780.c index f1a42f0f1ded..e9a893384362 100644 --- a/drivers/auxdisplay/hd44780.c +++ b/drivers/auxdisplay/hd44780.c @@ -62,17 +62,12 @@ static void hd44780_strobe_gpio(struct hd44780 *hd) /* write to an LCD panel register in 8 bit GPIO mode */ static void hd44780_write_gpio8(struct hd44780 *hd, u8 val, unsigned int rs) { - int values[10]; /* for DATA[0-7], RS, RW */ - unsigned int i, n; - - for (i = 0; i < 8; i++) - values[PIN_DATA0 + i] = !!(val & BIT(i)); - values[PIN_CTRL_RS] = rs; - n = 9; - if (hd->pins[PIN_CTRL_RW]) { - values[PIN_CTRL_RW] = 0; - n++; - } + DECLARE_BITMAP(values, 10); /* for DATA[0-7], RS, RW */ + unsigned int n; + + values[0] = val; + __assign_bit(8, values, rs); + n = hd->pins[PIN_CTRL_RW] ? 10 : 9; /* Present the data to the port */ gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA0], values); @@ -83,32 +78,25 @@ static void hd44780_write_gpio8(struct hd44780 *hd, u8 val, unsigned int rs) /* write to an LCD panel register in 4 bit GPIO mode */ static void hd44780_write_gpio4(struct hd44780 *hd, u8 val, unsigned int rs) { - int values[10]; /* for DATA[0-7], RS, RW, but DATA[0-3] is unused */ - unsigned int i, n; + DECLARE_BITMAP(values, 6); /* for DATA[4-7], RS, RW */ + unsigned int n; /* High nibble + RS, RW */ - for (i = 4; i < 8; i++) - values[PIN_DATA0 + i] = !!(val & BIT(i)); - values[PIN_CTRL_RS] = rs; - n = 5; - if (hd->pins[PIN_CTRL_RW]) { - values[PIN_CTRL_RW] = 0; - n++; - } + values[0] = val >> 4; + __assign_bit(4, values, rs); + n = hd->pins[PIN_CTRL_RW] ? 6 : 5; /* Present the data to the port */ - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], - &values[PIN_DATA4]); + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], values); hd44780_strobe_gpio(hd); /* Low nibble */ - for (i = 0; i < 4; i++) - values[PIN_DATA4 + i] = !!(val & BIT(i)); + values[0] &= ~0x0fUL; + values[0] |= val & 0x0f; /* Present the data to the port */ - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], - &values[PIN_DATA4]); + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], values); hd44780_strobe_gpio(hd); } @@ -155,23 +143,16 @@ static void hd44780_write_cmd_gpio4(struct charlcd *lcd, int cmd) /* Send 4-bits of a command to the LCD panel in raw 4 bit GPIO mode */ static void hd44780_write_cmd_raw_gpio4(struct charlcd *lcd, int cmd) { - int values[10]; /* for DATA[0-7], RS, RW, but DATA[0-3] is unused */ + DECLARE_BITMAP(values, 6); /* for DATA[4-7], RS, RW */ struct hd44780 *hd = lcd->drvdata; - unsigned int i, n; + unsigned int n; /* Command nibble + RS, RW */ - for (i = 0; i < 4; i++) - values[PIN_DATA4 + i] = !!(cmd & BIT(i)); - values[PIN_CTRL_RS] = 0; - n = 5; - if (hd->pins[PIN_CTRL_RW]) { - values[PIN_CTRL_RW] = 0; - n++; - } + values[0] = cmd & 0x0f; + n = hd->pins[PIN_CTRL_RW] ? 6 : 5; /* Present the data to the port */ - gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], - &values[PIN_DATA4]); + gpiod_set_array_value_cansleep(n, &hd->pins[PIN_DATA4], values); hd44780_strobe_gpio(hd); } diff --git a/drivers/bus/ts-nbus.c b/drivers/bus/ts-nbus.c index 073fd9011154..8dde7c77f62c 100644 --- a/drivers/bus/ts-nbus.c +++ b/drivers/bus/ts-nbus.c @@ -110,11 +110,9 @@ static void ts_nbus_set_direction(struct ts_nbus *ts_nbus, int direction) */ static void ts_nbus_reset_bus(struct ts_nbus *ts_nbus) { - int i; - int values[8]; + DECLARE_BITMAP(values, 8); - for (i = 0; i < 8; i++) - values[i] = 0; + values[0] = 0; gpiod_set_array_value_cansleep(8, ts_nbus->data->desc, values); gpiod_set_value_cansleep(ts_nbus->csn, 0); @@ -157,14 +155,9 @@ static int ts_nbus_read_byte(struct ts_nbus *ts_nbus, u8 *val) static void ts_nbus_write_byte(struct ts_nbus *ts_nbus, u8 byte) { struct gpio_descs *gpios = ts_nbus->data; - int i; - int values[8]; + DECLARE_BITMAP(values, 8); - for (i = 0; i < 8; i++) - if (byte & BIT(i)) - values[i] = 1; - else - values[i] = 0; + values[0] = byte; gpiod_set_array_value_cansleep(8, gpios->desc, values); } diff --git a/drivers/gpio/gpio-max3191x.c b/drivers/gpio/gpio-max3191x.c index b5b9cb1fda50..bd4a245fc5a0 100644 --- a/drivers/gpio/gpio-max3191x.c +++ b/drivers/gpio/gpio-max3191x.c @@ -315,14 +315,16 @@ static void gpiod_set_array_single_value_cansleep(unsigned int ndescs, struct gpio_desc **desc, int value) { - int i, *values; + unsigned long *values; - values = kmalloc_array(ndescs, sizeof(*values), GFP_KERNEL); + values = bitmap_alloc(ndescs, GFP_KERNEL); if (!values) return; - for (i = 0; i < ndescs; i++) - values[i] = value; + if (value) + bitmap_fill(values, ndescs); + else + bitmap_zero(values, ndescs); gpiod_set_array_value_cansleep(ndescs, desc, values); kfree(values); diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c index e8f8a1999393..b66b2191c5c5 100644 --- a/drivers/gpio/gpiolib.c +++ b/drivers/gpio/gpiolib.c @@ -427,7 +427,7 @@ static long linehandle_ioctl(struct file *filep, unsigned int cmd, struct linehandle_state *lh = filep->private_data; void __user *ip = (void __user *)arg; struct gpiohandle_data ghd; - int vals[GPIOHANDLES_MAX]; + DECLARE_BITMAP(vals, GPIOHANDLES_MAX); int i; if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) { @@ -442,7 +442,7 @@ static long linehandle_ioctl(struct file *filep, unsigned int cmd, memset(&ghd, 0, sizeof(ghd)); for (i = 0; i < lh->numdescs; i++) - ghd.values[i] = vals[i]; + ghd.values[i] = test_bit(i, vals); if (copy_to_user(ip, &ghd, sizeof(ghd))) return -EFAULT; @@ -461,7 +461,7 @@ static long linehandle_ioctl(struct file *filep, unsigned int cmd, /* Clamp all values to [0,1] */ for (i = 0; i < lh->numdescs; i++) - vals[i] = !!ghd.values[i]; + __assign_bit(i, vals, ghd.values[i]); /* Reuse the array setting function */ return gpiod_set_array_value_complex(false, @@ -2784,7 +2784,7 @@ static int gpio_chip_get_multiple(struct gpio_chip *chip, int gpiod_get_array_value_complex(bool raw, bool can_sleep, unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { int i = 0; @@ -2835,7 +2835,7 @@ int gpiod_get_array_value_complex(bool raw, bool can_sleep, if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags)) value = !value; - value_array[j] = value; + __assign_bit(j, value_bitmap, value); trace_gpio_value(desc_to_gpio(desc), 1, value); } @@ -2895,9 +2895,9 @@ EXPORT_SYMBOL_GPL(gpiod_get_value); /** * gpiod_get_raw_array_value() - read raw values from an array of GPIOs - * @array_size: number of elements in the descriptor / value arrays + * @array_size: number of elements in the descriptor array / value bitmap * @desc_array: array of GPIO descriptors whose values will be read - * @value_array: array to store the read values + * @value_bitmap: bitmap to store the read values * * Read the raw values of the GPIOs, i.e. the values of the physical lines * without regard for their ACTIVE_LOW status. Return 0 in case of success, @@ -2907,20 +2907,21 @@ EXPORT_SYMBOL_GPL(gpiod_get_value); * and it will complain if the GPIO chip functions potentially sleep. */ int gpiod_get_raw_array_value(unsigned int array_size, - struct gpio_desc **desc_array, int *value_array) + struct gpio_desc **desc_array, + unsigned long *value_bitmap) { if (!desc_array) return -EINVAL; return gpiod_get_array_value_complex(true, false, array_size, - desc_array, value_array); + desc_array, value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value); /** * gpiod_get_array_value() - read values from an array of GPIOs - * @array_size: number of elements in the descriptor / value arrays + * @array_size: number of elements in the descriptor array / value bitmap * @desc_array: array of GPIO descriptors whose values will be read - * @value_array: array to store the read values + * @value_bitmap: bitmap to store the read values * * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status * into account. Return 0 in case of success, else an error code. @@ -2929,12 +2930,13 @@ EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value); * and it will complain if the GPIO chip functions potentially sleep. */ int gpiod_get_array_value(unsigned int array_size, - struct gpio_desc **desc_array, int *value_array) + struct gpio_desc **desc_array, + unsigned long *value_bitmap) { if (!desc_array) return -EINVAL; return gpiod_get_array_value_complex(false, false, array_size, - desc_array, value_array); + desc_array, value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_get_array_value); @@ -3027,7 +3029,7 @@ static void gpio_chip_set_multiple(struct gpio_chip *chip, int gpiod_set_array_value_complex(bool raw, bool can_sleep, unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { int i = 0; @@ -3056,7 +3058,7 @@ int gpiod_set_array_value_complex(bool raw, bool can_sleep, do { struct gpio_desc *desc = desc_array[i]; int hwgpio = gpio_chip_hwgpio(desc); - int value = value_array[i]; + int value = test_bit(i, value_bitmap); if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags)) value = !value; @@ -3152,9 +3154,9 @@ EXPORT_SYMBOL_GPL(gpiod_set_value); /** * gpiod_set_raw_array_value() - assign values to an array of GPIOs - * @array_size: number of elements in the descriptor / value arrays + * @array_size: number of elements in the descriptor array / value bitmap * @desc_array: array of GPIO descriptors whose values will be assigned - * @value_array: array of values to assign + * @value_bitmap: bitmap of values to assign * * Set the raw values of the GPIOs, i.e. the values of the physical lines * without regard for their ACTIVE_LOW status. @@ -3163,20 +3165,21 @@ EXPORT_SYMBOL_GPL(gpiod_set_value); * complain if the GPIO chip functions potentially sleep. */ int gpiod_set_raw_array_value(unsigned int array_size, - struct gpio_desc **desc_array, int *value_array) + struct gpio_desc **desc_array, + unsigned long *value_bitmap) { if (!desc_array) return -EINVAL; return gpiod_set_array_value_complex(true, false, array_size, - desc_array, value_array); + desc_array, value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value); /** * gpiod_set_array_value() - assign values to an array of GPIOs - * @array_size: number of elements in the descriptor / value arrays + * @array_size: number of elements in the descriptor array / value bitmap * @desc_array: array of GPIO descriptors whose values will be assigned - * @value_array: array of values to assign + * @value_bitmap: bitmap of values to assign * * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status * into account. @@ -3185,12 +3188,13 @@ EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value); * complain if the GPIO chip functions potentially sleep. */ void gpiod_set_array_value(unsigned int array_size, - struct gpio_desc **desc_array, int *value_array) + struct gpio_desc **desc_array, + unsigned long *value_bitmap) { if (!desc_array) return; gpiod_set_array_value_complex(false, false, array_size, desc_array, - value_array); + value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_set_array_value); @@ -3410,9 +3414,9 @@ EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep); /** * gpiod_get_raw_array_value_cansleep() - read raw values from an array of GPIOs - * @array_size: number of elements in the descriptor / value arrays + * @array_size: number of elements in the descriptor array / value bitmap * @desc_array: array of GPIO descriptors whose values will be read - * @value_array: array to store the read values + * @value_bitmap: bitmap to store the read values * * Read the raw values of the GPIOs, i.e. the values of the physical lines * without regard for their ACTIVE_LOW status. Return 0 in case of success, @@ -3422,21 +3426,21 @@ EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep); */ int gpiod_get_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { might_sleep_if(extra_checks); if (!desc_array) return -EINVAL; return gpiod_get_array_value_complex(true, true, array_size, - desc_array, value_array); + desc_array, value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep); /** * gpiod_get_array_value_cansleep() - read values from an array of GPIOs - * @array_size: number of elements in the descriptor / value arrays + * @array_size: number of elements in the descriptor array / value bitmap * @desc_array: array of GPIO descriptors whose values will be read - * @value_array: array to store the read values + * @value_bitmap: bitmap to store the read values * * Read the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status * into account. Return 0 in case of success, else an error code. @@ -3445,13 +3449,13 @@ EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep); */ int gpiod_get_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { might_sleep_if(extra_checks); if (!desc_array) return -EINVAL; return gpiod_get_array_value_complex(false, true, array_size, - desc_array, value_array); + desc_array, value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep); @@ -3493,9 +3497,9 @@ EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep); /** * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs - * @array_size: number of elements in the descriptor / value arrays + * @array_size: number of elements in the descriptor array / value bitmap * @desc_array: array of GPIO descriptors whose values will be assigned - * @value_array: array of values to assign + * @value_bitmap: bitmap of values to assign * * Set the raw values of the GPIOs, i.e. the values of the physical lines * without regard for their ACTIVE_LOW status. @@ -3504,13 +3508,13 @@ EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep); */ int gpiod_set_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { might_sleep_if(extra_checks); if (!desc_array) return -EINVAL; return gpiod_set_array_value_complex(true, true, array_size, desc_array, - value_array); + value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep); @@ -3533,9 +3537,9 @@ void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n) /** * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs - * @array_size: number of elements in the descriptor / value arrays + * @array_size: number of elements in the descriptor array / value bitmap * @desc_array: array of GPIO descriptors whose values will be assigned - * @value_array: array of values to assign + * @value_bitmap: bitmap of values to assign * * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status * into account. @@ -3544,13 +3548,13 @@ void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n) */ void gpiod_set_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { might_sleep_if(extra_checks); if (!desc_array) return; gpiod_set_array_value_complex(false, true, array_size, desc_array, - value_array); + value_bitmap); } EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep); diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h index a7e49fef73d4..11e83d2eef89 100644 --- a/drivers/gpio/gpiolib.h +++ b/drivers/gpio/gpiolib.h @@ -187,11 +187,11 @@ struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip, u16 hwnum); int gpiod_get_array_value_complex(bool raw, bool can_sleep, unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); int gpiod_set_array_value_complex(bool raw, bool can_sleep, unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); /* This is just passed between gpiolib and devres */ struct gpio_desc *gpiod_get_from_of_node(struct device_node *node, diff --git a/drivers/i2c/muxes/i2c-mux-gpio.c b/drivers/i2c/muxes/i2c-mux-gpio.c index 401308e3d036..d835857bb094 100644 --- a/drivers/i2c/muxes/i2c-mux-gpio.c +++ b/drivers/i2c/muxes/i2c-mux-gpio.c @@ -22,18 +22,15 @@ struct gpiomux { struct i2c_mux_gpio_platform_data data; unsigned gpio_base; struct gpio_desc **gpios; - int *values; }; static void i2c_mux_gpio_set(const struct gpiomux *mux, unsigned val) { - int i; + DECLARE_BITMAP(values, BITS_PER_TYPE(val)); - for (i = 0; i < mux->data.n_gpios; i++) - mux->values[i] = (val >> i) & 1; + values[0] = val; - gpiod_set_array_value_cansleep(mux->data.n_gpios, - mux->gpios, mux->values); + gpiod_set_array_value_cansleep(mux->data.n_gpios, mux->gpios, values); } static int i2c_mux_gpio_select(struct i2c_mux_core *muxc, u32 chan) @@ -182,15 +179,13 @@ static int i2c_mux_gpio_probe(struct platform_device *pdev) return -EPROBE_DEFER; muxc = i2c_mux_alloc(parent, &pdev->dev, mux->data.n_values, - mux->data.n_gpios * sizeof(*mux->gpios) + - mux->data.n_gpios * sizeof(*mux->values), 0, + mux->data.n_gpios * sizeof(*mux->gpios), 0, i2c_mux_gpio_select, NULL); if (!muxc) { ret = -ENOMEM; goto alloc_failed; } mux->gpios = muxc->priv; - mux->values = (int *)(mux->gpios + mux->data.n_gpios); muxc->priv = mux; platform_set_drvdata(pdev, muxc); diff --git a/drivers/mmc/core/pwrseq_simple.c b/drivers/mmc/core/pwrseq_simple.c index a8b9fee4d62a..902476ef9a0e 100644 --- a/drivers/mmc/core/pwrseq_simple.c +++ b/drivers/mmc/core/pwrseq_simple.c @@ -40,18 +40,13 @@ static void mmc_pwrseq_simple_set_gpios_value(struct mmc_pwrseq_simple *pwrseq, struct gpio_descs *reset_gpios = pwrseq->reset_gpios; if (!IS_ERR(reset_gpios)) { - int i, *values; + DECLARE_BITMAP(values, BITS_PER_TYPE(value)); int nvalues = reset_gpios->ndescs; - values = kmalloc_array(nvalues, sizeof(int), GFP_KERNEL); - if (!values) - return; + values[0] = value; - for (i = 0; i < nvalues; i++) - values[i] = value; - - gpiod_set_array_value_cansleep(nvalues, reset_gpios->desc, values); - kfree(values); + gpiod_set_array_value_cansleep(nvalues, reset_gpios->desc, + values); } } diff --git a/drivers/mux/gpio.c b/drivers/mux/gpio.c index 6fdd9316db8b..46c44532fbd5 100644 --- a/drivers/mux/gpio.c +++ b/drivers/mux/gpio.c @@ -17,20 +17,17 @@ struct mux_gpio { struct gpio_descs *gpios; - int *val; }; static int mux_gpio_set(struct mux_control *mux, int state) { struct mux_gpio *mux_gpio = mux_chip_priv(mux->chip); - int i; + DECLARE_BITMAP(values, BITS_PER_TYPE(state)); - for (i = 0; i < mux_gpio->gpios->ndescs; i++) - mux_gpio->val[i] = (state >> i) & 1; + values[0] = state; gpiod_set_array_value_cansleep(mux_gpio->gpios->ndescs, - mux_gpio->gpios->desc, - mux_gpio->val); + mux_gpio->gpios->desc, values); return 0; } @@ -58,13 +55,11 @@ static int mux_gpio_probe(struct platform_device *pdev) if (pins < 0) return pins; - mux_chip = devm_mux_chip_alloc(dev, 1, sizeof(*mux_gpio) + - pins * sizeof(*mux_gpio->val)); + mux_chip = devm_mux_chip_alloc(dev, 1, sizeof(*mux_gpio)); if (IS_ERR(mux_chip)) return PTR_ERR(mux_chip); mux_gpio = mux_chip_priv(mux_chip); - mux_gpio->val = (int *)(mux_gpio + 1); mux_chip->ops = &mux_gpio_ops; mux_gpio->gpios = devm_gpiod_get_array(dev, "mux", GPIOD_OUT_LOW); diff --git a/drivers/net/phy/mdio-mux-gpio.c b/drivers/net/phy/mdio-mux-gpio.c index bc90764a8b8d..e25ccfc8c070 100644 --- a/drivers/net/phy/mdio-mux-gpio.c +++ b/drivers/net/phy/mdio-mux-gpio.c @@ -20,23 +20,21 @@ struct mdio_mux_gpio_state { struct gpio_descs *gpios; void *mux_handle; - int values[]; }; static int mdio_mux_gpio_switch_fn(int current_child, int desired_child, void *data) { struct mdio_mux_gpio_state *s = data; - unsigned int n; + DECLARE_BITMAP(values, BITS_PER_TYPE(desired_child)); if (current_child == desired_child) return 0; - for (n = 0; n < s->gpios->ndescs; n++) - s->values[n] = (desired_child >> n) & 1; + values[0] = desired_child; gpiod_set_array_value_cansleep(s->gpios->ndescs, s->gpios->desc, - s->values); + values); return 0; } @@ -51,8 +49,7 @@ static int mdio_mux_gpio_probe(struct platform_device *pdev) if (IS_ERR(gpios)) return PTR_ERR(gpios); - s = devm_kzalloc(&pdev->dev, struct_size(s, values, gpios->ndescs), - GFP_KERNEL); + s = devm_kzalloc(&pdev->dev, sizeof(*s), GFP_KERNEL); if (!s) { gpiod_put_array(gpios); return -ENOMEM; diff --git a/drivers/pcmcia/soc_common.c b/drivers/pcmcia/soc_common.c index c5f2344c189b..ac033d555700 100644 --- a/drivers/pcmcia/soc_common.c +++ b/drivers/pcmcia/soc_common.c @@ -351,15 +351,16 @@ static int soc_common_pcmcia_config_skt( if (ret == 0) { struct gpio_desc *descs[2]; - int values[2], n = 0; + DECLARE_BITMAP(values, 2); + int n = 0; if (skt->gpio_reset) { descs[n] = skt->gpio_reset; - values[n++] = !!(state->flags & SS_RESET); + __assign_bit(n++, values, state->flags & SS_RESET); } if (skt->gpio_bus_enable) { descs[n] = skt->gpio_bus_enable; - values[n++] = !!(state->flags & SS_OUTPUT_ENA); + __assign_bit(n++, values, state->flags & SS_OUTPUT_ENA); } if (n) diff --git a/drivers/phy/motorola/phy-mapphone-mdm6600.c b/drivers/phy/motorola/phy-mapphone-mdm6600.c index 0075fb0bef8c..9162b61ddb95 100644 --- a/drivers/phy/motorola/phy-mapphone-mdm6600.c +++ b/drivers/phy/motorola/phy-mapphone-mdm6600.c @@ -157,12 +157,9 @@ static const struct phy_ops gpio_usb_ops = { */ static void phy_mdm6600_cmd(struct phy_mdm6600 *ddata, int val) { - int values[PHY_MDM6600_NR_CMD_LINES]; - int i; + DECLARE_BITMAP(values, PHY_MDM6600_NR_CMD_LINES); - val &= (1 << PHY_MDM6600_NR_CMD_LINES) - 1; - for (i = 0; i < PHY_MDM6600_NR_CMD_LINES; i++) - values[i] = (val & BIT(i)) >> i; + values[0] = val; gpiod_set_array_value_cansleep(PHY_MDM6600_NR_CMD_LINES, ddata->cmd_gpios->desc, values); @@ -176,7 +173,7 @@ static void phy_mdm6600_status(struct work_struct *work) { struct phy_mdm6600 *ddata; struct device *dev; - int values[PHY_MDM6600_NR_STATUS_LINES]; + DECLARE_BITMAP(values, PHY_MDM6600_NR_STATUS_LINES); int error, i, val = 0; ddata = container_of(work, struct phy_mdm6600, status_work.work); @@ -189,11 +186,11 @@ static void phy_mdm6600_status(struct work_struct *work) return; for (i = 0; i < PHY_MDM6600_NR_STATUS_LINES; i++) { - val |= values[i] << i; + val |= test_bit(i, values) << i; dev_dbg(ddata->dev, "XXX %s: i: %i values[i]: %i val: %i\n", - __func__, i, values[i], val); + __func__, i, test_bit(i, values), val); } - ddata->status = val; + ddata->status = values[0]; dev_info(dev, "modem status: %i %s\n", ddata->status, diff --git a/drivers/staging/iio/adc/ad7606.c b/drivers/staging/iio/adc/ad7606.c index 25b9fcd5e3a4..9c1d77d48700 100644 --- a/drivers/staging/iio/adc/ad7606.c +++ b/drivers/staging/iio/adc/ad7606.c @@ -202,7 +202,7 @@ static int ad7606_write_raw(struct iio_dev *indio_dev, long mask) { struct ad7606_state *st = iio_priv(indio_dev); - int values[3]; + DECLARE_BITMAP(values, 3); int ret, i; switch (mask) { @@ -227,13 +227,10 @@ static int ad7606_write_raw(struct iio_dev *indio_dev, if (ret < 0) return ret; - values[0] = (ret >> 0) & 1; - values[1] = (ret >> 1) & 1; - values[2] = (ret >> 2) & 1; + values[0] = ret; mutex_lock(&st->lock); - gpiod_set_array_value(ARRAY_SIZE(values), st->gpio_os->desc, - values); + gpiod_set_array_value(3, st->gpio_os->desc, values); st->oversampling = val; mutex_unlock(&st->lock); diff --git a/drivers/tty/serial/serial_mctrl_gpio.c b/drivers/tty/serial/serial_mctrl_gpio.c index 1c06325beaca..7d9d2c7b6c39 100644 --- a/drivers/tty/serial/serial_mctrl_gpio.c +++ b/drivers/tty/serial/serial_mctrl_gpio.c @@ -40,7 +40,7 @@ void mctrl_gpio_set(struct mctrl_gpios *gpios, unsigned int mctrl) { enum mctrl_gpio_idx i; struct gpio_desc *desc_array[UART_GPIO_MAX]; - int value_array[UART_GPIO_MAX]; + DECLARE_BITMAP(values, UART_GPIO_MAX); unsigned int count = 0; if (gpios == NULL) @@ -49,10 +49,11 @@ void mctrl_gpio_set(struct mctrl_gpios *gpios, unsigned int mctrl) for (i = 0; i < UART_GPIO_MAX; i++) if (gpios->gpio[i] && mctrl_gpios_desc[i].dir_out) { desc_array[count] = gpios->gpio[i]; - value_array[count] = !!(mctrl & mctrl_gpios_desc[i].mctrl); + __assign_bit(count, values, + mctrl & mctrl_gpios_desc[i].mctrl); count++; } - gpiod_set_array_value(count, desc_array, value_array); + gpiod_set_array_value(count, desc_array, values); } EXPORT_SYMBOL_GPL(mctrl_gpio_set); diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h index 21ddbe440030..2b0389f0bec4 100644 --- a/include/linux/gpio/consumer.h +++ b/include/linux/gpio/consumer.h @@ -104,36 +104,38 @@ int gpiod_direction_output_raw(struct gpio_desc *desc, int value); /* Value get/set from non-sleeping context */ int gpiod_get_value(const struct gpio_desc *desc); int gpiod_get_array_value(unsigned int array_size, - struct gpio_desc **desc_array, int *value_array); + struct gpio_desc **desc_array, + unsigned long *value_bitmap); void gpiod_set_value(struct gpio_desc *desc, int value); void gpiod_set_array_value(unsigned int array_size, - struct gpio_desc **desc_array, int *value_array); + struct gpio_desc **desc_array, + unsigned long *value_bitmap); int gpiod_get_raw_value(const struct gpio_desc *desc); int gpiod_get_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); void gpiod_set_raw_value(struct gpio_desc *desc, int value); int gpiod_set_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); /* Value get/set from sleeping context */ int gpiod_get_value_cansleep(const struct gpio_desc *desc); int gpiod_get_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); void gpiod_set_value_cansleep(struct gpio_desc *desc, int value); void gpiod_set_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc); int gpiod_get_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value); int gpiod_set_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array); + unsigned long *value_bitmap); int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce); int gpiod_set_transitory(struct gpio_desc *desc, bool transitory); @@ -330,7 +332,7 @@ static inline int gpiod_get_value(const struct gpio_desc *desc) } static inline int gpiod_get_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { /* GPIO can never have been requested */ WARN_ON(1); @@ -343,7 +345,7 @@ static inline void gpiod_set_value(struct gpio_desc *desc, int value) } static inline void gpiod_set_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { /* GPIO can never have been requested */ WARN_ON(1); @@ -356,7 +358,7 @@ static inline int gpiod_get_raw_value(const struct gpio_desc *desc) } static inline int gpiod_get_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { /* GPIO can never have been requested */ WARN_ON(1); @@ -369,7 +371,7 @@ static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value) } static inline int gpiod_set_raw_array_value(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { /* GPIO can never have been requested */ WARN_ON(1); @@ -384,7 +386,7 @@ static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc) } static inline int gpiod_get_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { /* GPIO can never have been requested */ WARN_ON(1); @@ -397,7 +399,7 @@ static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value) } static inline void gpiod_set_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { /* GPIO can never have been requested */ WARN_ON(1); @@ -410,7 +412,7 @@ static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc) } static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { /* GPIO can never have been requested */ WARN_ON(1); @@ -424,7 +426,7 @@ static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, } static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size, struct gpio_desc **desc_array, - int *value_array) + unsigned long *value_bitmap) { /* GPIO can never have been requested */ WARN_ON(1); -- 2.16.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Janusz Krzysztofik Subject: [PATCH v8 1/4] gpiolib: Pass bitmaps, not integer arrays, to get/set array Date: Wed, 5 Sep 2018 23:50:05 +0200 Message-ID: <20180905215008.1649-2-jmkrzyszt@gmail.com> References: <20180902120144.6855-1-jmkrzyszt@gmail.com> <20180905215008.1649-1-jmkrzyszt@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180905215008.1649-1-jmkrzyszt@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: driverdev-devel-bounces@linuxdriverproject.org Sender: "devel" To: Linus Walleij Cc: Andrew Lunn , Ulf Hansson , linux-doc@vger.kernel.org, Tony Lindgren , Dominik Brodowski , Peter Rosin , netdev@vger.kernel.org, linux-i2c@vger.kernel.org, Peter Meerwald-Stadler , devel@driverdev.osuosl.org, Florian Fainelli , Jonathan Corbet , Janusz Krzysztofik , Kishon Vijay Abraham I , linux-iio@vger.kernel.org, Peter Korsgaard , Geert Uytterhoeven , linux-serial@vger.kernel.org, Jiri Slaby , Michael Hennerich , =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= , linux-gpio@vger.kernel.org, Russell King , Lars-Peter Clausen List-Id: linux-gpio@vger.kernel.org TW9zdCB1c2VycyBvZiBnZXQvc2V0IGFycmF5IGZ1bmN0aW9ucyBpdGVyYXRlIGNvbnNlY3V0aXZl IGJpdHMgb2YgZGF0YSwKdXN1YWxseSBhIHNpbmdsZSBpbnRlZ2VyLCB3aGlsZSBwcm9jZXNzaW5n IGFycmF5IG9mIHJlc3VsdHMgb2J0YWluZWQKZnJvbSwgb3IgYnVpbGRpbmcgYW4gYXJyYXkgb2Yg dmFsdWVzIHRvIGJlIHBhc3NlZCB0byB0aG9zZSBmdW5jdGlvbnMuClNhdmUgdGltZSB3YXN0ZWQg b24gdGhvc2UgaXRlcmF0aW9ucyBieSBjaGFuZ2luZyB0aGUgZnVuY3Rpb25zJyBBUEkgdG8KYWNj ZXB0IGJpdG1hcHMuCgpBbGwgY3VycmVudCB1c2VycyBhcmUgdXBkYXRlZCBhcyB3ZWxsLgoKTW9y ZSBiZW5lZml0cyBmcm9tIHRoZSBjaGFuZ2UgYXJlIGV4cGVjdGVkIGFzIHNvb24gYXMgcGxhbm5l ZCBzdXBwb3J0CmZvciBhY2NlcHRpbmcvcGFzc2luZyB0aG9zZSBiaXRtYXBzIGRpcmVjdGx5IGZy b20vdG8gcmVzcGVjdGl2ZSBHUElPCmNoaXAgY2FsbGJhY2tzIGlmIGFwcGxpY2FibGUgaXMgaW1w bGVtZW50ZWQuCgpDYzogSm9uYXRoYW4gQ29yYmV0IDxjb3JiZXRAbHduLm5ldD4KQ2M6IE1pZ3Vl bCBPamVkYSBTYW5kb25pcyA8bWlndWVsLm9qZWRhLnNhbmRvbmlzQGdtYWlsLmNvbT4KQ2M6IFNl YmFzdGllbiBCb3VyZGVsaW4gPHNlYmFzdGllbi5ib3VyZGVsaW5Ac2F2b2lyZmFpcmVsaW51eC5j b20+CkNjOiBMdWthcyBXdW5uZXIgPGx1a2FzQHd1bm5lci5kZT4KQ2M6IFBldGVyIEtvcnNnYWFy ZCA8cGV0ZXIua29yc2dhYXJkQGJhcmNvLmNvbT4KQ2M6IFBldGVyIFJvc2luIDxwZWRhQGF4ZW50 aWEuc2U+CkNjOiBBbmRyZXcgTHVubiA8YW5kcmV3QGx1bm4uY2g+CkNjOiBGbG9yaWFuIEZhaW5l bGxpIDxmLmZhaW5lbGxpQGdtYWlsLmNvbT4KQ2M6ICJEYXZpZCBTLiBNaWxsZXIiIDxkYXZlbUBk YXZlbWxvZnQubmV0PgpDYzogUm9qaGFsYXQgSWJyYWhpbSA8aW1yQHJ0c2NoZW5rLmRlPgpDYzog RG9taW5payBCcm9kb3dza2kgPGxpbnV4QGRvbWluaWticm9kb3dza2kubmV0PgpDYzogUnVzc2Vs bCBLaW5nIDxybWsra2VybmVsQGFybWxpbnV4Lm9yZy51az4KQ2M6IEtpc2hvbiBWaWpheSBBYnJh aGFtIEkgPGtpc2hvbkB0aS5jb20+CkNjOiBUb255IExpbmRncmVuIDx0b255QGF0b21pZGUuY29t PgpDYzogTGFycy1QZXRlciBDbGF1c2VuIDxsYXJzQG1ldGFmb28uZGU+CkNjOiBNaWNoYWVsIEhl bm5lcmljaCA8TWljaGFlbC5IZW5uZXJpY2hAYW5hbG9nLmNvbT4KQ2M6IEpvbmF0aGFuIENhbWVy b24gPGppYzIzQGtlcm5lbC5vcmc+CkNjOiBIYXJ0bXV0IEtuYWFjayA8a25hYWNrLmhAZ214LmRl PgpDYzogUGV0ZXIgTWVlcndhbGQtU3RhZGxlciA8cG1lZXJ3QHBtZWVydy5uZXQ+CkNjOiBHcmVn IEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRpb24ub3JnPgpDYzogSmlyaSBTbGFi eSA8anNsYWJ5QHN1c2UuY29tPgpDYzogWWVnb3IgWWVmcmVtb3YgPHllZ29yc2xpc3RzQGdvb2ds ZW1haWwuY29tPgpDYzogVXdlIEtsZWluZS1Lw7ZuaWcgPHUua2xlaW5lLWtvZW5pZ0BwZW5ndXRy b25peC5kZT4KU2lnbmVkLW9mZi1ieTogSmFudXN6IEtyenlzenRvZmlrIDxqbWtyenlzenRAZ21h aWwuY29tPgpBY2tlZC1ieTogVWxmIEhhbnNzb24gPHVsZi5oYW5zc29uQGxpbmFyby5vcmc+ClJl dmlld2VkLWJ5OiBHZWVydCBVeXR0ZXJob2V2ZW4gPGdlZXJ0K3JlbmVzYXNAZ2xpZGVyLmJlPgpU ZXN0ZWQtYnk6IEdlZXJ0IFV5dHRlcmhvZXZlbiA8Z2VlcnQrcmVuZXNhc0BnbGlkZXIuYmU+Ci0t LQogRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2dwaW8vY29uc3VtZXIucnN0ICB8IDIyICsrKyst LS0tCiBkcml2ZXJzL2F1eGRpc3BsYXkvaGQ0NDc4MC5jICAgICAgICAgICAgICAgIHwgNTkgKysr KysrKy0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2J1cy90cy1uYnVzLmMgICAgICAgICAgICAgICAg ICAgICAgIHwgMTUgKystLS0tCiBkcml2ZXJzL2dwaW8vZ3Bpby1tYXgzMTkxeC5jICAgICAgICAg ICAgICAgIHwgMTAgKystLQogZHJpdmVycy9ncGlvL2dwaW9saWIuYyAgICAgICAgICAgICAgICAg ICAgICB8IDgyICsrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2dwaW8vZ3Bp b2xpYi5oICAgICAgICAgICAgICAgICAgICAgIHwgIDQgKy0KIGRyaXZlcnMvaTJjL211eGVzL2ky Yy1tdXgtZ3Bpby5jICAgICAgICAgICAgfCAxMyArKy0tLQogZHJpdmVycy9tbWMvY29yZS9wd3Jz ZXFfc2ltcGxlLmMgICAgICAgICAgICB8IDEzICsrLS0tCiBkcml2ZXJzL211eC9ncGlvLmMgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgMTMgKystLS0KIGRyaXZlcnMvbmV0L3BoeS9tZGlvLW11 eC1ncGlvLmMgICAgICAgICAgICAgfCAxMSArKy0tCiBkcml2ZXJzL3BjbWNpYS9zb2NfY29tbW9u LmMgICAgICAgICAgICAgICAgIHwgIDcgKy0tCiBkcml2ZXJzL3BoeS9tb3Rvcm9sYS9waHktbWFw cGhvbmUtbWRtNjYwMC5jIHwgMTUgKysrLS0tCiBkcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc2 MDYuYyAgICAgICAgICAgIHwgIDkgKystLQogZHJpdmVycy90dHkvc2VyaWFsL3NlcmlhbF9tY3Ry bF9ncGlvLmMgICAgICB8ICA3ICstLQogaW5jbHVkZS9saW51eC9ncGlvL2NvbnN1bWVyLmggICAg ICAgICAgICAgICB8IDM0ICsrKysrKy0tLS0tLQogMTUgZmlsZXMgY2hhbmdlZCwgMTM3IGluc2Vy dGlvbnMoKyksIDE3NyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2Ry aXZlci1hcGkvZ3Bpby9jb25zdW1lci5yc3QgYi9Eb2N1bWVudGF0aW9uL2RyaXZlci1hcGkvZ3Bp by9jb25zdW1lci5yc3QKaW5kZXggYWEwM2YzODlkNDFkLi5lZDY4MDQyZGRjY2YgMTAwNjQ0Ci0t LSBhL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9ncGlvL2NvbnN1bWVyLnJzdAorKysgYi9Eb2N1 bWVudGF0aW9uL2RyaXZlci1hcGkvZ3Bpby9jb25zdW1lci5yc3QKQEAgLTMyMywyOSArMzIzLDI5 IEBAIFRoZSBmb2xsb3dpbmcgZnVuY3Rpb25zIGdldCBvciBzZXQgdGhlIHZhbHVlcyBvZiBhbiBh cnJheSBvZiBHUElPczo6CiAKIAlpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGlu dCBhcnJheV9zaXplLAogCQkJCSAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJ ICBpbnQgKnZhbHVlX2FycmF5KTsKKwkJCQkgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCk7 CiAJaW50IGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWUodW5zaWduZWQgaW50IGFycmF5X3NpemUs CiAJCQkJICAgICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJICAgICAgaW50 ICp2YWx1ZV9hcnJheSk7CisJCQkJICAgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsK IAlpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKHVuc2lnbmVkIGludCBhcnJheV9z aXplLAogCQkJCQkgICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkJICAgaW50 ICp2YWx1ZV9hcnJheSk7CisJCQkJCSAgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCk7CiAJ aW50IGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5 X3NpemUsCiAJCQkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCQkgICBp bnQgKnZhbHVlX2FycmF5KTsKKwkJCQkJICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsK IAogCXZvaWQgZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAog CQkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCSAgIGludCAqdmFsdWVf YXJyYXkpCisJCQkJICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogCXZvaWQgZ3Bpb2Rf c2V0X3Jhd19hcnJheV92YWx1ZSh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgICAgICAg c3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJICAgICAgIGludCAqdmFsdWVfYXJy YXkpCisJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIAl2b2lkIGdwaW9k X3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcCh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkJ ICAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCQkgICAgaW50ICp2YWx1ZV9h cnJheSkKKwkJCQkJICAgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIAl2b2lkIGdwaW9k X3NldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJ CQkJCQlzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkJCWludCAqdmFsdWVfYXJy YXkpCisJCQkJCQl1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiAKIFRoZSBhcnJheSBjYW4g YmUgYW4gYXJiaXRyYXJ5IHNldCBvZiBHUElPcy4gVGhlIGZ1bmN0aW9ucyB3aWxsIHRyeSB0byBh Y2Nlc3MKIEdQSU9zIGJlbG9uZ2luZyB0byB0aGUgc2FtZSBiYW5rIG9yIGNoaXAgc2ltdWx0YW5l b3VzbHkgaWYgc3VwcG9ydGVkIGJ5IHRoZQpAQCAtMzU2LDggKzM1Niw4IEBAIGFjY2Vzc2VkIHNl cXVlbnRpYWxseS4KIFRoZSBmdW5jdGlvbnMgdGFrZSB0aHJlZSBhcmd1bWVudHM6CiAJKiBhcnJh eV9zaXplCS0gdGhlIG51bWJlciBvZiBhcnJheSBlbGVtZW50cwogCSogZGVzY19hcnJheQktIGFu IGFycmF5IG9mIEdQSU8gZGVzY3JpcHRvcnMKLQkqIHZhbHVlX2FycmF5CS0gYW4gYXJyYXkgdG8g c3RvcmUgdGhlIEdQSU9zJyB2YWx1ZXMgKGdldCkgb3IKLQkJCSAgYW4gYXJyYXkgb2YgdmFsdWVz IHRvIGFzc2lnbiB0byB0aGUgR1BJT3MgKHNldCkKKwkqIHZhbHVlX2JpdG1hcAktIGEgYml0bWFw IHRvIHN0b3JlIHRoZSBHUElPcycgdmFsdWVzIChnZXQpIG9yCisJCQkgIGEgYml0bWFwIG9mIHZh bHVlcyB0byBhc3NpZ24gdG8gdGhlIEdQSU9zIChzZXQpCiAKIFRoZSBkZXNjcmlwdG9yIGFycmF5 IGNhbiBiZSBvYnRhaW5lZCB1c2luZyB0aGUgZ3Bpb2RfZ2V0X2FycmF5KCkgZnVuY3Rpb24KIG9y IG9uZSBvZiBpdHMgdmFyaWFudHMuIElmIHRoZSBncm91cCBvZiBkZXNjcmlwdG9ycyByZXR1cm5l ZCBieSB0aGF0IGZ1bmN0aW9uCkBAIC0zNjYsNyArMzY2LDcgQEAgdGhlIHN0cnVjdCBncGlvX2Rl c2NzIHJldHVybmVkIGJ5IGdwaW9kX2dldF9hcnJheSgpOjoKIAogCXN0cnVjdCBncGlvX2Rlc2Nz ICpteV9ncGlvX2Rlc2NzID0gZ3Bpb2RfZ2V0X2FycmF5KC4uLik7CiAJZ3Bpb2Rfc2V0X2FycmF5 X3ZhbHVlKG15X2dwaW9fZGVzY3MtPm5kZXNjcywgbXlfZ3Bpb19kZXNjcy0+ZGVzYywKLQkJCSAg ICAgIG15X2dwaW9fdmFsdWVzKTsKKwkJCSAgICAgIG15X2dwaW9fdmFsdWVfYml0bWFwKTsKIAog SXQgaXMgYWxzbyBwb3NzaWJsZSB0byBhY2Nlc3MgYSBjb21wbGV0ZWx5IGFyYml0cmFyeSBhcnJh eSBvZiBkZXNjcmlwdG9ycy4gVGhlCiBkZXNjcmlwdG9ycyBtYXkgYmUgb2J0YWluZWQgdXNpbmcg YW55IGNvbWJpbmF0aW9uIG9mIGdwaW9kX2dldCgpIGFuZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9h dXhkaXNwbGF5L2hkNDQ3ODAuYyBiL2RyaXZlcnMvYXV4ZGlzcGxheS9oZDQ0NzgwLmMKaW5kZXgg ZjFhNDJmMGYxZGVkLi5lOWE4OTMzODQzNjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXV4ZGlzcGxh eS9oZDQ0NzgwLmMKKysrIGIvZHJpdmVycy9hdXhkaXNwbGF5L2hkNDQ3ODAuYwpAQCAtNjIsMTcg KzYyLDEyIEBAIHN0YXRpYyB2b2lkIGhkNDQ3ODBfc3Ryb2JlX2dwaW8oc3RydWN0IGhkNDQ3ODAg KmhkKQogLyogd3JpdGUgdG8gYW4gTENEIHBhbmVsIHJlZ2lzdGVyIGluIDggYml0IEdQSU8gbW9k ZSAqLwogc3RhdGljIHZvaWQgaGQ0NDc4MF93cml0ZV9ncGlvOChzdHJ1Y3QgaGQ0NDc4MCAqaGQs IHU4IHZhbCwgdW5zaWduZWQgaW50IHJzKQogewotCWludCB2YWx1ZXNbMTBdOwkvKiBmb3IgREFU QVswLTddLCBSUywgUlcgKi8KLQl1bnNpZ25lZCBpbnQgaSwgbjsKLQotCWZvciAoaSA9IDA7IGkg PCA4OyBpKyspCi0JCXZhbHVlc1tQSU5fREFUQTAgKyBpXSA9ICEhKHZhbCAmIEJJVChpKSk7Ci0J dmFsdWVzW1BJTl9DVFJMX1JTXSA9IHJzOwotCW4gPSA5OwotCWlmIChoZC0+cGluc1tQSU5fQ1RS TF9SV10pIHsKLQkJdmFsdWVzW1BJTl9DVFJMX1JXXSA9IDA7Ci0JCW4rKzsKLQl9CisJREVDTEFS RV9CSVRNQVAodmFsdWVzLCAxMCk7IC8qIGZvciBEQVRBWzAtN10sIFJTLCBSVyAqLworCXVuc2ln bmVkIGludCBuOworCisJdmFsdWVzWzBdID0gdmFsOworCV9fYXNzaWduX2JpdCg4LCB2YWx1ZXMs IHJzKTsKKwluID0gaGQtPnBpbnNbUElOX0NUUkxfUlddID8gMTAgOiA5OwogCiAJLyogUHJlc2Vu dCB0aGUgZGF0YSB0byB0aGUgcG9ydCAqLwogCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVl cChuLCAmaGQtPnBpbnNbUElOX0RBVEEwXSwgdmFsdWVzKTsKQEAgLTgzLDMyICs3OCwyNSBAQCBz dGF0aWMgdm9pZCBoZDQ0NzgwX3dyaXRlX2dwaW84KHN0cnVjdCBoZDQ0NzgwICpoZCwgdTggdmFs LCB1bnNpZ25lZCBpbnQgcnMpCiAvKiB3cml0ZSB0byBhbiBMQ0QgcGFuZWwgcmVnaXN0ZXIgaW4g NCBiaXQgR1BJTyBtb2RlICovCiBzdGF0aWMgdm9pZCBoZDQ0NzgwX3dyaXRlX2dwaW80KHN0cnVj dCBoZDQ0NzgwICpoZCwgdTggdmFsLCB1bnNpZ25lZCBpbnQgcnMpCiB7Ci0JaW50IHZhbHVlc1sx MF07CS8qIGZvciBEQVRBWzAtN10sIFJTLCBSVywgYnV0IERBVEFbMC0zXSBpcyB1bnVzZWQgKi8K LQl1bnNpZ25lZCBpbnQgaSwgbjsKKwlERUNMQVJFX0JJVE1BUCh2YWx1ZXMsIDYpOyAvKiBmb3Ig REFUQVs0LTddLCBSUywgUlcgKi8KKwl1bnNpZ25lZCBpbnQgbjsKIAogCS8qIEhpZ2ggbmliYmxl ICsgUlMsIFJXICovCi0JZm9yIChpID0gNDsgaSA8IDg7IGkrKykKLQkJdmFsdWVzW1BJTl9EQVRB MCArIGldID0gISEodmFsICYgQklUKGkpKTsKLQl2YWx1ZXNbUElOX0NUUkxfUlNdID0gcnM7Ci0J biA9IDU7Ci0JaWYgKGhkLT5waW5zW1BJTl9DVFJMX1JXXSkgewotCQl2YWx1ZXNbUElOX0NUUkxf UlddID0gMDsKLQkJbisrOwotCX0KKwl2YWx1ZXNbMF0gPSB2YWwgPj4gNDsKKwlfX2Fzc2lnbl9i aXQoNCwgdmFsdWVzLCBycyk7CisJbiA9IGhkLT5waW5zW1BJTl9DVFJMX1JXXSA/IDYgOiA1Owog CiAJLyogUHJlc2VudCB0aGUgZGF0YSB0byB0aGUgcG9ydCAqLwotCWdwaW9kX3NldF9hcnJheV92 YWx1ZV9jYW5zbGVlcChuLCAmaGQtPnBpbnNbUElOX0RBVEE0XSwKLQkJCQkgICAgICAgJnZhbHVl c1tQSU5fREFUQTRdKTsKKwlncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAobiwgJmhkLT5w aW5zW1BJTl9EQVRBNF0sIHZhbHVlcyk7CiAKIAloZDQ0NzgwX3N0cm9iZV9ncGlvKGhkKTsKIAog CS8qIExvdyBuaWJibGUgKi8KLQlmb3IgKGkgPSAwOyBpIDwgNDsgaSsrKQotCQl2YWx1ZXNbUElO X0RBVEE0ICsgaV0gPSAhISh2YWwgJiBCSVQoaSkpOworCXZhbHVlc1swXSAmPSB+MHgwZlVMOwor CXZhbHVlc1swXSB8PSB2YWwgJiAweDBmOwogCiAJLyogUHJlc2VudCB0aGUgZGF0YSB0byB0aGUg cG9ydCAqLwotCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcChuLCAmaGQtPnBpbnNbUElO X0RBVEE0XSwKLQkJCQkgICAgICAgJnZhbHVlc1tQSU5fREFUQTRdKTsKKwlncGlvZF9zZXRfYXJy YXlfdmFsdWVfY2Fuc2xlZXAobiwgJmhkLT5waW5zW1BJTl9EQVRBNF0sIHZhbHVlcyk7CiAKIAlo ZDQ0NzgwX3N0cm9iZV9ncGlvKGhkKTsKIH0KQEAgLTE1NSwyMyArMTQzLDE2IEBAIHN0YXRpYyB2 b2lkIGhkNDQ3ODBfd3JpdGVfY21kX2dwaW80KHN0cnVjdCBjaGFybGNkICpsY2QsIGludCBjbWQp CiAvKiBTZW5kIDQtYml0cyBvZiBhIGNvbW1hbmQgdG8gdGhlIExDRCBwYW5lbCBpbiByYXcgNCBi aXQgR1BJTyBtb2RlICovCiBzdGF0aWMgdm9pZCBoZDQ0NzgwX3dyaXRlX2NtZF9yYXdfZ3BpbzQo c3RydWN0IGNoYXJsY2QgKmxjZCwgaW50IGNtZCkKIHsKLQlpbnQgdmFsdWVzWzEwXTsJLyogZm9y IERBVEFbMC03XSwgUlMsIFJXLCBidXQgREFUQVswLTNdIGlzIHVudXNlZCAqLworCURFQ0xBUkVf QklUTUFQKHZhbHVlcywgNik7IC8qIGZvciBEQVRBWzQtN10sIFJTLCBSVyAqLwogCXN0cnVjdCBo ZDQ0NzgwICpoZCA9IGxjZC0+ZHJ2ZGF0YTsKLQl1bnNpZ25lZCBpbnQgaSwgbjsKKwl1bnNpZ25l ZCBpbnQgbjsKIAogCS8qIENvbW1hbmQgbmliYmxlICsgUlMsIFJXICovCi0JZm9yIChpID0gMDsg aSA8IDQ7IGkrKykKLQkJdmFsdWVzW1BJTl9EQVRBNCArIGldID0gISEoY21kICYgQklUKGkpKTsK LQl2YWx1ZXNbUElOX0NUUkxfUlNdID0gMDsKLQluID0gNTsKLQlpZiAoaGQtPnBpbnNbUElOX0NU UkxfUlddKSB7Ci0JCXZhbHVlc1tQSU5fQ1RSTF9SV10gPSAwOwotCQluKys7Ci0JfQorCXZhbHVl c1swXSA9IGNtZCAmIDB4MGY7CisJbiA9IGhkLT5waW5zW1BJTl9DVFJMX1JXXSA/IDYgOiA1Owog CiAJLyogUHJlc2VudCB0aGUgZGF0YSB0byB0aGUgcG9ydCAqLwotCWdwaW9kX3NldF9hcnJheV92 YWx1ZV9jYW5zbGVlcChuLCAmaGQtPnBpbnNbUElOX0RBVEE0XSwKLQkJCQkgICAgICAgJnZhbHVl c1tQSU5fREFUQTRdKTsKKwlncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAobiwgJmhkLT5w aW5zW1BJTl9EQVRBNF0sIHZhbHVlcyk7CiAKIAloZDQ0NzgwX3N0cm9iZV9ncGlvKGhkKTsKIH0K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvYnVzL3RzLW5idXMuYyBiL2RyaXZlcnMvYnVzL3RzLW5idXMu YwppbmRleCAwNzNmZDkwMTExNTQuLjhkZGU3Yzc3ZjYyYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9i dXMvdHMtbmJ1cy5jCisrKyBiL2RyaXZlcnMvYnVzL3RzLW5idXMuYwpAQCAtMTEwLDExICsxMTAs OSBAQCBzdGF0aWMgdm9pZCB0c19uYnVzX3NldF9kaXJlY3Rpb24oc3RydWN0IHRzX25idXMgKnRz X25idXMsIGludCBkaXJlY3Rpb24pCiAgKi8KIHN0YXRpYyB2b2lkIHRzX25idXNfcmVzZXRfYnVz KHN0cnVjdCB0c19uYnVzICp0c19uYnVzKQogewotCWludCBpOwotCWludCB2YWx1ZXNbOF07CisJ REVDTEFSRV9CSVRNQVAodmFsdWVzLCA4KTsKIAotCWZvciAoaSA9IDA7IGkgPCA4OyBpKyspCi0J CXZhbHVlc1tpXSA9IDA7CisJdmFsdWVzWzBdID0gMDsKIAogCWdwaW9kX3NldF9hcnJheV92YWx1 ZV9jYW5zbGVlcCg4LCB0c19uYnVzLT5kYXRhLT5kZXNjLCB2YWx1ZXMpOwogCWdwaW9kX3NldF92 YWx1ZV9jYW5zbGVlcCh0c19uYnVzLT5jc24sIDApOwpAQCAtMTU3LDE0ICsxNTUsOSBAQCBzdGF0 aWMgaW50IHRzX25idXNfcmVhZF9ieXRlKHN0cnVjdCB0c19uYnVzICp0c19uYnVzLCB1OCAqdmFs KQogc3RhdGljIHZvaWQgdHNfbmJ1c193cml0ZV9ieXRlKHN0cnVjdCB0c19uYnVzICp0c19uYnVz LCB1OCBieXRlKQogewogCXN0cnVjdCBncGlvX2Rlc2NzICpncGlvcyA9IHRzX25idXMtPmRhdGE7 Ci0JaW50IGk7Ci0JaW50IHZhbHVlc1s4XTsKKwlERUNMQVJFX0JJVE1BUCh2YWx1ZXMsIDgpOwog Ci0JZm9yIChpID0gMDsgaSA8IDg7IGkrKykKLQkJaWYgKGJ5dGUgJiBCSVQoaSkpCi0JCQl2YWx1 ZXNbaV0gPSAxOwotCQllbHNlCi0JCQl2YWx1ZXNbaV0gPSAwOworCXZhbHVlc1swXSA9IGJ5dGU7 CiAKIAlncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAoOCwgZ3Bpb3MtPmRlc2MsIHZhbHVl cyk7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwaW8vZ3Bpby1tYXgzMTkxeC5jIGIvZHJpdmVy cy9ncGlvL2dwaW8tbWF4MzE5MXguYwppbmRleCBiNWI5Y2IxZmRhNTAuLmJkNGEyNDVmYzVhMCAx MDA2NDQKLS0tIGEvZHJpdmVycy9ncGlvL2dwaW8tbWF4MzE5MXguYworKysgYi9kcml2ZXJzL2dw aW8vZ3Bpby1tYXgzMTkxeC5jCkBAIC0zMTUsMTQgKzMxNSwxNiBAQCBzdGF0aWMgdm9pZCBncGlv ZF9zZXRfYXJyYXlfc2luZ2xlX3ZhbHVlX2NhbnNsZWVwKHVuc2lnbmVkIGludCBuZGVzY3MsCiAJ CQkJCQkgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjLAogCQkJCQkJICBpbnQgdmFsdWUpCiB7Ci0J aW50IGksICp2YWx1ZXM7CisJdW5zaWduZWQgbG9uZyAqdmFsdWVzOwogCi0JdmFsdWVzID0ga21h bGxvY19hcnJheShuZGVzY3MsIHNpemVvZigqdmFsdWVzKSwgR0ZQX0tFUk5FTCk7CisJdmFsdWVz ID0gYml0bWFwX2FsbG9jKG5kZXNjcywgR0ZQX0tFUk5FTCk7CiAJaWYgKCF2YWx1ZXMpCiAJCXJl dHVybjsKIAotCWZvciAoaSA9IDA7IGkgPCBuZGVzY3M7IGkrKykKLQkJdmFsdWVzW2ldID0gdmFs dWU7CisJaWYgKHZhbHVlKQorCQliaXRtYXBfZmlsbCh2YWx1ZXMsIG5kZXNjcyk7CisJZWxzZQor CQliaXRtYXBfemVybyh2YWx1ZXMsIG5kZXNjcyk7CiAKIAlncGlvZF9zZXRfYXJyYXlfdmFsdWVf Y2Fuc2xlZXAobmRlc2NzLCBkZXNjLCB2YWx1ZXMpOwogCWtmcmVlKHZhbHVlcyk7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi5jIGIvZHJpdmVycy9ncGlvL2dwaW9saWIuYwppbmRl eCBlOGY4YTE5OTkzOTMuLmI2NmIyMTkxYzVjNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncGlvL2dw aW9saWIuYworKysgYi9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi5jCkBAIC00MjcsNyArNDI3LDcgQEAg c3RhdGljIGxvbmcgbGluZWhhbmRsZV9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlsZXAsIHVuc2lnbmVk IGludCBjbWQsCiAJc3RydWN0IGxpbmVoYW5kbGVfc3RhdGUgKmxoID0gZmlsZXAtPnByaXZhdGVf ZGF0YTsKIAl2b2lkIF9fdXNlciAqaXAgPSAodm9pZCBfX3VzZXIgKilhcmc7CiAJc3RydWN0IGdw aW9oYW5kbGVfZGF0YSBnaGQ7Ci0JaW50IHZhbHNbR1BJT0hBTkRMRVNfTUFYXTsKKwlERUNMQVJF X0JJVE1BUCh2YWxzLCBHUElPSEFORExFU19NQVgpOwogCWludCBpOwogCiAJaWYgKGNtZCA9PSBH UElPSEFORExFX0dFVF9MSU5FX1ZBTFVFU19JT0NUTCkgewpAQCAtNDQyLDcgKzQ0Miw3IEBAIHN0 YXRpYyBsb25nIGxpbmVoYW5kbGVfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGVwLCB1bnNpZ25lZCBp bnQgY21kLAogCiAJCW1lbXNldCgmZ2hkLCAwLCBzaXplb2YoZ2hkKSk7CiAJCWZvciAoaSA9IDA7 IGkgPCBsaC0+bnVtZGVzY3M7IGkrKykKLQkJCWdoZC52YWx1ZXNbaV0gPSB2YWxzW2ldOworCQkJ Z2hkLnZhbHVlc1tpXSA9IHRlc3RfYml0KGksIHZhbHMpOwogCiAJCWlmIChjb3B5X3RvX3VzZXIo aXAsICZnaGQsIHNpemVvZihnaGQpKSkKIAkJCXJldHVybiAtRUZBVUxUOwpAQCAtNDYxLDcgKzQ2 MSw3IEBAIHN0YXRpYyBsb25nIGxpbmVoYW5kbGVfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGVwLCB1 bnNpZ25lZCBpbnQgY21kLAogCiAJCS8qIENsYW1wIGFsbCB2YWx1ZXMgdG8gWzAsMV0gKi8KIAkJ Zm9yIChpID0gMDsgaSA8IGxoLT5udW1kZXNjczsgaSsrKQotCQkJdmFsc1tpXSA9ICEhZ2hkLnZh bHVlc1tpXTsKKwkJCV9fYXNzaWduX2JpdChpLCB2YWxzLCBnaGQudmFsdWVzW2ldKTsKIAogCQkv KiBSZXVzZSB0aGUgYXJyYXkgc2V0dGluZyBmdW5jdGlvbiAqLwogCQlyZXR1cm4gZ3Bpb2Rfc2V0 X2FycmF5X3ZhbHVlX2NvbXBsZXgoZmFsc2UsCkBAIC0yNzg0LDcgKzI3ODQsNyBAQCBzdGF0aWMg aW50IGdwaW9fY2hpcF9nZXRfbXVsdGlwbGUoc3RydWN0IGdwaW9fY2hpcCAqY2hpcCwKIGludCBn cGlvZF9nZXRfYXJyYXlfdmFsdWVfY29tcGxleChib29sIHJhdywgYm9vbCBjYW5fc2xlZXAsCiAJ CQkJICB1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgIHN0cnVjdCBncGlvX2Rlc2MgKipk ZXNjX2FycmF5LAotCQkJCSAgaW50ICp2YWx1ZV9hcnJheSkKKwkJCQkgIHVuc2lnbmVkIGxvbmcg KnZhbHVlX2JpdG1hcCkKIHsKIAlpbnQgaSA9IDA7CiAKQEAgLTI4MzUsNyArMjgzNSw3IEBAIGlu dCBncGlvZF9nZXRfYXJyYXlfdmFsdWVfY29tcGxleChib29sIHJhdywgYm9vbCBjYW5fc2xlZXAs CiAKIAkJCWlmICghcmF3ICYmIHRlc3RfYml0KEZMQUdfQUNUSVZFX0xPVywgJmRlc2MtPmZsYWdz KSkKIAkJCQl2YWx1ZSA9ICF2YWx1ZTsKLQkJCXZhbHVlX2FycmF5W2pdID0gdmFsdWU7CisJCQlf X2Fzc2lnbl9iaXQoaiwgdmFsdWVfYml0bWFwLCB2YWx1ZSk7CiAJCQl0cmFjZV9ncGlvX3ZhbHVl KGRlc2NfdG9fZ3BpbyhkZXNjKSwgMSwgdmFsdWUpOwogCQl9CiAKQEAgLTI4OTUsOSArMjg5NSw5 IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX2dldF92YWx1ZSk7CiAKIC8qKgogICogZ3Bpb2Rf Z2V0X3Jhd19hcnJheV92YWx1ZSgpIC0gcmVhZCByYXcgdmFsdWVzIGZyb20gYW4gYXJyYXkgb2Yg R1BJT3MKLSAqIEBhcnJheV9zaXplOiBudW1iZXIgb2YgZWxlbWVudHMgaW4gdGhlIGRlc2NyaXB0 b3IgLyB2YWx1ZSBhcnJheXMKKyAqIEBhcnJheV9zaXplOiBudW1iZXIgb2YgZWxlbWVudHMgaW4g dGhlIGRlc2NyaXB0b3IgYXJyYXkgLyB2YWx1ZSBiaXRtYXAKICAqIEBkZXNjX2FycmF5OiBhcnJh eSBvZiBHUElPIGRlc2NyaXB0b3JzIHdob3NlIHZhbHVlcyB3aWxsIGJlIHJlYWQKLSAqIEB2YWx1 ZV9hcnJheTogYXJyYXkgdG8gc3RvcmUgdGhlIHJlYWQgdmFsdWVzCisgKiBAdmFsdWVfYml0bWFw OiBiaXRtYXAgdG8gc3RvcmUgdGhlIHJlYWQgdmFsdWVzCiAgKgogICogUmVhZCB0aGUgcmF3IHZh bHVlcyBvZiB0aGUgR1BJT3MsIGkuZS4gdGhlIHZhbHVlcyBvZiB0aGUgcGh5c2ljYWwgbGluZXMK ICAqIHdpdGhvdXQgcmVnYXJkIGZvciB0aGVpciBBQ1RJVkVfTE9XIHN0YXR1cy4gIFJldHVybiAw IGluIGNhc2Ugb2Ygc3VjY2VzcywKQEAgLTI5MDcsMjAgKzI5MDcsMjEgQEAgRVhQT1JUX1NZTUJP TF9HUEwoZ3Bpb2RfZ2V0X3ZhbHVlKTsKICAqIGFuZCBpdCB3aWxsIGNvbXBsYWluIGlmIHRoZSBH UElPIGNoaXAgZnVuY3Rpb25zIHBvdGVudGlhbGx5IHNsZWVwLgogICovCiBpbnQgZ3Bpb2RfZ2V0 X3Jhd19hcnJheV92YWx1ZSh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKLQkJCSAgICAgIHN0cnVj dCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LCBpbnQgKnZhbHVlX2FycmF5KQorCQkJICAgICAgc3Ry dWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCisJCQkgICAgICB1bnNpZ25lZCBsb25nICp2YWx1 ZV9iaXRtYXApCiB7CiAJaWYgKCFkZXNjX2FycmF5KQogCQlyZXR1cm4gLUVJTlZBTDsKIAlyZXR1 cm4gZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgodHJ1ZSwgZmFsc2UsIGFycmF5X3NpemUs Ci0JCQkJCSAgICAgZGVzY19hcnJheSwgdmFsdWVfYXJyYXkpOworCQkJCQkgICAgIGRlc2NfYXJy YXksIHZhbHVlX2JpdG1hcCk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9nZXRfcmF3X2Fy cmF5X3ZhbHVlKTsKIAogLyoqCiAgKiBncGlvZF9nZXRfYXJyYXlfdmFsdWUoKSAtIHJlYWQgdmFs dWVzIGZyb20gYW4gYXJyYXkgb2YgR1BJT3MKLSAqIEBhcnJheV9zaXplOiBudW1iZXIgb2YgZWxl bWVudHMgaW4gdGhlIGRlc2NyaXB0b3IgLyB2YWx1ZSBhcnJheXMKKyAqIEBhcnJheV9zaXplOiBu dW1iZXIgb2YgZWxlbWVudHMgaW4gdGhlIGRlc2NyaXB0b3IgYXJyYXkgLyB2YWx1ZSBiaXRtYXAK ICAqIEBkZXNjX2FycmF5OiBhcnJheSBvZiBHUElPIGRlc2NyaXB0b3JzIHdob3NlIHZhbHVlcyB3 aWxsIGJlIHJlYWQKLSAqIEB2YWx1ZV9hcnJheTogYXJyYXkgdG8gc3RvcmUgdGhlIHJlYWQgdmFs dWVzCisgKiBAdmFsdWVfYml0bWFwOiBiaXRtYXAgdG8gc3RvcmUgdGhlIHJlYWQgdmFsdWVzCiAg KgogICogUmVhZCB0aGUgbG9naWNhbCB2YWx1ZXMgb2YgdGhlIEdQSU9zLCBpLmUuIHRha2luZyB0 aGVpciBBQ1RJVkVfTE9XIHN0YXR1cwogICogaW50byBhY2NvdW50LiAgUmV0dXJuIDAgaW4gY2Fz ZSBvZiBzdWNjZXNzLCBlbHNlIGFuIGVycm9yIGNvZGUuCkBAIC0yOTI5LDEyICsyOTMwLDEzIEBA IEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWUpOwogICogYW5kIGl0 IHdpbGwgY29tcGxhaW4gaWYgdGhlIEdQSU8gY2hpcCBmdW5jdGlvbnMgcG90ZW50aWFsbHkgc2xl ZXAuCiAgKi8KIGludCBncGlvZF9nZXRfYXJyYXlfdmFsdWUodW5zaWduZWQgaW50IGFycmF5X3Np emUsCi0JCQkgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LCBpbnQgKnZhbHVlX2FycmF5 KQorCQkJICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCSAgdW5zaWduZWQgbG9u ZyAqdmFsdWVfYml0bWFwKQogewogCWlmICghZGVzY19hcnJheSkKIAkJcmV0dXJuIC1FSU5WQUw7 CiAJcmV0dXJuIGdwaW9kX2dldF9hcnJheV92YWx1ZV9jb21wbGV4KGZhbHNlLCBmYWxzZSwgYXJy YXlfc2l6ZSwKLQkJCQkJICAgICBkZXNjX2FycmF5LCB2YWx1ZV9hcnJheSk7CisJCQkJCSAgICAg ZGVzY19hcnJheSwgdmFsdWVfYml0bWFwKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX2dl dF9hcnJheV92YWx1ZSk7CiAKQEAgLTMwMjcsNyArMzAyOSw3IEBAIHN0YXRpYyB2b2lkIGdwaW9f Y2hpcF9zZXRfbXVsdGlwbGUoc3RydWN0IGdwaW9fY2hpcCAqY2hpcCwKIGludCBncGlvZF9zZXRf YXJyYXlfdmFsdWVfY29tcGxleChib29sIHJhdywgYm9vbCBjYW5fc2xlZXAsCiAJCQkJICAgdW5z aWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJy YXksCi0JCQkJICAgaW50ICp2YWx1ZV9hcnJheSkKKwkJCQkgICB1bnNpZ25lZCBsb25nICp2YWx1 ZV9iaXRtYXApCiB7CiAJaW50IGkgPSAwOwogCkBAIC0zMDU2LDcgKzMwNTgsNyBAQCBpbnQgZ3Bp b2Rfc2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgoYm9vbCByYXcsIGJvb2wgY2FuX3NsZWVwLAogCQlk byB7CiAJCQlzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNjID0gZGVzY19hcnJheVtpXTsKIAkJCWludCBo d2dwaW8gPSBncGlvX2NoaXBfaHdncGlvKGRlc2MpOwotCQkJaW50IHZhbHVlID0gdmFsdWVfYXJy YXlbaV07CisJCQlpbnQgdmFsdWUgPSB0ZXN0X2JpdChpLCB2YWx1ZV9iaXRtYXApOwogCiAJCQlp ZiAoIXJhdyAmJiB0ZXN0X2JpdChGTEFHX0FDVElWRV9MT1csICZkZXNjLT5mbGFncykpCiAJCQkJ dmFsdWUgPSAhdmFsdWU7CkBAIC0zMTUyLDkgKzMxNTQsOSBAQCBFWFBPUlRfU1lNQk9MX0dQTChn cGlvZF9zZXRfdmFsdWUpOwogCiAvKioKICAqIGdwaW9kX3NldF9yYXdfYXJyYXlfdmFsdWUoKSAt IGFzc2lnbiB2YWx1ZXMgdG8gYW4gYXJyYXkgb2YgR1BJT3MKLSAqIEBhcnJheV9zaXplOiBudW1i ZXIgb2YgZWxlbWVudHMgaW4gdGhlIGRlc2NyaXB0b3IgLyB2YWx1ZSBhcnJheXMKKyAqIEBhcnJh eV9zaXplOiBudW1iZXIgb2YgZWxlbWVudHMgaW4gdGhlIGRlc2NyaXB0b3IgYXJyYXkgLyB2YWx1 ZSBiaXRtYXAKICAqIEBkZXNjX2FycmF5OiBhcnJheSBvZiBHUElPIGRlc2NyaXB0b3JzIHdob3Nl IHZhbHVlcyB3aWxsIGJlIGFzc2lnbmVkCi0gKiBAdmFsdWVfYXJyYXk6IGFycmF5IG9mIHZhbHVl cyB0byBhc3NpZ24KKyAqIEB2YWx1ZV9iaXRtYXA6IGJpdG1hcCBvZiB2YWx1ZXMgdG8gYXNzaWdu CiAgKgogICogU2V0IHRoZSByYXcgdmFsdWVzIG9mIHRoZSBHUElPcywgaS5lLiB0aGUgdmFsdWVz IG9mIHRoZSBwaHlzaWNhbCBsaW5lcwogICogd2l0aG91dCByZWdhcmQgZm9yIHRoZWlyIEFDVElW RV9MT1cgc3RhdHVzLgpAQCAtMzE2MywyMCArMzE2NSwyMSBAQCBFWFBPUlRfU1lNQk9MX0dQTChn cGlvZF9zZXRfdmFsdWUpOwogICogY29tcGxhaW4gaWYgdGhlIEdQSU8gY2hpcCBmdW5jdGlvbnMg cG90ZW50aWFsbHkgc2xlZXAuCiAgKi8KIGludCBncGlvZF9zZXRfcmF3X2FycmF5X3ZhbHVlKHVu c2lnbmVkIGludCBhcnJheV9zaXplLAotCQkJIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5 LCBpbnQgKnZhbHVlX2FycmF5KQorCQkJIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAor CQkJIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIHsKIAlpZiAoIWRlc2NfYXJyYXkpCiAJ CXJldHVybiAtRUlOVkFMOwogCXJldHVybiBncGlvZF9zZXRfYXJyYXlfdmFsdWVfY29tcGxleCh0 cnVlLCBmYWxzZSwgYXJyYXlfc2l6ZSwKLQkJCQkJZGVzY19hcnJheSwgdmFsdWVfYXJyYXkpOwor CQkJCQlkZXNjX2FycmF5LCB2YWx1ZV9iaXRtYXApOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZ3Bp b2Rfc2V0X3Jhd19hcnJheV92YWx1ZSk7CiAKIC8qKgogICogZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVl KCkgLSBhc3NpZ24gdmFsdWVzIHRvIGFuIGFycmF5IG9mIEdQSU9zCi0gKiBAYXJyYXlfc2l6ZTog bnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkZXNjcmlwdG9yIC8gdmFsdWUgYXJyYXlzCisgKiBA YXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkZXNjcmlwdG9yIGFycmF5IC8g dmFsdWUgYml0bWFwCiAgKiBAZGVzY19hcnJheTogYXJyYXkgb2YgR1BJTyBkZXNjcmlwdG9ycyB3 aG9zZSB2YWx1ZXMgd2lsbCBiZSBhc3NpZ25lZAotICogQHZhbHVlX2FycmF5OiBhcnJheSBvZiB2 YWx1ZXMgdG8gYXNzaWduCisgKiBAdmFsdWVfYml0bWFwOiBiaXRtYXAgb2YgdmFsdWVzIHRvIGFz c2lnbgogICoKICAqIFNldCB0aGUgbG9naWNhbCB2YWx1ZXMgb2YgdGhlIEdQSU9zLCBpLmUuIHRh a2luZyB0aGVpciBBQ1RJVkVfTE9XIHN0YXR1cwogICogaW50byBhY2NvdW50LgpAQCAtMzE4NSwx MiArMzE4OCwxMyBAQCBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9zZXRfcmF3X2FycmF5X3ZhbHVl KTsKICAqIGNvbXBsYWluIGlmIHRoZSBHUElPIGNoaXAgZnVuY3Rpb25zIHBvdGVudGlhbGx5IHNs ZWVwLgogICovCiB2b2lkIGdwaW9kX3NldF9hcnJheV92YWx1ZSh1bnNpZ25lZCBpbnQgYXJyYXlf c2l6ZSwKLQkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LCBpbnQgKnZhbHVlX2Fy cmF5KQorCQkJICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCisJCQkgICB1bnNpZ25l ZCBsb25nICp2YWx1ZV9iaXRtYXApCiB7CiAJaWYgKCFkZXNjX2FycmF5KQogCQlyZXR1cm47CiAJ Z3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgoZmFsc2UsIGZhbHNlLCBhcnJheV9zaXplLCBk ZXNjX2FycmF5LAotCQkJCSAgICAgIHZhbHVlX2FycmF5KTsKKwkJCQkgICAgICB2YWx1ZV9iaXRt YXApOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlKTsKIApAQCAt MzQxMCw5ICszNDE0LDkgQEAgRVhQT1JUX1NZTUJPTF9HUEwoZ3Bpb2RfZ2V0X3ZhbHVlX2NhbnNs ZWVwKTsKIAogLyoqCiAgKiBncGlvZF9nZXRfcmF3X2FycmF5X3ZhbHVlX2NhbnNsZWVwKCkgLSBy ZWFkIHJhdyB2YWx1ZXMgZnJvbSBhbiBhcnJheSBvZiBHUElPcwotICogQGFycmF5X3NpemU6IG51 bWJlciBvZiBlbGVtZW50cyBpbiB0aGUgZGVzY3JpcHRvciAvIHZhbHVlIGFycmF5cworICogQGFy cmF5X3NpemU6IG51bWJlciBvZiBlbGVtZW50cyBpbiB0aGUgZGVzY3JpcHRvciBhcnJheSAvIHZh bHVlIGJpdG1hcAogICogQGRlc2NfYXJyYXk6IGFycmF5IG9mIEdQSU8gZGVzY3JpcHRvcnMgd2hv c2UgdmFsdWVzIHdpbGwgYmUgcmVhZAotICogQHZhbHVlX2FycmF5OiBhcnJheSB0byBzdG9yZSB0 aGUgcmVhZCB2YWx1ZXMKKyAqIEB2YWx1ZV9iaXRtYXA6IGJpdG1hcCB0byBzdG9yZSB0aGUgcmVh ZCB2YWx1ZXMKICAqCiAgKiBSZWFkIHRoZSByYXcgdmFsdWVzIG9mIHRoZSBHUElPcywgaS5lLiB0 aGUgdmFsdWVzIG9mIHRoZSBwaHlzaWNhbCBsaW5lcwogICogd2l0aG91dCByZWdhcmQgZm9yIHRo ZWlyIEFDVElWRV9MT1cgc3RhdHVzLiAgUmV0dXJuIDAgaW4gY2FzZSBvZiBzdWNjZXNzLApAQCAt MzQyMiwyMSArMzQyNiwyMSBAQCBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9nZXRfdmFsdWVfY2Fu c2xlZXApOwogICovCiBpbnQgZ3Bpb2RfZ2V0X3Jhd19hcnJheV92YWx1ZV9jYW5zbGVlcCh1bnNp Z25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgICAgICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2Nf YXJyYXksCi0JCQkJICAgICAgIGludCAqdmFsdWVfYXJyYXkpCisJCQkJICAgICAgIHVuc2lnbmVk IGxvbmcgKnZhbHVlX2JpdG1hcCkKIHsKIAltaWdodF9zbGVlcF9pZihleHRyYV9jaGVja3MpOwog CWlmICghZGVzY19hcnJheSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJcmV0dXJuIGdwaW9kX2dldF9h cnJheV92YWx1ZV9jb21wbGV4KHRydWUsIHRydWUsIGFycmF5X3NpemUsCi0JCQkJCSAgICAgZGVz Y19hcnJheSwgdmFsdWVfYXJyYXkpOworCQkJCQkgICAgIGRlc2NfYXJyYXksIHZhbHVlX2JpdG1h cCk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9nZXRfcmF3X2FycmF5X3ZhbHVlX2NhbnNs ZWVwKTsKIAogLyoqCiAgKiBncGlvZF9nZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAoKSAtIHJlYWQg dmFsdWVzIGZyb20gYW4gYXJyYXkgb2YgR1BJT3MKLSAqIEBhcnJheV9zaXplOiBudW1iZXIgb2Yg ZWxlbWVudHMgaW4gdGhlIGRlc2NyaXB0b3IgLyB2YWx1ZSBhcnJheXMKKyAqIEBhcnJheV9zaXpl OiBudW1iZXIgb2YgZWxlbWVudHMgaW4gdGhlIGRlc2NyaXB0b3IgYXJyYXkgLyB2YWx1ZSBiaXRt YXAKICAqIEBkZXNjX2FycmF5OiBhcnJheSBvZiBHUElPIGRlc2NyaXB0b3JzIHdob3NlIHZhbHVl cyB3aWxsIGJlIHJlYWQKLSAqIEB2YWx1ZV9hcnJheTogYXJyYXkgdG8gc3RvcmUgdGhlIHJlYWQg dmFsdWVzCisgKiBAdmFsdWVfYml0bWFwOiBiaXRtYXAgdG8gc3RvcmUgdGhlIHJlYWQgdmFsdWVz CiAgKgogICogUmVhZCB0aGUgbG9naWNhbCB2YWx1ZXMgb2YgdGhlIEdQSU9zLCBpLmUuIHRha2lu ZyB0aGVpciBBQ1RJVkVfTE9XIHN0YXR1cwogICogaW50byBhY2NvdW50LiAgUmV0dXJuIDAgaW4g Y2FzZSBvZiBzdWNjZXNzLCBlbHNlIGFuIGVycm9yIGNvZGUuCkBAIC0zNDQ1LDEzICszNDQ5LDEz IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAp OwogICovCiBpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKHVuc2lnbmVkIGludCBh cnJheV9zaXplLAogCQkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCSAg IGludCAqdmFsdWVfYXJyYXkpCisJCQkJICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQog ewogCW1pZ2h0X3NsZWVwX2lmKGV4dHJhX2NoZWNrcyk7CiAJaWYgKCFkZXNjX2FycmF5KQogCQly ZXR1cm4gLUVJTlZBTDsKIAlyZXR1cm4gZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgoZmFs c2UsIHRydWUsIGFycmF5X3NpemUsCi0JCQkJCSAgICAgZGVzY19hcnJheSwgdmFsdWVfYXJyYXkp OworCQkJCQkgICAgIGRlc2NfYXJyYXksIHZhbHVlX2JpdG1hcCk7CiB9CiBFWFBPUlRfU1lNQk9M X0dQTChncGlvZF9nZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXApOwogCkBAIC0zNDkzLDkgKzM0OTcs OSBAQCBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXApOwogCiAvKioK ICAqIGdwaW9kX3NldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAoKSAtIGFzc2lnbiB2YWx1ZXMg dG8gYW4gYXJyYXkgb2YgR1BJT3MKLSAqIEBhcnJheV9zaXplOiBudW1iZXIgb2YgZWxlbWVudHMg aW4gdGhlIGRlc2NyaXB0b3IgLyB2YWx1ZSBhcnJheXMKKyAqIEBhcnJheV9zaXplOiBudW1iZXIg b2YgZWxlbWVudHMgaW4gdGhlIGRlc2NyaXB0b3IgYXJyYXkgLyB2YWx1ZSBiaXRtYXAKICAqIEBk ZXNjX2FycmF5OiBhcnJheSBvZiBHUElPIGRlc2NyaXB0b3JzIHdob3NlIHZhbHVlcyB3aWxsIGJl IGFzc2lnbmVkCi0gKiBAdmFsdWVfYXJyYXk6IGFycmF5IG9mIHZhbHVlcyB0byBhc3NpZ24KKyAq IEB2YWx1ZV9iaXRtYXA6IGJpdG1hcCBvZiB2YWx1ZXMgdG8gYXNzaWduCiAgKgogICogU2V0IHRo ZSByYXcgdmFsdWVzIG9mIHRoZSBHUElPcywgaS5lLiB0aGUgdmFsdWVzIG9mIHRoZSBwaHlzaWNh bCBsaW5lcwogICogd2l0aG91dCByZWdhcmQgZm9yIHRoZWlyIEFDVElWRV9MT1cgc3RhdHVzLgpA QCAtMzUwNCwxMyArMzUwOCwxMyBAQCBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9zZXRfdmFsdWVf Y2Fuc2xlZXApOwogICovCiBpbnQgZ3Bpb2Rfc2V0X3Jhd19hcnJheV92YWx1ZV9jYW5zbGVlcCh1 bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkJc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJy YXksCi0JCQkJCWludCAqdmFsdWVfYXJyYXkpCisJCQkJCXVuc2lnbmVkIGxvbmcgKnZhbHVlX2Jp dG1hcCkKIHsKIAltaWdodF9zbGVlcF9pZihleHRyYV9jaGVja3MpOwogCWlmICghZGVzY19hcnJh eSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJcmV0dXJuIGdwaW9kX3NldF9hcnJheV92YWx1ZV9jb21w bGV4KHRydWUsIHRydWUsIGFycmF5X3NpemUsIGRlc2NfYXJyYXksCi0JCQkJICAgICAgdmFsdWVf YXJyYXkpOworCQkJCSAgICAgIHZhbHVlX2JpdG1hcCk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChn cGlvZF9zZXRfcmF3X2FycmF5X3ZhbHVlX2NhbnNsZWVwKTsKIApAQCAtMzUzMyw5ICszNTM3LDkg QEAgdm9pZCBncGlvZF9hZGRfbG9va3VwX3RhYmxlcyhzdHJ1Y3QgZ3Bpb2RfbG9va3VwX3RhYmxl ICoqdGFibGVzLCBzaXplX3QgbikKIAogLyoqCiAgKiBncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fu c2xlZXAoKSAtIGFzc2lnbiB2YWx1ZXMgdG8gYW4gYXJyYXkgb2YgR1BJT3MKLSAqIEBhcnJheV9z aXplOiBudW1iZXIgb2YgZWxlbWVudHMgaW4gdGhlIGRlc2NyaXB0b3IgLyB2YWx1ZSBhcnJheXMK KyAqIEBhcnJheV9zaXplOiBudW1iZXIgb2YgZWxlbWVudHMgaW4gdGhlIGRlc2NyaXB0b3IgYXJy YXkgLyB2YWx1ZSBiaXRtYXAKICAqIEBkZXNjX2FycmF5OiBhcnJheSBvZiBHUElPIGRlc2NyaXB0 b3JzIHdob3NlIHZhbHVlcyB3aWxsIGJlIGFzc2lnbmVkCi0gKiBAdmFsdWVfYXJyYXk6IGFycmF5 IG9mIHZhbHVlcyB0byBhc3NpZ24KKyAqIEB2YWx1ZV9iaXRtYXA6IGJpdG1hcCBvZiB2YWx1ZXMg dG8gYXNzaWduCiAgKgogICogU2V0IHRoZSBsb2dpY2FsIHZhbHVlcyBvZiB0aGUgR1BJT3MsIGku ZS4gdGFraW5nIHRoZWlyIEFDVElWRV9MT1cgc3RhdHVzCiAgKiBpbnRvIGFjY291bnQuCkBAIC0z NTQ0LDEzICszNTQ4LDEzIEBAIHZvaWQgZ3Bpb2RfYWRkX2xvb2t1cF90YWJsZXMoc3RydWN0IGdw aW9kX2xvb2t1cF90YWJsZSAqKnRhYmxlcywgc2l6ZV90IG4pCiAgKi8KIHZvaWQgZ3Bpb2Rfc2V0 X2FycmF5X3ZhbHVlX2NhbnNsZWVwKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCSAgICBz dHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkgICAgaW50ICp2YWx1ZV9hcnJheSkK KwkJCQkgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogewogCW1pZ2h0X3NsZWVwX2lm KGV4dHJhX2NoZWNrcyk7CiAJaWYgKCFkZXNjX2FycmF5KQogCQlyZXR1cm47CiAJZ3Bpb2Rfc2V0 X2FycmF5X3ZhbHVlX2NvbXBsZXgoZmFsc2UsIHRydWUsIGFycmF5X3NpemUsIGRlc2NfYXJyYXks Ci0JCQkJICAgICAgdmFsdWVfYXJyYXkpOworCQkJCSAgICAgIHZhbHVlX2JpdG1hcCk7CiB9CiBF WFBPUlRfU1lNQk9MX0dQTChncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXApOwogCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi5oIGIvZHJpdmVycy9ncGlvL2dwaW9saWIuaApp bmRleCBhN2U0OWZlZjczZDQuLjExZTgzZDJlZWY4OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncGlv L2dwaW9saWIuaAorKysgYi9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi5oCkBAIC0xODcsMTEgKzE4Nywx MSBAQCBzdHJ1Y3QgZ3Bpb19kZXNjICpncGlvY2hpcF9nZXRfZGVzYyhzdHJ1Y3QgZ3Bpb19jaGlw ICpjaGlwLCB1MTYgaHdudW0pOwogaW50IGdwaW9kX2dldF9hcnJheV92YWx1ZV9jb21wbGV4KGJv b2wgcmF3LCBib29sIGNhbl9zbGVlcCwKIAkJCQkgIHVuc2lnbmVkIGludCBhcnJheV9zaXplLAog CQkJCSAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJICBpbnQgKnZhbHVlX2Fy cmF5KTsKKwkJCQkgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCk7CiBpbnQgZ3Bpb2Rfc2V0 X2FycmF5X3ZhbHVlX2NvbXBsZXgoYm9vbCByYXcsIGJvb2wgY2FuX3NsZWVwLAogCQkJCSAgIHVu c2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2Fy cmF5LAotCQkJCSAgIGludCAqdmFsdWVfYXJyYXkpOworCQkJCSAgIHVuc2lnbmVkIGxvbmcgKnZh bHVlX2JpdG1hcCk7CiAKIC8qIFRoaXMgaXMganVzdCBwYXNzZWQgYmV0d2VlbiBncGlvbGliIGFu ZCBkZXZyZXMgKi8KIHN0cnVjdCBncGlvX2Rlc2MgKmdwaW9kX2dldF9mcm9tX29mX25vZGUoc3Ry dWN0IGRldmljZV9ub2RlICpub2RlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pMmMvbXV4ZXMvaTJj LW11eC1ncGlvLmMgYi9kcml2ZXJzL2kyYy9tdXhlcy9pMmMtbXV4LWdwaW8uYwppbmRleCA0MDEz MDhlM2QwMzYuLmQ4MzU4NTdiYjA5NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pMmMvbXV4ZXMvaTJj LW11eC1ncGlvLmMKKysrIGIvZHJpdmVycy9pMmMvbXV4ZXMvaTJjLW11eC1ncGlvLmMKQEAgLTIy LDE4ICsyMiwxNSBAQCBzdHJ1Y3QgZ3Bpb211eCB7CiAJc3RydWN0IGkyY19tdXhfZ3Bpb19wbGF0 Zm9ybV9kYXRhIGRhdGE7CiAJdW5zaWduZWQgZ3Bpb19iYXNlOwogCXN0cnVjdCBncGlvX2Rlc2Mg KipncGlvczsKLQlpbnQgKnZhbHVlczsKIH07CiAKIHN0YXRpYyB2b2lkIGkyY19tdXhfZ3Bpb19z ZXQoY29uc3Qgc3RydWN0IGdwaW9tdXggKm11eCwgdW5zaWduZWQgdmFsKQogewotCWludCBpOwor CURFQ0xBUkVfQklUTUFQKHZhbHVlcywgQklUU19QRVJfVFlQRSh2YWwpKTsKIAotCWZvciAoaSA9 IDA7IGkgPCBtdXgtPmRhdGEubl9ncGlvczsgaSsrKQotCQltdXgtPnZhbHVlc1tpXSA9ICh2YWwg Pj4gaSkgJiAxOworCXZhbHVlc1swXSA9IHZhbDsKIAotCWdwaW9kX3NldF9hcnJheV92YWx1ZV9j YW5zbGVlcChtdXgtPmRhdGEubl9ncGlvcywKLQkJCQkgICAgICAgbXV4LT5ncGlvcywgbXV4LT52 YWx1ZXMpOworCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcChtdXgtPmRhdGEubl9ncGlv cywgbXV4LT5ncGlvcywgdmFsdWVzKTsKIH0KIAogc3RhdGljIGludCBpMmNfbXV4X2dwaW9fc2Vs ZWN0KHN0cnVjdCBpMmNfbXV4X2NvcmUgKm11eGMsIHUzMiBjaGFuKQpAQCAtMTgyLDE1ICsxNzks MTMgQEAgc3RhdGljIGludCBpMmNfbXV4X2dwaW9fcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqcGRldikKIAkJcmV0dXJuIC1FUFJPQkVfREVGRVI7CiAKIAltdXhjID0gaTJjX211eF9hbGxv YyhwYXJlbnQsICZwZGV2LT5kZXYsIG11eC0+ZGF0YS5uX3ZhbHVlcywKLQkJCSAgICAgbXV4LT5k YXRhLm5fZ3Bpb3MgKiBzaXplb2YoKm11eC0+Z3Bpb3MpICsKLQkJCSAgICAgbXV4LT5kYXRhLm5f Z3Bpb3MgKiBzaXplb2YoKm11eC0+dmFsdWVzKSwgMCwKKwkJCSAgICAgbXV4LT5kYXRhLm5fZ3Bp b3MgKiBzaXplb2YoKm11eC0+Z3Bpb3MpLCAwLAogCQkJICAgICBpMmNfbXV4X2dwaW9fc2VsZWN0 LCBOVUxMKTsKIAlpZiAoIW11eGMpIHsKIAkJcmV0ID0gLUVOT01FTTsKIAkJZ290byBhbGxvY19m YWlsZWQ7CiAJfQogCW11eC0+Z3Bpb3MgPSBtdXhjLT5wcml2OwotCW11eC0+dmFsdWVzID0gKGlu dCAqKShtdXgtPmdwaW9zICsgbXV4LT5kYXRhLm5fZ3Bpb3MpOwogCW11eGMtPnByaXYgPSBtdXg7 CiAKIAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBtdXhjKTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbW1jL2NvcmUvcHdyc2VxX3NpbXBsZS5jIGIvZHJpdmVycy9tbWMvY29yZS9wd3JzZXFfc2lt cGxlLmMKaW5kZXggYThiOWZlZTRkNjJhLi45MDI0NzZlZjlhMGUgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvbW1jL2NvcmUvcHdyc2VxX3NpbXBsZS5jCisrKyBiL2RyaXZlcnMvbW1jL2NvcmUvcHdyc2Vx X3NpbXBsZS5jCkBAIC00MCwxOCArNDAsMTMgQEAgc3RhdGljIHZvaWQgbW1jX3B3cnNlcV9zaW1w bGVfc2V0X2dwaW9zX3ZhbHVlKHN0cnVjdCBtbWNfcHdyc2VxX3NpbXBsZSAqcHdyc2VxLAogCXN0 cnVjdCBncGlvX2Rlc2NzICpyZXNldF9ncGlvcyA9IHB3cnNlcS0+cmVzZXRfZ3Bpb3M7CiAKIAlp ZiAoIUlTX0VSUihyZXNldF9ncGlvcykpIHsKLQkJaW50IGksICp2YWx1ZXM7CisJCURFQ0xBUkVf QklUTUFQKHZhbHVlcywgQklUU19QRVJfVFlQRSh2YWx1ZSkpOwogCQlpbnQgbnZhbHVlcyA9IHJl c2V0X2dwaW9zLT5uZGVzY3M7CiAKLQkJdmFsdWVzID0ga21hbGxvY19hcnJheShudmFsdWVzLCBz aXplb2YoaW50KSwgR0ZQX0tFUk5FTCk7Ci0JCWlmICghdmFsdWVzKQotCQkJcmV0dXJuOworCQl2 YWx1ZXNbMF0gPSB2YWx1ZTsKIAotCQlmb3IgKGkgPSAwOyBpIDwgbnZhbHVlczsgaSsrKQotCQkJ dmFsdWVzW2ldID0gdmFsdWU7Ci0KLQkJZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKG52 YWx1ZXMsIHJlc2V0X2dwaW9zLT5kZXNjLCB2YWx1ZXMpOwotCQlrZnJlZSh2YWx1ZXMpOworCQln cGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAobnZhbHVlcywgcmVzZXRfZ3Bpb3MtPmRlc2Ms CisJCQkJCSAgICAgICB2YWx1ZXMpOwogCX0KIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdXgv Z3Bpby5jIGIvZHJpdmVycy9tdXgvZ3Bpby5jCmluZGV4IDZmZGQ5MzE2ZGI4Yi4uNDZjNDQ1MzJm YmQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL211eC9ncGlvLmMKKysrIGIvZHJpdmVycy9tdXgvZ3Bp by5jCkBAIC0xNywyMCArMTcsMTcgQEAKIAogc3RydWN0IG11eF9ncGlvIHsKIAlzdHJ1Y3QgZ3Bp b19kZXNjcyAqZ3Bpb3M7Ci0JaW50ICp2YWw7CiB9OwogCiBzdGF0aWMgaW50IG11eF9ncGlvX3Nl dChzdHJ1Y3QgbXV4X2NvbnRyb2wgKm11eCwgaW50IHN0YXRlKQogewogCXN0cnVjdCBtdXhfZ3Bp byAqbXV4X2dwaW8gPSBtdXhfY2hpcF9wcml2KG11eC0+Y2hpcCk7Ci0JaW50IGk7CisJREVDTEFS RV9CSVRNQVAodmFsdWVzLCBCSVRTX1BFUl9UWVBFKHN0YXRlKSk7CiAKLQlmb3IgKGkgPSAwOyBp IDwgbXV4X2dwaW8tPmdwaW9zLT5uZGVzY3M7IGkrKykKLQkJbXV4X2dwaW8tPnZhbFtpXSA9IChz dGF0ZSA+PiBpKSAmIDE7CisJdmFsdWVzWzBdID0gc3RhdGU7CiAKIAlncGlvZF9zZXRfYXJyYXlf dmFsdWVfY2Fuc2xlZXAobXV4X2dwaW8tPmdwaW9zLT5uZGVzY3MsCi0JCQkJICAgICAgIG11eF9n cGlvLT5ncGlvcy0+ZGVzYywKLQkJCQkgICAgICAgbXV4X2dwaW8tPnZhbCk7CisJCQkJICAgICAg IG11eF9ncGlvLT5ncGlvcy0+ZGVzYywgdmFsdWVzKTsKIAogCXJldHVybiAwOwogfQpAQCAtNTgs MTMgKzU1LDExIEBAIHN0YXRpYyBpbnQgbXV4X2dwaW9fcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKIAlpZiAocGlucyA8IDApCiAJCXJldHVybiBwaW5zOwogCi0JbXV4X2NoaXAg PSBkZXZtX211eF9jaGlwX2FsbG9jKGRldiwgMSwgc2l6ZW9mKCptdXhfZ3BpbykgKwotCQkJCSAg ICAgICBwaW5zICogc2l6ZW9mKCptdXhfZ3Bpby0+dmFsKSk7CisJbXV4X2NoaXAgPSBkZXZtX211 eF9jaGlwX2FsbG9jKGRldiwgMSwgc2l6ZW9mKCptdXhfZ3BpbykpOwogCWlmIChJU19FUlIobXV4 X2NoaXApKQogCQlyZXR1cm4gUFRSX0VSUihtdXhfY2hpcCk7CiAKIAltdXhfZ3BpbyA9IG11eF9j aGlwX3ByaXYobXV4X2NoaXApOwotCW11eF9ncGlvLT52YWwgPSAoaW50ICopKG11eF9ncGlvICsg MSk7CiAJbXV4X2NoaXAtPm9wcyA9ICZtdXhfZ3Bpb19vcHM7CiAKIAltdXhfZ3Bpby0+Z3Bpb3Mg PSBkZXZtX2dwaW9kX2dldF9hcnJheShkZXYsICJtdXgiLCBHUElPRF9PVVRfTE9XKTsKZGlmZiAt LWdpdCBhL2RyaXZlcnMvbmV0L3BoeS9tZGlvLW11eC1ncGlvLmMgYi9kcml2ZXJzL25ldC9waHkv bWRpby1tdXgtZ3Bpby5jCmluZGV4IGJjOTA3NjRhOGI4ZC4uZTI1Y2NmYzhjMDcwIDEwMDY0NAot LS0gYS9kcml2ZXJzL25ldC9waHkvbWRpby1tdXgtZ3Bpby5jCisrKyBiL2RyaXZlcnMvbmV0L3Bo eS9tZGlvLW11eC1ncGlvLmMKQEAgLTIwLDIzICsyMCwyMSBAQAogc3RydWN0IG1kaW9fbXV4X2dw aW9fc3RhdGUgewogCXN0cnVjdCBncGlvX2Rlc2NzICpncGlvczsKIAl2b2lkICptdXhfaGFuZGxl OwotCWludCB2YWx1ZXNbXTsKIH07CiAKIHN0YXRpYyBpbnQgbWRpb19tdXhfZ3Bpb19zd2l0Y2hf Zm4oaW50IGN1cnJlbnRfY2hpbGQsIGludCBkZXNpcmVkX2NoaWxkLAogCQkJCSAgIHZvaWQgKmRh dGEpCiB7CiAJc3RydWN0IG1kaW9fbXV4X2dwaW9fc3RhdGUgKnMgPSBkYXRhOwotCXVuc2lnbmVk IGludCBuOworCURFQ0xBUkVfQklUTUFQKHZhbHVlcywgQklUU19QRVJfVFlQRShkZXNpcmVkX2No aWxkKSk7CiAKIAlpZiAoY3VycmVudF9jaGlsZCA9PSBkZXNpcmVkX2NoaWxkKQogCQlyZXR1cm4g MDsKIAotCWZvciAobiA9IDA7IG4gPCBzLT5ncGlvcy0+bmRlc2NzOyBuKyspCi0JCXMtPnZhbHVl c1tuXSA9IChkZXNpcmVkX2NoaWxkID4+IG4pICYgMTsKKwl2YWx1ZXNbMF0gPSBkZXNpcmVkX2No aWxkOwogCiAJZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKHMtPmdwaW9zLT5uZGVzY3Ms IHMtPmdwaW9zLT5kZXNjLAotCQkJCSAgICAgICBzLT52YWx1ZXMpOworCQkJCSAgICAgICB2YWx1 ZXMpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC01MSw4ICs0OSw3IEBAIHN0YXRpYyBpbnQgbWRpb19t dXhfZ3Bpb19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWlmIChJU19FUlIo Z3Bpb3MpKQogCQlyZXR1cm4gUFRSX0VSUihncGlvcyk7CiAKLQlzID0gZGV2bV9remFsbG9jKCZw ZGV2LT5kZXYsIHN0cnVjdF9zaXplKHMsIHZhbHVlcywgZ3Bpb3MtPm5kZXNjcyksCi0JCQkgR0ZQ X0tFUk5FTCk7CisJcyA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplb2YoKnMpLCBHRlBf S0VSTkVMKTsKIAlpZiAoIXMpIHsKIAkJZ3Bpb2RfcHV0X2FycmF5KGdwaW9zKTsKIAkJcmV0dXJu IC1FTk9NRU07CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjbWNpYS9zb2NfY29tbW9uLmMgYi9kcml2 ZXJzL3BjbWNpYS9zb2NfY29tbW9uLmMKaW5kZXggYzVmMjM0NGMxODliLi5hYzAzM2Q1NTU3MDAg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNtY2lhL3NvY19jb21tb24uYworKysgYi9kcml2ZXJzL3Bj bWNpYS9zb2NfY29tbW9uLmMKQEAgLTM1MSwxNSArMzUxLDE2IEBAIHN0YXRpYyBpbnQgc29jX2Nv bW1vbl9wY21jaWFfY29uZmlnX3NrdCgKIAogCWlmIChyZXQgPT0gMCkgewogCQlzdHJ1Y3QgZ3Bp b19kZXNjICpkZXNjc1syXTsKLQkJaW50IHZhbHVlc1syXSwgbiA9IDA7CisJCURFQ0xBUkVfQklU TUFQKHZhbHVlcywgMik7CisJCWludCBuID0gMDsKIAogCQlpZiAoc2t0LT5ncGlvX3Jlc2V0KSB7 CiAJCQlkZXNjc1tuXSA9IHNrdC0+Z3Bpb19yZXNldDsKLQkJCXZhbHVlc1tuKytdID0gISEoc3Rh dGUtPmZsYWdzICYgU1NfUkVTRVQpOworCQkJX19hc3NpZ25fYml0KG4rKywgdmFsdWVzLCBzdGF0 ZS0+ZmxhZ3MgJiBTU19SRVNFVCk7CiAJCX0KIAkJaWYgKHNrdC0+Z3Bpb19idXNfZW5hYmxlKSB7 CiAJCQlkZXNjc1tuXSA9IHNrdC0+Z3Bpb19idXNfZW5hYmxlOwotCQkJdmFsdWVzW24rK10gPSAh IShzdGF0ZS0+ZmxhZ3MgJiBTU19PVVRQVVRfRU5BKTsKKwkJCV9fYXNzaWduX2JpdChuKyssIHZh bHVlcywgc3RhdGUtPmZsYWdzICYgU1NfT1VUUFVUX0VOQSk7CiAJCX0KIAogCQlpZiAobikKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvcGh5L21vdG9yb2xhL3BoeS1tYXBwaG9uZS1tZG02NjAwLmMgYi9k cml2ZXJzL3BoeS9tb3Rvcm9sYS9waHktbWFwcGhvbmUtbWRtNjYwMC5jCmluZGV4IDAwNzVmYjBi ZWY4Yy4uOTE2MmI2MWRkYjk1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BoeS9tb3Rvcm9sYS9waHkt bWFwcGhvbmUtbWRtNjYwMC5jCisrKyBiL2RyaXZlcnMvcGh5L21vdG9yb2xhL3BoeS1tYXBwaG9u ZS1tZG02NjAwLmMKQEAgLTE1NywxMiArMTU3LDkgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBwaHlf b3BzIGdwaW9fdXNiX29wcyA9IHsKICAqLwogc3RhdGljIHZvaWQgcGh5X21kbTY2MDBfY21kKHN0 cnVjdCBwaHlfbWRtNjYwMCAqZGRhdGEsIGludCB2YWwpCiB7Ci0JaW50IHZhbHVlc1tQSFlfTURN NjYwMF9OUl9DTURfTElORVNdOwotCWludCBpOworCURFQ0xBUkVfQklUTUFQKHZhbHVlcywgUEhZ X01ETTY2MDBfTlJfQ01EX0xJTkVTKTsKIAotCXZhbCAmPSAoMSA8PCBQSFlfTURNNjYwMF9OUl9D TURfTElORVMpIC0gMTsKLQlmb3IgKGkgPSAwOyBpIDwgUEhZX01ETTY2MDBfTlJfQ01EX0xJTkVT OyBpKyspCi0JCXZhbHVlc1tpXSA9ICh2YWwgJiBCSVQoaSkpID4+IGk7CisJdmFsdWVzWzBdID0g dmFsOwogCiAJZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKFBIWV9NRE02NjAwX05SX0NN RF9MSU5FUywKIAkJCQkgICAgICAgZGRhdGEtPmNtZF9ncGlvcy0+ZGVzYywgdmFsdWVzKTsKQEAg LTE3Niw3ICsxNzMsNyBAQCBzdGF0aWMgdm9pZCBwaHlfbWRtNjYwMF9zdGF0dXMoc3RydWN0IHdv cmtfc3RydWN0ICp3b3JrKQogewogCXN0cnVjdCBwaHlfbWRtNjYwMCAqZGRhdGE7CiAJc3RydWN0 IGRldmljZSAqZGV2OwotCWludCB2YWx1ZXNbUEhZX01ETTY2MDBfTlJfU1RBVFVTX0xJTkVTXTsK KwlERUNMQVJFX0JJVE1BUCh2YWx1ZXMsIFBIWV9NRE02NjAwX05SX1NUQVRVU19MSU5FUyk7CiAJ aW50IGVycm9yLCBpLCB2YWwgPSAwOwogCiAJZGRhdGEgPSBjb250YWluZXJfb2Yod29yaywgc3Ry dWN0IHBoeV9tZG02NjAwLCBzdGF0dXNfd29yay53b3JrKTsKQEAgLTE4OSwxMSArMTg2LDExIEBA IHN0YXRpYyB2b2lkIHBoeV9tZG02NjAwX3N0YXR1cyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmsp CiAJCXJldHVybjsKIAogCWZvciAoaSA9IDA7IGkgPCBQSFlfTURNNjYwMF9OUl9TVEFUVVNfTElO RVM7IGkrKykgewotCQl2YWwgfD0gdmFsdWVzW2ldIDw8IGk7CisJCXZhbCB8PSB0ZXN0X2JpdChp LCB2YWx1ZXMpIDw8IGk7CiAJCWRldl9kYmcoZGRhdGEtPmRldiwgIlhYWCAlczogaTogJWkgdmFs dWVzW2ldOiAlaSB2YWw6ICVpXG4iLAotCQkJX19mdW5jX18sIGksIHZhbHVlc1tpXSwgdmFsKTsK KwkJCV9fZnVuY19fLCBpLCB0ZXN0X2JpdChpLCB2YWx1ZXMpLCB2YWwpOwogCX0KLQlkZGF0YS0+ c3RhdHVzID0gdmFsOworCWRkYXRhLT5zdGF0dXMgPSB2YWx1ZXNbMF07CiAKIAlkZXZfaW5mbyhk ZXYsICJtb2RlbSBzdGF0dXM6ICVpICVzXG4iLAogCQkgZGRhdGEtPnN0YXR1cywKZGlmZiAtLWdp dCBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzYwNi5jIGIvZHJpdmVycy9zdGFnaW5nL2lp by9hZGMvYWQ3NjA2LmMKaW5kZXggMjViOWZjZDVlM2E0Li45YzFkNzdkNDg3MDAgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvc3RhZ2luZy9paW8vYWRjL2FkNzYwNi5jCisrKyBiL2RyaXZlcnMvc3RhZ2lu Zy9paW8vYWRjL2FkNzYwNi5jCkBAIC0yMDIsNyArMjAyLDcgQEAgc3RhdGljIGludCBhZDc2MDZf d3JpdGVfcmF3KHN0cnVjdCBpaW9fZGV2ICppbmRpb19kZXYsCiAJCQkgICAgbG9uZyBtYXNrKQog ewogCXN0cnVjdCBhZDc2MDZfc3RhdGUgKnN0ID0gaWlvX3ByaXYoaW5kaW9fZGV2KTsKLQlpbnQg dmFsdWVzWzNdOworCURFQ0xBUkVfQklUTUFQKHZhbHVlcywgMyk7CiAJaW50IHJldCwgaTsKIAog CXN3aXRjaCAobWFzaykgewpAQCAtMjI3LDEzICsyMjcsMTAgQEAgc3RhdGljIGludCBhZDc2MDZf d3JpdGVfcmF3KHN0cnVjdCBpaW9fZGV2ICppbmRpb19kZXYsCiAJCWlmIChyZXQgPCAwKQogCQkJ cmV0dXJuIHJldDsKIAotCQl2YWx1ZXNbMF0gPSAocmV0ID4+IDApICYgMTsKLQkJdmFsdWVzWzFd ID0gKHJldCA+PiAxKSAmIDE7Ci0JCXZhbHVlc1syXSA9IChyZXQgPj4gMikgJiAxOworCQl2YWx1 ZXNbMF0gPSByZXQ7CiAKIAkJbXV0ZXhfbG9jaygmc3QtPmxvY2spOwotCQlncGlvZF9zZXRfYXJy YXlfdmFsdWUoQVJSQVlfU0laRSh2YWx1ZXMpLCBzdC0+Z3Bpb19vcy0+ZGVzYywKLQkJCQkgICAg ICB2YWx1ZXMpOworCQlncGlvZF9zZXRfYXJyYXlfdmFsdWUoMywgc3QtPmdwaW9fb3MtPmRlc2Ms IHZhbHVlcyk7CiAJCXN0LT5vdmVyc2FtcGxpbmcgPSB2YWw7CiAJCW11dGV4X3VubG9jaygmc3Qt PmxvY2spOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX21jdHJsX2dw aW8uYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zZXJpYWxfbWN0cmxfZ3Bpby5jCmluZGV4IDFjMDYz MjViZWFjYS4uN2Q5ZDJjN2I2YzM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2Vy aWFsX21jdHJsX2dwaW8uYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX21jdHJsX2dw aW8uYwpAQCAtNDAsNyArNDAsNyBAQCB2b2lkIG1jdHJsX2dwaW9fc2V0KHN0cnVjdCBtY3RybF9n cGlvcyAqZ3Bpb3MsIHVuc2lnbmVkIGludCBtY3RybCkKIHsKIAllbnVtIG1jdHJsX2dwaW9faWR4 IGk7CiAJc3RydWN0IGdwaW9fZGVzYyAqZGVzY19hcnJheVtVQVJUX0dQSU9fTUFYXTsKLQlpbnQg dmFsdWVfYXJyYXlbVUFSVF9HUElPX01BWF07CisJREVDTEFSRV9CSVRNQVAodmFsdWVzLCBVQVJU X0dQSU9fTUFYKTsKIAl1bnNpZ25lZCBpbnQgY291bnQgPSAwOwogCiAJaWYgKGdwaW9zID09IE5V TEwpCkBAIC00OSwxMCArNDksMTEgQEAgdm9pZCBtY3RybF9ncGlvX3NldChzdHJ1Y3QgbWN0cmxf Z3Bpb3MgKmdwaW9zLCB1bnNpZ25lZCBpbnQgbWN0cmwpCiAJZm9yIChpID0gMDsgaSA8IFVBUlRf R1BJT19NQVg7IGkrKykKIAkJaWYgKGdwaW9zLT5ncGlvW2ldICYmIG1jdHJsX2dwaW9zX2Rlc2Nb aV0uZGlyX291dCkgewogCQkJZGVzY19hcnJheVtjb3VudF0gPSBncGlvcy0+Z3Bpb1tpXTsKLQkJ CXZhbHVlX2FycmF5W2NvdW50XSA9ICEhKG1jdHJsICYgbWN0cmxfZ3Bpb3NfZGVzY1tpXS5tY3Ry bCk7CisJCQlfX2Fzc2lnbl9iaXQoY291bnQsIHZhbHVlcywKKwkJCQkgICAgIG1jdHJsICYgbWN0 cmxfZ3Bpb3NfZGVzY1tpXS5tY3RybCk7CiAJCQljb3VudCsrOwogCQl9Ci0JZ3Bpb2Rfc2V0X2Fy cmF5X3ZhbHVlKGNvdW50LCBkZXNjX2FycmF5LCB2YWx1ZV9hcnJheSk7CisJZ3Bpb2Rfc2V0X2Fy cmF5X3ZhbHVlKGNvdW50LCBkZXNjX2FycmF5LCB2YWx1ZXMpOwogfQogRVhQT1JUX1NZTUJPTF9H UEwobWN0cmxfZ3Bpb19zZXQpOwogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2dwaW8vY29u c3VtZXIuaCBiL2luY2x1ZGUvbGludXgvZ3Bpby9jb25zdW1lci5oCmluZGV4IDIxZGRiZTQ0MDAz MC4uMmIwMzg5ZjBiZWM0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2dwaW8vY29uc3VtZXIu aAorKysgYi9pbmNsdWRlL2xpbnV4L2dwaW8vY29uc3VtZXIuaApAQCAtMTA0LDM2ICsxMDQsMzgg QEAgaW50IGdwaW9kX2RpcmVjdGlvbl9vdXRwdXRfcmF3KHN0cnVjdCBncGlvX2Rlc2MgKmRlc2Ms IGludCB2YWx1ZSk7CiAvKiBWYWx1ZSBnZXQvc2V0IGZyb20gbm9uLXNsZWVwaW5nIGNvbnRleHQg Ki8KIGludCBncGlvZF9nZXRfdmFsdWUoY29uc3Qgc3RydWN0IGdwaW9fZGVzYyAqZGVzYyk7CiBp bnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAotCQkJICBz dHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwgaW50ICp2YWx1ZV9hcnJheSk7CisJCQkgIHN0 cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAorCQkJICB1bnNpZ25lZCBsb25nICp2YWx1ZV9i aXRtYXApOwogdm9pZCBncGlvZF9zZXRfdmFsdWUoc3RydWN0IGdwaW9fZGVzYyAqZGVzYywgaW50 IHZhbHVlKTsKIHZvaWQgZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9z aXplLAotCQkJICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksIGludCAqdmFsdWVfYXJy YXkpOworCQkJICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCisJCQkgICB1bnNpZ25l ZCBsb25nICp2YWx1ZV9iaXRtYXApOwogaW50IGdwaW9kX2dldF9yYXdfdmFsdWUoY29uc3Qgc3Ry dWN0IGdwaW9fZGVzYyAqZGVzYyk7CiBpbnQgZ3Bpb2RfZ2V0X3Jhd19hcnJheV92YWx1ZSh1bnNp Z25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCSAgICAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2Fy cmF5LAotCQkJICAgICAgaW50ICp2YWx1ZV9hcnJheSk7CisJCQkgICAgICB1bnNpZ25lZCBsb25n ICp2YWx1ZV9iaXRtYXApOwogdm9pZCBncGlvZF9zZXRfcmF3X3ZhbHVlKHN0cnVjdCBncGlvX2Rl c2MgKmRlc2MsIGludCB2YWx1ZSk7CiBpbnQgZ3Bpb2Rfc2V0X3Jhd19hcnJheV92YWx1ZSh1bnNp Z25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCSAgICAgICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19h cnJheSwKLQkJCSAgICAgICBpbnQgKnZhbHVlX2FycmF5KTsKKwkJCSAgICAgICB1bnNpZ25lZCBs b25nICp2YWx1ZV9iaXRtYXApOwogCiAvKiBWYWx1ZSBnZXQvc2V0IGZyb20gc2xlZXBpbmcgY29u dGV4dCAqLwogaW50IGdwaW9kX2dldF92YWx1ZV9jYW5zbGVlcChjb25zdCBzdHJ1Y3QgZ3Bpb19k ZXNjICpkZXNjKTsKIGludCBncGlvZF9nZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQg aW50IGFycmF5X3NpemUsCiAJCQkJICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0J CQkJICAgaW50ICp2YWx1ZV9hcnJheSk7CisJCQkJICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0 bWFwKTsKIHZvaWQgZ3Bpb2Rfc2V0X3ZhbHVlX2NhbnNsZWVwKHN0cnVjdCBncGlvX2Rlc2MgKmRl c2MsIGludCB2YWx1ZSk7CiB2b2lkIGdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcCh1bnNp Z25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJy YXksCi0JCQkJICAgIGludCAqdmFsdWVfYXJyYXkpOworCQkJCSAgICB1bnNpZ25lZCBsb25nICp2 YWx1ZV9iaXRtYXApOwogaW50IGdwaW9kX2dldF9yYXdfdmFsdWVfY2Fuc2xlZXAoY29uc3Qgc3Ry dWN0IGdwaW9fZGVzYyAqZGVzYyk7CiBpbnQgZ3Bpb2RfZ2V0X3Jhd19hcnJheV92YWx1ZV9jYW5z bGVlcCh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgICAgICAgc3RydWN0IGdwaW9fZGVz YyAqKmRlc2NfYXJyYXksCi0JCQkJICAgICAgIGludCAqdmFsdWVfYXJyYXkpOworCQkJCSAgICAg ICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApOwogdm9pZCBncGlvZF9zZXRfcmF3X3ZhbHVl X2NhbnNsZWVwKHN0cnVjdCBncGlvX2Rlc2MgKmRlc2MsIGludCB2YWx1ZSk7CiBpbnQgZ3Bpb2Rf c2V0X3Jhd19hcnJheV92YWx1ZV9jYW5zbGVlcCh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJ CQkJc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJCWludCAqdmFsdWVfYXJyYXkp OworCQkJCQl1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApOwogCiBpbnQgZ3Bpb2Rfc2V0X2Rl Ym91bmNlKHN0cnVjdCBncGlvX2Rlc2MgKmRlc2MsIHVuc2lnbmVkIGRlYm91bmNlKTsKIGludCBn cGlvZF9zZXRfdHJhbnNpdG9yeShzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNjLCBib29sIHRyYW5zaXRv cnkpOwpAQCAtMzMwLDcgKzMzMiw3IEBAIHN0YXRpYyBpbmxpbmUgaW50IGdwaW9kX2dldF92YWx1 ZShjb25zdCBzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNjKQogfQogc3RhdGljIGlubGluZSBpbnQgZ3Bp b2RfZ2V0X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCQlzdHJ1Y3Qg Z3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkJaW50ICp2YWx1ZV9hcnJheSkKKwkJCQkJdW5z aWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogewogCS8qIEdQSU8gY2FuIG5ldmVyIGhhdmUgYmVl biByZXF1ZXN0ZWQgKi8KIAlXQVJOX09OKDEpOwpAQCAtMzQzLDcgKzM0NSw3IEBAIHN0YXRpYyBp bmxpbmUgdm9pZCBncGlvZF9zZXRfdmFsdWUoc3RydWN0IGdwaW9fZGVzYyAqZGVzYywgaW50IHZh bHVlKQogfQogc3RhdGljIGlubGluZSB2b2lkIGdwaW9kX3NldF9hcnJheV92YWx1ZSh1bnNpZ25l ZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkJIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAot CQkJCQkgaW50ICp2YWx1ZV9hcnJheSkKKwkJCQkJIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1h cCkKIHsKIAkvKiBHUElPIGNhbiBuZXZlciBoYXZlIGJlZW4gcmVxdWVzdGVkICovCiAJV0FSTl9P TigxKTsKQEAgLTM1Niw3ICszNTgsNyBAQCBzdGF0aWMgaW5saW5lIGludCBncGlvZF9nZXRfcmF3 X3ZhbHVlKGNvbnN0IHN0cnVjdCBncGlvX2Rlc2MgKmRlc2MpCiB9CiBzdGF0aWMgaW5saW5lIGlu dCBncGlvZF9nZXRfcmF3X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJ CQkgICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJCSAgICBpbnQgKnZhbHVl X2FycmF5KQorCQkJCQkgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogewogCS8qIEdQ SU8gY2FuIG5ldmVyIGhhdmUgYmVlbiByZXF1ZXN0ZWQgKi8KIAlXQVJOX09OKDEpOwpAQCAtMzY5 LDcgKzM3MSw3IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBncGlvZF9zZXRfcmF3X3ZhbHVlKHN0cnVj dCBncGlvX2Rlc2MgKmRlc2MsIGludCB2YWx1ZSkKIH0KIHN0YXRpYyBpbmxpbmUgaW50IGdwaW9k X3NldF9yYXdfYXJyYXlfdmFsdWUodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJCSAgICAg c3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJCSAgICAgaW50ICp2YWx1ZV9hcnJh eSkKKwkJCQkJICAgICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiB7CiAJLyogR1BJTyBj YW4gbmV2ZXIgaGF2ZSBiZWVuIHJlcXVlc3RlZCAqLwogCVdBUk5fT04oMSk7CkBAIC0zODQsNyAr Mzg2LDcgQEAgc3RhdGljIGlubGluZSBpbnQgZ3Bpb2RfZ2V0X3ZhbHVlX2NhbnNsZWVwKGNvbnN0 IHN0cnVjdCBncGlvX2Rlc2MgKmRlc2MpCiB9CiBzdGF0aWMgaW5saW5lIGludCBncGlvZF9nZXRf YXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJICAgICBz dHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkgICAgIGludCAqdmFsdWVfYXJyYXkp CisJCQkJICAgICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiB7CiAJLyogR1BJTyBjYW4g bmV2ZXIgaGF2ZSBiZWVuIHJlcXVlc3RlZCAqLwogCVdBUk5fT04oMSk7CkBAIC0zOTcsNyArMzk5 LDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGdwaW9kX3NldF92YWx1ZV9jYW5zbGVlcChzdHJ1Y3Qg Z3Bpb19kZXNjICpkZXNjLCBpbnQgdmFsdWUpCiB9CiBzdGF0aWMgaW5saW5lIHZvaWQgZ3Bpb2Rf c2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCQkg ICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJCSAgICBpbnQgKnZhbHVlX2Fy cmF5KQorCQkJCQkgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogewogCS8qIEdQSU8g Y2FuIG5ldmVyIGhhdmUgYmVlbiByZXF1ZXN0ZWQgKi8KIAlXQVJOX09OKDEpOwpAQCAtNDEwLDcg KzQxMiw3IEBAIHN0YXRpYyBpbmxpbmUgaW50IGdwaW9kX2dldF9yYXdfdmFsdWVfY2Fuc2xlZXAo Y29uc3Qgc3RydWN0IGdwaW9fZGVzYyAqZGVzYykKIH0KIHN0YXRpYyBpbmxpbmUgaW50IGdwaW9k X2dldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJ CQkJCSAgICAgICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkJICAgICAgIGlu dCAqdmFsdWVfYXJyYXkpCisJCQkJCSAgICAgICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXAp CiB7CiAJLyogR1BJTyBjYW4gbmV2ZXIgaGF2ZSBiZWVuIHJlcXVlc3RlZCAqLwogCVdBUk5fT04o MSk7CkBAIC00MjQsNyArNDI2LDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGdwaW9kX3NldF9yYXdf dmFsdWVfY2Fuc2xlZXAoc3RydWN0IGdwaW9fZGVzYyAqZGVzYywKIH0KIHN0YXRpYyBpbmxpbmUg aW50IGdwaW9kX3NldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5 X3NpemUsCiAJCQkJCQlzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkJCWludCAq dmFsdWVfYXJyYXkpCisJCQkJCQl1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiB7CiAJLyog R1BJTyBjYW4gbmV2ZXIgaGF2ZSBiZWVuIHJlcXVlc3RlZCAqLwogCVdBUk5fT04oMSk7Ci0tIAoy LjE2LjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRl dmVsIG1haWxpbmcgbGlzdApkZXZlbEBsaW51eGRyaXZlcnByb2plY3Qub3JnCmh0dHA6Ly9kcml2 ZXJkZXYubGludXhkcml2ZXJwcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaXZlcmRldi1k ZXZlbAo=