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.8 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 42F3A7D2EE for ; Sun, 2 Sep 2018 12:01:18 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727049AbeIBQQo (ORCPT ); Sun, 2 Sep 2018 12:16:44 -0400 Received: from mail-lf1-f65.google.com ([209.85.167.65]:43765 "EHLO mail-lf1-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726014AbeIBQQn (ORCPT ); Sun, 2 Sep 2018 12:16:43 -0400 Received: by mail-lf1-f65.google.com with SMTP id h64-v6so13119340lfi.10; Sun, 02 Sep 2018 05:01:07 -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=9kaeCdDVQIew8mjGJ5ZxydvdcTd9icxb40grHlRSzLo=; b=hdrILBo+h7Lo91fw0VMhoaivyN+KhV3mgea5YEMsMo3t/6BgqkFkORSPxuCuEh4YWt prdcWtB7BdwpyS1QpPiCEjeKfw+bkZWedDmxe+uGuWsZWu9zQ8GpQn37LDUmGbrZPwPC HDnhI512PVQkhnGJ8NQvfmDUMYR6eChVEsM+JgCecdohganKv1tdaoySbmXwtAhTLz7u a71mCmUHqA2tmuIR+X+vrmUw6hskrq7fAcOqWDheOcf7t8hHyq+JKiDwOKOKqhfE/KTF ciKPeOmDJxvZkDnM2ltaMcjEJ5ta7WAKqxG8Ta8obuAO4xNfafwmf3OJ4uPvkjsRDHJo cLsA== 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=9kaeCdDVQIew8mjGJ5ZxydvdcTd9icxb40grHlRSzLo=; b=ZJA7sU8JqXCRMT7Oryc4jWqWMLfFfXyhiZ5VuxdlumvSqqmPr1dCZpY5Pf+s3EmbOT aVL6SBLAex0yTV21eh8+CB6t2cuEbig8auOPPN22V1bbW3t9cZI+yQ5U7BDy8MBE54Hy L67gfaK0gQK7eS75zRq9jTrybsAydngGYa4RugqeJGVrluKvIw4Tgb6hNWGRJGvzULLh UbAKcoJHvVTa575TGisQLoAh0w0C50osVKgp3wEt9iCM9rr24s4d21dsm3xxxrIuVf/2 Rm+ZtK1khzCNTuaAS4s7RNwGBcQiviEV1xfjPKL7wtWhJTHspI3T5OJQMlnS+R4lTajj z/bw== X-Gm-Message-State: APzg51BecnNpP5+BrquUeARk2vxkx+xIOXWPjrvEAKMGP7HFyjNXPIzu C0NTCgUHbGOLP8V+Uz021Gk= X-Google-Smtp-Source: ANB0VdaHozmwLL1luAZlvywkTeTlSXUircqeoBaPCuEG9UOyu9ecqqnaTnB0ZbGmbtk8w026Hx5x/A== X-Received: by 2002:a19:4f12:: with SMTP id d18-v6mr14806360lfb.121.1535889666385; Sun, 02 Sep 2018 05:01:06 -0700 (PDT) Received: from localhost.localdomain (apn-37-248-210-194.dynamic.gprs.plus.pl. [37.248.210.194]) by smtp.gmail.com with ESMTPSA id n3-v6sm2760321lji.96.2018.09.02.05.00.54 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sun, 02 Sep 2018 05:01:05 -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 , 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, Janusz Krzysztofik , Sebastien Bourdelin , Lukas Wunner , Rojhalat Ibrahim , Russell King , Tony Lindgren , Yegor Yefremov , =?UTF-8?q?Uwe=20Kleine-K=C3=B6nig?= Subject: [PATCH v7 1/4] gpiolib: Pass bitmaps, not integer arrays, to get/set array Date: Sun, 2 Sep 2018 14:01:41 +0200 Message-Id: <20180902120144.6855-2-jmkrzyszt@gmail.com> X-Mailer: git-send-email 2.16.4 In-Reply-To: <20180902120144.6855-1-jmkrzyszt@gmail.com> References: <20180831225616.29221-1-jmkrzyszt@gmail.com> <20180902120144.6855-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: Geert Uytterhoeven 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 --- 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 | 8 +-- drivers/phy/motorola/phy-mapphone-mdm6600.c | 13 ++--- drivers/staging/iio/adc/ad7606.c | 9 ++-- drivers/tty/serial/serial_mctrl_gpio.c | 7 +-- include/linux/gpio/consumer.h | 18 ++++--- 15 files changed, 129 insertions(+), 168 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..333e30e378b5 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 = 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 = 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 &= ~0x0fUL; + *values |= 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 = 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..6499957a8044 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; 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 = 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..434d09779a1f 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_bitnap: 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..0717cfb56732 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 = 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..5ad764c88b50 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 = 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..1b6b4cc22a2c 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 = 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..eb8c56b83c70 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 = 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..388dbdc46129 100644 --- a/drivers/pcmcia/soc_common.c +++ b/drivers/pcmcia/soc_common.c @@ -351,15 +351,17 @@ 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..4de7f4577433 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 = 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,9 +186,9 @@ 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; diff --git a/drivers/staging/iio/adc/ad7606.c b/drivers/staging/iio/adc/ad7606.c index 25b9fcd5e3a4..053c9b7f1084 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 = 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..30444fd6cf32 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..1b21dc7b0fad 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); -- 2.16.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Janusz Krzysztofik Subject: [PATCH v7 1/4] gpiolib: Pass bitmaps, not integer arrays, to get/set array Date: Sun, 2 Sep 2018 14:01:41 +0200 Message-ID: <20180902120144.6855-2-jmkrzyszt@gmail.com> References: <20180831225616.29221-1-jmkrzyszt@gmail.com> <20180902120144.6855-1-jmkrzyszt@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180902120144.6855-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, linux-iio@vger.kernel.org, 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 , Tony Lindgren , Lukas Wunner , 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 , Yeg List-Id: linux-gpio@vger.kernel.org TW9zdCB1c2VycyBvZiBnZXQvc2V0IGFycmF5IGZ1bmN0aW9ucyBpdGVyYXRlIGNvbnNlY3V0aXZl IGJpdHMgb2YgZGF0YSwKdXN1YWxseSBhIHNpbmdsZSBpbnRlZ2VyLCB3aGlsZSBwcm9jZXNzaW5n IGFycmF5IG9mIHJlc3VsdHMgb2J0YWluZWQKZnJvbSwgb3IgYnVpbGRpbmcgYW4gYXJyYXkgb2Yg dmFsdWVzIHRvIGJlIHBhc3NlZCB0byB0aG9zZSBmdW5jdGlvbnMuClNhdmUgdGltZSB3YXN0ZWQg b24gdGhvc2UgaXRlcmF0aW9ucyBieSBjaGFuZ2luZyB0aGUgZnVuY3Rpb25zJyBBUEkgdG8KYWNj ZXB0IGJpdG1hcHMuCgpBbGwgY3VycmVudCB1c2VycyBhcmUgdXBkYXRlZCBhcyB3ZWxsLgoKTW9y ZSBiZW5lZml0cyBmcm9tIHRoZSBjaGFuZ2UgYXJlIGV4cGVjdGVkIGFzIHNvb24gYXMgcGxhbm5l ZCBzdXBwb3J0CmZvciBhY2NlcHRpbmcvcGFzc2luZyB0aG9zZSBiaXRtYXBzIGRpcmVjdGx5IGZy b20vdG8gcmVzcGVjdGl2ZSBHUElPCmNoaXAgY2FsbGJhY2tzIGlmIGFwcGxpY2FibGUgaXMgaW1w bGVtZW50ZWQuCgpDYzogSm9uYXRoYW4gQ29yYmV0IDxjb3JiZXRAbHduLm5ldD4KQ2M6IE1pZ3Vl bCBPamVkYSBTYW5kb25pcyA8bWlndWVsLm9qZWRhLnNhbmRvbmlzQGdtYWlsLmNvbT4KQ2M6IEdl ZXJ0IFV5dHRlcmhvZXZlbiA8Z2VlcnRAbGludXgtbTY4ay5vcmc+CkNjOiBTZWJhc3RpZW4gQm91 cmRlbGluIDxzZWJhc3RpZW4uYm91cmRlbGluQHNhdm9pcmZhaXJlbGludXguY29tPgpDYzogTHVr YXMgV3VubmVyIDxsdWthc0B3dW5uZXIuZGU+CkNjOiBQZXRlciBLb3JzZ2FhcmQgPHBldGVyLmtv cnNnYWFyZEBiYXJjby5jb20+CkNjOiBQZXRlciBSb3NpbiA8cGVkYUBheGVudGlhLnNlPgpDYzog QW5kcmV3IEx1bm4gPGFuZHJld0BsdW5uLmNoPgpDYzogRmxvcmlhbiBGYWluZWxsaSA8Zi5mYWlu ZWxsaUBnbWFpbC5jb20+CkNjOiAiRGF2aWQgUy4gTWlsbGVyIiA8ZGF2ZW1AZGF2ZW1sb2Z0Lm5l dD4KQ2M6IFJvamhhbGF0IElicmFoaW0gPGltckBydHNjaGVuay5kZT4KQ2M6IERvbWluaWsgQnJv ZG93c2tpIDxsaW51eEBkb21pbmlrYnJvZG93c2tpLm5ldD4KQ2M6IFJ1c3NlbGwgS2luZyA8cm1r K2tlcm5lbEBhcm1saW51eC5vcmcudWs+CkNjOiBLaXNob24gVmlqYXkgQWJyYWhhbSBJIDxraXNo b25AdGkuY29tPgpDYzogVG9ueSBMaW5kZ3JlbiA8dG9ueUBhdG9taWRlLmNvbT4KQ2M6IExhcnMt UGV0ZXIgQ2xhdXNlbiA8bGFyc0BtZXRhZm9vLmRlPgpDYzogTWljaGFlbCBIZW5uZXJpY2ggPE1p Y2hhZWwuSGVubmVyaWNoQGFuYWxvZy5jb20+CkNjOiBKb25hdGhhbiBDYW1lcm9uIDxqaWMyM0Br ZXJuZWwub3JnPgpDYzogSGFydG11dCBLbmFhY2sgPGtuYWFjay5oQGdteC5kZT4KQ2M6IFBldGVy IE1lZXJ3YWxkLVN0YWRsZXIgPHBtZWVyd0BwbWVlcncubmV0PgpDYzogR3JlZyBLcm9haC1IYXJ0 bWFuIDxncmVna2hAbGludXhmb3VuZGF0aW9uLm9yZz4KQ2M6IEppcmkgU2xhYnkgPGpzbGFieUBz dXNlLmNvbT4KQ2M6IFllZ29yIFllZnJlbW92IDx5ZWdvcnNsaXN0c0Bnb29nbGVtYWlsLmNvbT4K Q2M6IFV3ZSBLbGVpbmUtS8O2bmlnIDx1LmtsZWluZS1rb2VuaWdAcGVuZ3V0cm9uaXguZGU+ClNp Z25lZC1vZmYtYnk6IEphbnVzeiBLcnp5c3p0b2ZpayA8am1rcnp5c3p0QGdtYWlsLmNvbT4KQWNr ZWQtYnk6IFVsZiBIYW5zc29uIDx1bGYuaGFuc3NvbkBsaW5hcm8ub3JnPgotLS0KIERvY3VtZW50 YXRpb24vZHJpdmVyLWFwaS9ncGlvL2NvbnN1bWVyLnJzdCAgfCAyMiArKysrLS0tLQogZHJpdmVy cy9hdXhkaXNwbGF5L2hkNDQ3ODAuYyAgICAgICAgICAgICAgICB8IDU5ICsrKysrKystLS0tLS0t LS0tLS0tLQogZHJpdmVycy9idXMvdHMtbmJ1cy5jICAgICAgICAgICAgICAgICAgICAgICB8IDE1 ICsrLS0tLQogZHJpdmVycy9ncGlvL2dwaW8tbWF4MzE5MXguYyAgICAgICAgICAgICAgICB8IDEw ICsrLS0KIGRyaXZlcnMvZ3Bpby9ncGlvbGliLmMgICAgICAgICAgICAgICAgICAgICAgfCA4MiAr KysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLQogZHJpdmVycy9ncGlvL2dwaW9saWIuaCAgICAg ICAgICAgICAgICAgICAgICB8ICA0ICstCiBkcml2ZXJzL2kyYy9tdXhlcy9pMmMtbXV4LWdwaW8u YyAgICAgICAgICAgIHwgMTMgKystLS0KIGRyaXZlcnMvbW1jL2NvcmUvcHdyc2VxX3NpbXBsZS5j ICAgICAgICAgICAgfCAxMyArKy0tLQogZHJpdmVycy9tdXgvZ3Bpby5jICAgICAgICAgICAgICAg ICAgICAgICAgICB8IDEzICsrLS0tCiBkcml2ZXJzL25ldC9waHkvbWRpby1tdXgtZ3Bpby5jICAg ICAgICAgICAgIHwgMTEgKystLQogZHJpdmVycy9wY21jaWEvc29jX2NvbW1vbi5jICAgICAgICAg ICAgICAgICB8ICA4ICstLQogZHJpdmVycy9waHkvbW90b3JvbGEvcGh5LW1hcHBob25lLW1kbTY2 MDAuYyB8IDEzICsrLS0tCiBkcml2ZXJzL3N0YWdpbmcvaWlvL2FkYy9hZDc2MDYuYyAgICAgICAg ICAgIHwgIDkgKystLQogZHJpdmVycy90dHkvc2VyaWFsL3NlcmlhbF9tY3RybF9ncGlvLmMgICAg ICB8ICA3ICstLQogaW5jbHVkZS9saW51eC9ncGlvL2NvbnN1bWVyLmggICAgICAgICAgICAgICB8 IDE4ICsrKystLS0KIDE1IGZpbGVzIGNoYW5nZWQsIDEyOSBpbnNlcnRpb25zKCspLCAxNjggZGVs ZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2dwaW8vY29u c3VtZXIucnN0IGIvRG9jdW1lbnRhdGlvbi9kcml2ZXItYXBpL2dwaW8vY29uc3VtZXIucnN0Cmlu ZGV4IGFhMDNmMzg5ZDQxZC4uZWQ2ODA0MmRkY2NmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9u L2RyaXZlci1hcGkvZ3Bpby9jb25zdW1lci5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi9kcml2ZXIt YXBpL2dwaW8vY29uc3VtZXIucnN0CkBAIC0zMjMsMjkgKzMyMywyOSBAQCBUaGUgZm9sbG93aW5n IGZ1bmN0aW9ucyBnZXQgb3Igc2V0IHRoZSB2YWx1ZXMgb2YgYW4gYXJyYXkgb2YgR1BJT3M6Ogog CiAJaW50IGdwaW9kX2dldF9hcnJheV92YWx1ZSh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJ CQkgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCSAgaW50ICp2YWx1ZV9hcnJh eSk7CisJCQkJICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApOwogCWludCBncGlvZF9nZXRf cmF3X2FycmF5X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCSAgICAgIHN0cnVj dCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCSAgICAgIGludCAqdmFsdWVfYXJyYXkpOwor CQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCk7CiAJaW50IGdwaW9kX2dldF9h cnJheV92YWx1ZV9jYW5zbGVlcCh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkJICAgc3Ry dWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJCSAgIGludCAqdmFsdWVfYXJyYXkpOwor CQkJCQkgICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApOwogCWludCBncGlvZF9nZXRfcmF3 X2FycmF5X3ZhbHVlX2NhbnNsZWVwKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCQkgICBz dHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkJICAgaW50ICp2YWx1ZV9hcnJheSk7 CisJCQkJCSAgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCk7CiAKIAl2b2lkIGdwaW9kX3Nl dF9hcnJheV92YWx1ZSh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgICBzdHJ1Y3QgZ3Bp b19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkgICBpbnQgKnZhbHVlX2FycmF5KQorCQkJCSAgIHVu c2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIAl2b2lkIGdwaW9kX3NldF9yYXdfYXJyYXlfdmFs dWUodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJICAgICAgIHN0cnVjdCBncGlvX2Rlc2Mg KipkZXNjX2FycmF5LAotCQkJCSAgICAgICBpbnQgKnZhbHVlX2FycmF5KQorCQkJCSAgICAgICB1 bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiAJdm9pZCBncGlvZF9zZXRfYXJyYXlfdmFsdWVf Y2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJCSAgICBzdHJ1Y3QgZ3Bpb19k ZXNjICoqZGVzY19hcnJheSwKLQkJCQkJICAgIGludCAqdmFsdWVfYXJyYXkpCisJCQkJCSAgICB1 bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiAJdm9pZCBncGlvZF9zZXRfcmF3X2FycmF5X3Zh bHVlX2NhbnNsZWVwKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCQkJc3RydWN0IGdwaW9f ZGVzYyAqKmRlc2NfYXJyYXksCi0JCQkJCQlpbnQgKnZhbHVlX2FycmF5KQorCQkJCQkJdW5zaWdu ZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogCiBUaGUgYXJyYXkgY2FuIGJlIGFuIGFyYml0cmFyeSBz ZXQgb2YgR1BJT3MuIFRoZSBmdW5jdGlvbnMgd2lsbCB0cnkgdG8gYWNjZXNzCiBHUElPcyBiZWxv bmdpbmcgdG8gdGhlIHNhbWUgYmFuayBvciBjaGlwIHNpbXVsdGFuZW91c2x5IGlmIHN1cHBvcnRl ZCBieSB0aGUKQEAgLTM1Niw4ICszNTYsOCBAQCBhY2Nlc3NlZCBzZXF1ZW50aWFsbHkuCiBUaGUg ZnVuY3Rpb25zIHRha2UgdGhyZWUgYXJndW1lbnRzOgogCSogYXJyYXlfc2l6ZQktIHRoZSBudW1i ZXIgb2YgYXJyYXkgZWxlbWVudHMKIAkqIGRlc2NfYXJyYXkJLSBhbiBhcnJheSBvZiBHUElPIGRl c2NyaXB0b3JzCi0JKiB2YWx1ZV9hcnJheQktIGFuIGFycmF5IHRvIHN0b3JlIHRoZSBHUElPcycg dmFsdWVzIChnZXQpIG9yCi0JCQkgIGFuIGFycmF5IG9mIHZhbHVlcyB0byBhc3NpZ24gdG8gdGhl IEdQSU9zIChzZXQpCisJKiB2YWx1ZV9iaXRtYXAJLSBhIGJpdG1hcCB0byBzdG9yZSB0aGUgR1BJ T3MnIHZhbHVlcyAoZ2V0KSBvcgorCQkJICBhIGJpdG1hcCBvZiB2YWx1ZXMgdG8gYXNzaWduIHRv IHRoZSBHUElPcyAoc2V0KQogCiBUaGUgZGVzY3JpcHRvciBhcnJheSBjYW4gYmUgb2J0YWluZWQg dXNpbmcgdGhlIGdwaW9kX2dldF9hcnJheSgpIGZ1bmN0aW9uCiBvciBvbmUgb2YgaXRzIHZhcmlh bnRzLiBJZiB0aGUgZ3JvdXAgb2YgZGVzY3JpcHRvcnMgcmV0dXJuZWQgYnkgdGhhdCBmdW5jdGlv bgpAQCAtMzY2LDcgKzM2Niw3IEBAIHRoZSBzdHJ1Y3QgZ3Bpb19kZXNjcyByZXR1cm5lZCBieSBn cGlvZF9nZXRfYXJyYXkoKTo6CiAKIAlzdHJ1Y3QgZ3Bpb19kZXNjcyAqbXlfZ3Bpb19kZXNjcyA9 IGdwaW9kX2dldF9hcnJheSguLi4pOwogCWdwaW9kX3NldF9hcnJheV92YWx1ZShteV9ncGlvX2Rl c2NzLT5uZGVzY3MsIG15X2dwaW9fZGVzY3MtPmRlc2MsCi0JCQkgICAgICBteV9ncGlvX3ZhbHVl cyk7CisJCQkgICAgICBteV9ncGlvX3ZhbHVlX2JpdG1hcCk7CiAKIEl0IGlzIGFsc28gcG9zc2li bGUgdG8gYWNjZXNzIGEgY29tcGxldGVseSBhcmJpdHJhcnkgYXJyYXkgb2YgZGVzY3JpcHRvcnMu IFRoZQogZGVzY3JpcHRvcnMgbWF5IGJlIG9idGFpbmVkIHVzaW5nIGFueSBjb21iaW5hdGlvbiBv ZiBncGlvZF9nZXQoKSBhbmQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXV4ZGlzcGxheS9oZDQ0Nzgw LmMgYi9kcml2ZXJzL2F1eGRpc3BsYXkvaGQ0NDc4MC5jCmluZGV4IGYxYTQyZjBmMWRlZC4uMzMz ZTMwZTM3OGI1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F1eGRpc3BsYXkvaGQ0NDc4MC5jCisrKyBi L2RyaXZlcnMvYXV4ZGlzcGxheS9oZDQ0NzgwLmMKQEAgLTYyLDE3ICs2MiwxMiBAQCBzdGF0aWMg dm9pZCBoZDQ0NzgwX3N0cm9iZV9ncGlvKHN0cnVjdCBoZDQ0NzgwICpoZCkKIC8qIHdyaXRlIHRv IGFuIExDRCBwYW5lbCByZWdpc3RlciBpbiA4IGJpdCBHUElPIG1vZGUgKi8KIHN0YXRpYyB2b2lk IGhkNDQ3ODBfd3JpdGVfZ3Bpbzgoc3RydWN0IGhkNDQ3ODAgKmhkLCB1OCB2YWwsIHVuc2lnbmVk IGludCBycykKIHsKLQlpbnQgdmFsdWVzWzEwXTsJLyogZm9yIERBVEFbMC03XSwgUlMsIFJXICov Ci0JdW5zaWduZWQgaW50IGksIG47Ci0KLQlmb3IgKGkgPSAwOyBpIDwgODsgaSsrKQotCQl2YWx1 ZXNbUElOX0RBVEEwICsgaV0gPSAhISh2YWwgJiBCSVQoaSkpOwotCXZhbHVlc1tQSU5fQ1RSTF9S U10gPSByczsKLQluID0gOTsKLQlpZiAoaGQtPnBpbnNbUElOX0NUUkxfUlddKSB7Ci0JCXZhbHVl c1tQSU5fQ1RSTF9SV10gPSAwOwotCQluKys7Ci0JfQorCURFQ0xBUkVfQklUTUFQKHZhbHVlcywg MTApOyAvKiBmb3IgREFUQVswLTddLCBSUywgUlcgKi8KKwl1bnNpZ25lZCBpbnQgbjsKKworCSp2 YWx1ZXMgPSB2YWw7CisJX19hc3NpZ25fYml0KDgsIHZhbHVlcywgcnMpOworCW4gPSBoZC0+cGlu c1tQSU5fQ1RSTF9SV10gPyAxMCA6IDk7CiAKIAkvKiBQcmVzZW50IHRoZSBkYXRhIHRvIHRoZSBw b3J0ICovCiAJZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKG4sICZoZC0+cGluc1tQSU5f REFUQTBdLCB2YWx1ZXMpOwpAQCAtODMsMzIgKzc4LDI1IEBAIHN0YXRpYyB2b2lkIGhkNDQ3ODBf d3JpdGVfZ3Bpbzgoc3RydWN0IGhkNDQ3ODAgKmhkLCB1OCB2YWwsIHVuc2lnbmVkIGludCBycykK IC8qIHdyaXRlIHRvIGFuIExDRCBwYW5lbCByZWdpc3RlciBpbiA0IGJpdCBHUElPIG1vZGUgKi8K IHN0YXRpYyB2b2lkIGhkNDQ3ODBfd3JpdGVfZ3BpbzQoc3RydWN0IGhkNDQ3ODAgKmhkLCB1OCB2 YWwsIHVuc2lnbmVkIGludCBycykKIHsKLQlpbnQgdmFsdWVzWzEwXTsJLyogZm9yIERBVEFbMC03 XSwgUlMsIFJXLCBidXQgREFUQVswLTNdIGlzIHVudXNlZCAqLwotCXVuc2lnbmVkIGludCBpLCBu OworCURFQ0xBUkVfQklUTUFQKHZhbHVlcywgNik7IC8qIGZvciBEQVRBWzQtN10sIFJTLCBSVyAq LworCXVuc2lnbmVkIGludCBuOwogCiAJLyogSGlnaCBuaWJibGUgKyBSUywgUlcgKi8KLQlmb3Ig KGkgPSA0OyBpIDwgODsgaSsrKQotCQl2YWx1ZXNbUElOX0RBVEEwICsgaV0gPSAhISh2YWwgJiBC SVQoaSkpOwotCXZhbHVlc1tQSU5fQ1RSTF9SU10gPSByczsKLQluID0gNTsKLQlpZiAoaGQtPnBp bnNbUElOX0NUUkxfUlddKSB7Ci0JCXZhbHVlc1tQSU5fQ1RSTF9SV10gPSAwOwotCQluKys7Ci0J fQorCSp2YWx1ZXMgPSB2YWwgPj4gNDsKKwlfX2Fzc2lnbl9iaXQoNCwgdmFsdWVzLCBycyk7CisJ biA9IGhkLT5waW5zW1BJTl9DVFJMX1JXXSA/IDYgOiA1OwogCiAJLyogUHJlc2VudCB0aGUgZGF0 YSB0byB0aGUgcG9ydCAqLwotCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcChuLCAmaGQt PnBpbnNbUElOX0RBVEE0XSwKLQkJCQkgICAgICAgJnZhbHVlc1tQSU5fREFUQTRdKTsKKwlncGlv ZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAobiwgJmhkLT5waW5zW1BJTl9EQVRBNF0sIHZhbHVl cyk7CiAKIAloZDQ0NzgwX3N0cm9iZV9ncGlvKGhkKTsKIAogCS8qIExvdyBuaWJibGUgKi8KLQlm b3IgKGkgPSAwOyBpIDwgNDsgaSsrKQotCQl2YWx1ZXNbUElOX0RBVEE0ICsgaV0gPSAhISh2YWwg JiBCSVQoaSkpOworCSp2YWx1ZXMgJj0gfjB4MGZVTDsKKwkqdmFsdWVzIHw9IHZhbCAmIDB4MGY7 CiAKIAkvKiBQcmVzZW50IHRoZSBkYXRhIHRvIHRoZSBwb3J0ICovCi0JZ3Bpb2Rfc2V0X2FycmF5 X3ZhbHVlX2NhbnNsZWVwKG4sICZoZC0+cGluc1tQSU5fREFUQTRdLAotCQkJCSAgICAgICAmdmFs dWVzW1BJTl9EQVRBNF0pOworCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcChuLCAmaGQt PnBpbnNbUElOX0RBVEE0XSwgdmFsdWVzKTsKIAogCWhkNDQ3ODBfc3Ryb2JlX2dwaW8oaGQpOwog fQpAQCAtMTU1LDIzICsxNDMsMTYgQEAgc3RhdGljIHZvaWQgaGQ0NDc4MF93cml0ZV9jbWRfZ3Bp bzQoc3RydWN0IGNoYXJsY2QgKmxjZCwgaW50IGNtZCkKIC8qIFNlbmQgNC1iaXRzIG9mIGEgY29t bWFuZCB0byB0aGUgTENEIHBhbmVsIGluIHJhdyA0IGJpdCBHUElPIG1vZGUgKi8KIHN0YXRpYyB2 b2lkIGhkNDQ3ODBfd3JpdGVfY21kX3Jhd19ncGlvNChzdHJ1Y3QgY2hhcmxjZCAqbGNkLCBpbnQg Y21kKQogewotCWludCB2YWx1ZXNbMTBdOwkvKiBmb3IgREFUQVswLTddLCBSUywgUlcsIGJ1dCBE QVRBWzAtM10gaXMgdW51c2VkICovCisJREVDTEFSRV9CSVRNQVAodmFsdWVzLCA2KTsgLyogZm9y IERBVEFbNC03XSwgUlMsIFJXICovCiAJc3RydWN0IGhkNDQ3ODAgKmhkID0gbGNkLT5kcnZkYXRh OwotCXVuc2lnbmVkIGludCBpLCBuOworCXVuc2lnbmVkIGludCBuOwogCiAJLyogQ29tbWFuZCBu aWJibGUgKyBSUywgUlcgKi8KLQlmb3IgKGkgPSAwOyBpIDwgNDsgaSsrKQotCQl2YWx1ZXNbUElO X0RBVEE0ICsgaV0gPSAhIShjbWQgJiBCSVQoaSkpOwotCXZhbHVlc1tQSU5fQ1RSTF9SU10gPSAw OwotCW4gPSA1OwotCWlmIChoZC0+cGluc1tQSU5fQ1RSTF9SV10pIHsKLQkJdmFsdWVzW1BJTl9D VFJMX1JXXSA9IDA7Ci0JCW4rKzsKLQl9CisJKnZhbHVlcyA9IGNtZCAmIDB4MGY7CisJbiA9IGhk LT5waW5zW1BJTl9DVFJMX1JXXSA/IDYgOiA1OwogCiAJLyogUHJlc2VudCB0aGUgZGF0YSB0byB0 aGUgcG9ydCAqLwotCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcChuLCAmaGQtPnBpbnNb UElOX0RBVEE0XSwKLQkJCQkgICAgICAgJnZhbHVlc1tQSU5fREFUQTRdKTsKKwlncGlvZF9zZXRf YXJyYXlfdmFsdWVfY2Fuc2xlZXAobiwgJmhkLT5waW5zW1BJTl9EQVRBNF0sIHZhbHVlcyk7CiAK IAloZDQ0NzgwX3N0cm9iZV9ncGlvKGhkKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYnVzL3Rz LW5idXMuYyBiL2RyaXZlcnMvYnVzL3RzLW5idXMuYwppbmRleCAwNzNmZDkwMTExNTQuLjY0OTk5 NTdhODA0NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9idXMvdHMtbmJ1cy5jCisrKyBiL2RyaXZlcnMv YnVzL3RzLW5idXMuYwpAQCAtMTEwLDExICsxMTAsOSBAQCBzdGF0aWMgdm9pZCB0c19uYnVzX3Nl dF9kaXJlY3Rpb24oc3RydWN0IHRzX25idXMgKnRzX25idXMsIGludCBkaXJlY3Rpb24pCiAgKi8K IHN0YXRpYyB2b2lkIHRzX25idXNfcmVzZXRfYnVzKHN0cnVjdCB0c19uYnVzICp0c19uYnVzKQog ewotCWludCBpOwotCWludCB2YWx1ZXNbOF07CisJREVDTEFSRV9CSVRNQVAodmFsdWVzLCA4KTsK IAotCWZvciAoaSA9IDA7IGkgPCA4OyBpKyspCi0JCXZhbHVlc1tpXSA9IDA7CisJKnZhbHVlcyA9 IDA7CiAKIAlncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAoOCwgdHNfbmJ1cy0+ZGF0YS0+ ZGVzYywgdmFsdWVzKTsKIAlncGlvZF9zZXRfdmFsdWVfY2Fuc2xlZXAodHNfbmJ1cy0+Y3NuLCAw KTsKQEAgLTE1NywxNCArMTU1LDkgQEAgc3RhdGljIGludCB0c19uYnVzX3JlYWRfYnl0ZShzdHJ1 Y3QgdHNfbmJ1cyAqdHNfbmJ1cywgdTggKnZhbCkKIHN0YXRpYyB2b2lkIHRzX25idXNfd3JpdGVf Ynl0ZShzdHJ1Y3QgdHNfbmJ1cyAqdHNfbmJ1cywgdTggYnl0ZSkKIHsKIAlzdHJ1Y3QgZ3Bpb19k ZXNjcyAqZ3Bpb3MgPSB0c19uYnVzLT5kYXRhOwotCWludCBpOwotCWludCB2YWx1ZXNbOF07CisJ REVDTEFSRV9CSVRNQVAodmFsdWVzLCA4KTsKIAotCWZvciAoaSA9IDA7IGkgPCA4OyBpKyspCi0J CWlmIChieXRlICYgQklUKGkpKQotCQkJdmFsdWVzW2ldID0gMTsKLQkJZWxzZQotCQkJdmFsdWVz W2ldID0gMDsKKwkqdmFsdWVzID0gYnl0ZTsKIAogCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5z bGVlcCg4LCBncGlvcy0+ZGVzYywgdmFsdWVzKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bp by9ncGlvLW1heDMxOTF4LmMgYi9kcml2ZXJzL2dwaW8vZ3Bpby1tYXgzMTkxeC5jCmluZGV4IGI1 YjljYjFmZGE1MC4uYmQ0YTI0NWZjNWEwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby1t YXgzMTkxeC5jCisrKyBiL2RyaXZlcnMvZ3Bpby9ncGlvLW1heDMxOTF4LmMKQEAgLTMxNSwxNCAr MzE1LDE2IEBAIHN0YXRpYyB2b2lkIGdwaW9kX3NldF9hcnJheV9zaW5nbGVfdmFsdWVfY2Fuc2xl ZXAodW5zaWduZWQgaW50IG5kZXNjcywKIAkJCQkJCSAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2Ms CiAJCQkJCQkgIGludCB2YWx1ZSkKIHsKLQlpbnQgaSwgKnZhbHVlczsKKwl1bnNpZ25lZCBsb25n ICp2YWx1ZXM7CiAKLQl2YWx1ZXMgPSBrbWFsbG9jX2FycmF5KG5kZXNjcywgc2l6ZW9mKCp2YWx1 ZXMpLCBHRlBfS0VSTkVMKTsKKwl2YWx1ZXMgPSBiaXRtYXBfYWxsb2MobmRlc2NzLCBHRlBfS0VS TkVMKTsKIAlpZiAoIXZhbHVlcykKIAkJcmV0dXJuOwogCi0JZm9yIChpID0gMDsgaSA8IG5kZXNj czsgaSsrKQotCQl2YWx1ZXNbaV0gPSB2YWx1ZTsKKwlpZiAodmFsdWUpCisJCWJpdG1hcF9maWxs KHZhbHVlcywgbmRlc2NzKTsKKwllbHNlCisJCWJpdG1hcF96ZXJvKHZhbHVlcywgbmRlc2NzKTsK IAogCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcChuZGVzY3MsIGRlc2MsIHZhbHVlcyk7 CiAJa2ZyZWUodmFsdWVzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLmMgYi9k cml2ZXJzL2dwaW8vZ3Bpb2xpYi5jCmluZGV4IGU4ZjhhMTk5OTM5My4uNDM0ZDA5Nzc5YTFmIDEw MDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpb2xpYi5jCisrKyBiL2RyaXZlcnMvZ3Bpby9ncGlv bGliLmMKQEAgLTQyNyw3ICs0MjcsNyBAQCBzdGF0aWMgbG9uZyBsaW5laGFuZGxlX2lvY3RsKHN0 cnVjdCBmaWxlICpmaWxlcCwgdW5zaWduZWQgaW50IGNtZCwKIAlzdHJ1Y3QgbGluZWhhbmRsZV9z dGF0ZSAqbGggPSBmaWxlcC0+cHJpdmF0ZV9kYXRhOwogCXZvaWQgX191c2VyICppcCA9ICh2b2lk IF9fdXNlciAqKWFyZzsKIAlzdHJ1Y3QgZ3Bpb2hhbmRsZV9kYXRhIGdoZDsKLQlpbnQgdmFsc1tH UElPSEFORExFU19NQVhdOworCURFQ0xBUkVfQklUTUFQKHZhbHMsIEdQSU9IQU5ETEVTX01BWCk7 CiAJaW50IGk7CiAKIAlpZiAoY21kID09IEdQSU9IQU5ETEVfR0VUX0xJTkVfVkFMVUVTX0lPQ1RM KSB7CkBAIC00NDIsNyArNDQyLDcgQEAgc3RhdGljIGxvbmcgbGluZWhhbmRsZV9pb2N0bChzdHJ1 Y3QgZmlsZSAqZmlsZXAsIHVuc2lnbmVkIGludCBjbWQsCiAKIAkJbWVtc2V0KCZnaGQsIDAsIHNp emVvZihnaGQpKTsKIAkJZm9yIChpID0gMDsgaSA8IGxoLT5udW1kZXNjczsgaSsrKQotCQkJZ2hk LnZhbHVlc1tpXSA9IHZhbHNbaV07CisJCQlnaGQudmFsdWVzW2ldID0gdGVzdF9iaXQoaSwgdmFs cyk7CiAKIAkJaWYgKGNvcHlfdG9fdXNlcihpcCwgJmdoZCwgc2l6ZW9mKGdoZCkpKQogCQkJcmV0 dXJuIC1FRkFVTFQ7CkBAIC00NjEsNyArNDYxLDcgQEAgc3RhdGljIGxvbmcgbGluZWhhbmRsZV9p b2N0bChzdHJ1Y3QgZmlsZSAqZmlsZXAsIHVuc2lnbmVkIGludCBjbWQsCiAKIAkJLyogQ2xhbXAg YWxsIHZhbHVlcyB0byBbMCwxXSAqLwogCQlmb3IgKGkgPSAwOyBpIDwgbGgtPm51bWRlc2NzOyBp KyspCi0JCQl2YWxzW2ldID0gISFnaGQudmFsdWVzW2ldOworCQkJX19hc3NpZ25fYml0KGksIHZh bHMsICEhZ2hkLnZhbHVlc1tpXSk7CiAKIAkJLyogUmV1c2UgdGhlIGFycmF5IHNldHRpbmcgZnVu Y3Rpb24gKi8KIAkJcmV0dXJuIGdwaW9kX3NldF9hcnJheV92YWx1ZV9jb21wbGV4KGZhbHNlLApA QCAtMjc4NCw3ICsyNzg0LDcgQEAgc3RhdGljIGludCBncGlvX2NoaXBfZ2V0X211bHRpcGxlKHN0 cnVjdCBncGlvX2NoaXAgKmNoaXAsCiBpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgo Ym9vbCByYXcsIGJvb2wgY2FuX3NsZWVwLAogCQkJCSAgdW5zaWduZWQgaW50IGFycmF5X3NpemUs CiAJCQkJICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkgIGludCAqdmFsdWVf YXJyYXkpCisJCQkJICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiB7CiAJaW50IGkgPSAw OwogCkBAIC0yODM1LDcgKzI4MzUsNyBAQCBpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NvbXBs ZXgoYm9vbCByYXcsIGJvb2wgY2FuX3NsZWVwLAogCiAJCQlpZiAoIXJhdyAmJiB0ZXN0X2JpdChG TEFHX0FDVElWRV9MT1csICZkZXNjLT5mbGFncykpCiAJCQkJdmFsdWUgPSAhdmFsdWU7Ci0JCQl2 YWx1ZV9hcnJheVtqXSA9IHZhbHVlOworCQkJX19hc3NpZ25fYml0KGosIHZhbHVlX2JpdG1hcCwg dmFsdWUpOwogCQkJdHJhY2VfZ3Bpb192YWx1ZShkZXNjX3RvX2dwaW8oZGVzYyksIDEsIHZhbHVl KTsKIAkJfQogCkBAIC0yODk1LDkgKzI4OTUsOSBAQCBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9n ZXRfdmFsdWUpOwogCiAvKioKICAqIGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWUoKSAtIHJlYWQg cmF3IHZhbHVlcyBmcm9tIGFuIGFycmF5IG9mIEdQSU9zCi0gKiBAYXJyYXlfc2l6ZTogbnVtYmVy IG9mIGVsZW1lbnRzIGluIHRoZSBkZXNjcmlwdG9yIC8gdmFsdWUgYXJyYXlzCisgKiBAYXJyYXlf c2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkZXNjcmlwdG9yIGFycmF5IC8gdmFsdWUg Yml0bWFwCiAgKiBAZGVzY19hcnJheTogYXJyYXkgb2YgR1BJTyBkZXNjcmlwdG9ycyB3aG9zZSB2 YWx1ZXMgd2lsbCBiZSByZWFkCi0gKiBAdmFsdWVfYXJyYXk6IGFycmF5IHRvIHN0b3JlIHRoZSBy ZWFkIHZhbHVlcworICogQHZhbHVlX2JpdG1hcDogYml0bWFwIHRvIHN0b3JlIHRoZSByZWFkIHZh bHVlcwogICoKICAqIFJlYWQgdGhlIHJhdyB2YWx1ZXMgb2YgdGhlIEdQSU9zLCBpLmUuIHRoZSB2 YWx1ZXMgb2YgdGhlIHBoeXNpY2FsIGxpbmVzCiAgKiB3aXRob3V0IHJlZ2FyZCBmb3IgdGhlaXIg QUNUSVZFX0xPVyBzdGF0dXMuICBSZXR1cm4gMCBpbiBjYXNlIG9mIHN1Y2Nlc3MsCkBAIC0yOTA3 LDIwICsyOTA3LDIxIEBAIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX2dldF92YWx1ZSk7CiAgKiBh bmQgaXQgd2lsbCBjb21wbGFpbiBpZiB0aGUgR1BJTyBjaGlwIGZ1bmN0aW9ucyBwb3RlbnRpYWxs eSBzbGVlcC4KICAqLwogaW50IGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWUodW5zaWduZWQgaW50 IGFycmF5X3NpemUsCi0JCQkgICAgICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwgaW50 ICp2YWx1ZV9hcnJheSkKKwkJCSAgICAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAor CQkJICAgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogewogCWlmICghZGVzY19hcnJh eSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJcmV0dXJuIGdwaW9kX2dldF9hcnJheV92YWx1ZV9jb21w bGV4KHRydWUsIGZhbHNlLCBhcnJheV9zaXplLAotCQkJCQkgICAgIGRlc2NfYXJyYXksIHZhbHVl X2FycmF5KTsKKwkJCQkJICAgICBkZXNjX2FycmF5LCB2YWx1ZV9iaXRtYXApOwogfQogRVhQT1JU X1NZTUJPTF9HUEwoZ3Bpb2RfZ2V0X3Jhd19hcnJheV92YWx1ZSk7CiAKIC8qKgogICogZ3Bpb2Rf Z2V0X2FycmF5X3ZhbHVlKCkgLSByZWFkIHZhbHVlcyBmcm9tIGFuIGFycmF5IG9mIEdQSU9zCi0g KiBAYXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkZXNjcmlwdG9yIC8gdmFs dWUgYXJyYXlzCisgKiBAYXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkZXNj cmlwdG9yIGFycmF5IC8gdmFsdWUgYml0bWFwCiAgKiBAZGVzY19hcnJheTogYXJyYXkgb2YgR1BJ TyBkZXNjcmlwdG9ycyB3aG9zZSB2YWx1ZXMgd2lsbCBiZSByZWFkCi0gKiBAdmFsdWVfYXJyYXk6 IGFycmF5IHRvIHN0b3JlIHRoZSByZWFkIHZhbHVlcworICogQHZhbHVlX2JpdG5hcDogYml0bWFw IHRvIHN0b3JlIHRoZSByZWFkIHZhbHVlcwogICoKICAqIFJlYWQgdGhlIGxvZ2ljYWwgdmFsdWVz IG9mIHRoZSBHUElPcywgaS5lLiB0YWtpbmcgdGhlaXIgQUNUSVZFX0xPVyBzdGF0dXMKICAqIGlu dG8gYWNjb3VudC4gIFJldHVybiAwIGluIGNhc2Ugb2Ygc3VjY2VzcywgZWxzZSBhbiBlcnJvciBj b2RlLgpAQCAtMjkyOSwxMiArMjkzMCwxMyBAQCBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9nZXRf cmF3X2FycmF5X3ZhbHVlKTsKICAqIGFuZCBpdCB3aWxsIGNvbXBsYWluIGlmIHRoZSBHUElPIGNo aXAgZnVuY3Rpb25zIHBvdGVudGlhbGx5IHNsZWVwLgogICovCiBpbnQgZ3Bpb2RfZ2V0X2FycmF5 X3ZhbHVlKHVuc2lnbmVkIGludCBhcnJheV9zaXplLAotCQkJICBzdHJ1Y3QgZ3Bpb19kZXNjICoq ZGVzY19hcnJheSwgaW50ICp2YWx1ZV9hcnJheSkKKwkJCSAgc3RydWN0IGdwaW9fZGVzYyAqKmRl c2NfYXJyYXksCisJCQkgIHVuc2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIHsKIAlpZiAoIWRl c2NfYXJyYXkpCiAJCXJldHVybiAtRUlOVkFMOwogCXJldHVybiBncGlvZF9nZXRfYXJyYXlfdmFs dWVfY29tcGxleChmYWxzZSwgZmFsc2UsIGFycmF5X3NpemUsCi0JCQkJCSAgICAgZGVzY19hcnJh eSwgdmFsdWVfYXJyYXkpOworCQkJCQkgICAgIGRlc2NfYXJyYXksIHZhbHVlX2JpdG1hcCk7CiB9 CiBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9nZXRfYXJyYXlfdmFsdWUpOwogCkBAIC0zMDI3LDcg KzMwMjksNyBAQCBzdGF0aWMgdm9pZCBncGlvX2NoaXBfc2V0X211bHRpcGxlKHN0cnVjdCBncGlv X2NoaXAgKmNoaXAsCiBpbnQgZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgoYm9vbCByYXcs IGJvb2wgY2FuX3NsZWVwLAogCQkJCSAgIHVuc2lnbmVkIGludCBhcnJheV9zaXplLAogCQkJCSAg IHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCSAgIGludCAqdmFsdWVfYXJyYXkp CisJCQkJICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogewogCWludCBpID0gMDsKIApA QCAtMzA1Niw3ICszMDU4LDcgQEAgaW50IGdwaW9kX3NldF9hcnJheV92YWx1ZV9jb21wbGV4KGJv b2wgcmF3LCBib29sIGNhbl9zbGVlcCwKIAkJZG8gewogCQkJc3RydWN0IGdwaW9fZGVzYyAqZGVz YyA9IGRlc2NfYXJyYXlbaV07CiAJCQlpbnQgaHdncGlvID0gZ3Bpb19jaGlwX2h3Z3BpbyhkZXNj KTsKLQkJCWludCB2YWx1ZSA9IHZhbHVlX2FycmF5W2ldOworCQkJaW50IHZhbHVlID0gdGVzdF9i aXQoaSwgdmFsdWVfYml0bWFwKTsKIAogCQkJaWYgKCFyYXcgJiYgdGVzdF9iaXQoRkxBR19BQ1RJ VkVfTE9XLCAmZGVzYy0+ZmxhZ3MpKQogCQkJCXZhbHVlID0gIXZhbHVlOwpAQCAtMzE1Miw5ICsz MTU0LDkgQEAgRVhQT1JUX1NZTUJPTF9HUEwoZ3Bpb2Rfc2V0X3ZhbHVlKTsKIAogLyoqCiAgKiBn cGlvZF9zZXRfcmF3X2FycmF5X3ZhbHVlKCkgLSBhc3NpZ24gdmFsdWVzIHRvIGFuIGFycmF5IG9m IEdQSU9zCi0gKiBAYXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkZXNjcmlw dG9yIC8gdmFsdWUgYXJyYXlzCisgKiBAYXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGlu IHRoZSBkZXNjcmlwdG9yIGFycmF5IC8gdmFsdWUgYml0bWFwCiAgKiBAZGVzY19hcnJheTogYXJy YXkgb2YgR1BJTyBkZXNjcmlwdG9ycyB3aG9zZSB2YWx1ZXMgd2lsbCBiZSBhc3NpZ25lZAotICog QHZhbHVlX2FycmF5OiBhcnJheSBvZiB2YWx1ZXMgdG8gYXNzaWduCisgKiBAdmFsdWVfYml0bWFw OiBiaXRtYXAgb2YgdmFsdWVzIHRvIGFzc2lnbgogICoKICAqIFNldCB0aGUgcmF3IHZhbHVlcyBv ZiB0aGUgR1BJT3MsIGkuZS4gdGhlIHZhbHVlcyBvZiB0aGUgcGh5c2ljYWwgbGluZXMKICAqIHdp dGhvdXQgcmVnYXJkIGZvciB0aGVpciBBQ1RJVkVfTE9XIHN0YXR1cy4KQEAgLTMxNjMsMjAgKzMx NjUsMjEgQEAgRVhQT1JUX1NZTUJPTF9HUEwoZ3Bpb2Rfc2V0X3ZhbHVlKTsKICAqIGNvbXBsYWlu IGlmIHRoZSBHUElPIGNoaXAgZnVuY3Rpb25zIHBvdGVudGlhbGx5IHNsZWVwLgogICovCiBpbnQg Z3Bpb2Rfc2V0X3Jhd19hcnJheV92YWx1ZSh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKLQkJCSBz dHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwgaW50ICp2YWx1ZV9hcnJheSkKKwkJCSBzdHJ1 Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCSB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRt YXApCiB7CiAJaWYgKCFkZXNjX2FycmF5KQogCQlyZXR1cm4gLUVJTlZBTDsKIAlyZXR1cm4gZ3Bp b2Rfc2V0X2FycmF5X3ZhbHVlX2NvbXBsZXgodHJ1ZSwgZmFsc2UsIGFycmF5X3NpemUsCi0JCQkJ CWRlc2NfYXJyYXksIHZhbHVlX2FycmF5KTsKKwkJCQkJZGVzY19hcnJheSwgdmFsdWVfYml0bWFw KTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdwaW9kX3NldF9yYXdfYXJyYXlfdmFsdWUpOwogCiAv KioKICAqIGdwaW9kX3NldF9hcnJheV92YWx1ZSgpIC0gYXNzaWduIHZhbHVlcyB0byBhbiBhcnJh eSBvZiBHUElPcwotICogQGFycmF5X3NpemU6IG51bWJlciBvZiBlbGVtZW50cyBpbiB0aGUgZGVz Y3JpcHRvciAvIHZhbHVlIGFycmF5cworICogQGFycmF5X3NpemU6IG51bWJlciBvZiBlbGVtZW50 cyBpbiB0aGUgZGVzY3JpcHRvciBhcnJheSAvIHZhbHVlIGJpdG1hcAogICogQGRlc2NfYXJyYXk6 IGFycmF5IG9mIEdQSU8gZGVzY3JpcHRvcnMgd2hvc2UgdmFsdWVzIHdpbGwgYmUgYXNzaWduZWQK LSAqIEB2YWx1ZV9hcnJheTogYXJyYXkgb2YgdmFsdWVzIHRvIGFzc2lnbgorICogQHZhbHVlX2Jp dG1hcDogYml0bWFwIG9mIHZhbHVlcyB0byBhc3NpZ24KICAqCiAgKiBTZXQgdGhlIGxvZ2ljYWwg dmFsdWVzIG9mIHRoZSBHUElPcywgaS5lLiB0YWtpbmcgdGhlaXIgQUNUSVZFX0xPVyBzdGF0dXMK ICAqIGludG8gYWNjb3VudC4KQEAgLTMxODUsMTIgKzMxODgsMTMgQEAgRVhQT1JUX1NZTUJPTF9H UEwoZ3Bpb2Rfc2V0X3Jhd19hcnJheV92YWx1ZSk7CiAgKiBjb21wbGFpbiBpZiB0aGUgR1BJTyBj aGlwIGZ1bmN0aW9ucyBwb3RlbnRpYWxseSBzbGVlcC4KICAqLwogdm9pZCBncGlvZF9zZXRfYXJy YXlfdmFsdWUodW5zaWduZWQgaW50IGFycmF5X3NpemUsCi0JCQkgICBzdHJ1Y3QgZ3Bpb19kZXNj ICoqZGVzY19hcnJheSwgaW50ICp2YWx1ZV9hcnJheSkKKwkJCSAgIHN0cnVjdCBncGlvX2Rlc2Mg KipkZXNjX2FycmF5LAorCQkJICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKQogewogCWlm ICghZGVzY19hcnJheSkKIAkJcmV0dXJuOwogCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jb21wbGV4 KGZhbHNlLCBmYWxzZSwgYXJyYXlfc2l6ZSwgZGVzY19hcnJheSwKLQkJCQkgICAgICB2YWx1ZV9h cnJheSk7CisJCQkJICAgICAgdmFsdWVfYml0bWFwKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGdw aW9kX3NldF9hcnJheV92YWx1ZSk7CiAKQEAgLTM0MTAsOSArMzQxNCw5IEBAIEVYUE9SVF9TWU1C T0xfR1BMKGdwaW9kX2dldF92YWx1ZV9jYW5zbGVlcCk7CiAKIC8qKgogICogZ3Bpb2RfZ2V0X3Jh d19hcnJheV92YWx1ZV9jYW5zbGVlcCgpIC0gcmVhZCByYXcgdmFsdWVzIGZyb20gYW4gYXJyYXkg b2YgR1BJT3MKLSAqIEBhcnJheV9zaXplOiBudW1iZXIgb2YgZWxlbWVudHMgaW4gdGhlIGRlc2Ny aXB0b3IgLyB2YWx1ZSBhcnJheXMKKyAqIEBhcnJheV9zaXplOiBudW1iZXIgb2YgZWxlbWVudHMg aW4gdGhlIGRlc2NyaXB0b3IgYXJyYXkgLyB2YWx1ZSBiaXRtYXAKICAqIEBkZXNjX2FycmF5OiBh cnJheSBvZiBHUElPIGRlc2NyaXB0b3JzIHdob3NlIHZhbHVlcyB3aWxsIGJlIHJlYWQKLSAqIEB2 YWx1ZV9hcnJheTogYXJyYXkgdG8gc3RvcmUgdGhlIHJlYWQgdmFsdWVzCisgKiBAdmFsdWVfYml0 bWFwOiBiaXRtYXAgdG8gc3RvcmUgdGhlIHJlYWQgdmFsdWVzCiAgKgogICogUmVhZCB0aGUgcmF3 IHZhbHVlcyBvZiB0aGUgR1BJT3MsIGkuZS4gdGhlIHZhbHVlcyBvZiB0aGUgcGh5c2ljYWwgbGlu ZXMKICAqIHdpdGhvdXQgcmVnYXJkIGZvciB0aGVpciBBQ1RJVkVfTE9XIHN0YXR1cy4gIFJldHVy biAwIGluIGNhc2Ugb2Ygc3VjY2VzcywKQEAgLTM0MjIsMjEgKzM0MjYsMjEgQEAgRVhQT1JUX1NZ TUJPTF9HUEwoZ3Bpb2RfZ2V0X3ZhbHVlX2NhbnNsZWVwKTsKICAqLwogaW50IGdwaW9kX2dldF9y YXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJICAg ICAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCSAgICAgICBpbnQgKnZhbHVl X2FycmF5KQorCQkJCSAgICAgICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiB7CiAJbWln aHRfc2xlZXBfaWYoZXh0cmFfY2hlY2tzKTsKIAlpZiAoIWRlc2NfYXJyYXkpCiAJCXJldHVybiAt RUlOVkFMOwogCXJldHVybiBncGlvZF9nZXRfYXJyYXlfdmFsdWVfY29tcGxleCh0cnVlLCB0cnVl LCBhcnJheV9zaXplLAotCQkJCQkgICAgIGRlc2NfYXJyYXksIHZhbHVlX2FycmF5KTsKKwkJCQkJ ICAgICBkZXNjX2FycmF5LCB2YWx1ZV9iaXRtYXApOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZ3Bp b2RfZ2V0X3Jhd19hcnJheV92YWx1ZV9jYW5zbGVlcCk7CiAKIC8qKgogICogZ3Bpb2RfZ2V0X2Fy cmF5X3ZhbHVlX2NhbnNsZWVwKCkgLSByZWFkIHZhbHVlcyBmcm9tIGFuIGFycmF5IG9mIEdQSU9z Ci0gKiBAYXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkZXNjcmlwdG9yIC8g dmFsdWUgYXJyYXlzCisgKiBAYXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBk ZXNjcmlwdG9yIGFycmF5IC8gdmFsdWUgYml0bWFwCiAgKiBAZGVzY19hcnJheTogYXJyYXkgb2Yg R1BJTyBkZXNjcmlwdG9ycyB3aG9zZSB2YWx1ZXMgd2lsbCBiZSByZWFkCi0gKiBAdmFsdWVfYXJy YXk6IGFycmF5IHRvIHN0b3JlIHRoZSByZWFkIHZhbHVlcworICogQHZhbHVlX2JpdG1hcDogYml0 bWFwIHRvIHN0b3JlIHRoZSByZWFkIHZhbHVlcwogICoKICAqIFJlYWQgdGhlIGxvZ2ljYWwgdmFs dWVzIG9mIHRoZSBHUElPcywgaS5lLiB0YWtpbmcgdGhlaXIgQUNUSVZFX0xPVyBzdGF0dXMKICAq IGludG8gYWNjb3VudC4gIFJldHVybiAwIGluIGNhc2Ugb2Ygc3VjY2VzcywgZWxzZSBhbiBlcnJv ciBjb2RlLgpAQCAtMzQ0NSwxMyArMzQ0OSwxMyBAQCBFWFBPUlRfU1lNQk9MX0dQTChncGlvZF9n ZXRfcmF3X2FycmF5X3ZhbHVlX2NhbnNsZWVwKTsKICAqLwogaW50IGdwaW9kX2dldF9hcnJheV92 YWx1ZV9jYW5zbGVlcCh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgICBzdHJ1Y3QgZ3Bp b19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkgICBpbnQgKnZhbHVlX2FycmF5KQorCQkJCSAgIHVu c2lnbmVkIGxvbmcgKnZhbHVlX2JpdG1hcCkKIHsKIAltaWdodF9zbGVlcF9pZihleHRyYV9jaGVj a3MpOwogCWlmICghZGVzY19hcnJheSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAJcmV0dXJuIGdwaW9k X2dldF9hcnJheV92YWx1ZV9jb21wbGV4KGZhbHNlLCB0cnVlLCBhcnJheV9zaXplLAotCQkJCQkg ICAgIGRlc2NfYXJyYXksIHZhbHVlX2FycmF5KTsKKwkJCQkJICAgICBkZXNjX2FycmF5LCB2YWx1 ZV9iaXRtYXApOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2Nh bnNsZWVwKTsKIApAQCAtMzQ5Myw5ICszNDk3LDkgQEAgRVhQT1JUX1NZTUJPTF9HUEwoZ3Bpb2Rf c2V0X3ZhbHVlX2NhbnNsZWVwKTsKIAogLyoqCiAgKiBncGlvZF9zZXRfcmF3X2FycmF5X3ZhbHVl X2NhbnNsZWVwKCkgLSBhc3NpZ24gdmFsdWVzIHRvIGFuIGFycmF5IG9mIEdQSU9zCi0gKiBAYXJy YXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkZXNjcmlwdG9yIC8gdmFsdWUgYXJy YXlzCisgKiBAYXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBkZXNjcmlwdG9y IGFycmF5IC8gdmFsdWUgYml0bWFwCiAgKiBAZGVzY19hcnJheTogYXJyYXkgb2YgR1BJTyBkZXNj cmlwdG9ycyB3aG9zZSB2YWx1ZXMgd2lsbCBiZSBhc3NpZ25lZAotICogQHZhbHVlX2FycmF5OiBh cnJheSBvZiB2YWx1ZXMgdG8gYXNzaWduCisgKiBAdmFsdWVfYml0bWFwOiBiaXRtYXAgb2YgdmFs dWVzIHRvIGFzc2lnbgogICoKICAqIFNldCB0aGUgcmF3IHZhbHVlcyBvZiB0aGUgR1BJT3MsIGku ZS4gdGhlIHZhbHVlcyBvZiB0aGUgcGh5c2ljYWwgbGluZXMKICAqIHdpdGhvdXQgcmVnYXJkIGZv ciB0aGVpciBBQ1RJVkVfTE9XIHN0YXR1cy4KQEAgLTM1MDQsMTMgKzM1MDgsMTMgQEAgRVhQT1JU X1NZTUJPTF9HUEwoZ3Bpb2Rfc2V0X3ZhbHVlX2NhbnNsZWVwKTsKICAqLwogaW50IGdwaW9kX3Nl dF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJ CXN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCQlpbnQgKnZhbHVlX2FycmF5KQor CQkJCQl1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApCiB7CiAJbWlnaHRfc2xlZXBfaWYoZXh0 cmFfY2hlY2tzKTsKIAlpZiAoIWRlc2NfYXJyYXkpCiAJCXJldHVybiAtRUlOVkFMOwogCXJldHVy biBncGlvZF9zZXRfYXJyYXlfdmFsdWVfY29tcGxleCh0cnVlLCB0cnVlLCBhcnJheV9zaXplLCBk ZXNjX2FycmF5LAotCQkJCSAgICAgIHZhbHVlX2FycmF5KTsKKwkJCQkgICAgICB2YWx1ZV9iaXRt YXApOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZ3Bpb2Rfc2V0X3Jhd19hcnJheV92YWx1ZV9jYW5z bGVlcCk7CiAKQEAgLTM1MzMsOSArMzUzNyw5IEBAIHZvaWQgZ3Bpb2RfYWRkX2xvb2t1cF90YWJs ZXMoc3RydWN0IGdwaW9kX2xvb2t1cF90YWJsZSAqKnRhYmxlcywgc2l6ZV90IG4pCiAKIC8qKgog ICogZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKCkgLSBhc3NpZ24gdmFsdWVzIHRvIGFu IGFycmF5IG9mIEdQSU9zCi0gKiBAYXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRo ZSBkZXNjcmlwdG9yIC8gdmFsdWUgYXJyYXlzCisgKiBAYXJyYXlfc2l6ZTogbnVtYmVyIG9mIGVs ZW1lbnRzIGluIHRoZSBkZXNjcmlwdG9yIGFycmF5IC8gdmFsdWUgYml0bWFwCiAgKiBAZGVzY19h cnJheTogYXJyYXkgb2YgR1BJTyBkZXNjcmlwdG9ycyB3aG9zZSB2YWx1ZXMgd2lsbCBiZSBhc3Np Z25lZAotICogQHZhbHVlX2FycmF5OiBhcnJheSBvZiB2YWx1ZXMgdG8gYXNzaWduCisgKiBAdmFs dWVfYml0bWFwOiBiaXRtYXAgb2YgdmFsdWVzIHRvIGFzc2lnbgogICoKICAqIFNldCB0aGUgbG9n aWNhbCB2YWx1ZXMgb2YgdGhlIEdQSU9zLCBpLmUuIHRha2luZyB0aGVpciBBQ1RJVkVfTE9XIHN0 YXR1cwogICogaW50byBhY2NvdW50LgpAQCAtMzU0NCwxMyArMzU0OCwxMyBAQCB2b2lkIGdwaW9k X2FkZF9sb29rdXBfdGFibGVzKHN0cnVjdCBncGlvZF9sb29rdXBfdGFibGUgKip0YWJsZXMsIHNp emVfdCBuKQogICovCiB2b2lkIGdwaW9kX3NldF9hcnJheV92YWx1ZV9jYW5zbGVlcCh1bnNpZ25l ZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgICAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXks Ci0JCQkJICAgIGludCAqdmFsdWVfYXJyYXkpCisJCQkJICAgIHVuc2lnbmVkIGxvbmcgKnZhbHVl X2JpdG1hcCkKIHsKIAltaWdodF9zbGVlcF9pZihleHRyYV9jaGVja3MpOwogCWlmICghZGVzY19h cnJheSkKIAkJcmV0dXJuOwogCWdwaW9kX3NldF9hcnJheV92YWx1ZV9jb21wbGV4KGZhbHNlLCB0 cnVlLCBhcnJheV9zaXplLCBkZXNjX2FycmF5LAotCQkJCSAgICAgIHZhbHVlX2FycmF5KTsKKwkJ CQkgICAgICB2YWx1ZV9iaXRtYXApOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoZ3Bpb2Rfc2V0X2Fy cmF5X3ZhbHVlX2NhbnNsZWVwKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncGlvL2dwaW9saWIu aCBiL2RyaXZlcnMvZ3Bpby9ncGlvbGliLmgKaW5kZXggYTdlNDlmZWY3M2Q0Li4xMWU4M2QyZWVm ODkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9ncGlvbGliLmgKKysrIGIvZHJpdmVycy9ncGlv L2dwaW9saWIuaApAQCAtMTg3LDExICsxODcsMTEgQEAgc3RydWN0IGdwaW9fZGVzYyAqZ3Bpb2No aXBfZ2V0X2Rlc2Moc3RydWN0IGdwaW9fY2hpcCAqY2hpcCwgdTE2IGh3bnVtKTsKIGludCBncGlv ZF9nZXRfYXJyYXlfdmFsdWVfY29tcGxleChib29sIHJhdywgYm9vbCBjYW5fc2xlZXAsCiAJCQkJ ICB1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNj X2FycmF5LAotCQkJCSAgaW50ICp2YWx1ZV9hcnJheSk7CisJCQkJICB1bnNpZ25lZCBsb25nICp2 YWx1ZV9iaXRtYXApOwogaW50IGdwaW9kX3NldF9hcnJheV92YWx1ZV9jb21wbGV4KGJvb2wgcmF3 LCBib29sIGNhbl9zbGVlcCwKIAkJCQkgICB1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKIAkJCQkg ICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKLQkJCQkgICBpbnQgKnZhbHVlX2FycmF5 KTsKKwkJCQkgICB1bnNpZ25lZCBsb25nICp2YWx1ZV9iaXRtYXApOwogCiAvKiBUaGlzIGlzIGp1 c3QgcGFzc2VkIGJldHdlZW4gZ3Bpb2xpYiBhbmQgZGV2cmVzICovCiBzdHJ1Y3QgZ3Bpb19kZXNj ICpncGlvZF9nZXRfZnJvbV9vZl9ub2RlKHN0cnVjdCBkZXZpY2Vfbm9kZSAqbm9kZSwKZGlmZiAt LWdpdCBhL2RyaXZlcnMvaTJjL211eGVzL2kyYy1tdXgtZ3Bpby5jIGIvZHJpdmVycy9pMmMvbXV4 ZXMvaTJjLW11eC1ncGlvLmMKaW5kZXggNDAxMzA4ZTNkMDM2Li4wNzE3Y2ZiNTY3MzIgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvaTJjL211eGVzL2kyYy1tdXgtZ3Bpby5jCisrKyBiL2RyaXZlcnMvaTJj L211eGVzL2kyYy1tdXgtZ3Bpby5jCkBAIC0yMiwxOCArMjIsMTUgQEAgc3RydWN0IGdwaW9tdXgg ewogCXN0cnVjdCBpMmNfbXV4X2dwaW9fcGxhdGZvcm1fZGF0YSBkYXRhOwogCXVuc2lnbmVkIGdw aW9fYmFzZTsKIAlzdHJ1Y3QgZ3Bpb19kZXNjICoqZ3Bpb3M7Ci0JaW50ICp2YWx1ZXM7CiB9Owog CiBzdGF0aWMgdm9pZCBpMmNfbXV4X2dwaW9fc2V0KGNvbnN0IHN0cnVjdCBncGlvbXV4ICptdXgs IHVuc2lnbmVkIHZhbCkKIHsKLQlpbnQgaTsKKwlERUNMQVJFX0JJVE1BUCh2YWx1ZXMsIEJJVFNf UEVSX1RZUEUodmFsKSk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgbXV4LT5kYXRhLm5fZ3Bpb3M7IGkr KykKLQkJbXV4LT52YWx1ZXNbaV0gPSAodmFsID4+IGkpICYgMTsKKwkqdmFsdWVzID0gdmFsOwog Ci0JZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKG11eC0+ZGF0YS5uX2dwaW9zLAotCQkJ CSAgICAgICBtdXgtPmdwaW9zLCBtdXgtPnZhbHVlcyk7CisJZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVl X2NhbnNsZWVwKG11eC0+ZGF0YS5uX2dwaW9zLCBtdXgtPmdwaW9zLCB2YWx1ZXMpOwogfQogCiBz dGF0aWMgaW50IGkyY19tdXhfZ3Bpb19zZWxlY3Qoc3RydWN0IGkyY19tdXhfY29yZSAqbXV4Yywg dTMyIGNoYW4pCkBAIC0xODIsMTUgKzE3OSwxMyBAQCBzdGF0aWMgaW50IGkyY19tdXhfZ3Bpb19w cm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCQlyZXR1cm4gLUVQUk9CRV9ERUZF UjsKIAogCW11eGMgPSBpMmNfbXV4X2FsbG9jKHBhcmVudCwgJnBkZXYtPmRldiwgbXV4LT5kYXRh Lm5fdmFsdWVzLAotCQkJICAgICBtdXgtPmRhdGEubl9ncGlvcyAqIHNpemVvZigqbXV4LT5ncGlv cykgKwotCQkJICAgICBtdXgtPmRhdGEubl9ncGlvcyAqIHNpemVvZigqbXV4LT52YWx1ZXMpLCAw LAorCQkJICAgICBtdXgtPmRhdGEubl9ncGlvcyAqIHNpemVvZigqbXV4LT5ncGlvcyksIDAsCiAJ CQkgICAgIGkyY19tdXhfZ3Bpb19zZWxlY3QsIE5VTEwpOwogCWlmICghbXV4YykgewogCQlyZXQg PSAtRU5PTUVNOwogCQlnb3RvIGFsbG9jX2ZhaWxlZDsKIAl9CiAJbXV4LT5ncGlvcyA9IG11eGMt PnByaXY7Ci0JbXV4LT52YWx1ZXMgPSAoaW50ICopKG11eC0+Z3Bpb3MgKyBtdXgtPmRhdGEubl9n cGlvcyk7CiAJbXV4Yy0+cHJpdiA9IG11eDsKIAogCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYs IG11eGMpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tbWMvY29yZS9wd3JzZXFfc2ltcGxlLmMgYi9k cml2ZXJzL21tYy9jb3JlL3B3cnNlcV9zaW1wbGUuYwppbmRleCBhOGI5ZmVlNGQ2MmEuLjVhZDc2 NGM4OGI1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvY29yZS9wd3JzZXFfc2ltcGxlLmMKKysr IGIvZHJpdmVycy9tbWMvY29yZS9wd3JzZXFfc2ltcGxlLmMKQEAgLTQwLDE4ICs0MCwxMyBAQCBz dGF0aWMgdm9pZCBtbWNfcHdyc2VxX3NpbXBsZV9zZXRfZ3Bpb3NfdmFsdWUoc3RydWN0IG1tY19w d3JzZXFfc2ltcGxlICpwd3JzZXEsCiAJc3RydWN0IGdwaW9fZGVzY3MgKnJlc2V0X2dwaW9zID0g cHdyc2VxLT5yZXNldF9ncGlvczsKIAogCWlmICghSVNfRVJSKHJlc2V0X2dwaW9zKSkgewotCQlp bnQgaSwgKnZhbHVlczsKKwkJREVDTEFSRV9CSVRNQVAodmFsdWVzLCBCSVRTX1BFUl9UWVBFKHZh bHVlKSk7CiAJCWludCBudmFsdWVzID0gcmVzZXRfZ3Bpb3MtPm5kZXNjczsKIAotCQl2YWx1ZXMg PSBrbWFsbG9jX2FycmF5KG52YWx1ZXMsIHNpemVvZihpbnQpLCBHRlBfS0VSTkVMKTsKLQkJaWYg KCF2YWx1ZXMpCi0JCQlyZXR1cm47CisJCSp2YWx1ZXMgPSB2YWx1ZTsKIAotCQlmb3IgKGkgPSAw OyBpIDwgbnZhbHVlczsgaSsrKQotCQkJdmFsdWVzW2ldID0gdmFsdWU7Ci0KLQkJZ3Bpb2Rfc2V0 X2FycmF5X3ZhbHVlX2NhbnNsZWVwKG52YWx1ZXMsIHJlc2V0X2dwaW9zLT5kZXNjLCB2YWx1ZXMp OwotCQlrZnJlZSh2YWx1ZXMpOworCQlncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAobnZh bHVlcywgcmVzZXRfZ3Bpb3MtPmRlc2MsCisJCQkJCSAgICAgICB2YWx1ZXMpOwogCX0KIH0KIApk aWZmIC0tZ2l0IGEvZHJpdmVycy9tdXgvZ3Bpby5jIGIvZHJpdmVycy9tdXgvZ3Bpby5jCmluZGV4 IDZmZGQ5MzE2ZGI4Yi4uMWI2YjRjYzIyYTJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL211eC9ncGlv LmMKKysrIGIvZHJpdmVycy9tdXgvZ3Bpby5jCkBAIC0xNywyMCArMTcsMTcgQEAKIAogc3RydWN0 IG11eF9ncGlvIHsKIAlzdHJ1Y3QgZ3Bpb19kZXNjcyAqZ3Bpb3M7Ci0JaW50ICp2YWw7CiB9Owog CiBzdGF0aWMgaW50IG11eF9ncGlvX3NldChzdHJ1Y3QgbXV4X2NvbnRyb2wgKm11eCwgaW50IHN0 YXRlKQogewogCXN0cnVjdCBtdXhfZ3BpbyAqbXV4X2dwaW8gPSBtdXhfY2hpcF9wcml2KG11eC0+ Y2hpcCk7Ci0JaW50IGk7CisJREVDTEFSRV9CSVRNQVAodmFsdWVzLCBCSVRTX1BFUl9UWVBFKHN0 YXRlKSk7CiAKLQlmb3IgKGkgPSAwOyBpIDwgbXV4X2dwaW8tPmdwaW9zLT5uZGVzY3M7IGkrKykK LQkJbXV4X2dwaW8tPnZhbFtpXSA9IChzdGF0ZSA+PiBpKSAmIDE7CisJKnZhbHVlcyA9IHN0YXRl OwogCiAJZ3Bpb2Rfc2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKG11eF9ncGlvLT5ncGlvcy0+bmRl c2NzLAotCQkJCSAgICAgICBtdXhfZ3Bpby0+Z3Bpb3MtPmRlc2MsCi0JCQkJICAgICAgIG11eF9n cGlvLT52YWwpOworCQkJCSAgICAgICBtdXhfZ3Bpby0+Z3Bpb3MtPmRlc2MsIHZhbHVlcyk7CiAK IAlyZXR1cm4gMDsKIH0KQEAgLTU4LDEzICs1NSwxMSBAQCBzdGF0aWMgaW50IG11eF9ncGlvX3By b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJaWYgKHBpbnMgPCAwKQogCQlyZXR1 cm4gcGluczsKIAotCW11eF9jaGlwID0gZGV2bV9tdXhfY2hpcF9hbGxvYyhkZXYsIDEsIHNpemVv ZigqbXV4X2dwaW8pICsKLQkJCQkgICAgICAgcGlucyAqIHNpemVvZigqbXV4X2dwaW8tPnZhbCkp OworCW11eF9jaGlwID0gZGV2bV9tdXhfY2hpcF9hbGxvYyhkZXYsIDEsIHNpemVvZigqbXV4X2dw aW8pKTsKIAlpZiAoSVNfRVJSKG11eF9jaGlwKSkKIAkJcmV0dXJuIFBUUl9FUlIobXV4X2NoaXAp OwogCiAJbXV4X2dwaW8gPSBtdXhfY2hpcF9wcml2KG11eF9jaGlwKTsKLQltdXhfZ3Bpby0+dmFs ID0gKGludCAqKShtdXhfZ3BpbyArIDEpOwogCW11eF9jaGlwLT5vcHMgPSAmbXV4X2dwaW9fb3Bz OwogCiAJbXV4X2dwaW8tPmdwaW9zID0gZGV2bV9ncGlvZF9nZXRfYXJyYXkoZGV2LCAibXV4Iiwg R1BJT0RfT1VUX0xPVyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9waHkvbWRpby1tdXgtZ3Bp by5jIGIvZHJpdmVycy9uZXQvcGh5L21kaW8tbXV4LWdwaW8uYwppbmRleCBiYzkwNzY0YThiOGQu LmViOGM1NmI4M2M3MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcGh5L21kaW8tbXV4LWdwaW8u YworKysgYi9kcml2ZXJzL25ldC9waHkvbWRpby1tdXgtZ3Bpby5jCkBAIC0yMCwyMyArMjAsMjEg QEAKIHN0cnVjdCBtZGlvX211eF9ncGlvX3N0YXRlIHsKIAlzdHJ1Y3QgZ3Bpb19kZXNjcyAqZ3Bp b3M7CiAJdm9pZCAqbXV4X2hhbmRsZTsKLQlpbnQgdmFsdWVzW107CiB9OwogCiBzdGF0aWMgaW50 IG1kaW9fbXV4X2dwaW9fc3dpdGNoX2ZuKGludCBjdXJyZW50X2NoaWxkLCBpbnQgZGVzaXJlZF9j aGlsZCwKIAkJCQkgICB2b2lkICpkYXRhKQogewogCXN0cnVjdCBtZGlvX211eF9ncGlvX3N0YXRl ICpzID0gZGF0YTsKLQl1bnNpZ25lZCBpbnQgbjsKKwlERUNMQVJFX0JJVE1BUCh2YWx1ZXMsIEJJ VFNfUEVSX1RZUEUoZGVzaXJlZF9jaGlsZCkpOwogCiAJaWYgKGN1cnJlbnRfY2hpbGQgPT0gZGVz aXJlZF9jaGlsZCkKIAkJcmV0dXJuIDA7CiAKLQlmb3IgKG4gPSAwOyBuIDwgcy0+Z3Bpb3MtPm5k ZXNjczsgbisrKQotCQlzLT52YWx1ZXNbbl0gPSAoZGVzaXJlZF9jaGlsZCA+PiBuKSAmIDE7CisJ KnZhbHVlcyA9IGRlc2lyZWRfY2hpbGQ7CiAKIAlncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xl ZXAocy0+Z3Bpb3MtPm5kZXNjcywgcy0+Z3Bpb3MtPmRlc2MsCi0JCQkJICAgICAgIHMtPnZhbHVl cyk7CisJCQkJICAgICAgIHZhbHVlcyk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTUxLDggKzQ5LDcg QEAgc3RhdGljIGludCBtZGlvX211eF9ncGlvX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ug KnBkZXYpCiAJaWYgKElTX0VSUihncGlvcykpCiAJCXJldHVybiBQVFJfRVJSKGdwaW9zKTsKIAot CXMgPSBkZXZtX2t6YWxsb2MoJnBkZXYtPmRldiwgc3RydWN0X3NpemUocywgdmFsdWVzLCBncGlv cy0+bmRlc2NzKSwKLQkJCSBHRlBfS0VSTkVMKTsKKwlzID0gZGV2bV9remFsbG9jKCZwZGV2LT5k ZXYsIHNpemVvZigqcyksIEdGUF9LRVJORUwpOwogCWlmICghcykgewogCQlncGlvZF9wdXRfYXJy YXkoZ3Bpb3MpOwogCQlyZXR1cm4gLUVOT01FTTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNtY2lh L3NvY19jb21tb24uYyBiL2RyaXZlcnMvcGNtY2lhL3NvY19jb21tb24uYwppbmRleCBjNWYyMzQ0 YzE4OWIuLjM4OGRiZGM0NjEyOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY21jaWEvc29jX2NvbW1v bi5jCisrKyBiL2RyaXZlcnMvcGNtY2lhL3NvY19jb21tb24uYwpAQCAtMzUxLDE1ICszNTEsMTcg QEAgc3RhdGljIGludCBzb2NfY29tbW9uX3BjbWNpYV9jb25maWdfc2t0KAogCiAJaWYgKHJldCA9 PSAwKSB7CiAJCXN0cnVjdCBncGlvX2Rlc2MgKmRlc2NzWzJdOwotCQlpbnQgdmFsdWVzWzJdLCBu ID0gMDsKKwkJREVDTEFSRV9CSVRNQVAodmFsdWVzLCAyKTsKKwkJaW50IG4gPSAwOwogCiAJCWlm IChza3QtPmdwaW9fcmVzZXQpIHsKIAkJCWRlc2NzW25dID0gc2t0LT5ncGlvX3Jlc2V0OwotCQkJ dmFsdWVzW24rK10gPSAhIShzdGF0ZS0+ZmxhZ3MgJiBTU19SRVNFVCk7CisJCQlfX2Fzc2lnbl9i aXQobisrLCB2YWx1ZXMsICEhKHN0YXRlLT5mbGFncyAmIFNTX1JFU0VUKSk7CiAJCX0KIAkJaWYg KHNrdC0+Z3Bpb19idXNfZW5hYmxlKSB7CiAJCQlkZXNjc1tuXSA9IHNrdC0+Z3Bpb19idXNfZW5h YmxlOwotCQkJdmFsdWVzW24rK10gPSAhIShzdGF0ZS0+ZmxhZ3MgJiBTU19PVVRQVVRfRU5BKTsK KwkJCV9fYXNzaWduX2JpdChuKyssIHZhbHVlcywKKwkJCQkgICAgICEhKHN0YXRlLT5mbGFncyAm IFNTX09VVFBVVF9FTkEpKTsKIAkJfQogCiAJCWlmIChuKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9w aHkvbW90b3JvbGEvcGh5LW1hcHBob25lLW1kbTY2MDAuYyBiL2RyaXZlcnMvcGh5L21vdG9yb2xh L3BoeS1tYXBwaG9uZS1tZG02NjAwLmMKaW5kZXggMDA3NWZiMGJlZjhjLi40ZGU3ZjQ1Nzc0MzMg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGh5L21vdG9yb2xhL3BoeS1tYXBwaG9uZS1tZG02NjAwLmMK KysrIGIvZHJpdmVycy9waHkvbW90b3JvbGEvcGh5LW1hcHBob25lLW1kbTY2MDAuYwpAQCAtMTU3 LDEyICsxNTcsOSBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHBoeV9vcHMgZ3Bpb191c2Jfb3BzID0g ewogICovCiBzdGF0aWMgdm9pZCBwaHlfbWRtNjYwMF9jbWQoc3RydWN0IHBoeV9tZG02NjAwICpk ZGF0YSwgaW50IHZhbCkKIHsKLQlpbnQgdmFsdWVzW1BIWV9NRE02NjAwX05SX0NNRF9MSU5FU107 Ci0JaW50IGk7CisJREVDTEFSRV9CSVRNQVAodmFsdWVzLCBQSFlfTURNNjYwMF9OUl9DTURfTElO RVMpOwogCi0JdmFsICY9ICgxIDw8IFBIWV9NRE02NjAwX05SX0NNRF9MSU5FUykgLSAxOwotCWZv ciAoaSA9IDA7IGkgPCBQSFlfTURNNjYwMF9OUl9DTURfTElORVM7IGkrKykKLQkJdmFsdWVzW2ld ID0gKHZhbCAmIEJJVChpKSkgPj4gaTsKKwkqdmFsdWVzID0gdmFsOwogCiAJZ3Bpb2Rfc2V0X2Fy cmF5X3ZhbHVlX2NhbnNsZWVwKFBIWV9NRE02NjAwX05SX0NNRF9MSU5FUywKIAkJCQkgICAgICAg ZGRhdGEtPmNtZF9ncGlvcy0+ZGVzYywgdmFsdWVzKTsKQEAgLTE3Niw3ICsxNzMsNyBAQCBzdGF0 aWMgdm9pZCBwaHlfbWRtNjYwMF9zdGF0dXMoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewog CXN0cnVjdCBwaHlfbWRtNjYwMCAqZGRhdGE7CiAJc3RydWN0IGRldmljZSAqZGV2OwotCWludCB2 YWx1ZXNbUEhZX01ETTY2MDBfTlJfU1RBVFVTX0xJTkVTXTsKKwlERUNMQVJFX0JJVE1BUCh2YWx1 ZXMsIFBIWV9NRE02NjAwX05SX1NUQVRVU19MSU5FUyk7CiAJaW50IGVycm9yLCBpLCB2YWwgPSAw OwogCiAJZGRhdGEgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IHBoeV9tZG02NjAwLCBzdGF0 dXNfd29yay53b3JrKTsKQEAgLTE4OSw5ICsxODYsOSBAQCBzdGF0aWMgdm9pZCBwaHlfbWRtNjYw MF9zdGF0dXMoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogCQlyZXR1cm47CiAKIAlmb3IgKGkg PSAwOyBpIDwgUEhZX01ETTY2MDBfTlJfU1RBVFVTX0xJTkVTOyBpKyspIHsKLQkJdmFsIHw9IHZh bHVlc1tpXSA8PCBpOworCQl2YWwgfD0gdGVzdF9iaXQoaSwgdmFsdWVzKSA8PCBpOwogCQlkZXZf ZGJnKGRkYXRhLT5kZXYsICJYWFggJXM6IGk6ICVpIHZhbHVlc1tpXTogJWkgdmFsOiAlaVxuIiwK LQkJCV9fZnVuY19fLCBpLCB2YWx1ZXNbaV0sIHZhbCk7CisJCQlfX2Z1bmNfXywgaSwgdGVzdF9i aXQoaSwgdmFsdWVzKSwgdmFsKTsKIAl9CiAJZGRhdGEtPnN0YXR1cyA9IHZhbDsKIApkaWZmIC0t Z2l0IGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NjA2LmMgYi9kcml2ZXJzL3N0YWdpbmcv aWlvL2FkYy9hZDc2MDYuYwppbmRleCAyNWI5ZmNkNWUzYTQuLjA1M2M5YjdmMTA4NCAxMDA2NDQK LS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9hZGMvYWQ3NjA2LmMKKysrIGIvZHJpdmVycy9zdGFn aW5nL2lpby9hZGMvYWQ3NjA2LmMKQEAgLTIwMiw3ICsyMDIsNyBAQCBzdGF0aWMgaW50IGFkNzYw Nl93cml0ZV9yYXcoc3RydWN0IGlpb19kZXYgKmluZGlvX2RldiwKIAkJCSAgICBsb25nIG1hc2sp CiB7CiAJc3RydWN0IGFkNzYwNl9zdGF0ZSAqc3QgPSBpaW9fcHJpdihpbmRpb19kZXYpOwotCWlu dCB2YWx1ZXNbM107CisJREVDTEFSRV9CSVRNQVAodmFsdWVzLCAzKTsKIAlpbnQgcmV0LCBpOwog CiAJc3dpdGNoIChtYXNrKSB7CkBAIC0yMjcsMTMgKzIyNywxMCBAQCBzdGF0aWMgaW50IGFkNzYw Nl93cml0ZV9yYXcoc3RydWN0IGlpb19kZXYgKmluZGlvX2RldiwKIAkJaWYgKHJldCA8IDApCiAJ CQlyZXR1cm4gcmV0OwogCi0JCXZhbHVlc1swXSA9IChyZXQgPj4gMCkgJiAxOwotCQl2YWx1ZXNb MV0gPSAocmV0ID4+IDEpICYgMTsKLQkJdmFsdWVzWzJdID0gKHJldCA+PiAyKSAmIDE7CisJCSp2 YWx1ZXMgPSByZXQ7CiAKIAkJbXV0ZXhfbG9jaygmc3QtPmxvY2spOwotCQlncGlvZF9zZXRfYXJy YXlfdmFsdWUoQVJSQVlfU0laRSh2YWx1ZXMpLCBzdC0+Z3Bpb19vcy0+ZGVzYywKLQkJCQkgICAg ICB2YWx1ZXMpOworCQlncGlvZF9zZXRfYXJyYXlfdmFsdWUoMywgc3QtPmdwaW9fb3MtPmRlc2Ms IHZhbHVlcyk7CiAJCXN0LT5vdmVyc2FtcGxpbmcgPSB2YWw7CiAJCW11dGV4X3VubG9jaygmc3Qt PmxvY2spOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX21jdHJsX2dw aW8uYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zZXJpYWxfbWN0cmxfZ3Bpby5jCmluZGV4IDFjMDYz MjViZWFjYS4uMzA0NDRmZDZjZjMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2Vy aWFsX21jdHJsX2dwaW8uYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX21jdHJsX2dw aW8uYwpAQCAtNDAsNyArNDAsNyBAQCB2b2lkIG1jdHJsX2dwaW9fc2V0KHN0cnVjdCBtY3RybF9n cGlvcyAqZ3Bpb3MsIHVuc2lnbmVkIGludCBtY3RybCkKIHsKIAllbnVtIG1jdHJsX2dwaW9faWR4 IGk7CiAJc3RydWN0IGdwaW9fZGVzYyAqZGVzY19hcnJheVtVQVJUX0dQSU9fTUFYXTsKLQlpbnQg dmFsdWVfYXJyYXlbVUFSVF9HUElPX01BWF07CisJREVDTEFSRV9CSVRNQVAodmFsdWVzLCBVQVJU X0dQSU9fTUFYKTsKIAl1bnNpZ25lZCBpbnQgY291bnQgPSAwOwogCiAJaWYgKGdwaW9zID09IE5V TEwpCkBAIC00OSwxMCArNDksMTEgQEAgdm9pZCBtY3RybF9ncGlvX3NldChzdHJ1Y3QgbWN0cmxf Z3Bpb3MgKmdwaW9zLCB1bnNpZ25lZCBpbnQgbWN0cmwpCiAJZm9yIChpID0gMDsgaSA8IFVBUlRf R1BJT19NQVg7IGkrKykKIAkJaWYgKGdwaW9zLT5ncGlvW2ldICYmIG1jdHJsX2dwaW9zX2Rlc2Nb aV0uZGlyX291dCkgewogCQkJZGVzY19hcnJheVtjb3VudF0gPSBncGlvcy0+Z3Bpb1tpXTsKLQkJ CXZhbHVlX2FycmF5W2NvdW50XSA9ICEhKG1jdHJsICYgbWN0cmxfZ3Bpb3NfZGVzY1tpXS5tY3Ry bCk7CisJCQlfX2Fzc2lnbl9iaXQoY291bnQsIHZhbHVlcywKKwkJCQkgICAgICEhKG1jdHJsICYg bWN0cmxfZ3Bpb3NfZGVzY1tpXS5tY3RybCkpOwogCQkJY291bnQrKzsKIAkJfQotCWdwaW9kX3Nl dF9hcnJheV92YWx1ZShjb3VudCwgZGVzY19hcnJheSwgdmFsdWVfYXJyYXkpOworCWdwaW9kX3Nl dF9hcnJheV92YWx1ZShjb3VudCwgZGVzY19hcnJheSwgdmFsdWVzKTsKIH0KIEVYUE9SVF9TWU1C T0xfR1BMKG1jdHJsX2dwaW9fc2V0KTsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9ncGlv L2NvbnN1bWVyLmggYi9pbmNsdWRlL2xpbnV4L2dwaW8vY29uc3VtZXIuaAppbmRleCAyMWRkYmU0 NDAwMzAuLjFiMjFkYzdiMGZhZCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9ncGlvL2NvbnN1 bWVyLmgKKysrIGIvaW5jbHVkZS9saW51eC9ncGlvL2NvbnN1bWVyLmgKQEAgLTEwNCwzNiArMTA0 LDM4IEBAIGludCBncGlvZF9kaXJlY3Rpb25fb3V0cHV0X3JhdyhzdHJ1Y3QgZ3Bpb19kZXNjICpk ZXNjLCBpbnQgdmFsdWUpOwogLyogVmFsdWUgZ2V0L3NldCBmcm9tIG5vbi1zbGVlcGluZyBjb250 ZXh0ICovCiBpbnQgZ3Bpb2RfZ2V0X3ZhbHVlKGNvbnN0IHN0cnVjdCBncGlvX2Rlc2MgKmRlc2Mp OwogaW50IGdwaW9kX2dldF9hcnJheV92YWx1ZSh1bnNpZ25lZCBpbnQgYXJyYXlfc2l6ZSwKLQkJ CSAgc3RydWN0IGdwaW9fZGVzYyAqKmRlc2NfYXJyYXksIGludCAqdmFsdWVfYXJyYXkpOworCQkJ ICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVzY19hcnJheSwKKwkJCSAgdW5zaWduZWQgbG9uZyAqdmFs dWVfYml0bWFwKTsKIHZvaWQgZ3Bpb2Rfc2V0X3ZhbHVlKHN0cnVjdCBncGlvX2Rlc2MgKmRlc2Ms IGludCB2YWx1ZSk7CiB2b2lkIGdwaW9kX3NldF9hcnJheV92YWx1ZSh1bnNpZ25lZCBpbnQgYXJy YXlfc2l6ZSwKLQkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LCBpbnQgKnZhbHVl X2FycmF5KTsKKwkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAorCQkJICAgdW5z aWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsKIGludCBncGlvZF9nZXRfcmF3X3ZhbHVlKGNvbnN0 IHN0cnVjdCBncGlvX2Rlc2MgKmRlc2MpOwogaW50IGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWUo dW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkgICAgICBzdHJ1Y3QgZ3Bpb19kZXNjICoqZGVz Y19hcnJheSwKLQkJCSAgICAgIGludCAqdmFsdWVfYXJyYXkpOworCQkJICAgICAgdW5zaWduZWQg bG9uZyAqdmFsdWVfYml0bWFwKTsKIHZvaWQgZ3Bpb2Rfc2V0X3Jhd192YWx1ZShzdHJ1Y3QgZ3Bp b19kZXNjICpkZXNjLCBpbnQgdmFsdWUpOwogaW50IGdwaW9kX3NldF9yYXdfYXJyYXlfdmFsdWUo dW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkgICAgICAgc3RydWN0IGdwaW9fZGVzYyAqKmRl c2NfYXJyYXksCi0JCQkgICAgICAgaW50ICp2YWx1ZV9hcnJheSk7CisJCQkgICAgICAgdW5zaWdu ZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsKIAogLyogVmFsdWUgZ2V0L3NldCBmcm9tIHNsZWVwaW5n IGNvbnRleHQgKi8KIGludCBncGlvZF9nZXRfdmFsdWVfY2Fuc2xlZXAoY29uc3Qgc3RydWN0IGdw aW9fZGVzYyAqZGVzYyk7CiBpbnQgZ3Bpb2RfZ2V0X2FycmF5X3ZhbHVlX2NhbnNsZWVwKHVuc2ln bmVkIGludCBhcnJheV9zaXplLAogCQkJCSAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5 LAotCQkJCSAgIGludCAqdmFsdWVfYXJyYXkpOworCQkJCSAgIHVuc2lnbmVkIGxvbmcgKnZhbHVl X2JpdG1hcCk7CiB2b2lkIGdwaW9kX3NldF92YWx1ZV9jYW5zbGVlcChzdHJ1Y3QgZ3Bpb19kZXNj ICpkZXNjLCBpbnQgdmFsdWUpOwogdm9pZCBncGlvZF9zZXRfYXJyYXlfdmFsdWVfY2Fuc2xlZXAo dW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJICAgIHN0cnVjdCBncGlvX2Rlc2MgKipkZXNj X2FycmF5LAotCQkJCSAgICBpbnQgKnZhbHVlX2FycmF5KTsKKwkJCQkgICAgdW5zaWduZWQgbG9u ZyAqdmFsdWVfYml0bWFwKTsKIGludCBncGlvZF9nZXRfcmF3X3ZhbHVlX2NhbnNsZWVwKGNvbnN0 IHN0cnVjdCBncGlvX2Rlc2MgKmRlc2MpOwogaW50IGdwaW9kX2dldF9yYXdfYXJyYXlfdmFsdWVf Y2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUsCiAJCQkJICAgICAgIHN0cnVjdCBncGlv X2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCSAgICAgICBpbnQgKnZhbHVlX2FycmF5KTsKKwkJCQkg ICAgICAgdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsKIHZvaWQgZ3Bpb2Rfc2V0X3Jhd192 YWx1ZV9jYW5zbGVlcChzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNjLCBpbnQgdmFsdWUpOwogaW50IGdw aW9kX3NldF9yYXdfYXJyYXlfdmFsdWVfY2Fuc2xlZXAodW5zaWduZWQgaW50IGFycmF5X3NpemUs CiAJCQkJCXN0cnVjdCBncGlvX2Rlc2MgKipkZXNjX2FycmF5LAotCQkJCQlpbnQgKnZhbHVlX2Fy cmF5KTsKKwkJCQkJdW5zaWduZWQgbG9uZyAqdmFsdWVfYml0bWFwKTsKIAogaW50IGdwaW9kX3Nl dF9kZWJvdW5jZShzdHJ1Y3QgZ3Bpb19kZXNjICpkZXNjLCB1bnNpZ25lZCBkZWJvdW5jZSk7CiBp bnQgZ3Bpb2Rfc2V0X3RyYW5zaXRvcnkoc3RydWN0IGdwaW9fZGVzYyAqZGVzYywgYm9vbCB0cmFu c2l0b3J5KTsKLS0gCjIuMTYuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KZGV2ZWwgbWFpbGluZyBsaXN0CmRldmVsQGxpbnV4ZHJpdmVycHJvamVjdC5v cmcKaHR0cDovL2RyaXZlcmRldi5saW51eGRyaXZlcnByb2plY3Qub3JnL21haWxtYW4vbGlzdGlu Zm8vZHJpdmVyZGV2LWRldmVsCg==