From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 9327 invoked by alias); 9 Jan 2012 11:47:36 -0000 Received: (qmail 9307 invoked by uid 22791); 9 Jan 2012 11:47:31 -0000 X-SWARE-Spam-Status: No, hits=-0.7 required=5.0 tests=AWL,BAYES_50,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FROM,RCVD_IN_DNSWL_LOW,TW_BJ X-Spam-Check-By: sourceware.org Received: from mail-vx0-f169.google.com (HELO mail-vx0-f169.google.com) (209.85.220.169) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 09 Jan 2012 11:46:52 +0000 Received: by vcge1 with SMTP id e1so2922620vcg.0 for ; Mon, 09 Jan 2012 03:46:51 -0800 (PST) Received: by 10.220.213.200 with SMTP id gx8mr8988150vcb.13.1326109611214; Mon, 09 Jan 2012 03:46:51 -0800 (PST) MIME-Version: 1.0 Received: by 10.220.3.130 with HTTP; Mon, 9 Jan 2012 03:46:30 -0800 (PST) In-Reply-To: References: From: Kevin Pouget Date: Mon, 09 Jan 2012 11:47:00 -0000 Message-ID: Subject: Re: [PATCH] Add bp_location to Python interface To: gdb-patches@sourceware.org Cc: pmuldoon@redhat.com Content-Type: multipart/mixed; boundary=bcaec54fb8144f474704b616f463 X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2012-01/txt/msg00269.txt.bz2 --bcaec54fb8144f474704b616f463 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-length: 16693 On Tue, Dec 13, 2011 at 4:28 PM, Kevin Pouget wrot= e: > > On Fri, Dec 9, 2011 at 3:10 PM, Phil Muldoon wrote: > > Kevin Pouget writes: > > > >> On Thu, Dec 8, 2011 at 3:28 PM, Phil Muldoon wro= te: > >> > > > >>>> +A breakpoint location is represented with a @code{gdb.BpLocation} o= bject, > >>>> +which offers the following attributes (all read only) and methods. > >>>> +Please note that breakpoint locations are very transient entities in > >>>> +@value{GDBN}, so one should avoid keeping references to them. > >> > >>> > >>> While it is good to note that, I'm not sure =A0what we are explaining= here > >>> other than when the breakpoint is deleted, all location objects that = are > >>> associated with that object are invalid too. =A0Or, are you noting we > >>> should allow the user to interact after the fact? If that is the case, > >>> what is "is_valid" for? =A0Why note the transient nature of the objec= t? > >> > >>> I'm not sure what we are explaining here other than when the breakpoi= nt is deleted > >> > >> that's what I wanted to emphasize here, bp_locations are cleaned/reset > >> more often than 'high-level' breakpoints are removed. My knowledge > >> about that is quite limited, but for instance this (cleaned up) stack: > >> > >> #0 =A0gdbpy_bplocation_free py-bploc.c:60 > >> #1 =A0free_bp_location (loc=3D) breakpoint.c:5685 > >> #2 =A0decref_bp_location (blp=3D) breakpoint.c:5707 > >> #3 =A0update_global_location_list (should_insert=3D1) =A0breakpoint.c:= 10575 > >> #4 =A0update_breakpoint_locations (b=3D, sals=3D..., =A0 =A0 sals_end= =3D...) > >> breakpoint.c:11787 > >> #5 =A0breakpoint_re_set_default (b=3D) breakpoint.c:11937 > >> #6 =A0breakpoint_re_set_one (bint=3D) breakpoint.c:11968 > >> #8 =A0breakpoint_re_set () breakpoint.c:11992 > >> #9 =A0solib_add (pattern=3D0x0, from_tty=3D0, target=3D, =A0readsyms= =3D1) solib.c:926 > >> #10 bpstat_what (bs_head=3D) breakpoint.c:4487 > >> #11 handle_inferior_event (ecs=3D) infrun.c:4394 > >> #12 wait_for_inferior () > >> > >> shows that bplocations might be removed when a shared library is loaded > > > > Good point, I did not think of this scenario. =A0Looking at several > > sections of GDB code, update_global_location_list can just be called > > whenever. > > > >>> If the breakpoint is deleted and the user still has reference to a > >>> location object, I think we should just run a validation routine and > >>> refuse to do anything but raise an exception at that point (like > >>> is_valid, but triggered for all function/attribute calls). > >> > >> hum, I think that's what I already do in the code :) > >> > >> I've updated the gdb.BpLocation.is_valid documentation, maybe it's cle= arer? > > > > Yeah, I saw it later. =A0Forgot to delete that comment! > > > >>> @defun BpLocation.is_valid () > >>> Returns @code{True} if the @code{gdb.BpLocation} object is valid, > >>> @code{False} if not. =A0A @code{gdb.BpLocation} object may be invalid= ated by > >>> GDB at any moment for internal reasons. All other @code{gdb.BpLocatio= n} methods > >>> and attributes will throw an exception if the object is invalid. > >>> @end defun > >> > >>>> + > >>>> +@defvar BpLocation.owner > >>>> +This attribute holds a reference to the @code{gdb.Breakpoint} objec= t which > >>>> +owns this location. > >>>> +@end defvar > >> > >>> Note which attributes are read only/writable. =A0This and others. > >> I specify a few lines above that all the attributes are read only, but > >> I've noted it on each attribute as well. > > > > Right, but there is no guarantee that the user will read the entirety > > of that section's documentation. =A0So we always put attribute access r= ights > > in the attribute section. > > ok, I thought that as soon as it was clearly mentioned somewhere, that > was enough. But it doesn't cost anything to me to write it for each > attribute, so no problem! > > >>> Also many different breakpoints can be at one location. =A0I'm not su= re if it > >>> is worth pointing out here that "this breakpoint" only owns the > >>> location insofar as the scope of that breakpoint (there could be other > >>> breakpoints set to that location). > >> > >> from an implementation point of view, the is a BP =A0<1--------n> > >> BpLocation relation, even if two locations have the same address. > >> > >> Also, I think that the end-users won't have problems to understand > >> these BpLocations, as they're already exposed with "info breakpoints": > > > > I was purely talking from a scripting point of view, but ok. =A0My view > > is, if the user has to run experiments to collect data on the actual > > behavior, then our documentation needs to be a little better. > > yes, no doubt about that! > > > You could just put in that "from an implementation point of view" parag= raph in > > the documentation somewhere? > > I've added it to 'BpLocation.owner' description: > > @defvar BpLocation.owner > This attribute holds a reference to the @code{gdb.Breakpoint} object which > owns this location. =A0This attribute is not writable. =A0From an impleme= ntation > point of view, there is a @code{1 ... n} relation between a breakpoint and > its locations, even if two breakpoints are set on at same address. > > > > >>>> +struct bploc_object > >>>> +{ > >>>> + =A0PyObject_HEAD > >>>> + > >>>> + =A0/* The location corresponding to this py object. =A0NULL is the= location > >>>> + =A0 =A0 has been deleted. =A0*/ > >>>> + =A0struct bp_location *loc; > >>> > >>> Typo in the comment "NULL is the location has been deleted.". =A0Also= nit > >>> pick shouldn't it be "The location corresponding to a gdb.Breakpoint > >>> object"? > >> > >> typo fixed, but not the nit: it's the same idea as breakpoint, > >> if the 'backend' breakpoint is deleted, 'struct breakpoint_object . bp= ' is NULL, > >> if the 'backend' location is deleted, 'struct bploc_object . loc' is > >> NULL > > > > My objection was to "py object", I would just find it clearer to name > > the object. =A0Also, the explanation above would go a long way for futu= re > > hackers to understand the relationship. =A0Maybe add that to the code t= oo? > > You're right, it looks obvious to me, but it would take time to figure > out by itself. > Here are a few more bits of comments: > > /* The location corresponding to this gdb.BpLocation object. =A0It's the = same > =A0 =A0 idea as gdb.Breakpoint, if the 'backend' location is deleted, LOC= is > =A0 =A0 set to NULL. =A0No reference to the location is owned here (in te= rms of > =A0 =A0 ref. counting) in order not to change the internal behavior. =A0*/ > struct bp_location *loc; > > >> > >>>> + > >>>> + =A0/* 1 if the owner BP has been deleted, 0 otherwise. =A0*/ > >>>> + =A0int invalid_owner; > >>>> + > >>>> + =A0/* Cache for the gdb.Value object corresponding to loc->address= . =A0*/ > >>>> + =A0PyObject *py_address; > >>>> +}; > >>> > >>> I'm not sure if breakpoint locations can change. =A0I do not think so= , but > >>> why do we need to cache loc->address? > >> > >> I assumed that it can't change, but didn't actually investigate all > >> the implementation. > >> My feeling is "caching is easy, creating a Py object has a cost, so > >> let's cache!", but I've got no idea about the actual cost, so I'll > >> change it if someone insists [and convinces me] :) > > > > I don't know enough about breakpoint locations to be able to advise you, > > but what does update_global_location_list do? =A0Just shuffle add/delete > > locations to the list? =A0I am not against caching. =A0Just not sure wh= y we > > need it. =A0I tend towards the conservative with things like these, if > > only purely because we keep missing reference counts in the existing > > code. > > I somehow managed to convinced myself to remove this address caching, > 1/I'm not sure about the actual py object creation, certainly quite low, > 2/BpLocation objects have a short lifespan, so the cached addresses > would be discarded quite frequently > so all in all, I can't see anymore any relevant reason to cache it :) > > >>>> + > >>>> +/* Require that LOCATION be a valid bp_location; throw a Python > >>>> + =A0 exception if it is invalid. =A0*/ > >>>> +#define BPLOCPY_REQUIRE_VALID(Location) =A0 =A0 =A0 =A0 =A0 =A0 =A0= =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 \ > >>>> + =A0 =A0do { =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 = =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0\ > >>>> + =A0 =A0 =A0if ((Location)->loc =3D=3D NULL) =A0 =A0 =A0 =A0 =A0 = =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0\ > >>>> + =A0 =A0 =A0 =A0return PyErr_Format (PyExc_RuntimeError, =A0 =A0 = =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0\ > >>>> + =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 _("BpLocat= ion invalid.")); =A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 \ > >>>> + =A0 =A0} while (0) > >>> > >>> I prefer error messages a little more descriptive. =A0That is just a > >>> personal thing of mine, but "BpLocation invalid" would seem cryptic w= hen > >>> thrown in the context of a script. > >> > >> I'm not sure how I could improve it, at this point (checking validity > >> at the beginning of all the attributes), we just know that the backend > >> location has been freed, but we don't know why. > > > > "BpLocation object, breakpoint location is NULL". Or something like tha= t. > > I'm still not sure, I think that when I read "BpLocation invalid", I'd > take a look at the 'is_valid' method description, and understand > that "A @code{gdb.BpLocation} object may be invalidated by GDB at any > moment for internal reasons." > 'breakpoint location is NULL' sounds like an internal error to me ... > > Maybe "BpLocation invalid: internal location object freed up/removed by G= DB." ? > > >>>> +PyObject * > >>>> +bplocation_to_bplocation_object (struct bp_location *loc) > >>>> +{ > >>>> + =A0bploc_object *bploc_obj; > >>>> + > >>>> + =A0gdb_assert (loc !=3D NULL); > >>> > >>> Is this a fatal error that we need to shutdown GDB for? =A0gdb_assert > >>> seems pretty strong from an API point of view. > >> > >> hum, I'm not sure here, > >> I wrote this line to actually shutdown GDB instead of segfaulting on > >> the next line, > >> for instance 'py-pspace.c::pspace_to_pspace_object' and > >> 'py-objfile.c::objfile_to_objfile_object" will just segfault if > >> there're called with a NULL parameter. > >> > >> throwing an Python/GDB exception wouldn't make much sense to me > >> either, as there end-user won't be able to deal with it > > > > Neither would killing GDB. =A0I almost never use gdb_assert because of = the > > possible negative user implications. =A0Can you discern that GDB has > > entered an unstable state because a function has received a NULL > > argument for a bp_location? =A0If you cannot answer "yes" with a high > > degree of certainty, it is my opinion we should raise an exception and > > return NULL. =A0We can make sure in the Python API that, if this is the > > case, we will return the exception to the script boundary for the script > > to deal with. =A0From an API point-of-view I think we should defer to > > script authors the opportunity to deal with and decide what to do in > > this scenario. =A0If GDB is truly unstable, then I agree, assert is > > correct. =A0I think the other two cases are bugs. > > I get your point and quite agree with you, the only thing is that > we're talking about 'gdb_assert' and not 'assert' itself. > > > Neither would killing GDB. > and here's my point, 'gdb_assert' does't kill GDB, but raises a > warning message asking the user if he wants to quit or continue. > My feeling about *assert is that it's a development/beta-test > features, which might/should be turned into noop for production. > > > From an API point-of-view I think we should defer to script authors the= opportunity to deal with > I don't think so, because (from my developer point of view) I see it > as very improbable that this situation would occur, or even impossible > if I were a good programmer! > I don't think that API should cover internal 'buggy' situations, > otherwise they would be endless! > > > The Maintainers may differ on this, wait for their opinion. > yes, I'm curious about different point of views > > >>>> +bplocpy_get_address (PyObject *self, void *closure) > >>>> +{ > >>>> + =A0bploc_object *self_bploc =3D (bploc_object *) self; > >>>> + > >>>> + =A0BPLOCPY_REQUIRE_VALID (self_bploc); > >>>> + > >>>> + =A0if (!self_bploc->py_address) > >>>> + =A0 =A0{ > >>>> + =A0 =A0 =A0/* Get the address Value object as a void *. =A0*/ > >>>> + =A0 =A0 =A0volatile struct gdb_exception except; > >>>> + =A0 =A0 =A0struct type *void_ptr_type; > >>>> + =A0 =A0 =A0struct value *val =3D NULL ; /* Initialize to appease g= cc warning. =A0*/ > >>>> + > >>>> + =A0 =A0 =A0TRY_CATCH (except, RETURN_MASK_ALL) > >>>> + =A0 =A0 =A0 =A0{ > >>>> + =A0 =A0 =A0 =A0 =A0void_ptr_type =3D lookup_pointer_type ( > >>>> + =A0 =A0 =A0 =A0 =A0 =A0 =A0builtin_type (python_gdbarch)->builtin_= void); > >>>> + =A0 =A0 =A0 =A0 =A0val =3D value_from_pointer (void_ptr_type, self= _bploc->loc->address); > >>>> + =A0 =A0 =A0 =A0} > >>>> + =A0 =A0 =A0GDB_PY_HANDLE_EXCEPTION (except); > >>>> + > >>>> + =A0 =A0 =A0self_bploc->py_address =3D value_to_value_object (val); > >>>> + =A0 =A0 =A0Py_XINCREF (self_bploc->py_address); > >>>> + =A0 =A0} > >>>> + =A0Py_XINCREF (self_bploc->py_address); > >>> > >>> I don't really mind it, but I prefer explicit return NULL when dealing > >>> with cases of exceptions. =A0I find the other logic hard to read. =A0= This is > >>> not a request for a change. Is there a case where py_address will be > >>> NULL? =A0Yes, there is, value_to_value_object can return NULL. =A0If = it > >>> returns NULL, then there is an exception set. =A0I much prefer to exit > >>> then and there, other the conditional XINCREF step, and returning at = the > >>> function exit. =A0Still, this is just a stylistic thing, and probably > >>> personal thing. =A0The second XINCREF can just be a plain old INCREF = as we > >>> already tested for NULL. > >> > >> makes sense to me, my "single return point" idea doesn't stand against > >> error handling > > > > Note this is purely a personal style issue, there was nothing wrong with > > the correctness of your code. > > sure, I try to make it clear when I don't agree with the suggestion; > this one was perfectly fine, > I think that's actually the way I wrote it at the first time :) > > >>> This brings me to the address cache argument. =A0Is it worthwhile man= aging > >>> the cache increment counts instead of just returning the address each > >>> time? =A0I ask as I am not sure if you have done any metrics that ind= icate > >>> this is a slow operation. > >> > >> no, I didn't run any measurement so far; I'll wait for a maintainer > >> point of view about that > > > > Ok. > > > >>> We need to make sure that the this is not a watchpoint. > >> > >> why not? > >> I don't know much about watchpoints, but as per my quick > >> investigations, they share the same high-level structure (struct > >> breakpoint), and they seem to use bp_location the same way ? > > > > I'm not sure as watchpoints are based on expressions. =A0Maybe it is ok, > > but note that watchpoints are removed and reinserted on scope of the > > expression. =A0It might be fine. =A0A few tests would prove the issue. > > I'll try to build some test to ensure that it's fine > > > thanks for your comments and reviews, ping patch refreshed against current HEAD Thanks, Kevin -- 2012-01-09 Kevin Pouget Add bp_location to Python interface * Makefile.in (SUBDIR_PYTHON_OBS): Add py-bploc.o (SUBDIR_PYTHON_SRCS): Add python/py-bploc.c Add build rule for this file. * breakpoint.h (struct bploc_object): Forward declaration. (struct bp_location): Add py_bploc_obj. * breakpoint.c (free_bp_location): Call gdbpy_bplocation_free. * python/py-bploc.c: New file. * python/py-breakpoint.c (bppy_locations): New function. (breakpoint_object_methods): New method binding: locations(). * python/python-internal.h (bploc_object): New typedef. (bplocation_to_bplocation_object): New prototype. (gdbpy_initialize_bplocation): Likewise. * python/python.c (gdbpy_bplocation_free): New empty stub. (_initialize_python): Call gdbpy_initialize_bplocation. * python/python.h (gdbpy_bplocation_free): New prototype. =09 doc/ Add bp_location to Python interface * gdb.texinfo (Breakpoints In Python): Document gdb.Breakpoint.locations and gdb.BpLocation. testsuite/ Add bp_location to Python interface * gdb.python/py-breakpoint.exp: Test gdb.BpLocation. --bcaec54fb8144f474704b616f463 Content-Type: text/x-patch; charset=US-ASCII; name="0001-Add-bp_location-to-Python-interface.patch" Content-Disposition: attachment; filename="0001-Add-bp_location-to-Python-interface.patch" Content-Transfer-Encoding: base64 X-Attachment-Id: f_gx7fdv8w1 Content-length: 30496 RnJvbSBlNjFlZDMzYWNlODhkZDMzNmVlYTZmNWUzYjdmNzUwMjQzMDg3ODIy IE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBLZXZpbiBQb3VnZXQg PGtldmluLnBvdWdldEBzdC5jb20+CkRhdGU6IFdlZCwgMTggTWF5IDIwMTEg MTA6MDI6MjMgLTA0MDAKU3ViamVjdDogW1BBVENIXSBBZGQgYnBfbG9jYXRp b24gdG8gUHl0aG9uIGludGVyZmFjZQoKLS0tCiBnZGIvTWFrZWZpbGUuaW4g ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICA2ICsKIGdkYi9ORVdT ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgIDYgKwog Z2RiL2JyZWFrcG9pbnQuYyAgICAgICAgICAgICAgICAgICAgICAgICAgIHwg ICAgMyArCiBnZGIvYnJlYWtwb2ludC5oICAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgICA2ICsKIGdkYi9kb2MvZ2RiLnRleGluZm8gICAgICAgICAg ICAgICAgICAgICAgICB8ICAgNDQgKysrKwogZ2RiL3B5dGhvbi9weS1icGxv Yy5jICAgICAgICAgICAgICAgICAgICAgIHwgIDMwMiArKysrKysrKysrKysr KysrKysrKysrKysrKysrCiBnZGIvcHl0aG9uL3B5LWJyZWFrcG9pbnQuYyAg ICAgICAgICAgICAgICAgfCAgIDM5ICsrKysKIGdkYi9weXRob24vcHl0aG9u LWludGVybmFsLmggICAgICAgICAgICAgICB8ICAgIDYgKwogZ2RiL3B5dGhv bi9weXRob24uYyAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgNyArCiBn ZGIvcHl0aG9uL3B5dGhvbi5oICAgICAgICAgICAgICAgICAgICAgICAgfCAg ICAyICsKIGdkYi90ZXN0c3VpdGUvZ2RiLnB5dGhvbi9weS1icmVha3BvaW50 LmV4cCB8ICAgNTIgKysrKysKIDExIGZpbGVzIGNoYW5nZWQsIDQ3MyBpbnNl cnRpb25zKCspLCAwIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0 IGdkYi9weXRob24vcHktYnBsb2MuYwoKZGlmZiAtLWdpdCBhL2dkYi9NYWtl ZmlsZS5pbiBiL2dkYi9NYWtlZmlsZS5pbgppbmRleCBjZDkzNzY4Li5lNGNk ZDVhIDEwMDY0NAotLS0gYS9nZGIvTWFrZWZpbGUuaW4KKysrIGIvZ2RiL01h a2VmaWxlLmluCkBAIC0yNzMsNiArMjczLDcgQEAgU1VCRElSX1BZVEhPTl9P QlMgPSBcCiAJcHktYXV0by1sb2FkLm8gXAogCXB5LWJsb2NrLm8gXAogCXB5 LWJwZXZlbnQubyBcCisJcHktYnBsb2MubyBcCiAJcHktYnJlYWtwb2ludC5v IFwKIAlweS1jbWQubyBcCiAJcHktY29udGludWVldmVudC5vIFwKQEAgLTMw NSw2ICszMDYsNyBAQCBTVUJESVJfUFlUSE9OX1NSQ1MgPSBcCiAJcHl0aG9u L3B5LWF1dG8tbG9hZC5jIFwKIAlweXRob24vcHktYmxvY2suYyBcCiAJcHl0 aG9uL3B5LWJwZXZlbnQuYyBcCisJcHl0aG9uL3B5LWJwbG9jLmMgXAogCXB5 dGhvbi9weS1icmVha3BvaW50LmMgXAogCXB5dGhvbi9weS1jbWQuYyBcCiAJ cHl0aG9uL3B5LWNvbnRpbnVlZXZlbnQuYyBcCkBAIC0yMDMzLDYgKzIwMzUs MTAgQEAgcHktYnBldmVudC5vOiAkKHNyY2RpcikvcHl0aG9uL3B5LWJwZXZl bnQuYwogCSQoQ09NUElMRSkgJChQWVRIT05fQ0ZMQUdTKSAkKHNyY2Rpcikv cHl0aG9uL3B5LWJwZXZlbnQuYwogCSQoUE9TVENPTVBJTEUpCiAKK3B5LWJw bG9jLm86ICQoc3JjZGlyKS9weXRob24vcHktYnBsb2MuYworCSQoQ09NUElM RSkgJChQWVRIT05fQ0ZMQUdTKSAkKHNyY2RpcikvcHl0aG9uL3B5LWJwbG9j LmMKKwkkKFBPU1RDT01QSUxFKQorCiBweS1icmVha3BvaW50Lm86ICQoc3Jj ZGlyKS9weXRob24vcHktYnJlYWtwb2ludC5jCiAJJChDT01QSUxFKSAkKFBZ VEhPTl9DRkxBR1MpICQoc3JjZGlyKS9weXRob24vcHktYnJlYWtwb2ludC5j CiAJJChQT1NUQ09NUElMRSkKZGlmZiAtLWdpdCBhL2dkYi9ORVdTIGIvZ2Ri L05FV1MKaW5kZXggYTlhNzg1OS4uYzUyOWY5NiAxMDA2NDQKLS0tIGEvZ2Ri L05FV1MKKysrIGIvZ2RiL05FV1MKQEAgLTksNiArOSwxMiBAQAogKiBUaGUg YmluYXJ5ICJnZGJ0dWkiIGNhbiBubyBsb25nZXIgYmUgYnVpbHQgb3IgaW5z dGFsbGVkLgogICBVc2UgImdkYiAtdHVpIiBpbnN0ZWFkLgogCisqIFB5dGhv biBzY3JpcHRpbmcKKworICAqKiBBIG5ldyBtZXRob2QgImdkYi5CcmVha3Bv aW50LmxvY2F0aW9ucyIgaGFzIGJlZW4gYWRkZWQsIGFzIHdlbGwgYXMKKyAg ICAgdGhlIGNsYXNzIGdkYi5CcExvY2F0aW9uIHRvIHByb3ZpZGUgZnVydGhl ciBkZXRhaWxzIGFib3V0IGJyZWFrcG9pbnQKKyAgICAgbG9jYXRpb25zLgor CiAqKiogQ2hhbmdlcyBpbiBHREIgNy40CiAKICogR0RCIG5vdyBoYW5kbGVz IGFtYmlndW91cyBsaW5lc3BlY3MgbW9yZSBjb25zaXN0ZW50bHk7IHRoZSBl eGlzdGluZwpkaWZmIC0tZ2l0IGEvZ2RiL2JyZWFrcG9pbnQuYyBiL2dkYi9i cmVha3BvaW50LmMKaW5kZXggNmJjZWRjNC4uNjIzZjJkZiAxMDA2NDQKLS0t IGEvZ2RiL2JyZWFrcG9pbnQuYworKysgYi9nZGIvYnJlYWtwb2ludC5jCkBA IC01Njc5LDYgKzU2NzksOSBAQCBzdGF0aWMgdm9pZAogZnJlZV9icF9sb2Nh dGlvbiAoc3RydWN0IGJwX2xvY2F0aW9uICpsb2MpCiB7CiAgIGxvYy0+b3Bz LT5kdG9yIChsb2MpOworCisgIGdkYnB5X2JwbG9jYXRpb25fZnJlZSAobG9j KTsKKwogICB4ZnJlZSAobG9jKTsKIH0KIApkaWZmIC0tZ2l0IGEvZ2RiL2Jy ZWFrcG9pbnQuaCBiL2dkYi9icmVha3BvaW50LmgKaW5kZXggYzFkM2JlOS4u OGQ2ZmExOSAxMDA2NDQKLS0tIGEvZ2RiL2JyZWFrcG9pbnQuaAorKysgYi9n ZGIvYnJlYWtwb2ludC5oCkBAIC0yNiw2ICsyNiw3IEBACiBzdHJ1Y3QgdmFs dWU7CiBzdHJ1Y3QgYmxvY2s7CiBzdHJ1Y3QgYnJlYWtwb2ludF9vYmplY3Q7 CitzdHJ1Y3QgYnBsb2Nfb2JqZWN0Owogc3RydWN0IGdldF9udW1iZXJfb3Jf cmFuZ2Vfc3RhdGU7CiBzdHJ1Y3QgdGhyZWFkX2luZm87CiBzdHJ1Y3QgYnBz dGF0czsKQEAgLTQwMyw2ICs0MDQsMTEgQEAgc3RydWN0IGJwX2xvY2F0aW9u CiAgIC8qIFNvdXJjZSBmaWxlIG5hbWUgb2YgdGhpcyBhZGRyZXNzLiAgKi8K IAogICBjaGFyICpzb3VyY2VfZmlsZTsKKworICAvKiBQeXRob24gb2JqZWN0 IGFzc29jaWF0ZWQgd2l0aCB0aGlzIGxvY2F0aW9uLiAgTWF5IGJlIE5VTEwg aWYgdGhlIGxvY2F0aW9uCisgICAgIGlzIG5vdCB5ZXQgZXhwb3J0ZWQgdG8g UHl0aG9uLiAgKi8KKworICBzdHJ1Y3QgYnBsb2Nfb2JqZWN0ICpweV9icGxv Y19vYmo7CiB9OwogCiAvKiBUaGlzIHN0cnVjdHVyZSBpcyBhIGNvbGxlY3Rp b24gb2YgZnVuY3Rpb24gcG9pbnRlcnMgdGhhdCwgaWYgYXZhaWxhYmxlLApk aWZmIC0tZ2l0IGEvZ2RiL2RvYy9nZGIudGV4aW5mbyBiL2dkYi9kb2MvZ2Ri LnRleGluZm8KaW5kZXggMmY0YWE0Zi4uZjgzNzVkNiAxMDA2NDQKLS0tIGEv Z2RiL2RvYy9nZGIudGV4aW5mbworKysgYi9nZGIvZG9jL2dkYi50ZXhpbmZv CkBAIC0yNDM1OCw2ICsyNDM1OCw1MCBAQCBjb21tYW5kcywgc2VwYXJhdGVk IGJ5IG5ld2xpbmVzLiAgSWYgdGhlcmUgYXJlIG5vIGNvbW1hbmRzLCB0aGlz CiBhdHRyaWJ1dGUgaXMgQGNvZGV7Tm9uZX0uICBUaGlzIGF0dHJpYnV0ZSBp cyBub3Qgd3JpdGFibGUuCiBAZW5kIGRlZnZhcgogCitAZmluZGV4IGdkYi5s b2NhdGlvbnMKK0BkZWZ1biBnZGIubG9jYXRpb25zICgpCitSZXR1cm4gYSB0 dXBsZSBjb250YWluaW5nIGEgc2VxdWVuY2Ugb2YgQGNvZGV7Z2RiLkJwTG9j YXRpb259IG9iamVjdHMgCisoc2VlIGJlbG93KSBhc3NvY2lhdGVkIHdpdGgg dGhpcyBicmVha3BvaW50LiAgQSBicmVha3BvaW50IHdpdGggbm8gbG9jYXRp b24KK2lzIGEgcGVuZGluZyBicmVha3BvaW50IChAeHJlZntTZXQgQnJlYWtz LCAsIHBlbmRpbmcgYnJlYWtwb2ludHN9KS4KK0BlbmQgZGVmdW4KKworQSBi cmVha3BvaW50IGxvY2F0aW9uIGlzIHJlcHJlc2VudGVkIHdpdGggYSBAY29k ZXtnZGIuQnBMb2NhdGlvbn0gb2JqZWN0LAord2hpY2ggb2ZmZXJzIHRoZSBm b2xsb3dpbmcgYXR0cmlidXRlcyAoYWxsIHJlYWQgb25seSkgYW5kIG1ldGhv ZHMuCitQbGVhc2Ugbm90ZSB0aGF0IGJyZWFrcG9pbnQgbG9jYXRpb25zIGFy ZSB2ZXJ5IHRyYW5zaWVudCBlbnRpdGllcyBpbgorQHZhbHVle0dEQk59LCBz byBvbmUgc2hvdWxkIGF2b2lkIGtlZXBpbmcgcmVmZXJlbmNlcyB0byB0aGVt LgorCitAZGVmdmFyIEJwTG9jYXRpb24ub3duZXIKK1RoaXMgYXR0cmlidXRl IGhvbGRzIGEgcmVmZXJlbmNlIHRvIHRoZSBAY29kZXtnZGIuQnJlYWtwb2lu dH0gb2JqZWN0IHdoaWNoCitvd25zIHRoaXMgbG9jYXRpb24uICBUaGlzIGF0 dHJpYnV0ZSBpcyBub3Qgd3JpdGFibGUuICBGcm9tIGFuIGltcGxlbWVudGF0 aW9uIAorcG9pbnQgb2YgdmlldywgdGhlcmUgaXMgYSBAY29kZXsxIC4uLiBu fSByZWxhdGlvbiBiZXR3ZWVuIGEgYnJlYWtwb2ludCBhbmQKK2l0cyBsb2Nh dGlvbnMsIGV2ZW4gaWYgdHdvIGJyZWFrcG9pbnRzIGFyZSBzZXQgb24gYXQg c2FtZSBhZGRyZXNzLgorIAorQGVuZCBkZWZ2YXIKKworQGRlZnZhciBCcExv Y2F0aW9uLmVuYWJsZWQKK1RoaXMgYXR0cmlidXRlIGluZGljYXRlcyB3aGV0 aGVyIHRoaXMgbG9jYXRpb24gaXMgY3VycmVudGx5IGVuYWJsZWQgb3Igbm90 LgorVGhpcyBhdHRyaWJ1dGUgaXMgbm90IHdyaXRhYmxlLgorQGVuZCBkZWZ2 YXIKKworQGRlZnZhciBCcExvY2F0aW9uLmluZmVyaW9yCitUaGlzIGF0dHJp YnV0ZSBob2xkcyBhIHJlZmVyZW5jZSB0byB0aGUgQGNvZGV7Z2RiLkluZmVy aW9yfSBpbmZlcmlvciBvYmplY3QKK2luIHdoaWNoIHRoaXMgYnJlYWtwb2lu dCBsb2NhdGlvbiBoYXMgYmVlbiBpbnNlcnRlZC4gIFRoZSB2YWx1ZSB3aWxs IGJlIAorQGNvZGV7Tm9uZX0gaWYgdGhlcmUgaXMgbm8gaW5mZXJpb3IgYXNz b2NpYXRlZCB3aXRoIHRoaXMgbG9jYXRpb24uICAgVGhpcyAKK2F0dHJpYnV0 ZSBpcyBub3Qgd3JpdGFibGUuCitAZW5kIGRlZnZhcgorCitAZGVmdmFyIEJw TG9jYXRpb24uYWRkcmVzcworVGhpcyBhdHRyaWJ1dGUgaG9sZHMgYSBAY29k ZXtnZGIuVmFsdWV9IG9iamVjdCBjb3JyZXNwb25kaW5nIHRvIHRoZSBhZGRy ZXNzIAorYXQgd2hpY2ggdGhlIGJyZWFrcG9pbnQgaGFzIGJlZW4gaW5zZXJ0 ZWQuICAgVGhpcyBhdHRyaWJ1dGUgaXMgbm90IHdyaXRhYmxlLgorQGVuZCBk ZWZ2YXIKKworQGRlZnVuIEJwTG9jYXRpb24uaXNfdmFsaWQgKCkKK1JldHVy bnMgQGNvZGV7VHJ1ZX0gaWYgdGhlIEBjb2Rle2dkYi5CcExvY2F0aW9ufSBv YmplY3QgaXMgdmFsaWQsCitAY29kZXtGYWxzZX0gaWYgbm90LiAgQSBAY29k ZXtnZGIuQnBMb2NhdGlvbn0gb2JqZWN0IG1heSBiZSBpbnZhbGlkYXRlZCBi eQorR0RCIGF0IGFueSBtb21lbnQgZm9yIGludGVybmFsIHJlYXNvbnMuICBB bGwgb3RoZXIgQGNvZGV7Z2RiLkJwTG9jYXRpb259CittZXRob2RzIGFuZCBh dHRyaWJ1dGVzIHdpbGwgdGhyb3cgYW4gZXhjZXB0aW9uIGlmIHRoZSBvYmpl Y3QgaXMgaW52YWxpZC4KK0BlbmQgZGVmdW4KKwogQG5vZGUgRmluaXNoIEJy ZWFrcG9pbnRzIGluIFB5dGhvbgogQHN1YnN1YnNlY3Rpb24gRmluaXNoIEJy ZWFrcG9pbnRzCiAKZGlmZiAtLWdpdCBhL2dkYi9weXRob24vcHktYnBsb2Mu YyBiL2dkYi9weXRob24vcHktYnBsb2MuYwpuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwLi41YmEzOTQ4Ci0tLSAvZGV2L251bGwKKysrIGIv Z2RiL3B5dGhvbi9weS1icGxvYy5jCkBAIC0wLDAgKzEsMzAyIEBACisvKiBQ eXRob24gaW50ZXJmYWNlIHRvIGJyZWFrcG9pbnQgbG9jYXRpb25zLgorCisg ICBDb3B5cmlnaHQgKEMpIDIwMTEgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9u LCBJbmMuCisKKyAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIEdEQi4KKworICAg VGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0 cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAgIGl0IHVuZGVyIHRoZSB0ZXJt cyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlz aGVkIGJ5CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRo ZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorICAgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgVGhpcyBwcm9ncmFt IGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1 c2VmdWwsCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQg ZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVSQ0hBTlRBQklM SVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZQorICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUg ZGV0YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29w eSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAgIGFsb25n IHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cu Z251Lm9yZy9saWNlbnNlcy8+LiAgKi8KKworCisjaW5jbHVkZSAiZGVmcy5o IgorI2luY2x1ZGUgImluZmVyaW9yLmgiCisjaW5jbHVkZSAicHl0aG9uLWlu dGVybmFsLmgiCisjaW5jbHVkZSAib2JzZXJ2ZXIuaCIKKyNpbmNsdWRlICJn ZGJhcmNoLmgiCisKK3N0cnVjdCBicGxvY19vYmplY3QKK3sKKyAgUHlPYmpl Y3RfSEVBRAorCisgIC8qIFRoZSBsb2NhdGlvbiBjb3JyZXNwb25kaW5nIHRv IHRoaXMgZ2RiLkJwTG9jYXRpb24gb2JqZWN0LiAgSXQncyB0aGUgc2FtZQor ICAgICBpZGVhIGFzIGdkYi5CcmVha3BvaW50LCBpZiB0aGUgJ2JhY2tlbmQn IGxvY2F0aW9uIGlzIGRlbGV0ZWQsIExPQyBpcworICAgICBzZXQgdG8gTlVM TC4gIE5vIHJlZmVyZW5jZSB0byB0aGUgbG9jYXRpb24gaXMgb3duZWQgaGVy ZSAoaW4gdGVybXMgb2YKKyAgICAgcmVmLiBjb3VudGluZykgaW4gb3JkZXIg bm90IHRvIGNoYW5nZSB0aGUgaW50ZXJuYWwgYmVoYXZpb3IuICAqLworICBz dHJ1Y3QgYnBfbG9jYXRpb24gKmxvYzsKKworICAvKiAxIGlmIHRoZSBvd25l ciBCUCBoYXMgYmVlbiBkZWxldGVkLCAwIG90aGVyd2lzZS4gICovCisgIGlu dCBpbnZhbGlkX293bmVyOworfTsKKworLyogUmVxdWlyZSB0aGF0IExPQ0FU SU9OIGJlIGEgdmFsaWQgYnBfbG9jYXRpb247IHRocm93IGEgUHl0aG9uCisg ICBleGNlcHRpb24gaWYgaXQgaXMgaW52YWxpZC4gICovCisjZGVmaW5lIEJQ TE9DUFlfUkVRVUlSRV9WQUxJRChMb2NhdGlvbikgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBcCisgICAgZG8geyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBcCisgICAgICBpZiAoKExvY2F0aW9uKS0+bG9jID09IE5VTEwpICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgIHJl dHVybiBQeUVycl9Gb3JtYXQgKFB5RXhjX1J1bnRpbWVFcnJvciwgICAgICAg ICAgICAgICAgICAgICAgICBcCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIF8oIkJwTG9jYXRpb24gaW52YWxpZC4iKSk7ICAgICAgICAgICAgICAg ICBcCisgICAgfSB3aGlsZSAoMCkKKworc3RhdGljIFB5VHlwZU9iamVjdCBi cGxvY19vYmplY3RfdHlwZTsKKworLyogQ2FsbCBieSBmcmVlX2JwX2xvY2F0 aW9uIHdoZW4gbG9jIGlzIGFib3V0IHRvIGJlIGZyZWVkLiAgKi8KKwordm9p ZAorZ2RicHlfYnBsb2NhdGlvbl9mcmVlIChzdHJ1Y3QgYnBfbG9jYXRpb24g KmxvYykKK3sKKyAgaWYgKGxvYy0+cHlfYnBsb2Nfb2JqKQorICAgIHsKKyAg ICAgIGxvYy0+cHlfYnBsb2Nfb2JqLT5sb2MgPSBOVUxMOworICAgICAgUHlf REVDUkVGIChsb2MtPnB5X2JwbG9jX29iaik7CisgICAgfQorfQorCisvKiBE aXNzb2NpYXRlIHRoZSBicF9sb2NhdGlvbiBmcm9tIHRoZSBQeXRob24gb2Jq ZWN0LiAgKi8KKworc3RhdGljIHZvaWQKK2JwbG9jcHlfZGVhbGxvYyAoUHlP YmplY3QgKnNlbGYpCit7CisgIGJwbG9jX29iamVjdCAqc2VsZl9icGxvYyA9 IChicGxvY19vYmplY3QgKikgc2VsZjsKKworICBpZiAoc2VsZl9icGxvYy0+ bG9jICE9IE5VTEwpCisgICAgc2VsZl9icGxvYy0+bG9jLT5weV9icGxvY19v YmogPSBOVUxMOworCisgIHNlbGYtPm9iX3R5cGUtPnRwX2ZyZWUgKHNlbGYp OworfQorCisvKiBDcmVhdGUgb3IgYWNxdWlyZSBhIHJlZiB0byB0aGUgYnBf bG9jYXRpb24gb2JqZWN0IChnZGIuQnBMb2NhdGlvbikKKyAgIHRoYXQgZW5j YXBzdWxhdGVzIHRoZSBzdHJ1Y3QgYnBfbG9jYXRpb24gZnJvbSBHREIuICAq LworCitQeU9iamVjdCAqCiticGxvY2F0aW9uX3RvX2JwbG9jYXRpb25fb2Jq ZWN0IChzdHJ1Y3QgYnBfbG9jYXRpb24gKmxvYykKK3sKKyAgYnBsb2Nfb2Jq ZWN0ICpicGxvY19vYmo7CisKKyAgZ2RiX2Fzc2VydCAobG9jICE9IE5VTEwp OworICBpZiAobG9jLT5weV9icGxvY19vYmopCisgICAgeworICAgICAgUHlf SU5DUkVGIChsb2MtPnB5X2JwbG9jX29iaik7CisgICAgICByZXR1cm4gKFB5 T2JqZWN0ICopIGxvYy0+cHlfYnBsb2Nfb2JqOworICAgIH0KKworICBicGxv Y19vYmogPSBQeU9iamVjdF9OZXcgKGJwbG9jX29iamVjdCwgJmJwbG9jX29i amVjdF90eXBlKTsKKyAgaWYgKCFicGxvY19vYmopCisgICAgcmV0dXJuIE5V TEw7CisKKyAgYnBsb2Nfb2JqLT5sb2MgPSBsb2M7CisgIGJwbG9jX29iai0+ aW52YWxpZF9vd25lciA9IDA7CisgIFB5X0lOQ1JFRiAoYnBsb2Nfb2JqKTsK KyAgbG9jLT5weV9icGxvY19vYmogPSBicGxvY19vYmo7CisKKyAgcmV0dXJu IChQeU9iamVjdCAqKSBicGxvY19vYmo7Cit9CisKKy8qIFB5dGhvbiBmdW5j dGlvbiB0byBnZXQgdGhlIEJQIG93bmluZyB0aGlzIGxvY2F0aW9uLCBpZiBh bnkuICAqLworCitzdGF0aWMgUHlPYmplY3QgKgorYnBsb2NweV9nZXRfb3du ZXIgKFB5T2JqZWN0ICpzZWxmLCB2b2lkICpjbG9zdXJlKQoreworICBicGxv Y19vYmplY3QgKnNlbGZfYnBsb2MgPSAoYnBsb2Nfb2JqZWN0ICopIHNlbGY7 CisKKyAgQlBMT0NQWV9SRVFVSVJFX1ZBTElEIChzZWxmX2JwbG9jKTsKKwor ICBpZiAoc2VsZl9icGxvYy0+aW52YWxpZF9vd25lcikKKyAgICBQeV9SRVRV Uk5fTk9ORTsKKworICBpZiAoc2VsZl9icGxvYy0+bG9jLT5vd25lcgorICAg ICAgJiYgc2VsZl9icGxvYy0+bG9jLT5vd25lci0+cHlfYnBfb2JqZWN0KQor ICAgIHsKKyAgICAgIFB5X0lOQ1JFRiAoc2VsZl9icGxvYy0+bG9jLT5vd25l ci0+cHlfYnBfb2JqZWN0KTsKKyAgICAgIHJldHVybiAoUHlPYmplY3QgKikg c2VsZl9icGxvYy0+bG9jLT5vd25lci0+cHlfYnBfb2JqZWN0OworICAgIH0K KworICBQeV9SRVRVUk5fTk9ORTsKK30KKworLyogUHl0aG9uIGZ1bmN0aW9u IHRvIHRlc3Qgd2hldGhlciBvciBub3QgdGhpcyBicmVha3BvaW50IGxvY2F0 aW9uIGlzCisgICBlbmFibGVkLiAgKi8KKworc3RhdGljIFB5T2JqZWN0ICoK K2JwbG9jcHlfZ2V0X2VuYWJsZWQgKFB5T2JqZWN0ICpzZWxmLCB2b2lkICpj bG9zdXJlKQoreworICBicGxvY19vYmplY3QgKnNlbGZfYnBsb2MgPSAoYnBs b2Nfb2JqZWN0ICopIHNlbGY7CisKKyAgQlBMT0NQWV9SRVFVSVJFX1ZBTElE IChzZWxmX2JwbG9jKTsKKworICBpZiAoc2VsZl9icGxvYy0+bG9jLT5lbmFi bGVkKQorICAgIFB5X1JFVFVSTl9UUlVFOworCisgIFB5X1JFVFVSTl9GQUxT RTsKK30KKworLyogUHl0aG9uIGZ1bmN0aW9uIHRvIGdldCB0aGUgYWRkcmVz cyBvZiB0aGlzIGJyZWFrcG9pbnQgbG9jYXRpb24uICBUaGUKKyAgIGdkYi5W YWx1ZSBvYmplY3Qgd2lsbCBiZSBjYWNoZWQgaWYgdGhpcyBpcyB0aGUgZmly c3QgYWNjZXNzLiAgUmV0dXJucworICAgTlVMTCBpbiBjYXNlIG9mIGZhaWx1 cmUsIHdpdGggYSBQeXRob24gZXhjZXB0aW9uIHNldC4gICovCisKK3N0YXRp YyBQeU9iamVjdCAqCiticGxvY3B5X2dldF9hZGRyZXNzIChQeU9iamVjdCAq c2VsZiwgdm9pZCAqY2xvc3VyZSkKK3sKKyAgYnBsb2Nfb2JqZWN0ICpzZWxm X2JwbG9jID0gKGJwbG9jX29iamVjdCAqKSBzZWxmOworICB2b2xhdGlsZSBz dHJ1Y3QgZ2RiX2V4Y2VwdGlvbiBleGNlcHQ7CisgIHN0cnVjdCB0eXBlICp2 b2lkX3B0cl90eXBlOworICBzdHJ1Y3QgdmFsdWUgKnZhbCA9IE5VTEw7IC8q IEluaXRpYWxpemUgdG8gYXBwZWFzZSBnY2Mgd2FybmluZy4gICovCisgIFB5 T2JqZWN0ICpweV9hZGRyZXNzOworCisgIEJQTE9DUFlfUkVRVUlSRV9WQUxJ RCAoc2VsZl9icGxvYyk7CisKKyAgLyogR2V0IHRoZSBhZGRyZXNzIFZhbHVl IG9iamVjdCBhcyBhIHZvaWQgKiB2YWx1ZS4gICovCisgIFRSWV9DQVRDSCAo ZXhjZXB0LCBSRVRVUk5fTUFTS19BTEwpCisgICAgeworICAgICAgdm9pZF9w dHJfdHlwZSA9IGxvb2t1cF9wb2ludGVyX3R5cGUgKAorICAgICAgICAgIGJ1 aWx0aW5fdHlwZSAocHl0aG9uX2dkYmFyY2gpLT5idWlsdGluX3ZvaWQpOwor ICAgICAgdmFsID0gdmFsdWVfZnJvbV9wb2ludGVyICh2b2lkX3B0cl90eXBl LCBzZWxmX2JwbG9jLT5sb2MtPmFkZHJlc3MpOworICAgIH0KKyAgR0RCX1BZ X0hBTkRMRV9FWENFUFRJT04gKGV4Y2VwdCk7CisKKyAgcHlfYWRkcmVzcyA9 IHZhbHVlX3RvX3ZhbHVlX29iamVjdCAodmFsKTsKKyAgaWYgKCFweV9hZGRy ZXNzKQorICAgIHJldHVybiBOVUxMOworCisgIHJldHVybiBweV9hZGRyZXNz OworfQorCisvKiBQeXRob24gZnVuY3Rpb24gdG8gZ2V0IHRoZSBpbmZlcmlv ciBob3N0aW5nIHRoaXMgYnJlYWtwb2ludCBsb2NhdGlvbi4KKyAgIFJldHVy biBQeV9Ob25lIGlmIHRoZXJlIGlzIG5vIGluZmVyaW9yIGFzc29jaWF0ZWQg d2l0aCB0aGUgcHJvZ3JhbSBzcGFjZSBvZgorICAgdGhpcyBsb2NhdGlvbiwg b3IgTlVMTCBpbiBjYXNlIG9mIGZhaWx1cmUsIHdpdGggYSBweXRob24gZXhj ZXB0aW9uIHNldC4gICovCisKK3N0YXRpYyBQeU9iamVjdCAqCiticGxvY3B5 X2dldF9pbmZlcmlvciAoUHlPYmplY3QgKnNlbGYsIHZvaWQgKmNsb3N1cmUp Cit7CisgIGJwbG9jX29iamVjdCAqc2VsZl9icGxvYyA9IChicGxvY19vYmpl Y3QgKikgc2VsZjsKKyAgc3RydWN0IGluZmVyaW9yICppbmY7CisgIFB5T2Jq ZWN0ICppbmZvYmo7CisKKyAgQlBMT0NQWV9SRVFVSVJFX1ZBTElEIChzZWxm X2JwbG9jKTsKKworICBpbmYgPSBmaW5kX2luZmVyaW9yX2Zvcl9wcm9ncmFt X3NwYWNlIChzZWxmX2JwbG9jLT5sb2MtPnBzcGFjZSk7CisgIGlmICghaW5m KQorICAgIFB5X1JFVFVSTl9OT05FOworCisgIGluZm9iaiA9IGluZmVyaW9y X3RvX2luZmVyaW9yX29iamVjdCAoaW5mKTsKKyAgUHlfWElOQ1JFRiAoaW5m b2JqKTsKKworICByZXR1cm4gaW5mb2JqOworfQorCisvKiBQeXRob24gZnVu Y3Rpb24gd2hpY2ggY2hlY2tzIHRoZSB2YWxpZGl0eSBvZiBhIGJwIGxvY2F0 aW9uIG9iamVjdC4gICovCisKK3N0YXRpYyBQeU9iamVjdCAqCiticGxvY3B5 X2lzX3ZhbGlkIChQeU9iamVjdCAqc2VsZiwgUHlPYmplY3QgKmFyZ3MpCit7 CisgIGJwbG9jX29iamVjdCAqc2VsZl9icGxvYyA9IChicGxvY19vYmplY3Qg Kikgc2VsZjsKKworICBpZiAoc2VsZl9icGxvYy0+bG9jKQorICAgIFB5X1JF VFVSTl9UUlVFOworICBQeV9SRVRVUk5fRkFMU0U7Cit9CisKKy8qIENhbGxi YWNrIHRyaWdnZXJlZCB3aGVuIGEgYnJlYWtwb2ludCBpcyBkZWxldGVkLiAg VGhpcyB3aWxsIGludmFsaWRhdGUKKyAgIHRoZSBjb3JyZXNwb25kaW5nIGJw X2xvY2F0aW9uIFB5dGhvbiBvYmplY3Qgb3duZXJzLiAgKi8KKworc3RhdGlj IHZvaWQKK2JwbG9jcHlfYnJlYWtwb2ludF9kZWxldGVkIChzdHJ1Y3QgYnJl YWtwb2ludCAqYikgeworICBzdHJ1Y3QgYnBfbG9jYXRpb24gKmxvYzsKKwor ICBmb3IgKGxvYyA9IGItPmxvYzsgbG9jOyBsb2MgPSBsb2MtPm5leHQpCisg ICAgeworICAgICAgaWYgKGxvYy0+cHlfYnBsb2Nfb2JqKQorICAgICAgICBs b2MtPnB5X2JwbG9jX29iai0+aW52YWxpZF9vd25lciA9IDE7CisgICAgfQor fQorCisvKiBJbml0aWFsaXplIHRoZSBQeXRob24gYnBfbG9jYXRpb24gY29k ZS4gICovCisKK3ZvaWQKK2dkYnB5X2luaXRpYWxpemVfYnBsb2NhdGlvbiAo dm9pZCkKK3sKKyAgaWYgKFB5VHlwZV9SZWFkeSAoJmJwbG9jX29iamVjdF90 eXBlKSA8IDApCisgICAgcmV0dXJuOworCisgIFB5X0lOQ1JFRiAoJmJwbG9j X29iamVjdF90eXBlKTsKKyAgaWYgKFB5TW9kdWxlX0FkZE9iamVjdCAoZ2Ri X21vZHVsZSwgIkJwTG9jYXRpb24iLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAoUHlPYmplY3QgKikgJmJwbG9jX29iamVjdF90eXBlKSA8IDApCisg ICAgcmV0dXJuOworCisgIG9ic2VydmVyX2F0dGFjaF9icmVha3BvaW50X2Rl bGV0ZWQgKGJwbG9jcHlfYnJlYWtwb2ludF9kZWxldGVkKTsKK30KKworc3Rh dGljIFB5R2V0U2V0RGVmIGJwbG9jX29iamVjdF9nZXRzZXRbXSA9Cit7Cisg IHsgIm93bmVyIiwgYnBsb2NweV9nZXRfb3duZXIsIE5VTEwsCisgICAgIkVh Y2ggYnJlYWtwb2ludCBsb2NhdGlvbiBtdXN0IGJlbG9uZyB0byBleGFjdGx5 IG9uZSBoaWdoZXItbGV2ZWwgXAorYnJlYWtwb2ludC4gIFRoaXMgcG9pbnRl ciBpcyBOVUxMIGlmZiB0aGlzIGJwX2xvY2F0aW9uIGlzIG5vIFwKK2xvbmdl ciBhdHRhY2hlZCB0byBhIGJyZWFrcG9pbnQgKHJlYWQtb25seSkuIiwKKyAg ICBOVUxMIH0sCisgIHsgImVuYWJsZWQiLCBicGxvY3B5X2dldF9lbmFibGVk LCBOVUxMLAorICAgICJJcyB0aGlzIHBhcnRpY3VsYXIgbG9jYXRpb24gZW5h YmxlZC4iLCBOVUxMIH0sCisgIHsgImFkZHJlc3MiLCBicGxvY3B5X2dldF9h ZGRyZXNzLCBOVUxMLAorICAgICJUaGUgYWRkcmVzcyBhdCB3aGljaCB0aGUg YnJlYWtwb2ludCBoYXMgYmVlbiBzZXQuIiwgTlVMTCB9LAorICB7ICJpbmZl cmlvciIsIGJwbG9jcHlfZ2V0X2luZmVyaW9yLCBOVUxMLAorICAgICJUaGUg aW5mZXJpb3IgaW4gd2hpY2ggdGhpcyBicmVha3BvaW50IGxvY2F0aW9uIGhh cyBiZWVuIHNldC4iLCBOVUxMIH0sCisgIHsgTlVMTCB9ICAvKiBTZW50aW5l bC4gICovCit9OworCisKK3N0YXRpYyBQeU1ldGhvZERlZiBicGxvY19vYmpl Y3RfbWV0aG9kc1tdID0KK3sKKyAgeyAiaXNfdmFsaWQiLCBicGxvY3B5X2lz X3ZhbGlkLCBNRVRIX05PQVJHUywKKyAgICAiUmV0dXJuIHRydWUgaWYgdGhp cyBicmVha3BvaW50IGxvY2F0aW9uIGlzIHZhbGlkLCBmYWxzZSBpZiBub3Qu IiB9LAorICB7IE5VTEwgfSAvKiBTZW50aW5lbC4gICovCit9OworCitzdGF0 aWMgUHlUeXBlT2JqZWN0IGJwbG9jX29iamVjdF90eXBlID0KK3sKKyAgUHlP YmplY3RfSEVBRF9JTklUIChOVUxMKQorICAwLCAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIC8qIG9iX3NpemUgKi8KKyAgImdk Yi5CcExvY2F0aW9uIiwgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB0 cF9uYW1lICovCisgIHNpemVvZiAoYnBsb2Nfb2JqZWN0KSwgICAgICAgICAg ICAgICAgICAgICAgLyogdHBfYmFzaWNzaXplICovCisgIDAsICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfaXRlbXNp emUgKi8KKyAgYnBsb2NweV9kZWFsbG9jLCAgICAgICAgICAgICAgICAgICAg ICAgICAgICAvKiB0cF9kZWFsbG9jICovCisgIDAsICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfcHJpbnQgKi8KKyAg MCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAv KiB0cF9nZXRhdHRyICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgLyogdHBfc2V0YXR0ciAqLworICAwLCAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIHRwX2Nv bXBhcmUgKi8KKyAgMCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAvKiB0cF9yZXByICovCisgIDAsICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfYXNfbnVtYmVyICov CisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgLyogdHBfYXNfc2VxdWVuY2UgKi8KKyAgMCwgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9hc19tYXBwaW5nICov CisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgLyogdHBfaGFzaCAgKi8KKyAgMCwgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAvKiB0cF9jYWxsICovCisgIDAsICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfc3Ry ICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgLyogdHBfZ2V0YXR0cm8gKi8KKyAgMCwgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9zZXRhdHRybyAqLwor ICAwLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IC8qIHRwX2FzX2J1ZmZlciAqLworICBQeV9UUEZMQUdTX0RFRkFVTFQgfCBQ eV9UUEZMQUdTX0JBU0VUWVBFLCAgIC8qIHRwX2ZsYWdzICovCisgICJHREIg YnJlYWtwb2ludCBsb2NhdGlvbiBvYmplY3QiLCAgICAgICAgICAgLyogdHBf ZG9jICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgLyogdHBfdHJhdmVyc2UgKi8KKyAgMCwgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9jbGVhciAqLwor ICAwLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IC8qIHRwX3JpY2hjb21wYXJlICovCisgIDAsICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfd2Vha2xpc3RvZmZzZXQg Ki8KKyAgMCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAvKiB0cF9pdGVyICovCisgIDAsICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgLyogdHBfaXRlcm5leHQgKi8KKyAgYnBs b2Nfb2JqZWN0X21ldGhvZHMsICAgICAgICAgICAgICAgICAgICAgICAvKiB0 cF9tZXRob2RzICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgLyogdHBfbWVtYmVycyAqLworICBicGxvY19vYmpl Y3RfZ2V0c2V0LCAgICAgICAgICAgICAgICAgICAgICAgIC8qIHRwX2dldHNl dCAqLworICAwLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIC8qIHRwX2Jhc2UgKi8KKyAgMCwgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9kaWN0ICovCisgIDAsICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBf ZGVzY3JfZ2V0ICovCisgIDAsICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgLyogdHBfZGVzY3Jfc2V0ICovCisgIDAsICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogdHBfZGlj dG9mZnNldCAqLworICAwLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIC8qIHRwX2luaXQgKi8KKyAgMCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiB0cF9hbGxvYyAqLwor fTsKZGlmZiAtLWdpdCBhL2dkYi9weXRob24vcHktYnJlYWtwb2ludC5jIGIv Z2RiL3B5dGhvbi9weS1icmVha3BvaW50LmMKaW5kZXggMTk1ZWQyYi4uMjVl ZjYyZiAxMDA2NDQKLS0tIGEvZ2RiL3B5dGhvbi9weS1icmVha3BvaW50LmMK KysrIGIvZ2RiL3B5dGhvbi9weS1icmVha3BvaW50LmMKQEAgLTU4NCw2ICs1 ODQsNDMgQEAgYnBweV9nZXRfaWdub3JlX2NvdW50IChQeU9iamVjdCAqc2Vs Ziwgdm9pZCAqY2xvc3VyZSkKICAgcmV0dXJuIFB5SW50X0Zyb21Mb25nIChz ZWxmX2JwLT5icC0+aWdub3JlX2NvdW50KTsKIH0KIAorCisvKiBQeXRob24g ZnVuY3Rpb24gd2hpY2ggcmV0dXJucyB0aGUgQnBMb2NhdGlvbiBvYmplY3Rz IGFzc29jaWF0ZWQKKyAgIHdpdGggdGhpcyBicmVha3BvaW50LiAgKi8KKwor c3RhdGljIFB5T2JqZWN0ICoKK2JwcHlfbG9jYXRpb25zIChQeU9iamVjdCAq c2VsZiwgUHlPYmplY3QgKmFyZ3MpCit7CisgIGJyZWFrcG9pbnRfb2JqZWN0 ICpzZWxmX2JwID0gKGJyZWFrcG9pbnRfb2JqZWN0ICopIHNlbGY7CisgIFB5 T2JqZWN0ICpsaXN0LCAqdHVwbGU7CisgIHN0cnVjdCBicF9sb2NhdGlvbiAq bG9jOworICBpbnQgZXJyOworCisgIEJQUFlfUkVRVUlSRV9WQUxJRCAoc2Vs Zl9icCk7CisKKyAgbGlzdCA9IFB5TGlzdF9OZXcgKDApOworICBpZiAoIWxp c3QpCisgICAgcmV0dXJuIE5VTEw7CisKKyAgZXJyID0gMDsKKyAgZm9yIChs b2MgPSBzZWxmX2JwLT5icC0+bG9jOyBsb2M7IGxvYyA9IGxvYy0+bmV4dCkK KyAgICB7CisgICAgICBQeU9iamVjdCAqbG9jX29iaiA9ICBicGxvY2F0aW9u X3RvX2JwbG9jYXRpb25fb2JqZWN0IChsb2MpOworICAgICAgZXJyID0gUHlM aXN0X0FwcGVuZCAobGlzdCwgbG9jX29iaik7CisgICAgICBpZiAoZXJyID09 IC0xKQorICAgICAgICB7CisgICAgICAgICAgUHlfREVDUkVGIChsaXN0KTsK KyAgICAgICAgICByZXR1cm4gTlVMTDsKKyAgICAgICAgfQorICAgICAgUHlf REVDUkVGIChsb2Nfb2JqKTsKKyAgICB9CisKKyAgdHVwbGUgPSBQeUxpc3Rf QXNUdXBsZSAobGlzdCk7CisgIFB5X0RFQ1JFRiAobGlzdCk7CisKKyAgcmV0 dXJuIHR1cGxlOworfQorCiAvKiBQeXRob24gZnVuY3Rpb24gdG8gY3JlYXRl IGEgbmV3IGJyZWFrcG9pbnQuICAqLwogc3RhdGljIGludAogYnBweV9pbml0 IChQeU9iamVjdCAqc2VsZiwgUHlPYmplY3QgKmFyZ3MsIFB5T2JqZWN0ICpr d2FyZ3MpCkBAIC05NzUsNiArMTAxMiw4IEBAIHN0YXRpYyBQeU1ldGhvZERl ZiBicmVha3BvaW50X29iamVjdF9tZXRob2RzW10gPQogICAgICJSZXR1cm4g dHJ1ZSBpZiB0aGlzIGJyZWFrcG9pbnQgaXMgdmFsaWQsIGZhbHNlIGlmIG5v dC4iIH0sCiAgIHsgImRlbGV0ZSIsIGJwcHlfZGVsZXRlX2JyZWFrcG9pbnQs IE1FVEhfTk9BUkdTLAogICAgICJEZWxldGUgdGhlIHVuZGVybHlpbmcgR0RC IGJyZWFrcG9pbnQuIiB9LAorICB7ICJsb2NhdGlvbnMiLCBicHB5X2xvY2F0 aW9ucywgTUVUSF9OT0FSR1MsCisgICAgIkdldCBhIGxpc3Qgb2YgZ2RiLkJw TG9jYXRpb24gb2JqZWN0cyBhc3NvY2lhdGVkIHdpdGggdGhpcyBicmVha3Bv aW50LiIgfSwKICAgeyBOVUxMIH0gLyogU2VudGluZWwuICAqLwogfTsKIApk aWZmIC0tZ2l0IGEvZ2RiL3B5dGhvbi9weXRob24taW50ZXJuYWwuaCBiL2dk Yi9weXRob24vcHl0aG9uLWludGVybmFsLmgKaW5kZXggMzI4ZTVkOC4uMTQ2 MDhjMiAxMDA2NDQKLS0tIGEvZ2RiL3B5dGhvbi9weXRob24taW50ZXJuYWwu aAorKysgYi9nZGIvcHl0aG9uL3B5dGhvbi1pbnRlcm5hbC5oCkBAIC0xNjUs NiArMTY1LDkgQEAgdHlwZWRlZiBzdHJ1Y3QgYnJlYWtwb2ludF9vYmplY3QK IGV4dGVybiBicmVha3BvaW50X29iamVjdCAqYnBweV9wZW5kaW5nX29iamVj dDsKIAogCisvKiBEZWZpbmVkIGluIHB5LWJwbG9jLmMgKi8KK3R5cGVkZWYg c3RydWN0IGJwbG9jX29iamVjdCBicGxvY19vYmplY3Q7CisKIHR5cGVkZWYg c3RydWN0CiB7CiAgIFB5T2JqZWN0X0hFQUQKQEAgLTIxNyw2ICsyMjAsOCBA QCBQeU9iamVjdCAqcHNweV9nZXRfcHJpbnRlcnMgKFB5T2JqZWN0ICosIHZv aWQgKik7CiBQeU9iamVjdCAqb2JqZmlsZV90b19vYmpmaWxlX29iamVjdCAo c3RydWN0IG9iamZpbGUgKik7CiBQeU9iamVjdCAqb2JqZnB5X2dldF9wcmlu dGVycyAoUHlPYmplY3QgKiwgdm9pZCAqKTsKIAorUHlPYmplY3QgKmJwbG9j YXRpb25fdG9fYnBsb2NhdGlvbl9vYmplY3QgKHN0cnVjdCBicF9sb2NhdGlv biAqbG9jKTsKKwogdGhyZWFkX29iamVjdCAqY3JlYXRlX3RocmVhZF9vYmpl Y3QgKHN0cnVjdCB0aHJlYWRfaW5mbyAqdHApOwogdGhyZWFkX29iamVjdCAq ZmluZF90aHJlYWRfb2JqZWN0IChwdGlkX3QgcHRpZCk7CiBQeU9iamVjdCAq ZmluZF9pbmZlcmlvcl9vYmplY3QgKGludCBwaWQpOwpAQCAtMjQ1LDYgKzI1 MCw3IEBAIHZvaWQgZ2RicHlfaW5pdGlhbGl6ZV9wc3BhY2UgKHZvaWQpOwog dm9pZCBnZGJweV9pbml0aWFsaXplX29iamZpbGUgKHZvaWQpOwogdm9pZCBn ZGJweV9pbml0aWFsaXplX2JyZWFrcG9pbnRzICh2b2lkKTsKIHZvaWQgZ2Ri cHlfaW5pdGlhbGl6ZV9maW5pc2hicmVha3BvaW50cyAodm9pZCk7Cit2b2lk IGdkYnB5X2luaXRpYWxpemVfYnBsb2NhdGlvbiAodm9pZCk7CiB2b2lkIGdk YnB5X2luaXRpYWxpemVfbGF6eV9zdHJpbmcgKHZvaWQpOwogdm9pZCBnZGJw eV9pbml0aWFsaXplX3BhcmFtZXRlcnMgKHZvaWQpOwogdm9pZCBnZGJweV9p bml0aWFsaXplX3RocmVhZCAodm9pZCk7CmRpZmYgLS1naXQgYS9nZGIvcHl0 aG9uL3B5dGhvbi5jIGIvZ2RiL3B5dGhvbi9weXRob24uYwppbmRleCA1MjEy ZDRlLi5mYjg4YjVlIDEwMDY0NAotLS0gYS9nZGIvcHl0aG9uL3B5dGhvbi5j CisrKyBiL2dkYi9weXRob24vcHl0aG9uLmMKQEAgLTExMDEsNiArMTEwMSwx MiBAQCBnZGJweV9icmVha3BvaW50X2hhc19weV9jb25kIChzdHJ1Y3QgYnJl YWtwb2ludF9vYmplY3QgKmJwX29iaikKIAkJICAgICJzY3JpcHRpbmcgaXMg bm90IHN1cHBvcnRlZC4iKSk7CiB9CiAKK3ZvaWQKK2dkYnB5X2JwbG9jYXRp b25fZnJlZSAoc3RydWN0IGJyZWFrcG9pbnRfb2JqZWN0ICpicF9vYmopCit7 CisgIHJldHVybjsKK30KKwogI2VuZGlmIC8qIEhBVkVfUFlUSE9OICovCiAK IAwKQEAgLTEyNDQsNiArMTI1MCw3IEBAIG1lc3NhZ2UgPT0gYW4gZXJyb3Ig bWVzc2FnZSB3aXRob3V0IGEgc3RhY2sgd2lsbCBiZSBwcmludGVkLiIpLAog ICBnZGJweV9pbml0aWFsaXplX29iamZpbGUgKCk7CiAgIGdkYnB5X2luaXRp YWxpemVfYnJlYWtwb2ludHMgKCk7CiAgIGdkYnB5X2luaXRpYWxpemVfZmlu aXNoYnJlYWtwb2ludHMgKCk7CisgIGdkYnB5X2luaXRpYWxpemVfYnBsb2Nh dGlvbiAoKTsKICAgZ2RicHlfaW5pdGlhbGl6ZV9sYXp5X3N0cmluZyAoKTsK ICAgZ2RicHlfaW5pdGlhbGl6ZV90aHJlYWQgKCk7CiAgIGdkYnB5X2luaXRp YWxpemVfaW5mZXJpb3IgKCk7CmRpZmYgLS1naXQgYS9nZGIvcHl0aG9uL3B5 dGhvbi5oIGIvZ2RiL3B5dGhvbi9weXRob24uaAppbmRleCA5ZTQ2MWY3Li41 MTZhOTRjIDEwMDY0NAotLS0gYS9nZGIvcHl0aG9uL3B5dGhvbi5oCisrKyBi L2dkYi9weXRob24vcHl0aG9uLmgKQEAgLTQ3LDQgKzQ3LDYgQEAgaW50IGdk YnB5X3Nob3VsZF9zdG9wIChzdHJ1Y3QgYnJlYWtwb2ludF9vYmplY3QgKmJw X29iaik7CiAKIGludCBnZGJweV9icmVha3BvaW50X2hhc19weV9jb25kIChz dHJ1Y3QgYnJlYWtwb2ludF9vYmplY3QgKmJwX29iaik7CiAKK3ZvaWQgZ2Ri cHlfYnBsb2NhdGlvbl9mcmVlIChzdHJ1Y3QgYnBfbG9jYXRpb24gKmxvYyk7 CisKICNlbmRpZiAvKiBHREJfUFlUSE9OX0ggKi8KZGlmZiAtLWdpdCBhL2dk Yi90ZXN0c3VpdGUvZ2RiLnB5dGhvbi9weS1icmVha3BvaW50LmV4cCBiL2dk Yi90ZXN0c3VpdGUvZ2RiLnB5dGhvbi9weS1icmVha3BvaW50LmV4cAppbmRl eCA4ZWQzNzQyLi42YTFhNDNiIDEwMDY0NAotLS0gYS9nZGIvdGVzdHN1aXRl L2dkYi5weXRob24vcHktYnJlYWtwb2ludC5leHAKKysrIGIvZ2RiL3Rlc3Rz dWl0ZS9nZGIucHl0aG9uL3B5LWJyZWFrcG9pbnQuZXhwCkBAIC0zMDQsMyAr MzA0LDU1IEBAIGdkYl9weV90ZXN0X3NpbGVudF9jbWQgICJweXRob24gd3Ax ID0gd3BfZXZhbCAoXCJyZXN1bHRcIiwgdHlwZT1nZGIuQlBfV0FUQ0hQT0lO CiBnZGJfdGVzdCAiY29udGludWUiICIuKlxbV3dcXWF0Y2hwb2ludC4qcmVz dWx0LipPbGQgdmFsdWUgPS4qTmV3IHZhbHVlID0gNzg4LioiICJUZXN0IHdh dGNocG9pbnQgd3JpdGUiCiBnZGJfdGVzdCAicHl0aG9uIHByaW50IG5ldmVy X2V2YWxfYnAxLmNvdW50IiAiMCIgXAogICAgICJDaGVjayB0aGF0IHRoaXMg dW5yZWxhdGVkIGJyZWFrcG9pbnRzIGV2YWwgZnVuY3Rpb24gd2FzIG5ldmVy IGNhbGxlZC4iCisKKyMgZ2RiLkJwTG9jYXRpb24KKworIyBTdGFydCB3aXRo IGEgZnJlc2ggZ2RiLgorY2xlYW5fcmVzdGFydCAke3Rlc3RmaWxlfQorCitp ZiAhW3J1bnRvX21haW5dIHRoZW4geworICAgIGZhaWwgIkNhbm5vdCBydW4g dG8gbWFpbi4iCisgICAgcmV0dXJuIDAKK30KK2RlbGV0ZV9icmVha3BvaW50 cworZ2RiX3Rlc3Rfbm9fb3V0cHV0ICJzZXQgZGV0YWNoLW9uLWZvcmsgb2Zm IiAiZG9uJ3QgZGV0YWNoIG9uIGZvcmsiCitnZGJfdGVzdCAiY2FsbCBmb3Jr KCkiICJOZXcgcHJvY2VzcyAuKiIgImNyZWF0ZSBhIHNlY29uZCBpbmZlcmlv ciIKKworZ2RiX2JyZWFrcG9pbnQgIm1haW4iCitnZGJfdGVzdCAicHkgcHJp bnQgbGVuKGdkYi5icmVha3BvaW50cygpKSIgIjEiICJlbnN1cmUgdGhhdCB0 aHJlcmUgaXMgb25seSBvbmUgQlAiCitnZGJfdGVzdF9ub19vdXRwdXQge3B5 IGJwMCA9IGdkYi5icmVha3BvaW50cygpWzBdfSAic2F2ZSBicmVha3BvaW50 IDAiCitnZGJfdGVzdCAicHkgcHJpbnQgbGVuKGJwMC5sb2NhdGlvbnMoKSki ICIyIiAiZW5zdXJlIHRoYXQgdGhyZXJlIGFyZSAyIGxvY2F0aW9ucyIKKwor Z2RiX3Rlc3Rfbm9fb3V0cHV0IHtweSBsb2MwID0gYnAwLmxvY2F0aW9ucygp WzBdfSAic2F2ZSBsb2NhdGlvbiAwIgorZ2RiX3Rlc3Rfbm9fb3V0cHV0IHtw eSBsb2MxID0gYnAwLmxvY2F0aW9ucygpWzFdfSAic2F2ZSBsb2NhdGlvbiAx IgorCitnZGJfdGVzdCAicHkgcHJpbnQgbG9jMC5vd25lciA9PSBsb2MxLm93 bmVyID09IGJwMCIgIlRydWUiICJ2ZXJpZnkgb3duZXJzaGlwIgorZ2RiX3Rl c3QgInB5IHByaW50IGxvYzAuYWRkcmVzcyA9PSBsb2MxLmFkZHJlc3MgIiAi VHJ1ZSIgInZlcmlmeSBhZGRyZXNzZXMgYXJlIGlkZW50aWNhbCIKKyMgaG93 IHRvIGNoZWNrIGFkZHJlc3MgbG9jYXRpb24gPyAhPSBhZGRyZXNzKG1haW4p CisKK2dkYl90ZXN0IHtweSBwcmludCBsb2MwLmluZmVyaW9yID09IGdkYi5p bmZlcmlvcnMoKVswXX0gIlRydWUiICJ2ZXJpZnkgaW5mZXJpb3IgZm9yIGxv YyAwIiAjaW5mIDIKK2dkYl90ZXN0IHtweSBwcmludCBsb2MxLmluZmVyaW9y ID09IGdkYi5pbmZlcmlvcnMoKVsxXX0gIlRydWUiICJ2ZXJpZnkgaW5mZXJp b3IgZm9yIGxvYyAxIiAjaW5mIDEKKworZ2RiX3Rlc3QgInB5IHByaW50IGxv YzAuZW5hYmxlZCA9PSBsb2MxLmVuYWJsZWQgPT0gVHJ1ZSIgIlRydWUiICJ2 ZXJpZnkgdGhhdCBsb2NhdGlvbnMgYXJlIGVuYWJsZWQiCisKK2dkYl90ZXN0 ICJweSBwcmludCBsb2MwLmluZmVyaW9yLm51bSIgIjIiICJlbnN1cmUgdGhh dCBsb2MwIGlzIG9uIGluZmVyaW9yIDIiCisKK2dkYl90ZXN0ICJkZXRhY2gg aW5mZXJpb3IgMiIgIkRldGFjaGluZyBmcm9tIHByb2dyYW06LioiICJkZXRh Y2ggaW5mZXJpb3IgMiIKK2dkYl90ZXN0ICJpbmZlcmlvciAxIiAiU3dpdGNo aW5nIHRvIGluZmVyaW9yIC4qIiAic3dpdGNoIHRvIGluZmVyaW9yIDEiCitn ZGJfdGVzdF9ub19vdXRwdXQgInJlbW92ZS1pbmZlcmlvcnMgMiIgInJlbW92 ZSBpbmZlcmlvciAyIgorZ2RiX3Rlc3QgInB5IHByaW50IGxvYzAuaW5mZXJp b3IiICJOb25lIiAicmVtb3ZlZCBpbmZlcmlvciBzZXQgdG8gTm9uZSIKKwor ZGVsZXRlX2JyZWFrcG9pbnRzCitnZGJfdGVzdCAicHkgcHJpbnQgYnAwLmlz X3ZhbGlkKCkiICJGYWxzZSIgInZlcmlmeSB0aGF0IEJQIGhhcyBiZWVuIGlu dmFsaWRhdGVkIgorZ2RiX3Rlc3QgInB5IGJwMC5sb2NhdGlvbnMoKSIgIi4q UnVudGltZUVycm9yOiBCcmVha3BvaW50IC4qIGlzIGludmFsaWQuKiJcCisg ICAgICAgICAidmVyaWZ5IHRoYXQgbG9jYXRpb25zIGNhbid0IGFjY2Vzc2Vk IG9uIGFuIGludmFsaWQgYnJlYWtwb2ludCIKKyAgICAgICAgIAorZ2RiX3Rl c3QgInB5IHByaW50IGxvYzAuaXNfdmFsaWQoKSIgIkZhbHNlIiAidmVyaWZ5 IHRoYXQgbG9jYXRpb24gaXMgaW52YWxpZCIKK2dkYl90ZXN0ICJweSBwcmlu dCBsb2MwLm93bmVyIiAiLipSdW50aW1lRXJyb3I6IEJwTG9jYXRpb24gaW52 YWxpZC4qIlwKKyAgICAgICAgICJ2ZXJpZnkgdGhhdCBvd25lciBjYW4ndCBi ZSBhY2Nlc3NlZCIKK2dkYl90ZXN0ICJweSBwcmludCBsb2MwLmVuYWJsZWQi ICIuKlJ1bnRpbWVFcnJvcjogQnBMb2NhdGlvbiBpbnZhbGlkLioiXAorICAg ICAgICAgInZlcmlmeSB0aGF0IGxvY2F0aW9uIGNhbid0IGJlIGFjY2Vzc2Vk IgorZ2RiX3Rlc3QgInB5IHByaW50IGxvYzAuYWRkcmVzcyIgIi4qUnVudGlt ZUVycm9yOiBCcExvY2F0aW9uIGludmFsaWQuKiJcCisgICAgICAgICAidmVy aWZ5IHRoYXQgbG9jYXRpb24gY2FuJ3QgYmUgYWNjZXNzZWQiCitnZGJfdGVz dCAicHkgcHJpbnQgbG9jMC5pbmZlcmlvciIgIi4qUnVudGltZUVycm9yOiBC cExvY2F0aW9uIGludmFsaWQuKiJcCisgICAgICAgICAidmVyaWZ5IHRoYXQg aW5mZXJpb3IgY2FuJ3QgYmUgYWNjZXNzZWQiCi0tIAoxLjcuNi41Cgo= --bcaec54fb8144f474704b616f463--