From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 17567 invoked by alias); 4 Jun 2011 19:30:56 -0000 Received: (qmail 17557 invoked by uid 22791); 4 Jun 2011 19:30:51 -0000 X-SWARE-Spam-Status: No, hits=-0.8 required=5.0 tests=AWL,BAYES_50,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,SPF_HELO_PASS,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from smtp-out.google.com (HELO smtp-out.google.com) (216.239.44.51) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sat, 04 Jun 2011 19:30:34 +0000 Received: from wpaz13.hot.corp.google.com (wpaz13.hot.corp.google.com [172.24.198.77]) by smtp-out.google.com with ESMTP id p54JUXel011581 for ; Sat, 4 Jun 2011 12:30:33 -0700 Received: from gyf2 (gyf2.prod.google.com [10.243.50.66]) by wpaz13.hot.corp.google.com with ESMTP id p54JUWbR018158 (version=TLSv1/SSLv3 cipher=RC4-SHA bits=128 verify=NOT) for ; Sat, 4 Jun 2011 12:30:32 -0700 Received: by gyf2 with SMTP id 2so1568187gyf.25 for ; Sat, 04 Jun 2011 12:30:31 -0700 (PDT) MIME-Version: 1.0 Received: by 10.150.13.13 with SMTP id 13mr3213840ybm.241.1307215830822; Sat, 04 Jun 2011 12:30:30 -0700 (PDT) Received: by 10.151.41.13 with HTTP; Sat, 4 Jun 2011 12:30:30 -0700 (PDT) In-Reply-To: References: <20110601001232.CCD681DA1C9@topo.tor.corp.google.com> Date: Sat, 04 Jun 2011 19:30:00 -0000 Message-ID: Subject: Re: [lto] Merge streamer hooks from pph branch. (issue4568043) From: Diego Novillo To: Richard Guenther Cc: reply@codereview.appspotmail.com, Jan Hubicka , gcc-patches@gcc.gnu.org Content-Type: multipart/mixed; boundary=000e0cdf19ce3db17704a4e7e7d2 X-System-Of-Record: true X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org X-SW-Source: 2011-06/txt/msg00320.txt.bz2 --000e0cdf19ce3db17704a4e7e7d2 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Content-length: 9127 On Wed, Jun 1, 2011 at 15:19, Richard Guenther wrote: > Yes, I see no benefit of using a global function to get access > to the address of a global variable. There is the minor benefit of being able to control access to it, but I don't have a really convincing reason to give you, so I changed it to a global. >> >> + =C2=A0 =C2=A0 if (h->indexable_with_decls_p && h->indexable_with_de= cls_p (expr)) >> >> + =C2=A0 =C2=A0 =C2=A0 { >> >> + =C2=A0 =C2=A0 =C2=A0 =C2=A0 output_record_start (ob, LTO_global_dec= l_ref); >> >> + =C2=A0 =C2=A0 =C2=A0 =C2=A0 lto_output_var_decl_index (ob->decl_sta= te, ob->main_stream, expr); >> > >> > Why hook it this way and not >> > >> > =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 if (h->output_tree_ref >> > =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 && h->output_t= ree_ref (...)) >> > =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 break; >> > =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 gcc_unreachable (); >> > >> > I find the flag vs. function hook stuff somewhat odd. >> >> Sure. =C2=A0It's > > ... missing words? ;) Sorry. I meant to continue with "It's just that this particular hook is simpler if it only needs to decide whether the node can be written as a decl reference. The code to write the node will be the same everywhere." It would lead to duplication and the hooks would need to know more internal details of the generic streamer (they need to write the reference in exactly the way that lto_input_tree is expecting). This is not a flag, actually. It's a predicate function called on a node. If the node passes the predicate, then it is written in the decl index table. >> >> @@ -1438,8 +1450,27 @@ lto_output_tree (struct output_block *ob, tree= expr, bool ref_p) >> >> =C2=A0 =C2=A0 =C2=A0 to be materialized by the reader (to implement T= YPE_CACHED_VALUES). =C2=A0*/ >> >> =C2=A0 =C2=A0if (TREE_CODE (expr) =3D=3D INTEGER_CST) >> >> =C2=A0 =C2=A0 =C2=A0{ >> >> - =C2=A0 =C2=A0 =C2=A0lto_output_integer_cst (ob, expr, ref_p); >> >> - =C2=A0 =C2=A0 =C2=A0return; >> >> + =C2=A0 =C2=A0 =C2=A0bool is_special; >> >> + >> >> + =C2=A0 =C2=A0 /* There are some constants that are special to the s= treamer >> >> + =C2=A0 =C2=A0 (e.g., void_zero_node, truthvalue_false_node). >> >> + =C2=A0 =C2=A0 These constants cannot be rematerialized with >> >> + =C2=A0 =C2=A0 build_int_cst_wide because they may actually lack a t= ype (like >> >> + =C2=A0 =C2=A0 void_zero_node) and they need to be pointer-identical= to trees >> >> + =C2=A0 =C2=A0 materialized by the compiler tables like global_trees= or >> >> + =C2=A0 =C2=A0 c_global_trees. >> >> + >> >> + =C2=A0 =C2=A0 If the streamer told us that it has special constants= , they >> >> + =C2=A0 =C2=A0 will be preloaded in the streamer cache. =C2=A0If we = find a match, >> >> + =C2=A0 =C2=A0 then stream the constant as a reference so the reader= can >> >> + =C2=A0 =C2=A0 re-materialize it from the cache. =C2=A0*/ >> >> + =C2=A0 =C2=A0 =C2=A0is_special =3D streamer_hooks ()->has_unique_in= teger_csts_p >> >> + =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0&& lto_strea= mer_cache_lookup (ob->writer_cache, expr, NULL); >> >> + =C2=A0 =C2=A0 =C2=A0if (!is_special) >> >> + =C2=A0 =C2=A0 { >> >> + =C2=A0 =C2=A0 =C2=A0 lto_output_integer_cst (ob, expr, ref_p); >> >> + =C2=A0 =C2=A0 =C2=A0 return; >> >> + =C2=A0 =C2=A0 } >> > >> > ??? =C2=A0We should not arrive here for such global trees. =C2=A0Pleas= e do not >> > merge this part of the patch as part of the hook introducing (keep >> > patches simple, make them do a single thing ...) >> >> Not sure what you are objecting to. =C2=A0We do execute this for global >> trees in the C++ FE (as described in the comment). =C2=A0Are you objecti= ng >> to never handling unique constants or to merging this handling until >> the pph bits are in? > > Are you not pre-loading those global trees then? I am, but since the streamer always wanted to stream INTEGER_CSTs separately, it wasn't getting a chance to check the cache first. > Yes, I think this isn't the time to merge this piece. No problem. I'll keep this part in the branch. >=C2=A0Ah, I think I get it - we don't stream integer constants as trees. Right. > But it's odd that you only handle this > for integer-csts and not other trees we don't stream as-is (and > thus do not enter into the cache) Because constants are the only ones that are handled right before the cache is consulted. Every other pre-built tree can be cached (regardless of whether it's handled by the streamer). > - I think this should be moved up a level and made generic to handle all = trees. =C2=A0Or we should > handle integer-csts similar to builtins - always enter them in the cache, I tried this, but the result was sub-optimal (http://gcc.gnu.org/ml/gcc-patches/2011-05/msg00563.html) Putting constants in the cache, caused various failures which I never fully debugged because I noticed an increase in the object size (I remember it was noticeable, but not by how much). I didn't insist too much with this approach, so maybe I could try it again. > or only handle all pre-loaded nodes that way. That is what we do. Pre-loaded nodes always go through the cache. The problem were pre-loaded constants, since they *never* go through the cache. >> >> @@ -2238,6 +2269,8 @@ static void >> >> =C2=A0lto_writer_init (void) >> >> =C2=A0{ >> >> =C2=A0 =C2=A0lto_streamer_init (); >> >> + =C2=A0if (streamer_hooks ()->writer_init) >> >> + =C2=A0 =C2=A0streamer_hooks ()->writer_init (); >> > >> > This hook should always exist. =C2=A0Why is this called in a context w= ith >> > lto_*? >> >> There is common streaming code that both the gimple and c++ streamers >> use. =C2=A0I suppose both could call lto_streamer_init and then call the= ir >> own initializer routines instead of doing a hook. > > Yeah, I'd prefer that. =C2=A0I don't have a clear picture yet on what > piece of the streamer is actually shared. Sure. Done. >> >> + >> >> +/* Initialize all the streamer hooks used for streaming GIMPLE. =C2= =A0*/ >> >> + >> >> +void >> >> +gimple_streamer_hooks_init (void) >> > >> > It's more like lto_streamer_hooks_init, no? =C2=A0You are basically >> > turning lto_streamer_* to tree_streamer_* and make lto_streamer_* >> > tree_streamer_* + lto_streamer_hooks, no? >> >> I was about to call them gimple_streamer_hooks, but lto_streamer_hooks >> is also fine with me. =C2=A0Subsequent patch. =C2=A0So: >> >> 1- Call the generic implementation and streamer hooks tree_streamer_* >> 2- Rename the lto-specific parts of streaming to lto_streamer_* >> 3- Move generic streaming implementation to tree-streamer.[ch] >> >> Does that sound OK? > > That sounds ok. =C2=A0You are only sharing the code streaming trees, righ= t? Right. Patch coming up on top of the revised patch for streamer hooks. The attached revision of the patch has been tested again with an LTO profiledbootstrap on x86_64. OK for trunk? * Makefile.in (lto-compress.o): Add dependency on LTO_STREAMER_H. (cgraph.o): Likewise. (cgraphunit.o): Likewise. * cgraphunit.c: Include lto-streamer.h (cgraph_finalize_compilation_unit): Call lto_streamer_hooks_init if LTO is enabled. * lto-streamer-in.c (unpack_value_fields): Call streamer_hooks.unpack_value_fields if set. (lto_materialize_tree): For unhandled nodes, first try to call lto_streamer_hooks.alloc_tree, if it exists. (lto_input_ts_decl_common_tree_pointers): Move reading of DECL_INITIAL to lto_streamer_read_tree. (lto_read_tree): Call lto_streamer_hooks.read_tree if set. (lto_streamer_read_tree): New. (lto_reader_init): Rename from lto_init_reader. Move initialization code to lto/lto.c. * lto-streamer-out.c (pack_value_fields): Call streamer_hooks.pack_value_fields if set. (lto_output_tree_ref): For tree nodes that are not normally indexable, call streamer_hooks.indexable_with_decls_p before giving up. (lto_output_ts_decl_common_tree_pointers): Move handling for FUNCTION_DECL and TRANSLATION_UNIT_DECL to lto_streamer_write_tree. (lto_output_tree_header): Call streamer_hooks.is_streamable instead of lto_is_streamable. Call lto_streamer_hooks.output_tree_header if set. (lto_write_tree): Call lto_streamer_hooks.write_tree if set. (lto_streamer_write_tree): New. (lto_output): Call lto_streamer_init directly. (lto_writer_init): Remove. * lto-streamer.c (streamer_hooks): New. (lto_streamer_cache_create): Call streamer_hooks.preload_common_nodes instead of lto_preload_common_nodes. (lto_is_streamable): Move from lto-streamer.h (lto_streamer_hooks_init): New. (streamer_hooks): New. (streamer_hooks_init): New. * lto-streamer.h (struct output_block): Forward declare. (struct lto_input_block): Likewise. (struct data_in): Likewise. (struct bitpack_d): Likewise. (struct streamer_hooks): Declare. (streamer_hooks): Declare. (lto_streamer_hooks_init): Declare. (lto_streamer_write_tree): Declare. (lto_streamer_read_tree): Declare. (streamer_hooks_init): Declare. (lto_is_streamable): Move to lto-streamer.c lto/ChangeLog * lto.c (lto_init): New. (lto_main): Call it. Diego. --000e0cdf19ce3db17704a4e7e7d2 Content-Type: text/x-patch; charset=US-ASCII; name="00.diff" Content-Disposition: attachment; filename="00.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_goiyizjn0 Content-length: 32086 MjAxMS0wNi0wNCAgRGllZ28gTm92aWxsbyAgPGRub3ZpbGxvQGdvb2dsZS5j b20+CgoJKiBNYWtlZmlsZS5pbiAobHRvLWNvbXByZXNzLm8pOiBBZGQgZGVw ZW5kZW5jeSBvbiBMVE9fU1RSRUFNRVJfSC4KCShjZ3JhcGgubyk6IExpa2V3 aXNlLgoJKGNncmFwaHVuaXQubyk6IExpa2V3aXNlLgoJKiBjZ3JhcGh1bml0 LmM6IEluY2x1ZGUgbHRvLXN0cmVhbWVyLmgKCShjZ3JhcGhfZmluYWxpemVf Y29tcGlsYXRpb25fdW5pdCk6IENhbGwgbHRvX3N0cmVhbWVyX2hvb2tzX2lu aXQKCWlmIExUTyBpcyBlbmFibGVkLgoJKiBsdG8tc3RyZWFtZXItaW4uYyAo dW5wYWNrX3ZhbHVlX2ZpZWxkcyk6IENhbGwgCglzdHJlYW1lcl9ob29rcy51 bnBhY2tfdmFsdWVfZmllbGRzIGlmIHNldC4KCShsdG9fbWF0ZXJpYWxpemVf dHJlZSk6IEZvciB1bmhhbmRsZWQgbm9kZXMsIGZpcnN0IHRyeSB0bwoJY2Fs bCBsdG9fc3RyZWFtZXJfaG9va3MuYWxsb2NfdHJlZSwgaWYgaXQgZXhpc3Rz LgoJKGx0b19pbnB1dF90c19kZWNsX2NvbW1vbl90cmVlX3BvaW50ZXJzKTog TW92ZSByZWFkaW5nIG9mCglERUNMX0lOSVRJQUwgdG8gbHRvX3N0cmVhbWVy X3JlYWRfdHJlZS4KCShsdG9fcmVhZF90cmVlKTogQ2FsbCBsdG9fc3RyZWFt ZXJfaG9va3MucmVhZF90cmVlIGlmIHNldC4KCShsdG9fc3RyZWFtZXJfcmVh ZF90cmVlKTogTmV3LgoJKGx0b19yZWFkZXJfaW5pdCk6IFJlbmFtZSBmcm9t IGx0b19pbml0X3JlYWRlci4KCU1vdmUgaW5pdGlhbGl6YXRpb24gY29kZSB0 byBsdG8vbHRvLmMuCgkqIGx0by1zdHJlYW1lci1vdXQuYyAocGFja192YWx1 ZV9maWVsZHMpOiBDYWxsCglzdHJlYW1lcl9ob29rcy5wYWNrX3ZhbHVlX2Zp ZWxkcyBpZiBzZXQuCgkobHRvX291dHB1dF90cmVlX3JlZik6IEZvciB0cmVl IG5vZGVzIHRoYXQgYXJlIG5vdAoJbm9ybWFsbHkgaW5kZXhhYmxlLCBjYWxs IHN0cmVhbWVyX2hvb2tzLmluZGV4YWJsZV93aXRoX2RlY2xzX3AKCWJlZm9y ZSBnaXZpbmcgdXAuCgkobHRvX291dHB1dF90c19kZWNsX2NvbW1vbl90cmVl X3BvaW50ZXJzKTogTW92ZSBoYW5kbGluZwoJZm9yIEZVTkNUSU9OX0RFQ0wg YW5kIFRSQU5TTEFUSU9OX1VOSVRfREVDTCB0bwoJbHRvX3N0cmVhbWVyX3dy aXRlX3RyZWUuCgkobHRvX291dHB1dF90cmVlX2hlYWRlcik6IENhbGwgc3Ry ZWFtZXJfaG9va3MuaXNfc3RyZWFtYWJsZQoJaW5zdGVhZCBvZiBsdG9faXNf c3RyZWFtYWJsZS4KCUNhbGwgbHRvX3N0cmVhbWVyX2hvb2tzLm91dHB1dF90 cmVlX2hlYWRlciBpZiBzZXQuCgkobHRvX3dyaXRlX3RyZWUpOiBDYWxsIGx0 b19zdHJlYW1lcl9ob29rcy53cml0ZV90cmVlIGlmCglzZXQuCgkobHRvX3N0 cmVhbWVyX3dyaXRlX3RyZWUpOiBOZXcuCgkobHRvX291dHB1dCk6IENhbGwg bHRvX3N0cmVhbWVyX2luaXQgZGlyZWN0bHkuCgkobHRvX3dyaXRlcl9pbml0 KTogUmVtb3ZlLgoJKiBsdG8tc3RyZWFtZXIuYyAoc3RyZWFtZXJfaG9va3Mp OiBOZXcuCgkobHRvX3N0cmVhbWVyX2NhY2hlX2NyZWF0ZSk6IENhbGwgc3Ry ZWFtZXJfaG9va3MucHJlbG9hZF9jb21tb25fbm9kZXMKCWluc3RlYWQgb2Yg bHRvX3ByZWxvYWRfY29tbW9uX25vZGVzLgoJKGx0b19pc19zdHJlYW1hYmxl KTogTW92ZSBmcm9tIGx0by1zdHJlYW1lci5oCgkobHRvX3N0cmVhbWVyX2hv b2tzX2luaXQpOiBOZXcuCgkoc3RyZWFtZXJfaG9va3MpOiBOZXcuCgkoc3Ry ZWFtZXJfaG9va3NfaW5pdCk6IE5ldy4KCSogbHRvLXN0cmVhbWVyLmggKHN0 cnVjdCBvdXRwdXRfYmxvY2spOiBGb3J3YXJkIGRlY2xhcmUuCgkoc3RydWN0 IGx0b19pbnB1dF9ibG9jayk6IExpa2V3aXNlLgoJKHN0cnVjdCBkYXRhX2lu KTogTGlrZXdpc2UuCgkoc3RydWN0IGJpdHBhY2tfZCk6IExpa2V3aXNlLgoJ KHN0cnVjdCBzdHJlYW1lcl9ob29rcyk6IERlY2xhcmUuCgkoc3RyZWFtZXJf aG9va3MpOiBEZWNsYXJlLgoJKGx0b19zdHJlYW1lcl9ob29rc19pbml0KTog RGVjbGFyZS4KCShsdG9fc3RyZWFtZXJfd3JpdGVfdHJlZSk6IERlY2xhcmUu CgkobHRvX3N0cmVhbWVyX3JlYWRfdHJlZSk6IERlY2xhcmUuCgkoc3RyZWFt ZXJfaG9va3NfaW5pdCk6IERlY2xhcmUuCgkobHRvX2lzX3N0cmVhbWFibGUp OiBNb3ZlIHRvIGx0by1zdHJlYW1lci5jCgpsdG8vQ2hhbmdlTG9nCgoJKiBs dG8uYyAobHRvX2luaXQpOiBOZXcuCgkobHRvX21haW4pOiBDYWxsIGl0LgoK ZGlmZiAtLWdpdCBhL2djYy9NYWtlZmlsZS5pbiBiL2djYy9NYWtlZmlsZS5p bgppbmRleCA4MTczNmEwLi40OTYxNzdjIDEwMDY0NAotLS0gYS9nY2MvTWFr ZWZpbGUuaW4KKysrIGIvZ2NjL01ha2VmaWxlLmluCkBAIC0yMzQ4LDcgKzIz NDgsNyBAQCBkb3VibGUtaW50Lm86IGRvdWJsZS1pbnQuYyAkKENPTkZJR19I KSAkKFNZU1RFTV9IKSBjb3JldHlwZXMuaCAkKFRNX0gpIFwKIAogIyBsdG8t Y29tcHJlc3MubyBuZWVkcyAkKFpMSUJJTkMpIGFkZGVkIHRvIHRoZSBpbmNs dWRlIGZsYWdzLgogbHRvLWNvbXByZXNzLm86IGx0by1jb21wcmVzcy5jICQo Q09ORklHX0gpICQoU1lTVEVNX0gpIGNvcmV0eXBlcy5oIFwKLQkkKFRSRUVf SCkgbGFuZ2hvb2tzLmggJChMVE9fSEVBREVSX0gpICQoTFRPX1NFQ1RJT05f SCkgXAorCSQoVFJFRV9IKSBsYW5naG9va3MuaCAkKExUT19TVFJFQU1FUl9I KSAkKExUT19TRUNUSU9OX0gpIFwKIAlsdG8tY29tcHJlc3MuaCAkKERJQUdO T1NUSUNfQ09SRV9IKSAkKERJQUdOT1NUSUNfQ09SRV9IKQogCSQoQ09NUElM RVIpIC1jICQoQUxMX0NPTVBJTEVSRkxBR1MpICQoQUxMX0NQUEZMQUdTKSAk KFpMSUJJTkMpICQ8ICQoT1VUUFVUX09QVElPTikKIApAQCAtMzAzMCwxNCAr MzAzMCwxNSBAQCBjZ3JhcGgubyA6IGNncmFwaC5jICQoQ09ORklHX0gpICQo U1lTVEVNX0gpIGNvcmV0eXBlcy5oICQoVE1fSCkgJChUUkVFX0gpIFwKICAg IGd0LWNncmFwaC5oIG91dHB1dC5oIGludGwuaCAkKEJBU0lDX0JMT0NLX0gp IGRlYnVnLmggJChIQVNIVEFCX0gpIFwKICAgICQoVFJFRV9JTkxJTkVfSCkg JChUUkVFX0RVTVBfSCkgJChUUkVFX0ZMT1dfSCkgY2lmLWNvZGUuZGVmIFwK ICAgIHZhbHVlLXByb2YuaCAkKEVYQ0VQVF9IKSAkKElQQV9VVElMU19IKSAk KERJQUdOT1NUSUNfQ09SRV9IKSBcCi0gICBpcGEtaW5saW5lLmgKKyAgIGlw YS1pbmxpbmUuaCAkKExUT19TVFJFQU1FUl9IKQogY2dyYXBodW5pdC5vIDog Y2dyYXBodW5pdC5jICQoQ09ORklHX0gpICQoU1lTVEVNX0gpIGNvcmV0eXBl cy5oICQoVE1fSCkgXAogICAgJChUUkVFX0gpIGxhbmdob29rcy5oICQoVFJF RV9JTkxJTkVfSCkgdG9wbGV2LmggJChESUFHTk9TVElDX0NPUkVfSCkgJChG TEFHU19IKSAkKEdHQ19IKSBcCiAgICAkKFRBUkdFVF9IKSAkKENHUkFQSF9I KSBpbnRsLmggcG9pbnRlci1zZXQuaCAkKEZVTkNUSU9OX0gpICQoR0lNUExF X0gpIFwKICAgICQoVFJFRV9GTE9XX0gpICQoVFJFRV9QQVNTX0gpIGRlYnVn LmggJChESUFHTk9TVElDX0gpIFwKICAgICQoRklCSEVBUF9IKSBvdXRwdXQu aCAkKFBBUkFNU19IKSAkKFJUTF9IKSAkKFRJTUVWQVJfSCkgJChJUEFfUFJP UF9IKSBcCiAgICBndC1jZ3JhcGh1bml0LmggdHJlZS1pdGVyYXRvci5oICQo Q09WRVJBR0VfSCkgJChUUkVFX0RVTVBfSCkgXAotICAgdHJlZS1wcmV0dHkt cHJpbnQuaCBnaW1wbGUtcHJldHR5LXByaW50LmggaXBhLWlubGluZS5oICQo SVBBX1VUSUxTX0gpCisgICB0cmVlLXByZXR0eS1wcmludC5oIGdpbXBsZS1w cmV0dHktcHJpbnQuaCBpcGEtaW5saW5lLmggJChJUEFfVVRJTFNfSCkgXAor ICAgJChMVE9fU1RSRUFNRVJfSCkKIGNncmFwaGJ1aWxkLm8gOiBjZ3JhcGhi dWlsZC5jICQoQ09ORklHX0gpICQoU1lTVEVNX0gpIGNvcmV0eXBlcy5oICQo VE1fSCkgXAogICAgJChUUkVFX0gpIGxhbmdob29rcy5oICQoQ0dSQVBIX0gp IGludGwuaCBwb2ludGVyLXNldC5oICQoR0lNUExFX0gpIFwKICAgICQoVFJF RV9GTE9XX0gpICQoVFJFRV9QQVNTX0gpICQoSVBBX1VUSUxTX0gpICQoRVhD RVBUX0gpIFwKZGlmZiAtLWdpdCBhL2djYy9jZ3JhcGh1bml0LmMgYi9nY2Mv Y2dyYXBodW5pdC5jCmluZGV4IDgzNGFjYjEuLjYxNGI3ODUgMTAwNjQ0Ci0t LSBhL2djYy9jZ3JhcGh1bml0LmMKKysrIGIvZ2NjL2NncmFwaHVuaXQuYwpA QCAtMTQwLDYgKzE0MCw3IEBAIGFsb25nIHdpdGggR0NDOyBzZWUgdGhlIGZp bGUgQ09QWUlORzMuICBJZiBub3Qgc2VlCiAjaW5jbHVkZSAicGx1Z2luLmgi CiAjaW5jbHVkZSAiaXBhLWlubGluZS5oIgogI2luY2x1ZGUgImlwYS11dGls cy5oIgorI2luY2x1ZGUgImx0by1zdHJlYW1lci5oIgogCiBzdGF0aWMgdm9p ZCBjZ3JhcGhfZXhwYW5kX2FsbF9mdW5jdGlvbnMgKHZvaWQpOwogc3RhdGlj IHZvaWQgY2dyYXBoX21hcmtfZnVuY3Rpb25zX3RvX291dHB1dCAodm9pZCk7 CkBAIC0xMDkyLDYgKzEwOTMsMTAgQEAgY2dyYXBoX2ZpbmFsaXplX2NvbXBp bGF0aW9uX3VuaXQgKHZvaWQpCiB7CiAgIHRpbWV2YXJfcHVzaCAoVFZfQ0dS QVBIKTsKIAorICAvKiBJZiBMVE8gaXMgZW5hYmxlZCwgaW5pdGlhbGl6ZSB0 aGUgc3RyZWFtZXIgaG9va3MgbmVlZGVkIGJ5IEdJTVBMRS4gICovCisgIGlm IChmbGFnX2x0bykKKyAgICBsdG9fc3RyZWFtZXJfaG9va3NfaW5pdCAoKTsK KwogICAvKiBJZiB3ZSdyZSBoZXJlIHRoZXJlJ3Mgbm8gY3VycmVudCBmdW5j dGlvbiBhbnltb3JlLiAgU29tZSBmcm9udGVuZHMKICAgICAgYXJlIGxhenkg aW4gY2xlYXJpbmcgdGhlc2UuICAqLwogICBjdXJyZW50X2Z1bmN0aW9uX2Rl Y2wgPSBOVUxMOwpkaWZmIC0tZ2l0IGEvZ2NjL2x0by1zdHJlYW1lci1pbi5j IGIvZ2NjL2x0by1zdHJlYW1lci1pbi5jCmluZGV4IDNhNWViNWEuLjI1Y2Ni MjQgMTAwNjQ0Ci0tLSBhL2djYy9sdG8tc3RyZWFtZXItaW4uYworKysgYi9n Y2MvbHRvLXN0cmVhbWVyLWluLmMKQEAgLTE4NDEsNiArMTg0MSw5IEBAIHVu cGFja192YWx1ZV9maWVsZHMgKHN0cnVjdCBiaXRwYWNrX2QgKmJwLCB0cmVl IGV4cHIpCiAKICAgaWYgKENPREVfQ09OVEFJTlNfU1RSVUNUIChjb2RlLCBU U19UUkFOU0xBVElPTl9VTklUX0RFQ0wpKQogICAgIHVucGFja190c190cmFu c2xhdGlvbl91bml0X2RlY2xfdmFsdWVfZmllbGRzIChicCwgZXhwcik7CisK KyAgaWYgKHN0cmVhbWVyX2hvb2tzLnVucGFja192YWx1ZV9maWVsZHMpCisg ICAgc3RyZWFtZXJfaG9va3MudW5wYWNrX3ZhbHVlX2ZpZWxkcyAoYnAsIGV4 cHIpOwogfQogCiAKQEAgLTE4OTIsOCArMTg5NSwxNSBAQCBsdG9fbWF0ZXJp YWxpemVfdHJlZSAoc3RydWN0IGx0b19pbnB1dF9ibG9jayAqaWIsIHN0cnVj dCBkYXRhX2luICpkYXRhX2luLAogICAgIH0KICAgZWxzZQogICAgIHsKLSAg ICAgIC8qIEFsbCBvdGhlciBub2RlcyBjYW4gYmUgbWF0ZXJpYWxpemVkIHdp dGggYSByYXcgbWFrZV9ub2RlIGNhbGwuICAqLwotICAgICAgcmVzdWx0ID0g bWFrZV9ub2RlIChjb2RlKTsKKyAgICAgIC8qIEZvciBhbGwgb3RoZXIgbm9k ZXMsIHNlZSBpZiB0aGUgc3RyZWFtZXIga25vd3MgaG93IHRvIGFsbG9jYXRl CisJIGl0LiAgKi8KKyAgICAgIGlmIChzdHJlYW1lcl9ob29rcy5hbGxvY190 cmVlKQorCXJlc3VsdCA9IHN0cmVhbWVyX2hvb2tzLmFsbG9jX3RyZWUgKGNv ZGUsIGliLCBkYXRhX2luKTsKKworICAgICAgLyogSWYgdGhlIGhvb2sgZGlk IG5vdCBoYW5kbGUgaXQsIG1hdGVyaWFsaXplIHRoZSB0cmVlIHdpdGggYSBy YXcKKwkgbWFrZV9ub2RlIGNhbGwuICAqLworICAgICAgaWYgKHJlc3VsdCA9 PSBOVUxMX1RSRUUpCisJcmVzdWx0ID0gbWFrZV9ub2RlIChjb2RlKTsKICAg ICB9CiAKICNpZmRlZiBMVE9fU1RSRUFNRVJfREVCVUcKQEAgLTE5ODgsMTIg KzE5OTgsOCBAQCBsdG9faW5wdXRfdHNfZGVjbF9jb21tb25fdHJlZV9wb2lu dGVycyAoc3RydWN0IGx0b19pbnB1dF9ibG9jayAqaWIsCiB7CiAgIERFQ0xf U0laRSAoZXhwcikgPSBsdG9faW5wdXRfdHJlZSAoaWIsIGRhdGFfaW4pOwog ICBERUNMX1NJWkVfVU5JVCAoZXhwcikgPSBsdG9faW5wdXRfdHJlZSAoaWIs IGRhdGFfaW4pOwotCi0gIGlmIChUUkVFX0NPREUgKGV4cHIpICE9IEZVTkNU SU9OX0RFQ0wKLSAgICAgICYmIFRSRUVfQ09ERSAoZXhwcikgIT0gVFJBTlNM QVRJT05fVU5JVF9ERUNMKQotICAgIERFQ0xfSU5JVElBTCAoZXhwcikgPSBs dG9faW5wdXRfdHJlZSAoaWIsIGRhdGFfaW4pOwotCiAgIERFQ0xfQVRUUklC VVRFUyAoZXhwcikgPSBsdG9faW5wdXRfdHJlZSAoaWIsIGRhdGFfaW4pOwor CiAgIC8qIERvIG5vdCBzdHJlYW0gREVDTF9BQlNUUkFDVF9PUklHSU4uICBX ZSBjYW5ub3QgaGFuZGxlIGRlYnVnIGluZm9ybWF0aW9uCiAgICAgIGZvciBl YXJseSBpbmxpbmluZyBzbyBkcm9wIGl0IG9uIHRoZSBmbG9vciBpbnN0ZWFk IG9mIElDRWluZyBpbgogICAgICBkd2FyZjJvdXQuYy4gICovCkBAIC0yNDg0 LDYgKzI0OTAsMTEgQEAgbHRvX3JlYWRfdHJlZSAoc3RydWN0IGx0b19pbnB1 dF9ibG9jayAqaWIsIHN0cnVjdCBkYXRhX2luICpkYXRhX2luLAogICAvKiBS ZWFkIGFsbCB0aGUgcG9pbnRlciBmaWVsZHMgaW4gUkVTVUxULiAgKi8KICAg bHRvX2lucHV0X3RyZWVfcG9pbnRlcnMgKGliLCBkYXRhX2luLCByZXN1bHQp OwogCisgIC8qIENhbGwgYmFjayBpbnRvIHRoZSBzdHJlYW1pbmcgbW9kdWxl IHRvIHJlYWQgYW55dGhpbmcgZWxzZSBpdAorICAgICBtYXkgbmVlZC4gICov CisgIGlmIChzdHJlYW1lcl9ob29rcy5yZWFkX3RyZWUpCisgICAgc3RyZWFt ZXJfaG9va3MucmVhZF90cmVlIChpYiwgZGF0YV9pbiwgcmVzdWx0KTsKKwog ICAvKiBXZSBzaG91bGQgbmV2ZXIgdHJ5IHRvIGluc3RhbnRpYXRlIGFuIE1E IG9yIE5PUk1BTCBidWlsdGluIGhlcmUuICAqLwogICBpZiAoVFJFRV9DT0RF IChyZXN1bHQpID09IEZVTkNUSU9OX0RFQ0wpCiAgICAgZ2NjX2Fzc2VydCAo IWx0b19zdHJlYW1fYXNfYnVpbHRpbl9wIChyZXN1bHQpKTsKQEAgLTI1MDAs NiArMjUxMSwyMSBAQCBsdG9fcmVhZF90cmVlIChzdHJ1Y3QgbHRvX2lucHV0 X2Jsb2NrICppYiwgc3RydWN0IGRhdGFfaW4gKmRhdGFfaW4sCiB9CiAKIAor LyogTFRPIHN0cmVhbWVyIGhvb2sgZm9yIHJlYWRpbmcgR0lNUExFIHRyZWVz LiAgSUIgYW5kIERBVEFfSU4gYXJlIGFzIGluCisgICBsdG9fcmVhZF90cmVl LiAgRVhQUiBpcyB0aGUgdHJlZSB3YXMgbWF0ZXJpYWxpemVkIGJ5IGx0b19y ZWFkX3RyZWUgYW5kCisgICBuZWVkcyBHSU1QTEUgc3BlY2lmaWMgZGF0YSB0 byBiZSBmaWxsZWQgaW4uICAqLworCit2b2lkCitsdG9fc3RyZWFtZXJfcmVh ZF90cmVlIChzdHJ1Y3QgbHRvX2lucHV0X2Jsb2NrICppYiwgc3RydWN0IGRh dGFfaW4gKmRhdGFfaW4sCisJCQl0cmVlIGV4cHIpCit7CisgIGlmIChERUNM X1AgKGV4cHIpCisgICAgICAmJiBUUkVFX0NPREUgKGV4cHIpICE9IEZVTkNU SU9OX0RFQ0wKKyAgICAgICYmIFRSRUVfQ09ERSAoZXhwcikgIT0gVFJBTlNM QVRJT05fVU5JVF9ERUNMKQorICAgIERFQ0xfSU5JVElBTCAoZXhwcikgPSBs dG9faW5wdXRfdHJlZSAoaWIsIGRhdGFfaW4pOworfQorCisKIC8qIFJlYWQg YW5kIElOVEVHRVJfQ1NUIG5vZGUgZnJvbSBpbnB1dCBibG9jayBJQiB1c2lu ZyB0aGUgcGVyLWZpbGUKICAgIGNvbnRleHQgaW4gREFUQV9JTi4gICovCiAK QEAgLTI1ODEsMTcgKzI2MDcsMTEgQEAgbHRvX2lucHV0X3RyZWUgKHN0cnVj dCBsdG9faW5wdXRfYmxvY2sgKmliLCBzdHJ1Y3QgZGF0YV9pbiAqZGF0YV9p bikKIC8qIEluaXRpYWxpemF0aW9uIGZvciB0aGUgTFRPIHJlYWRlci4gICov CiAKIHZvaWQKLWx0b19pbml0X3JlYWRlciAodm9pZCkKK2x0b19yZWFkZXJf aW5pdCAodm9pZCkKIHsKICAgbHRvX3N0cmVhbWVyX2luaXQgKCk7Ci0KLSAg bWVtc2V0ICgmbHRvX3N0YXRzLCAwLCBzaXplb2YgKGx0b19zdGF0cykpOwot ICBiaXRtYXBfb2JzdGFja19pbml0aWFsaXplIChOVUxMKTsKLQogICBmaWxl X25hbWVfaGFzaF90YWJsZSA9IGh0YWJfY3JlYXRlICgzNywgaGFzaF9zdHJp bmdfc2xvdF9ub2RlLAogCQkJCSAgICAgIGVxX3N0cmluZ19zbG90X25vZGUs IGZyZWUpOwotCi0gIGdpbXBsZV9yZWdpc3Rlcl9jZmdfaG9va3MgKCk7CiB9 CiAKIApkaWZmIC0tZ2l0IGEvZ2NjL2x0by1zdHJlYW1lci1vdXQuYyBiL2dj Yy9sdG8tc3RyZWFtZXItb3V0LmMKaW5kZXggNjZiMWFjNi4uMDJhYzk1OCAx MDA2NDQKLS0tIGEvZ2NjL2x0by1zdHJlYW1lci1vdXQuYworKysgYi9nY2Mv bHRvLXN0cmVhbWVyLW91dC5jCkBAIC01OTEsNiArNTkxLDkgQEAgcGFja192 YWx1ZV9maWVsZHMgKHN0cnVjdCBiaXRwYWNrX2QgKmJwLCB0cmVlIGV4cHIp CiAKICAgaWYgKENPREVfQ09OVEFJTlNfU1RSVUNUIChjb2RlLCBUU19UUkFO U0xBVElPTl9VTklUX0RFQ0wpKQogICAgIHBhY2tfdHNfdHJhbnNsYXRpb25f dW5pdF9kZWNsX3ZhbHVlX2ZpZWxkcyAoYnAsIGV4cHIpOworCisgIGlmIChz dHJlYW1lcl9ob29rcy5wYWNrX3ZhbHVlX2ZpZWxkcykKKyAgICBzdHJlYW1l cl9ob29rcy5wYWNrX3ZhbHVlX2ZpZWxkcyAoYnAsIGV4cHIpOwogfQogCiAK QEAgLTc1NCw5ICs3NTcsMjIgQEAgbHRvX291dHB1dF90cmVlX3JlZiAoc3Ry dWN0IG91dHB1dF9ibG9jayAqb2IsIHRyZWUgZXhwcikKICAgICAgIGJyZWFr OwogCiAgICAgZGVmYXVsdDoKLSAgICAgIC8qIE5vIG90aGVyIG5vZGUgaXMg aW5kZXhhYmxlLCBzbyBpdCBzaG91bGQgaGF2ZSBiZWVuIGhhbmRsZWQKLQkg YnkgbHRvX291dHB1dF90cmVlLiAgKi8KLSAgICAgIGdjY191bnJlYWNoYWJs ZSAoKTsKKyAgICAgIHsKKwkvKiBTZWUgaWYgdGhlIHN0cmVhbWVyIGFsbG93 cyB0aGlzIG5vZGUgdG8gYmUgaW5kZXhhYmxlCisJICAgbGlrZSBvdGhlciBn bG9iYWwgZGVjbGFyYXRpb25zLiAgKi8KKwlpZiAoc3RyZWFtZXJfaG9va3Mu aW5kZXhhYmxlX3dpdGhfZGVjbHNfcAorCSAgICAmJiBzdHJlYW1lcl9ob29r cy5pbmRleGFibGVfd2l0aF9kZWNsc19wIChleHByKSkKKwkgIHsKKwkgICAg b3V0cHV0X3JlY29yZF9zdGFydCAob2IsIExUT19nbG9iYWxfZGVjbF9yZWYp OworCSAgICBsdG9fb3V0cHV0X3Zhcl9kZWNsX2luZGV4IChvYi0+ZGVjbF9z dGF0ZSwgb2ItPm1haW5fc3RyZWFtLCBleHByKTsKKwkgIH0KKwllbHNlCisJ ICB7CisJICAgIC8qIE5vIG90aGVyIG5vZGUgaXMgaW5kZXhhYmxlLCBzbyBp dCBzaG91bGQgaGF2ZSBiZWVuCisJICAgICAgaGFuZGxlZCBieSBsdG9fb3V0 cHV0X3RyZWUuICAqLworCSAgICBnY2NfdW5yZWFjaGFibGUgKCk7CisJICB9 CisgICAgICB9CiAgICAgfQogfQogCkBAIC04NjUsMjcgKzg4MSwxMSBAQCBs dG9fb3V0cHV0X3RzX2RlY2xfY29tbW9uX3RyZWVfcG9pbnRlcnMgKHN0cnVj dCBvdXRwdXRfYmxvY2sgKm9iLCB0cmVlIGV4cHIsCiAgIGx0b19vdXRwdXRf dHJlZV9vcl9yZWYgKG9iLCBERUNMX1NJWkUgKGV4cHIpLCByZWZfcCk7CiAg IGx0b19vdXRwdXRfdHJlZV9vcl9yZWYgKG9iLCBERUNMX1NJWkVfVU5JVCAo ZXhwciksIHJlZl9wKTsKIAotICBpZiAoVFJFRV9DT0RFIChleHByKSAhPSBG VU5DVElPTl9ERUNMCi0gICAgICAmJiBUUkVFX0NPREUgKGV4cHIpICE9IFRS QU5TTEFUSU9OX1VOSVRfREVDTCkKLSAgICB7Ci0gICAgICB0cmVlIGluaXRp YWwgPSBERUNMX0lOSVRJQUwgKGV4cHIpOwotICAgICAgaWYgKFRSRUVfQ09E RSAoZXhwcikgPT0gVkFSX0RFQ0wKLQkgICYmIChUUkVFX1NUQVRJQyAoZXhw cikgfHwgREVDTF9FWFRFUk5BTCAoZXhwcikpCi0JICAmJiBpbml0aWFsKQot CXsKLQkgIGx0b192YXJwb29sX2VuY29kZXJfdCB2YXJwb29sX2VuY29kZXIg PSBvYi0+ZGVjbF9zdGF0ZS0+dmFycG9vbF9ub2RlX2VuY29kZXI7Ci0JICBz dHJ1Y3QgdmFycG9vbF9ub2RlICp2bm9kZSA9IHZhcnBvb2xfZ2V0X25vZGUg KGV4cHIpOwotCSAgaWYgKCF2bm9kZSkKLQkgICAgaW5pdGlhbCA9IGVycm9y X21hcmtfbm9kZTsKLQkgIGVsc2UgaWYgKCFsdG9fdmFycG9vbF9lbmNvZGVy X2VuY29kZV9pbml0aWFsaXplcl9wICh2YXJwb29sX2VuY29kZXIsCi0JCQkJ CQkJICAgICAgdm5vZGUpKQotCSAgICBpbml0aWFsID0gTlVMTDsKLQl9Ci0g ICAgCi0gICAgICBsdG9fb3V0cHV0X3RyZWVfb3JfcmVmIChvYiwgaW5pdGlh bCwgcmVmX3ApOwotICAgIH0KKyAgLyogTm90ZSwgREVDTF9JTklUSUFMIGlz IG5vdCBoYW5kbGVkIGhlcmUuICBTaW5jZSBERUNMX0lOSVRJQUwgbmVlZHMK KyAgICAgc3BlY2lhbCBoYW5kbGluZyBpbiBMVE8sIGl0IG11c3QgYmUgaGFu ZGxlZCBieSBzdHJlYW1lciBob29rcy4gICovCiAKICAgbHRvX291dHB1dF90 cmVlX29yX3JlZiAob2IsIERFQ0xfQVRUUklCVVRFUyAoZXhwciksIHJlZl9w KTsKKwogICAvKiBEbyBub3Qgc3RyZWFtIERFQ0xfQUJTVFJBQ1RfT1JJR0lO LiAgV2UgY2Fubm90IGhhbmRsZSBkZWJ1ZyBpbmZvcm1hdGlvbgogICAgICBm b3IgZWFybHkgaW5saW5pbmcgc28gZHJvcCBpdCBvbiB0aGUgZmxvb3IgaW5z dGVhZCBvZiBJQ0VpbmcgaW4KICAgICAgZHdhcmYyb3V0LmMuICAqLwpAQCAt MTI2MSwxMSArMTI2MSwxMSBAQCBsdG9fb3V0cHV0X3RyZWVfaGVhZGVyIChz dHJ1Y3Qgb3V0cHV0X2Jsb2NrICpvYiwgdHJlZSBleHByKQogICBlbnVtIExU T190YWdzIHRhZzsKICAgZW51bSB0cmVlX2NvZGUgY29kZTsKIAotICAvKiBX ZSBzaG91bGQgbm90IHNlZSBhbnkgbm9uLUdJTVBMRSB0cmVlIG5vZGVzIGhl cmUuICAqLworICAvKiBXZSBzaG91bGQgbm90IHNlZSBhbnkgdHJlZSBub2Rl cyBub3QgaGFuZGxlZCBieSB0aGUgc3RyZWFtZXIuICAqLwogICBjb2RlID0g VFJFRV9DT0RFIChleHByKTsKLSAgaWYgKCFsdG9faXNfc3RyZWFtYWJsZSAo ZXhwcikpCi0gICAgaW50ZXJuYWxfZXJyb3IgKCJ0cmVlIGNvZGUgJXFzIGlz IG5vdCBzdXBwb3J0ZWQgaW4gZ2ltcGxlIHN0cmVhbXMiLAotCQkgICAgdHJl ZV9jb2RlX25hbWVbY29kZV0pOworICBpZiAoIXN0cmVhbWVyX2hvb2tzLmlz X3N0cmVhbWFibGUgKGV4cHIpKQorICAgIGludGVybmFsX2Vycm9yICgidHJl ZSBjb2RlICVxcyBpcyBub3Qgc3VwcG9ydGVkIGluICVzIHN0cmVhbXMiLAor CQkgICAgdHJlZV9jb2RlX25hbWVbY29kZV0sIHN0cmVhbWVyX2hvb2tzLm5h bWUpOwogCiAgIC8qIFRoZSBoZWFkZXIgb2YgYSB0cmVlIG5vZGUgY29uc2lz dHMgb2YgaXRzIHRhZywgdGhlIHNpemUgb2YKICAgICAgdGhlIG5vZGUsIGFu ZCBhbnkgb3RoZXIgaW5mb3JtYXRpb24gbmVlZGVkIHRvIGluc3RhbnRpYXRl CkBAIC0xMjk0LDYgKzEyOTQsMTEgQEAgbHRvX291dHB1dF90cmVlX2hlYWRl ciAoc3RydWN0IG91dHB1dF9ibG9jayAqb2IsIHRyZWUgZXhwcikKICAgICBv dXRwdXRfc2xlYjEyOCAob2IsIFRSRUVfVkVDX0xFTkdUSCAoZXhwcikpOwog ICBlbHNlIGlmIChDT0RFX0NPTlRBSU5TX1NUUlVDVCAoY29kZSwgVFNfQklO Rk8pKQogICAgIG91dHB1dF91bGViMTI4IChvYiwgQklORk9fTl9CQVNFX0JJ TkZPUyAoZXhwcikpOworCisgIC8qIEFsbG93IHRoZSBzdHJlYW1lciB0byB3 cml0ZSBhbnkgc3RyZWFtZXItc3BlY2lmaWMgaW5mb3JtYXRpb24KKyAgICAg bmVlZGVkIHRvIGluc3RhbnRpYXRlIHRoZSBub2RlIHdoZW4gcmVhZGluZy4g ICovCisgIGlmIChzdHJlYW1lcl9ob29rcy5vdXRwdXRfdHJlZV9oZWFkZXIp CisgICAgc3RyZWFtZXJfaG9va3Mub3V0cHV0X3RyZWVfaGVhZGVyIChvYiwg ZXhwcik7CiB9CiAKIApAQCAtMTM1NSwxMSArMTM2MCw0OSBAQCBsdG9fd3Jp dGVfdHJlZSAoc3RydWN0IG91dHB1dF9ibG9jayAqb2IsIHRyZWUgZXhwciwg Ym9vbCByZWZfcCkKICAgLyogV3JpdGUgYWxsIHRoZSBwb2ludGVyIGZpZWxk cyBpbiBFWFBSLiAgKi8KICAgbHRvX291dHB1dF90cmVlX3BvaW50ZXJzIChv YiwgZXhwciwgcmVmX3ApOwogCisgIC8qIENhbGwgYmFjayBpbnRvIHRoZSBz dHJlYW1pbmcgbW9kdWxlIHRvIHNlZSBpZiBpdCBuZWVkcyB0byB3cml0ZQor ICAgICBhbnl0aGluZyB0aGF0IHdhcyBub3Qgd3JpdHRlbiBieSB0aGUgY29t bW9uIHN0cmVhbWVyLiAgKi8KKyAgaWYgKHN0cmVhbWVyX2hvb2tzLndyaXRl X3RyZWUpCisgICAgc3RyZWFtZXJfaG9va3Mud3JpdGVfdHJlZSAob2IsIGV4 cHIsIHJlZl9wKTsKKwogICAvKiBNYXJrIHRoZSBlbmQgb2YgRVhQUi4gICov CiAgIG91dHB1dF96ZXJvIChvYik7CiB9CiAKIAorLyogR0lNUExFIGhvb2sg Zm9yIHdyaXRpbmcgR0lNUExFLXNwZWNpZmljIHBhcnRzIG9mIHRyZWVzLiAg T0IsIEVYUFIKKyAgIGFuZCBSRUZfUCBhcmUgYXMgaW4gbHRvX3dyaXRlX3Ry ZWUuICAqLworCit2b2lkCitsdG9fc3RyZWFtZXJfd3JpdGVfdHJlZSAoc3Ry dWN0IG91dHB1dF9ibG9jayAqb2IsIHRyZWUgZXhwciwgYm9vbCByZWZfcCkK K3sKKyAgaWYgKERFQ0xfUCAoZXhwcikKKyAgICAgICYmIFRSRUVfQ09ERSAo ZXhwcikgIT0gRlVOQ1RJT05fREVDTAorICAgICAgJiYgVFJFRV9DT0RFIChl eHByKSAhPSBUUkFOU0xBVElPTl9VTklUX0RFQ0wpCisgICAgeworICAgICAg LyogSGFuZGxlIERFQ0xfSU5JVElBTCBmb3Igc3ltYm9scy4gICovCisgICAg ICB0cmVlIGluaXRpYWwgPSBERUNMX0lOSVRJQUwgKGV4cHIpOworICAgICAg aWYgKFRSRUVfQ09ERSAoZXhwcikgPT0gVkFSX0RFQ0wKKwkgICYmIChUUkVF X1NUQVRJQyAoZXhwcikgfHwgREVDTF9FWFRFUk5BTCAoZXhwcikpCisJICAm JiBpbml0aWFsKQorCXsKKwkgIGx0b192YXJwb29sX2VuY29kZXJfdCB2YXJw b29sX2VuY29kZXI7CisJICBzdHJ1Y3QgdmFycG9vbF9ub2RlICp2bm9kZTsK KworCSAgdmFycG9vbF9lbmNvZGVyID0gb2ItPmRlY2xfc3RhdGUtPnZhcnBv b2xfbm9kZV9lbmNvZGVyOworCSAgdm5vZGUgPSB2YXJwb29sX2dldF9ub2Rl IChleHByKTsKKwkgIGlmICghdm5vZGUpCisJICAgIGluaXRpYWwgPSBlcnJv cl9tYXJrX25vZGU7CisJICBlbHNlIGlmICghbHRvX3ZhcnBvb2xfZW5jb2Rl cl9lbmNvZGVfaW5pdGlhbGl6ZXJfcCAodmFycG9vbF9lbmNvZGVyLAorCQkJ CQkJCSAgICAgIHZub2RlKSkKKwkgICAgaW5pdGlhbCA9IE5VTEw7CisJfQor CisgICAgICBsdG9fb3V0cHV0X3RyZWVfb3JfcmVmIChvYiwgaW5pdGlhbCwg cmVmX3ApOworICAgIH0KK30KKworCiAvKiBFbWl0IHRoZSBpbnRlZ2VyIGNv bnN0YW50IENTVCB0byBvdXRwdXQgYmxvY2sgT0IuICBJZiBSRUZfUCBpcyB0 cnVlLAogICAgQ1NUJ3MgdHlwZSB3aWxsIGJlIGVtaXR0ZWQgYXMgYSByZWZl cmVuY2UuICAqLwogCkBAIC0yMTg4LDE1ICsyMjMxLDYgQEAgY29weV9mdW5j dGlvbiAoc3RydWN0IGNncmFwaF9ub2RlICpub2RlKQogfQogCiAKLS8qIElu aXRpYWxpemUgdGhlIExUTyB3cml0ZXIuICAqLwotCi1zdGF0aWMgdm9pZAot bHRvX3dyaXRlcl9pbml0ICh2b2lkKQotewotICBsdG9fc3RyZWFtZXJfaW5p dCAoKTsKLX0KLQotCiAvKiBNYWluIGVudHJ5IHBvaW50IGZyb20gdGhlIHBh c3MgbWFuYWdlci4gICovCiAKIHN0YXRpYyB2b2lkCkBAIC0yMjEwLDcgKzIy NDQsOCBAQCBsdG9fb3V0cHV0IChjZ3JhcGhfbm9kZV9zZXQgc2V0LCB2YXJw b29sX25vZGVfc2V0IHZzZXQpCiAgIGludCBpLCBuX25vZGVzOwogICBsdG9f Y2dyYXBoX2VuY29kZXJfdCBlbmNvZGVyID0gbHRvX2dldF9vdXRfZGVjbF9z dGF0ZSAoKS0+Y2dyYXBoX25vZGVfZW5jb2RlcjsKIAotICBsdG9fd3JpdGVy X2luaXQgKCk7CisgIC8qIEluaXRpYWxpemUgdGhlIHN0cmVhbWVyLiAgKi8K KyAgbHRvX3N0cmVhbWVyX2luaXQgKCk7CiAKICAgbl9ub2RlcyA9IGx0b19j Z3JhcGhfZW5jb2Rlcl9zaXplIChlbmNvZGVyKTsKICAgLyogUHJvY2VzcyBv bmx5IHRoZSBmdW5jdGlvbnMgd2l0aCBib2RpZXMuICAqLwpkaWZmIC0tZ2l0 IGEvZ2NjL2x0by1zdHJlYW1lci5jIGIvZ2NjL2x0by1zdHJlYW1lci5jCmlu ZGV4IDc2M2VjYzUuLjA2MDhiMzMgMTAwNjQ0Ci0tLSBhL2djYy9sdG8tc3Ry ZWFtZXIuYworKysgYi9nY2MvbHRvLXN0cmVhbWVyLmMKQEAgLTM3LDYgKzM3 LDkgQEAgYWxvbmcgd2l0aCBHQ0M7IHNlZSB0aGUgZmlsZSBDT1BZSU5HMy4g IElmIG5vdCBzZWUKIC8qIFN0YXRpc3RpY3MgZ2F0aGVyZWQgZHVyaW5nIExU TywgV1BBIGFuZCBMVFJBTlMuICAqLwogc3RydWN0IGx0b19zdGF0c19kIGx0 b19zdGF0czsKIAorLyogU3RyZWFtZXIgaG9va3MuICAqLworc3RydWN0IHN0 cmVhbWVyX2hvb2tzIHN0cmVhbWVyX2hvb2tzOworCiAvKiBMVE8gdXNlcyBi aXRtYXBzIHdpdGggZGlmZmVyZW50IGxpZmUtdGltZXMuICBTbyB1c2UgYSBz ZXBlcmF0ZQogICAgb2JzdGFjayBmb3IgYWxsIExUTyBiaXRtYXBzLiAgKi8K IHN0YXRpYyBiaXRtYXBfb2JzdGFjayBsdG9fb2JzdGFjazsKQEAgLTU2OCw3 ICs1NzEsNyBAQCBsdG9fc3RyZWFtZXJfY2FjaGVfY3JlYXRlICh2b2lkKQog ICAvKiBMb2FkIGFsbCB0aGUgd2VsbC1rbm93biB0cmVlIG5vZGVzIHRoYXQg YXJlIGFsd2F5cyBjcmVhdGVkIGJ5CiAgICAgIHRoZSBjb21waWxlciBvbiBz dGFydHVwLiAgVGhpcyBwcmV2ZW50cyB3cml0aW5nIHRoZW0gb3V0CiAgICAg IHVubmVjZXNzYXJpbHkuICAqLwotICBsdG9fcHJlbG9hZF9jb21tb25fbm9k ZXMgKGNhY2hlKTsKKyAgc3RyZWFtZXJfaG9va3MucHJlbG9hZF9jb21tb25f bm9kZXMgKGNhY2hlKTsKIAogICByZXR1cm4gY2FjaGU7CiB9CkBAIC03MTMs MyArNzE2LDUyIEBAIGx0b19jaGVja192ZXJzaW9uIChpbnQgbWFqb3IsIGlu dCBtaW5vcikKIAkJIG1ham9yLCBtaW5vciwKIAkJIExUT19tYWpvcl92ZXJz aW9uLCBMVE9fbWlub3JfdmVyc2lvbik7CiB9CisKKworLyogUmV0dXJuIHRy dWUgaWYgRVhQUiBpcyBhIHRyZWUgbm9kZSB0aGF0IGNhbiBiZSB3cml0dGVu IHRvIGRpc2suICAqLworc3RhdGljIGlubGluZSBib29sCitsdG9faXNfc3Ry ZWFtYWJsZSAodHJlZSBleHByKQoreworICBlbnVtIHRyZWVfY29kZSBjb2Rl ID0gVFJFRV9DT0RFIChleHByKTsKKworICAvKiBOb3RpY2UgdGhhdCB3ZSBy ZWplY3QgU1NBX05BTUVzIGFzIHdlbGwuICBXZSBvbmx5IGVtaXQgdGhlIFNT QQorICAgICBuYW1lIHZlcnNpb24gaW4gbHRvX291dHB1dF90cmVlX3JlZiAo c2VlIG91dHB1dF9zc2FfbmFtZXMpLiAgKi8KKyAgcmV0dXJuICFpc19sYW5n X3NwZWNpZmljIChleHByKQorCSAmJiBjb2RlICE9IFNTQV9OQU1FCisJICYm IGNvZGUgIT0gQ0FMTF9FWFBSCisJICYmIGNvZGUgIT0gTEFOR19UWVBFCisJ ICYmIGNvZGUgIT0gTU9ESUZZX0VYUFIKKwkgJiYgY29kZSAhPSBJTklUX0VY UFIKKwkgJiYgY29kZSAhPSBUQVJHRVRfRVhQUgorCSAmJiBjb2RlICE9IEJJ TkRfRVhQUgorCSAmJiBjb2RlICE9IFdJVEhfQ0xFQU5VUF9FWFBSCisJICYm IGNvZGUgIT0gU1RBVEVNRU5UX0xJU1QKKwkgJiYgY29kZSAhPSBPTVBfQ0xB VVNFCisJICYmIGNvZGUgIT0gT1BUSU1JWkFUSU9OX05PREUKKwkgJiYgKGNv ZGUgPT0gQ0FTRV9MQUJFTF9FWFBSCisJICAgICB8fCBjb2RlID09IERFQ0xf RVhQUgorCSAgICAgfHwgVFJFRV9DT0RFX0NMQVNTIChjb2RlKSAhPSB0Y2Nf c3RhdGVtZW50KTsKK30KKworCisvKiBJbml0aWFsaXplIGFsbCB0aGUgc3Ry ZWFtZXIgaG9va3MgdXNlZCBmb3Igc3RyZWFtaW5nIEdJTVBMRS4gICovCisK K3ZvaWQKK2x0b19zdHJlYW1lcl9ob29rc19pbml0ICh2b2lkKQoreworICBz dHJlYW1lcl9ob29rc19pbml0ICgpOworICBzdHJlYW1lcl9ob29rcy5uYW1l ID0gImdpbXBsZSI7CisgIHN0cmVhbWVyX2hvb2tzLnByZWxvYWRfY29tbW9u X25vZGVzID0gbHRvX3ByZWxvYWRfY29tbW9uX25vZGVzOworICBzdHJlYW1l cl9ob29rcy5pc19zdHJlYW1hYmxlID0gbHRvX2lzX3N0cmVhbWFibGU7Cisg IHN0cmVhbWVyX2hvb2tzLndyaXRlX3RyZWUgPSBsdG9fc3RyZWFtZXJfd3Jp dGVfdHJlZTsKKyAgc3RyZWFtZXJfaG9va3MucmVhZF90cmVlID0gbHRvX3N0 cmVhbWVyX3JlYWRfdHJlZTsKK30KKworCisvKiBJbml0aWFsaXplIHRoZSBj dXJyZW50IHNldCBvZiBzdHJlYW1lciBob29rcy4gICovCisKK3ZvaWQKK3N0 cmVhbWVyX2hvb2tzX2luaXQgKHZvaWQpCit7CisgIG1lbXNldCAoJnN0cmVh bWVyX2hvb2tzLCAwLCBzaXplb2YgKHN0cmVhbWVyX2hvb2tzKSk7Cit9CmRp ZmYgLS1naXQgYS9nY2MvbHRvLXN0cmVhbWVyLmggYi9nY2MvbHRvLXN0cmVh bWVyLmgKaW5kZXggNWY2OTY1NS4uMTU3ZTVjMCAxMDA2NDQKLS0tIGEvZ2Nj L2x0by1zdHJlYW1lci5oCisrKyBiL2djYy9sdG8tc3RyZWFtZXIuaApAQCAt MzMsNiArMzMsMTIgQEAgYWxvbmcgd2l0aCBHQ0M7IHNlZSB0aGUgZmlsZSBD T1BZSU5HMy4gIElmIG5vdCBzZWUKICNpbmNsdWRlICJhbGxvYy1wb29sLmgi CiAjaW5jbHVkZSAiZ2Nvdi1pby5oIgogCisvKiBGb3J3YXJkIGRlY2xhcmF0 aW9ucyB0byBhdm9pZCBpbmNsdWRpbmcgdW5uZWNlc3NhcnkgaGVhZGVycy4g ICovCitzdHJ1Y3Qgb3V0cHV0X2Jsb2NrOworc3RydWN0IGx0b19pbnB1dF9i bG9jazsKK3N0cnVjdCBkYXRhX2luOworc3RydWN0IGJpdHBhY2tfZDsKKwog LyogRGVmaW5lIHdoZW4gZGVidWdnaW5nIHRoZSBMVE8gc3RyZWFtZXIuICBU aGlzIGNhdXNlcyB0aGUgd3JpdGVyCiAgICB0byBvdXRwdXQgdGhlIG51bWVy aWMgdmFsdWUgZm9yIHRoZSBtZW1vcnkgYWRkcmVzcyBvZiB0aGUgdHJlZSBu b2RlCiAgICBiZWluZyBlbWl0dGVkLiAgV2hlbiBkZWJ1Z2dpbmcgYSBwcm9i bGVtIGluIHRoZSByZWFkZXIsIGNoZWNrIHRoZQpAQCAtNzQxLDYgKzc0Nyw4 NiBAQCBzdHJ1Y3QgZGF0YV9pbgogfTsKIAogCisvKiBTdHJlYW1lciBob29r cy4gIFRoZXNlIGZ1bmN0aW9ucyBkbyBhZGRpdGlvbmFsIHByb2Nlc3Npbmcg YXMKKyAgIG5lZWRlZCBieSB0aGUgbW9kdWxlLiAgVGhlcmUgYXJlIHR3byB0 eXBlcyBvZiBjYWxsYmFja3MsIHRob3NlIHRoYXQKKyAgIHJlcGxhY2UgdGhl IGRlZmF1bHQgYmVoYXZpb3IgYW5kIHRob3NlIHRoYXQgc3VwcGxlbWVudCBp dC4KKworICAgSG9va3MgbWFya2VkIFtSRVFdIGFyZSByZXF1aXJlZCB0byBi ZSBzZXQuICBUaG9zZSBtYXJrZWQgW09QVF0gbWF5CisgICBiZSBOVUxMLCBp ZiB0aGUgc3RyZWFtZXIgZG9lcyBub3QgbmVlZCB0byBpbXBsZW1lbnQgdGhl bS4gICovCitzdHJ1Y3Qgc3RyZWFtZXJfaG9va3MgeworICAvKiBbUkVRXSBB IHN0cmluZyBpZGVudGlmeWluZyB0aGlzIHN0cmVhbWVyLiAgKi8KKyAgY29u c3QgY2hhciAqbmFtZTsKKworICAvKiBbUkVRXSBDYWxsZWQgYnkgbHRvX3N0 cmVhbWVyX2NhY2hlX2NyZWF0ZSB0byBpbnN0YW50aWF0ZSBhIGNhY2hlIG9m CisgICAgIHdlbGwta25vd24gbm9kZXMuICBUaGVzZSBhcmUgdHJlZSBub2Rl cyB0aGF0IGFyZSBhbHdheXMKKyAgICAgaW5zdGFudGlhdGVkIGJ5IHRoZSBj b21waWxlciBvbiBzdGFydHVwLiAgQWRkaXRpb25hbGx5LCB0aGVzZQorICAg ICBub2RlcyBuZWVkIHRvIGJlIHNoYXJlZC4gIFRoaXMgZnVuY3Rpb24gc2hv dWxkIGNhbGwKKyAgICAgbHRvX3N0cmVhbWVyX2NhY2hlX2FwcGVuZCBvbiBl dmVyeSB0cmVlIG5vZGUgdGhhdCBpdCB3aXNoZXMgdG8KKyAgICAgcHJlbG9h ZCBpbiB0aGUgc3RyZWFtZXIgY2FjaGUuICBUaGlzIHdheSwgdGhlIHdyaXRl ciB3aWxsIG9ubHkKKyAgICAgd3JpdGUgb3V0IGEgcmVmZXJlbmNlIHRvIHRo ZSB0cmVlIGFuZCB0aGUgcmVhZGVyIHdpbGwgaW5zdGFudGlhdGUKKyAgICAg dGhlIHRyZWUgb3V0IG9mIHRoaXMgcHJlLXBvcHVsYXRlZCBjYWNoZS4gICov CisgIHZvaWQgKCpwcmVsb2FkX2NvbW1vbl9ub2RlcykgKHN0cnVjdCBsdG9f c3RyZWFtZXJfY2FjaGVfZCAqKTsKKworICAvKiBbUkVRXSBSZXR1cm4gdHJ1 ZSBpZiB0aGUgZ2l2ZW4gdHJlZSBpcyBzdXBwb3J0ZWQgYnkgdGhpcyBzdHJl YW1lci4gICovCisgIGJvb2wgKCppc19zdHJlYW1hYmxlKSAodHJlZSk7CisK KyAgLyogW09QVF0gQ2FsbGVkIGJ5IGx0b193cml0ZV90cmVlIGFmdGVyIHdy aXRpbmcgYWxsIHRoZSBjb21tb24gcGFydHMgb2YKKyAgICAgYSB0cmVlLiAg SWYgZGVmaW5lZCwgdGhlIGNhbGxiYWNrIGlzIGluIGNoYXJnZSBvZiB3cml0 aW5nIGFsbAorICAgICB0aGUgZmllbGRzIHRoYXQgbHRvX3dyaXRlX3RyZWUg ZGlkIG5vdCB3cml0ZSBvdXQuICBBcmd1bWVudHMKKyAgICAgYXJlIGFzIGlu IGx0b193cml0ZV90cmVlLgorCisgICAgIFRoZSBmb2xsb3dpbmcgdHJlZSBm aWVsZHMgYXJlIG5vdCBoYW5kbGVkIGJ5IGNvbW1vbiBjb2RlOgorCisJREVD TF9BQlNUUkFDVF9PUklHSU4KKwlERUNMX0lOSVRJQUwKKwlERUNMX1NBVkVE X1RSRUUKKworICAgICBDYWxsYmFja3MgbWF5IGNob29zZSB0byBpZ25vcmUg b3IgaGFuZGxlIHRoZW0uICBJZiBoYW5kbGVkLAorICAgICB0aGUgcmVhZGVy IHNob3VsZCByZWFkIHRoZW0gaW4gdGhlIGV4YWN0IHNhbWUgc2VxdWVuY2Ug d3JpdHRlbgorICAgICBieSB0aGUgd3JpdGVyLiAgKi8KKyAgdm9pZCAoKndy aXRlX3RyZWUpIChzdHJ1Y3Qgb3V0cHV0X2Jsb2NrICosIHRyZWUsIGJvb2wp OworCisgIC8qIFtPUFRdIENhbGxlZCBieSBsdG9fcmVhZF90cmVlIGFmdGVy IHJlYWRpbmcgYWxsIHRoZSBjb21tb24gcGFydHMgb2YKKyAgICAgYSB0cmVl LiAgSWYgZGVmaW5lZCwgdGhlIGNhbGxiYWNrIGlzIGluIGNoYXJnZSBvZiBy ZWFkaW5nIGFsbAorICAgICB0aGUgZmllbGRzIHRoYXQgbHRvX3JlYWRfdHJl ZSBkaWQgbm90IHJlYWQgaW4uICBBcmd1bWVudHMKKyAgICAgYXJlIGFzIGlu IGx0b19yZWFkX3RyZWUuICAqLworICB2b2lkICgqcmVhZF90cmVlKSAoc3Ry dWN0IGx0b19pbnB1dF9ibG9jayAqLCBzdHJ1Y3QgZGF0YV9pbiAqLCB0cmVl KTsKKworICAvKiBbT1BUXSBDYWxsZWQgYnkgbHRvX291dHB1dF90cmVlX3Jl ZiB0byBkZXRlcm1pbmUgaWYgdGhlIGdpdmVuIHRyZWUgbm9kZQorICAgICBz aG91bGQgYmUgZW1pdHRlZCBhcyBhIHJlZmVyZW5jZSB0byB0aGUgdGFibGUg b2YgZGVjbGFyYXRpb25zCisgICAgICh0aGUgc2FtZSB0YWJsZSB0aGF0IGhv bGRzIGdsb2JhbCBkZWNsYXJhdGlvbnMpLiAgKi8KKyAgYm9vbCAoKmluZGV4 YWJsZV93aXRoX2RlY2xzX3ApICh0cmVlKTsKKworICAvKiBbT1BUXSBDYWxs ZWQgYnkgcGFja192YWx1ZV9maWVsZHMgdG8gc3RvcmUgYW55IG5vbi1wb2lu dGVyIGZpZWxkcworICAgICBpbiB0aGUgdHJlZSBzdHJ1Y3R1cmUuICBUaGUg YXJndW1lbnRzIGFyZSBhcyBpbiBwYWNrX3ZhbHVlX2ZpZWxkcy4gICovCisg IHZvaWQgKCpwYWNrX3ZhbHVlX2ZpZWxkcykgKHN0cnVjdCBiaXRwYWNrX2Qg KiwgdHJlZSk7CisKKyAgLyogW09QVF0gQ2FsbGVkIGJ5IHVucGFja192YWx1 ZV9maWVsZHMgdG8gcmV0cmlldmUgYW55IG5vbi1wb2ludGVyIGZpZWxkcwor ICAgICBpbiB0aGUgdHJlZSBzdHJ1Y3R1cmUuICBUaGUgYXJndW1lbnRzIGFy ZSBhcyBpbiB1bnBhY2tfdmFsdWVfZmllbGRzLiAgKi8KKyAgdm9pZCAoKnVu cGFja192YWx1ZV9maWVsZHMpIChzdHJ1Y3QgYml0cGFja19kICosIHRyZWUp OworCisgIC8qIFtPUFRdIENhbGxlZCBieSBsdG9fbWF0ZXJpYWxpemVfdHJl ZSBmb3IgdHJlZSBub2RlcyB0aGF0IGl0IGRvZXMgbm90CisgICAgIGtub3cg aG93IHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IuICBJZiBkZWZpbmVkLCB0aGlz IGhvb2sgc2hvdWxkCisgICAgIHJldHVybiBhIG5ldyB0cmVlIG5vZGUgb2Yg dGhlIGdpdmVuIGNvZGUuICBUaGUgZGF0YV9pbiBhbmQKKyAgICAgaW5wdXRf YmxvY2sgYXJndW1lbnRzIGFyZSBwYXNzZWQgaW4gY2FzZSB0aGUgaG9vayBu ZWVkcyB0bworICAgICByZWFkIG1vcmUgZGF0YSBmcm9tIHRoZSBzdHJlYW0g dG8gYWxsb2NhdGUgdGhlIG5vZGUuCisgICAgIElmIHRoaXMgaG9vayByZXR1 cm5zIE5VTEwsIHRoZW4gbHRvX21hdGVyaWFsaXplX3RyZWUgd2lsbCBhdHRl bXB0CisgICAgIHRvIGFsbG9jYXRlIHRoZSB0cmVlIGJ5IGNhbGxpbmcgbWFr ZV9ub2RlIGRpcmVjdGx5LiAgKi8KKyAgdHJlZSAoKmFsbG9jX3RyZWUpIChl bnVtIHRyZWVfY29kZSwgc3RydWN0IGx0b19pbnB1dF9ibG9jayAqLAorICAg ICAgICAgICAgICAgICAgICAgIHN0cnVjdCBkYXRhX2luICopOworCisgIC8q IFtPUFRdIENhbGxlZCBieSBsdG9fb3V0cHV0X3RyZWVfaGVhZGVyIHRvIHdy aXRlIGFueSBzdHJlYW1lci1zcGVjaWZpYworICAgICBpbmZvcm1hdGlvbiBu ZWVkZWQgdG8gYWxsb2NhdGUgdGhlIHRyZWUuICBUaGlzIGhvb2sgbWF5IGFz c3VtZQorICAgICB0aGF0IHRoZSBiYXNpYyBoZWFkZXIgZGF0YSAodHJlZSBj b2RlLCBldGMpIGhhcyBhbHJlYWR5IGJlZW4KKyAgICAgd3JpdHRlbi4gIEl0 IHNob3VsZCBvbmx5IHdyaXRlIGFueSBleHRyYSBkYXRhIG5lZWRlZCB0byBh bGxvY2F0ZQorICAgICB0aGUgbm9kZSAoZS5nLiwgaW4gdGhlIGNhc2Ugb2Yg Q0FMTF9FWFBSLCB0aGlzIGhvb2sgd291bGQgd3JpdGUKKyAgICAgdGhlIG51 bWJlciBvZiBhcmd1bWVudHMgdG8gdGhlIENBTExfRVhQUikuICAqLworICB2 b2lkICgqb3V0cHV0X3RyZWVfaGVhZGVyKSAoc3RydWN0IG91dHB1dF9ibG9j ayAqLCB0cmVlKTsKK307CisKKy8qIFN0cmVhbWVyIGhvb2tzLiAgKi8KK2V4 dGVybiBzdHJ1Y3Qgc3RyZWFtZXJfaG9va3Mgc3RyZWFtZXJfaG9va3M7CisK IC8qIEluIGx0by1zZWN0aW9uLWluLmMgICovCiBleHRlcm4gc3RydWN0IGx0 b19pbnB1dF9ibG9jayAqIGx0b19jcmVhdGVfc2ltcGxlX2lucHV0X2Jsb2Nr ICgKIAkJCSAgICAgICBzdHJ1Y3QgbHRvX2ZpbGVfZGVjbF9kYXRhICosCkBA IC04NTEsMTcgKzkzNywyMCBAQCBleHRlcm4gaW50cHRyX3QgbHRvX29yaWdf YWRkcmVzc19nZXQgKHRyZWUpOwogZXh0ZXJuIHZvaWQgbHRvX29yaWdfYWRk cmVzc19yZW1vdmUgKHRyZWUpOwogI2VuZGlmCiBleHRlcm4gdm9pZCBsdG9f Y2hlY2tfdmVyc2lvbiAoaW50LCBpbnQpOwotCitleHRlcm4gdm9pZCBsdG9f c3RyZWFtZXJfaG9va3NfaW5pdCAodm9pZCk7CitleHRlcm4gdm9pZCBsdG9f c3RyZWFtZXJfd3JpdGVfdHJlZSAoc3RydWN0IG91dHB1dF9ibG9jayAqLCB0 cmVlLCBib29sKTsKK2V4dGVybiB2b2lkIGx0b19zdHJlYW1lcl9yZWFkX3Ry ZWUgKHN0cnVjdCBsdG9faW5wdXRfYmxvY2sgKiwKKwkJCQkgICAgIHN0cnVj dCBkYXRhX2luICosIHRyZWUpOworZXh0ZXJuIHZvaWQgc3RyZWFtZXJfaG9v a3NfaW5pdCAodm9pZCk7CiAKIC8qIEluIGx0by1zdHJlYW1lci1pbi5jICov CiBleHRlcm4gdm9pZCBsdG9faW5wdXRfY2dyYXBoIChzdHJ1Y3QgbHRvX2Zp bGVfZGVjbF9kYXRhICosIGNvbnN0IGNoYXIgKik7Ci1leHRlcm4gdm9pZCBs dG9faW5pdF9yZWFkZXIgKHZvaWQpOworZXh0ZXJuIHZvaWQgbHRvX3JlYWRl cl9pbml0ICh2b2lkKTsKIGV4dGVybiB0cmVlIGx0b19pbnB1dF90cmVlIChz dHJ1Y3QgbHRvX2lucHV0X2Jsb2NrICosIHN0cnVjdCBkYXRhX2luICopOwog ZXh0ZXJuIHZvaWQgbHRvX2lucHV0X2Z1bmN0aW9uX2JvZHkgKHN0cnVjdCBs dG9fZmlsZV9kZWNsX2RhdGEgKiwgdHJlZSwKIAkJCQkgICAgIGNvbnN0IGNo YXIgKik7CiBleHRlcm4gdm9pZCBsdG9faW5wdXRfY29uc3RydWN0b3JzX2Fu ZF9pbml0cyAoc3RydWN0IGx0b19maWxlX2RlY2xfZGF0YSAqLAogCQkJCQkg ICAgICBjb25zdCBjaGFyICopOwotZXh0ZXJuIHZvaWQgbHRvX2luaXRfcmVh ZGVyICh2b2lkKTsKIGV4dGVybiBzdHJ1Y3QgZGF0YV9pbiAqbHRvX2RhdGFf aW5fY3JlYXRlIChzdHJ1Y3QgbHRvX2ZpbGVfZGVjbF9kYXRhICosCiAJCQkJ ICAgIGNvbnN0IGNoYXIgKiwgdW5zaWduZWQsCiAJCQkJICAgIFZFQyhsZF9w bHVnaW5fc3ltYm9sX3Jlc29sdXRpb25fdCxoZWFwKSAqKTsKQEAgLTEwNjMs MzEgKzExNTIsNiBAQCBsdG9fc3RyZWFtX2FzX2J1aWx0aW5fcCAodHJlZSBl eHByKQogCSAgICAgIHx8IERFQ0xfQlVJTFRfSU5fQ0xBU1MgKGV4cHIpID09 IEJVSUxUX0lOX01EKSk7CiB9CiAKLS8qIFJldHVybiB0cnVlIGlmIEVYUFIg aXMgYSB0cmVlIG5vZGUgdGhhdCBjYW4gYmUgd3JpdHRlbiB0byBkaXNrLiAg Ki8KLXN0YXRpYyBpbmxpbmUgYm9vbAotbHRvX2lzX3N0cmVhbWFibGUgKHRy ZWUgZXhwcikKLXsKLSAgZW51bSB0cmVlX2NvZGUgY29kZSA9IFRSRUVfQ09E RSAoZXhwcik7Ci0KLSAgLyogTm90aWNlIHRoYXQgd2UgcmVqZWN0IFNTQV9O QU1FcyBhcyB3ZWxsLiAgV2Ugb25seSBlbWl0IHRoZSBTU0EKLSAgICAgbmFt ZSB2ZXJzaW9uIGluIGx0b19vdXRwdXRfdHJlZV9yZWYgKHNlZSBvdXRwdXRf c3NhX25hbWVzKS4gICovCi0gIHJldHVybiAhaXNfbGFuZ19zcGVjaWZpYyAo ZXhwcikKLQkgJiYgY29kZSAhPSBTU0FfTkFNRQotCSAmJiBjb2RlICE9IENB TExfRVhQUgotCSAmJiBjb2RlICE9IExBTkdfVFlQRQotCSAmJiBjb2RlICE9 IE1PRElGWV9FWFBSCi0JICYmIGNvZGUgIT0gSU5JVF9FWFBSCi0JICYmIGNv ZGUgIT0gVEFSR0VUX0VYUFIKLQkgJiYgY29kZSAhPSBCSU5EX0VYUFIKLQkg JiYgY29kZSAhPSBXSVRIX0NMRUFOVVBfRVhQUgotCSAmJiBjb2RlICE9IFNU QVRFTUVOVF9MSVNUCi0JICYmIGNvZGUgIT0gT01QX0NMQVVTRQotCSAmJiBj b2RlICE9IE9QVElNSVpBVElPTl9OT0RFCi0JICYmIChjb2RlID09IENBU0Vf TEFCRUxfRVhQUgotCSAgICAgfHwgY29kZSA9PSBERUNMX0VYUFIKLQkgICAg IHx8IFRSRUVfQ09ERV9DTEFTUyAoY29kZSkgIT0gdGNjX3N0YXRlbWVudCk7 Ci19Ci0KIERFRklORV9ERUNMX1NUUkVBTV9GVU5DUyAoVFlQRSwgdHlwZSkK IERFRklORV9ERUNMX1NUUkVBTV9GVU5DUyAoRklFTERfREVDTCwgZmllbGRf ZGVjbCkKIERFRklORV9ERUNMX1NUUkVBTV9GVU5DUyAoRk5fREVDTCwgZm5f ZGVjbCkKZGlmZiAtLWdpdCBhL2djYy9sdG8vbHRvLmMgYi9nY2MvbHRvL2x0 by5jCmluZGV4IDcwZDViZGUuLjc0ZGZlY2QgMTAwNjQ0Ci0tLSBhL2djYy9s dG8vbHRvLmMKKysrIGIvZ2NjL2x0by9sdG8uYwpAQCAtMjczMiw2ICsyNzMy LDIxIEBAIGx0b19wcm9jZXNzX25hbWUgKHZvaWQpCiAgICAgc2V0cHJvY3Rp dGxlICgibHRvMS1sdHJhbnMiKTsKIH0KIAorCisvKiBJbml0aWFsaXplIHRo ZSBMVE8gZnJvbnQgZW5kLiAgKi8KKworc3RhdGljIHZvaWQKK2x0b19pbml0 ICh2b2lkKQoreworICBsdG9fcHJvY2Vzc19uYW1lICgpOworICBsdG9fc3Ry ZWFtZXJfaG9va3NfaW5pdCAoKTsKKyAgbHRvX3JlYWRlcl9pbml0ICgpOwor ICBtZW1zZXQgKCZsdG9fc3RhdHMsIDAsIHNpemVvZiAobHRvX3N0YXRzKSk7 CisgIGJpdG1hcF9vYnN0YWNrX2luaXRpYWxpemUgKE5VTEwpOworICBnaW1w bGVfcmVnaXN0ZXJfY2ZnX2hvb2tzICgpOworfQorCisKIC8qIE1haW4gZW50 cnkgcG9pbnQgZm9yIHRoZSBHSU1QTEUgZnJvbnQgZW5kLiAgVGhpcyBmcm9u dCBlbmQgaGFzCiAgICB0aHJlZSBtYWluIHBlcnNvbmFsaXRpZXM6CiAKQEAg LTI3NTUsOSArMjc3MCw4IEBAIGx0b19wcm9jZXNzX25hbWUgKHZvaWQpCiB2 b2lkCiBsdG9fbWFpbiAodm9pZCkKIHsKLSAgbHRvX3Byb2Nlc3NfbmFtZSAo KTsKLQotICBsdG9faW5pdF9yZWFkZXIgKCk7CisgIC8qIEluaXRpYWxpemUg dGhlIExUTyBmcm9udCBlbmQuICAqLworICBsdG9faW5pdCAoKTsKIAogICAv KiBSZWFkIGFsbCB0aGUgc3ltYm9scyBhbmQgY2FsbCBncmFwaCBmcm9tIGFs bCB0aGUgZmlsZXMgaW4gdGhlCiAgICAgIGNvbW1hbmQgbGluZS4gICovCg== --000e0cdf19ce3db17704a4e7e7d2--