From mboxrd@z Thu Jan 1 00:00:00 1970 From: =?UTF-8?q?Andr=C3=A9=20Goddard=20Rosa?= Subject: [PATCH v4 12/12] tree-wide: convert open calls to remove spaces to skip_spaces() lib function Date: Sat, 7 Nov 2009 13:16:20 -0200 Message-ID: <7d5883637aa976b54e944998f635d47a41618a75.1257602781.git.andre.goddard@gmail.com> References: Reply-To: device-mapper development Mime-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: In-Reply-To: References: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com To: Martin Schwidefsky , Heiko Carstens , linux390@de.ibm.com, Michael Holzheu , Andrew Morton Cc: =?UTF-8?q?Andr=C3=A9=20Goddard=20Rosa?= List-Id: dm-devel.ids Makes use of skip_spaces() defined in lib/string.c for removing leading spaces from strings all over the tree. Also, while at it, if we see (*str && isspace(*str)), we can be sure to remove the first condition (*str) as the second one (isspace(*str)) also evaluates to 0 whenever *str =3D=3D 0, making it redundant. In other word= s, "a char equals zero is never a space". Signed-off-by: Andr=C3=A9 Goddard Rosa --- arch/s390/kernel/debug.c | 3 +- arch/um/drivers/mconsole_kern.c | 16 ++++++-------- arch/x86/kernel/cpu/mtrr/if.c | 11 +++------ drivers/md/dm-table.c | 6 +--- drivers/md/md.c | 4 +- drivers/parisc/pdc_stable.c | 9 ++----- drivers/platform/x86/thinkpad_acpi.c | 7 +---- drivers/pnp/interface.c | 36 +++++++++------------------= ----- drivers/s390/block/dasd_proc.c | 5 ++- drivers/video/backlight/lcd.c | 4 +- drivers/video/display/display-sysfs.c | 2 +- fs/cachefiles/daemon.c | 8 ++---- fs/ext4/super.c | 7 +---- kernel/params.c | 8 ++---- lib/argv_split.c | 13 ++--------- lib/dynamic_debug.c | 4 +- lib/vsprintf.c | 15 +++---------- net/irda/irnet/irnet.h | 1 + net/irda/irnet/irnet_ppp.c | 8 ++---- net/netfilter/xt_recent.c | 3 +- sound/pci/hda/hda_hwdep.c | 7 ++--- 21 files changed, 63 insertions(+), 114 deletions(-) diff --git a/arch/s390/kernel/debug.c b/arch/s390/kernel/debug.c index 20f282c..7a0f4a9 100644 --- a/arch/s390/kernel/debug.c +++ b/arch/s390/kernel/debug.c @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -1183,7 +1184,7 @@ debug_get_uint(char *buf) { int rc; =20 - for(; isspace(*buf); buf++); + buf =3D skip_spaces(buf); rc =3D simple_strtoul(buf, &buf, 10); if(*buf){ rc =3D -EINVAL; diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_k= ern.c index e14629c..f5d459a 100644 --- a/arch/um/drivers/mconsole_kern.c +++ b/arch/um/drivers/mconsole_kern.c @@ -6,6 +6,7 @@ =20 #include #include +#include #include #include #include @@ -131,7 +132,7 @@ void mconsole_proc(struct mc_request *req) char *ptr =3D req->request.data, *buf; =20 ptr +=3D strlen("proc"); - while (isspace(*ptr)) ptr++; + ptr =3D skip_spaces(ptr); =20 proc =3D get_fs_type("proc"); if (proc =3D=3D NULL) { @@ -212,8 +213,7 @@ void mconsole_proc(struct mc_request *req) char *ptr =3D req->request.data; =20 ptr +=3D strlen("proc"); - while (isspace(*ptr)) - ptr++; + ptr =3D skip_spaces(ptr); snprintf(path, sizeof(path), "/proc/%s", ptr); =20 fd =3D sys_open(path, 0, 0); @@ -560,8 +560,7 @@ void mconsole_config(struct mc_request *req) int err; =20 ptr +=3D strlen("config"); - while (isspace(*ptr)) - ptr++; + ptr =3D skip_spaces(ptr); dev =3D mconsole_find_dev(ptr); if (dev =3D=3D NULL) { mconsole_reply(req, "Bad configuration option", 1, 0); @@ -588,7 +587,7 @@ void mconsole_remove(struct mc_request *req) int err, start, end, n; =20 ptr +=3D strlen("remove"); - while (isspace(*ptr)) ptr++; + ptr =3D skip_spaces(ptr); dev =3D mconsole_find_dev(ptr); if (dev =3D=3D NULL) { mconsole_reply(req, "Bad remove option", 1, 0); @@ -712,7 +711,7 @@ void mconsole_sysrq(struct mc_request *req) char *ptr =3D req->request.data; =20 ptr +=3D strlen("sysrq"); - while (isspace(*ptr)) ptr++; + ptr =3D skip_spaces(ptr); =20 /* * With 'b', the system will shut down without a chance to reply, @@ -757,8 +756,7 @@ void mconsole_stack(struct mc_request *req) */ =20 ptr +=3D strlen("stack"); - while (isspace(*ptr)) - ptr++; + ptr =3D skip_spaces(ptr); =20 /* * Should really check for multiple pids or reject bad args here diff --git a/arch/x86/kernel/cpu/mtrr/if.c b/arch/x86/kernel/cpu/mtrr/if.= c index 3c1b12d..e006e56 100644 --- a/arch/x86/kernel/cpu/mtrr/if.c +++ b/arch/x86/kernel/cpu/mtrr/if.c @@ -4,6 +4,7 @@ #include #include #include +#include #include =20 #define LINE_SIZE 80 @@ -133,8 +134,7 @@ mtrr_write(struct file *file, const char __user *buf,= size_t len, loff_t * ppos) return -EINVAL; =20 base =3D simple_strtoull(line + 5, &ptr, 0); - while (isspace(*ptr)) - ptr++; + ptr =3D skip_spaces(ptr); =20 if (strncmp(ptr, "size=3D", 5)) return -EINVAL; @@ -142,14 +142,11 @@ mtrr_write(struct file *file, const char __user *bu= f, size_t len, loff_t * ppos) size =3D simple_strtoull(ptr + 5, &ptr, 0); if ((base & 0xfff) || (size & 0xfff)) return -EINVAL; - while (isspace(*ptr)) - ptr++; + ptr =3D skip_spaces(ptr); =20 if (strncmp(ptr, "type=3D", 5)) return -EINVAL; - ptr +=3D 5; - while (isspace(*ptr)) - ptr++; + ptr =3D skip_spaces(ptr + 5); =20 for (i =3D 0; i < MTRR_NUM_TYPES; ++i) { if (strcmp(ptr, mtrr_strings[i])) diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c index 1a6cb3c..91976e8 100644 --- a/drivers/md/dm-table.c +++ b/drivers/md/dm-table.c @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -600,11 +601,8 @@ int dm_split_args(int *argc, char ***argvp, char *in= put) return -ENOMEM; =20 while (1) { - start =3D end; - /* Skip whitespace */ - while (*start && isspace(*start)) - start++; + start =3D skip_spaces(end); =20 if (!*start) break; /* success, we hit the end */ diff --git a/drivers/md/md.c b/drivers/md/md.c index 26ba42a..1dcb83c 100644 --- a/drivers/md/md.c +++ b/drivers/md/md.c @@ -39,6 +39,7 @@ #include /* for invalidate_bdev */ #include #include +#include #include #include #include @@ -3225,8 +3226,7 @@ bitmap_store(mddev_t *mddev, const char *buf, size_= t len) } if (*end && !isspace(*end)) break; bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk); - buf =3D end; - while (isspace(*buf)) buf++; + buf =3D skip_spaces(end); } bitmap_unplug(mddev->bitmap); /* flush the bits to disk */ out: diff --git a/drivers/parisc/pdc_stable.c b/drivers/parisc/pdc_stable.c index 13a64bc..0bc5d47 100644 --- a/drivers/parisc/pdc_stable.c +++ b/drivers/parisc/pdc_stable.c @@ -779,12 +779,9 @@ static ssize_t pdcs_auto_write(struct kobject *kobj, read_unlock(&pathentry->rw_lock); =09 DPRINTK("%s: flags before: 0x%X\n", __func__, flags); - =09 - temp =3D in; -=09 - while (*temp && isspace(*temp)) - temp++; -=09 + + temp =3D skip_spaces(in); + c =3D *temp++ - '0'; if ((c !=3D 0) && (c !=3D 1)) goto parse_error; diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/= thinkpad_acpi.c index 7e7da18..29dd2dd 100644 --- a/drivers/platform/x86/thinkpad_acpi.c +++ b/drivers/platform/x86/thinkpad_acpi.c @@ -1006,11 +1006,8 @@ static int parse_strtoul(const char *buf, { char *endp; =20 - while (*buf && isspace(*buf)) - buf++; - *value =3D simple_strtoul(buf, &endp, 0); - while (*endp && isspace(*endp)) - endp++; + *value =3D simple_strtoul(skip_spaces(buf), &endp, 0); + endp =3D skip_spaces(endp); if (*endp || *value > max) return -EINVAL; =20 diff --git a/drivers/pnp/interface.c b/drivers/pnp/interface.c index c3f1c8e..68b0c04 100644 --- a/drivers/pnp/interface.c +++ b/drivers/pnp/interface.c @@ -310,8 +310,7 @@ static ssize_t pnp_set_current_resources(struct devic= e *dmdev, goto done; } =20 - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf); if (!strnicmp(buf, "disable", 7)) { retval =3D pnp_disable_dev(dev); goto done; @@ -353,19 +352,13 @@ static ssize_t pnp_set_current_resources(struct dev= ice *dmdev, pnp_init_resources(dev); mutex_lock(&pnp_res_mutex); while (1) { - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf); if (!strnicmp(buf, "io", 2)) { - buf +=3D 2; - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf + 2); start =3D simple_strtoul(buf, &buf, 0); - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf); if (*buf =3D=3D '-') { - buf +=3D 1; - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf + 1); end =3D simple_strtoul(buf, &buf, 0); } else end =3D start; @@ -373,16 +366,11 @@ static ssize_t pnp_set_current_resources(struct dev= ice *dmdev, continue; } if (!strnicmp(buf, "mem", 3)) { - buf +=3D 3; - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf + 3); start =3D simple_strtoul(buf, &buf, 0); - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf); if (*buf =3D=3D '-') { - buf +=3D 1; - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf + 1); end =3D simple_strtoul(buf, &buf, 0); } else end =3D start; @@ -390,17 +378,13 @@ static ssize_t pnp_set_current_resources(struct dev= ice *dmdev, continue; } if (!strnicmp(buf, "irq", 3)) { - buf +=3D 3; - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf + 3); start =3D simple_strtoul(buf, &buf, 0); pnp_add_irq_resource(dev, start, 0); continue; } if (!strnicmp(buf, "dma", 3)) { - buf +=3D 3; - while (isspace(*buf)) - ++buf; + buf =3D skip_spaces(buf + 3); start =3D simple_strtoul(buf, &buf, 0); pnp_add_dma_resource(dev, start, 0); continue; diff --git a/drivers/s390/block/dasd_proc.c b/drivers/s390/block/dasd_pro= c.c index 654daa3..c2d8792 100644 --- a/drivers/s390/block/dasd_proc.c +++ b/drivers/s390/block/dasd_proc.c @@ -14,6 +14,7 @@ #define KMSG_COMPONENT "dasd" =20 #include +#include #include #include #include @@ -272,10 +273,10 @@ dasd_statistics_write(struct file *file, const char= __user *user_buf, DBF_EVENT(DBF_DEBUG, "/proc/dasd/statictics: '%s'\n", buffer); =20 /* check for valid verbs */ - for (str =3D buffer; isspace(*str); str++); + str =3D skip_spaces(buffer); if (strncmp(str, "set", 3) =3D=3D 0 && isspace(str[3])) { /* 'set xxx' was given */ - for (str =3D str + 4; isspace(*str); str++); + str =3D skip_spaces(str + 4); if (strcmp(str, "on") =3D=3D 0) { /* switch on statistics profiling */ dasd_profile_level =3D DASD_PROFILE_ON; diff --git a/drivers/video/backlight/lcd.c b/drivers/video/backlight/lcd.= c index b644947..3b20cbf 100644 --- a/drivers/video/backlight/lcd.c +++ b/drivers/video/backlight/lcd.c @@ -101,7 +101,7 @@ static ssize_t lcd_store_power(struct device *dev, int power =3D simple_strtoul(buf, &endp, 0); size_t size =3D endp - buf; =20 - if (*endp && isspace(*endp)) + if (isspace(*endp)) size++; if (size !=3D count) return -EINVAL; @@ -140,7 +140,7 @@ static ssize_t lcd_store_contrast(struct device *dev, int contrast =3D simple_strtoul(buf, &endp, 0); size_t size =3D endp - buf; =20 - if (*endp && isspace(*endp)) + if (isspace(*endp)) size++; if (size !=3D count) return -EINVAL; diff --git a/drivers/video/display/display-sysfs.c b/drivers/video/displa= y/display-sysfs.c index 4830b1b..80abbf3 100644 --- a/drivers/video/display/display-sysfs.c +++ b/drivers/video/display/display-sysfs.c @@ -67,7 +67,7 @@ static ssize_t display_store_contrast(struct device *de= v, contrast =3D simple_strtoul(buf, &endp, 0); size =3D endp - buf; =20 - if (*endp && isspace(*endp)) + if (isspace(*endp)) size++; =20 if (size !=3D count) diff --git a/fs/cachefiles/daemon.c b/fs/cachefiles/daemon.c index 4618516..af6d9a6 100644 --- a/fs/cachefiles/daemon.c +++ b/fs/cachefiles/daemon.c @@ -21,6 +21,7 @@ #include #include #include +#include #include #include "internal.h" =20 @@ -250,15 +251,12 @@ static ssize_t cachefiles_daemon_write(struct file = *file, /* parse the command */ ret =3D -EOPNOTSUPP; =20 - for (args =3D data; *args; args++) - if (isspace(*args)) - break; + args =3D skip_spaces(data); if (*args) { if (args =3D=3D data) goto error; *args =3D '\0'; - for (args++; isspace(*args); args++) - continue; + args =3D skip_spaces(++args); } =20 /* run the appropriate command handler */ diff --git a/fs/ext4/super.c b/fs/ext4/super.c index 312211e..580766a 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -2097,11 +2097,8 @@ static int parse_strtoul(const char *buf, { char *endp; =20 - while (*buf && isspace(*buf)) - buf++; - *value =3D simple_strtoul(buf, &endp, 0); - while (*endp && isspace(*endp)) - endp++; + *value =3D simple_strtoul(skip_spaces(buf), &endp, 0); + endp =3D skip_spaces(endp); if (*endp || *value > max) return -EINVAL; =20 diff --git a/kernel/params.c b/kernel/params.c index d656c27..cf1b691 100644 --- a/kernel/params.c +++ b/kernel/params.c @@ -24,6 +24,7 @@ #include #include #include +#include =20 #if 0 #define DEBUGP printk @@ -122,9 +123,7 @@ static char *next_arg(char *args, char **param, char = **val) next =3D args + i; =20 /* Chew up trailing spaces. */ - while (isspace(*next)) - next++; - return next; + return skip_spaces(next); } =20 /* Args looks like "foo=3Dbar,bar2 baz=3Dfuz wiz". */ @@ -139,8 +138,7 @@ int parse_args(const char *name, DEBUGP("Parsing ARGS: %s\n", args); =20 /* Chew leading spaces */ - while (isspace(*args)) - args++; + args =3D skip_spaces(args); =20 while (*args) { int ret; diff --git a/lib/argv_split.c b/lib/argv_split.c index 5205a8d..4b1b083 100644 --- a/lib/argv_split.c +++ b/lib/argv_split.c @@ -4,17 +4,10 @@ =20 #include #include +#include #include #include =20 -static const char *skip_sep(const char *cp) -{ - while (*cp && isspace(*cp)) - cp++; - - return cp; -} - static const char *skip_arg(const char *cp) { while (*cp && !isspace(*cp)) @@ -28,7 +21,7 @@ static int count_argc(const char *str) int count =3D 0; =20 while (*str) { - str =3D skip_sep(str); + str =3D skip_spaces(str); if (*str) { count++; str =3D skip_arg(str); @@ -82,7 +75,7 @@ char **argv_split(gfp_t gfp, const char *str, int *argc= p) argvp =3D argv; =20 while (*str) { - str =3D skip_sep(str); + str =3D skip_spaces(str); =20 if (*str) { const char *p =3D str; diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c index e22c148..f935029 100644 --- a/lib/dynamic_debug.c +++ b/lib/dynamic_debug.c @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -209,8 +210,7 @@ static int ddebug_tokenize(char *buf, char *words[], = int maxwords) char *end; =20 /* Skip leading whitespace */ - while (*buf && isspace(*buf)) - buf++; + buf =3D skip_spaces(buf); if (!*buf) break; /* oh, it was trailing whitespace */ =20 diff --git a/lib/vsprintf.c b/lib/vsprintf.c index 7ec96a3..06e0311 100644 --- a/lib/vsprintf.c +++ b/lib/vsprintf.c @@ -1716,13 +1716,6 @@ EXPORT_SYMBOL_GPL(bprintf); =20 #endif /* CONFIG_BINARY_PRINTF */ =20 -static noinline const char *skip_space(const char *str) -{ - while (isspace(*str)) - ++str; - return str; -} - /** * vsscanf - Unformat a buffer into a list of arguments * @buf: input buffer @@ -1744,8 +1737,8 @@ int vsscanf(const char *buf, const char *fmt, va_li= st args) * white space, including none, in the input. */ if (isspace(*fmt)) { - fmt =3D skip_space(fmt); - str =3D skip_space(str); + fmt =3D skip_spaces(++fmt); + str =3D skip_spaces(str); } =20 /* anything that is not a conversion must match exactly */ @@ -1815,7 +1808,7 @@ int vsscanf(const char *buf, const char *fmt, va_li= st args) if (field_width =3D=3D -1) field_width =3D INT_MAX; /* first, skip leading white space in buffer */ - str =3D skip_space(str); + str =3D skip_spaces(str); =20 /* now copy until next white space */ while (*str && !isspace(*str) && field_width--) @@ -1857,7 +1850,7 @@ int vsscanf(const char *buf, const char *fmt, va_li= st args) /* have some sort of integer conversion. * first, skip white space in buffer. */ - str =3D skip_space(str); + str =3D skip_spaces(str); =20 digit =3D *str; if (is_sign && digit =3D=3D '-') diff --git a/net/irda/irnet/irnet.h b/net/irda/irnet/irnet.h index b001c36..4300df3 100644 --- a/net/irda/irnet/irnet.h +++ b/net/irda/irnet/irnet.h @@ -249,6 +249,7 @@ #include #include #include /* isspace() */ +#include /* skip_spaces() */ #include #include =20 diff --git a/net/irda/irnet/irnet_ppp.c b/net/irda/irnet/irnet_ppp.c index 7dea882..156020d 100644 --- a/net/irda/irnet/irnet_ppp.c +++ b/net/irda/irnet/irnet_ppp.c @@ -76,9 +76,8 @@ irnet_ctrl_write(irnet_socket * ap, /* Look at the next command */ start =3D next; =20 - /* Scrap whitespaces before the command */ - while(isspace(*start)) - start++; + /* Scrap whitespaces before the command */ + start =3D skip_spaces(start); =20 /* ',' is our command separator */ next =3D strchr(start, ','); @@ -133,8 +132,7 @@ irnet_ctrl_write(irnet_socket * ap, char * endp; =20 /* Scrap whitespaces before the command */ - while(isspace(*begp)) - begp++; + begp =3D skip_spaces(begp); =20 /* Convert argument to a number (last arg is the base) */ addr =3D simple_strtoul(begp, &endp, 16); diff --git a/net/netfilter/xt_recent.c b/net/netfilter/xt_recent.c index eb0ceb8..fc70a49 100644 --- a/net/netfilter/xt_recent.c +++ b/net/netfilter/xt_recent.c @@ -482,8 +482,7 @@ static ssize_t recent_old_proc_write(struct file *fil= e, if (copy_from_user(buf, input, size)) return -EFAULT; =20 - while (isspace(*c)) - c++; + c =3D skip_spaces(c); =20 if (size - (c - buf) < 5) return c - buf; diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c index cc24e67..4e17b43 100644 --- a/sound/pci/hda/hda_hwdep.c +++ b/sound/pci/hda/hda_hwdep.c @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include "hda_codec.h" @@ -390,8 +391,7 @@ static int parse_hints(struct hda_codec *codec, const= char *buf) char *key, *val; struct hda_hint *hint; =20 - while (isspace(*buf)) - buf++; + buf =3D skip_spaces(buf); if (!*buf || *buf =3D=3D '#' || *buf =3D=3D '\n') return 0; if (*buf =3D=3D '=3D') @@ -406,8 +406,7 @@ static int parse_hints(struct hda_codec *codec, const= char *buf) return -EINVAL; } *val++ =3D 0; - while (isspace(*val)) - val++; + val =3D skip_spaces(val); remove_trail_spaces(key); remove_trail_spaces(val); hint =3D get_hint(codec, key); --=20 1.6.5.2.153.g6e31f.dirty From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: =?UTF-8?q?Andr=C3=A9=20Goddard=20Rosa?= Date: Sat, 7 Nov 2009 13:16:20 -0200 Message-Id: <7d5883637aa976b54e944998f635d47a41618a75.1257602781.git.andre.goddard@gmail.com> In-Reply-To: References: In-Reply-To: References: MIME-Version: 1.0 Subject: [uml-devel] [PATCH v4 12/12] tree-wide: convert open calls to remove spaces to skip_spaces() lib function List-Id: The user-mode Linux development list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: user-mode-linux-devel-bounces@lists.sourceforge.net To: Martin Schwidefsky , Heiko Carstens , linux390@de.ibm.com, Michael Holzheu , Andrew Morton , Stoyan Gaydarov , Julia Lawall , Jeff Dike , James Morris , WANG Cong , Pekka Enberg , David Howells , Thomas Gleixner , Ingo Molnar , "H . Peter Anvin" , x86@kernel.org, Alexey Dobriyan , Joe Perches , Alan Cox , Arjan van de Ven , Neil Brown , Alasdair G Kergon , Mike Snitzer , Mikulas Patocka , Jens Axboe , "Martin K . Petersen" , Andre Noll , Kyle McMartin , Helge Deller , "James E . J . Bottomley" , Roel Kluin , Henrique de Moraes Holschuh , Len Brown , Adam Belay , Bjorn Helgaas , Stefan Haberland , Stefan Weinhuber , Richard Purdie , Andrea Righi , Greg Kroah-Hartman , Pavel Roskin , Andrey Borzenkov , Steve Dickson , Trond Myklebust , Daire Byrne , Al Viro , Theodore Ts'o , Andreas Dilger , Eric Sandeen , Jan Kara , Rusty Russell , Takashi Iwai , Frederic Weisbecker , Sitsofe Wheeler , Christof Schmitt , Greg Banks , Jason Baron , "David S . Miller" , Steven Rostedt , Samuel Ortiz , Patrick McHardy , Jan Engelhardt , Roman Hoog Antink , Jaroslav Kysela , linux-s390@vger.kernel.org, linux-kernel@vger.kernel.org, user-mode-linux-devel@lists.sourceforge.net, user-mode-linux-user@lists.sourceforge.net, dm-devel@redhat.com, linux-raid@vger.kernel.org, linux-parisc@vger.kernel.org, ibm-acpi-devel@lists.sourceforge.net, linux-cachefs@redhat.com, linux-ext4@vger.kernel.org, netdev@vger.kernel.org, netfilter-devel@vger.kernel.org, netfilter@vger.kernel.org, coreteam@netfilter.org, alsa-devel@alsa-project.org Cc: =?UTF-8?q?Andr=C3=A9=20Goddard=20Rosa?= TWFrZXMgdXNlIG9mIHNraXBfc3BhY2VzKCkgZGVmaW5lZCBpbiBsaWIvc3RyaW5nLmMgZm9yIHJl bW92aW5nIGxlYWRpbmcKc3BhY2VzIGZyb20gc3RyaW5ncyBhbGwgb3ZlciB0aGUgdHJlZS4KCkFs c28sIHdoaWxlIGF0IGl0LCBpZiB3ZSBzZWUgKCpzdHIgJiYgaXNzcGFjZSgqc3RyKSksIHdlIGNh biBiZSBzdXJlIHRvCnJlbW92ZSB0aGUgZmlyc3QgY29uZGl0aW9uICgqc3RyKSBhcyB0aGUgc2Vj b25kIG9uZSAoaXNzcGFjZSgqc3RyKSkgYWxzbwpldmFsdWF0ZXMgdG8gMCB3aGVuZXZlciAqc3Ry ID09IDAsIG1ha2luZyBpdCByZWR1bmRhbnQuIEluIG90aGVyIHdvcmRzLAoiYSBjaGFyIGVxdWFs cyB6ZXJvIGlzIG5ldmVyIGEgc3BhY2UiLgoKU2lnbmVkLW9mZi1ieTogQW5kcsOpIEdvZGRhcmQg Um9zYSA8YW5kcmUuZ29kZGFyZEBnbWFpbC5jb20+Ci0tLQogYXJjaC9zMzkwL2tlcm5lbC9kZWJ1 Zy5jICAgICAgICAgICAgICB8ICAgIDMgKy0KIGFyY2gvdW0vZHJpdmVycy9tY29uc29sZV9rZXJu LmMgICAgICAgfCAgIDE2ICsrKysrKy0tLS0tLS0tCiBhcmNoL3g4Ni9rZXJuZWwvY3B1L210cnIv aWYuYyAgICAgICAgIHwgICAxMSArKystLS0tLS0KIGRyaXZlcnMvbWQvZG0tdGFibGUuYyAgICAg ICAgICAgICAgICAgfCAgICA2ICstLS0KIGRyaXZlcnMvbWQvbWQuYyAgICAgICAgICAgICAgICAg ICAgICAgfCAgICA0ICstCiBkcml2ZXJzL3BhcmlzYy9wZGNfc3RhYmxlLmMgICAgICAgICAgIHwg ICAgOSArKy0tLS0tCiBkcml2ZXJzL3BsYXRmb3JtL3g4Ni90aGlua3BhZF9hY3BpLmMgIHwgICAg NyArLS0tLQogZHJpdmVycy9wbnAvaW50ZXJmYWNlLmMgICAgICAgICAgICAgICB8ICAgMzYgKysr KysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvczM5MC9ibG9jay9kYXNkX3By b2MuYyAgICAgICAgfCAgICA1ICsrLQogZHJpdmVycy92aWRlby9iYWNrbGlnaHQvbGNkLmMgICAg ICAgICB8ICAgIDQgKy0KIGRyaXZlcnMvdmlkZW8vZGlzcGxheS9kaXNwbGF5LXN5c2ZzLmMgfCAg ICAyICstCiBmcy9jYWNoZWZpbGVzL2RhZW1vbi5jICAgICAgICAgICAgICAgIHwgICAgOCArKy0t LS0KIGZzL2V4dDQvc3VwZXIuYyAgICAgICAgICAgICAgICAgICAgICAgfCAgICA3ICstLS0tCiBr ZXJuZWwvcGFyYW1zLmMgICAgICAgICAgICAgICAgICAgICAgIHwgICAgOCArKy0tLS0KIGxpYi9h cmd2X3NwbGl0LmMgICAgICAgICAgICAgICAgICAgICAgfCAgIDEzICsrLS0tLS0tLS0tCiBsaWIv ZHluYW1pY19kZWJ1Zy5jICAgICAgICAgICAgICAgICAgIHwgICAgNCArLQogbGliL3ZzcHJpbnRm LmMgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMTUgKysrLS0tLS0tLS0tLQogbmV0L2lyZGEv aXJuZXQvaXJuZXQuaCAgICAgICAgICAgICAgICB8ICAgIDEgKwogbmV0L2lyZGEvaXJuZXQvaXJu ZXRfcHBwLmMgICAgICAgICAgICB8ICAgIDggKystLS0tCiBuZXQvbmV0ZmlsdGVyL3h0X3JlY2Vu dC5jICAgICAgICAgICAgIHwgICAgMyArLQogc291bmQvcGNpL2hkYS9oZGFfaHdkZXAuYyAgICAg ICAgICAgICB8ICAgIDcgKystLS0KIDIxIGZpbGVzIGNoYW5nZWQsIDYzIGluc2VydGlvbnMoKyks IDExNCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAva2VybmVsL2RlYnVnLmMg Yi9hcmNoL3MzOTAva2VybmVsL2RlYnVnLmMKaW5kZXggMjBmMjgyYy4uN2EwZjRhOSAxMDA2NDQK LS0tIGEvYXJjaC9zMzkwL2tlcm5lbC9kZWJ1Zy5jCisrKyBiL2FyY2gvczM5MC9rZXJuZWwvZGVi dWcuYwpAQCAtMTgsNiArMTgsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiAjaW5jbHVk ZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+CisjaW5jbHVkZSA8bGlu dXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvc3lzY3RsLmg+CiAjaW5jbHVkZSA8YXNtL3Vh Y2Nlc3MuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KQEAgLTExODMsNyArMTE4NCw3IEBA IGRlYnVnX2dldF91aW50KGNoYXIgKmJ1ZikKIHsKIAlpbnQgcmM7CiAKLQlmb3IoOyBpc3NwYWNl KCpidWYpOyBidWYrKyk7CisJYnVmID0gc2tpcF9zcGFjZXMoYnVmKTsKIAlyYyA9IHNpbXBsZV9z dHJ0b3VsKGJ1ZiwgJmJ1ZiwgMTApOwogCWlmKCpidWYpewogCQlyYyA9IC1FSU5WQUw7CmRpZmYg LS1naXQgYS9hcmNoL3VtL2RyaXZlcnMvbWNvbnNvbGVfa2Vybi5jIGIvYXJjaC91bS9kcml2ZXJz L21jb25zb2xlX2tlcm4uYwppbmRleCBlMTQ2MjljLi5mNWQ0NTlhIDEwMDY0NAotLS0gYS9hcmNo L3VtL2RyaXZlcnMvbWNvbnNvbGVfa2Vybi5jCisrKyBiL2FyY2gvdW0vZHJpdmVycy9tY29uc29s ZV9rZXJuLmMKQEAgLTYsNiArNiw3IEBACiAKICNpbmNsdWRlIDxsaW51eC9jb25zb2xlLmg+CiAj aW5jbHVkZSA8bGludXgvY3R5cGUuaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNpbmNs dWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9saXN0Lmg+CiAjaW5jbHVk ZSA8bGludXgvbW0uaD4KQEAgLTEzMSw3ICsxMzIsNyBAQCB2b2lkIG1jb25zb2xlX3Byb2Moc3Ry dWN0IG1jX3JlcXVlc3QgKnJlcSkKIAljaGFyICpwdHIgPSByZXEtPnJlcXVlc3QuZGF0YSwgKmJ1 ZjsKIAogCXB0ciArPSBzdHJsZW4oInByb2MiKTsKLQl3aGlsZSAoaXNzcGFjZSgqcHRyKSkgcHRy Kys7CisJcHRyID0gc2tpcF9zcGFjZXMocHRyKTsKIAogCXByb2MgPSBnZXRfZnNfdHlwZSgicHJv YyIpOwogCWlmIChwcm9jID09IE5VTEwpIHsKQEAgLTIxMiw4ICsyMTMsNyBAQCB2b2lkIG1jb25z b2xlX3Byb2Moc3RydWN0IG1jX3JlcXVlc3QgKnJlcSkKIAljaGFyICpwdHIgPSByZXEtPnJlcXVl c3QuZGF0YTsKIAogCXB0ciArPSBzdHJsZW4oInByb2MiKTsKLQl3aGlsZSAoaXNzcGFjZSgqcHRy KSkKLQkJcHRyKys7CisJcHRyID0gc2tpcF9zcGFjZXMocHRyKTsKIAlzbnByaW50ZihwYXRoLCBz aXplb2YocGF0aCksICIvcHJvYy8lcyIsIHB0cik7CiAKIAlmZCA9IHN5c19vcGVuKHBhdGgsIDAs IDApOwpAQCAtNTYwLDggKzU2MCw3IEBAIHZvaWQgbWNvbnNvbGVfY29uZmlnKHN0cnVjdCBtY19y ZXF1ZXN0ICpyZXEpCiAJaW50IGVycjsKIAogCXB0ciArPSBzdHJsZW4oImNvbmZpZyIpOwotCXdo aWxlIChpc3NwYWNlKCpwdHIpKQotCQlwdHIrKzsKKwlwdHIgPSBza2lwX3NwYWNlcyhwdHIpOwog CWRldiA9IG1jb25zb2xlX2ZpbmRfZGV2KHB0cik7CiAJaWYgKGRldiA9PSBOVUxMKSB7CiAJCW1j b25zb2xlX3JlcGx5KHJlcSwgIkJhZCBjb25maWd1cmF0aW9uIG9wdGlvbiIsIDEsIDApOwpAQCAt NTg4LDcgKzU4Nyw3IEBAIHZvaWQgbWNvbnNvbGVfcmVtb3ZlKHN0cnVjdCBtY19yZXF1ZXN0ICpy ZXEpCiAJaW50IGVyciwgc3RhcnQsIGVuZCwgbjsKIAogCXB0ciArPSBzdHJsZW4oInJlbW92ZSIp OwotCXdoaWxlIChpc3NwYWNlKCpwdHIpKSBwdHIrKzsKKwlwdHIgPSBza2lwX3NwYWNlcyhwdHIp OwogCWRldiA9IG1jb25zb2xlX2ZpbmRfZGV2KHB0cik7CiAJaWYgKGRldiA9PSBOVUxMKSB7CiAJ CW1jb25zb2xlX3JlcGx5KHJlcSwgIkJhZCByZW1vdmUgb3B0aW9uIiwgMSwgMCk7CkBAIC03MTIs NyArNzExLDcgQEAgdm9pZCBtY29uc29sZV9zeXNycShzdHJ1Y3QgbWNfcmVxdWVzdCAqcmVxKQog CWNoYXIgKnB0ciA9IHJlcS0+cmVxdWVzdC5kYXRhOwogCiAJcHRyICs9IHN0cmxlbigic3lzcnEi KTsKLQl3aGlsZSAoaXNzcGFjZSgqcHRyKSkgcHRyKys7CisJcHRyID0gc2tpcF9zcGFjZXMocHRy KTsKIAogCS8qCiAJICogV2l0aCAnYicsIHRoZSBzeXN0ZW0gd2lsbCBzaHV0IGRvd24gd2l0aG91 dCBhIGNoYW5jZSB0byByZXBseSwKQEAgLTc1Nyw4ICs3NTYsNyBAQCB2b2lkIG1jb25zb2xlX3N0 YWNrKHN0cnVjdCBtY19yZXF1ZXN0ICpyZXEpCiAJICovCiAKIAlwdHIgKz0gc3RybGVuKCJzdGFj ayIpOwotCXdoaWxlIChpc3NwYWNlKCpwdHIpKQotCQlwdHIrKzsKKwlwdHIgPSBza2lwX3NwYWNl cyhwdHIpOwogCiAJLyoKIAkgKiBTaG91bGQgcmVhbGx5IGNoZWNrIGZvciBtdWx0aXBsZSBwaWRz IG9yIHJlamVjdCBiYWQgYXJncyBoZXJlCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvY3B1 L210cnIvaWYuYyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvbXRyci9pZi5jCmluZGV4IDNjMWIxMmQu LmUwMDZlNTYgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9jcHUvbXRyci9pZi5jCisrKyBi L2FyY2gveDg2L2tlcm5lbC9jcHUvbXRyci9pZi5jCkBAIC00LDYgKzQsNyBAQAogI2luY2x1ZGUg PGxpbnV4L3Byb2NfZnMuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxs aW51eC9jdHlwZS5oPgorI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUgPGxpbnV4 L2luaXQuaD4KIAogI2RlZmluZSBMSU5FX1NJWkUgODAKQEAgLTEzMyw4ICsxMzQsNyBAQCBtdHJy X3dyaXRlKHN0cnVjdCBmaWxlICpmaWxlLCBjb25zdCBjaGFyIF9fdXNlciAqYnVmLCBzaXplX3Qg bGVuLCBsb2ZmX3QgKiBwcG9zKQogCQlyZXR1cm4gLUVJTlZBTDsKIAogCWJhc2UgPSBzaW1wbGVf c3RydG91bGwobGluZSArIDUsICZwdHIsIDApOwotCXdoaWxlIChpc3NwYWNlKCpwdHIpKQotCQlw dHIrKzsKKwlwdHIgPSBza2lwX3NwYWNlcyhwdHIpOwogCiAJaWYgKHN0cm5jbXAocHRyLCAic2l6 ZT0iLCA1KSkKIAkJcmV0dXJuIC1FSU5WQUw7CkBAIC0xNDIsMTQgKzE0MiwxMSBAQCBtdHJyX3dy aXRlKHN0cnVjdCBmaWxlICpmaWxlLCBjb25zdCBjaGFyIF9fdXNlciAqYnVmLCBzaXplX3QgbGVu LCBsb2ZmX3QgKiBwcG9zKQogCXNpemUgPSBzaW1wbGVfc3RydG91bGwocHRyICsgNSwgJnB0ciwg MCk7CiAJaWYgKChiYXNlICYgMHhmZmYpIHx8IChzaXplICYgMHhmZmYpKQogCQlyZXR1cm4gLUVJ TlZBTDsKLQl3aGlsZSAoaXNzcGFjZSgqcHRyKSkKLQkJcHRyKys7CisJcHRyID0gc2tpcF9zcGFj ZXMocHRyKTsKIAogCWlmIChzdHJuY21wKHB0ciwgInR5cGU9IiwgNSkpCiAJCXJldHVybiAtRUlO VkFMOwotCXB0ciArPSA1OwotCXdoaWxlIChpc3NwYWNlKCpwdHIpKQotCQlwdHIrKzsKKwlwdHIg PSBza2lwX3NwYWNlcyhwdHIgKyA1KTsKIAogCWZvciAoaSA9IDA7IGkgPCBNVFJSX05VTV9UWVBF UzsgKytpKSB7CiAJCWlmIChzdHJjbXAocHRyLCBtdHJyX3N0cmluZ3NbaV0pKQpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9tZC9kbS10YWJsZS5jIGIvZHJpdmVycy9tZC9kbS10YWJsZS5jCmluZGV4IDFh NmNiM2MuLjkxOTc2ZTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tdGFibGUuYworKysgYi9k cml2ZXJzL21kL2RtLXRhYmxlLmMKQEAgLTEyLDYgKzEyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9i bGtkZXYuaD4KICNpbmNsdWRlIDxsaW51eC9uYW1laS5oPgogI2luY2x1ZGUgPGxpbnV4L2N0eXBl Lmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgog I2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CkBA IC02MDAsMTEgKzYwMSw4IEBAIGludCBkbV9zcGxpdF9hcmdzKGludCAqYXJnYywgY2hhciAqKiph cmd2cCwgY2hhciAqaW5wdXQpCiAJCXJldHVybiAtRU5PTUVNOwogCiAJd2hpbGUgKDEpIHsKLQkJ c3RhcnQgPSBlbmQ7Ci0KIAkJLyogU2tpcCB3aGl0ZXNwYWNlICovCi0JCXdoaWxlICgqc3RhcnQg JiYgaXNzcGFjZSgqc3RhcnQpKQotCQkJc3RhcnQrKzsKKwkJc3RhcnQgPSBza2lwX3NwYWNlcyhl bmQpOwogCiAJCWlmICghKnN0YXJ0KQogCQkJYnJlYWs7CS8qIHN1Y2Nlc3MsIHdlIGhpdCB0aGUg ZW5kICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL21kLmMgYi9kcml2ZXJzL21kL21kLmMKaW5k ZXggMjZiYTQyYS4uMWRjYjgzYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9tZC5jCisrKyBiL2Ry aXZlcnMvbWQvbWQuYwpAQCAtMzksNiArMzksNyBAQAogI2luY2x1ZGUgPGxpbnV4L2J1ZmZlcl9o ZWFkLmg+IC8qIGZvciBpbnZhbGlkYXRlX2JkZXYgKi8KICNpbmNsdWRlIDxsaW51eC9wb2xsLmg+ CiAjaW5jbHVkZSA8bGludXgvY3R5cGUuaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNp bmNsdWRlIDxsaW51eC9oZHJlZy5oPgogI2luY2x1ZGUgPGxpbnV4L3Byb2NfZnMuaD4KICNpbmNs dWRlIDxsaW51eC9yYW5kb20uaD4KQEAgLTMyMjUsOCArMzIyNiw3IEBAIGJpdG1hcF9zdG9yZSht ZGRldl90ICptZGRldiwgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgbGVuKQogCQl9CiAJCWlmICgq ZW5kICYmICFpc3NwYWNlKCplbmQpKSBicmVhazsKIAkJYml0bWFwX2RpcnR5X2JpdHMobWRkZXYt PmJpdG1hcCwgY2h1bmssIGVuZF9jaHVuayk7Ci0JCWJ1ZiA9IGVuZDsKLQkJd2hpbGUgKGlzc3Bh Y2UoKmJ1ZikpIGJ1ZisrOworCQlidWYgPSBza2lwX3NwYWNlcyhlbmQpOwogCX0KIAliaXRtYXBf dW5wbHVnKG1kZGV2LT5iaXRtYXApOyAvKiBmbHVzaCB0aGUgYml0cyB0byBkaXNrICovCiBvdXQ6 CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BhcmlzYy9wZGNfc3RhYmxlLmMgYi9kcml2ZXJzL3Bhcmlz Yy9wZGNfc3RhYmxlLmMKaW5kZXggMTNhNjRiYy4uMGJjNWQ0NyAxMDA2NDQKLS0tIGEvZHJpdmVy cy9wYXJpc2MvcGRjX3N0YWJsZS5jCisrKyBiL2RyaXZlcnMvcGFyaXNjL3BkY19zdGFibGUuYwpA QCAtNzc5LDEyICs3NzksOSBAQCBzdGF0aWMgc3NpemVfdCBwZGNzX2F1dG9fd3JpdGUoc3RydWN0 IGtvYmplY3QgKmtvYmosCiAJcmVhZF91bmxvY2soJnBhdGhlbnRyeS0+cndfbG9jayk7CiAJCiAJ RFBSSU5USygiJXM6IGZsYWdzIGJlZm9yZTogMHglWFxuIiwgX19mdW5jX18sIGZsYWdzKTsKLQkJ CQotCXRlbXAgPSBpbjsKLQkKLQl3aGlsZSAoKnRlbXAgJiYgaXNzcGFjZSgqdGVtcCkpCi0JCXRl bXArKzsKLQkKKworCXRlbXAgPSBza2lwX3NwYWNlcyhpbik7CisKIAljID0gKnRlbXArKyAtICcw JzsKIAlpZiAoKGMgIT0gMCkgJiYgKGMgIT0gMSkpCiAJCWdvdG8gcGFyc2VfZXJyb3I7CmRpZmYg LS1naXQgYS9kcml2ZXJzL3BsYXRmb3JtL3g4Ni90aGlua3BhZF9hY3BpLmMgYi9kcml2ZXJzL3Bs YXRmb3JtL3g4Ni90aGlua3BhZF9hY3BpLmMKaW5kZXggN2U3ZGExOC4uMjlkZDJkZCAxMDA2NDQK LS0tIGEvZHJpdmVycy9wbGF0Zm9ybS94ODYvdGhpbmtwYWRfYWNwaS5jCisrKyBiL2RyaXZlcnMv cGxhdGZvcm0veDg2L3RoaW5rcGFkX2FjcGkuYwpAQCAtMTAwNiwxMSArMTAwNiw4IEBAIHN0YXRp YyBpbnQgcGFyc2Vfc3RydG91bChjb25zdCBjaGFyICpidWYsCiB7CiAJY2hhciAqZW5kcDsKIAot CXdoaWxlICgqYnVmICYmIGlzc3BhY2UoKmJ1ZikpCi0JCWJ1ZisrOwotCSp2YWx1ZSA9IHNpbXBs ZV9zdHJ0b3VsKGJ1ZiwgJmVuZHAsIDApOwotCXdoaWxlICgqZW5kcCAmJiBpc3NwYWNlKCplbmRw KSkKLQkJZW5kcCsrOworCSp2YWx1ZSA9IHNpbXBsZV9zdHJ0b3VsKHNraXBfc3BhY2VzKGJ1Ziks ICZlbmRwLCAwKTsKKwllbmRwID0gc2tpcF9zcGFjZXMoZW5kcCk7CiAJaWYgKCplbmRwIHx8ICp2 YWx1ZSA+IG1heCkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcG5w L2ludGVyZmFjZS5jIGIvZHJpdmVycy9wbnAvaW50ZXJmYWNlLmMKaW5kZXggYzNmMWM4ZS4uNjhi MGMwNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wbnAvaW50ZXJmYWNlLmMKKysrIGIvZHJpdmVycy9w bnAvaW50ZXJmYWNlLmMKQEAgLTMxMCw4ICszMTAsNyBAQCBzdGF0aWMgc3NpemVfdCBwbnBfc2V0 X2N1cnJlbnRfcmVzb3VyY2VzKHN0cnVjdCBkZXZpY2UgKmRtZGV2LAogCQlnb3RvIGRvbmU7CiAJ fQogCi0Jd2hpbGUgKGlzc3BhY2UoKmJ1ZikpCi0JCSsrYnVmOworCWJ1ZiA9IHNraXBfc3BhY2Vz KGJ1Zik7CiAJaWYgKCFzdHJuaWNtcChidWYsICJkaXNhYmxlIiwgNykpIHsKIAkJcmV0dmFsID0g cG5wX2Rpc2FibGVfZGV2KGRldik7CiAJCWdvdG8gZG9uZTsKQEAgLTM1MywxOSArMzUyLDEzIEBA IHN0YXRpYyBzc2l6ZV90IHBucF9zZXRfY3VycmVudF9yZXNvdXJjZXMoc3RydWN0IGRldmljZSAq ZG1kZXYsCiAJCXBucF9pbml0X3Jlc291cmNlcyhkZXYpOwogCQltdXRleF9sb2NrKCZwbnBfcmVz X211dGV4KTsKIAkJd2hpbGUgKDEpIHsKLQkJCXdoaWxlIChpc3NwYWNlKCpidWYpKQotCQkJCSsr YnVmOworCQkJYnVmID0gc2tpcF9zcGFjZXMoYnVmKTsKIAkJCWlmICghc3RybmljbXAoYnVmLCAi aW8iLCAyKSkgewotCQkJCWJ1ZiArPSAyOwotCQkJCXdoaWxlIChpc3NwYWNlKCpidWYpKQotCQkJ CQkrK2J1ZjsKKwkJCQlidWYgPSBza2lwX3NwYWNlcyhidWYgKyAyKTsKIAkJCQlzdGFydCA9IHNp bXBsZV9zdHJ0b3VsKGJ1ZiwgJmJ1ZiwgMCk7Ci0JCQkJd2hpbGUgKGlzc3BhY2UoKmJ1ZikpCi0J CQkJCSsrYnVmOworCQkJCWJ1ZiA9IHNraXBfc3BhY2VzKGJ1Zik7CiAJCQkJaWYgKCpidWYgPT0g Jy0nKSB7Ci0JCQkJCWJ1ZiArPSAxOwotCQkJCQl3aGlsZSAoaXNzcGFjZSgqYnVmKSkKLQkJCQkJ CSsrYnVmOworCQkJCQlidWYgPSBza2lwX3NwYWNlcyhidWYgKyAxKTsKIAkJCQkJZW5kID0gc2lt cGxlX3N0cnRvdWwoYnVmLCAmYnVmLCAwKTsKIAkJCQl9IGVsc2UKIAkJCQkJZW5kID0gc3RhcnQ7 CkBAIC0zNzMsMTYgKzM2NiwxMSBAQCBzdGF0aWMgc3NpemVfdCBwbnBfc2V0X2N1cnJlbnRfcmVz b3VyY2VzKHN0cnVjdCBkZXZpY2UgKmRtZGV2LAogCQkJCWNvbnRpbnVlOwogCQkJfQogCQkJaWYg KCFzdHJuaWNtcChidWYsICJtZW0iLCAzKSkgewotCQkJCWJ1ZiArPSAzOwotCQkJCXdoaWxlIChp c3NwYWNlKCpidWYpKQotCQkJCQkrK2J1ZjsKKwkJCQlidWYgPSBza2lwX3NwYWNlcyhidWYgKyAz KTsKIAkJCQlzdGFydCA9IHNpbXBsZV9zdHJ0b3VsKGJ1ZiwgJmJ1ZiwgMCk7Ci0JCQkJd2hpbGUg KGlzc3BhY2UoKmJ1ZikpCi0JCQkJCSsrYnVmOworCQkJCWJ1ZiA9IHNraXBfc3BhY2VzKGJ1Zik7 CiAJCQkJaWYgKCpidWYgPT0gJy0nKSB7Ci0JCQkJCWJ1ZiArPSAxOwotCQkJCQl3aGlsZSAoaXNz cGFjZSgqYnVmKSkKLQkJCQkJCSsrYnVmOworCQkJCQlidWYgPSBza2lwX3NwYWNlcyhidWYgKyAx KTsKIAkJCQkJZW5kID0gc2ltcGxlX3N0cnRvdWwoYnVmLCAmYnVmLCAwKTsKIAkJCQl9IGVsc2UK IAkJCQkJZW5kID0gc3RhcnQ7CkBAIC0zOTAsMTcgKzM3OCwxMyBAQCBzdGF0aWMgc3NpemVfdCBw bnBfc2V0X2N1cnJlbnRfcmVzb3VyY2VzKHN0cnVjdCBkZXZpY2UgKmRtZGV2LAogCQkJCWNvbnRp bnVlOwogCQkJfQogCQkJaWYgKCFzdHJuaWNtcChidWYsICJpcnEiLCAzKSkgewotCQkJCWJ1ZiAr PSAzOwotCQkJCXdoaWxlIChpc3NwYWNlKCpidWYpKQotCQkJCQkrK2J1ZjsKKwkJCQlidWYgPSBz a2lwX3NwYWNlcyhidWYgKyAzKTsKIAkJCQlzdGFydCA9IHNpbXBsZV9zdHJ0b3VsKGJ1ZiwgJmJ1 ZiwgMCk7CiAJCQkJcG5wX2FkZF9pcnFfcmVzb3VyY2UoZGV2LCBzdGFydCwgMCk7CiAJCQkJY29u dGludWU7CiAJCQl9CiAJCQlpZiAoIXN0cm5pY21wKGJ1ZiwgImRtYSIsIDMpKSB7Ci0JCQkJYnVm ICs9IDM7Ci0JCQkJd2hpbGUgKGlzc3BhY2UoKmJ1ZikpCi0JCQkJCSsrYnVmOworCQkJCWJ1ZiA9 IHNraXBfc3BhY2VzKGJ1ZiArIDMpOwogCQkJCXN0YXJ0ID0gc2ltcGxlX3N0cnRvdWwoYnVmLCAm YnVmLCAwKTsKIAkJCQlwbnBfYWRkX2RtYV9yZXNvdXJjZShkZXYsIHN0YXJ0LCAwKTsKIAkJCQlj b250aW51ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX3Byb2MuYyBiL2Ry aXZlcnMvczM5MC9ibG9jay9kYXNkX3Byb2MuYwppbmRleCA2NTRkYWEzLi5jMmQ4NzkyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZF9wcm9jLmMKKysrIGIvZHJpdmVycy9zMzkw L2Jsb2NrL2Rhc2RfcHJvYy5jCkBAIC0xNCw2ICsxNCw3IEBACiAjZGVmaW5lIEtNU0dfQ09NUE9O RU5UICJkYXNkIgogCiAjaW5jbHVkZSA8bGludXgvY3R5cGUuaD4KKyNpbmNsdWRlIDxsaW51eC9z dHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3Zt YWxsb2MuaD4KICNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+CkBAIC0yNzIsMTAgKzI3MywxMCBA QCBkYXNkX3N0YXRpc3RpY3Nfd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsIGNvbnN0IGNoYXIgX191 c2VyICp1c2VyX2J1ZiwKIAlEQkZfRVZFTlQoREJGX0RFQlVHLCAiL3Byb2MvZGFzZC9zdGF0aWN0 aWNzOiAnJXMnXG4iLCBidWZmZXIpOwogCiAJLyogY2hlY2sgZm9yIHZhbGlkIHZlcmJzICovCi0J Zm9yIChzdHIgPSBidWZmZXI7IGlzc3BhY2UoKnN0cik7IHN0cisrKTsKKwlzdHIgPSBza2lwX3Nw YWNlcyhidWZmZXIpOwogCWlmIChzdHJuY21wKHN0ciwgInNldCIsIDMpID09IDAgJiYgaXNzcGFj ZShzdHJbM10pKSB7CiAJCS8qICdzZXQgeHh4JyB3YXMgZ2l2ZW4gKi8KLQkJZm9yIChzdHIgPSBz dHIgKyA0OyBpc3NwYWNlKCpzdHIpOyBzdHIrKyk7CisJCXN0ciA9IHNraXBfc3BhY2VzKHN0ciAr IDQpOwogCQlpZiAoc3RyY21wKHN0ciwgIm9uIikgPT0gMCkgewogCQkJLyogc3dpdGNoIG9uIHN0 YXRpc3RpY3MgcHJvZmlsaW5nICovCiAJCQlkYXNkX3Byb2ZpbGVfbGV2ZWwgPSBEQVNEX1BST0ZJ TEVfT047CmRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpZGVvL2JhY2tsaWdodC9sY2QuYyBiL2RyaXZl cnMvdmlkZW8vYmFja2xpZ2h0L2xjZC5jCmluZGV4IGI2NDQ5NDcuLjNiMjBjYmYgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvdmlkZW8vYmFja2xpZ2h0L2xjZC5jCisrKyBiL2RyaXZlcnMvdmlkZW8vYmFj a2xpZ2h0L2xjZC5jCkBAIC0xMDEsNyArMTAxLDcgQEAgc3RhdGljIHNzaXplX3QgbGNkX3N0b3Jl X3Bvd2VyKHN0cnVjdCBkZXZpY2UgKmRldiwKIAlpbnQgcG93ZXIgPSBzaW1wbGVfc3RydG91bChi dWYsICZlbmRwLCAwKTsKIAlzaXplX3Qgc2l6ZSA9IGVuZHAgLSBidWY7CiAKLQlpZiAoKmVuZHAg JiYgaXNzcGFjZSgqZW5kcCkpCisJaWYgKGlzc3BhY2UoKmVuZHApKQogCQlzaXplKys7CiAJaWYg KHNpemUgIT0gY291bnQpCiAJCXJldHVybiAtRUlOVkFMOwpAQCAtMTQwLDcgKzE0MCw3IEBAIHN0 YXRpYyBzc2l6ZV90IGxjZF9zdG9yZV9jb250cmFzdChzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJaW50 IGNvbnRyYXN0ID0gc2ltcGxlX3N0cnRvdWwoYnVmLCAmZW5kcCwgMCk7CiAJc2l6ZV90IHNpemUg PSBlbmRwIC0gYnVmOwogCi0JaWYgKCplbmRwICYmIGlzc3BhY2UoKmVuZHApKQorCWlmIChpc3Nw YWNlKCplbmRwKSkKIAkJc2l6ZSsrOwogCWlmIChzaXplICE9IGNvdW50KQogCQlyZXR1cm4gLUVJ TlZBTDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmlkZW8vZGlzcGxheS9kaXNwbGF5LXN5c2ZzLmMg Yi9kcml2ZXJzL3ZpZGVvL2Rpc3BsYXkvZGlzcGxheS1zeXNmcy5jCmluZGV4IDQ4MzBiMWIuLjgw YWJiZjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdmlkZW8vZGlzcGxheS9kaXNwbGF5LXN5c2ZzLmMK KysrIGIvZHJpdmVycy92aWRlby9kaXNwbGF5L2Rpc3BsYXktc3lzZnMuYwpAQCAtNjcsNyArNjcs NyBAQCBzdGF0aWMgc3NpemVfdCBkaXNwbGF5X3N0b3JlX2NvbnRyYXN0KHN0cnVjdCBkZXZpY2Ug KmRldiwKIAljb250cmFzdCA9IHNpbXBsZV9zdHJ0b3VsKGJ1ZiwgJmVuZHAsIDApOwogCXNpemUg PSBlbmRwIC0gYnVmOwogCi0JaWYgKCplbmRwICYmIGlzc3BhY2UoKmVuZHApKQorCWlmIChpc3Nw YWNlKCplbmRwKSkKIAkJc2l6ZSsrOwogCiAJaWYgKHNpemUgIT0gY291bnQpCmRpZmYgLS1naXQg YS9mcy9jYWNoZWZpbGVzL2RhZW1vbi5jIGIvZnMvY2FjaGVmaWxlcy9kYWVtb24uYwppbmRleCA0 NjE4NTE2Li5hZjZkOWE2IDEwMDY0NAotLS0gYS9mcy9jYWNoZWZpbGVzL2RhZW1vbi5jCisrKyBi L2ZzL2NhY2hlZmlsZXMvZGFlbW9uLmMKQEAgLTIxLDYgKzIxLDcgQEAKICNpbmNsdWRlIDxsaW51 eC9tb3VudC5oPgogI2luY2x1ZGUgPGxpbnV4L3N0YXRmcy5oPgogI2luY2x1ZGUgPGxpbnV4L2N0 eXBlLmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvZnNfc3Ry dWN0Lmg+CiAjaW5jbHVkZSAiaW50ZXJuYWwuaCIKIApAQCAtMjUwLDE1ICsyNTEsMTIgQEAgc3Rh dGljIHNzaXplX3QgY2FjaGVmaWxlc19kYWVtb25fd3JpdGUoc3RydWN0IGZpbGUgKmZpbGUsCiAJ LyogcGFyc2UgdGhlIGNvbW1hbmQgKi8KIAlyZXQgPSAtRU9QTk9UU1VQUDsKIAotCWZvciAoYXJn cyA9IGRhdGE7ICphcmdzOyBhcmdzKyspCi0JCWlmIChpc3NwYWNlKCphcmdzKSkKLQkJCWJyZWFr OworCWFyZ3MgPSBza2lwX3NwYWNlcyhkYXRhKTsKIAlpZiAoKmFyZ3MpIHsKIAkJaWYgKGFyZ3Mg PT0gZGF0YSkKIAkJCWdvdG8gZXJyb3I7CiAJCSphcmdzID0gJ1wwJzsKLQkJZm9yIChhcmdzKys7 IGlzc3BhY2UoKmFyZ3MpOyBhcmdzKyspCi0JCQljb250aW51ZTsKKwkJYXJncyA9IHNraXBfc3Bh Y2VzKCsrYXJncyk7CiAJfQogCiAJLyogcnVuIHRoZSBhcHByb3ByaWF0ZSBjb21tYW5kIGhhbmRs ZXIgKi8KZGlmZiAtLWdpdCBhL2ZzL2V4dDQvc3VwZXIuYyBiL2ZzL2V4dDQvc3VwZXIuYwppbmRl eCAzMTIyMTFlLi41ODA3NjZhIDEwMDY0NAotLS0gYS9mcy9leHQ0L3N1cGVyLmMKKysrIGIvZnMv ZXh0NC9zdXBlci5jCkBAIC0yMDk3LDExICsyMDk3LDggQEAgc3RhdGljIGludCBwYXJzZV9zdHJ0 b3VsKGNvbnN0IGNoYXIgKmJ1ZiwKIHsKIAljaGFyICplbmRwOwogCi0Jd2hpbGUgKCpidWYgJiYg aXNzcGFjZSgqYnVmKSkKLQkJYnVmKys7Ci0JKnZhbHVlID0gc2ltcGxlX3N0cnRvdWwoYnVmLCAm ZW5kcCwgMCk7Ci0Jd2hpbGUgKCplbmRwICYmIGlzc3BhY2UoKmVuZHApKQotCQllbmRwKys7CisJ KnZhbHVlID0gc2ltcGxlX3N0cnRvdWwoc2tpcF9zcGFjZXMoYnVmKSwgJmVuZHAsIDApOworCWVu ZHAgPSBza2lwX3NwYWNlcyhlbmRwKTsKIAlpZiAoKmVuZHAgfHwgKnZhbHVlID4gbWF4KQogCQly ZXR1cm4gLUVJTlZBTDsKIApkaWZmIC0tZ2l0IGEva2VybmVsL3BhcmFtcy5jIGIva2VybmVsL3Bh cmFtcy5jCmluZGV4IGQ2NTZjMjcuLmNmMWI2OTEgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9wYXJhbXMu YworKysgYi9rZXJuZWwvcGFyYW1zLmMKQEAgLTI0LDYgKzI0LDcgQEAKICNpbmNsdWRlIDxsaW51 eC9lcnIuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvY3R5cGUu aD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KIAogI2lmIDAKICNkZWZpbmUgREVCVUdQIHBy aW50awpAQCAtMTIyLDkgKzEyMyw3IEBAIHN0YXRpYyBjaGFyICpuZXh0X2FyZyhjaGFyICphcmdz LCBjaGFyICoqcGFyYW0sIGNoYXIgKip2YWwpCiAJCW5leHQgPSBhcmdzICsgaTsKIAogCS8qIENo ZXcgdXAgdHJhaWxpbmcgc3BhY2VzLiAqLwotCXdoaWxlIChpc3NwYWNlKCpuZXh0KSkKLQkJbmV4 dCsrOwotCXJldHVybiBuZXh0OworCXJldHVybiBza2lwX3NwYWNlcyhuZXh0KTsKIH0KIAogLyog QXJncyBsb29rcyBsaWtlICJmb289YmFyLGJhcjIgYmF6PWZ1eiB3aXoiLiAqLwpAQCAtMTM5LDgg KzEzOCw3IEBAIGludCBwYXJzZV9hcmdzKGNvbnN0IGNoYXIgKm5hbWUsCiAJREVCVUdQKCJQYXJz aW5nIEFSR1M6ICVzXG4iLCBhcmdzKTsKIAogCS8qIENoZXcgbGVhZGluZyBzcGFjZXMgKi8KLQl3 aGlsZSAoaXNzcGFjZSgqYXJncykpCi0JCWFyZ3MrKzsKKwlhcmdzID0gc2tpcF9zcGFjZXMoYXJn cyk7CiAKIAl3aGlsZSAoKmFyZ3MpIHsKIAkJaW50IHJldDsKZGlmZiAtLWdpdCBhL2xpYi9hcmd2 X3NwbGl0LmMgYi9saWIvYXJndl9zcGxpdC5jCmluZGV4IDUyMDVhOGQuLjRiMWIwODMgMTAwNjQ0 Ci0tLSBhL2xpYi9hcmd2X3NwbGl0LmMKKysrIGIvbGliL2FyZ3Zfc3BsaXQuYwpAQCAtNCwxNyAr NCwxMCBAQAogCiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvY3R5 cGUuaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+ CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAKLXN0YXRpYyBjb25zdCBjaGFyICpza2lwX3Nl cChjb25zdCBjaGFyICpjcCkKLXsKLQl3aGlsZSAoKmNwICYmIGlzc3BhY2UoKmNwKSkKLQkJY3Ar KzsKLQotCXJldHVybiBjcDsKLX0KLQogc3RhdGljIGNvbnN0IGNoYXIgKnNraXBfYXJnKGNvbnN0 IGNoYXIgKmNwKQogewogCXdoaWxlICgqY3AgJiYgIWlzc3BhY2UoKmNwKSkKQEAgLTI4LDcgKzIx LDcgQEAgc3RhdGljIGludCBjb3VudF9hcmdjKGNvbnN0IGNoYXIgKnN0cikKIAlpbnQgY291bnQg PSAwOwogCiAJd2hpbGUgKCpzdHIpIHsKLQkJc3RyID0gc2tpcF9zZXAoc3RyKTsKKwkJc3RyID0g c2tpcF9zcGFjZXMoc3RyKTsKIAkJaWYgKCpzdHIpIHsKIAkJCWNvdW50Kys7CiAJCQlzdHIgPSBz a2lwX2FyZyhzdHIpOwpAQCAtODIsNyArNzUsNyBAQCBjaGFyICoqYXJndl9zcGxpdChnZnBfdCBn ZnAsIGNvbnN0IGNoYXIgKnN0ciwgaW50ICphcmdjcCkKIAlhcmd2cCA9IGFyZ3Y7CiAKIAl3aGls ZSAoKnN0cikgewotCQlzdHIgPSBza2lwX3NlcChzdHIpOworCQlzdHIgPSBza2lwX3NwYWNlcyhz dHIpOwogCiAJCWlmICgqc3RyKSB7CiAJCQljb25zdCBjaGFyICpwID0gc3RyOwpkaWZmIC0tZ2l0 IGEvbGliL2R5bmFtaWNfZGVidWcuYyBiL2xpYi9keW5hbWljX2RlYnVnLmMKaW5kZXggZTIyYzE0 OC4uZjkzNTAyOSAxMDA2NDQKLS0tIGEvbGliL2R5bmFtaWNfZGVidWcuYworKysgYi9saWIvZHlu YW1pY19kZWJ1Zy5jCkBAIC0yMSw2ICsyMSw3IEBACiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgog I2luY2x1ZGUgPGxpbnV4L3N5c2N0bC5oPgogI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+CisjaW5j bHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgogI2luY2x1 ZGUgPGxpbnV4L2R5bmFtaWNfZGVidWcuaD4KICNpbmNsdWRlIDxsaW51eC9kZWJ1Z2ZzLmg+CkBA IC0yMDksOCArMjEwLDcgQEAgc3RhdGljIGludCBkZGVidWdfdG9rZW5pemUoY2hhciAqYnVmLCBj aGFyICp3b3Jkc1tdLCBpbnQgbWF4d29yZHMpCiAJCWNoYXIgKmVuZDsKIAogCQkvKiBTa2lwIGxl YWRpbmcgd2hpdGVzcGFjZSAqLwotCQl3aGlsZSAoKmJ1ZiAmJiBpc3NwYWNlKCpidWYpKQotCQkJ YnVmKys7CisJCWJ1ZiA9IHNraXBfc3BhY2VzKGJ1Zik7CiAJCWlmICghKmJ1ZikKIAkJCWJyZWFr OwkvKiBvaCwgaXQgd2FzIHRyYWlsaW5nIHdoaXRlc3BhY2UgKi8KIApkaWZmIC0tZ2l0IGEvbGli L3ZzcHJpbnRmLmMgYi9saWIvdnNwcmludGYuYwppbmRleCA3ZWM5NmEzLi4wNmUwMzExIDEwMDY0 NAotLS0gYS9saWIvdnNwcmludGYuYworKysgYi9saWIvdnNwcmludGYuYwpAQCAtMTcxNiwxMyAr MTcxNiw2IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGJwcmludGYpOwogCiAjZW5kaWYgLyogQ09ORklH X0JJTkFSWV9QUklOVEYgKi8KIAotc3RhdGljIG5vaW5saW5lIGNvbnN0IGNoYXIgKnNraXBfc3Bh Y2UoY29uc3QgY2hhciAqc3RyKQotewotCXdoaWxlIChpc3NwYWNlKCpzdHIpKQotCQkrK3N0cjsK LQlyZXR1cm4gc3RyOwotfQotCiAvKioKICAqIHZzc2NhbmYgLSBVbmZvcm1hdCBhIGJ1ZmZlciBp bnRvIGEgbGlzdCBvZiBhcmd1bWVudHMKICAqIEBidWY6CWlucHV0IGJ1ZmZlcgpAQCAtMTc0NCw4 ICsxNzM3LDggQEAgaW50IHZzc2NhbmYoY29uc3QgY2hhciAqYnVmLCBjb25zdCBjaGFyICpmbXQs IHZhX2xpc3QgYXJncykKIAkJICogd2hpdGUgc3BhY2UsIGluY2x1ZGluZyBub25lLCBpbiB0aGUg aW5wdXQuCiAJCSAqLwogCQlpZiAoaXNzcGFjZSgqZm10KSkgewotCQkJZm10ID0gc2tpcF9zcGFj ZShmbXQpOwotCQkJc3RyID0gc2tpcF9zcGFjZShzdHIpOworCQkJZm10ID0gc2tpcF9zcGFjZXMo KytmbXQpOworCQkJc3RyID0gc2tpcF9zcGFjZXMoc3RyKTsKIAkJfQogCiAJCS8qIGFueXRoaW5n IHRoYXQgaXMgbm90IGEgY29udmVyc2lvbiBtdXN0IG1hdGNoIGV4YWN0bHkgKi8KQEAgLTE4MTUs NyArMTgwOCw3IEBAIGludCB2c3NjYW5mKGNvbnN0IGNoYXIgKmJ1ZiwgY29uc3QgY2hhciAqZm10 LCB2YV9saXN0IGFyZ3MpCiAJCQlpZiAoZmllbGRfd2lkdGggPT0gLTEpCiAJCQkJZmllbGRfd2lk dGggPSBJTlRfTUFYOwogCQkJLyogZmlyc3QsIHNraXAgbGVhZGluZyB3aGl0ZSBzcGFjZSBpbiBi dWZmZXIgKi8KLQkJCXN0ciA9IHNraXBfc3BhY2Uoc3RyKTsKKwkJCXN0ciA9IHNraXBfc3BhY2Vz KHN0cik7CiAKIAkJCS8qIG5vdyBjb3B5IHVudGlsIG5leHQgd2hpdGUgc3BhY2UgKi8KIAkJCXdo aWxlICgqc3RyICYmICFpc3NwYWNlKCpzdHIpICYmIGZpZWxkX3dpZHRoLS0pCkBAIC0xODU3LDcg KzE4NTAsNyBAQCBpbnQgdnNzY2FuZihjb25zdCBjaGFyICpidWYsIGNvbnN0IGNoYXIgKmZtdCwg dmFfbGlzdCBhcmdzKQogCQkvKiBoYXZlIHNvbWUgc29ydCBvZiBpbnRlZ2VyIGNvbnZlcnNpb24u CiAJCSAqIGZpcnN0LCBza2lwIHdoaXRlIHNwYWNlIGluIGJ1ZmZlci4KIAkJICovCi0JCXN0ciA9 IHNraXBfc3BhY2Uoc3RyKTsKKwkJc3RyID0gc2tpcF9zcGFjZXMoc3RyKTsKIAogCQlkaWdpdCA9 ICpzdHI7CiAJCWlmIChpc19zaWduICYmIGRpZ2l0ID09ICctJykKZGlmZiAtLWdpdCBhL25ldC9p cmRhL2lybmV0L2lybmV0LmggYi9uZXQvaXJkYS9pcm5ldC9pcm5ldC5oCmluZGV4IGIwMDFjMzYu LjQzMDBkZjMgMTAwNjQ0Ci0tLSBhL25ldC9pcmRhL2lybmV0L2lybmV0LmgKKysrIGIvbmV0L2ly ZGEvaXJuZXQvaXJuZXQuaApAQCAtMjQ5LDYgKzI0OSw3IEBACiAjaW5jbHVkZSA8bGludXgvcG9s bC5oPgogI2luY2x1ZGUgPGxpbnV4L2NhcGFiaWxpdHkuaD4KICNpbmNsdWRlIDxsaW51eC9jdHlw ZS5oPgkvKiBpc3NwYWNlKCkgKi8KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4JLyogc2tpcF9z cGFjZXMoKSAqLwogI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CiAjaW5jbHVkZSA8bGludXgvaW5p dC5oPgogCmRpZmYgLS1naXQgYS9uZXQvaXJkYS9pcm5ldC9pcm5ldF9wcHAuYyBiL25ldC9pcmRh L2lybmV0L2lybmV0X3BwcC5jCmluZGV4IDdkZWE4ODIuLjE1NjAyMGQgMTAwNjQ0Ci0tLSBhL25l dC9pcmRhL2lybmV0L2lybmV0X3BwcC5jCisrKyBiL25ldC9pcmRhL2lybmV0L2lybmV0X3BwcC5j CkBAIC03Niw5ICs3Niw4IEBAIGlybmV0X2N0cmxfd3JpdGUoaXJuZXRfc29ja2V0ICoJYXAsCiAg ICAgICAvKiBMb29rIGF0IHRoZSBuZXh0IGNvbW1hbmQgKi8KICAgICAgIHN0YXJ0ID0gbmV4dDsK IAotICAgICAgLyogU2NyYXAgd2hpdGVzcGFjZXMgYmVmb3JlIHRoZSBjb21tYW5kICovCi0gICAg ICB3aGlsZShpc3NwYWNlKCpzdGFydCkpCi0Jc3RhcnQrKzsKKwkvKiBTY3JhcCB3aGl0ZXNwYWNl cyBiZWZvcmUgdGhlIGNvbW1hbmQgKi8KKwlzdGFydCA9IHNraXBfc3BhY2VzKHN0YXJ0KTsKIAog ICAgICAgLyogJywnIGlzIG91ciBjb21tYW5kIHNlcGFyYXRvciAqLwogICAgICAgbmV4dCA9IHN0 cmNocihzdGFydCwgJywnKTsKQEAgLTEzMyw4ICsxMzIsNyBAQCBpcm5ldF9jdHJsX3dyaXRlKGly bmV0X3NvY2tldCAqCWFwLAogCSAgICAgIGNoYXIgKgllbmRwOwogCiAJICAgICAgLyogU2NyYXAg d2hpdGVzcGFjZXMgYmVmb3JlIHRoZSBjb21tYW5kICovCi0JICAgICAgd2hpbGUoaXNzcGFjZSgq YmVncCkpCi0JCWJlZ3ArKzsKKwkgICAgICBiZWdwID0gc2tpcF9zcGFjZXMoYmVncCk7CiAKIAkg ICAgICAvKiBDb252ZXJ0IGFyZ3VtZW50IHRvIGEgbnVtYmVyIChsYXN0IGFyZyBpcyB0aGUgYmFz ZSkgKi8KIAkgICAgICBhZGRyID0gc2ltcGxlX3N0cnRvdWwoYmVncCwgJmVuZHAsIDE2KTsKZGlm ZiAtLWdpdCBhL25ldC9uZXRmaWx0ZXIveHRfcmVjZW50LmMgYi9uZXQvbmV0ZmlsdGVyL3h0X3Jl Y2VudC5jCmluZGV4IGViMGNlYjguLmZjNzBhNDkgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIv eHRfcmVjZW50LmMKKysrIGIvbmV0L25ldGZpbHRlci94dF9yZWNlbnQuYwpAQCAtNDgyLDggKzQ4 Miw3IEBAIHN0YXRpYyBzc2l6ZV90IHJlY2VudF9vbGRfcHJvY193cml0ZShzdHJ1Y3QgZmlsZSAq ZmlsZSwKIAlpZiAoY29weV9mcm9tX3VzZXIoYnVmLCBpbnB1dCwgc2l6ZSkpCiAJCXJldHVybiAt RUZBVUxUOwogCi0Jd2hpbGUgKGlzc3BhY2UoKmMpKQotCQljKys7CisJYyA9IHNraXBfc3BhY2Vz KGMpOwogCiAJaWYgKHNpemUgLSAoYyAtIGJ1ZikgPCA1KQogCQlyZXR1cm4gYyAtIGJ1ZjsKZGlm ZiAtLWdpdCBhL3NvdW5kL3BjaS9oZGEvaGRhX2h3ZGVwLmMgYi9zb3VuZC9wY2kvaGRhL2hkYV9o d2RlcC5jCmluZGV4IGNjMjRlNjcuLjRlMTdiNDMgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9oZGEv aGRhX2h3ZGVwLmMKKysrIGIvc291bmQvcGNpL2hkYS9oZGFfaHdkZXAuYwpAQCAtMjQsNiArMjQs NyBAQAogI2luY2x1ZGUgPGxpbnV4L2NvbXBhdC5oPgogI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+ CiAjaW5jbHVkZSA8bGludXgvY3R5cGUuaD4KKyNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNp bmNsdWRlIDxsaW51eC9maXJtd2FyZS5oPgogI2luY2x1ZGUgPHNvdW5kL2NvcmUuaD4KICNpbmNs dWRlICJoZGFfY29kZWMuaCIKQEAgLTM5MCw4ICszOTEsNyBAQCBzdGF0aWMgaW50IHBhcnNlX2hp bnRzKHN0cnVjdCBoZGFfY29kZWMgKmNvZGVjLCBjb25zdCBjaGFyICpidWYpCiAJY2hhciAqa2V5 LCAqdmFsOwogCXN0cnVjdCBoZGFfaGludCAqaGludDsKIAotCXdoaWxlIChpc3NwYWNlKCpidWYp KQotCQlidWYrKzsKKwlidWYgPSBza2lwX3NwYWNlcyhidWYpOwogCWlmICghKmJ1ZiB8fCAqYnVm ID09ICcjJyB8fCAqYnVmID09ICdcbicpCiAJCXJldHVybiAwOwogCWlmICgqYnVmID09ICc9JykK QEAgLTQwNiw4ICs0MDYsNyBAQCBzdGF0aWMgaW50IHBhcnNlX2hpbnRzKHN0cnVjdCBoZGFfY29k ZWMgKmNvZGVjLCBjb25zdCBjaGFyICpidWYpCiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAkqdmFs KysgPSAwOwotCXdoaWxlIChpc3NwYWNlKCp2YWwpKQotCQl2YWwrKzsKKwl2YWwgPSBza2lwX3Nw YWNlcyh2YWwpOwogCXJlbW92ZV90cmFpbF9zcGFjZXMoa2V5KTsKIAlyZW1vdmVfdHJhaWxfc3Bh Y2VzKHZhbCk7CiAJaGludCA9IGdldF9oaW50KGNvZGVjLCBrZXkpOwotLSAKMS42LjUuMi4xNTMu ZzZlMzFmLmRpcnR5CgoKLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCkxldCBDcnlzdGFsIFJlcG9ydHMg aGFuZGxlIHRoZSByZXBvcnRpbmcgLSBGcmVlIENyeXN0YWwgUmVwb3J0cyAyMDA4IDMwLURheSAK dHJpYWwuIFNpbXBsaWZ5IHlvdXIgcmVwb3J0IGRlc2lnbiwgaW50ZWdyYXRpb24gYW5kIGRlcGxv eW1lbnQgLSBhbmQgZm9jdXMgb24gCndoYXQgeW91IGRvIGJlc3QsIGNvcmUgYXBwbGljYXRpb24g Y29kaW5nLiBEaXNjb3ZlciB3aGF0J3MgbmV3IHdpdGgKQ3J5c3RhbCBSZXBvcnRzIG5vdy4gIGh0 dHA6Ly9wLnNmLm5ldC9zZnUvYm9iai1qdWx5Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fClVzZXItbW9kZS1saW51eC1kZXZlbCBtYWlsaW5nIGxpc3QKVXNl ci1tb2RlLWxpbnV4LWRldmVsQGxpc3RzLnNvdXJjZWZvcmdlLm5ldApodHRwczovL2xpc3RzLnNv dXJjZWZvcmdlLm5ldC9saXN0cy9saXN0aW5mby91c2VyLW1vZGUtbGludXgtZGV2ZWwK