From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!.POSTED!not-for-mail From: Vibhav Pant Newsgroups: gmane.emacs.devel Subject: Re: [PATCH] Make purecopy create hash tables properly Date: Sun, 29 Jan 2017 22:53:10 +0530 Message-ID: References: NNTP-Posting-Host: blaine.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary=94eb2c147b0e0ba57305473ef489 X-Trace: blaine.gmane.org 1485710653 28463 195.159.176.226 (29 Jan 2017 17:24:13 GMT) X-Complaints-To: usenet@blaine.gmane.org NNTP-Posting-Date: Sun, 29 Jan 2017 17:24:13 +0000 (UTC) Cc: "emacs-devel@gnu.org" To: Stefan Monnier Original-X-From: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Sun Jan 29 18:24:00 2017 Return-path: Envelope-to: ged-emacs-devel@m.gmane.org Original-Received: from lists.gnu.org ([208.118.235.17]) by blaine.gmane.org with esmtp (Exim 4.84_2) (envelope-from ) id 1cXtCo-0006Kg-Vw for ged-emacs-devel@m.gmane.org; Sun, 29 Jan 2017 18:23:59 +0100 Original-Received: from localhost ([::1]:56131 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cXtCu-0001TS-B7 for ged-emacs-devel@m.gmane.org; Sun, 29 Jan 2017 12:24:04 -0500 Original-Received: from eggs.gnu.org ([2001:4830:134:3::10]:43194) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cXtCB-0001T7-VC for emacs-devel@gnu.org; Sun, 29 Jan 2017 12:23:27 -0500 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1cXtC4-0000qs-T9 for emacs-devel@gnu.org; Sun, 29 Jan 2017 12:23:19 -0500 Original-Received: from mail-yb0-x243.google.com ([2607:f8b0:4002:c09::243]:33114) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1cXtC4-0000qo-LS for emacs-devel@gnu.org; Sun, 29 Jan 2017 12:23:12 -0500 Original-Received: by mail-yb0-x243.google.com with SMTP id 123so24541758ybe.0 for ; Sun, 29 Jan 2017 09:23:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:in-reply-to:references:from:date:message-id:subject:to :cc; bh=EHi1ma2gHuOGnMBWh3xk4swINsjOxYuBcGCcTMyNQYw=; b=rtcUWKLxAifTDv3c1z1XshLHlsfarAjGCKrYObaOnsqYNLFbb/x6u2ia7icNIajNFP 05AbabL0XSOXFUIN+frU2s2CbixFdKm23hCudnCbutvEZeIeJPYhWdLI0ZYs9yaLW1lO yLgawmn5eLkNqAlQpYH6owSGjqGs4Wj4m8gr4wC8zwNuHuc0H0fihv9i0amVGOscyr0I olprc43ELCoaZzkbk1wlRKJEZlJ+uHKY4ETbkwZoO8TnkPb5SsA1WaeYkJu7raMCi/m2 EQSc5KjmWqCYkEyO8O+sgBSpzoIkCNETxX7iCi9HqRjRl+uEtr1UUjAEhvc0hNUxC+7h R/gA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:in-reply-to:references:from:date :message-id:subject:to:cc; bh=EHi1ma2gHuOGnMBWh3xk4swINsjOxYuBcGCcTMyNQYw=; b=IIqHEEB9J3JGhByogCoPQ5FKvJiC/5bL56rM6etWYw7OugP8gD9x0Hw2V6yWnQPxNk WbaaoE6sZzdFj8ORaeLHeQasTCyl81VDPoi7aLdCzbGSFZGWXzzrwpI1bx/UUlWZLL45 cL+QWzdO5pyZccOIbq+cVMdL5Dz087sDHBkfeABbKGqqWNslZ8hsyyoqk7eDD4uQ34zS WIeVuzjQtTrdohFWw43gDeomCAvgto3UyIpQPQK1WxkweAQX5SJc9blog/F3s6kkFWC+ aVmHNcy+exeUE4lmjqjLzK51yYztfR8LT7A9TDquZGvmQ3u2bUl2TGBm75LrL/6wsVED ceqQ== X-Gm-Message-State: AIkVDXLFI43v9crdBSuWb3OkUIrjijthVIHDWrhL69cOnZeI7j/15B7kPvx4b71+nC1Wpv/uAFx+6/9PYRqGNQ== X-Received: by 10.37.197.74 with SMTP id v71mr8715428ybe.33.1485710591488; Sun, 29 Jan 2017 09:23:11 -0800 (PST) Original-Received: by 10.129.153.77 with HTTP; Sun, 29 Jan 2017 09:23:10 -0800 (PST) In-Reply-To: X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] X-Received-From: 2607:f8b0:4002:c09::243 X-BeenThere: emacs-devel@gnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: "Emacs development discussions." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Original-Sender: "Emacs-devel" Xref: news.gmane.org gmane.emacs.devel:211728 Archived-At: --94eb2c147b0e0ba57305473ef489 Content-Type: text/plain; charset=UTF-8 On Sat, Jan 28, 2017 at 8:28 PM, Stefan Monnier wrote: > Good point. So we should check NILP (old->weak) and signal an > error if set. And thus old->next_weak should always be NULL and is > trivial to copy. > That would imply we can't purecopy any object which ends up referencing > a hash-table. Unless we arrange to keep track of those hash-tables > which are referenced from purespace. We already do that for symbols, so > maybe we can extend/generalize that mechanism (probably a good idea). > > For cons cells we do: > > CHECK_IMPURE (cell, XCONS (cell)); > > in `setcar', so we can do the same for hash-tables. Since purespace is > contiguous, CHECK_IMPURE is pretty efficient, and since it only relies > on the pointer value, the CPU can compute it in parallel with the access to > the object (and the test itself is trivial to predict), so it should > have a negligible impact on performance. Based on these suggestions, I have made a few more modifications to the code: * `gethash' now takes an additional :purecopy argument. If non-nil, the table will/can be copied to pure storage when the Emacs binary is being dumped. Since objects in pure storage are read only, gethash enforces that :weak and :purecopy aren't non-nil at the same time, erroring out when the latter is true. * All functions that modify hash tables (`puthash', `clrhash' and `remhash') make sure that the table is not in pure storage (with CHECK_IMPURE). * `make_pure_hash_table' now also purecopies the hash table test, and enforces the checks above with `eassert'. * A new struct, `pinned_object' is used as a linked list to store objects that should be marked before every GC cycle. For now, this is only used when a hash table with the :purecopy property set to nil is passed to purecopy (but should be usable for other objects in the future). Should this work, or is there anything else I need to do? Thanks, Vibhav -- Vibhav Pant vibhavp@gmail.com diff --git a/src/alloc.c b/src/alloc.c index f7b6515f4e..7d1132c953 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -5434,6 +5434,35 @@ make_pure_vector (ptrdiff_t len) return new; } +static struct Lisp_Hash_Table * +make_pure_hash_table (struct Lisp_Hash_Table *table) { + eassert (NILP (table->weak)); + eassert (!NILP (table->pure)); + + struct Lisp_Hash_Table *pure = pure_alloc (sizeof *pure, Lisp_Vectorlike); + struct hash_table_test pure_test = table->test; + + /* Purecopy the hash table test. */ + pure_test.name = purecopy (table->test.name); + pure_test.user_hash_function = purecopy (table->test.user_hash_function); + pure_test.user_cmp_function = purecopy (table->test.user_cmp_function); + + pure->test = pure_test; + pure->header = table->header; + pure->weak = purecopy (Qnil); + pure->rehash_size = purecopy (table->rehash_size); + pure->rehash_threshold = purecopy (table->rehash_threshold); + pure->hash = purecopy (table->hash); + pure->next = purecopy (table->next); + pure->next_free = purecopy (table->next_free); + pure->index = purecopy (table->index); + pure->count = table->count; + pure->key_and_value = purecopy (table->key_and_value); + pure->pure = purecopy (table->pure); + + return pure; +} + DEFUN ("purecopy", Fpurecopy, Spurecopy, 1, 1, 0, doc: /* Make a copy of object OBJ in pure storage. Recursively copies contents of vectors and cons cells. @@ -5442,14 +5471,22 @@ Does not copy symbols. Copies strings without text properties. */) { if (NILP (Vpurify_flag)) return obj; - else if (MARKERP (obj) || OVERLAYP (obj) - || HASH_TABLE_P (obj) || SYMBOLP (obj)) + else if (MARKERP (obj) || OVERLAYP (obj) || SYMBOLP (obj)) /* Can't purify those. */ return obj; else return purecopy (obj); } +struct pinned_object +{ + Lisp_Object object; + struct pinned_object *next; +}; + +/* Pinned objects are marked before every GC cycle. */ +static struct pinned_object *pinned_objects; + static Lisp_Object purecopy (Lisp_Object obj) { @@ -5477,7 +5514,26 @@ purecopy (Lisp_Object obj) obj = make_pure_string (SSDATA (obj), SCHARS (obj), SBYTES (obj), STRING_MULTIBYTE (obj)); - else if (COMPILEDP (obj) || VECTORP (obj) || HASH_TABLE_P (obj)) + else if (HASH_TABLE_P (obj)) + { + struct Lisp_Hash_Table *table = XHASH_TABLE (obj); + /* We cannot purecopy hash tables which haven't been defined with + :purecopy as non-nil, they aren't guaranteed to not change. */ + if (NILP (table->pure)) + { + /* Instead, the hash table is added to the list of pinned objects, + and is marked before GC. */ + struct pinned_object *o = xmalloc (sizeof *o); + o->object = obj; + o->next = pinned_objects; + pinned_objects = o; + return obj; + } + + struct Lisp_Hash_Table *h = make_pure_hash_table (table); + XSET_HASH_TABLE (obj, h); + } + else if (COMPILEDP (obj) || VECTORP (obj)) { struct Lisp_Vector *objp = XVECTOR (obj); ptrdiff_t nbytes = vector_nbytes (objp); @@ -5694,6 +5750,16 @@ compact_undo_list (Lisp_Object list) } static void +mark_pinned_objects (void) +{ + struct pinned_object *pobj; + for (pobj = pinned_objects; pobj; pobj = pobj->next) + { + mark_object (pobj->object); + } +} + +static void mark_pinned_symbols (void) { struct symbol_block *sblk; @@ -5813,6 +5879,7 @@ garbage_collect_1 (void *end) for (i = 0; i < staticidx; i++) mark_object (*staticvec[i]); + mark_pinned_objects (); mark_pinned_symbols (); mark_terminals (); mark_kboards (); diff --git a/src/category.c b/src/category.c index e5d261c1cf..ff287a4af3 100644 --- a/src/category.c +++ b/src/category.c @@ -67,7 +67,7 @@ hash_get_category_set (Lisp_Object table, Lisp_Object category_set) make_hash_table (hashtest_equal, make_number (DEFAULT_HASH_SIZE), make_float (DEFAULT_REHASH_SIZE), make_float (DEFAULT_REHASH_THRESHOLD), - Qnil)); + Qnil, Qnil)); h = XHASH_TABLE (XCHAR_TABLE (table)->extras[1]); i = hash_lookup (h, category_set, &hash); if (i >= 0) diff --git a/src/emacs-module.c b/src/emacs-module.c index e22c7dc5b7..69fa5c8e64 100644 --- a/src/emacs-module.c +++ b/src/emacs-module.c @@ -1016,7 +1016,7 @@ syms_of_module (void) = make_hash_table (hashtest_eq, make_number (DEFAULT_HASH_SIZE), make_float (DEFAULT_REHASH_SIZE), make_float (DEFAULT_REHASH_THRESHOLD), - Qnil); + Qnil, Qnil); Funintern (Qmodule_refs_hash, Qnil); DEFSYM (Qmodule_environments, "module-environments"); diff --git a/src/fns.c b/src/fns.c index b8ebfe5b2e..420bf6c1ee 100644 --- a/src/fns.c +++ b/src/fns.c @@ -34,6 +34,7 @@ along with GNU Emacs. If not, see . */ #include "buffer.h" #include "intervals.h" #include "window.h" +#include "puresize.h" static void sort_vector_copy (Lisp_Object, ptrdiff_t, Lisp_Object *restrict, Lisp_Object *restrict); @@ -3750,12 +3751,17 @@ allocate_hash_table (void) (table size) is >= REHASH_THRESHOLD. WEAK specifies the weakness of the table. If non-nil, it must be - one of the symbols `key', `value', `key-or-value', or `key-and-value'. */ + one of the symbols `key', `value', `key-or-value', or `key-and-value'. + + If PURECOPY is non-nil, the table can be copied to pure storage via + `purecopy' when Emacs is being dumped. Such tables can no longer be + changed after purecopy. */ Lisp_Object make_hash_table (struct hash_table_test test, Lisp_Object size, Lisp_Object rehash_size, - Lisp_Object rehash_threshold, Lisp_Object weak) + Lisp_Object rehash_threshold, Lisp_Object weak, + Lisp_Object pure) { struct Lisp_Hash_Table *h; Lisp_Object table; @@ -3774,6 +3780,8 @@ make_hash_table (struct hash_table_test test, if (XFASTINT (size) == 0) size = make_number (1); + if (!NILP (weak) && !NILP (pure)) + error ("Weak hash tables cannot be purecopied"); sz = XFASTINT (size); index_float = sz / XFLOAT_DATA (rehash_threshold); @@ -3796,6 +3804,7 @@ make_hash_table (struct hash_table_test test, h->hash = Fmake_vector (size, Qnil); h->next = Fmake_vector (size, Qnil); h->index = Fmake_vector (make_number (index_size), Qnil); + h->pure = pure; /* Set up the free list. */ for (i = 0; i < sz - 1; ++i) @@ -4460,10 +4469,14 @@ key, value, one of key or value, or both key and value, depending on WEAK. WEAK t is equivalent to `key-and-value'. Default value of WEAK is nil. +:purecopy PURECOPY -- If PURECOPY is non-nil, the table can be copied +to pure storage when Emacs is being dumped, making the contents of the +table read only. WEAK should be nil for such tables. + usage: (make-hash-table &rest KEYWORD-ARGS) */) (ptrdiff_t nargs, Lisp_Object *args) { - Lisp_Object test, size, rehash_size, rehash_threshold, weak; + Lisp_Object test, size, rehash_size, rehash_threshold, weak, pure; struct hash_table_test testdesc; ptrdiff_t i; USE_SAFE_ALLOCA; @@ -4497,6 +4510,9 @@ usage: (make-hash-table &rest KEYWORD-ARGS) */) testdesc.cmpfn = cmpfn_user_defined; } + /* See if there's a `:purecopy PURECOPY' argument. */ + i = get_key_arg (QCpurecopy, nargs, args, used); + pure = i ? args[i] : Qnil; /* See if there's a `:size SIZE' argument. */ i = get_key_arg (QCsize, nargs, args, used); size = i ? args[i] : Qnil; @@ -4538,7 +4554,8 @@ usage: (make-hash-table &rest KEYWORD-ARGS) */) signal_error ("Invalid argument list", args[i]); SAFE_FREE (); - return make_hash_table (testdesc, size, rehash_size, rehash_threshold, weak); + return make_hash_table (testdesc, size, rehash_size, rehash_threshold, weak, + pure); } @@ -4617,7 +4634,9 @@ DEFUN ("clrhash", Fclrhash, Sclrhash, 1, 1, 0, doc: /* Clear hash table TABLE and return it. */) (Lisp_Object table) { - hash_clear (check_hash_table (table)); + struct Lisp_Hash_Table *h = check_hash_table (table); + CHECK_IMPURE (table, h); + hash_clear (h); /* Be compatible with XEmacs. */ return table; } @@ -4641,9 +4660,10 @@ VALUE. In any case, return VALUE. */) (Lisp_Object key, Lisp_Object value, Lisp_Object table) { struct Lisp_Hash_Table *h = check_hash_table (table); + CHECK_IMPURE (table, h); + ptrdiff_t i; EMACS_UINT hash; - i = hash_lookup (h, key, &hash); if (i >= 0) set_hash_value_slot (h, i, value); @@ -4659,6 +4679,7 @@ DEFUN ("remhash", Fremhash, Sremhash, 2, 2, 0, (Lisp_Object key, Lisp_Object table) { struct Lisp_Hash_Table *h = check_hash_table (table); + CHECK_IMPURE (table, h); hash_remove_from_table (h, key); return Qnil; } @@ -5029,6 +5050,7 @@ syms_of_fns (void) DEFSYM (Qequal, "equal"); DEFSYM (QCtest, ":test"); DEFSYM (QCsize, ":size"); + DEFSYM (QCpurecopy, ":purecopy"); DEFSYM (QCrehash_size, ":rehash-size"); DEFSYM (QCrehash_threshold, ":rehash-threshold"); DEFSYM (QCweakness, ":weakness"); diff --git a/src/image.c b/src/image.c index 39677d2add..ad0143be48 100644 --- a/src/image.c +++ b/src/image.c @@ -4020,7 +4020,7 @@ xpm_make_color_table_h (void (**put_func) (Lisp_Object, const char *, int, return make_hash_table (hashtest_equal, make_number (DEFAULT_HASH_SIZE), make_float (DEFAULT_REHASH_SIZE), make_float (DEFAULT_REHASH_THRESHOLD), - Qnil); + Qnil, Qnil); } static void diff --git a/src/lisp.h b/src/lisp.h index 84d53bb1ee..91c430fe98 100644 --- a/src/lisp.h +++ b/src/lisp.h @@ -1995,6 +1995,10 @@ struct Lisp_Hash_Table hash table size to reduce collisions. */ Lisp_Object index; + /* Non-nil if the table can be purecopied. Any changes the table after + purecopy will result in an error. */ + Lisp_Object pure; + /* Only the fields above are traced normally by the GC. The ones below `count' are special and are either ignored by the GC or traced in a special way (e.g. because of weakness). */ @@ -3364,7 +3368,7 @@ extern void sweep_weak_hash_tables (void); EMACS_UINT hash_string (char const *, ptrdiff_t); EMACS_UINT sxhash (Lisp_Object, int); Lisp_Object make_hash_table (struct hash_table_test, Lisp_Object, Lisp_Object, - Lisp_Object, Lisp_Object); + Lisp_Object, Lisp_Object, Lisp_Object); ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, EMACS_UINT *); ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object, EMACS_UINT); diff --git a/src/lread.c b/src/lread.c index ea2a1d1d85..17806922a8 100644 --- a/src/lread.c +++ b/src/lread.c @@ -2599,7 +2599,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list) Lisp_Object val = Qnil; /* The size is 2 * number of allowed keywords to make-hash-table. */ - Lisp_Object params[10]; + Lisp_Object params[12]; Lisp_Object ht; Lisp_Object key = Qnil; int param_count = 0; @@ -2636,6 +2636,11 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list) if (!NILP (params[param_count + 1])) param_count += 2; + params[param_count] = QCpurecopy; + params[param_count + 1] = Fplist_get (tmp, Qpurecopy); + if (!NILP (params[param_count + 1])) + param_count += 2; + /* This is the hash table data. */ data = Fplist_get (tmp, Qdata); @@ -4849,6 +4854,7 @@ that are loaded before your customizations are read! */); DEFSYM (Qdata, "data"); DEFSYM (Qtest, "test"); DEFSYM (Qsize, "size"); + DEFSYM (Qpurecopy, "purecopy"); DEFSYM (Qweakness, "weakness"); DEFSYM (Qrehash_size, "rehash-size"); DEFSYM (Qrehash_threshold, "rehash-threshold"); diff --git a/src/print.c b/src/print.c index 36d68a452e..db3d00f51f 100644 --- a/src/print.c +++ b/src/print.c @@ -1818,6 +1818,12 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag) print_object (h->rehash_threshold, printcharfun, escapeflag); } + if (!NILP (h->pure)) + { + print_c_string (" purecopy ", printcharfun); + print_object (h->pure, printcharfun, escapeflag); + } + print_c_string (" data ", printcharfun); /* Print the data here as a plist. */ diff --git a/src/profiler.c b/src/profiler.c index 88825bebdb..a223a7e7c0 100644 --- a/src/profiler.c +++ b/src/profiler.c @@ -48,7 +48,7 @@ make_log (EMACS_INT heap_size, EMACS_INT max_stack_depth) make_number (heap_size), make_float (DEFAULT_REHASH_SIZE), make_float (DEFAULT_REHASH_THRESHOLD), - Qnil); + Qnil, Qnil); struct Lisp_Hash_Table *h = XHASH_TABLE (log); /* What is special about our hash-tables is that the keys are pre-filled diff --git a/src/xterm.c b/src/xterm.c index 80cf8ce191..38229a5f31 100644 --- a/src/xterm.c +++ b/src/xterm.c @@ -12877,7 +12877,7 @@ keysyms. The default is nil, which is the same as `super'. */); Vx_keysym_table = make_hash_table (hashtest_eql, make_number (900), make_float (DEFAULT_REHASH_SIZE), make_float (DEFAULT_REHASH_THRESHOLD), - Qnil); + Qnil, Qnil); DEFVAR_BOOL ("x-frame-normalize-before-maximize", x_frame_normalize_before_maximize, --94eb2c147b0e0ba57305473ef489 Content-Type: text/x-patch; charset=US-ASCII; name="purecopy_hash_table.patch" Content-Disposition: attachment; filename="purecopy_hash_table.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_iyixplhx0 ZGlmZiAtLWdpdCBhL3NyYy9hbGxvYy5jIGIvc3JjL2FsbG9jLmMKaW5kZXggZjdiNjUxNWY0ZS4u N2QxMTMyYzk1MyAxMDA2NDQKLS0tIGEvc3JjL2FsbG9jLmMKKysrIGIvc3JjL2FsbG9jLmMKQEAg LTU0MzQsNiArNTQzNCwzNSBAQCBtYWtlX3B1cmVfdmVjdG9yIChwdHJkaWZmX3QgbGVuKQogICBy ZXR1cm4gbmV3OwogfQogCitzdGF0aWMgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqCittYWtlX3B1 cmVfaGFzaF90YWJsZSAoc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqdGFibGUpIHsKKyAgZWFzc2Vy dCAoTklMUCAodGFibGUtPndlYWspKTsKKyAgZWFzc2VydCAoIU5JTFAgKHRhYmxlLT5wdXJlKSk7 CisKKyAgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqcHVyZSA9IHB1cmVfYWxsb2MgKHNpemVvZiAq cHVyZSwgTGlzcF9WZWN0b3JsaWtlKTsKKyAgc3RydWN0IGhhc2hfdGFibGVfdGVzdCBwdXJlX3Rl c3QgPSB0YWJsZS0+dGVzdDsKKworICAvKiBQdXJlY29weSB0aGUgaGFzaCB0YWJsZSB0ZXN0LiAg Ki8KKyAgcHVyZV90ZXN0Lm5hbWUgPSBwdXJlY29weSAodGFibGUtPnRlc3QubmFtZSk7CisgIHB1 cmVfdGVzdC51c2VyX2hhc2hfZnVuY3Rpb24gPSBwdXJlY29weSAodGFibGUtPnRlc3QudXNlcl9o YXNoX2Z1bmN0aW9uKTsKKyAgcHVyZV90ZXN0LnVzZXJfY21wX2Z1bmN0aW9uID0gcHVyZWNvcHkg KHRhYmxlLT50ZXN0LnVzZXJfY21wX2Z1bmN0aW9uKTsKKworICBwdXJlLT50ZXN0ID0gcHVyZV90 ZXN0OworICBwdXJlLT5oZWFkZXIgPSB0YWJsZS0+aGVhZGVyOworICBwdXJlLT53ZWFrID0gcHVy ZWNvcHkgKFFuaWwpOworICBwdXJlLT5yZWhhc2hfc2l6ZSA9IHB1cmVjb3B5ICh0YWJsZS0+cmVo YXNoX3NpemUpOworICBwdXJlLT5yZWhhc2hfdGhyZXNob2xkID0gcHVyZWNvcHkgKHRhYmxlLT5y ZWhhc2hfdGhyZXNob2xkKTsKKyAgcHVyZS0+aGFzaCA9IHB1cmVjb3B5ICh0YWJsZS0+aGFzaCk7 CisgIHB1cmUtPm5leHQgPSBwdXJlY29weSAodGFibGUtPm5leHQpOworICBwdXJlLT5uZXh0X2Zy ZWUgPSBwdXJlY29weSAodGFibGUtPm5leHRfZnJlZSk7CisgIHB1cmUtPmluZGV4ID0gcHVyZWNv cHkgKHRhYmxlLT5pbmRleCk7CisgIHB1cmUtPmNvdW50ID0gdGFibGUtPmNvdW50OworICBwdXJl LT5rZXlfYW5kX3ZhbHVlID0gcHVyZWNvcHkgKHRhYmxlLT5rZXlfYW5kX3ZhbHVlKTsKKyAgcHVy ZS0+cHVyZSA9IHB1cmVjb3B5ICh0YWJsZS0+cHVyZSk7CisKKyAgcmV0dXJuIHB1cmU7Cit9CisK IERFRlVOICgicHVyZWNvcHkiLCBGcHVyZWNvcHksIFNwdXJlY29weSwgMSwgMSwgMCwKICAgICAg ICBkb2M6IC8qIE1ha2UgYSBjb3B5IG9mIG9iamVjdCBPQkogaW4gcHVyZSBzdG9yYWdlLgogUmVj dXJzaXZlbHkgY29waWVzIGNvbnRlbnRzIG9mIHZlY3RvcnMgYW5kIGNvbnMgY2VsbHMuCkBAIC01 NDQyLDE0ICs1NDcxLDIyIEBAIERvZXMgbm90IGNvcHkgc3ltYm9scy4gIENvcGllcyBzdHJpbmdz IHdpdGhvdXQgdGV4dCBwcm9wZXJ0aWVzLiAgKi8pCiB7CiAgIGlmIChOSUxQIChWcHVyaWZ5X2Zs YWcpKQogICAgIHJldHVybiBvYmo7Ci0gIGVsc2UgaWYgKE1BUktFUlAgKG9iaikgfHwgT1ZFUkxB WVAgKG9iaikKLQkgICB8fCBIQVNIX1RBQkxFX1AgKG9iaikgfHwgU1lNQk9MUCAob2JqKSkKKyAg ZWxzZSBpZiAoTUFSS0VSUCAob2JqKSB8fCBPVkVSTEFZUCAob2JqKSB8fCBTWU1CT0xQIChvYmop KQogICAgIC8qIENhbid0IHB1cmlmeSB0aG9zZS4gICovCiAgICAgcmV0dXJuIG9iajsKICAgZWxz ZQogICAgIHJldHVybiBwdXJlY29weSAob2JqKTsKIH0KIAorc3RydWN0IHBpbm5lZF9vYmplY3QK K3sKKyAgTGlzcF9PYmplY3Qgb2JqZWN0OworICBzdHJ1Y3QgcGlubmVkX29iamVjdCAqbmV4dDsK K307CisKKy8qIFBpbm5lZCBvYmplY3RzIGFyZSBtYXJrZWQgYmVmb3JlIGV2ZXJ5IEdDIGN5Y2xl LiAgKi8KK3N0YXRpYyBzdHJ1Y3QgcGlubmVkX29iamVjdCAqcGlubmVkX29iamVjdHM7CisKIHN0 YXRpYyBMaXNwX09iamVjdAogcHVyZWNvcHkgKExpc3BfT2JqZWN0IG9iaikKIHsKQEAgLTU0Nzcs NyArNTUxNCwyNiBAQCBwdXJlY29weSAoTGlzcF9PYmplY3Qgb2JqKQogICAgIG9iaiA9IG1ha2Vf cHVyZV9zdHJpbmcgKFNTREFUQSAob2JqKSwgU0NIQVJTIChvYmopLAogCQkJICAgIFNCWVRFUyAo b2JqKSwKIAkJCSAgICBTVFJJTkdfTVVMVElCWVRFIChvYmopKTsKLSAgZWxzZSBpZiAoQ09NUElM RURQIChvYmopIHx8IFZFQ1RPUlAgKG9iaikgfHwgSEFTSF9UQUJMRV9QIChvYmopKQorICBlbHNl IGlmIChIQVNIX1RBQkxFX1AgKG9iaikpCisgICAgeworICAgICAgc3RydWN0IExpc3BfSGFzaF9U YWJsZSAqdGFibGUgPSBYSEFTSF9UQUJMRSAob2JqKTsKKyAgICAgIC8qIFdlIGNhbm5vdCBwdXJl Y29weSBoYXNoIHRhYmxlcyB3aGljaCBoYXZlbid0IGJlZW4gZGVmaW5lZCB3aXRoCisgICAgICAg ICA6cHVyZWNvcHkgYXMgbm9uLW5pbCwgdGhleSBhcmVuJ3QgZ3VhcmFudGVlZCB0byBub3QgY2hh bmdlLiAgKi8KKyAgICAgIGlmIChOSUxQICh0YWJsZS0+cHVyZSkpCisgICAgICAgIHsKKyAgICAg ICAgICAvKiBJbnN0ZWFkLCB0aGUgaGFzaCB0YWJsZSBpcyBhZGRlZCB0byB0aGUgbGlzdCBvZiBw aW5uZWQgb2JqZWN0cywKKyAgICAgICAgICAgICBhbmQgaXMgbWFya2VkIGJlZm9yZSBHQy4gICov CisgICAgICAgICAgc3RydWN0IHBpbm5lZF9vYmplY3QgKm8gPSB4bWFsbG9jIChzaXplb2YgKm8p OworICAgICAgICAgIG8tPm9iamVjdCA9IG9iajsKKyAgICAgICAgICBvLT5uZXh0ID0gcGlubmVk X29iamVjdHM7CisgICAgICAgICAgcGlubmVkX29iamVjdHMgPSBvOworICAgICAgICAgIHJldHVy biBvYmo7CisgICAgICAgIH0KKworICAgICAgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCA9IG1h a2VfcHVyZV9oYXNoX3RhYmxlICh0YWJsZSk7CisgICAgICBYU0VUX0hBU0hfVEFCTEUgKG9iaiwg aCk7CisgICAgfQorICBlbHNlIGlmIChDT01QSUxFRFAgKG9iaikgfHwgVkVDVE9SUCAob2JqKSkK ICAgICB7CiAgICAgICBzdHJ1Y3QgTGlzcF9WZWN0b3IgKm9ianAgPSBYVkVDVE9SIChvYmopOwog ICAgICAgcHRyZGlmZl90IG5ieXRlcyA9IHZlY3Rvcl9uYnl0ZXMgKG9ianApOwpAQCAtNTY5NCw2 ICs1NzUwLDE2IEBAIGNvbXBhY3RfdW5kb19saXN0IChMaXNwX09iamVjdCBsaXN0KQogfQogCiBz dGF0aWMgdm9pZAorbWFya19waW5uZWRfb2JqZWN0cyAodm9pZCkKK3sKKyAgc3RydWN0IHBpbm5l ZF9vYmplY3QgKnBvYmo7CisgIGZvciAocG9iaiA9IHBpbm5lZF9vYmplY3RzOyBwb2JqOyBwb2Jq ID0gcG9iai0+bmV4dCkKKyAgICB7CisgICAgICBtYXJrX29iamVjdCAocG9iai0+b2JqZWN0KTsK KyAgICB9Cit9CisKK3N0YXRpYyB2b2lkCiBtYXJrX3Bpbm5lZF9zeW1ib2xzICh2b2lkKQogewog ICBzdHJ1Y3Qgc3ltYm9sX2Jsb2NrICpzYmxrOwpAQCAtNTgxMyw2ICs1ODc5LDcgQEAgZ2FyYmFn ZV9jb2xsZWN0XzEgKHZvaWQgKmVuZCkKICAgZm9yIChpID0gMDsgaSA8IHN0YXRpY2lkeDsgaSsr KQogICAgIG1hcmtfb2JqZWN0ICgqc3RhdGljdmVjW2ldKTsKIAorICBtYXJrX3Bpbm5lZF9vYmpl Y3RzICgpOwogICBtYXJrX3Bpbm5lZF9zeW1ib2xzICgpOwogICBtYXJrX3Rlcm1pbmFscyAoKTsK ICAgbWFya19rYm9hcmRzICgpOwpkaWZmIC0tZ2l0IGEvc3JjL2NhdGVnb3J5LmMgYi9zcmMvY2F0 ZWdvcnkuYwppbmRleCBlNWQyNjFjMWNmLi5mZjI4N2E0YWYzIDEwMDY0NAotLS0gYS9zcmMvY2F0 ZWdvcnkuYworKysgYi9zcmMvY2F0ZWdvcnkuYwpAQCAtNjcsNyArNjcsNyBAQCBoYXNoX2dldF9j YXRlZ29yeV9zZXQgKExpc3BfT2JqZWN0IHRhYmxlLCBMaXNwX09iamVjdCBjYXRlZ29yeV9zZXQp CiAgICAgICAgbWFrZV9oYXNoX3RhYmxlIChoYXNodGVzdF9lcXVhbCwgbWFrZV9udW1iZXIgKERF RkFVTFRfSEFTSF9TSVpFKSwKIAkJCW1ha2VfZmxvYXQgKERFRkFVTFRfUkVIQVNIX1NJWkUpLAog CQkJbWFrZV9mbG9hdCAoREVGQVVMVF9SRUhBU0hfVEhSRVNIT0xEKSwKLQkJCVFuaWwpKTsKKwkJ CVFuaWwsIFFuaWwpKTsKICAgaCA9IFhIQVNIX1RBQkxFIChYQ0hBUl9UQUJMRSAodGFibGUpLT5l eHRyYXNbMV0pOwogICBpID0gaGFzaF9sb29rdXAgKGgsIGNhdGVnb3J5X3NldCwgJmhhc2gpOwog ICBpZiAoaSA+PSAwKQpkaWZmIC0tZ2l0IGEvc3JjL2VtYWNzLW1vZHVsZS5jIGIvc3JjL2VtYWNz LW1vZHVsZS5jCmluZGV4IGUyMmM3ZGM1YjcuLjY5ZmE1YzhlNjQgMTAwNjQ0Ci0tLSBhL3NyYy9l bWFjcy1tb2R1bGUuYworKysgYi9zcmMvZW1hY3MtbW9kdWxlLmMKQEAgLTEwMTYsNyArMTAxNiw3 IEBAIHN5bXNfb2ZfbW9kdWxlICh2b2lkKQogICAgID0gbWFrZV9oYXNoX3RhYmxlIChoYXNodGVz dF9lcSwgbWFrZV9udW1iZXIgKERFRkFVTFRfSEFTSF9TSVpFKSwKIAkJICAgICAgIG1ha2VfZmxv YXQgKERFRkFVTFRfUkVIQVNIX1NJWkUpLAogCQkgICAgICAgbWFrZV9mbG9hdCAoREVGQVVMVF9S RUhBU0hfVEhSRVNIT0xEKSwKLQkJICAgICAgIFFuaWwpOworCQkgICAgICAgUW5pbCwgUW5pbCk7 CiAgIEZ1bmludGVybiAoUW1vZHVsZV9yZWZzX2hhc2gsIFFuaWwpOwogCiAgIERFRlNZTSAoUW1v ZHVsZV9lbnZpcm9ubWVudHMsICJtb2R1bGUtZW52aXJvbm1lbnRzIik7CmRpZmYgLS1naXQgYS9z cmMvZm5zLmMgYi9zcmMvZm5zLmMKaW5kZXggYjhlYmZlNWIyZS4uNDIwYmY2YzFlZSAxMDA2NDQK LS0tIGEvc3JjL2Zucy5jCisrKyBiL3NyYy9mbnMuYwpAQCAtMzQsNiArMzQsNyBAQCBhbG9uZyB3 aXRoIEdOVSBFbWFjcy4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMv Pi4gICovCiAjaW5jbHVkZSAiYnVmZmVyLmgiCiAjaW5jbHVkZSAiaW50ZXJ2YWxzLmgiCiAjaW5j bHVkZSAid2luZG93LmgiCisjaW5jbHVkZSAicHVyZXNpemUuaCIKIAogc3RhdGljIHZvaWQgc29y dF92ZWN0b3JfY29weSAoTGlzcF9PYmplY3QsIHB0cmRpZmZfdCwKIAkJCSAgICAgIExpc3BfT2Jq ZWN0ICpyZXN0cmljdCwgTGlzcF9PYmplY3QgKnJlc3RyaWN0KTsKQEAgLTM3NTAsMTIgKzM3NTEs MTcgQEAgYWxsb2NhdGVfaGFzaF90YWJsZSAodm9pZCkKICAgICh0YWJsZSBzaXplKSBpcyA+PSBS RUhBU0hfVEhSRVNIT0xELgogCiAgICBXRUFLIHNwZWNpZmllcyB0aGUgd2Vha25lc3Mgb2YgdGhl IHRhYmxlLiAgSWYgbm9uLW5pbCwgaXQgbXVzdCBiZQotICAgb25lIG9mIHRoZSBzeW1ib2xzIGBr ZXknLCBgdmFsdWUnLCBga2V5LW9yLXZhbHVlJywgb3IgYGtleS1hbmQtdmFsdWUnLiAgKi8KKyAg IG9uZSBvZiB0aGUgc3ltYm9scyBga2V5JywgYHZhbHVlJywgYGtleS1vci12YWx1ZScsIG9yIGBr ZXktYW5kLXZhbHVlJy4KKworICAgSWYgUFVSRUNPUFkgaXMgbm9uLW5pbCwgdGhlIHRhYmxlIGNh biBiZSBjb3BpZWQgdG8gcHVyZSBzdG9yYWdlIHZpYQorICAgYHB1cmVjb3B5JyB3aGVuIEVtYWNz IGlzIGJlaW5nIGR1bXBlZC4gU3VjaCB0YWJsZXMgY2FuIG5vIGxvbmdlciBiZQorICAgY2hhbmdl ZCBhZnRlciBwdXJlY29weS4gICovCiAKIExpc3BfT2JqZWN0CiBtYWtlX2hhc2hfdGFibGUgKHN0 cnVjdCBoYXNoX3RhYmxlX3Rlc3QgdGVzdCwKIAkJIExpc3BfT2JqZWN0IHNpemUsIExpc3BfT2Jq ZWN0IHJlaGFzaF9zaXplLAotCQkgTGlzcF9PYmplY3QgcmVoYXNoX3RocmVzaG9sZCwgTGlzcF9P YmplY3Qgd2VhaykKKwkJIExpc3BfT2JqZWN0IHJlaGFzaF90aHJlc2hvbGQsIExpc3BfT2JqZWN0 IHdlYWssCisgICAgICAgICAgICAgICAgIExpc3BfT2JqZWN0IHB1cmUpCiB7CiAgIHN0cnVjdCBM aXNwX0hhc2hfVGFibGUgKmg7CiAgIExpc3BfT2JqZWN0IHRhYmxlOwpAQCAtMzc3NCw2ICszNzgw LDggQEAgbWFrZV9oYXNoX3RhYmxlIChzdHJ1Y3QgaGFzaF90YWJsZV90ZXN0IHRlc3QsCiAKICAg aWYgKFhGQVNUSU5UIChzaXplKSA9PSAwKQogICAgIHNpemUgPSBtYWtlX251bWJlciAoMSk7Cisg IGlmICghTklMUCAod2VhaykgJiYgIU5JTFAgKHB1cmUpKQorICAgIGVycm9yICgiV2VhayBoYXNo IHRhYmxlcyBjYW5ub3QgYmUgcHVyZWNvcGllZCIpOwogCiAgIHN6ID0gWEZBU1RJTlQgKHNpemUp OwogICBpbmRleF9mbG9hdCA9IHN6IC8gWEZMT0FUX0RBVEEgKHJlaGFzaF90aHJlc2hvbGQpOwpA QCAtMzc5Niw2ICszODA0LDcgQEAgbWFrZV9oYXNoX3RhYmxlIChzdHJ1Y3QgaGFzaF90YWJsZV90 ZXN0IHRlc3QsCiAgIGgtPmhhc2ggPSBGbWFrZV92ZWN0b3IgKHNpemUsIFFuaWwpOwogICBoLT5u ZXh0ID0gRm1ha2VfdmVjdG9yIChzaXplLCBRbmlsKTsKICAgaC0+aW5kZXggPSBGbWFrZV92ZWN0 b3IgKG1ha2VfbnVtYmVyIChpbmRleF9zaXplKSwgUW5pbCk7CisgIGgtPnB1cmUgPSBwdXJlOwog CiAgIC8qIFNldCB1cCB0aGUgZnJlZSBsaXN0LiAgKi8KICAgZm9yIChpID0gMDsgaSA8IHN6IC0g MTsgKytpKQpAQCAtNDQ2MCwxMCArNDQ2OSwxNCBAQCBrZXksIHZhbHVlLCBvbmUgb2Yga2V5IG9y IHZhbHVlLCBvciBib3RoIGtleSBhbmQgdmFsdWUsIGRlcGVuZGluZyBvbgogV0VBSy4gIFdFQUsg dCBpcyBlcXVpdmFsZW50IHRvIGBrZXktYW5kLXZhbHVlJy4gIERlZmF1bHQgdmFsdWUgb2YgV0VB SwogaXMgbmlsLgogCis6cHVyZWNvcHkgUFVSRUNPUFkgLS0gSWYgUFVSRUNPUFkgaXMgbm9uLW5p bCwgdGhlIHRhYmxlIGNhbiBiZSBjb3BpZWQKK3RvIHB1cmUgc3RvcmFnZSB3aGVuIEVtYWNzIGlz IGJlaW5nIGR1bXBlZCwgbWFraW5nIHRoZSBjb250ZW50cyBvZiB0aGUKK3RhYmxlIHJlYWQgb25s eS4gV0VBSyBzaG91bGQgYmUgbmlsIGZvciBzdWNoIHRhYmxlcy4KKwogdXNhZ2U6IChtYWtlLWhh c2gtdGFibGUgJnJlc3QgS0VZV09SRC1BUkdTKSAgKi8pCiAgIChwdHJkaWZmX3QgbmFyZ3MsIExp c3BfT2JqZWN0ICphcmdzKQogewotICBMaXNwX09iamVjdCB0ZXN0LCBzaXplLCByZWhhc2hfc2l6 ZSwgcmVoYXNoX3RocmVzaG9sZCwgd2VhazsKKyAgTGlzcF9PYmplY3QgdGVzdCwgc2l6ZSwgcmVo YXNoX3NpemUsIHJlaGFzaF90aHJlc2hvbGQsIHdlYWssIHB1cmU7CiAgIHN0cnVjdCBoYXNoX3Rh YmxlX3Rlc3QgdGVzdGRlc2M7CiAgIHB0cmRpZmZfdCBpOwogICBVU0VfU0FGRV9BTExPQ0E7CkBA IC00NDk3LDYgKzQ1MTAsOSBAQCB1c2FnZTogKG1ha2UtaGFzaC10YWJsZSAmcmVzdCBLRVlXT1JE LUFSR1MpICAqLykKICAgICAgIHRlc3RkZXNjLmNtcGZuID0gY21wZm5fdXNlcl9kZWZpbmVkOwog ICAgIH0KIAorICAvKiBTZWUgaWYgdGhlcmUncyBhIGA6cHVyZWNvcHkgUFVSRUNPUFknIGFyZ3Vt ZW50LiAgKi8KKyAgaSA9IGdldF9rZXlfYXJnIChRQ3B1cmVjb3B5LCBuYXJncywgYXJncywgdXNl ZCk7CisgIHB1cmUgPSBpID8gYXJnc1tpXSA6IFFuaWw7CiAgIC8qIFNlZSBpZiB0aGVyZSdzIGEg YDpzaXplIFNJWkUnIGFyZ3VtZW50LiAgKi8KICAgaSA9IGdldF9rZXlfYXJnIChRQ3NpemUsIG5h cmdzLCBhcmdzLCB1c2VkKTsKICAgc2l6ZSA9IGkgPyBhcmdzW2ldIDogUW5pbDsKQEAgLTQ1Mzgs NyArNDU1NCw4IEBAIHVzYWdlOiAobWFrZS1oYXNoLXRhYmxlICZyZXN0IEtFWVdPUkQtQVJHUykg ICovKQogICAgICAgc2lnbmFsX2Vycm9yICgiSW52YWxpZCBhcmd1bWVudCBsaXN0IiwgYXJnc1tp XSk7CiAKICAgU0FGRV9GUkVFICgpOwotICByZXR1cm4gbWFrZV9oYXNoX3RhYmxlICh0ZXN0ZGVz Yywgc2l6ZSwgcmVoYXNoX3NpemUsIHJlaGFzaF90aHJlc2hvbGQsIHdlYWspOworICByZXR1cm4g bWFrZV9oYXNoX3RhYmxlICh0ZXN0ZGVzYywgc2l6ZSwgcmVoYXNoX3NpemUsIHJlaGFzaF90aHJl c2hvbGQsIHdlYWssCisgICAgICAgICAgICAgICAgICAgICAgICAgIHB1cmUpOwogfQogCiAKQEAg LTQ2MTcsNyArNDYzNCw5IEBAIERFRlVOICgiY2xyaGFzaCIsIEZjbHJoYXNoLCBTY2xyaGFzaCwg MSwgMSwgMCwKICAgICAgICBkb2M6IC8qIENsZWFyIGhhc2ggdGFibGUgVEFCTEUgYW5kIHJldHVy biBpdC4gICovKQogICAoTGlzcF9PYmplY3QgdGFibGUpCiB7Ci0gIGhhc2hfY2xlYXIgKGNoZWNr X2hhc2hfdGFibGUgKHRhYmxlKSk7CisgIHN0cnVjdCBMaXNwX0hhc2hfVGFibGUgKmggPSBjaGVj a19oYXNoX3RhYmxlICh0YWJsZSk7CisgIENIRUNLX0lNUFVSRSAodGFibGUsIGgpOworICBoYXNo X2NsZWFyIChoKTsKICAgLyogQmUgY29tcGF0aWJsZSB3aXRoIFhFbWFjcy4gICovCiAgIHJldHVy biB0YWJsZTsKIH0KQEAgLTQ2NDEsOSArNDY2MCwxMCBAQCBWQUxVRS4gIEluIGFueSBjYXNlLCBy ZXR1cm4gVkFMVUUuICAqLykKICAgKExpc3BfT2JqZWN0IGtleSwgTGlzcF9PYmplY3QgdmFsdWUs IExpc3BfT2JqZWN0IHRhYmxlKQogewogICBzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICpoID0gY2hl Y2tfaGFzaF90YWJsZSAodGFibGUpOworICBDSEVDS19JTVBVUkUgKHRhYmxlLCBoKTsKKwogICBw dHJkaWZmX3QgaTsKICAgRU1BQ1NfVUlOVCBoYXNoOwotCiAgIGkgPSBoYXNoX2xvb2t1cCAoaCwg a2V5LCAmaGFzaCk7CiAgIGlmIChpID49IDApCiAgICAgc2V0X2hhc2hfdmFsdWVfc2xvdCAoaCwg aSwgdmFsdWUpOwpAQCAtNDY1OSw2ICs0Njc5LDcgQEAgREVGVU4gKCJyZW1oYXNoIiwgRnJlbWhh c2gsIFNyZW1oYXNoLCAyLCAyLCAwLAogICAoTGlzcF9PYmplY3Qga2V5LCBMaXNwX09iamVjdCB0 YWJsZSkKIHsKICAgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCA9IGNoZWNrX2hhc2hfdGFibGUg KHRhYmxlKTsKKyAgQ0hFQ0tfSU1QVVJFICh0YWJsZSwgaCk7CiAgIGhhc2hfcmVtb3ZlX2Zyb21f dGFibGUgKGgsIGtleSk7CiAgIHJldHVybiBRbmlsOwogfQpAQCAtNTAyOSw2ICs1MDUwLDcgQEAg c3ltc19vZl9mbnMgKHZvaWQpCiAgIERFRlNZTSAoUWVxdWFsLCAiZXF1YWwiKTsKICAgREVGU1lN IChRQ3Rlc3QsICI6dGVzdCIpOwogICBERUZTWU0gKFFDc2l6ZSwgIjpzaXplIik7CisgIERFRlNZ TSAoUUNwdXJlY29weSwgIjpwdXJlY29weSIpOwogICBERUZTWU0gKFFDcmVoYXNoX3NpemUsICI6 cmVoYXNoLXNpemUiKTsKICAgREVGU1lNIChRQ3JlaGFzaF90aHJlc2hvbGQsICI6cmVoYXNoLXRo cmVzaG9sZCIpOwogICBERUZTWU0gKFFDd2Vha25lc3MsICI6d2Vha25lc3MiKTsKZGlmZiAtLWdp dCBhL3NyYy9pbWFnZS5jIGIvc3JjL2ltYWdlLmMKaW5kZXggMzk2NzdkMmFkZC4uYWQwMTQzYmU0 OCAxMDA2NDQKLS0tIGEvc3JjL2ltYWdlLmMKKysrIGIvc3JjL2ltYWdlLmMKQEAgLTQwMjAsNyAr NDAyMCw3IEBAIHhwbV9tYWtlX2NvbG9yX3RhYmxlX2ggKHZvaWQgKCoqcHV0X2Z1bmMpIChMaXNw X09iamVjdCwgY29uc3QgY2hhciAqLCBpbnQsCiAgIHJldHVybiBtYWtlX2hhc2hfdGFibGUgKGhh c2h0ZXN0X2VxdWFsLCBtYWtlX251bWJlciAoREVGQVVMVF9IQVNIX1NJWkUpLAogCQkJICBtYWtl X2Zsb2F0IChERUZBVUxUX1JFSEFTSF9TSVpFKSwKIAkJCSAgbWFrZV9mbG9hdCAoREVGQVVMVF9S RUhBU0hfVEhSRVNIT0xEKSwKLQkJCSAgUW5pbCk7CisJCQkgIFFuaWwsIFFuaWwpOwogfQogCiBz dGF0aWMgdm9pZApkaWZmIC0tZ2l0IGEvc3JjL2xpc3AuaCBiL3NyYy9saXNwLmgKaW5kZXggODRk NTNiYjFlZS4uOTFjNDMwZmU5OCAxMDA2NDQKLS0tIGEvc3JjL2xpc3AuaAorKysgYi9zcmMvbGlz cC5oCkBAIC0xOTk1LDYgKzE5OTUsMTAgQEAgc3RydWN0IExpc3BfSGFzaF9UYWJsZQogICAgICBo YXNoIHRhYmxlIHNpemUgdG8gcmVkdWNlIGNvbGxpc2lvbnMuICAqLwogICBMaXNwX09iamVjdCBp bmRleDsKIAorICAvKiBOb24tbmlsIGlmIHRoZSB0YWJsZSBjYW4gYmUgcHVyZWNvcGllZC4gQW55 IGNoYW5nZXMgdGhlIHRhYmxlIGFmdGVyCisgICAgIHB1cmVjb3B5IHdpbGwgcmVzdWx0IGluIGFu IGVycm9yLiAgKi8KKyAgTGlzcF9PYmplY3QgcHVyZTsKKwogICAvKiBPbmx5IHRoZSBmaWVsZHMg YWJvdmUgYXJlIHRyYWNlZCBub3JtYWxseSBieSB0aGUgR0MuICBUaGUgb25lcyBiZWxvdwogICAg ICBgY291bnQnIGFyZSBzcGVjaWFsIGFuZCBhcmUgZWl0aGVyIGlnbm9yZWQgYnkgdGhlIEdDIG9y IHRyYWNlZCBpbgogICAgICBhIHNwZWNpYWwgd2F5IChlLmcuIGJlY2F1c2Ugb2Ygd2Vha25lc3Mp LiAgKi8KQEAgLTMzNjQsNyArMzM2OCw3IEBAIGV4dGVybiB2b2lkIHN3ZWVwX3dlYWtfaGFzaF90 YWJsZXMgKHZvaWQpOwogRU1BQ1NfVUlOVCBoYXNoX3N0cmluZyAoY2hhciBjb25zdCAqLCBwdHJk aWZmX3QpOwogRU1BQ1NfVUlOVCBzeGhhc2ggKExpc3BfT2JqZWN0LCBpbnQpOwogTGlzcF9PYmpl Y3QgbWFrZV9oYXNoX3RhYmxlIChzdHJ1Y3QgaGFzaF90YWJsZV90ZXN0LCBMaXNwX09iamVjdCwg TGlzcF9PYmplY3QsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgIExpc3BfT2JqZWN0LCBM aXNwX09iamVjdCk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExpc3BfT2JqZWN0LCBM aXNwX09iamVjdCwgTGlzcF9PYmplY3QpOwogcHRyZGlmZl90IGhhc2hfbG9va3VwIChzdHJ1Y3Qg TGlzcF9IYXNoX1RhYmxlICosIExpc3BfT2JqZWN0LCBFTUFDU19VSU5UICopOwogcHRyZGlmZl90 IGhhc2hfcHV0IChzdHJ1Y3QgTGlzcF9IYXNoX1RhYmxlICosIExpc3BfT2JqZWN0LCBMaXNwX09i amVjdCwKIAkJICAgIEVNQUNTX1VJTlQpOwpkaWZmIC0tZ2l0IGEvc3JjL2xyZWFkLmMgYi9zcmMv bHJlYWQuYwppbmRleCBlYTJhMWQxZDg1Li4xNzgwNjkyMmE4IDEwMDY0NAotLS0gYS9zcmMvbHJl YWQuYworKysgYi9zcmMvbHJlYWQuYwpAQCAtMjU5OSw3ICsyNTk5LDcgQEAgcmVhZDEgKExpc3Bf T2JqZWN0IHJlYWRjaGFyZnVuLCBpbnQgKnBjaCwgYm9vbCBmaXJzdF9pbl9saXN0KQogCSAgICAg IExpc3BfT2JqZWN0IHZhbCA9IFFuaWw7CiAJICAgICAgLyogVGhlIHNpemUgaXMgMiAqIG51bWJl ciBvZiBhbGxvd2VkIGtleXdvcmRzIHRvCiAJCSBtYWtlLWhhc2gtdGFibGUuICAqLwotCSAgICAg IExpc3BfT2JqZWN0IHBhcmFtc1sxMF07CisJICAgICAgTGlzcF9PYmplY3QgcGFyYW1zWzEyXTsK IAkgICAgICBMaXNwX09iamVjdCBodDsKIAkgICAgICBMaXNwX09iamVjdCBrZXkgPSBRbmlsOwog CSAgICAgIGludCBwYXJhbV9jb3VudCA9IDA7CkBAIC0yNjM2LDYgKzI2MzYsMTEgQEAgcmVhZDEg KExpc3BfT2JqZWN0IHJlYWRjaGFyZnVuLCBpbnQgKnBjaCwgYm9vbCBmaXJzdF9pbl9saXN0KQog CSAgICAgIGlmICghTklMUCAocGFyYW1zW3BhcmFtX2NvdW50ICsgMV0pKQogCQlwYXJhbV9jb3Vu dCArPSAyOwogCisgICAgICAgICAgICAgIHBhcmFtc1twYXJhbV9jb3VudF0gPSBRQ3B1cmVjb3B5 OworICAgICAgICAgICAgICBwYXJhbXNbcGFyYW1fY291bnQgKyAxXSA9IEZwbGlzdF9nZXQgKHRt cCwgUXB1cmVjb3B5KTsKKyAgICAgICAgICAgICAgaWYgKCFOSUxQIChwYXJhbXNbcGFyYW1fY291 bnQgKyAxXSkpCisgICAgICAgICAgICAgICAgcGFyYW1fY291bnQgKz0gMjsKKwogCSAgICAgIC8q IFRoaXMgaXMgdGhlIGhhc2ggdGFibGUgZGF0YS4gICovCiAJICAgICAgZGF0YSA9IEZwbGlzdF9n ZXQgKHRtcCwgUWRhdGEpOwogCkBAIC00ODQ5LDYgKzQ4NTQsNyBAQCB0aGF0IGFyZSBsb2FkZWQg YmVmb3JlIHlvdXIgY3VzdG9taXphdGlvbnMgYXJlIHJlYWQhICAqLyk7CiAgIERFRlNZTSAoUWRh dGEsICJkYXRhIik7CiAgIERFRlNZTSAoUXRlc3QsICJ0ZXN0Iik7CiAgIERFRlNZTSAoUXNpemUs ICJzaXplIik7CisgIERFRlNZTSAoUXB1cmVjb3B5LCAicHVyZWNvcHkiKTsKICAgREVGU1lNIChR d2Vha25lc3MsICJ3ZWFrbmVzcyIpOwogICBERUZTWU0gKFFyZWhhc2hfc2l6ZSwgInJlaGFzaC1z aXplIik7CiAgIERFRlNZTSAoUXJlaGFzaF90aHJlc2hvbGQsICJyZWhhc2gtdGhyZXNob2xkIik7 CmRpZmYgLS1naXQgYS9zcmMvcHJpbnQuYyBiL3NyYy9wcmludC5jCmluZGV4IDM2ZDY4YTQ1MmUu LmRiM2QwMGY1MWYgMTAwNjQ0Ci0tLSBhL3NyYy9wcmludC5jCisrKyBiL3NyYy9wcmludC5jCkBA IC0xODE4LDYgKzE4MTgsMTIgQEAgcHJpbnRfb2JqZWN0IChMaXNwX09iamVjdCBvYmosIExpc3Bf T2JqZWN0IHByaW50Y2hhcmZ1biwgYm9vbCBlc2NhcGVmbGFnKQogCSAgICAgIHByaW50X29iamVj dCAoaC0+cmVoYXNoX3RocmVzaG9sZCwgcHJpbnRjaGFyZnVuLCBlc2NhcGVmbGFnKTsKIAkgICAg fQogCisgICAgICAgICAgaWYgKCFOSUxQIChoLT5wdXJlKSkKKyAgICAgICAgICAgIHsKKyAgICAg ICAgICAgICAgcHJpbnRfY19zdHJpbmcgKCIgcHVyZWNvcHkgIiwgcHJpbnRjaGFyZnVuKTsKKwkg ICAgICBwcmludF9vYmplY3QgKGgtPnB1cmUsIHByaW50Y2hhcmZ1biwgZXNjYXBlZmxhZyk7Cisg ICAgICAgICAgICB9CisKIAkgIHByaW50X2Nfc3RyaW5nICgiIGRhdGEgIiwgcHJpbnRjaGFyZnVu KTsKIAogCSAgLyogUHJpbnQgdGhlIGRhdGEgaGVyZSBhcyBhIHBsaXN0LiAqLwpkaWZmIC0tZ2l0 IGEvc3JjL3Byb2ZpbGVyLmMgYi9zcmMvcHJvZmlsZXIuYwppbmRleCA4ODgyNWJlYmRiLi5hMjIz YTdlN2MwIDEwMDY0NAotLS0gYS9zcmMvcHJvZmlsZXIuYworKysgYi9zcmMvcHJvZmlsZXIuYwpA QCAtNDgsNyArNDgsNyBAQCBtYWtlX2xvZyAoRU1BQ1NfSU5UIGhlYXBfc2l6ZSwgRU1BQ1NfSU5U IG1heF9zdGFja19kZXB0aCkKIAkJCQkgICAgIG1ha2VfbnVtYmVyIChoZWFwX3NpemUpLAogCQkJ CSAgICAgbWFrZV9mbG9hdCAoREVGQVVMVF9SRUhBU0hfU0laRSksCiAJCQkJICAgICBtYWtlX2Zs b2F0IChERUZBVUxUX1JFSEFTSF9USFJFU0hPTEQpLAotCQkJCSAgICAgUW5pbCk7CisJCQkJICAg ICBRbmlsLCBRbmlsKTsKICAgc3RydWN0IExpc3BfSGFzaF9UYWJsZSAqaCA9IFhIQVNIX1RBQkxF IChsb2cpOwogCiAgIC8qIFdoYXQgaXMgc3BlY2lhbCBhYm91dCBvdXIgaGFzaC10YWJsZXMgaXMg dGhhdCB0aGUga2V5cyBhcmUgcHJlLWZpbGxlZApkaWZmIC0tZ2l0IGEvc3JjL3h0ZXJtLmMgYi9z cmMveHRlcm0uYwppbmRleCA4MGNmOGNlMTkxLi4zODIyOWE1ZjMxIDEwMDY0NAotLS0gYS9zcmMv eHRlcm0uYworKysgYi9zcmMveHRlcm0uYwpAQCAtMTI4NzcsNyArMTI4NzcsNyBAQCBrZXlzeW1z LiAgVGhlIGRlZmF1bHQgaXMgbmlsLCB3aGljaCBpcyB0aGUgc2FtZSBhcyBgc3VwZXInLiAgKi8p OwogICBWeF9rZXlzeW1fdGFibGUgPSBtYWtlX2hhc2hfdGFibGUgKGhhc2h0ZXN0X2VxbCwgbWFr ZV9udW1iZXIgKDkwMCksCiAJCQkJICAgICBtYWtlX2Zsb2F0IChERUZBVUxUX1JFSEFTSF9TSVpF KSwKIAkJCQkgICAgIG1ha2VfZmxvYXQgKERFRkFVTFRfUkVIQVNIX1RIUkVTSE9MRCksCi0JCQkJ ICAgICBRbmlsKTsKKwkJCQkgICAgIFFuaWwsIFFuaWwpOwogCiAgIERFRlZBUl9CT09MICgieC1m cmFtZS1ub3JtYWxpemUtYmVmb3JlLW1heGltaXplIiwKIAkgICAgICAgeF9mcmFtZV9ub3JtYWxp emVfYmVmb3JlX21heGltaXplLAo= --94eb2c147b0e0ba57305473ef489--