Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1w2uF4-000iaY-0b for pgsql-hackers@arkaria.postgresql.org; Wed, 18 Mar 2026 16:59:34 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1w2uF2-00Cc7c-20 for pgsql-hackers@arkaria.postgresql.org; Wed, 18 Mar 2026 16:59:32 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1w2uF1-00Cc7T-2X for pgsql-hackers@lists.postgresql.org; Wed, 18 Mar 2026 16:59:32 +0000 Received: from mail-ed1-x52d.google.com ([2a00:1450:4864:20::52d]) by makus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1w2uEu-00000000OLm-11Sl for pgsql-hackers@postgresql.org; Wed, 18 Mar 2026 16:59:30 +0000 Received: by mail-ed1-x52d.google.com with SMTP id 4fb4d7f45d1cf-6652452d94aso200011a12.3 for ; Wed, 18 Mar 2026 09:59:25 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1773853164; cv=none; d=google.com; s=arc-20240605; b=ScyMBP3aHyTRR/apuWN451uYeCmYLskyCvxJPG8vhkreG9byFxoxXRc13XQdxsQ3x8 Fp3cvdTjn7702rHOY7FSgKeDzDCoRs8CrBPpdNnyCCZQe1oZrGgNcp59l8eacQsDeKei 2vFI5fo/+Shoils/THk+P8mETxKOzCSYWx++qXjkzlA+toNsS8+aJoVB+1NqaiRzvP3L yObgYyPVyn1Z4kix3YqfEBC9jJvBUkAK7F5+pa9PQ8/EDMU3om/X44OhJ/Xme5Yg7K3u 985CEYotdzIiMkTCE+eQBnYrwwDO3Puii/7tZ+bY0jMiC8UFZFBupBn7Y9JXiReqaE7X aXWA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:dkim-signature; bh=KTXUHLJGAlJbEyTrHhcW/zSb20vDMGT+/eTCwDPweY8=; fh=3tVi9dS0eBgdF7ksEfTi7G5mhm4UIbz9xGiNjPBf1q0=; b=DTAExodSH9TFqxdG825c7t/Wefs5qKAQ4EjAUFdOg7vmUBkiML9jvFVqffmxzwCycU vaVc0Ge3FzUh6Bo9pnUEFc4aeJDWCa8n2v2S9AyRceRkZMl5lSHxkmnfZL/sIatISpwB p3vQX/rC+5NkJ63wLQlYQ9Vm+UUZ6oT2dj7cXSk1JfsmtZLtnk0a9FnfI3HIy+UqUOqM rczK4I7BPnu7I4VvUt7/x8nJOW81nF8zHw3MYUpOJCHAL9mcaZxJX9Y7QuQzcfc8CCZQ 9S6vMsV+axBh74Qr7c3GTFa+mvDLJ9mav6gJEqNaPHwwUWAJSesfCznG61UIhk14is2t KUuQ==; darn=postgresql.org ARC-Authentication-Results: i=1; mx.google.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1773853164; x=1774457964; darn=postgresql.org; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=KTXUHLJGAlJbEyTrHhcW/zSb20vDMGT+/eTCwDPweY8=; b=aVK1HU1vFNn4nL/Cbd5wT09AY7eoe+vFZJGG2i0y68NOiwAJpzmi0dAMUUSXcc6KN4 p4mUgerA3s3hepNR6yk1u07suHAQZpHJzIwkwQQDR1VGtl9O+eU4oKE2EfUZxVE44kXP kndy1e7lNJv5wcFHbhxkZpOYBWCfieUqbRC6mSq3tYk8Igo7+EVBpWiWwxFnxI7ik+Om LAB99rN6sqi2n5yTGe/Swp6VuBzkLfgb8dRgyo/fWrpvCfrL2oemc/sMDfs9orWX6rHd e/uzQjnKNYCdSHprqR6b3kuR98WehGb22E/FC1fCmGNtRsGMQnNDJD1BiVMFZPhd/ZuO H7OQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1773853164; x=1774457964; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-gg:x-gm-message-state:from:to:cc:subject:date :message-id:reply-to; bh=KTXUHLJGAlJbEyTrHhcW/zSb20vDMGT+/eTCwDPweY8=; b=EJMaVQc+cGSQazjKqVjF5drHCmwvdAueyz22im57FtmxsbgAtFP1UN2nhfgM5BpTxC O9r8NAQfqpNc1FrLiXvogTgfBw0Y16cfKTxqsmNfqO2/Xm4TxFq3jkw9T+ZEdb9LsiSu C8V6JRwjdFTiLy2gT/cmEcCM4FwwlWMLsLsF6MK/LezUV/2ta28uB/M36PjKxJf6P39I rVmh1N2VPtsQFsun20L+kHJ6PrFdVyVZ/pKMdgYoUCIK22dFx9GZiatr6GV7diKncQ1s 9W+o/bpvjR0HHh1ow+yzUNY/zGlwsoJXVjKA8CXhSxY7dbrgx6s4aSVxocAn4d0pdpJB be9g== X-Forwarded-Encrypted: i=1; AJvYcCXPMhY7+S8ykWw+kOSOi5vQN+tkwGJ95bvLWXK5HyObMUb1HLNHgl3OC0ogqs4MwaQ4aaUs0Lp18RhGPHuA@postgresql.org X-Gm-Message-State: AOJu0Yz6CKUsYRE7k2qB6ctoEVqxY6w6zwT0w05FiULBEgqB/wz7pYhe jslqSJPOU4Gj+lCFR5/DM3r8WSKrK04tPUpeObMz6sivvPebxe8GbAhCt3hJLyXQV6bjjyxkM9x duqCnsiaRrwhrwxX3KMMA3N6QuggPyr8= X-Gm-Gg: ATEYQzzS6GnY2qNbipOogvigqQxys4xuSZrzDsCA1/G56h9tQcvGh+FUlG6z8mbNIn9 PPKXChHgeikZNCpyHjRjMFT12DaR7h1wAuIT0t/rw6dp8irjo3eBrhZZD44NiQ9dDIr/tVyUk4g 6N5v0bk0zkXAwL2anySn83+dz0RZQV53rv1gtBUfCMLQBUnatfIuewbjMY1tICOAktKDTcfDC9h 2IpM3b77bWx11VD4M6YBHetb32fFkHwTchm3YUle6ClCQbeXFta5KrLQdYPTKJS1ZJYkfvg2Rv0 uSKnP2sFolJTR2iILRdlIJZ86kWtFcUng1U0ubgeyeRUEYCt88yYrP76b1QSXJIamAfuq9d8XEj VA6c+sdgW X-Received: by 2002:a05:6402:51c6:b0:668:488a:d3e1 with SMTP id 4fb4d7f45d1cf-668488adc0emr437961a12.25.1773853164045; Wed, 18 Mar 2026 09:59:24 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Melanie Plageman Date: Wed, 18 Mar 2026 12:59:11 -0400 X-Gm-Features: AaiRm51a4y_faHT7cRWFX_4UwVtnQfWG79YsoPY_Bh4KXk766BxiqMKzeEX37fY Message-ID: Subject: Re: Don't synchronously wait for already-in-progress IO in read stream To: Andres Freund Cc: Nazir Bilal Yavuz , Thomas Munro , pgsql-hackers@postgresql.org, Peter Geoghegan , Tomas Vondra Content-Type: multipart/mixed; boundary="000000000000ba4671064d4f5fb2" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --000000000000ba4671064d4f5fb2 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Thanks for the review! Everything you suggested that I don't elaborate on below, I've just gone ahead and done in attached v6. On Tue, Mar 17, 2026 at 1:26=E2=80=AFPM Andres Freund = wrote: > > > --- a/src/backend/storage/buffer/bufmgr.c > > +++ b/src/backend/storage/buffer/bufmgr.c > > @@ -1990,7 +1990,7 @@ AsyncReadBuffers(ReadBuffersOperation *operation,= int *nblocks_progress) > > * must have started out as a miss in PinBufferForBlock()= . The other > > * backend will track this as a 'read'. > > */ > > - TRACE_POSTGRESQL_BUFFER_READ_DONE(forknum, blocknum + ope= ration->nblocks_done, > > + TRACE_POSTGRESQL_BUFFER_READ_DONE(forknum, blocknum + ope= ration->nblocks_done - 1, > > = operation->smgr->smgr_rlocator.locator.spcOid, > > = operation->smgr->smgr_rlocator.locator.dbOid, > > = operation->smgr->smgr_rlocator.locator.relNumber, > > -- > > Ah, the issue is that we already incremented nblocks_done, right? Maybe = it'd > be easier to understand if we stashed blocknum + nblocks_done into a loca= l > var, and use it in in both branches of if (!ReadBuffersCanStartIO())? > > This probably needs to be backpatched... 0003 in v6 does as you suggest. I'll backport it after a quick +1 here. > > Subject: [PATCH v5 4/5] Make buffer hit helper > > > @@ -1236,17 +1238,6 @@ PinBufferForBlock(Relation rel, > > persistence =3D=3D RELPERSISTENCE_PERMANENT || > > persistence =3D=3D RELPERSISTENCE_UNLOGGED)); > > > > - if (persistence =3D=3D RELPERSISTENCE_TEMP) > > - { > > - io_context =3D IOCONTEXT_NORMAL; > > - io_object =3D IOOBJECT_TEMP_RELATION; > > - } > > - else > > - { > > - io_context =3D IOContextForStrategy(strategy); > > - io_object =3D IOOBJECT_RELATION; > > - } > > - > > I'm mildly worried that this will lead to a bit worse code generation, th= e > compiler might have a harder time figuring out that io_context/io_object > doesn't change across multiple PinBufferForBlock calls. Although it alrea= dy > might be unable to do so (we don't mark IOContextForStrategy as > pure [1]). > > I kinda wonder if, for StartReadBuffersImpl(), we should go the opposite > direction, and explicitly look up IOContextForStrategy(strategy) *before*= the > actual_nblocks loop to make sure the compiler doesn't inject external fun= ction > calls (which will in all likelihood require register spilling etc). I added a separate patch to refactor the code to do this first (0004). > > @@ -1254,18 +1245,11 @@ PinBufferForBlock(Relation rel, > > = smgr->smgr_rlocator.backend); > > > > if (persistence =3D=3D RELPERSISTENCE_TEMP) > > And here it might end up adding a separate persistence =3D=3D RELPERSISTE= NCE_TEMP > branch in CountBufferHit(), I suspect the compiler may not be able to opt= imize > it away. And you think it is optimizing it away in PinBufferForBlock()? > At the very least I'd invert the call to CountBufferHit() and the > pgstat_count_buffer_read(), as the latter will probably prevent most > optimizations (due to the compiler not being able to prove that > (rel)->pgstat_info->counts.blocks_fetched is a different memory location = as > *foundPtr). I did this. I did not check the compiled code before or after though. > > +CountBufferHit(BufferAccessStrategy strategy, > > + Relation rel, char persistence, SMgrRelation s= mgr, > > + ForkNumber forknum, BlockNumber blocknum) > > I don't think "Count*" is a great name for something that does tracepoint= s and > vacuum cost balance accounting, the latter actually changes behavior of t= he > program due to the sleeps it injects. > > The first alternative I have is AccountForBufferHit(), not great, but sti= ll > seems a bit better. At some point, I had ProcessBufferHit(), but Bilal felt it implied the function did more than counting. I've changed it now to TrackBufferHit(). > > From 4d737fa14f333abc4ee6ade8cb0340530695e887 Mon Sep 17 00:00:00 2001 > > From: Melanie Plageman > > Date: Fri, 23 Jan 2026 14:00:31 -0500 > > Subject: [PATCH v5 5/5] Don't wait for already in-progress IO > > I wonder if might be worth splitting this up in a refactoring and a > "behavioural change" commit. Might be too complicated. > > Candidates for a split seem to be: > - Moving pgaio_io_acquire_nb() to earlier > - Introduce PrepareNewReadBufferIO/PrepareAdditionalReadBuffer without su= pport > for READ_BUFFER_IN_PROGRESS > - introduce READ_BUFFER_IN_PROGRESS I've done something like this in v6. > > + * Local version of PrepareNewReadBufferIO(). Here instead of localbuf= .c to > > + * avoid an external function call. > > + */ > > +static PrepareReadBuffer_Status > > +PrepareNewLocalReadBufferIO(ReadBuffersOperation *operation, > > + Buffer buffer) > > Hm, seems the test in 0002 should be extended to cover the the temp table= case. I did this. However, I was a bit lazy in how many cases I added because I used invalidate_rel_block(), which is pretty verbose (since evict_rel() doesn't work yet for local buffers). I don't think we'll be able to easily test READ_BUFFER_ALREADY_DONE (though perhaps we aren't testing it for shared buffers either?). > > +{ > > + BufferDesc *desc =3D GetLocalBufferDescriptor(-buffer - 1); > > + uint64 buf_state =3D pg_atomic_read_u64(&desc->state); > > + > > + /* Already valid, no work to do */ > > + if (buf_state & BM_VALID) > > + { > > + pgaio_wref_clear(&operation->io_wref); > > + return READ_BUFFER_ALREADY_DONE; > > + } > > Is this reachable for local buffers? Yes, I think this is reachable by local buffers that started the IO already and then completed it when acquiring a new IO handle at the top of AsyncReadBuffers(). > > + if (pgaio_wref_valid(&desc->io_wref)) > > + { > > + operation->io_wref =3D desc->io_wref; > > + operation->foreign_io =3D true; > > + return READ_BUFFER_IN_PROGRESS; > > + } > > + > > + /* > > + * While it is possible for a buffer to have been prepared for IO= but not > > + * yet had its wait reference set, there's no way for us to know = that for > > + * temporary buffers. Thus, we'll prepare for own IO on this buff= er. > > + */ > > + return READ_BUFFER_READY_FOR_IO; > > Is that actually possible? And would it be ok to just do start IO in that > case? You're right, that's not possible for local buffers. For local buffers, we "prepare for IO" by calling PrepareNewLocalReadBufferIO() and then set the wait ref in a codepath initiated by calling smgrstartreadv() as part of "staging" the IO. No one can observe that buffer in between the call to PrepareNewLocalReadBufferIO() and setting the wait reference. So, I've deleted the comment. > > +static PrepareReadBuffer_Status > > +PrepareNewReadBufferIO(ReadBuffersOperation *operation, > > + Buffer buffer) > > +{ > > I'm not sure I love "New" here, compared to "Additional". Perhaps "Begin"= & > "Continue"? Or "First" & "Additional"? Or ... I changed the names to PrepareHeadBufferReadIO() and PrepareAdditionalBufferReadIO(). "Head" instead of "First" because First felt like it implied the first buffer ever and head seems to make it clear it is the first buffer of this new IO. - Melanie --000000000000ba4671064d4f5fb2 Content-Type: text/x-patch; charset="US-ASCII"; name="v6-0001-aio-Refactor-tests-in-preparation-for-more-tests.patch" Content-Disposition: attachment; filename="v6-0001-aio-Refactor-tests-in-preparation-for-more-tests.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmwa8fcx0 RnJvbSA1M2YwMTBlNzA3MmZiNWJkYTlhMzQyYzMyZmI2MDM1ZGE0MWM5YzVjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZXMgRnJldW5kIDxhbmRyZXNAYW5hcmF6ZWwuZGU+CkRh dGU6IFR1ZSwgOSBTZXAgMjAyNSAxMDoxNDozNCAtMDQwMApTdWJqZWN0OiBbUEFUQ0ggdjYgMS84 XSBhaW86IFJlZmFjdG9yIHRlc3RzIGluIHByZXBhcmF0aW9uIGZvciBtb3JlIHRlc3RzCgpJbiBh IGZ1dHVyZSBjb21taXQgbW9yZSBBSU8gcmVsYXRlZCB0ZXN0cyBhcmUgZHVlIHRvIGJlIGludHJv ZHVjZWQuIEhvd2V2ZXIKMDAxX2Fpby5wbCBhbHJlYWR5IGlzIGZhaXJseSBsYXJnZS4KClRoaXMg Y29tbWl0IGludHJvZHVjZXMgYSBuZXcgVGVzdEFpbyBwYWNrYWdlIHdpdGggaGVscGVycyBmb3Ig d3JpdGluZyBBSU8KcmVsYXRlZCB0ZXN0cy4gVGhlbiBpdCB1c2VzIHRoZSBuZXcgaGVscGVycyB0 byBzaW1wbGlmeSB0aGUgZXhpc3RpbmcKMDAxX2Fpby5wbCBieSBpdGVyYXRpbmcgb3ZlciBhbGwg c3VwcG9ydGVkIGlvX21ldGhvZHMuIFRoaXMgd2lsbCBiZQpwYXJ0aWN1bGFybHkgaGVscGZ1bCBi ZWNhdXNlIGFkZGl0aW9uYWwgbWV0aG9kcyBhbHJlYWR5IGhhdmUgYmVlbiBzdWJtaXR0ZWQuCgpB ZGRpdGlvbmFsbHkgdGhpcyBjb21taXQgc3BsaXRzIG91dCB0ZXN0aW5nIG9mIGluaXRkYiB1c2lu ZyBhIG5vbi1kZWZhdWx0Cm1ldGhvZCBpbnRvIGl0cyBvd24gdGVzdC4gV2hpbGUgdGhhdCB0ZXN0 IGlzIHNvbWV3aGF0IGltcG9ydGFudCwgaXQncyBmYWlybHkKc2xvdyBhbmQgZG9lc24ndCBicmVh ayB0aGF0IG9mdGVuLiBGb3IgZGV2ZWxvcG1lbnQgdmVsb2NpdHkgaXQncyBoZWxwZnVsIGZvcgow MDFfYWlvLnBsIHRvIGJlIGZhc3Rlci4KCldoaWxlIHBhcnRpY3VsYXJseSB0aGUgbGF0dGVyIGNv dWxkIGJlbmVmaXQgZnJvbSBiZWluZyBpdHMgb3duIGNvbW1pdCwgaXQKc2VlbXMgdG8gaW50cm9k dWNlIG1vcmUgYmFjay1hbmQtZm9ydGggdGhhbiBpdCdzIHdvcnRoLgoKQXV0aG9yOiBBbmRyZXMg RnJldW5kIDxhbmRyZXNAYW5hcmF6ZWwuZGU+ClJldmlld2VkLWJ5OiBOYXppciBCaWxhbCBZYXZ1 eiA8YnlhdnV6ODFAZ21haWwuY29tPgpSZXZpZXdlZC1ieTogTWVsYW5pZSBQbGFnZW1hbiA8bWVs YW5pZXBsYWdlbWFuQGdtYWlsLmNvbT4KRGlzY3Vzc2lvbjogaHR0cHM6Ly9wb3N0Z3IuZXMvbS8K LS0tCiBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL21lc29uLmJ1aWxkICAgICB8ICAgMSArCiBz cmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL3QvMDAxX2Fpby5wbCAgICB8IDE0MSArKysrKysrLS0t LS0tLS0tLS0tLS0tCiBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL3QvMDAzX2luaXRkYi5wbCB8 ICA3MSArKysrKysrKysrKwogc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby90L1Rlc3RBaW8ucG0g ICAgfCAgOTAgKysrKysrKysrKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgMjA0IGluc2VydGlvbnMo KyksIDk5IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IHNyYy90ZXN0L21vZHVsZXMv dGVzdF9haW8vdC8wMDNfaW5pdGRiLnBsCiBjcmVhdGUgbW9kZSAxMDA2NDQgc3JjL3Rlc3QvbW9k dWxlcy90ZXN0X2Fpby90L1Rlc3RBaW8ucG0KCmRpZmYgLS1naXQgYS9zcmMvdGVzdC9tb2R1bGVz L3Rlc3RfYWlvL21lc29uLmJ1aWxkIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby9tZXNvbi5i dWlsZAppbmRleCBmZWZhMjViYzVhYi4uMThhNzk3ZjNhM2IgMTAwNjQ0Ci0tLSBhL3NyYy90ZXN0 L21vZHVsZXMvdGVzdF9haW8vbWVzb24uYnVpbGQKKysrIGIvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0 X2Fpby9tZXNvbi5idWlsZApAQCAtMzIsNiArMzIsNyBAQCB0ZXN0cyArPSB7CiAgICAgJ3Rlc3Rz JzogWwogICAgICAgJ3QvMDAxX2Fpby5wbCcsCiAgICAgICAndC8wMDJfaW9fd29ya2Vycy5wbCcs CisgICAgICAndC8wMDNfaW5pdGRiLnBsJywKICAgICBdLAogICB9LAogfQpkaWZmIC0tZ2l0IGEv c3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby90LzAwMV9haW8ucGwgYi9zcmMvdGVzdC9tb2R1bGVz L3Rlc3RfYWlvL3QvMDAxX2Fpby5wbAppbmRleCA1YzYzNGVjM2NhOS4uZTE4YjJhMmI4YWUgMTAw NjQ0Ci0tLSBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vdC8wMDFfYWlvLnBsCisrKyBiL3Ny Yy90ZXN0L21vZHVsZXMvdGVzdF9haW8vdC8wMDFfYWlvLnBsCkBAIC03LDEyNiArNyw1NiBAQCB1 c2UgUG9zdGdyZVNRTDo6VGVzdDo6Q2x1c3RlcjsKIHVzZSBQb3N0Z3JlU1FMOjpUZXN0OjpVdGls czsKIHVzZSBUZXN0OjpNb3JlOwogCit1c2UgRmluZEJpbjsKK3VzZSBsaWIgJEZpbmRCaW46OlJl YWxCaW47CiAKLSMjIwotIyBUZXN0IGlvX21ldGhvZD13b3JrZXIKLSMjIwotbXkgJG5vZGVfd29y a2VyID0gY3JlYXRlX25vZGUoJ3dvcmtlcicpOwotJG5vZGVfd29ya2VyLT5zdGFydCgpOwotCi10 ZXN0X2dlbmVyaWMoJ3dvcmtlcicsICRub2RlX3dvcmtlcik7Ci1TS0lQOgotewotCXNraXAgJ0lu amVjdGlvbiBwb2ludHMgbm90IHN1cHBvcnRlZCBieSB0aGlzIGJ1aWxkJywgMQotCSAgdW5sZXNz ICRFTlZ7ZW5hYmxlX2luamVjdGlvbl9wb2ludHN9IGVxICd5ZXMnOwotCXRlc3RfaW5qZWN0X3dv cmtlcignd29ya2VyJywgJG5vZGVfd29ya2VyKTsKLX0KK3VzZSBUZXN0QWlvOwogCi0kbm9kZV93 b3JrZXItPnN0b3AoKTsKK215IEBtZXRob2RzID0gVGVzdEFpbzo6c3VwcG9ydGVkX2lvX21ldGhv ZHMoKTsKK215ICVub2RlczsKIAogCiAjIyMKLSMgVGVzdCBpb19tZXRob2Q9aW9fdXJpbmcKKyMg Q3JlYXRlIGFuZCBjb25maWd1cmUgb25lIGluc3RhbmNlIGZvciBlYWNoIGlvX21ldGhvZAogIyMj CiAKLWlmIChoYXZlX2lvX3VyaW5nKCkpCitmb3JlYWNoIG15ICRtZXRob2QgKEBtZXRob2RzKQog ewotCW15ICRub2RlX3VyaW5nID0gY3JlYXRlX25vZGUoJ2lvX3VyaW5nJyk7Ci0JJG5vZGVfdXJp bmctPnN0YXJ0KCk7Ci0JdGVzdF9nZW5lcmljKCdpb191cmluZycsICRub2RlX3VyaW5nKTsKLQkk bm9kZV91cmluZy0+c3RvcCgpOwotfQotCi0KLSMjIwotIyBUZXN0IGlvX21ldGhvZD1zeW5jCi0j IyMKLQotbXkgJG5vZGVfc3luYyA9IGNyZWF0ZV9ub2RlKCdzeW5jJyk7CisJbXkgJG5vZGUgPSBQ b3N0Z3JlU1FMOjpUZXN0OjpDbHVzdGVyLT5uZXcoJG1ldGhvZCk7CiAKLSMganVzdCB0byBoYXZl IG9uZSB0ZXN0IG5vdCB1c2UgdGhlIGRlZmF1bHQgYXV0by10dW5pbmcKKwkkbm9kZXN7JG1ldGhv ZH0gPSAkbm9kZTsKKwkkbm9kZS0+aW5pdCgpOworCSRub2RlLT5hcHBlbmRfY29uZigncG9zdGdy ZXNxbC5jb25mJywgImlvX21ldGhvZD0kbWV0aG9kIik7CisJVGVzdEFpbzo6Y29uZmlndXJlKCRu b2RlKTsKK30KIAotJG5vZGVfc3luYy0+YXBwZW5kX2NvbmYoCisjIEp1c3QgdG8gaGF2ZSBvbmUg dGVzdCBub3QgdXNlIHRoZSBkZWZhdWx0IGF1dG8tdHVuaW5nCiskbm9kZXN7J3N5bmMnfS0+YXBw ZW5kX2NvbmYoCiAJJ3Bvc3RncmVzcWwuY29uZicsIHFxKAotaW9fbWF4X2NvbmN1cnJlbmN5PTQK KyBpb19tYXhfY29uY3VycmVuY3k9NAogKSk7CiAKLSRub2RlX3N5bmMtPnN0YXJ0KCk7Ci10ZXN0 X2dlbmVyaWMoJ3N5bmMnLCAkbm9kZV9zeW5jKTsKLSRub2RlX3N5bmMtPnN0b3AoKTsKLQotZG9u ZV90ZXN0aW5nKCk7Ci0KIAogIyMjCi0jIFRlc3QgSGVscGVycworIyBFeGVjdXRlIHRoZSB0ZXN0 cyBmb3IgZWFjaCBpb19tZXRob2QKICMjIwogCi1zdWIgY3JlYXRlX25vZGUKK2ZvcmVhY2ggbXkg JG1ldGhvZCAoQG1ldGhvZHMpCiB7Ci0JbG9jYWwgJFRlc3Q6OkJ1aWxkZXI6OkxldmVsID0gJFRl c3Q6OkJ1aWxkZXI6OkxldmVsICsgMTsKLQotCW15ICRpb19tZXRob2QgPSBzaGlmdDsKKwlteSAk bm9kZSA9ICRub2Rlc3skbWV0aG9kfTsKIAotCW15ICRub2RlID0gUG9zdGdyZVNRTDo6VGVzdDo6 Q2x1c3Rlci0+bmV3KCRpb19tZXRob2QpOwotCi0JIyBXYW50IHRvIHRlc3QgaW5pdGRiIGZvciBl YWNoIElPIG1ldGhvZCwgb3RoZXJ3aXNlIHdlIGNvdWxkIGp1c3QgcmV1c2UKLQkjIHRoZSBjbHVz dGVyLgotCSMKLQkjIFVuZm9ydHVuYXRlbHkgQ2x1c3Rlcjo6aW5pdCgpIHB1dHMgUEdfVEVTVF9J TklUREJfRVhUUkFfT1BUUyBhZnRlciB0aGUKLQkjIG9wdGlvbnMgc3BlY2lmaWVkIGJ5IC0+ZXh0 cmEsIGlmIHNvbWVib2R5IHB1dHMgLWMgaW9fbWV0aG9kPXh5eiBpbgotCSMgUEdfVEVTVF9JTklU REJfRVhUUkFfT1BUUyBpdCB3b3VsZCBicmVhayB0aGlzIHRlc3QuIEZpeCB0aGF0IHVwIGlmIHdl Ci0JIyBkZXRlY3QgaXQuCi0JbG9jYWwgJEVOVntQR19URVNUX0lOSVREQl9FWFRSQV9PUFRTfSA9 ICRFTlZ7UEdfVEVTVF9JTklUREJfRVhUUkFfT1BUU307Ci0JaWYgKGRlZmluZWQgJEVOVntQR19U RVNUX0lOSVREQl9FWFRSQV9PUFRTfQotCQkmJiAkRU5We1BHX1RFU1RfSU5JVERCX0VYVFJBX09Q VFN9ID1+IG0vaW9fbWV0aG9kPS8pCi0JewotCQkkRU5We1BHX1RFU1RfSU5JVERCX0VYVFJBX09Q VFN9IC49ICIgLWMgaW9fbWV0aG9kPSRpb19tZXRob2QiOwotCX0KLQotCSRub2RlLT5pbml0KGV4 dHJhID0+IFsgJy1jJywgImlvX21ldGhvZD0kaW9fbWV0aG9kIiBdKTsKLQotCSRub2RlLT5hcHBl bmRfY29uZigKLQkJJ3Bvc3RncmVzcWwuY29uZicsIHFxKAotc2hhcmVkX3ByZWxvYWRfbGlicmFy aWVzPXRlc3RfYWlvCi1sb2dfbWluX21lc3NhZ2VzID0gJ0RFQlVHMycKLWxvZ19zdGF0ZW1lbnQ9 YWxsCi1sb2dfZXJyb3JfdmVyYm9zaXR5PWRlZmF1bHQKLXJlc3RhcnRfYWZ0ZXJfY3Jhc2g9ZmFs c2UKLXRlbXBfYnVmZmVycz0xMDAKLSkpOworCSRub2RlLT5zdGFydCgpOworCXRlc3RfaW9fbWV0 aG9kKCRtZXRob2QsICRub2RlKTsKKwkkbm9kZS0+c3RvcCgpOworfQogCi0JIyBFdmVuIHRob3Vn aCB3ZSB1c2VkIC1jIGlvX21ldGhvZD0uLi4gYWJvdmUsIGlmIFRFTVBfQ09ORklHIHNldHMKLQkj IGlvX21ldGhvZCwgaXQnZCBvdmVycmlkZSB0aGUgc2V0dGluZyBwZXJzaXN0ZWQgYXQgaW5pdGRi IHRpbWUuIFdoaWxlCi0JIyB1c2luZyAoYW5kIGxhdGVyIHZlcmlmeWluZykgdGhlIHNldHRpbmcg ZnJvbSBpbml0ZGIgcHJvdmlkZXMgc29tZQotCSMgdmVyaWZpY2F0aW9uIG9mIGhhdmluZyB1c2Vk IHRoZSBpb19tZXRob2QgZHVyaW5nIGluaXRkYiwgaXQncyBwcm9iYWJseQotCSMgbm90IHdvcnRo IHRoZSBjb21wbGljYXRpb24gb2Ygb25seSBhcHBlbmRpbmcgaWYgdGhlIHZhcmlhYmxlIGlzIHNl dCBpbgotCSMgaW4gVEVNUF9DT05GSUcuCi0JJG5vZGUtPmFwcGVuZF9jb25mKAotCQkncG9zdGdy ZXNxbC5jb25mJywgcXEoCi1pb19tZXRob2Q9JGlvX21ldGhvZAotKSk7Citkb25lX3Rlc3Rpbmco KTsKIAotCW9rKDEsICIkaW9fbWV0aG9kOiBpbml0ZGIiKTsKIAotCXJldHVybiAkbm9kZTsKLX0K KyMjIworIyBUZXN0IEhlbHBlcnMKKyMjIwogCi1zdWIgaGF2ZV9pb191cmluZwotewotCSMgVG8g ZGV0ZWN0IGlmIGlvX3VyaW5nIGlzIHN1cHBvcnRlZCwgd2UgbG9vayBhdCB0aGUgZXJyb3IgbWVz c2FnZSBmb3IKLQkjIGFzc2lnbmluZyBhbiBpbnZhbGlkIHZhbHVlIHRvIGFuIGVudW0gR1VDLCB3 aGljaCBsaXN0cyBhbGwgdGhlIHZhbGlkCi0JIyBvcHRpb25zLiBXZSBuZWVkIHRvIHVzZSAtQyB0 byBkZWFsIHdpdGggcnVubmluZyBhcyBhZG1pbmlzdHJhdG9yIG9uCi0JIyB3aW5kb3dzLCB0aGUg c3VwZXJ1c2VyIGNoZWNrIGlzIG9taXR0ZWQgaWYgLUMgaXMgdXNlZC4KLQlteSAoJHN0ZG91dCwg JHN0ZGVycikgPQotCSAgcnVuX2NvbW1hbmQgW3F3KHBvc3RncmVzIC1DIGludmFsaWQgLWMgaW9f bWV0aG9kPWludmFsaWQpXTsKLQlkaWUgImNhbid0IGRldGVybWluZSBzdXBwb3J0ZWQgaW9fbWV0 aG9kIHZhbHVlcyIKLQkgIHVubGVzcyAkc3RkZXJyID1+IG0vQXZhaWxhYmxlIHZhbHVlczogKFte XC5dKylcLi87Ci0JbXkgJG1ldGhvZHMgPSAkMTsKLQlub3RlICJzdXBwb3J0ZWQgaW9fbWV0aG9k IHZhbHVlcyBhcmU6ICRtZXRob2RzIjsKLQotCXJldHVybiAoJG1ldGhvZHMgPX4gbS9pb191cmlu Zy8pID8gMSA6IDA7Ci19CiAKIHN1YiBwc3FsX2xpa2UKIHsKQEAgLTE0OTAsOCArMTQyMCw4IEBA IFNFTEVDVCByZWFkX3JlbF9ibG9ja19sbCgndGJsX2NzX2ZhaWwnLCAzLCBuYmxvY2tzPT4xLCB6 ZXJvX29uX2Vycm9yPT50cnVlKTspLAogfQogCiAKLSMgUnVuIGFsbCB0ZXN0cyB0aGF0IGFyZSBz dXBwb3J0ZWQgZm9yIGFsbCBpb19tZXRob2RzCi1zdWIgdGVzdF9nZW5lcmljCisjIFJ1biBhbGwg dGVzdHMgdGhhdCBmb3IgdGhlIHNwZWNpZmllZCBub2RlIC8gaW9fbWV0aG9kCitzdWIgdGVzdF9p b19tZXRob2QKIHsKIAlteSAkaW9fbWV0aG9kID0gc2hpZnQ7CiAJbXkgJG5vZGUgPSBzaGlmdDsK QEAgLTE1MjYsMTAgKzE0NTYsMjMgQEAgQ0hFQ0tQT0lOVDsKIAl0ZXN0X2lnbm9yZV9jaGVja3N1 bSgkaW9fbWV0aG9kLCAkbm9kZSk7CiAJdGVzdF9jaGVja3N1bV9jcmVhdGVkYigkaW9fbWV0aG9k LCAkbm9kZSk7CiAKKwkjIGdlbmVyaWMgaW5qZWN0aW9uIHRlc3RzCiAgIFNLSVA6CiAJewogCQlz a2lwICdJbmplY3Rpb24gcG9pbnRzIG5vdCBzdXBwb3J0ZWQgYnkgdGhpcyBidWlsZCcsIDEKIAkJ ICB1bmxlc3MgJEVOVntlbmFibGVfaW5qZWN0aW9uX3BvaW50c30gZXEgJ3llcyc7CiAJCXRlc3Rf aW5qZWN0KCRpb19tZXRob2QsICRub2RlKTsKIAl9CisKKwkjIHdvcmtlciBzcGVjaWZpYyBpbmpl Y3Rpb24gdGVzdHMKKwlpZiAoJGlvX21ldGhvZCBlcSAnd29ya2VyJykKKwl7CisJICBTS0lQOgor CQl7CisJCQlza2lwICdJbmplY3Rpb24gcG9pbnRzIG5vdCBzdXBwb3J0ZWQgYnkgdGhpcyBidWls ZCcsIDEKKwkJCSAgdW5sZXNzICRFTlZ7ZW5hYmxlX2luamVjdGlvbl9wb2ludHN9IGVxICd5ZXMn OworCisJCQl0ZXN0X2luamVjdF93b3JrZXIoJGlvX21ldGhvZCwgJG5vZGUpOworCQl9CisJfQog fQpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby90LzAwM19pbml0ZGIucGwg Yi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL3QvMDAzX2luaXRkYi5wbApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uYzAzYWU1OGQwMGEKLS0tIC9kZXYvbnVsbAorKysg Yi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL3QvMDAzX2luaXRkYi5wbApAQCAtMCwwICsxLDcx IEBACisjIENvcHlyaWdodCAoYykgMjAyNC0yMDI1LCBQb3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9w bWVudCBHcm91cAorIworIyBUZXN0IGluaXRkYiBmb3IgZWFjaCBJTyBtZXRob2QuIFRoaXMgaXMg ZG9uZSBzZXBhcmF0ZWx5IGZyb20gMDAxX2Fpby5wbCwgYXMKKyMgaXQgaXNuJ3QgZmFzdC4gVGhp cyB3YXkgdGhlIG1vcmUgY29tbW9ubHkgZmFpbGluZyAvIGhhY2tlZC1vbiAwMDFfYWlvLnBsIGNh bgorIyBiZSBpdGVyYXRlZCBvbiBtb3JlIHF1aWNrbHkuCisKK3VzZSBzdHJpY3Q7Cit1c2Ugd2Fy bmluZ3MgRkFUQUwgPT4gJ2FsbCc7Cit1c2UgUG9zdGdyZVNRTDo6VGVzdDo6Q2x1c3RlcjsKK3Vz ZSBQb3N0Z3JlU1FMOjpUZXN0OjpVdGlsczsKK3VzZSBUZXN0OjpNb3JlOworCit1c2UgRmluZEJp bjsKK3VzZSBsaWIgJEZpbmRCaW46OlJlYWxCaW47CisKK3VzZSBUZXN0QWlvOworCisKK2ZvcmVh Y2ggbXkgJG1ldGhvZCAoVGVzdEFpbzo6c3VwcG9ydGVkX2lvX21ldGhvZHMoKSkKK3sKKwl0ZXN0 X2NyZWF0ZV9ub2RlKCRtZXRob2QpOworfQorCitkb25lX3Rlc3RpbmcoKTsKKworCitzdWIgdGVz dF9jcmVhdGVfbm9kZQoreworCWxvY2FsICRUZXN0OjpCdWlsZGVyOjpMZXZlbCA9ICRUZXN0OjpC dWlsZGVyOjpMZXZlbCArIDE7CisKKwlteSAkaW9fbWV0aG9kID0gc2hpZnQ7CisKKwlteSAkbm9k ZSA9IFBvc3RncmVTUUw6OlRlc3Q6OkNsdXN0ZXItPm5ldygkaW9fbWV0aG9kKTsKKworCSMgV2Fu dCB0byB0ZXN0IGluaXRkYiBmb3IgZWFjaCBJTyBtZXRob2QsIG90aGVyd2lzZSB3ZSBjb3VsZCBq dXN0IHJldXNlCisJIyB0aGUgY2x1c3Rlci4KKwkjCisJIyBVbmZvcnR1bmF0ZWx5IENsdXN0ZXI6 OmluaXQoKSBwdXRzIFBHX1RFU1RfSU5JVERCX0VYVFJBX09QVFMgYWZ0ZXIgdGhlCisJIyBvcHRp b25zIHNwZWNpZmllZCBieSAtPmV4dHJhLCBpZiBzb21lYm9keSBwdXRzIC1jIGlvX21ldGhvZD14 eXogaW4KKwkjIFBHX1RFU1RfSU5JVERCX0VYVFJBX09QVFMgaXQgd291bGQgYnJlYWsgdGhpcyB0 ZXN0LiBGaXggdGhhdCB1cCBpZiB3ZQorCSMgZGV0ZWN0IGl0LgorCWxvY2FsICRFTlZ7UEdfVEVT VF9JTklUREJfRVhUUkFfT1BUU30gPSAkRU5We1BHX1RFU1RfSU5JVERCX0VYVFJBX09QVFN9Owor CWlmIChkZWZpbmVkICRFTlZ7UEdfVEVTVF9JTklUREJfRVhUUkFfT1BUU30KKwkJJiYgJEVOVntQ R19URVNUX0lOSVREQl9FWFRSQV9PUFRTfSA9fiBtL2lvX21ldGhvZD0vKQorCXsKKwkJJEVOVntQ R19URVNUX0lOSVREQl9FWFRSQV9PUFRTfSAuPSAiIC1jIGlvX21ldGhvZD0kaW9fbWV0aG9kIjsK Kwl9CisKKwkkbm9kZS0+aW5pdChleHRyYSA9PiBbICctYycsICJpb19tZXRob2Q9JGlvX21ldGhv ZCIgXSk7CisKKwlUZXN0QWlvOjpjb25maWd1cmUoJG5vZGUpOworCisJIyBFdmVuIHRob3VnaCB3 ZSB1c2VkIC1jIGlvX21ldGhvZD0uLi4gYWJvdmUsIGlmIFRFTVBfQ09ORklHIHNldHMKKwkjIGlv X21ldGhvZCwgaXQnZCBvdmVycmlkZSB0aGUgc2V0dGluZyBwZXJzaXN0ZWQgYXQgaW5pdGRiIHRp bWUuIFdoaWxlCisJIyB1c2luZyAoYW5kIGxhdGVyIHZlcmlmeWluZykgdGhlIHNldHRpbmcgZnJv bSBpbml0ZGIgcHJvdmlkZXMgc29tZQorCSMgdmVyaWZpY2F0aW9uIG9mIGhhdmluZyB1c2VkIHRo ZSBpb19tZXRob2QgZHVyaW5nIGluaXRkYiwgaXQncyBwcm9iYWJseQorCSMgbm90IHdvcnRoIHRo ZSBjb21wbGljYXRpb24gb2Ygb25seSBhcHBlbmRpbmcgaWYgdGhlIHZhcmlhYmxlIGlzIHNldCBp bgorCSMgaW4gVEVNUF9DT05GSUcuCisJJG5vZGUtPmFwcGVuZF9jb25mKAorCQkncG9zdGdyZXNx bC5jb25mJywgcXEoCitpb19tZXRob2Q9JGlvX21ldGhvZAorKSk7CisKKwlvaygxLCAiJGlvX21l dGhvZDogaW5pdGRiIik7CisKKwkkbm9kZS0+c3RhcnQoKTsKKwkkbm9kZS0+c3RvcCgpOworCW9r KDEsICIkaW9fbWV0aG9kOiBzdGFydCAmIHN0b3AiKTsKKworCXJldHVybiAkbm9kZTsKK30KZGlm ZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vdC9UZXN0QWlvLnBtIGIvc3JjL3Rl c3QvbW9kdWxlcy90ZXN0X2Fpby90L1Rlc3RBaW8ucG0KbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAuLjViYzgwYTliMTMwCi0tLSAvZGV2L251bGwKKysrIGIvc3JjL3Rlc3Qv bW9kdWxlcy90ZXN0X2Fpby90L1Rlc3RBaW8ucG0KQEAgLTAsMCArMSw5MCBAQAorIyBDb3B5cmln aHQgKGMpIDIwMjQtMjAyNSwgUG9zdGdyZVNRTCBHbG9iYWwgRGV2ZWxvcG1lbnQgR3JvdXAKKwor PXBvZAorCis9aGVhZDEgTkFNRQorCitUZXN0QWlvIC0gaGVscGVycyBmb3Igd3JpdGluZyBBSU8g cmVsYXRlZCB0ZXN0cworCis9Y3V0CisKK3BhY2thZ2UgVGVzdEFpbzsKKwordXNlIFBvc3RncmVT UUw6OlRlc3Q6OkNsdXN0ZXI7Cit1c2UgUG9zdGdyZVNRTDo6VGVzdDo6VXRpbHM7Cit1c2UgVGVz dDo6TW9yZTsKKworCis9cG9kCisKKz1oZWFkMSBNRVRIT0RTCisKKz1vdmVyCisKKz1pdGVtIFRl c3RBaW86OnN1cHBvcnRlZF9pb19tZXRob2RzKCkKKworUmV0dXJuIGFuIGFycmF5IG9mIGFsbCB0 aGUgc3VwcG9ydGVkIHZhbHVlcyBmb3IgdGhlIGlvX21ldGhvZCBHVUMKKworPWN1dAorCitzdWIg c3VwcG9ydGVkX2lvX21ldGhvZHMoKQoreworCW15IEBpb19tZXRob2RzID0gKCd3b3JrZXInKTsK KworCXB1c2goQGlvX21ldGhvZHMsICJpb191cmluZyIpIGlmIGhhdmVfaW9fdXJpbmcoKTsKKwor CSMgUmV0dXJuIHN5bmMgbGFzdCwgYXMgaXQgd2lsbCBsZWFzdCBjb21tb25seSBmYWlsCisJcHVz aChAaW9fbWV0aG9kcywgInN5bmMiKTsKKworCXJldHVybiBAaW9fbWV0aG9kczsKK30KKworCis9 aXRlbSBUZXN0QWlvOjpjb25maWd1cmUoKQorCitQcmVwYXJlIGEgY2x1c3RlciBmb3IgQUlPIHRl c3QKKworPWN1dAorCitzdWIgY29uZmlndXJlCit7CisJbXkgJG5vZGUgPSBzaGlmdDsKKworCSRu b2RlLT5hcHBlbmRfY29uZigKKwkJJ3Bvc3RncmVzcWwuY29uZicsIHFxKAorc2hhcmVkX3ByZWxv YWRfbGlicmFyaWVzPXRlc3RfYWlvCitsb2dfbWluX21lc3NhZ2VzID0gJ0RFQlVHMycKK2xvZ19z dGF0ZW1lbnQ9YWxsCitsb2dfZXJyb3JfdmVyYm9zaXR5PWRlZmF1bHQKK3Jlc3RhcnRfYWZ0ZXJf Y3Jhc2g9ZmFsc2UKK3RlbXBfYnVmZmVycz0xMDAKKykpOworCit9CisKKworPXBvZAorCis9aXRl bSBUZXN0QWlvOjpoYXZlX2lvX3VyaW5nKCkKKworUmV0dXJuIGlmIGlvX3VyaW5nIGlzIHN1cHBv cnRlZAorCis9Y3V0CisKK3N1YiBoYXZlX2lvX3VyaW5nCit7CisJIyBUbyBkZXRlY3QgaWYgaW9f dXJpbmcgaXMgc3VwcG9ydGVkLCB3ZSBsb29rIGF0IHRoZSBlcnJvciBtZXNzYWdlIGZvcgorCSMg YXNzaWduaW5nIGFuIGludmFsaWQgdmFsdWUgdG8gYW4gZW51bSBHVUMsIHdoaWNoIGxpc3RzIGFs bCB0aGUgdmFsaWQKKwkjIG9wdGlvbnMuIFdlIG5lZWQgdG8gdXNlIC1DIHRvIGRlYWwgd2l0aCBy dW5uaW5nIGFzIGFkbWluaXN0cmF0b3Igb24KKwkjIHdpbmRvd3MsIHRoZSBzdXBlcnVzZXIgY2hl Y2sgaXMgb21pdHRlZCBpZiAtQyBpcyB1c2VkLgorCW15ICgkc3Rkb3V0LCAkc3RkZXJyKSA9CisJ ICBydW5fY29tbWFuZCBbcXcocG9zdGdyZXMgLUMgaW52YWxpZCAtYyBpb19tZXRob2Q9aW52YWxp ZCldOworCWRpZSAiY2FuJ3QgZGV0ZXJtaW5lIHN1cHBvcnRlZCBpb19tZXRob2QgdmFsdWVzIgor CSAgdW5sZXNzICRzdGRlcnIgPX4gbS9BdmFpbGFibGUgdmFsdWVzOiAoW15cLl0rKVwuLzsKKwlt eSAkbWV0aG9kcyA9ICQxOworCW5vdGUgInN1cHBvcnRlZCBpb19tZXRob2QgdmFsdWVzIGFyZTog JG1ldGhvZHMiOworCisJcmV0dXJuICgkbWV0aG9kcyA9fiBtL2lvX3VyaW5nLykgPyAxIDogMDsK K30KKworMTsKLS0gCjIuNDMuMAoK --000000000000ba4671064d4f5fb2 Content-Type: text/x-patch; charset="US-ASCII"; name="v6-0002-test_aio-Add-read_stream-test-infrastructure-test.patch" Content-Disposition: attachment; filename="v6-0002-test_aio-Add-read_stream-test-infrastructure-test.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmwa8ir01 RnJvbSBkNTEwYjQ2NTMwYmQyMTljOTc2N2U0MmUwMmYwOTNkMzQ2MGJhYmVmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBBbmRyZXMgRnJldW5kIDxhbmRyZXNAYW5hcmF6ZWwuZGU+CkRh dGU6IFdlZCwgMTAgU2VwIDIwMjUgMTQ6MDA6MDIgLTA0MDAKU3ViamVjdDogW1BBVENIIHY2IDIv OF0gdGVzdF9haW86IEFkZCByZWFkX3N0cmVhbSB0ZXN0IGluZnJhc3RydWN0dXJlICYgdGVzdHMK CkF1dGhvcjogQW5kcmVzIEZyZXVuZCA8YW5kcmVzQGFuYXJhemVsLmRlPgpSZXZpZXdlZC1ieTog TmF6aXIgQmlsYWwgWWF2dXogPGJ5YXZ1ejgxQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6IE1lbGFu aWUgUGxhZ2VtYW4gPG1lbGFuaWVwbGFnZW1hbkBnbWFpbC5jb20+CkRpc2N1c3Npb246IGh0dHBz Oi8vcG9zdGdyLmVzL20vZmxhdC96bGplcmd3ZXF0aTd4NjdsZzVpamUycnpqdXNpZTM3bnNsc25r amtrYnk0bGFxcWJmdyU0MDNwM3p1NTIyeXlrdgotLS0KIHNyYy90ZXN0L21vZHVsZXMvdGVzdF9h aW8vbWVzb24uYnVpbGQgICAgICAgICB8ICAgMSArCiAuLi4vbW9kdWxlcy90ZXN0X2Fpby90LzAw NF9yZWFkX3N0cmVhbS5wbCAgICAgfCAyODYgKysrKysrKysrKysrKysrCiBzcmMvdGVzdC9tb2R1 bGVzL3Rlc3RfYWlvL3Rlc3RfYWlvLS0xLjAuc3FsICAgfCAgMjQgKy0KIHNyYy90ZXN0L21vZHVs ZXMvdGVzdF9haW8vdGVzdF9haW8uYyAgICAgICAgICB8IDM0NiArKysrKysrKysrKysrKystLS0K IHNyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0ICAgICAgICAgICAgICB8ICAgMSArCiA1 IGZpbGVzIGNoYW5nZWQsIDYwNyBpbnNlcnRpb25zKCspLCA1MSBkZWxldGlvbnMoLSkKIGNyZWF0 ZSBtb2RlIDEwMDY0NCBzcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL3QvMDA0X3JlYWRfc3RyZWFt LnBsCgpkaWZmIC0tZ2l0IGEvc3JjL3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby9tZXNvbi5idWlsZCBi L3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vbWVzb24uYnVpbGQKaW5kZXggMThhNzk3ZjNhM2Iu LjkwOWY4MWQ5NmMxIDEwMDY0NAotLS0gYS9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL21lc29u LmJ1aWxkCisrKyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vbWVzb24uYnVpbGQKQEAgLTMz LDYgKzMzLDcgQEAgdGVzdHMgKz0gewogICAgICAgJ3QvMDAxX2Fpby5wbCcsCiAgICAgICAndC8w MDJfaW9fd29ya2Vycy5wbCcsCiAgICAgICAndC8wMDNfaW5pdGRiLnBsJywKKyAgICAgICd0LzAw NF9yZWFkX3N0cmVhbS5wbCcsCiAgICAgXSwKICAgfSwKIH0KZGlmZiAtLWdpdCBhL3NyYy90ZXN0 L21vZHVsZXMvdGVzdF9haW8vdC8wMDRfcmVhZF9zdHJlYW0ucGwgYi9zcmMvdGVzdC9tb2R1bGVz L3Rlc3RfYWlvL3QvMDA0X3JlYWRfc3RyZWFtLnBsCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwLi4xN2E2OGUzNWMxZAotLS0gL2Rldi9udWxsCisrKyBiL3NyYy90ZXN0L21v ZHVsZXMvdGVzdF9haW8vdC8wMDRfcmVhZF9zdHJlYW0ucGwKQEAgLTAsMCArMSwyODYgQEAKKyMg Q29weXJpZ2h0IChjKSAyMDI1LCBQb3N0Z3JlU1FMIEdsb2JhbCBEZXZlbG9wbWVudCBHcm91cAor Cit1c2Ugc3RyaWN0OwordXNlIHdhcm5pbmdzIEZBVEFMID0+ICdhbGwnOworCit1c2UgUG9zdGdy ZVNRTDo6VGVzdDo6Q2x1c3RlcjsKK3VzZSBQb3N0Z3JlU1FMOjpUZXN0OjpVdGlsczsKK3VzZSBU ZXN0OjpNb3JlOworCit1c2UgRmluZEJpbjsKK3VzZSBsaWIgJEZpbmRCaW46OlJlYWxCaW47CisK K3VzZSBUZXN0QWlvOworCisKK215ICRub2RlID0gUG9zdGdyZVNRTDo6VGVzdDo6Q2x1c3Rlci0+ bmV3KCd0ZXN0Jyk7Ciskbm9kZS0+aW5pdCgpOworCiskbm9kZS0+YXBwZW5kX2NvbmYoCisJJ3Bv c3RncmVzcWwuY29uZicsIHFxKAorc2hhcmVkX3ByZWxvYWRfbGlicmFyaWVzPXRlc3RfYWlvCits b2dfbWluX21lc3NhZ2VzID0gJ0RFQlVHMycKK2xvZ19zdGF0ZW1lbnQ9YWxsCitsb2dfZXJyb3Jf dmVyYm9zaXR5PWRlZmF1bHQKK3Jlc3RhcnRfYWZ0ZXJfY3Jhc2g9ZmFsc2UKK3RlbXBfYnVmZmVy cz0xMDAKK21heF9jb25uZWN0aW9ucz04Citpb19tZXRob2Q9d29ya2VyCispKTsKKworJG5vZGUt PnN0YXJ0KCk7Cit0ZXN0X3NldHVwKCRub2RlKTsKKyRub2RlLT5zdG9wKCk7CisKKworZm9yZWFj aCBteSAkbWV0aG9kIChUZXN0QWlvOjpzdXBwb3J0ZWRfaW9fbWV0aG9kcygpKQoreworCSRub2Rl LT5hZGp1c3RfY29uZigncG9zdGdyZXNxbC5jb25mJywgJ2lvX21ldGhvZCcsICRtZXRob2QpOwor CSRub2RlLT5zdGFydCgpOworCXRlc3RfaW9fbWV0aG9kKCRtZXRob2QsICRub2RlKTsKKwkkbm9k ZS0+c3RvcCgpOworfQorCitkb25lX3Rlc3RpbmcoKTsKKworCitzdWIgdGVzdF9zZXR1cAorewor CW15ICRub2RlID0gc2hpZnQ7CisKKwkkbm9kZS0+c2FmZV9wc3FsKAorCQkncG9zdGdyZXMnLCBx cSgKK0NSRUFURSBFWFRFTlNJT04gdGVzdF9haW87CisKK0NSRUFURSBUQUJMRSBsYXJnZWlzaChr IGludCBub3QgbnVsbCkgV0lUSCAoRklMTEZBQ1RPUj0xMCk7CitJTlNFUlQgSU5UTyBsYXJnZWlz aChrKSBTRUxFQ1QgZ2VuZXJhdGVfc2VyaWVzKDEsIDEwMDAwKTsKKykpOworCW9rKDEsICJzZXR1 cCIpOworfQorCisKK3N1YiB0ZXN0X3JlcGVhdGVkX2Jsb2NrcworeworCW15ICRpb19tZXRob2Qg PSBzaGlmdDsKKwlteSAkbm9kZSA9IHNoaWZ0OworCisJbXkgJHBzcWwgPSAkbm9kZS0+YmFja2dy b3VuZF9wc3FsKCdwb3N0Z3JlcycsIG9uX2Vycm9yX3N0b3AgPT4gMCk7CisKKwkjIFByZXZlbnRp bmcgbGFyZ2VyIHJlYWRzIG1ha2VzIHRlc3RpbmcgZWFzaWVyCisJJHBzcWwtPnF1ZXJ5X3NhZmUo CisJCXFxLyBTRVQgaW9fY29tYmluZV9saW1pdCA9IDE7IC8pOworCisJIyB0ZXN0IG1pc3Mgb2Yg dGhlIHNhbWUgYmxvY2sgdHdpY2UgaW4gYSByb3cKKwkkcHNxbC0+cXVlcnlfc2FmZSgKKwkJcXEv IFNFTEVDVCBldmljdF9yZWwoJ2xhcmdlaXNoJyk7IC8pOworCisJIyBibG9jayAwIGdyb3dzIHRo ZSBkaXN0YW5jZSBlbm91Z2ggdGhhdCB0aGUgc3RyZWFtIHdpbGwgbG9vayBhaGVhZCBhbmQgdHJ5 CisJIyB0byBzdGFydCBhIHBlbmRpbmcgcmVhZCBmb3IgYmxvY2sgMiAoYW5kIGxhdGVyIGJsb2Nr IDQpIHR3aWNlIGJlZm9yZQorCSMgcmV0dXJuaW5nIGFueSBidWZmZXJzLgorCSRwc3FsLT5xdWVy eV9zYWZlKAorCQlxcS8gU0VMRUNUICogRlJPTSByZWFkX3N0cmVhbV9mb3JfYmxvY2tzKCdsYXJn ZWlzaCcsCisJCQlBUlJBWVswLCAyLCAyLCA0LCA0XSk7IC8pOworCisJb2soMSwgIiRpb19tZXRo b2Q6IHN0cmVhbSBtaXNzaW5nIHRoZSBzYW1lIGJsb2NrIHJlcGVhdGVkbHkiKTsKKworCSRwc3Fs LT5xdWVyeV9zYWZlKAorCQlxcS8gU0VMRUNUICogRlJPTSByZWFkX3N0cmVhbV9mb3JfYmxvY2tz KCdsYXJnZWlzaCcsCisJCQlBUlJBWVswLCAyLCAyLCA0LCA0XSk7IC8pOworCW9rKDEsICIkaW9f bWV0aG9kOiBzdHJlYW0gaGl0dGluZyB0aGUgc2FtZSBibG9jayByZXBlYXRlZGx5Iik7CisKKwkj IHRlc3QgaGl0IG9mIHRoZSBzYW1lIGJsb2NrIHR3aWNlIGluIGEgcm93CisJJHBzcWwtPnF1ZXJ5 X3NhZmUoCisJCXFxLyBTRUxFQ1QgZXZpY3RfcmVsKCdsYXJnZWlzaCcpOyAvKTsKKwkkcHNxbC0+ cXVlcnlfc2FmZSgKKwkJcXEvIFNFTEVDVCAqIEZST00gcmVhZF9zdHJlYW1fZm9yX2Jsb2Nrcygn bGFyZ2Vpc2gnLAorCQkJQVJSQVlbMCwgMSwgMiwgMywgNCwgNSwgNiwgNSwgNCwgMywgMiwgMSwg MF0pOyAvKTsKKwlvaygxLCAiJGlvX21ldGhvZDogc3RyZWFtIGFjY2Vzc2luZyBzYW1lIGJsb2Nr Iik7CisKKwkjIFRlc3QgcmVwZWF0ZWQgYmxvY2tzIHdpdGggYSB0ZW1wIHRhYmxlLCB1c2luZyBp bnZhbGlkYXRlX3JlbF9ibG9jaygpCisJIyB0byBldmljdCBpbmRpdmlkdWFsIGxvY2FsIGJ1ZmZl cnMuCisJJHBzcWwtPnF1ZXJ5X3NhZmUoCisJCXFxLyBDUkVBVEUgVEVNUCBUQUJMRSBsYXJnZWlz aF90ZW1wKGsgaW50IG5vdCBudWxsKSBXSVRIIChGSUxMRkFDVE9SPTEwKTsKKwkJCUlOU0VSVCBJ TlRPIGxhcmdlaXNoX3RlbXAoaykgU0VMRUNUIGdlbmVyYXRlX3NlcmllcygxLCAyMDApOyAvKTsK KworCSMgRXZpY3QgdGhlIHNwZWNpZmljIGJsb2NrcyB3ZSdsbCByZXF1ZXN0IHRvIGZvcmNlIG1p c3NlcworCSRwc3FsLT5xdWVyeV9zYWZlKAorCQlxcS8gU0VMRUNUIGludmFsaWRhdGVfcmVsX2Js b2NrKCdsYXJnZWlzaF90ZW1wJywgMCk7IC8pOworCSRwc3FsLT5xdWVyeV9zYWZlKAorCQlxcS8g U0VMRUNUIGludmFsaWRhdGVfcmVsX2Jsb2NrKCdsYXJnZWlzaF90ZW1wJywgMik7IC8pOworCSRw c3FsLT5xdWVyeV9zYWZlKAorCQlxcS8gU0VMRUNUIGludmFsaWRhdGVfcmVsX2Jsb2NrKCdsYXJn ZWlzaF90ZW1wJywgNCk7IC8pOworCisJJHBzcWwtPnF1ZXJ5X3NhZmUoCisJCXFxLyBTRUxFQ1Qg KiBGUk9NIHJlYWRfc3RyZWFtX2Zvcl9ibG9ja3MoJ2xhcmdlaXNoX3RlbXAnLAorCQkJQVJSQVlb MCwgMiwgMiwgNCwgNF0pOyAvKTsKKwlvaygxLCAiJGlvX21ldGhvZDogdGVtcCBzdHJlYW0gbWlz c2luZyB0aGUgc2FtZSBibG9jayByZXBlYXRlZGx5Iik7CisKKwkjIE5vdyB0aGUgYmxvY2tzIGFy ZSBjYWNoZWQsIHNvIHJlcGVhdGVkIGFjY2VzcyBzaG91bGQgYmUgaGl0cworCSRwc3FsLT5xdWVy eV9zYWZlKAorCQlxcS8gU0VMRUNUICogRlJPTSByZWFkX3N0cmVhbV9mb3JfYmxvY2tzKCdsYXJn ZWlzaF90ZW1wJywKKwkJCUFSUkFZWzAsIDIsIDIsIDQsIDRdKTsgLyk7CisJb2soMSwgIiRpb19t ZXRob2Q6IHRlbXAgc3RyZWFtIGhpdHRpbmcgdGhlIHNhbWUgYmxvY2sgcmVwZWF0ZWRseSIpOwor CisJJHBzcWwtPnF1aXQoKTsKK30KKworCitzdWIgdGVzdF9pbmplY3RfZm9yZWlnbgoreworCW15 ICRpb19tZXRob2QgPSBzaGlmdDsKKwlteSAkbm9kZSA9IHNoaWZ0OworCisJbXkgJHBzcWxfYSA9 ICRub2RlLT5iYWNrZ3JvdW5kX3BzcWwoJ3Bvc3RncmVzJywgb25fZXJyb3Jfc3RvcCA9PiAwKTsK KwlteSAkcHNxbF9iID0gJG5vZGUtPmJhY2tncm91bmRfcHNxbCgncG9zdGdyZXMnLCBvbl9lcnJv cl9zdG9wID0+IDApOworCisJbXkgJHBpZF9hID0gJHBzcWxfYS0+cXVlcnlfc2FmZShxcS9TRUxF Q1QgcGdfYmFja2VuZF9waWQoKTsvKTsKKworCisJIyMjCisJIyBUZXN0IHJlYWQgc3RyZWFtIGVu Y291bnRlcmluZyBidWZmZXJzIHVuZGVyZ29pbmcgSU8gaW4gYW5vdGhlciBiYWNrZW5kLAorCSMg d2l0aCB0aGUgb3RoZXIgYmFja2VuZCdzIHJlYWRzIHN1Y2NlZWRpbmcuCisJIyMjCisJJHBzcWxf YS0+cXVlcnlfc2FmZSgKKwkJcXEvIFNFTEVDVCBldmljdF9yZWwoJ2xhcmdlaXNoJyk7IC8pOwor CisJJHBzcWxfYi0+cXVlcnlfc2FmZSgKKwkJcXEvIFNFTEVDVCBpbmpfaW9fY29tcGxldGlvbl93 YWl0KHBpZD0+cGdfYmFja2VuZF9waWQoKSwKKwkJCXJlbGZpbGVub2RlPT5wZ19yZWxhdGlvbl9m aWxlbm9kZSgnbGFyZ2Vpc2gnKSk7IC8pOworCisJJHBzcWxfYi0+e3N0ZGlufSAuPSBxcS8gU0VM RUNUIHJlYWRfcmVsX2Jsb2NrX2xsKCdsYXJnZWlzaCcsCisJCWJsb2Nrbm89PjUsIG5ibG9ja3M9 PjEpO1xuLzsKKwkkcHNxbF9iLT57cnVufS0+cHVtcF9uYigpOworCisJJG5vZGUtPnBvbGxfcXVl cnlfdW50aWwoCisJCSdwb3N0Z3JlcycsIHFxLyBTRUxFQ1Qgd2FpdF9ldmVudCBGUk9NIHBnX3N0 YXRfYWN0aXZpdHkKKwkJCVdIRVJFIHdhaXRfZXZlbnQgPSAnY29tcGxldGlvbl93YWl0JzsgLywK KwkJJ2NvbXBsZXRpb25fd2FpdCcpOworCisJIyBCbG9jayA1IGlzIHVuZGVyZ29pbmcgSU8gaW4g c2Vzc2lvbiBiLCBzbyBzZXNzaW9uIGEgd2lsbCBtb3ZlIG9uIHRvIHN0YXJ0CisJIyBhIG5ldyBJ TyBmb3IgYmxvY2sgNy4KKwkkcHNxbF9hLT57c3RkaW59IC49IHFxLyBTRUxFQ1QgYXJyYXlfYWdn KGJsb2NrbnVtKSBGUk9NCisJCXJlYWRfc3RyZWFtX2Zvcl9ibG9ja3MoJ2xhcmdlaXNoJywgQVJS QVlbMCwgMiwgNSwgN10pO1xuLzsKKwkkcHNxbF9hLT57cnVufS0+cHVtcF9uYigpOworCisJJG5v ZGUtPnBvbGxfcXVlcnlfdW50aWwoJ3Bvc3RncmVzJywKKwkJcXEoU0VMRUNUIHdhaXRfZXZlbnQg RlJPTSBwZ19zdGF0X2FjdGl2aXR5IFdIRVJFIHBpZCA9ICRwaWRfYSksCisJCSdBaW9Jb0NvbXBs ZXRpb24nKTsKKworCSRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywgcXEvU0VMRUNUIGlual9p b19jb21wbGV0aW9uX2NvbnRpbnVlKCkvKTsKKworCXB1bXBfdW50aWwoCisJCSRwc3FsX2EtPnty dW59LCAkcHNxbF9hLT57dGltZW91dH0sCisJCVwkcHNxbF9hLT57c3Rkb3V0fSwgcXIvXHswLDIs NSw3XH0vKTsKKworCW9rKDEsIHFxLyRpb19tZXRob2Q6IHJlYWQgc3RyZWFtIGVuY291bnRlcnMg c3VjY2VlZGluZyBJTyBieSBhbm90aGVyIGJhY2tlbmQvKTsKKworCSMjIworCSMgVGVzdCByZWFk IHN0cmVhbSBlbmNvdW50ZXJpbmcgYnVmZmVycyB1bmRlcmdvaW5nIElPIGluIGFub3RoZXIgYmFj a2VuZCwKKwkjIHdpdGggdGhlIG90aGVyIGJhY2tlbmQncyByZWFkcyBmYWlsaW5nLgorCSMjIwor CSRwc3FsX2EtPnF1ZXJ5X3NhZmUoCisJCXFxLyBTRUxFQ1QgZXZpY3RfcmVsKCdsYXJnZWlzaCcp OyAvKTsKKworCSRwc3FsX2ItPnF1ZXJ5X3NhZmUoCisJCXFxLyBTRUxFQ1QgaW5qX2lvX2NvbXBs ZXRpb25fd2FpdChwaWQ9PnBnX2JhY2tlbmRfcGlkKCksCisJCQlyZWxmaWxlbm9kZT0+cGdfcmVs YXRpb25fZmlsZW5vZGUoJ2xhcmdlaXNoJykpOyAvKTsKKworCSRwc3FsX2ItPnF1ZXJ5X3NhZmUo CisJCXFxLyBTRUxFQ1QgaW5qX2lvX3Nob3J0X3JlYWRfYXR0YWNoKC1lcnJub19mcm9tX3N0cmlu ZygnRUlPJyksCisJCQlwaWQ9PnBnX2JhY2tlbmRfcGlkKCksCisJCQlyZWxmaWxlbm9kZT0+cGdf cmVsYXRpb25fZmlsZW5vZGUoJ2xhcmdlaXNoJykpOyAvKTsKKworCSRwc3FsX2ItPntzdGRpbn0g Lj0gcXEvIFNFTEVDVCByZWFkX3JlbF9ibG9ja19sbCgnbGFyZ2Vpc2gnLAorCQlibG9ja25vPT41 LCBuYmxvY2tzPT4xKTtcbi87CisJJHBzcWxfYi0+e3J1bn0tPnB1bXBfbmIoKTsKKworCSRub2Rl LT5wb2xsX3F1ZXJ5X3VudGlsKCdwb3N0Z3JlcycsCisJCXFxLyBTRUxFQ1Qgd2FpdF9ldmVudCBG Uk9NIHBnX3N0YXRfYWN0aXZpdHkKKwkJCVdIRVJFIHdhaXRfZXZlbnQgPSAnY29tcGxldGlvbl93 YWl0JzsgLywKKwkJJ2NvbXBsZXRpb25fd2FpdCcpOworCisJJHBzcWxfYS0+e3N0ZGlufSAuPSBx cS8gU0VMRUNUIGFycmF5X2FnZyhibG9ja251bSkgRlJPTQorCQlyZWFkX3N0cmVhbV9mb3JfYmxv Y2tzKCdsYXJnZWlzaCcsIEFSUkFZWzAsIDIsIDUsIDddKTtcbi87CisJJHBzcWxfYS0+e3J1bn0t PnB1bXBfbmIoKTsKKworCSRub2RlLT5wb2xsX3F1ZXJ5X3VudGlsKCdwb3N0Z3JlcycsCisJCXFx KFNFTEVDVCB3YWl0X2V2ZW50IEZST00gcGdfc3RhdF9hY3Rpdml0eSBXSEVSRSBwaWQgPSAkcGlk X2EpLAorCQknQWlvSW9Db21wbGV0aW9uJyk7CisKKwkkbm9kZS0+c2FmZV9wc3FsKCdwb3N0Z3Jl cycsIHFxL1NFTEVDVCBpbmpfaW9fY29tcGxldGlvbl9jb250aW51ZSgpLyk7CisKKwlwdW1wX3Vu dGlsKAorCQkkcHNxbF9hLT57cnVufSwgJHBzcWxfYS0+e3RpbWVvdXR9LAorCQlcJHBzcWxfYS0+ e3N0ZG91dH0sIHFyL1x7MCwyLDUsN1x9Lyk7CisKKwlwdW1wX3VudGlsKAorCQkkcHNxbF9iLT57 cnVufSwgJHBzcWxfYi0+e3RpbWVvdXR9LAorCQlcJHBzcWxfYi0+e3N0ZGVycn0sIHFyL0VSUk9S Lipjb3VsZCBub3QgcmVhZCBibG9ja3MgNVwuXC41Lyk7CisJb2soMSwgIiRpb19tZXRob2Q6IGlu amVjdGVkIGVycm9yIG9jY3VycmVkIik7CisJJHBzcWxfYi0+e3N0ZGVycn0gPSAnJzsKKwkkcHNx bF9iLT5xdWVyeV9zYWZlKHFxL1NFTEVDVCBpbmpfaW9fc2hvcnRfcmVhZF9kZXRhY2goKTsvKTsK KworCW9rKDEsCisJCXFxLyRpb19tZXRob2Q6IHJlYWQgc3RyZWFtIGVuY291bnRlcnMgZmFpbGlu ZyBJTyBieSBhbm90aGVyIGJhY2tlbmQvKTsKKworCisJIyMjCisJIyBUZXN0IHJlYWQgc3RyZWFt IGVuY291bnRlcmluZyB0d28gYnVmZmVycyB0aGF0IGFyZSB1bmRlcmdvaW5nIHRoZSBzYW1lCisJ IyBJTywgc3RhcnRlZCBieSBhbm90aGVyIGJhY2tlbmQuCisJIyMjCisJJHBzcWxfYS0+cXVlcnlf c2FmZSgKKwkJcXEvIFNFTEVDVCBldmljdF9yZWwoJ2xhcmdlaXNoJyk7IC8pOworCisJJHBzcWxf Yi0+cXVlcnlfc2FmZSgKKwkJcXEvIFNFTEVDVCBpbmpfaW9fY29tcGxldGlvbl93YWl0KHBpZD0+ cGdfYmFja2VuZF9waWQoKSwKKwkJCXJlbGZpbGVub2RlPT5wZ19yZWxhdGlvbl9maWxlbm9kZSgn bGFyZ2Vpc2gnKSk7IC8pOworCisJJHBzcWxfYi0+e3N0ZGlufSAuPSBxcS8gU0VMRUNUIHJlYWRf cmVsX2Jsb2NrX2xsKCdsYXJnZWlzaCcsCisJCWJsb2Nrbm89PjIsIG5ibG9ja3M9PjMpO1xuLzsK KwkkcHNxbF9iLT57cnVufS0+cHVtcF9uYigpOworCisJJG5vZGUtPnBvbGxfcXVlcnlfdW50aWwo J3Bvc3RncmVzJywKKwkJcXEvIFNFTEVDVCB3YWl0X2V2ZW50IEZST00gcGdfc3RhdF9hY3Rpdml0 eQorCQkJV0hFUkUgd2FpdF9ldmVudCA9ICdjb21wbGV0aW9uX3dhaXQnOyAvLAorCQknY29tcGxl dGlvbl93YWl0Jyk7CisKKwkjIEJsb2NrcyAyIGFuZCA0IGFyZSB1bmRlcmdvaW5nIElPIGluaXRp YXRlZCBieSBzZXNzaW9uIGEKKwkkcHNxbF9hLT57c3RkaW59IC49IHFxLyBTRUxFQ1QgYXJyYXlf YWdnKGJsb2NrbnVtKSBGUk9NCisJCXJlYWRfc3RyZWFtX2Zvcl9ibG9ja3MoJ2xhcmdlaXNoJywg QVJSQVlbMCwgMiwgNF0pO1xuLzsKKwkkcHNxbF9hLT57cnVufS0+cHVtcF9uYigpOworCisJJG5v ZGUtPnBvbGxfcXVlcnlfdW50aWwoJ3Bvc3RncmVzJywKKwkJcXEoU0VMRUNUIHdhaXRfZXZlbnQg RlJPTSBwZ19zdGF0X2FjdGl2aXR5IFdIRVJFIHBpZCA9ICRwaWRfYSksCisJCSdBaW9Jb0NvbXBs ZXRpb24nKTsKKworCSRub2RlLT5zYWZlX3BzcWwoJ3Bvc3RncmVzJywKKwkJcXEvIFNFTEVDVCBp bmpfaW9fY29tcGxldGlvbl9jb250aW51ZSgpIC8pOworCisJcHVtcF91bnRpbCgKKwkJJHBzcWxf YS0+e3J1bn0sICRwc3FsX2EtPnt0aW1lb3V0fSwKKwkJXCRwc3FsX2EtPntzdGRvdXR9LCBxci9c ezAsMiw0XH0vKTsKKworCW9rKDEsIHFxLyRpb19tZXRob2Q6IHJlYWQgc3RyZWFtIGVuY291bnRl cnMgdHdvIGJ1ZmZlciByZWFkIGluIG9uZSBJTy8pOworCisJJHBzcWxfYS0+cXVpdCgpOworCSRw c3FsX2ItPnF1aXQoKTsKK30KKworCitzdWIgdGVzdF9pb19tZXRob2QKK3sKKwlteSAkaW9fbWV0 aG9kID0gc2hpZnQ7CisJbXkgJG5vZGUgPSBzaGlmdDsKKworCWlzKCRub2RlLT5zYWZlX3BzcWwo J3Bvc3RncmVzJywgJ1NIT1cgaW9fbWV0aG9kJyksCisJCSRpb19tZXRob2QsICIkaW9fbWV0aG9k OiBpb19tZXRob2Qgc2V0IGNvcnJlY3RseSIpOworCisJdGVzdF9yZXBlYXRlZF9ibG9ja3MoJGlv X21ldGhvZCwgJG5vZGUpOworCisgIFNLSVA6CisJeworCQlza2lwICdJbmplY3Rpb24gcG9pbnRz IG5vdCBzdXBwb3J0ZWQgYnkgdGhpcyBidWlsZCcsIDEKKwkJICB1bmxlc3MgJEVOVntlbmFibGVf aW5qZWN0aW9uX3BvaW50c30gZXEgJ3llcyc7CisJCXRlc3RfaW5qZWN0X2ZvcmVpZ24oJGlvX21l dGhvZCwgJG5vZGUpOworCX0KK30KZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9h aW8vdGVzdF9haW8tLTEuMC5zcWwgYi9zcmMvdGVzdC9tb2R1bGVzL3Rlc3RfYWlvL3Rlc3RfYWlv LS0xLjAuc3FsCmluZGV4IGU0OTU0ODFjNDFlLi4xY2M0NzM0YTc0NiAxMDA2NDQKLS0tIGEvc3Jj L3Rlc3QvbW9kdWxlcy90ZXN0X2Fpby90ZXN0X2Fpby0tMS4wLnNxbAorKysgYi9zcmMvdGVzdC9t b2R1bGVzL3Rlc3RfYWlvL3Rlc3RfYWlvLS0xLjAuc3FsCkBAIC0zMyw2ICszMywxMCBAQCBDUkVB VEUgRlVOQ1RJT04gcmVhZF9yZWxfYmxvY2tfbGwoCiBSRVRVUk5TIHBnX2NhdGFsb2cudm9pZCBT VFJJQ1QKIEFTICdNT0RVTEVfUEFUSE5BTUUnIExBTkdVQUdFIEM7CiAKK0NSRUFURSBGVU5DVElP TiBldmljdF9yZWwocmVsIHJlZ2NsYXNzKQorUkVUVVJOUyBwZ19jYXRhbG9nLnZvaWQgU1RSSUNU CitBUyAnTU9EVUxFX1BBVEhOQU1FJyBMQU5HVUFHRSBDOworCiBDUkVBVEUgRlVOQ1RJT04gaW52 YWxpZGF0ZV9yZWxfYmxvY2socmVsIHJlZ2NsYXNzLCBibG9ja25vIGludCkKIFJFVFVSTlMgcGdf Y2F0YWxvZy52b2lkIFNUUklDVAogQVMgJ01PRFVMRV9QQVRITkFNRScgTEFOR1VBR0UgQzsKQEAg LTUwLDYgKzU0LDE0IEBAIFJFVFVSTlMgcGdfY2F0YWxvZy52b2lkIFNUUklDVAogQVMgJ01PRFVM RV9QQVRITkFNRScgTEFOR1VBR0UgQzsKIAogCisvKgorICogUmVhZCBzdHJlYW0gcmVsYXRlZCBm dW5jdGlvbnMKKyAqLworQ1JFQVRFIEZVTkNUSU9OIHJlYWRfc3RyZWFtX2Zvcl9ibG9ja3MocmVs IHJlZ2NsYXNzLCBibG9ja3MgaW50NFtdLCBPVVQgYmxvY2tvZmYgaW50NCwgT1VUIGJsb2NrbnVt IGludDQsIE9VVCBidWYgaW50NCkKK1JFVFVSTlMgU0VUT0YgcmVjb3JkIFNUUklDVAorQVMgJ01P RFVMRV9QQVRITkFNRScgTEFOR1VBR0UgQzsKKworCiAKIC8qCiAgKiBIYW5kbGUgcmVsYXRlZCBm dW5jdGlvbnMKQEAgLTkxLDggKzEwMywxNiBAQCBBUyAnTU9EVUxFX1BBVEhOQU1FJyBMQU5HVUFH RSBDOwogLyoKICAqIEluamVjdGlvbiBwb2ludCByZWxhdGVkIGZ1bmN0aW9ucwogICovCi1DUkVB VEUgRlVOQ1RJT04gaW5qX2lvX3Nob3J0X3JlYWRfYXR0YWNoKHJlc3VsdCBpbnQpCi1SRVRVUk5T IHBnX2NhdGFsb2cudm9pZCBTVFJJQ1QKK0NSRUFURSBGVU5DVElPTiBpbmpfaW9fY29tcGxldGlv bl93YWl0KHBpZCBpbnQgREVGQVVMVCBOVUxMLCByZWxmaWxlbm9kZSBvaWQgREVGQVVMVCAwKQor UkVUVVJOUyBwZ19jYXRhbG9nLnZvaWQKK0FTICdNT0RVTEVfUEFUSE5BTUUnIExBTkdVQUdFIEM7 CisKK0NSRUFURSBGVU5DVElPTiBpbmpfaW9fY29tcGxldGlvbl9jb250aW51ZSgpCitSRVRVUk5T IHBnX2NhdGFsb2cudm9pZAorQVMgJ01PRFVMRV9QQVRITkFNRScgTEFOR1VBR0UgQzsKKworQ1JF QVRFIEZVTkNUSU9OIGlual9pb19zaG9ydF9yZWFkX2F0dGFjaChyZXN1bHQgaW50LCBwaWQgaW50 IERFRkFVTFQgTlVMTCwgcmVsZmlsZW5vZGUgb2lkIERFRkFVTFQgMCkKK1JFVFVSTlMgcGdfY2F0 YWxvZy52b2lkCiBBUyAnTU9EVUxFX1BBVEhOQU1FJyBMQU5HVUFHRSBDOwogCiBDUkVBVEUgRlVO Q1RJT04gaW5qX2lvX3Nob3J0X3JlYWRfZGV0YWNoKCkKZGlmZiAtLWdpdCBhL3NyYy90ZXN0L21v ZHVsZXMvdGVzdF9haW8vdGVzdF9haW8uYyBiL3NyYy90ZXN0L21vZHVsZXMvdGVzdF9haW8vdGVz dF9haW8uYwppbmRleCBiMWFhOGFmOWVjMC4uMDYxZjBjOWY5MmEgMTAwNjQ0Ci0tLSBhL3NyYy90 ZXN0L21vZHVsZXMvdGVzdF9haW8vdGVzdF9haW8uYworKysgYi9zcmMvdGVzdC9tb2R1bGVzL3Rl c3RfYWlvL3Rlc3RfYWlvLmMKQEAgLTE5LDE3ICsxOSwyNiBAQAogI2luY2x1ZGUgInBvc3RncmVz LmgiCiAKICNpbmNsdWRlICJhY2Nlc3MvcmVsYXRpb24uaCIKKyNpbmNsdWRlICJjYXRhbG9nL3Bn X3R5cGUuaCIKICNpbmNsdWRlICJmbWdyLmgiCisjaW5jbHVkZSAiZnVuY2FwaS5oIgogI2luY2x1 ZGUgInN0b3JhZ2UvYWlvLmgiCiAjaW5jbHVkZSAic3RvcmFnZS9haW9faW50ZXJuYWwuaCIKICNp bmNsdWRlICJzdG9yYWdlL2J1Zl9pbnRlcm5hbHMuaCIKICNpbmNsdWRlICJzdG9yYWdlL2J1Zm1n ci5oIgogI2luY2x1ZGUgInN0b3JhZ2UvY2hlY2tzdW0uaCIKKyNpbmNsdWRlICJzdG9yYWdlL2Nv bmRpdGlvbl92YXJpYWJsZS5oIgogI2luY2x1ZGUgInN0b3JhZ2UvaXBjLmgiCiAjaW5jbHVkZSAi c3RvcmFnZS9sd2xvY2suaCIKKyNpbmNsdWRlICJzdG9yYWdlL3Byb2MuaCIKKyNpbmNsdWRlICJz dG9yYWdlL3Byb2NudW1iZXIuaCIKKyNpbmNsdWRlICJzdG9yYWdlL3JlYWRfc3RyZWFtLmgiCisj aW5jbHVkZSAidXRpbHMvYXJyYXkuaCIKICNpbmNsdWRlICJ1dGlscy9idWlsdGlucy5oIgogI2lu Y2x1ZGUgInV0aWxzL2luamVjdGlvbl9wb2ludC5oIgogI2luY2x1ZGUgInV0aWxzL3JlbC5oIgor I2luY2x1ZGUgInV0aWxzL3R1cGxlc3RvcmUuaCIKKyNpbmNsdWRlICJ1dGlscy93YWl0X2V2ZW50 LmgiCiAKIAogUEdfTU9EVUxFX01BR0lDOwpAQCAtMzcsMTMgKzQ2LDMwIEBAIFBHX01PRFVMRV9N QUdJQzsKIAogdHlwZWRlZiBzdHJ1Y3QgSW5qSW9FcnJvclN0YXRlCiB7CisJQ29uZGl0aW9uVmFy aWFibGUgY3Y7CisKIAlib29sCQllbmFibGVkX3Nob3J0X3JlYWQ7CiAJYm9vbAkJZW5hYmxlZF9y ZW9wZW47CiAKKwlib29sCQllbmFibGVkX2NvbXBsZXRpb25fd2FpdDsKKwlPaWQJCQljb21wbGV0 aW9uX3dhaXRfcmVsZmlsZW5vZGU7CisJcGlkX3QJCWNvbXBsZXRpb25fd2FpdF9waWQ7CisJdWlu dDMyCQljb21wbGV0aW9uX3dhaXRfZXZlbnQ7CisKIAlib29sCQlzaG9ydF9yZWFkX3Jlc3VsdF9z ZXQ7CisJT2lkCQkJc2hvcnRfcmVhZF9yZWxmaWxlbm9kZTsKKwlwaWRfdAkJc2hvcnRfcmVhZF9w aWQ7CiAJaW50CQkJc2hvcnRfcmVhZF9yZXN1bHQ7CiB9IEluaklvRXJyb3JTdGF0ZTsKIAordHlw ZWRlZiBzdHJ1Y3QgQmxvY2tzUmVhZFN0cmVhbURhdGEKK3sKKwlpbnQJCQluYmxvY2tzOworCWlu dAkJCWN1cmJsb2NrOworCXVpbnQzMgkgICAqYmxvY2tzOworfSBCbG9ja3NSZWFkU3RyZWFtRGF0 YTsKKworCiBzdGF0aWMgSW5qSW9FcnJvclN0YXRlICppbmpfaW9fZXJyb3Jfc3RhdGU7CiAKIC8q IFNoYXJlZCBtZW1vcnkgaW5pdCBjYWxsYmFja3MgKi8KQEAgLTg1LDEwICsxMTEsMTMgQEAgdGVz dF9haW9fc2htZW1fc3RhcnR1cCh2b2lkKQogCQlpbmpfaW9fZXJyb3Jfc3RhdGUtPmVuYWJsZWRf c2hvcnRfcmVhZCA9IGZhbHNlOwogCQlpbmpfaW9fZXJyb3Jfc3RhdGUtPmVuYWJsZWRfcmVvcGVu ID0gZmFsc2U7CiAKKwkJQ29uZGl0aW9uVmFyaWFibGVJbml0KCZpbmpfaW9fZXJyb3Jfc3RhdGUt PmN2KTsKKwkJaW5qX2lvX2Vycm9yX3N0YXRlLT5jb21wbGV0aW9uX3dhaXRfZXZlbnQgPSBXYWl0 RXZlbnRJbmplY3Rpb25Qb2ludE5ldygiY29tcGxldGlvbl93YWl0Iik7CisKICNpZmRlZiBVU0Vf SU5KRUNUSU9OX1BPSU5UUwogCQlJbmplY3Rpb25Qb2ludEF0dGFjaCgiYWlvLXByb2Nlc3MtY29t cGxldGlvbi1iZWZvcmUtc2hhcmVkIiwKIAkJCQkJCQkgInRlc3RfYWlvIiwKLQkJCQkJCQkgImlu al9pb19zaG9ydF9yZWFkIiwKKwkJCQkJCQkgImlual9pb19jb21wbGV0aW9uX2hvb2siLAogCQkJ CQkJCSBOVUxMLAogCQkJCQkJCSAwKTsKIAkJSW5qZWN0aW9uUG9pbnRMb2FkKCJhaW8tcHJvY2Vz cy1jb21wbGV0aW9uLWJlZm9yZS1zaGFyZWQiKTsKQEAgLTM4NCw3ICs0MTMsNyBAQCByZWFkX3Jl bF9ibG9ja19sbChQR19GVU5DVElPTl9BUkdTKQogCWlmIChuYmxvY2tzIDw9IDAgfHwgbmJsb2Nr cyA+IFBHX0lPVl9NQVgpCiAJCWVsb2coRVJST1IsICJuYmxvY2tzIGlzIG91dCBvZiByYW5nZSIp OwogCi0JcmVsID0gcmVsYXRpb25fb3BlbihyZWxpZCwgQWNjZXNzRXhjbHVzaXZlTG9jayk7CisJ cmVsID0gcmVsYXRpb25fb3BlbihyZWxpZCwgQWNjZXNzU2hhcmVMb2NrKTsKIAogCWZvciAoaW50 IGkgPSAwOyBpIDwgbmJsb2NrczsgaSsrKQogCXsKQEAgLTQ1OCw2ICs0ODcsMjcgQEAgcmVhZF9y ZWxfYmxvY2tfbGwoUEdfRlVOQ1RJT05fQVJHUykKIAlQR19SRVRVUk5fVk9JRCgpOwogfQogCitQ R19GVU5DVElPTl9JTkZPX1YxKGV2aWN0X3JlbCk7CitEYXR1bQorZXZpY3RfcmVsKFBHX0ZVTkNU SU9OX0FSR1MpCit7CisJT2lkCQkJcmVsaWQgPSBQR19HRVRBUkdfT0lEKDApOworCVJlbGF0aW9u CXJlbDsKKwlpbnQzMgkJYnVmZmVyc19ldmljdGVkLAorCQkJCWJ1ZmZlcnNfZmx1c2hlZCwKKwkJ CQlidWZmZXJzX3NraXBwZWQ7CisKKwlyZWwgPSByZWxhdGlvbl9vcGVuKHJlbGlkLCBBY2Nlc3NF eGNsdXNpdmVMb2NrKTsKKworCUV2aWN0UmVsVW5waW5uZWRCdWZmZXJzKHJlbCwgJmJ1ZmZlcnNf ZXZpY3RlZCwgJmJ1ZmZlcnNfZmx1c2hlZCwKKwkJCQkJCQkmYnVmZmVyc19za2lwcGVkKTsKKwor CXJlbGF0aW9uX2Nsb3NlKHJlbCwgQWNjZXNzRXhjbHVzaXZlTG9jayk7CisKKworCVBHX1JFVFVS Tl9WT0lEKCk7Cit9CisKIFBHX0ZVTkNUSU9OX0lORk9fVjEoaW52YWxpZGF0ZV9yZWxfYmxvY2sp OwogRGF0dW0KIGludmFsaWRhdGVfcmVsX2Jsb2NrKFBHX0ZVTkNUSU9OX0FSR1MpCkBAIC02MTAs NiArNjYwLDg2IEBAIGJ1ZmZlcl9jYWxsX3Rlcm1pbmF0ZV9pbyhQR19GVU5DVElPTl9BUkdTKQog CVBHX1JFVFVSTl9WT0lEKCk7CiB9CiAKKworc3RhdGljIEJsb2NrTnVtYmVyCityZWFkX3N0cmVh bV9mb3JfYmxvY2tzX2NiKFJlYWRTdHJlYW0gKnN0cmVhbSwKKwkJCQkJCSAgdm9pZCAqY2FsbGJh Y2tfcHJpdmF0ZV9kYXRhLAorCQkJCQkJICB2b2lkICpwZXJfYnVmZmVyX2RhdGEpCit7CisJQmxv Y2tzUmVhZFN0cmVhbURhdGEgKnN0cmVhbV9kYXRhID0gY2FsbGJhY2tfcHJpdmF0ZV9kYXRhOwor CisJaWYgKHN0cmVhbV9kYXRhLT5jdXJibG9jayA+PSBzdHJlYW1fZGF0YS0+bmJsb2NrcykKKwkJ cmV0dXJuIEludmFsaWRCbG9ja051bWJlcjsKKwlyZXR1cm4gc3RyZWFtX2RhdGEtPmJsb2Nrc1tz dHJlYW1fZGF0YS0+Y3VyYmxvY2srK107Cit9CisKK1BHX0ZVTkNUSU9OX0lORk9fVjEocmVhZF9z dHJlYW1fZm9yX2Jsb2Nrcyk7CitEYXR1bQorcmVhZF9zdHJlYW1fZm9yX2Jsb2NrcyhQR19GVU5D VElPTl9BUkdTKQoreworCU9pZAkJCXJlbGlkID0gUEdfR0VUQVJHX09JRCgwKTsKKwlBcnJheVR5 cGUgICpibG9ja3NhcnJheSA9IFBHX0dFVEFSR19BUlJBWVRZUEVfUCgxKTsKKwlSZXR1cm5TZXRJ bmZvICpyc2luZm8gPSAoUmV0dXJuU2V0SW5mbyAqKSBmY2luZm8tPnJlc3VsdGluZm87CisJUmVs YXRpb24JcmVsOworCUJsb2Nrc1JlYWRTdHJlYW1EYXRhIHN0cmVhbV9kYXRhOworCVJlYWRTdHJl YW0gKnN0cmVhbTsKKworCUluaXRNYXRlcmlhbGl6ZWRTUkYoZmNpbmZvLCAwKTsKKworCS8qCisJ ICogV2UgZXhwZWN0IHRoZSBpbnB1dCB0byBiZSBhbiBOLWVsZW1lbnQgaW50NCBhcnJheTsgdmVy aWZ5IHRoYXQuIFdlCisJICogZG9uJ3QgbmVlZCB0byB1c2UgZGVjb25zdHJ1Y3RfYXJyYXkoKSBz aW5jZSB0aGUgYXJyYXkgZGF0YSBpcyBqdXN0CisJICogZ29pbmcgdG8gbG9vayBsaWtlIGEgQyBh cnJheSBvZiBOIGludDQgdmFsdWVzLgorCSAqLworCWlmIChBUlJfTkRJTShibG9ja3NhcnJheSkg IT0gMSB8fAorCQlBUlJfSEFTTlVMTChibG9ja3NhcnJheSkgfHwKKwkJQVJSX0VMRU1UWVBFKGJs b2Nrc2FycmF5KSAhPSBJTlQ0T0lEKQorCQllbG9nKEVSUk9SLCAiZXhwZWN0ZWQgMSBkaW1lbnNp b25hbCBpbnQ0IGFycmF5Iik7CisKKwlzdHJlYW1fZGF0YS5jdXJibG9jayA9IDA7CisJc3RyZWFt X2RhdGEubmJsb2NrcyA9IEFSUl9ESU1TKGJsb2Nrc2FycmF5KVswXTsKKwlzdHJlYW1fZGF0YS5i bG9ja3MgPSAodWludDMyICopIEFSUl9EQVRBX1BUUihibG9ja3NhcnJheSk7CisKKwlyZWwgPSBy ZWxhdGlvbl9vcGVuKHJlbGlkLCBBY2Nlc3NTaGFyZUxvY2spOworCisJc3RyZWFtID0gcmVhZF9z dHJlYW1fYmVnaW5fcmVsYXRpb24oUkVBRF9TVFJFQU1fRlVMTCwKKwkJCQkJCQkJCQlOVUxMLAor CQkJCQkJCQkJCXJlbCwKKwkJCQkJCQkJCQlNQUlOX0ZPUktOVU0sCisJCQkJCQkJCQkJcmVhZF9z dHJlYW1fZm9yX2Jsb2Nrc19jYiwKKwkJCQkJCQkJCQkmc3RyZWFtX2RhdGEsCisJCQkJCQkJCQkJ MCk7CisKKwlmb3IgKGludCBpID0gMDsgaSA8IHN0cmVhbV9kYXRhLm5ibG9ja3M7IGkrKykKKwl7 CisJCUJ1ZmZlcgkJYnVmID0gcmVhZF9zdHJlYW1fbmV4dF9idWZmZXIoc3RyZWFtLCBOVUxMKTsK KwkJRGF0dW0JCXZhbHVlc1szXSA9IHswfTsKKwkJYm9vbAkJbnVsbHNbM10gPSB7MH07CisKKwkJ aWYgKCFCdWZmZXJJc1ZhbGlkKGJ1ZikpCisJCQllbG9nKEVSUk9SLCAicmVhZF9zdHJlYW1fbmV4 dF9idWZmZXIoKSBjYWxsICVkIGlzIHVuZXhwZWN0ZWRseSBpbnZhbGlkIiwgaSk7CisKKwkJdmFs dWVzWzBdID0gSW50MzJHZXREYXR1bShpKTsKKwkJdmFsdWVzWzFdID0gVUludDMyR2V0RGF0dW0o c3RyZWFtX2RhdGEuYmxvY2tzW2ldKTsKKwkJdmFsdWVzWzJdID0gVUludDMyR2V0RGF0dW0oYnVm KTsKKworCQl0dXBsZXN0b3JlX3B1dHZhbHVlcyhyc2luZm8tPnNldFJlc3VsdCwgcnNpbmZvLT5z ZXREZXNjLCB2YWx1ZXMsIG51bGxzKTsKKworCQlSZWxlYXNlQnVmZmVyKGJ1Zik7CisJfQorCisJ aWYgKHJlYWRfc3RyZWFtX25leHRfYnVmZmVyKHN0cmVhbSwgTlVMTCkgIT0gSW52YWxpZEJ1ZmZl cikKKwkJZWxvZyhFUlJPUiwgInJlYWRfc3RyZWFtX25leHRfYnVmZmVyKCkgY2FsbCAlZCBpcyB1 bmV4cGVjdGVkbHkgdmFsaWQiLAorCQkJIHN0cmVhbV9kYXRhLm5ibG9ja3MgKyAxKTsKKworCXJl YWRfc3RyZWFtX2VuZChzdHJlYW0pOworCisJcmVsYXRpb25fY2xvc2UocmVsLCBOb0xvY2spOwor CisJcmV0dXJuIChEYXR1bSkgMDsKK30KKworCiBQR19GVU5DVElPTl9JTkZPX1YxKGhhbmRsZV9n ZXQpOwogRGF0dW0KIGhhbmRsZV9nZXQoUEdfRlVOQ1RJT05fQVJHUykKQEAgLTY4MCwxNSArODEw LDk4IEBAIGJhdGNoX2VuZChQR19GVU5DVElPTl9BUkdTKQogfQogCiAjaWZkZWYgVVNFX0lOSkVD VElPTl9QT0lOVFMKLWV4dGVybiBQR0RMTEVYUE9SVCB2b2lkIGlual9pb19zaG9ydF9yZWFkKGNv bnN0IGNoYXIgKm5hbWUsCi0JCQkJCQkJCQkJICBjb25zdCB2b2lkICpwcml2YXRlX2RhdGEsCi0J CQkJCQkJCQkJICB2b2lkICphcmcpOworZXh0ZXJuIFBHRExMRVhQT1JUIHZvaWQgaW5qX2lvX2Nv bXBsZXRpb25faG9vayhjb25zdCBjaGFyICpuYW1lLAorCQkJCQkJCQkJCQkgICBjb25zdCB2b2lk ICpwcml2YXRlX2RhdGEsCisJCQkJCQkJCQkJCSAgIHZvaWQgKmFyZyk7CiBleHRlcm4gUEdETExF WFBPUlQgdm9pZCBpbmpfaW9fcmVvcGVuKGNvbnN0IGNoYXIgKm5hbWUsCiAJCQkJCQkJCQkgIGNv bnN0IHZvaWQgKnByaXZhdGVfZGF0YSwKIAkJCQkJCQkJCSAgdm9pZCAqYXJnKTsKIAotdm9pZAot aW5qX2lvX3Nob3J0X3JlYWQoY29uc3QgY2hhciAqbmFtZSwgY29uc3Qgdm9pZCAqcHJpdmF0ZV9k YXRhLCB2b2lkICphcmcpCitzdGF0aWMgYm9vbAoraW5qX2lvX3Nob3J0X3JlYWRfbWF0Y2hlcyhQ Z0Fpb0hhbmRsZSAqaW9oKQoreworCVBHUFJPQwkgICAqb3duZXJfcHJvYzsKKwlpbnQzMgkJb3du ZXJfcGlkOworCVBnQWlvVGFyZ2V0RGF0YSAqdGQ7CisKKwlpZiAoIWlual9pb19lcnJvcl9zdGF0 ZS0+ZW5hYmxlZF9zaG9ydF9yZWFkKQorCQlyZXR1cm4gZmFsc2U7CisKKwlpZiAoIWlual9pb19l cnJvcl9zdGF0ZS0+c2hvcnRfcmVhZF9yZXN1bHRfc2V0KQorCQlyZXR1cm4gZmFsc2U7CisKKwlv d25lcl9wcm9jID0gR2V0UEdQcm9jQnlOdW1iZXIocGdhaW9faW9fZ2V0X293bmVyKGlvaCkpOwor CW93bmVyX3BpZCA9IG93bmVyX3Byb2MtPnBpZDsKKworCWlmIChpbmpfaW9fZXJyb3Jfc3RhdGUt PnNob3J0X3JlYWRfcGlkICE9IDAgJiYKKwkJaW5qX2lvX2Vycm9yX3N0YXRlLT5zaG9ydF9yZWFk X3BpZCAhPSBvd25lcl9waWQpCisJCXJldHVybiBmYWxzZTsKKworCXRkID0gcGdhaW9faW9fZ2V0 X3RhcmdldF9kYXRhKGlvaCk7CisKKwlpZiAoaW5qX2lvX2Vycm9yX3N0YXRlLT5zaG9ydF9yZWFk X3JlbGZpbGVub2RlICE9IEludmFsaWRPaWQgJiYKKwkJdGQtPnNtZ3IucmxvY2F0b3IucmVsTnVt YmVyICE9IGlual9pb19lcnJvcl9zdGF0ZS0+c2hvcnRfcmVhZF9yZWxmaWxlbm9kZSkKKwkJcmV0 dXJuIGZhbHNlOworCisJLyoKKwkgKiBPbmx5IHNob3J0ZW4gcmVhZHMgdGhhdCBhcmUgYWN0dWFs bHkgbG9uZ2VyIHRoYW4gdGhlIHRhcmdldCBzaXplLAorCSAqIG90aGVyd2lzZSB3ZSBjYW4gdHJp Z2dlciBvdmVyLXJlYWRzLgorCSAqLworCWlmIChpbmpfaW9fZXJyb3Jfc3RhdGUtPnNob3J0X3Jl YWRfcmVzdWx0ID49IGlvaC0+cmVzdWx0KQorCQlyZXR1cm4gZmFsc2U7CisKKwlyZXR1cm4gdHJ1 ZTsKK30KKworc3RhdGljIGJvb2wKK2lual9pb19jb21wbGV0aW9uX3dhaXRfbWF0Y2hlcyhQZ0Fp b0hhbmRsZSAqaW9oKQoreworCVBHUFJPQwkgICAqb3duZXJfcHJvYzsKKwlpbnQzMgkJb3duZXJf cGlkOworCVBnQWlvVGFyZ2V0RGF0YSAqdGQ7CisKKwlpZiAoIWlual9pb19lcnJvcl9zdGF0ZS0+ ZW5hYmxlZF9jb21wbGV0aW9uX3dhaXQpCisJCXJldHVybiBmYWxzZTsKKworCW93bmVyX3Byb2Mg PSBHZXRQR1Byb2NCeU51bWJlcihwZ2Fpb19pb19nZXRfb3duZXIoaW9oKSk7CisJb3duZXJfcGlk ID0gb3duZXJfcHJvYy0+cGlkOworCisJaWYgKGlual9pb19lcnJvcl9zdGF0ZS0+Y29tcGxldGlv bl93YWl0X3BpZCAhPSBvd25lcl9waWQpCisJCXJldHVybiBmYWxzZTsKKworCXRkID0gcGdhaW9f aW9fZ2V0X3RhcmdldF9kYXRhKGlvaCk7CisKKwlpZiAoaW5qX2lvX2Vycm9yX3N0YXRlLT5jb21w bGV0aW9uX3dhaXRfcmVsZmlsZW5vZGUgIT0gSW52YWxpZE9pZCAmJgorCQl0ZC0+c21nci5ybG9j YXRvci5yZWxOdW1iZXIgIT0gaW5qX2lvX2Vycm9yX3N0YXRlLT5jb21wbGV0aW9uX3dhaXRfcmVs ZmlsZW5vZGUpCisJCXJldHVybiBmYWxzZTsKKworCXJldHVybiB0cnVlOworfQorCitzdGF0aWMg dm9pZAoraW5qX2lvX2NvbXBsZXRpb25fd2FpdF9ob29rKGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0 IHZvaWQgKnByaXZhdGVfZGF0YSwgdm9pZCAqYXJnKQoreworCVBnQWlvSGFuZGxlICppb2ggPSAo UGdBaW9IYW5kbGUgKikgYXJnOworCisJaWYgKCFpbmpfaW9fY29tcGxldGlvbl93YWl0X21hdGNo ZXMoaW9oKSkKKwkJcmV0dXJuOworCisJQ29uZGl0aW9uVmFyaWFibGVQcmVwYXJlVG9TbGVlcCgm aW5qX2lvX2Vycm9yX3N0YXRlLT5jdik7CisKKwl3aGlsZSAodHJ1ZSkKKwl7CisJCWlmICghaW5q X2lvX2NvbXBsZXRpb25fd2FpdF9tYXRjaGVzKGlvaCkpCisJCQlicmVhazsKKworCQlDb25kaXRp b25WYXJpYWJsZVNsZWVwKCZpbmpfaW9fZXJyb3Jfc3RhdGUtPmN2LAorCQkJCQkJCSAgIGlual9p b19lcnJvcl9zdGF0ZS0+Y29tcGxldGlvbl93YWl0X2V2ZW50KTsKKwl9CisKKwlDb25kaXRpb25W YXJpYWJsZUNhbmNlbFNsZWVwKCk7Cit9CisKK3N0YXRpYyB2b2lkCitpbmpfaW9fc2hvcnRfcmVh ZF9ob29rKGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0IHZvaWQgKnByaXZhdGVfZGF0YSwgdm9pZCAq YXJnKQogewogCVBnQWlvSGFuZGxlICppb2ggPSAoUGdBaW9IYW5kbGUgKikgYXJnOwogCkBAIC02 OTcsNTggKzkxMCw1NiBAQCBpbmpfaW9fc2hvcnRfcmVhZChjb25zdCBjaGFyICpuYW1lLCBjb25z dCB2b2lkICpwcml2YXRlX2RhdGEsIHZvaWQgKmFyZykKIAkJCQkgICBpbmpfaW9fZXJyb3Jfc3Rh dGUtPmVuYWJsZWRfcmVvcGVuKSwKIAkJCWVycmhpZGVzdG10KHRydWUpLCBlcnJoaWRlY29udGV4 dCh0cnVlKSk7CiAKLQlpZiAoaW5qX2lvX2Vycm9yX3N0YXRlLT5lbmFibGVkX3Nob3J0X3JlYWQp CisJaWYgKGlual9pb19zaG9ydF9yZWFkX21hdGNoZXMoaW9oKSkKIAl7CisJCXN0cnVjdCBpb3Zl YyAqaW92ID0gJnBnYWlvX2N0bC0+aW92ZWNzW2lvaC0+aW92ZWNfb2ZmXTsKKwkJaW50MzIJCW9s ZF9yZXN1bHQgPSBpb2gtPnJlc3VsdDsKKwkJaW50MzIJCW5ld19yZXN1bHQgPSBpbmpfaW9fZXJy b3Jfc3RhdGUtPnNob3J0X3JlYWRfcmVzdWx0OworCQlpbnQzMgkJcHJvY2Vzc2VkID0gMDsKKwor CQllcmVwb3J0KExPRywKKwkJCQllcnJtc2coInNob3J0IHJlYWQgaW5qZWN0IHBvaW50LCBjaGFu Z2luZyByZXN1bHQgZnJvbSAlZCB0byAlZCIsCisJCQkJCSAgIG9sZF9yZXN1bHQsIG5ld19yZXN1 bHQpLAorCQkJCWVycmhpZGVzdG10KHRydWUpLCBlcnJoaWRlY29udGV4dCh0cnVlKSk7CisKIAkJ LyoKLQkJICogT25seSBzaG9ydGVuIHJlYWRzIHRoYXQgYXJlIGFjdHVhbGx5IGxvbmdlciB0aGFu IHRoZSB0YXJnZXQgc2l6ZSwKLQkJICogb3RoZXJ3aXNlIHdlIGNhbiB0cmlnZ2VyIG92ZXItcmVh ZHMuCisJCSAqIFRoZSB1bmRlcmx5aW5nIElPIGFjdHVhbGx5IGNvbXBsZXRlZCBPSywgYW5kIHRo dXMgdGhlICJpbnZhbGlkIgorCQkgKiBwb3J0aW9uIG9mIHRoZSBJT1YgYWN0dWFsbHkgY29udGFp bnMgdmFsaWQgZGF0YS4gVGhhdCBjYW4gaGlkZSBhCisJCSAqIGxvdCBvZiBwcm9ibGVtcywgZS5n LiBpZiB3ZSB3ZXJlIHRvIHdyb25nbHkgbWFyayBhIGJ1ZmZlciwgdGhhdAorCQkgKiB3YXNuJ3Qg cmVhZCBhY2NvcmRpbmcgdG8gdGhlIHNob3J0ZW5lZC1yZWFkLCBJTyBhcyB2YWxpZCwgdGhlCisJ CSAqIGNvbnRlbnRzIHdvdWxkIGxvb2sgdmFsaWQgYW5kIHdlIG1pZ2h0IG1pc3MgYSBidWcuCisJ CSAqCisJCSAqIFRvIGF2b2lkIHRoYXQsIGl0ZXJhdGUgdGhyb3VnaCB0aGUgSU9WIGFuZCB6ZXJv IG91dCB0aGUgImZhaWxlZCIKKwkJICogcG9ydGlvbiBvZiB0aGUgSU8uCiAJCSAqLwotCQlpZiAo aW5qX2lvX2Vycm9yX3N0YXRlLT5zaG9ydF9yZWFkX3Jlc3VsdF9zZXQKLQkJCSYmIGlvaC0+b3Ag PT0gUEdBSU9fT1BfUkVBRFYKLQkJCSYmIGlual9pb19lcnJvcl9zdGF0ZS0+c2hvcnRfcmVhZF9y ZXN1bHQgPD0gaW9oLT5yZXN1bHQpCisJCWZvciAoaW50IGkgPSAwOyBpIDwgaW9oLT5vcF9kYXRh LnJlYWQuaW92X2xlbmd0aDsgaSsrKQogCQl7Ci0JCQlzdHJ1Y3QgaW92ZWMgKmlvdiA9ICZwZ2Fp b19jdGwtPmlvdmVjc1tpb2gtPmlvdmVjX29mZl07Ci0JCQlpbnQzMgkJb2xkX3Jlc3VsdCA9IGlv aC0+cmVzdWx0OwotCQkJaW50MzIJCW5ld19yZXN1bHQgPSBpbmpfaW9fZXJyb3Jfc3RhdGUtPnNo b3J0X3JlYWRfcmVzdWx0OwotCQkJaW50MzIJCXByb2Nlc3NlZCA9IDA7Ci0KLQkJCWVyZXBvcnQo TE9HLAotCQkJCQllcnJtc2coInNob3J0IHJlYWQgaW5qZWN0IHBvaW50LCBjaGFuZ2luZyByZXN1 bHQgZnJvbSAlZCB0byAlZCIsCi0JCQkJCQkgICBvbGRfcmVzdWx0LCBuZXdfcmVzdWx0KSwKLQkJ CQkJZXJyaGlkZXN0bXQodHJ1ZSksIGVycmhpZGVjb250ZXh0KHRydWUpKTsKLQotCQkJLyoKLQkJ CSAqIFRoZSB1bmRlcmx5aW5nIElPIGFjdHVhbGx5IGNvbXBsZXRlZCBPSywgYW5kIHRodXMgdGhl ICJpbnZhbGlkIgotCQkJICogcG9ydGlvbiBvZiB0aGUgSU9WIGFjdHVhbGx5IGNvbnRhaW5zIHZh bGlkIGRhdGEuIFRoYXQgY2FuIGhpZGUKLQkJCSAqIGEgbG90IG9mIHByb2JsZW1zLCBlLmcuIGlm IHdlIHdlcmUgdG8gd3JvbmdseSBtYXJrIGEgYnVmZmVyLAotCQkJICogdGhhdCB3YXNuJ3QgcmVh ZCBhY2NvcmRpbmcgdG8gdGhlIHNob3J0ZW5lZC1yZWFkLCBJTyBhcyB2YWxpZCwKLQkJCSAqIHRo ZSBjb250ZW50cyB3b3VsZCBsb29rIHZhbGlkIGFuZCB3ZSBtaWdodCBtaXNzIGEgYnVnLgotCQkJ ICoKLQkJCSAqIFRvIGF2b2lkIHRoYXQsIGl0ZXJhdGUgdGhyb3VnaCB0aGUgSU9WIGFuZCB6ZXJv IG91dCB0aGUKLQkJCSAqICJmYWlsZWQiIHBvcnRpb24gb2YgdGhlIElPLgotCQkJICovCi0JCQlm b3IgKGludCBpID0gMDsgaSA8IGlvaC0+b3BfZGF0YS5yZWFkLmlvdl9sZW5ndGg7IGkrKykKKwkJ CWlmIChwcm9jZXNzZWQgKyBpb3ZbaV0uaW92X2xlbiA8PSBuZXdfcmVzdWx0KQorCQkJCXByb2Nl c3NlZCArPSBpb3ZbaV0uaW92X2xlbjsKKwkJCWVsc2UgaWYgKHByb2Nlc3NlZCA8PSBuZXdfcmVz dWx0KQogCQkJewotCQkJCWlmIChwcm9jZXNzZWQgKyBpb3ZbaV0uaW92X2xlbiA8PSBuZXdfcmVz dWx0KQotCQkJCQlwcm9jZXNzZWQgKz0gaW92W2ldLmlvdl9sZW47Ci0JCQkJZWxzZSBpZiAocHJv Y2Vzc2VkIDw9IG5ld19yZXN1bHQpCi0JCQkJewotCQkJCQl1aW50MzIJCW9rX3BhcnQgPSBuZXdf cmVzdWx0IC0gcHJvY2Vzc2VkOwotCi0JCQkJCW1lbXNldCgoY2hhciAqKSBpb3ZbaV0uaW92X2Jh c2UgKyBva19wYXJ0LCAwLCBpb3ZbaV0uaW92X2xlbiAtIG9rX3BhcnQpOwotCQkJCQlwcm9jZXNz ZWQgKz0gaW92W2ldLmlvdl9sZW47Ci0JCQkJfQotCQkJCWVsc2UKLQkJCQl7Ci0JCQkJCW1lbXNl dCgoY2hhciAqKSBpb3ZbaV0uaW92X2Jhc2UsIDAsIGlvdltpXS5pb3ZfbGVuKTsKLQkJCQl9Ci0J CQl9CisJCQkJdWludDMyCQlva19wYXJ0ID0gbmV3X3Jlc3VsdCAtIHByb2Nlc3NlZDsKIAotCQkJ aW9oLT5yZXN1bHQgPSBuZXdfcmVzdWx0OworCQkJCW1lbXNldCgoY2hhciAqKSBpb3ZbaV0uaW92 X2Jhc2UgKyBva19wYXJ0LCAwLCBpb3ZbaV0uaW92X2xlbiAtIG9rX3BhcnQpOworCQkJCXByb2Nl c3NlZCArPSBpb3ZbaV0uaW92X2xlbjsKKwkJCX0KKwkJCWVsc2UKKwkJCXsKKwkJCQltZW1zZXQo KGNoYXIgKikgaW92W2ldLmlvdl9iYXNlLCAwLCBpb3ZbaV0uaW92X2xlbik7CisJCQl9CiAJCX0K KworCQlpb2gtPnJlc3VsdCA9IG5ld19yZXN1bHQ7CiAJfQogfQogCit2b2lkCitpbmpfaW9fY29t cGxldGlvbl9ob29rKGNvbnN0IGNoYXIgKm5hbWUsIGNvbnN0IHZvaWQgKnByaXZhdGVfZGF0YSwg dm9pZCAqYXJnKQoreworCWlual9pb19jb21wbGV0aW9uX3dhaXRfaG9vayhuYW1lLCBwcml2YXRl X2RhdGEsIGFyZyk7CisJaW5qX2lvX3Nob3J0X3JlYWRfaG9vayhuYW1lLCBwcml2YXRlX2RhdGEs IGFyZyk7Cit9CisKIHZvaWQKIGlual9pb19yZW9wZW4oY29uc3QgY2hhciAqbmFtZSwgY29uc3Qg dm9pZCAqcHJpdmF0ZV9kYXRhLCB2b2lkICphcmcpCiB7CkBAIC03NjIsNiArOTczLDM5IEBAIGlu al9pb19yZW9wZW4oY29uc3QgY2hhciAqbmFtZSwgY29uc3Qgdm9pZCAqcHJpdmF0ZV9kYXRhLCB2 b2lkICphcmcpCiB9CiAjZW5kaWYKIAorUEdfRlVOQ1RJT05fSU5GT19WMShpbmpfaW9fY29tcGxl dGlvbl93YWl0KTsKK0RhdHVtCitpbmpfaW9fY29tcGxldGlvbl93YWl0KFBHX0ZVTkNUSU9OX0FS R1MpCit7CisjaWZkZWYgVVNFX0lOSkVDVElPTl9QT0lOVFMKKwlpbmpfaW9fZXJyb3Jfc3RhdGUt PmVuYWJsZWRfY29tcGxldGlvbl93YWl0ID0gdHJ1ZTsKKwlpbmpfaW9fZXJyb3Jfc3RhdGUtPmNv bXBsZXRpb25fd2FpdF9waWQgPQorCQlQR19BUkdJU05VTEwoMCkgPyAwIDogUEdfR0VUQVJHX0lO VDMyKDApOworCWlual9pb19lcnJvcl9zdGF0ZS0+Y29tcGxldGlvbl93YWl0X3JlbGZpbGVub2Rl ID0KKwkJUEdfQVJHSVNOVUxMKDEpID8gSW52YWxpZE9pZCA6IFBHX0dFVEFSR19PSUQoMSk7Cisj ZWxzZQorCWVsb2coRVJST1IsICJpbmplY3Rpb24gcG9pbnRzIG5vdCBzdXBwb3J0ZWQiKTsKKyNl bmRpZgorCisJUEdfUkVUVVJOX1ZPSUQoKTsKK30KKworUEdfRlVOQ1RJT05fSU5GT19WMShpbmpf aW9fY29tcGxldGlvbl9jb250aW51ZSk7CitEYXR1bQoraW5qX2lvX2NvbXBsZXRpb25fY29udGlu dWUoUEdfRlVOQ1RJT05fQVJHUykKK3sKKyNpZmRlZiBVU0VfSU5KRUNUSU9OX1BPSU5UUworCWlu al9pb19lcnJvcl9zdGF0ZS0+ZW5hYmxlZF9jb21wbGV0aW9uX3dhaXQgPSBmYWxzZTsKKwlpbmpf aW9fZXJyb3Jfc3RhdGUtPmNvbXBsZXRpb25fd2FpdF9waWQgPSAwOworCWlual9pb19lcnJvcl9z dGF0ZS0+Y29tcGxldGlvbl93YWl0X3JlbGZpbGVub2RlID0gSW52YWxpZE9pZDsKKwlDb25kaXRp b25WYXJpYWJsZUJyb2FkY2FzdCgmaW5qX2lvX2Vycm9yX3N0YXRlLT5jdik7CisjZWxzZQorCWVs b2coRVJST1IsICJpbmplY3Rpb24gcG9pbnRzIG5vdCBzdXBwb3J0ZWQiKTsKKyNlbmRpZgorCisJ UEdfUkVUVVJOX1ZPSUQoKTsKK30KKwogUEdfRlVOQ1RJT05fSU5GT19WMShpbmpfaW9fc2hvcnRf cmVhZF9hdHRhY2gpOwogRGF0dW0KIGlual9pb19zaG9ydF9yZWFkX2F0dGFjaChQR19GVU5DVElP Tl9BUkdTKQpAQCAtNzcxLDYgKzEwMTUsMTAgQEAgaW5qX2lvX3Nob3J0X3JlYWRfYXR0YWNoKFBH X0ZVTkNUSU9OX0FSR1MpCiAJaW5qX2lvX2Vycm9yX3N0YXRlLT5zaG9ydF9yZWFkX3Jlc3VsdF9z ZXQgPSAhUEdfQVJHSVNOVUxMKDApOwogCWlmIChpbmpfaW9fZXJyb3Jfc3RhdGUtPnNob3J0X3Jl YWRfcmVzdWx0X3NldCkKIAkJaW5qX2lvX2Vycm9yX3N0YXRlLT5zaG9ydF9yZWFkX3Jlc3VsdCA9 IFBHX0dFVEFSR19JTlQzMigwKTsKKwlpbmpfaW9fZXJyb3Jfc3RhdGUtPnNob3J0X3JlYWRfcGlk ID0KKwkJUEdfQVJHSVNOVUxMKDEpID8gMCA6IFBHX0dFVEFSR19JTlQzMigxKTsKKwlpbmpfaW9f ZXJyb3Jfc3RhdGUtPnNob3J0X3JlYWRfcmVsZmlsZW5vZGUgPQorCQlQR19BUkdJU05VTEwoMikg PyAwIDogUEdfR0VUQVJHX09JRCgyKTsKICNlbHNlCiAJZWxvZyhFUlJPUiwgImluamVjdGlvbiBw b2ludHMgbm90IHN1cHBvcnRlZCIpOwogI2VuZGlmCmRpZmYgLS1naXQgYS9zcmMvdG9vbHMvcGdp bmRlbnQvdHlwZWRlZnMubGlzdCBiL3NyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0Cmlu ZGV4IDE3NGUyNzk4NDQzLi4zNDA2NjJjZjcyYyAxMDA2NDQKLS0tIGEvc3JjL3Rvb2xzL3BnaW5k ZW50L3R5cGVkZWZzLmxpc3QKKysrIGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QK QEAgLTMwNSw2ICszMDUsNyBAQCBCbG9ja1NhbXBsZXIKIEJsb2NrU2FtcGxlckRhdGEKIEJsb2Nr ZWRQcm9jRGF0YQogQmxvY2tlZFByb2NzRGF0YQorQmxvY2tzUmVhZFN0cmVhbURhdGEKIEJsb2Nr dGFibGVFbnRyeQogQmxvb21CdWlsZFN0YXRlCiBCbG9vbUZpbHRlcgotLSAKMi40My4wCgo= --000000000000ba4671064d4f5fb2 Content-Type: text/x-patch; charset="US-ASCII"; name="v6-0003-Fix-off-by-one-error-in-read-IO-tracing.patch" Content-Disposition: attachment; filename="v6-0003-Fix-off-by-one-error-in-read-IO-tracing.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmwa8okf2 RnJvbSAwNjA2ODU2Yzk3Y2VjMmRhMjlhNzBmYTVmZWRmYjBlYzRiYmVkODQyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBNb24sIDE2IE1hciAyMDI2IDE2OjUwOjU2IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2NiAzLzhdIEZpeCBvZmYtYnktb25lIGVycm9yIGluIHJlYWQgSU8gdHJhY2luZwoKQXN5 bmNSZWFkQnVmZmVyKCkncyBuby1JTyBuZWVkZWQgcGF0aCBwYXNzZWQKVFJBQ0VfUE9TVEdSRVNR TF9CVUZGRVJfUkVBRF9ET05FIHRoZSB3cm9uZyBibG9jayBudW1iZXIgYmVjYXVzZSBpdCBoYWQK YWxyZWFkeSBpbmNyZW1lbnRlZCBvcGVyYXRpb24tPm5ibG9ja3NfZG9uZS4gRml4IGJ5IGZvbGRp bmcgdGhlCm5ibG9ja3NfZG9uZSBvZmZzZXQgaW50byB0aGUgYmxvY2tudW0gbG9jYWwgdmFyaWFi bGUgYXQgaW5pdGlhbGl6YXRpb24uCgpBdXRob3I6IE1lbGFuaWUgUGxhZ2VtYW4gPG1lbGFuaWVw bGFnZW1hbkBnbWFpbC5jb20+ClJldmlld2VkLWJ5OiBBbmRyZXMgRnJldW5kIDxhbmRyZXNAYW5h cmF6ZWwuZGU+CkRpc2N1c3Npb246IGh0dHBzOi8vcG9zdGdyLmVzL20vdTczdW4zeGVsanI0Zmlp ZHp3aTRpa2NyNnZtN29xdWduNGZvNXZxcHN0amlvNmFubDIlNDBocGg2ZnZkaWlyaWEKLS0tCiBz cmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyB8IDYgKysrLS0tCiAxIGZpbGUgY2hh bmdlZCwgMyBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9i YWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZm ZXIvYnVmbWdyLmMKaW5kZXggMDBiYzYwOTUyOWEuLjEwYWZhZTE5OTBiIDEwMDY0NAotLS0gYS9z cmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYworKysgYi9zcmMvYmFja2VuZC9zdG9y YWdlL2J1ZmZlci9idWZtZ3IuYwpAQCAtMTg3NSwxMCArMTg3NSwxMCBAQCBBc3luY1JlYWRCdWZm ZXJzKFJlYWRCdWZmZXJzT3BlcmF0aW9uICpvcGVyYXRpb24sIGludCAqbmJsb2Nrc19wcm9ncmVz cykKIHsKIAlCdWZmZXIJICAgKmJ1ZmZlcnMgPSAmb3BlcmF0aW9uLT5idWZmZXJzWzBdOwogCWlu dAkJCWZsYWdzID0gb3BlcmF0aW9uLT5mbGFnczsKLQlCbG9ja051bWJlciBibG9ja251bSA9IG9w ZXJhdGlvbi0+YmxvY2tudW07CiAJRm9ya051bWJlcglmb3JrbnVtID0gb3BlcmF0aW9uLT5mb3Jr bnVtOwogCWNoYXIJCXBlcnNpc3RlbmNlID0gb3BlcmF0aW9uLT5wZXJzaXN0ZW5jZTsKIAlpbnQx NgkJbmJsb2Nrc19kb25lID0gb3BlcmF0aW9uLT5uYmxvY2tzX2RvbmU7CisJQmxvY2tOdW1iZXIg YmxvY2tudW0gPSBvcGVyYXRpb24tPmJsb2NrbnVtICsgbmJsb2Nrc19kb25lOwogCUJ1ZmZlcgkg ICAqaW9fYnVmZmVycyA9ICZvcGVyYXRpb24tPmJ1ZmZlcnNbbmJsb2Nrc19kb25lXTsKIAlpbnQJ CQlpb19idWZmZXJzX2xlbiA9IDA7CiAJUGdBaW9IYW5kbGUgKmlvaDsKQEAgLTE5OTAsNyArMTk5 MCw3IEBAIEFzeW5jUmVhZEJ1ZmZlcnMoUmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbiwg aW50ICpuYmxvY2tzX3Byb2dyZXNzKQogCQkgKiBtdXN0IGhhdmUgc3RhcnRlZCBvdXQgYXMgYSBt aXNzIGluIFBpbkJ1ZmZlckZvckJsb2NrKCkuIFRoZSBvdGhlcgogCQkgKiBiYWNrZW5kIHdpbGwg dHJhY2sgdGhpcyBhcyBhICdyZWFkJy4KIAkJICovCi0JCVRSQUNFX1BPU1RHUkVTUUxfQlVGRkVS X1JFQURfRE9ORShmb3JrbnVtLCBibG9ja251bSArIG9wZXJhdGlvbi0+bmJsb2Nrc19kb25lLAor CQlUUkFDRV9QT1NUR1JFU1FMX0JVRkZFUl9SRUFEX0RPTkUoZm9ya251bSwgYmxvY2tudW0sCiAJ CQkJCQkJCQkJICBvcGVyYXRpb24tPnNtZ3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRvci5zcGNPaWQs CiAJCQkJCQkJCQkJICBvcGVyYXRpb24tPnNtZ3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRvci5kYk9p ZCwKIAkJCQkJCQkJCQkgIG9wZXJhdGlvbi0+c21nci0+c21ncl9ybG9jYXRvci5sb2NhdG9yLnJl bE51bWJlciwKQEAgLTIwNjIsNyArMjA2Miw3IEBAIEFzeW5jUmVhZEJ1ZmZlcnMoUmVhZEJ1ZmZl cnNPcGVyYXRpb24gKm9wZXJhdGlvbiwgaW50ICpuYmxvY2tzX3Byb2dyZXNzKQogCQkgKi8KIAkJ aW9fc3RhcnQgPSBwZ3N0YXRfcHJlcGFyZV9pb190aW1lKHRyYWNrX2lvX3RpbWluZyk7CiAJCXNt Z3JzdGFydHJlYWR2KGlvaCwgb3BlcmF0aW9uLT5zbWdyLCBmb3JrbnVtLAotCQkJCQkgICBibG9j a251bSArIG5ibG9ja3NfZG9uZSwKKwkJCQkJICAgYmxvY2tudW0sCiAJCQkJCSAgIGlvX3BhZ2Vz LCBpb19idWZmZXJzX2xlbik7CiAJCXBnc3RhdF9jb3VudF9pb19vcF90aW1lKGlvX29iamVjdCwg aW9fY29udGV4dCwgSU9PUF9SRUFELAogCQkJCQkJCQlpb19zdGFydCwgMSwgaW9fYnVmZmVyc19s ZW4gKiBCTENLU1opOwotLSAKMi40My4wCgo= --000000000000ba4671064d4f5fb2 Content-Type: text/x-patch; charset="US-ASCII"; name="v6-0004-Pass-io_object-and-io_context-through-to-PinBuffe.patch" Content-Disposition: attachment; filename="v6-0004-Pass-io_object-and-io_context-through-to-PinBuffe.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmwa8tx13 RnJvbSBmYmZkMWQ5ZGYxMWQ4MTkwM2U1ODEwYzUxNjVjYTllMjM0YTZhYTI2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBUdWUsIDE3IE1hciAyMDI2IDE1OjQ5OjUyIC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2NiA0LzhdIFBhc3MgaW9fb2JqZWN0IGFuZCBpb19jb250ZXh0IHRocm91Z2ggdG8KIFBp bkJ1ZmZlckZvckJsb2NrKCkKClBpbkJ1ZmZlckZvckJsb2NrKCkgaXMgYWx3YXlzX2lubGluZSBh bmQgY2FsbGVkIGluIGEgbG9vcCBpbgpTdGFydFJlYWRCdWZmZXJzSW1wbCgpLiBQcmV2aW91c2x5 IGl0IGNvbXB1dGVkIGlvX2NvbnRleHQgYW5kIGlvX29iamVjdAppbnRlcm5hbGx5LCB3aGljaCBy ZXF1aXJlZCBjYWxsaW5nIElPQ29udGV4dEZvclN0cmF0ZWd5KCkgLS0gYSBub24taW5saW5lCmZ1 bmN0aW9uIHRoZSBjb21waWxlciBjYW5ub3QgcHJvdmUgaXMgc2lkZS1lZmZlY3QtZnJlZS4gVGhp cyBjb3VsZApwb3RlbnRpYWwgY2F1c2UgdW5uZWVkZWQgcmVkdW5kYW50IGZ1bmN0aW9uIGNhbGxz LgoKQ29tcHV0ZSBpb19jb250ZXh0IGFuZCBpb19vYmplY3QgaW4gdGhlIGNhbGxlcnMgaW5zdGVh ZCwgYWxsb3dpbmcKU3RhcnRSZWFkQnVmZmVyc0ltcGwoKSB0byBkbyBzbyBvbmNlIGJlZm9yZSBl bnRlcmluZyB0aGUgbG9vcC4KClN1Z2dlc3RlZC1ieTogQW5kcmVzIEZyZXVuZCA8YW5kcmVzQGFu YXJhemVsLmRlPgotLS0KIHNyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jIHwgNDUg KysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAzMSBpbnNlcnRp b25zKCspLCAxNCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdl L2J1ZmZlci9idWZtZ3IuYyBiL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jCmlu ZGV4IDEwYWZhZTE5OTBiLi5hYjljMmE0YjkwNCAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvc3Rv cmFnZS9idWZmZXIvYnVmbWdyLmMKKysrIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVm bWdyLmMKQEAgLTEyMjMsMTEgKzEyMjMsMTEgQEAgUGluQnVmZmVyRm9yQmxvY2soUmVsYXRpb24g cmVsLAogCQkJCSAgRm9ya051bWJlciBmb3JrTnVtLAogCQkJCSAgQmxvY2tOdW1iZXIgYmxvY2tO dW0sCiAJCQkJICBCdWZmZXJBY2Nlc3NTdHJhdGVneSBzdHJhdGVneSwKKwkJCQkgIElPT2JqZWN0 IGlvX29iamVjdCwKKwkJCQkgIElPQ29udGV4dCBpb19jb250ZXh0LAogCQkJCSAgYm9vbCAqZm91 bmRQdHIpCiB7CiAJQnVmZmVyRGVzYyAqYnVmSGRyOwotCUlPQ29udGV4dAlpb19jb250ZXh0Owot CUlPT2JqZWN0CWlvX29iamVjdDsKIAogCUFzc2VydChibG9ja051bSAhPSBQX05FVyk7CiAKQEAg LTEyMzYsMTcgKzEyMzYsNiBAQCBQaW5CdWZmZXJGb3JCbG9jayhSZWxhdGlvbiByZWwsCiAJCQlw ZXJzaXN0ZW5jZSA9PSBSRUxQRVJTSVNURU5DRV9QRVJNQU5FTlQgfHwKIAkJCXBlcnNpc3RlbmNl ID09IFJFTFBFUlNJU1RFTkNFX1VOTE9HR0VEKSk7CiAKLQlpZiAocGVyc2lzdGVuY2UgPT0gUkVM UEVSU0lTVEVOQ0VfVEVNUCkKLQl7Ci0JCWlvX2NvbnRleHQgPSBJT0NPTlRFWFRfTk9STUFMOwot CQlpb19vYmplY3QgPSBJT09CSkVDVF9URU1QX1JFTEFUSU9OOwotCX0KLQllbHNlCi0JewotCQlp b19jb250ZXh0ID0gSU9Db250ZXh0Rm9yU3RyYXRlZ3koc3RyYXRlZ3kpOwotCQlpb19vYmplY3Qg PSBJT09CSkVDVF9SRUxBVElPTjsKLQl9Ci0KIAlUUkFDRV9QT1NUR1JFU1FMX0JVRkZFUl9SRUFE X1NUQVJUKGZvcmtOdW0sIGJsb2NrTnVtLAogCQkJCQkJCQkJICAgc21nci0+c21ncl9ybG9jYXRv ci5sb2NhdG9yLnNwY09pZCwKIAkJCQkJCQkJCSAgIHNtZ3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRv ci5kYk9pZCwKQEAgLTEzMzksOSArMTMyOCwyMyBAQCBSZWFkQnVmZmVyX2NvbW1vbihSZWxhdGlv biByZWwsIFNNZ3JSZWxhdGlvbiBzbWdyLCBjaGFyIHNtZ3JfcGVyc2lzdGVuY2UsCiAJCQkJIG1v ZGUgPT0gUkJNX1pFUk9fQU5EX0xPQ0spKQogCXsKIAkJYm9vbAkJZm91bmQ7CisJCUlPQ29udGV4 dAlpb19jb250ZXh0OworCQlJT09iamVjdAlpb19vYmplY3Q7CisKKwkJaWYgKHBlcnNpc3RlbmNl ID09IFJFTFBFUlNJU1RFTkNFX1RFTVApCisJCXsKKwkJCWlvX2NvbnRleHQgPSBJT0NPTlRFWFRf Tk9STUFMOworCQkJaW9fb2JqZWN0ID0gSU9PQkpFQ1RfVEVNUF9SRUxBVElPTjsKKwkJfQorCQll bHNlCisJCXsKKwkJCWlvX2NvbnRleHQgPSBJT0NvbnRleHRGb3JTdHJhdGVneShzdHJhdGVneSk7 CisJCQlpb19vYmplY3QgPSBJT09CSkVDVF9SRUxBVElPTjsKKwkJfQogCiAJCWJ1ZmZlciA9IFBp bkJ1ZmZlckZvckJsb2NrKHJlbCwgc21nciwgcGVyc2lzdGVuY2UsCi0JCQkJCQkJCSAgIGZvcmtO dW0sIGJsb2NrTnVtLCBzdHJhdGVneSwgJmZvdW5kKTsKKwkJCQkJCQkJICAgZm9ya051bSwgYmxv Y2tOdW0sIHN0cmF0ZWd5LAorCQkJCQkJCQkgICBpb19vYmplY3QsIGlvX2NvbnRleHQsICZmb3Vu ZCk7CiAJCVplcm9BbmRMb2NrQnVmZmVyKGJ1ZmZlciwgbW9kZSwgZm91bmQpOwogCQlyZXR1cm4g YnVmZmVyOwogCX0KQEAgLTEzNzksMTEgKzEzODIsMjQgQEAgU3RhcnRSZWFkQnVmZmVyc0ltcGwo UmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbiwKIAlpbnQJCQlhY3R1YWxfbmJsb2NrcyA9 ICpuYmxvY2tzOwogCWludAkJCW1heGNvbWJpbmUgPSAwOwogCWJvb2wJCWRpZF9zdGFydF9pbzsK KwlJT0NvbnRleHQJaW9fY29udGV4dDsKKwlJT09iamVjdAlpb19vYmplY3Q7CiAKIAlBc3NlcnQo Km5ibG9ja3MgPT0gMSB8fCBhbGxvd19mb3J3YXJkaW5nKTsKIAlBc3NlcnQoKm5ibG9ja3MgPiAw KTsKIAlBc3NlcnQoKm5ibG9ja3MgPD0gTUFYX0lPX0NPTUJJTkVfTElNSVQpOwogCisJaWYgKG9w ZXJhdGlvbi0+cGVyc2lzdGVuY2UgPT0gUkVMUEVSU0lTVEVOQ0VfVEVNUCkKKwl7CisJCWlvX2Nv bnRleHQgPSBJT0NPTlRFWFRfTk9STUFMOworCQlpb19vYmplY3QgPSBJT09CSkVDVF9URU1QX1JF TEFUSU9OOworCX0KKwllbHNlCisJeworCQlpb19jb250ZXh0ID0gSU9Db250ZXh0Rm9yU3RyYXRl Z3kob3BlcmF0aW9uLT5zdHJhdGVneSk7CisJCWlvX29iamVjdCA9IElPT0JKRUNUX1JFTEFUSU9O OworCX0KKwogCWZvciAoaW50IGkgPSAwOyBpIDwgYWN0dWFsX25ibG9ja3M7ICsraSkKIAl7CiAJ CWJvb2wJCWZvdW5kOwpAQCAtMTQzMiw2ICsxNDQ4LDcgQEAgU3RhcnRSZWFkQnVmZmVyc0ltcGwo UmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbiwKIAkJCQkJCQkJCQkgICBvcGVyYXRpb24t PmZvcmtudW0sCiAJCQkJCQkJCQkJICAgYmxvY2tOdW0gKyBpLAogCQkJCQkJCQkJCSAgIG9wZXJh dGlvbi0+c3RyYXRlZ3ksCisJCQkJCQkJCQkJICAgaW9fb2JqZWN0LCBpb19jb250ZXh0LAogCQkJ CQkJCQkJCSAgICZmb3VuZCk7CiAJCX0KIAotLSAKMi40My4wCgo= --000000000000ba4671064d4f5fb2 Content-Type: text/x-patch; charset="US-ASCII"; name="v6-0005-Make-buffer-hit-helper.patch" Content-Disposition: attachment; filename="v6-0005-Make-buffer-hit-helper.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmwa8xre4 RnJvbSA5ZTU3YTVkZWZmNDBiMGUzMjcyODA5YTA0OGZjNjk1MDY0NmY4MTQ2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBGcmksIDIzIEphbiAyMDI2IDEzOjU0OjAyIC0wNTAwClN1YmplY3Q6IFtQ QVRDSCB2NiA1LzhdIE1ha2UgYnVmZmVyIGhpdCBoZWxwZXIKCkFscmVhZHkgdHdvIHBsYWNlcyBj b3VudCBidWZmZXIgaGl0cywgcmVxdWlyaW5nIHF1aXRlIGEgZmV3IGxpbmVzIG9mCmNvZGUgc2lu Y2Ugd2UgZG8gYWNjb3VudGluZyBpbiBzbyBtYW55IHBsYWNlcy4gRnV0dXJlIGNvbW1pdHMgd2ls bCBhZGQKbW9yZSBsb2NhdGlvbnMsIHNvIHJlZmFjdG9yIGludG8gYSBoZWxwZXIuCgpSZXZpZXdl ZC1ieTogTmF6aXIgQmlsYWwgWWF2dXogPGJ5YXZ1ejgxQGdtYWlsLmNvbT4KRGlzY3Vzc2lvbjog aHR0cHM6Ly9wb3N0Z3IuZXMvbS9mbGF0L3psamVyZ3dlcXRpN3g2N2xnNWlqZTJyemp1c2llMzdu c2xzbmtqa2tieTRsYXFxYmZ3JTQwM3AzenU1MjJ5eWt2Ci0tLQogc3JjL2JhY2tlbmQvc3RvcmFn ZS9idWZmZXIvYnVmbWdyLmMgfCA4NCArKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tLQogMSBm aWxlIGNoYW5nZWQsIDQyIGluc2VydGlvbnMoKyksIDQyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jIGIvc3JjL2JhY2tlbmQvc3Rv cmFnZS9idWZmZXIvYnVmbWdyLmMKaW5kZXggYWI5YzJhNGI5MDQuLmZhODU1NzBhNzkxIDEwMDY0 NAotLS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYworKysgYi9zcmMvYmFj a2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYwpAQCAtNjQ4LDYgKzY0OCwxMSBAQCBzdGF0aWMg aW5saW5lIEJ1ZmZlckRlc2MgKkJ1ZmZlckFsbG9jKFNNZ3JSZWxhdGlvbiBzbWdyLAogCQkJCQkJ CQkJICBib29sICpmb3VuZFB0ciwgSU9Db250ZXh0IGlvX2NvbnRleHQpOwogc3RhdGljIGJvb2wg QXN5bmNSZWFkQnVmZmVycyhSZWFkQnVmZmVyc09wZXJhdGlvbiAqb3BlcmF0aW9uLCBpbnQgKm5i bG9ja3NfcHJvZ3Jlc3MpOwogc3RhdGljIHZvaWQgQ2hlY2tSZWFkQnVmZmVyc09wZXJhdGlvbihS ZWFkQnVmZmVyc09wZXJhdGlvbiAqb3BlcmF0aW9uLCBib29sIGlzX2NvbXBsZXRlKTsKKworc3Rh dGljIHBnX2F0dHJpYnV0ZV9hbHdheXNfaW5saW5lIHZvaWQgVHJhY2tCdWZmZXJIaXQoSU9PYmpl Y3QgaW9fb2JqZWN0LAorCQkJCQkJCQkJCQkJCSAgSU9Db250ZXh0IGlvX2NvbnRleHQsCisJCQkJ CQkJCQkJCQkJICBSZWxhdGlvbiByZWwsIGNoYXIgcGVyc2lzdGVuY2UsIFNNZ3JSZWxhdGlvbiBz bWdyLAorCQkJCQkJCQkJCQkJCSAgRm9ya051bWJlciBmb3JrbnVtLCBCbG9ja051bWJlciBibG9j a251bSk7CiBzdGF0aWMgQnVmZmVyIEdldFZpY3RpbUJ1ZmZlcihCdWZmZXJBY2Nlc3NTdHJhdGVn eSBzdHJhdGVneSwgSU9Db250ZXh0IGlvX2NvbnRleHQpOwogc3RhdGljIHZvaWQgRmx1c2hVbmxv Y2tlZEJ1ZmZlcihCdWZmZXJEZXNjICpidWYsIFNNZ3JSZWxhdGlvbiByZWxuLAogCQkJCQkJCQlJ T09iamVjdCBpb19vYmplY3QsIElPQ29udGV4dCBpb19jb250ZXh0KTsKQEAgLTEyNDMsMTggKzEy NDgsMTQgQEAgUGluQnVmZmVyRm9yQmxvY2soUmVsYXRpb24gcmVsLAogCQkJCQkJCQkJICAgc21n ci0+c21ncl9ybG9jYXRvci5iYWNrZW5kKTsKIAogCWlmIChwZXJzaXN0ZW5jZSA9PSBSRUxQRVJT SVNURU5DRV9URU1QKQotCXsKIAkJYnVmSGRyID0gTG9jYWxCdWZmZXJBbGxvYyhzbWdyLCBmb3Jr TnVtLCBibG9ja051bSwgZm91bmRQdHIpOwotCQlpZiAoKmZvdW5kUHRyKQotCQkJcGdCdWZmZXJV c2FnZS5sb2NhbF9ibGtzX2hpdCsrOwotCX0KIAllbHNlCi0JewogCQlidWZIZHIgPSBCdWZmZXJB bGxvYyhzbWdyLCBwZXJzaXN0ZW5jZSwgZm9ya051bSwgYmxvY2tOdW0sCiAJCQkJCQkJIHN0cmF0 ZWd5LCBmb3VuZFB0ciwgaW9fY29udGV4dCk7Ci0JCWlmICgqZm91bmRQdHIpCi0JCQlwZ0J1ZmZl clVzYWdlLnNoYXJlZF9ibGtzX2hpdCsrOwotCX0KKworCWlmICgqZm91bmRQdHIpCisJCVRyYWNr QnVmZmVySGl0KGlvX29iamVjdCwgaW9fY29udGV4dCwgcmVsLCBwZXJzaXN0ZW5jZSwgc21nciwg Zm9ya051bSwgYmxvY2tOdW0pOworCiAJaWYgKHJlbCkKIAl7CiAJCS8qCkBAIC0xMjYzLDIxICsx MjY0LDYgQEAgUGluQnVmZmVyRm9yQmxvY2soUmVsYXRpb24gcmVsLAogCQkgKiB6ZXJvZWQgaW5z dGVhZCksIHRoZSBwZXItcmVsYXRpb24gc3RhdHMgYWx3YXlzIGNvdW50IHRoZW0uCiAJCSAqLwog CQlwZ3N0YXRfY291bnRfYnVmZmVyX3JlYWQocmVsKTsKLQkJaWYgKCpmb3VuZFB0cikKLQkJCXBn c3RhdF9jb3VudF9idWZmZXJfaGl0KHJlbCk7Ci0JfQotCWlmICgqZm91bmRQdHIpCi0JewotCQlw Z3N0YXRfY291bnRfaW9fb3AoaW9fb2JqZWN0LCBpb19jb250ZXh0LCBJT09QX0hJVCwgMSwgMCk7 Ci0JCWlmIChWYWN1dW1Db3N0QWN0aXZlKQotCQkJVmFjdXVtQ29zdEJhbGFuY2UgKz0gVmFjdXVt Q29zdFBhZ2VIaXQ7Ci0KLQkJVFJBQ0VfUE9TVEdSRVNRTF9CVUZGRVJfUkVBRF9ET05FKGZvcmtO dW0sIGJsb2NrTnVtLAotCQkJCQkJCQkJCSAgc21nci0+c21ncl9ybG9jYXRvci5sb2NhdG9yLnNw Y09pZCwKLQkJCQkJCQkJCQkgIHNtZ3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRvci5kYk9pZCwKLQkJ CQkJCQkJCQkgIHNtZ3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRvci5yZWxOdW1iZXIsCi0JCQkJCQkJ CQkJICBzbWdyLT5zbWdyX3Jsb2NhdG9yLmJhY2tlbmQsCi0JCQkJCQkJCQkJICB0cnVlKTsKIAl9 CiAKIAlyZXR1cm4gQnVmZmVyRGVzY3JpcHRvckdldEJ1ZmZlcihidWZIZHIpOwpAQCAtMTcxMiw2 ICsxNjk4LDM3IEBAIFJlYWRCdWZmZXJzQ2FuU3RhcnRJTyhCdWZmZXIgYnVmZmVyLCBib29sIG5v d2FpdCkKIAlyZXR1cm4gUmVhZEJ1ZmZlcnNDYW5TdGFydElPT25jZShidWZmZXIsIG5vd2FpdCk7 CiB9CiAKKy8qCisgKiBXZSB0cmFjayB2YXJpb3VzIHN0YXRzIHJlbGF0ZWQgdG8gYnVmZmVyIGhp dHMuIEJlY2F1c2UgdGhpcyBpcyBkb25lIGluIGEKKyAqIGZldyBzZXBhcmF0ZSBwbGFjZXMsIHRo aXMgaGVscGVyIGV4aXN0cyBmb3IgY29udmVuaWVuY2UuCisgKi8KK3N0YXRpYyBwZ19hdHRyaWJ1 dGVfYWx3YXlzX2lubGluZSB2b2lkCitUcmFja0J1ZmZlckhpdChJT09iamVjdCBpb19vYmplY3Qs IElPQ29udGV4dCBpb19jb250ZXh0LAorCQkJICAgUmVsYXRpb24gcmVsLCBjaGFyIHBlcnNpc3Rl bmNlLCBTTWdyUmVsYXRpb24gc21nciwKKwkJCSAgIEZvcmtOdW1iZXIgZm9ya251bSwgQmxvY2tO dW1iZXIgYmxvY2tudW0pCit7CisJVFJBQ0VfUE9TVEdSRVNRTF9CVUZGRVJfUkVBRF9ET05FKGZv cmtudW0sCisJCQkJCQkJCQkgIGJsb2NrbnVtLAorCQkJCQkJCQkJICBzbWdyLT5zbWdyX3Jsb2Nh dG9yLmxvY2F0b3Iuc3BjT2lkLAorCQkJCQkJCQkJICBzbWdyLT5zbWdyX3Jsb2NhdG9yLmxvY2F0 b3IuZGJPaWQsCisJCQkJCQkJCQkgIHNtZ3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRvci5yZWxOdW1i ZXIsCisJCQkJCQkJCQkgIHNtZ3ItPnNtZ3JfcmxvY2F0b3IuYmFja2VuZCwKKwkJCQkJCQkJCSAg dHJ1ZSk7CisKKwlpZiAocGVyc2lzdGVuY2UgPT0gUkVMUEVSU0lTVEVOQ0VfVEVNUCkKKwkJcGdC dWZmZXJVc2FnZS5sb2NhbF9ibGtzX2hpdCArPSAxOworCWVsc2UKKwkJcGdCdWZmZXJVc2FnZS5z aGFyZWRfYmxrc19oaXQgKz0gMTsKKworCXBnc3RhdF9jb3VudF9pb19vcChpb19vYmplY3QsIGlv X2NvbnRleHQsIElPT1BfSElULCAxLCAwKTsKKworCWlmIChWYWN1dW1Db3N0QWN0aXZlKQorCQlW YWN1dW1Db3N0QmFsYW5jZSArPSBWYWN1dW1Db3N0UGFnZUhpdDsKKworCWlmIChyZWwpCisJCXBn c3RhdF9jb3VudF9idWZmZXJfaGl0KHJlbCk7Cit9CisKIC8qCiAgKiBIZWxwZXIgZm9yIFdhaXRS ZWFkQnVmZmVycygpIHRoYXQgcHJvY2Vzc2VzIHRoZSByZXN1bHRzIG9mIGEgcmVhZHYKICAqIG9w ZXJhdGlvbiwgcmFpc2luZyBhbiBlcnJvciBpZiBuZWNlc3NhcnkuCkBAIC0yMDA3LDI1ICsyMDI0 LDggQEAgQXN5bmNSZWFkQnVmZmVycyhSZWFkQnVmZmVyc09wZXJhdGlvbiAqb3BlcmF0aW9uLCBp bnQgKm5ibG9ja3NfcHJvZ3Jlc3MpCiAJCSAqIG11c3QgaGF2ZSBzdGFydGVkIG91dCBhcyBhIG1p c3MgaW4gUGluQnVmZmVyRm9yQmxvY2soKS4gVGhlIG90aGVyCiAJCSAqIGJhY2tlbmQgd2lsbCB0 cmFjayB0aGlzIGFzIGEgJ3JlYWQnLgogCQkgKi8KLQkJVFJBQ0VfUE9TVEdSRVNRTF9CVUZGRVJf UkVBRF9ET05FKGZvcmtudW0sIGJsb2NrbnVtLAotCQkJCQkJCQkJCSAgb3BlcmF0aW9uLT5zbWdy LT5zbWdyX3Jsb2NhdG9yLmxvY2F0b3Iuc3BjT2lkLAotCQkJCQkJCQkJCSAgb3BlcmF0aW9uLT5z bWdyLT5zbWdyX3Jsb2NhdG9yLmxvY2F0b3IuZGJPaWQsCi0JCQkJCQkJCQkJICBvcGVyYXRpb24t PnNtZ3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRvci5yZWxOdW1iZXIsCi0JCQkJCQkJCQkJICBvcGVy YXRpb24tPnNtZ3ItPnNtZ3JfcmxvY2F0b3IuYmFja2VuZCwKLQkJCQkJCQkJCQkgIHRydWUpOwot Ci0JCWlmIChwZXJzaXN0ZW5jZSA9PSBSRUxQRVJTSVNURU5DRV9URU1QKQotCQkJcGdCdWZmZXJV c2FnZS5sb2NhbF9ibGtzX2hpdCArPSAxOwotCQllbHNlCi0JCQlwZ0J1ZmZlclVzYWdlLnNoYXJl ZF9ibGtzX2hpdCArPSAxOwotCi0JCWlmIChvcGVyYXRpb24tPnJlbCkKLQkJCXBnc3RhdF9jb3Vu dF9idWZmZXJfaGl0KG9wZXJhdGlvbi0+cmVsKTsKLQotCQlwZ3N0YXRfY291bnRfaW9fb3AoaW9f b2JqZWN0LCBpb19jb250ZXh0LCBJT09QX0hJVCwgMSwgMCk7Ci0KLQkJaWYgKFZhY3V1bUNvc3RB Y3RpdmUpCi0JCQlWYWN1dW1Db3N0QmFsYW5jZSArPSBWYWN1dW1Db3N0UGFnZUhpdDsKKwkJVHJh Y2tCdWZmZXJIaXQoaW9fb2JqZWN0LCBpb19jb250ZXh0LCBvcGVyYXRpb24tPnJlbCwgcGVyc2lz dGVuY2UsCisJCQkJCSAgIG9wZXJhdGlvbi0+c21nciwgZm9ya251bSwgYmxvY2tudW0pOwogCX0K IAllbHNlCiAJewotLSAKMi40My4wCgo= --000000000000ba4671064d4f5fb2 Content-Type: text/x-patch; charset="US-ASCII"; name="v6-0006-Restructure-AsyncReadBuffers.patch" Content-Disposition: attachment; filename="v6-0006-Restructure-AsyncReadBuffers.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmwa90ds5 RnJvbSBiNzNiODk2ZmViYzM1MjUzY2EyNjA3Y2IwZmUxNDMzNTViOTEyNTZmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBXZWQsIDE4IE1hciAyMDI2IDExOjA5OjU4IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2NiA2LzhdIFJlc3RydWN0dXJlIEFzeW5jUmVhZEJ1ZmZlcnMoKQoKUmVzdHJ1Y3R1cmUg QXN5bmNSZWFkQnVmZmVycygpIHRvIHVzZSBlYXJseSByZXR1cm4gd2hlbiB0aGUgaGVhZCBidWZm ZXIKaXMgYWxyZWFkeSB2YWxpZCwgaW5zdGVhZCBvZiB1c2luZyBhIGRpZF9zdGFydF9pbyBmbGFn IGFuZCBpZi9lbHNlCmJyYW5jaGVzLiBBbHNvIG1vdmUgYXJvdW5kIGEgYml0IG9mIHRoZSBjb2Rl IHRvIGJlIGxvY2F0ZWQgY2xvc2VyIHRvCndoZXJlIGl0IGlzIHVzZWQuIFRoaXMgaXMgYSByZWZh Y3RvciBvbmx5LgotLS0KIHNyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jIHwgMjA4 ICsrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAxMDMgaW5zZXJ0 aW9ucygrKSwgMTA1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3Jh Z2UvYnVmZmVyL2J1Zm1nci5jIGIvc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMK aW5kZXggZmE4NTU3MGE3OTEuLmE5OTk1Yjc1OTE3IDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9z dG9yYWdlL2J1ZmZlci9idWZtZ3IuYworKysgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9i dWZtZ3IuYwpAQCAtMTkyMCwyMSArMTkyMCwxMiBAQCBBc3luY1JlYWRCdWZmZXJzKFJlYWRCdWZm ZXJzT3BlcmF0aW9uICpvcGVyYXRpb24sIGludCAqbmJsb2Nrc19wcm9ncmVzcykKIAl2b2lkCSAg ICppb19wYWdlc1tNQVhfSU9fQ09NQklORV9MSU1JVF07CiAJSU9Db250ZXh0CWlvX2NvbnRleHQ7 CiAJSU9PYmplY3QJaW9fb2JqZWN0OwotCWJvb2wJCWRpZF9zdGFydF9pbzsKLQotCS8qCi0JICog V2hlbiB0aGlzIElPIGlzIGV4ZWN1dGVkIHN5bmNocm9ub3VzbHksIGVpdGhlciBiZWNhdXNlIHRo ZSBjYWxsZXIgd2lsbAotCSAqIGltbWVkaWF0ZWx5IGJsb2NrIHdhaXRpbmcgZm9yIHRoZSBJTyBv ciBiZWNhdXNlIElPTUVUSE9EX1NZTkMgaXMgdXNlZCwKLQkgKiB0aGUgQUlPIHN1YnN5c3RlbSBu ZWVkcyB0byBrbm93LgotCSAqLwotCWlmIChmbGFncyAmIFJFQURfQlVGRkVSU19TWU5DSFJPTk9V U0xZKQotCQlpb2hfZmxhZ3MgfD0gUEdBSU9fSEZfU1lOQ0hST05PVVM7CisJaW5zdHJfdGltZQlp b19zdGFydDsKIAogCWlmIChwZXJzaXN0ZW5jZSA9PSBSRUxQRVJTSVNURU5DRV9URU1QKQogCXsK IAkJaW9fY29udGV4dCA9IElPQ09OVEVYVF9OT1JNQUw7CiAJCWlvX29iamVjdCA9IElPT0JKRUNU X1RFTVBfUkVMQVRJT047Ci0JCWlvaF9mbGFncyB8PSBQR0FJT19IRl9SRUZFUkVOQ0VTX0xPQ0FM OwogCX0KIAllbHNlCiAJewpAQCAtMTk0MiwzNSArMTkzMyw2IEBAIEFzeW5jUmVhZEJ1ZmZlcnMo UmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbiwgaW50ICpuYmxvY2tzX3Byb2dyZXNzKQog CQlpb19vYmplY3QgPSBJT09CSkVDVF9SRUxBVElPTjsKIAl9CiAKLQkvKgotCSAqIElmIHplcm9f ZGFtYWdlZF9wYWdlcyBpcyBlbmFibGVkLCBhZGQgdGhlIFJFQURfQlVGRkVSU19aRVJPX09OX0VS Uk9SCi0JICogZmxhZy4gVGhlIHJlYXNvbiBmb3IgdGhhdCBpcyB0aGF0LCBob3BlZnVsbHksIHpl cm9fZGFtYWdlZF9wYWdlcyBpc24ndAotCSAqIHNldCBnbG9iYWxseSwgYnV0IG9uIGEgcGVyLXNl c3Npb24gYmFzaXMuIFRoZSBjb21wbGV0aW9uIGNhbGxiYWNrLAotCSAqIHdoaWNoIG1heSBiZSBy dW4gaW4gb3RoZXIgcHJvY2Vzc2VzLCBlLmcuIGluIElPIHdvcmtlcnMsIG1heSBoYXZlIGEKLQkg KiBkaWZmZXJlbnQgdmFsdWUgb2YgdGhlIHplcm9fZGFtYWdlZF9wYWdlcyBHVUMuCi0JICoKLQkg KiBYWFg6IFdlIHByb2JhYmx5IHNob3VsZCBldmVudHVhbGx5IHVzZSBhIGRpZmZlcmVudCBmbGFn IGZvcgotCSAqIHplcm9fZGFtYWdlZF9wYWdlcywgc28gd2UgY2FuIHJlcG9ydCBkaWZmZXJlbnQg bG9nIGxldmVscyAvIGVycm9yIGNvZGVzCi0JICogZm9yIHplcm9fZGFtYWdlZF9wYWdlcyBhbmQg WkVST19PTl9FUlJPUi4KLQkgKi8KLQlpZiAoemVyb19kYW1hZ2VkX3BhZ2VzKQotCQlmbGFncyB8 PSBSRUFEX0JVRkZFUlNfWkVST19PTl9FUlJPUjsKLQotCS8qCi0JICogRm9yIHRoZSBzYW1lIHJl YXNvbiBhcyB3aXRoIHplcm9fZGFtYWdlZF9wYWdlcyB3ZSBuZWVkIHRvIHVzZSB0aGlzCi0JICog YmFja2VuZCdzIGlnbm9yZV9jaGVja3N1bV9mYWlsdXJlIHZhbHVlLgotCSAqLwotCWlmIChpZ25v cmVfY2hlY2tzdW1fZmFpbHVyZSkKLQkJZmxhZ3MgfD0gUkVBRF9CVUZGRVJTX0lHTk9SRV9DSEVD S1NVTV9GQUlMVVJFUzsKLQotCi0JLyoKLQkgKiBUbyBiZSBhbGxvd2VkIHRvIHJlcG9ydCBzdGF0 cyBpbiB0aGUgbG9jYWwgY29tcGxldGlvbiBjYWxsYmFjayB3ZSBuZWVkCi0JICogdG8gcHJlcGFy ZSB0byByZXBvcnQgc3RhdHMgbm93LiBUaGlzIGVuc3VyZXMgd2UgY2FuIHNhZmVseSByZXBvcnQg dGhlCi0JICogY2hlY2tzdW0gZmFpbHVyZSBldmVuIGluIGEgY3JpdGljYWwgc2VjdGlvbi4KLQkg Ki8KLQlwZ3N0YXRfcHJlcGFyZV9yZXBvcnRfY2hlY2tzdW1fZmFpbHVyZShvcGVyYXRpb24tPnNt Z3ItPnNtZ3JfcmxvY2F0b3IubG9jYXRvci5kYk9pZCk7Ci0KIAkvKgogCSAqIEdldCBJTyBoYW5k bGUgYmVmb3JlIFJlYWRCdWZmZXJzQ2FuU3RhcnRJTygpLCBhcyBwZ2Fpb19pb19hY3F1aXJlKCkK IAkgKiBtaWdodCBibG9jaywgd2hpY2ggd2UgZG9uJ3Qgd2FudCBhZnRlciBzZXR0aW5nIElPX0lO X1BST0dSRVNTLgpAQCAtMTk5Miw3ICsxOTU0LDYgQEAgQXN5bmNSZWFkQnVmZmVycyhSZWFkQnVm ZmVyc09wZXJhdGlvbiAqb3BlcmF0aW9uLCBpbnQgKm5ibG9ja3NfcHJvZ3Jlc3MpCiAJaWYgKHVu bGlrZWx5KCFpb2gpKQogCXsKIAkJcGdhaW9fc3VibWl0X3N0YWdlZCgpOwotCiAJCWlvaCA9IHBn YWlvX2lvX2FjcXVpcmUoQ3VycmVudFJlc291cmNlT3duZXIsICZvcGVyYXRpb24tPmlvX3JldHVy bik7CiAJfQogCkBAIC0yMDE3LDkxICsxOTc4LDEyOCBAQCBBc3luY1JlYWRCdWZmZXJzKFJlYWRC dWZmZXJzT3BlcmF0aW9uICpvcGVyYXRpb24sIGludCAqbmJsb2Nrc19wcm9ncmVzcykKIAogCQlw Z2Fpb19pb19yZWxlYXNlKGlvaCk7CiAJCXBnYWlvX3dyZWZfY2xlYXIoJm9wZXJhdGlvbi0+aW9f d3JlZik7Ci0JCWRpZF9zdGFydF9pbyA9IGZhbHNlOwogCiAJCS8qCiAJCSAqIFJlcG9ydCBhbmQg dHJhY2sgdGhpcyBhcyBhICdoaXQnIGZvciB0aGlzIGJhY2tlbmQsIGV2ZW4gdGhvdWdoIGl0CiAJ CSAqIG11c3QgaGF2ZSBzdGFydGVkIG91dCBhcyBhIG1pc3MgaW4gUGluQnVmZmVyRm9yQmxvY2so KS4gVGhlIG90aGVyCiAJCSAqIGJhY2tlbmQgd2lsbCB0cmFjayB0aGlzIGFzIGEgJ3JlYWQnLgog CQkgKi8KLQkJVHJhY2tCdWZmZXJIaXQoaW9fb2JqZWN0LCBpb19jb250ZXh0LCBvcGVyYXRpb24t PnJlbCwgcGVyc2lzdGVuY2UsCi0JCQkJCSAgIG9wZXJhdGlvbi0+c21nciwgZm9ya251bSwgYmxv Y2tudW0pOworCQlUcmFja0J1ZmZlckhpdChpb19vYmplY3QsIGlvX2NvbnRleHQsCisJCQkJCSAg IG9wZXJhdGlvbi0+cmVsLCBvcGVyYXRpb24tPnBlcnNpc3RlbmNlLAorCQkJCQkgICBvcGVyYXRp b24tPnNtZ3IsIG9wZXJhdGlvbi0+Zm9ya251bSwKKwkJCQkJICAgYmxvY2tudW0pOworCQlyZXR1 cm4gZmFsc2U7CiAJfQotCWVsc2UKKworCS8qCisJICogV2hlbiB0aGlzIElPIGlzIGV4ZWN1dGVk IHN5bmNocm9ub3VzbHksIGVpdGhlciBiZWNhdXNlIHRoZSBjYWxsZXIgd2lsbAorCSAqIGltbWVk aWF0ZWx5IGJsb2NrIHdhaXRpbmcgZm9yIHRoZSBJTyBvciBiZWNhdXNlIElPTUVUSE9EX1NZTkMg aXMgdXNlZCwKKwkgKiB0aGUgQUlPIHN1YnN5c3RlbSBuZWVkcyB0byBrbm93LgorCSAqLworCWlm IChmbGFncyAmIFJFQURfQlVGRkVSU19TWU5DSFJPTk9VU0xZKQorCQlpb2hfZmxhZ3MgfD0gUEdB SU9fSEZfU1lOQ0hST05PVVM7CisKKwlpZiAocGVyc2lzdGVuY2UgPT0gUkVMUEVSU0lTVEVOQ0Vf VEVNUCkKKwkJaW9oX2ZsYWdzIHw9IFBHQUlPX0hGX1JFRkVSRU5DRVNfTE9DQUw7CisKKwkvKgor CSAqIElmIHplcm9fZGFtYWdlZF9wYWdlcyBpcyBlbmFibGVkLCBhZGQgdGhlIFJFQURfQlVGRkVS U19aRVJPX09OX0VSUk9SCisJICogZmxhZy4gVGhlIHJlYXNvbiBmb3IgdGhhdCBpcyB0aGF0LCBo b3BlZnVsbHksIHplcm9fZGFtYWdlZF9wYWdlcyBpc24ndAorCSAqIHNldCBnbG9iYWxseSwgYnV0 IG9uIGEgcGVyLXNlc3Npb24gYmFzaXMuIFRoZSBjb21wbGV0aW9uIGNhbGxiYWNrLAorCSAqIHdo aWNoIG1heSBiZSBydW4gaW4gb3RoZXIgcHJvY2Vzc2VzLCBlLmcuIGluIElPIHdvcmtlcnMsIG1h eSBoYXZlIGEKKwkgKiBkaWZmZXJlbnQgdmFsdWUgb2YgdGhlIHplcm9fZGFtYWdlZF9wYWdlcyBH VUMuCisJICoKKwkgKiBYWFg6IFdlIHByb2JhYmx5IHNob3VsZCBldmVudHVhbGx5IHVzZSBhIGRp ZmZlcmVudCBmbGFnIGZvcgorCSAqIHplcm9fZGFtYWdlZF9wYWdlcywgc28gd2UgY2FuIHJlcG9y dCBkaWZmZXJlbnQgbG9nIGxldmVscyAvIGVycm9yIGNvZGVzCisJICogZm9yIHplcm9fZGFtYWdl ZF9wYWdlcyBhbmQgWkVST19PTl9FUlJPUi4KKwkgKi8KKwlpZiAoemVyb19kYW1hZ2VkX3BhZ2Vz KQorCQlmbGFncyB8PSBSRUFEX0JVRkZFUlNfWkVST19PTl9FUlJPUjsKKworCS8qCisJICogRm9y IHRoZSBzYW1lIHJlYXNvbiBhcyB3aXRoIHplcm9fZGFtYWdlZF9wYWdlcyB3ZSBuZWVkIHRvIHVz ZSB0aGlzCisJICogYmFja2VuZCdzIGlnbm9yZV9jaGVja3N1bV9mYWlsdXJlIHZhbHVlLgorCSAq LworCWlmIChpZ25vcmVfY2hlY2tzdW1fZmFpbHVyZSkKKwkJZmxhZ3MgfD0gUkVBRF9CVUZGRVJT X0lHTk9SRV9DSEVDS1NVTV9GQUlMVVJFUzsKKworCS8qCisJICogVG8gYmUgYWxsb3dlZCB0byBy ZXBvcnQgc3RhdHMgaW4gdGhlIGxvY2FsIGNvbXBsZXRpb24gY2FsbGJhY2sgd2UgbmVlZAorCSAq IHRvIHByZXBhcmUgdG8gcmVwb3J0IHN0YXRzIG5vdy4gVGhpcyBlbnN1cmVzIHdlIGNhbiBzYWZl bHkgcmVwb3J0IHRoZQorCSAqIGNoZWNrc3VtIGZhaWx1cmUgZXZlbiBpbiBhIGNyaXRpY2FsIHNl Y3Rpb24uCisJICovCisJcGdzdGF0X3ByZXBhcmVfcmVwb3J0X2NoZWNrc3VtX2ZhaWx1cmUob3Bl cmF0aW9uLT5zbWdyLT5zbWdyX3Jsb2NhdG9yLmxvY2F0b3IuZGJPaWQpOworCisJQXNzZXJ0KGlv X2J1ZmZlcnNbMF0gPT0gYnVmZmVyc1tuYmxvY2tzX2RvbmVdKTsKKwlpb19wYWdlc1swXSA9IEJ1 ZmZlckdldEJsb2NrKGJ1ZmZlcnNbbmJsb2Nrc19kb25lXSk7CisJaW9fYnVmZmVyc19sZW4gPSAx OworCisJLyoKKwkgKiBIb3cgbWFueSBuZWlnaGJvcmluZy1vbi1kaXNrIGJsb2NrcyBjYW4gd2Ug c2NhdHRlci1yZWFkIGludG8gb3RoZXIKKwkgKiBidWZmZXJzIGF0IHRoZSBzYW1lIHRpbWU/ICBJ biB0aGlzIGNhc2Ugd2UgZG9uJ3Qgd2FpdCBpZiB3ZSBzZWUgYW4gSS9PCisJICogYWxyZWFkeSBp biBwcm9ncmVzcy4gIFdlIGFscmVhZHkgc2V0IEJNX0lPX0lOX1BST0dSRVNTIGZvciB0aGUgaGVh ZAorCSAqIGJsb2NrLCBzbyB3ZSBzaG91bGQgZ2V0IG9uIHdpdGggdGhhdCBJL08gYXMgc29vbiBh cyBwb3NzaWJsZS4KKwkgKi8KKwlmb3IgKGludCBpID0gbmJsb2Nrc19kb25lICsgMTsgaSA8IG9w ZXJhdGlvbi0+bmJsb2NrczsgaSsrKQogCXsKLQkJaW5zdHJfdGltZQlpb19zdGFydDsKKwkJLyog TXVzdCBiZSBjb25zZWN1dGl2ZSBibG9jayBudW1iZXJzLiAqLworCQlBc3NlcnQoQnVmZmVyR2V0 QmxvY2tOdW1iZXIoYnVmZmVyc1tpIC0gMV0pID09CisJCQkgICBCdWZmZXJHZXRCbG9ja051bWJl cihidWZmZXJzW2ldKSAtIDEpOwogCi0JCS8qIFdlIGZvdW5kIGEgYnVmZmVyIHRoYXQgd2UgbmVl ZCB0byByZWFkIGluLiAqLwotCQlBc3NlcnQoaW9fYnVmZmVyc1swXSA9PSBidWZmZXJzW25ibG9j a3NfZG9uZV0pOwotCQlpb19wYWdlc1swXSA9IEJ1ZmZlckdldEJsb2NrKGJ1ZmZlcnNbbmJsb2Nr c19kb25lXSk7Ci0JCWlvX2J1ZmZlcnNfbGVuID0gMTsKKwkJaWYgKCFSZWFkQnVmZmVyc0NhblN0 YXJ0SU8oYnVmZmVyc1tpXSwgdHJ1ZSkpCisJCQlicmVhazsKIAotCQkvKgotCQkgKiBIb3cgbWFu eSBuZWlnaGJvcmluZy1vbi1kaXNrIGJsb2NrcyBjYW4gd2Ugc2NhdHRlci1yZWFkIGludG8gb3Ro ZXIKLQkJICogYnVmZmVycyBhdCB0aGUgc2FtZSB0aW1lPyAgSW4gdGhpcyBjYXNlIHdlIGRvbid0 IHdhaXQgaWYgd2Ugc2VlIGFuCi0JCSAqIEkvTyBhbHJlYWR5IGluIHByb2dyZXNzLiAgV2UgYWxy ZWFkeSBzZXQgQk1fSU9fSU5fUFJPR1JFU1MgZm9yIHRoZQotCQkgKiBoZWFkIGJsb2NrLCBzbyB3 ZSBzaG91bGQgZ2V0IG9uIHdpdGggdGhhdCBJL08gYXMgc29vbiBhcyBwb3NzaWJsZS4KLQkJICov Ci0JCWZvciAoaW50IGkgPSBuYmxvY2tzX2RvbmUgKyAxOyBpIDwgb3BlcmF0aW9uLT5uYmxvY2tz OyBpKyspCi0JCXsKLQkJCWlmICghUmVhZEJ1ZmZlcnNDYW5TdGFydElPKGJ1ZmZlcnNbaV0sIHRy dWUpKQotCQkJCWJyZWFrOwotCQkJLyogTXVzdCBiZSBjb25zZWN1dGl2ZSBibG9jayBudW1iZXJz LiAqLwotCQkJQXNzZXJ0KEJ1ZmZlckdldEJsb2NrTnVtYmVyKGJ1ZmZlcnNbaSAtIDFdKSA9PQot CQkJCSAgIEJ1ZmZlckdldEJsb2NrTnVtYmVyKGJ1ZmZlcnNbaV0pIC0gMSk7Ci0JCQlBc3NlcnQo aW9fYnVmZmVyc1tpb19idWZmZXJzX2xlbl0gPT0gYnVmZmVyc1tpXSk7CisJCUFzc2VydChpb19i dWZmZXJzW2lvX2J1ZmZlcnNfbGVuXSA9PSBidWZmZXJzW2ldKTsKIAotCQkJaW9fcGFnZXNbaW9f YnVmZmVyc19sZW4rK10gPSBCdWZmZXJHZXRCbG9jayhidWZmZXJzW2ldKTsKLQkJfQorCQlpb19w YWdlc1tpb19idWZmZXJzX2xlbisrXSA9IEJ1ZmZlckdldEJsb2NrKGJ1ZmZlcnNbaV0pOworCX0K IAotCQkvKiBnZXQgYSByZWZlcmVuY2UgdG8gd2FpdCBmb3IgaW4gV2FpdFJlYWRCdWZmZXJzKCkg Ki8KLQkJcGdhaW9faW9fZ2V0X3dyZWYoaW9oLCAmb3BlcmF0aW9uLT5pb193cmVmKTsKKwkvKiBn ZXQgYSByZWZlcmVuY2UgdG8gd2FpdCBmb3IgaW4gV2FpdFJlYWRCdWZmZXJzKCkgKi8KKwlwZ2Fp b19pb19nZXRfd3JlZihpb2gsICZvcGVyYXRpb24tPmlvX3dyZWYpOwogCi0JCS8qIHByb3ZpZGUg dGhlIGxpc3Qgb2YgYnVmZmVycyB0byB0aGUgY29tcGxldGlvbiBjYWxsYmFja3MgKi8KLQkJcGdh aW9faW9fc2V0X2hhbmRsZV9kYXRhXzMyKGlvaCwgKHVpbnQzMiAqKSBpb19idWZmZXJzLCBpb19i dWZmZXJzX2xlbik7CisJLyogcHJvdmlkZSB0aGUgbGlzdCBvZiBidWZmZXJzIHRvIHRoZSBjb21w bGV0aW9uIGNhbGxiYWNrcyAqLworCXBnYWlvX2lvX3NldF9oYW5kbGVfZGF0YV8zMihpb2gsICh1 aW50MzIgKikgaW9fYnVmZmVycywgaW9fYnVmZmVyc19sZW4pOwogCi0JCXBnYWlvX2lvX3JlZ2lz dGVyX2NhbGxiYWNrcyhpb2gsCi0JCQkJCQkJCQlwZXJzaXN0ZW5jZSA9PSBSRUxQRVJTSVNURU5D RV9URU1QID8KLQkJCQkJCQkJCVBHQUlPX0hDQl9MT0NBTF9CVUZGRVJfUkVBRFYgOgotCQkJCQkJ CQkJUEdBSU9fSENCX1NIQVJFRF9CVUZGRVJfUkVBRFYsCi0JCQkJCQkJCQlmbGFncyk7CisJcGdh aW9faW9fcmVnaXN0ZXJfY2FsbGJhY2tzKGlvaCwKKwkJCQkJCQkJcGVyc2lzdGVuY2UgPT0gUkVM UEVSU0lTVEVOQ0VfVEVNUCA/CisJCQkJCQkJCVBHQUlPX0hDQl9MT0NBTF9CVUZGRVJfUkVBRFYg OgorCQkJCQkJCQlQR0FJT19IQ0JfU0hBUkVEX0JVRkZFUl9SRUFEViwKKwkJCQkJCQkJZmxhZ3Mp OwogCi0JCXBnYWlvX2lvX3NldF9mbGFnKGlvaCwgaW9oX2ZsYWdzKTsKKwlwZ2Fpb19pb19zZXRf ZmxhZyhpb2gsIGlvaF9mbGFncyk7CiAKLQkJLyogLS0tCi0JCSAqIEV2ZW4gdGhvdWdoIHdlJ3Jl IHRyeWluZyB0byBpc3N1ZSBJTyBhc3luY2hyb25vdXNseSwgdHJhY2sgdGhlIHRpbWUKLQkJICog aW4gc21ncnN0YXJ0cmVhZHYoKToKLQkJICogLSBpZiBpb19tZXRob2QgPT0gSU9NRVRIT0RfU1lO Qywgd2Ugd2lsbCBhbHdheXMgcGVyZm9ybSB0aGUgSU8KLQkJICogICBpbW1lZGlhdGVseQotCQkg KiAtIHRoZSBpbyBtZXRob2QgbWlnaHQgbm90IHN1cHBvcnQgdGhlIElPIChlLmcuIHdvcmtlciBJ TyBmb3IgYSB0ZW1wCi0JCSAqICAgdGFibGUpCi0JCSAqIC0tLQotCQkgKi8KLQkJaW9fc3RhcnQg PSBwZ3N0YXRfcHJlcGFyZV9pb190aW1lKHRyYWNrX2lvX3RpbWluZyk7Ci0JCXNtZ3JzdGFydHJl YWR2KGlvaCwgb3BlcmF0aW9uLT5zbWdyLCBmb3JrbnVtLAotCQkJCQkgICBibG9ja251bSwKLQkJ CQkJICAgaW9fcGFnZXMsIGlvX2J1ZmZlcnNfbGVuKTsKLQkJcGdzdGF0X2NvdW50X2lvX29wX3Rp bWUoaW9fb2JqZWN0LCBpb19jb250ZXh0LCBJT09QX1JFQUQsCi0JCQkJCQkJCWlvX3N0YXJ0LCAx LCBpb19idWZmZXJzX2xlbiAqIEJMQ0tTWik7CisJLyogLS0tCisJICogRXZlbiB0aG91Z2ggd2Un cmUgdHJ5aW5nIHRvIGlzc3VlIElPIGFzeW5jaHJvbm91c2x5LCB0cmFjayB0aGUgdGltZQorCSAq IGluIHNtZ3JzdGFydHJlYWR2KCk6CisJICogLSBpZiBpb19tZXRob2QgPT0gSU9NRVRIT0RfU1lO Qywgd2Ugd2lsbCBhbHdheXMgcGVyZm9ybSB0aGUgSU8KKwkgKiAgIGltbWVkaWF0ZWx5CisJICog LSB0aGUgaW8gbWV0aG9kIG1pZ2h0IG5vdCBzdXBwb3J0IHRoZSBJTyAoZS5nLiB3b3JrZXIgSU8g Zm9yIGEgdGVtcAorCSAqICAgdGFibGUpCisJICogLS0tCisJICovCisJaW9fc3RhcnQgPSBwZ3N0 YXRfcHJlcGFyZV9pb190aW1lKHRyYWNrX2lvX3RpbWluZyk7CisJc21ncnN0YXJ0cmVhZHYoaW9o LCBvcGVyYXRpb24tPnNtZ3IsIGZvcmtudW0sCisJCQkJICAgYmxvY2tudW0sCisJCQkJICAgaW9f cGFnZXMsIGlvX2J1ZmZlcnNfbGVuKTsKKwlwZ3N0YXRfY291bnRfaW9fb3BfdGltZShpb19vYmpl Y3QsIGlvX2NvbnRleHQsIElPT1BfUkVBRCwKKwkJCQkJCQlpb19zdGFydCwgMSwgaW9fYnVmZmVy c19sZW4gKiBCTENLU1opOwogCi0JCWlmIChwZXJzaXN0ZW5jZSA9PSBSRUxQRVJTSVNURU5DRV9U RU1QKQotCQkJcGdCdWZmZXJVc2FnZS5sb2NhbF9ibGtzX3JlYWQgKz0gaW9fYnVmZmVyc19sZW47 Ci0JCWVsc2UKLQkJCXBnQnVmZmVyVXNhZ2Uuc2hhcmVkX2Jsa3NfcmVhZCArPSBpb19idWZmZXJz X2xlbjsKKwlpZiAocGVyc2lzdGVuY2UgPT0gUkVMUEVSU0lTVEVOQ0VfVEVNUCkKKwkJcGdCdWZm ZXJVc2FnZS5sb2NhbF9ibGtzX3JlYWQgKz0gaW9fYnVmZmVyc19sZW47CisJZWxzZQorCQlwZ0J1 ZmZlclVzYWdlLnNoYXJlZF9ibGtzX3JlYWQgKz0gaW9fYnVmZmVyc19sZW47CiAKLQkJLyoKLQkJ ICogVHJhY2sgdmFjdXVtIGNvc3Qgd2hlbiBpc3N1aW5nIElPLCBub3QgYWZ0ZXIgd2FpdGluZyBm b3IgaXQuCi0JCSAqIE90aGVyd2lzZSB3ZSBjb3VsZCBlbmQgdXAgaXNzdWluZyBhIGxvdCBvZiBJ TyBpbiBhIHNob3J0IHRpbWVzcGFuLAotCQkgKiBkZXNwaXRlIGEgbG93IGNvc3QgbGltaXQuCi0J CSAqLwotCQlpZiAoVmFjdXVtQ29zdEFjdGl2ZSkKLQkJCVZhY3V1bUNvc3RCYWxhbmNlICs9IFZh Y3V1bUNvc3RQYWdlTWlzcyAqIGlvX2J1ZmZlcnNfbGVuOworCS8qCisJICogVHJhY2sgdmFjdXVt IGNvc3Qgd2hlbiBpc3N1aW5nIElPLCBub3QgYWZ0ZXIgd2FpdGluZyBmb3IgaXQuIE90aGVyd2lz ZQorCSAqIHdlIGNvdWxkIGVuZCB1cCBpc3N1aW5nIGEgbG90IG9mIElPIGluIGEgc2hvcnQgdGlt ZXNwYW4sIGRlc3BpdGUgYSBsb3cKKwkgKiBjb3N0IGxpbWl0LgorCSAqLworCWlmIChWYWN1dW1D b3N0QWN0aXZlKQorCQlWYWN1dW1Db3N0QmFsYW5jZSArPSBWYWN1dW1Db3N0UGFnZU1pc3MgKiBp b19idWZmZXJzX2xlbjsKIAotCQkqbmJsb2Nrc19wcm9ncmVzcyA9IGlvX2J1ZmZlcnNfbGVuOwot CQlkaWRfc3RhcnRfaW8gPSB0cnVlOwotCX0KKwkqbmJsb2Nrc19wcm9ncmVzcyA9IGlvX2J1ZmZl cnNfbGVuOwogCi0JcmV0dXJuIGRpZF9zdGFydF9pbzsKKwlyZXR1cm4gdHJ1ZTsKIH0KIAogLyoK LS0gCjIuNDMuMAoK --000000000000ba4671064d4f5fb2 Content-Type: text/x-patch; charset="US-ASCII"; name="v6-0007-Introduce-PrepareHeadBufferReadIO-and-PrepareAddi.patch" Content-Disposition: attachment; filename="v6-0007-Introduce-PrepareHeadBufferReadIO-and-PrepareAddi.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmwa92rq6 RnJvbSAyMDBhZjBkNTg5MDU0ZjhkMDE1YTFlZDRhZTM0N2M2ODQxNDliZGU4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBXZWQsIDE4IE1hciAyMDI2IDExOjEzOjI1IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2NiA3LzhdIEludHJvZHVjZSBQcmVwYXJlSGVhZEJ1ZmZlclJlYWRJTygpIGFuZAogUHJl cGFyZUFkZGl0aW9uYWxCdWZmZXJSZWFkSU8oKQoKUmVwbGFjZSBSZWFkQnVmZmVyc0NhblN0YXJ0 SU8oKSBhbmQgUmVhZEJ1ZmZlcnNDYW5TdGFydElPT25jZSgpIHdpdGgKbmV3IGV4cGxpY2l0IGhl bHBlciBmdW5jdGlvbnMgdGhhdCBpbmxpbmUgdGhlIGxvZ2ljIGZyb20KU3RhcnRCdWZmZXJJTygp IGFuZCBTdGFydExvY2FsQnVmZmVySU8oKS4KCkJlc2lkZXMgdGhlIGlubGluZWQgbG9naWMgYmVp bmcgZWFzaWVyIHRvIHJlYXNvbiwgU3RhcnRCdWZmZXJJTygpCmRvZXNuJ3QgZGlzdGluZ3Vpc2gg YmV0d2VlbiAnYWxyZWFkeSB2YWxpZCcgYW5kICdJTyBpbiBwcm9ncmVzcycgKGFuZApleHBsaWNp dGx5IHN0YXRlcyBpdCBkb2VzIG5vdCB3YW50IHRvKSwgd2hpY2ggaXMgcmVxdWlyZWQgdG8gZGVm ZXIKd2FpdGluZyBmb3IgaW4tcHJvZ3Jlc3MgSU8uIEEgZnV0dXJlIGNvbW1pdCB3aWxsIGltcGxl bWVudCBkZWZlcnJlZAp3YWl0aW5nIGZvciBpbi1wcm9ncmVzcyBJTy4KLS0tCiBzcmMvYmFja2Vu ZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYyB8IDE3MSArKysrKysrKysrKysrKysrKysrKysrKy0t LS0tCiAxIGZpbGUgY2hhbmdlZCwgMTQxIGluc2VydGlvbnMoKyksIDMwIGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jIGIvc3JjL2Jh Y2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKaW5kZXggYTk5OTViNzU5MTcuLjIxNzlhZGUw N2NjIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYworKysg Yi9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYwpAQCAtMTY1OSw0MyArMTY1OSwx NTAgQEAgQ2hlY2tSZWFkQnVmZmVyc09wZXJhdGlvbihSZWFkQnVmZmVyc09wZXJhdGlvbiAqb3Bl cmF0aW9uLCBib29sIGlzX2NvbXBsZXRlKQogI2VuZGlmCiB9CiAKLS8qIGhlbHBlciBmb3IgUmVh ZEJ1ZmZlcnNDYW5TdGFydElPKCksIHRvIGF2b2lkIHJlcGV0aXRpb24gKi8KLXN0YXRpYyBpbmxp bmUgYm9vbAotUmVhZEJ1ZmZlcnNDYW5TdGFydElPT25jZShCdWZmZXIgYnVmZmVyLCBib29sIG5v d2FpdCkKKy8qCisgKiBMb2NhbCB2ZXJzaW9uIG9mIFByZXBhcmVIZWFkQnVmZmVyUmVhZElPKCku IEhlcmUgaW5zdGVhZCBvZiBsb2NhbGJ1Zi5jIHRvCisgKiBhdm9pZCBhbiBleHRlcm5hbCBmdW5j dGlvbiBjYWxsLgorICovCitzdGF0aWMgYm9vbAorUHJlcGFyZUhlYWRMb2NhbEJ1ZmZlclJlYWRJ TyhCdWZmZXIgYnVmZmVyKQogewotCWlmIChCdWZmZXJJc0xvY2FsKGJ1ZmZlcikpCi0JCXJldHVy biBTdGFydExvY2FsQnVmZmVySU8oR2V0TG9jYWxCdWZmZXJEZXNjcmlwdG9yKC1idWZmZXIgLSAx KSwKLQkJCQkJCQkJICB0cnVlLCBub3dhaXQpOwotCWVsc2UKLQkJcmV0dXJuIFN0YXJ0QnVmZmVy SU8oR2V0QnVmZmVyRGVzY3JpcHRvcihidWZmZXIgLSAxKSwgdHJ1ZSwgbm93YWl0KTsKKwlCdWZm ZXJEZXNjICpkZXNjID0gR2V0TG9jYWxCdWZmZXJEZXNjcmlwdG9yKC1idWZmZXIgLSAxKTsKKwl1 aW50NjQJCWJ1Zl9zdGF0ZSA9IHBnX2F0b21pY19yZWFkX3U2NCgmZGVzYy0+c3RhdGUpOworCisJ LyoKKwkgKiBUaGUgYnVmZmVyIGNvdWxkIGFscmVhZHkgYmUgdmFsaWQgaWYgYSBwcmlvciBJTyBi eSB0aGlzIGJhY2tlbmQgd2FzCisJICogY29tcGxldGVkIGFuZCByZWNsYWltZWQgaW5jaWRlbnRh bGx5IChlLmcuIHdoaWxlIGFjcXVpcmluZyBhIG5ldyBBSU8KKwkgKiBoYW5kbGUpLiBPbmx5IHRo ZSBvd25pbmcgYmFja2VuZCBjYW4gc2V0IEJNX1ZBTElEIG9uIGEgbG9jYWwgYnVmZmVyLgorCSAq LworCWlmIChidWZfc3RhdGUgJiBCTV9WQUxJRCkKKwkJcmV0dXJuIGZhbHNlOworCisJLyoKKwkg KiBTdWJtaXQgYW55IHN0YWdlZCBJTyBiZWZvcmUgY2hlY2tpbmcgZm9yIGluLXByb2dyZXNzIElP LiBXaXRob3V0IHRoaXMsCisJICogdGhlIHdyZWYgY2hlY2sgYmVsb3cgY291bGQgZmluZCBJTyB0 aGF0IHRoaXMgYmFja2VuZCBzdGFnZWQgYnV0IGhhc24ndAorCSAqIHN1Ym1pdHRlZCB5ZXQuIFdh aXRpbmcgb24gdGhhdCB3b3VsZCBQQU5JQyBiZWNhdXNlIHRoZSBvd25lciBjYW4ndCB3YWl0CisJ ICogb24gaXRzIG93biBzdGFnZWQgSU8uCisJICovCisJcGdhaW9fc3VibWl0X3N0YWdlZCgpOwor CisJLyogV2FpdCBmb3IgaW4tcHJvZ3Jlc3MgSU8gKi8KKwlpZiAocGdhaW9fd3JlZl92YWxpZCgm ZGVzYy0+aW9fd3JlZikpCisJeworCQlQZ0Fpb1dhaXRSZWYgaW93ID0gZGVzYy0+aW9fd3JlZjsK KworCQlwZ2Fpb193cmVmX3dhaXQoJmlvdyk7CisKKwkJYnVmX3N0YXRlID0gcGdfYXRvbWljX3Jl YWRfdTY0KCZkZXNjLT5zdGF0ZSk7CisJfQorCisJLyoKKwkgKiBJZiBCTV9WQUxJRCBpcyBzZXQs IHdlIHdhaXRlZCBvbiBJTyBhbmQgaXQgY29tcGxldGVkIHN1Y2Nlc3NmdWxseS4KKwkgKiBPdGhl cndpc2UsIHdlJ2xsIGluaXRpYXRlIElPIG9uIHRoZSBidWZmZXIuCisJICovCisJcmV0dXJuICEo YnVmX3N0YXRlICYgQk1fVkFMSUQpOwogfQogCiAvKgotICogSGVscGVyIGZvciBBc3luY1JlYWRC dWZmZXJzIHRoYXQgdHJpZXMgdG8gZ2V0IHRoZSBidWZmZXIgcmVhZHkgZm9yIElPLgorICogVHJ5 IHRvIHN0YXJ0IElPIG9uIHRoZSBmaXJzdCBidWZmZXIgaW4gYSBuZXcgcnVuIG9mIGJsb2Nrcy4g SWYgQUlPIGlzIGluCisgKiBwcm9ncmVzcywgYmUgaXQgaW4gdGhpcyBiYWNrZW5kIG9yIGFub3Ro ZXIgYmFja2VuZCwgd2Ugd2FpdCBmb3IgaXQgdG8KKyAqIGZpbmlzaCBhbmQgdGhlbiBjaGVjayB0 aGUgcmVzdWx0LgorICoKKyAqIFJldHVybnMgdHJ1ZSBpZiB0aGUgYnVmZmVyIGlzIHJlYWR5IGZv ciBJTywgZmFsc2UgaWYgdGhlIGJ1ZmZlciBpcyBhbHJlYWR5CisgKiB2YWxpZC4KICAqLwotc3Rh dGljIGlubGluZSBib29sCi1SZWFkQnVmZmVyc0NhblN0YXJ0SU8oQnVmZmVyIGJ1ZmZlciwgYm9v bCBub3dhaXQpCitzdGF0aWMgYm9vbAorUHJlcGFyZUhlYWRCdWZmZXJSZWFkSU8oQnVmZmVyIGJ1 ZmZlcikKIHsKLQkvKgotCSAqIElmIHRoaXMgYmFja2VuZCBjdXJyZW50bHkgaGFzIHN0YWdlZCBJ Tywgd2UgbmVlZCB0byBzdWJtaXQgdGhlIHBlbmRpbmcKLQkgKiBJTyBiZWZvcmUgd2FpdGluZyBm b3IgdGhlIHJpZ2h0IHRvIGlzc3VlIElPLCB0byBhdm9pZCB0aGUgcG90ZW50aWFsIGZvcgotCSAq IGRlYWRsb2NrcyAoYW5kLCBtb3JlIGNvbW1vbmx5LCB1bm5lY2Vzc2FyeSBkZWxheXMgZm9yIG90 aGVyIGJhY2tlbmRzKS4KLQkgKi8KLQlpZiAoIW5vd2FpdCAmJiBwZ2Fpb19oYXZlX3N0YWdlZCgp KQorCXVpbnQ2NAkJYnVmX3N0YXRlOworCUJ1ZmZlckRlc2MgKmRlc2M7CisKKwlpZiAoQnVmZmVy SXNMb2NhbChidWZmZXIpKQorCQlyZXR1cm4gUHJlcGFyZUhlYWRMb2NhbEJ1ZmZlclJlYWRJTyhi dWZmZXIpOworCisJUmVzb3VyY2VPd25lckVubGFyZ2UoQ3VycmVudFJlc291cmNlT3duZXIpOwor CWRlc2MgPSBHZXRCdWZmZXJEZXNjcmlwdG9yKGJ1ZmZlciAtIDEpOworCisJZm9yICg7OykKIAl7 Ci0JCWlmIChSZWFkQnVmZmVyc0NhblN0YXJ0SU9PbmNlKGJ1ZmZlciwgdHJ1ZSkpCi0JCQlyZXR1 cm4gdHJ1ZTsKKwkJYnVmX3N0YXRlID0gTG9ja0J1ZkhkcihkZXNjKTsKKworCQlBc3NlcnQoYnVm X3N0YXRlICYgQk1fVEFHX1ZBTElEKTsKKworCQkvKiBBbHJlYWR5IHZhbGlkLCBubyB3b3JrIHRv IGRvICovCisJCWlmIChidWZfc3RhdGUgJiBCTV9WQUxJRCkKKwkJeworCQkJVW5sb2NrQnVmSGRy KGRlc2MpOworCQkJcmV0dXJuIGZhbHNlOworCQl9CisKKwkJaWYgKGJ1Zl9zdGF0ZSAmIEJNX0lP X0lOX1BST0dSRVNTKQorCQl7CisJCQlVbmxvY2tCdWZIZHIoZGVzYyk7CisKKwkJCS8qCisJCQkg KiBJZiB0aGlzIGJhY2tlbmQgY3VycmVudGx5IGhhcyBzdGFnZWQgSU8sIHN1Ym1pdCBpdCBiZWZv cmUKKwkJCSAqIHdhaXRpbmcgZm9yIGluLXByb2dyZXNzIElPLCB0byBhdm9pZCBwb3RlbnRpYWwg ZGVhZGxvY2tzIGFuZAorCQkJICogdW5uZWNlc3NhcnkgZGVsYXlzLgorCQkJICovCisJCQlwZ2Fp b19zdWJtaXRfc3RhZ2VkKCk7CisJCQlXYWl0SU8oZGVzYyk7CisJCQljb250aW51ZTsKKwkJfQog CiAJCS8qCi0JCSAqIFVuZm9ydHVuYXRlbHkgU3RhcnRCdWZmZXJJTygpIHJldHVybmluZyBmYWxz ZSBkb2Vzbid0IGFsbG93IHRvCi0JCSAqIGRpc3Rpbmd1aXNoIGJldHdlZW4gdGhlIGJ1ZmZlciBh bHJlYWR5IGJlaW5nIHZhbGlkIGFuZCBJTyBhbHJlYWR5Ci0JCSAqIGJlaW5nIGluIHByb2dyZXNz LiBTaW5jZSBJTyBhbHJlYWR5IGJlaW5nIGluIHByb2dyZXNzIGlzIHF1aXRlCi0JCSAqIHJhcmUs IHRoaXMgYXBwcm9hY2ggc2VlbXMgZmluZS4KKwkJICogTm8gSU8gaW4gcHJvZ3Jlc3MgYW5kIG5v dCBhbHJlYWR5IHZhbGlkOyBXZSB3aWxsIHN0YXJ0IElPLiBJdCdzCisJCSAqIHBvc3NpYmxlIHRo YXQgdGhlIElPIHdhcyBpbiBwcm9ncmVzcyBhbmQgbmV2ZXIgYmVjYW1lIHZhbGlkIGJlY2F1c2UK KwkJICogdGhlIElPIGVycm9yZWQgb3V0LiBXZSdsbCBkbyB0aGUgSU8gb3Vyc2VsdmVzLgogCQkg Ki8KLQkJcGdhaW9fc3VibWl0X3N0YWdlZCgpOworCQlVbmxvY2tCdWZIZHJFeHQoZGVzYywgYnVm X3N0YXRlLCBCTV9JT19JTl9QUk9HUkVTUywgMCwgMCk7CisJCVJlc291cmNlT3duZXJSZW1lbWJl ckJ1ZmZlcklPKEN1cnJlbnRSZXNvdXJjZU93bmVyLAorCQkJCQkJCQkJICBCdWZmZXJEZXNjcmlw dG9yR2V0QnVmZmVyKGRlc2MpKTsKKworCQlyZXR1cm4gdHJ1ZTsKKwl9Cit9CisKKy8qCisgKiBX aGVuIGJ1aWxkaW5nIGEgbmV3IElPIGZyb20gbXVsdGlwbGUgYnVmZmVycywgd2Ugd29uJ3QgaW5j bHVkZSBidWZmZXJzCisgKiB0aGF0IGFyZSBhbHJlYWR5IHZhbGlkIG9yIGFscmVhZHkgaW4gcHJv Z3Jlc3MuIFRoaXMgZnVuY3Rpb24gc2hvdWxkIG9ubHkgYmUKKyAqIHVzZWQgZm9yIGFkZGl0aW9u YWwgYWRqYWNlbnQgYnVmZmVycyBmb2xsb3dpbmcgdGhlIGhlYWQgYnVmZmVyIGluIGEgbmV3IElP LgorICoKKyAqIFRoaXMgZnVuY3Rpb24gbXVzdCBuZXZlciB3YWl0IGZvciBJTyB0byBhdm9pZCBk ZWFkbG9ja3MuIFRoZSBoZWFkIGJ1ZmZlcgorICogYWxyZWFkeSBoYXMgQk1fSU9fSU5fUFJPR1JF U1Mgc2V0LCBzbyB3ZSdsbCBqdXN0IGlzc3VlIHRoYXQgSU8gYW5kIGNvbWUKKyAqIGJhY2sgaW4g bGlldSBvZiB3YWl0aW5nIGhlcmUuCisgKgorICogUmV0dXJucyB0cnVlIGlmIHRoZSBidWZmZXIg d2FzIHN1Y2Nlc3NmdWxseSBwcmVwYXJlZCBmb3IgSU8gYW5kIGZhbHNlIGlmIGl0CisgKiBpcyBy ZWplY3RlZCBhbmQgdGhlIHJlYWQgSU8gc2hvdWxkIG5vdCBpbmNsdWRlIHRoaXMgYnVmZmVyLgor ICovCitzdGF0aWMgYm9vbAorUHJlcGFyZUFkZGl0aW9uYWxCdWZmZXJSZWFkSU8oQnVmZmVyIGJ1 ZmZlcikKK3sKKwl1aW50NjQJCWJ1Zl9zdGF0ZTsKKwlCdWZmZXJEZXNjICpkZXNjOworCisJaWYg KEJ1ZmZlcklzTG9jYWwoYnVmZmVyKSkKKwl7CisJCWRlc2MgPSBHZXRMb2NhbEJ1ZmZlckRlc2Ny aXB0b3IoLWJ1ZmZlciAtIDEpOworCQlidWZfc3RhdGUgPSBwZ19hdG9taWNfcmVhZF91NjQoJmRl c2MtPnN0YXRlKTsKKwkJLyogTG9jYWwgYnVmZmVycyBkb24ndCB1c2UgQk1fSU9fSU5fUFJPR1JF U1MgKi8KKwkJaWYgKGJ1Zl9zdGF0ZSAmIEJNX1ZBTElEIHx8IHBnYWlvX3dyZWZfdmFsaWQoJmRl c2MtPmlvX3dyZWYpKQorCQkJcmV0dXJuIGZhbHNlOworCX0KKwllbHNlCisJeworCQlSZXNvdXJj ZU93bmVyRW5sYXJnZShDdXJyZW50UmVzb3VyY2VPd25lcik7CisJCWRlc2MgPSBHZXRCdWZmZXJE ZXNjcmlwdG9yKGJ1ZmZlciAtIDEpOworCQlidWZfc3RhdGUgPSBMb2NrQnVmSGRyKGRlc2MpOwor CQlpZiAoYnVmX3N0YXRlICYgKEJNX1ZBTElEIHwgQk1fSU9fSU5fUFJPR1JFU1MpKQorCQl7CisJ CQlVbmxvY2tCdWZIZHIoZGVzYyk7CisJCQlyZXR1cm4gZmFsc2U7CisJCX0KKwkJVW5sb2NrQnVm SGRyRXh0KGRlc2MsIGJ1Zl9zdGF0ZSwgQk1fSU9fSU5fUFJPR1JFU1MsIDAsIDApOworCQlSZXNv dXJjZU93bmVyUmVtZW1iZXJCdWZmZXJJTyhDdXJyZW50UmVzb3VyY2VPd25lciwgYnVmZmVyKTsK IAl9CiAKLQlyZXR1cm4gUmVhZEJ1ZmZlcnNDYW5TdGFydElPT25jZShidWZmZXIsIG5vd2FpdCk7 CisJcmV0dXJuIHRydWU7CiB9CiAKIC8qCkBAIC0xOTM0LDggKzIwNDEsMTAgQEAgQXN5bmNSZWFk QnVmZmVycyhSZWFkQnVmZmVyc09wZXJhdGlvbiAqb3BlcmF0aW9uLCBpbnQgKm5ibG9ja3NfcHJv Z3Jlc3MpCiAJfQogCiAJLyoKLQkgKiBHZXQgSU8gaGFuZGxlIGJlZm9yZSBSZWFkQnVmZmVyc0Nh blN0YXJ0SU8oKSwgYXMgcGdhaW9faW9fYWNxdWlyZSgpCi0JICogbWlnaHQgYmxvY2ssIHdoaWNo IHdlIGRvbid0IHdhbnQgYWZ0ZXIgc2V0dGluZyBJT19JTl9QUk9HUkVTUy4KKwkgKiBXZSBtdXN0 IGdldCBhbiBJTyBoYW5kbGUgYmVmb3JlIFByZXBhcmVIZWFkQnVmZmVyUmVhZElPKCksIGFzCisJ ICogcGdhaW9faW9fYWNxdWlyZSgpIG1pZ2h0IGJsb2NrLCB3aGljaCB3ZSBkb24ndCB3YW50IGFm dGVyIHNldHRpbmcKKwkgKiBJT19JTl9QUk9HUkVTUy4gSWYgd2UgZG9uJ3QgbmVlZCB0byBkbyB0 aGUgSU8sIHdlJ2xsIHJlbGVhc2UgdGhlCisJICogaGFuZGxlLgogCSAqCiAJICogSWYgd2UgbmVl ZCB0byB3YWl0IGZvciBJTyBiZWZvcmUgd2UgY2FuIGdldCBhIGhhbmRsZSwgc3VibWl0CiAJICog YWxyZWFkeS1zdGFnZWQgSU8gZmlyc3QsIHNvIHRoYXQgb3RoZXIgYmFja2VuZHMgZG9uJ3QgbmVl ZCB0byB3YWl0LgpAQCAtMTk1Nyw2ICsyMDY2LDggQEAgQXN5bmNSZWFkQnVmZmVycyhSZWFkQnVm ZmVyc09wZXJhdGlvbiAqb3BlcmF0aW9uLCBpbnQgKm5ibG9ja3NfcHJvZ3Jlc3MpCiAJCWlvaCA9 IHBnYWlvX2lvX2FjcXVpcmUoQ3VycmVudFJlc291cmNlT3duZXIsICZvcGVyYXRpb24tPmlvX3Jl dHVybik7CiAJfQogCisJcGdhaW9fd3JlZl9jbGVhcigmb3BlcmF0aW9uLT5pb193cmVmKTsKKwog CS8qCiAJICogQ2hlY2sgaWYgd2UgY2FuIHN0YXJ0IElPIG9uIHRoZSBmaXJzdCB0by1iZS1yZWFk IGJ1ZmZlci4KIAkgKgpAQCAtMTk2NCwxMCArMjA3NSwxMCBAQCBBc3luY1JlYWRCdWZmZXJzKFJl YWRCdWZmZXJzT3BlcmF0aW9uICpvcGVyYXRpb24sIGludCAqbmJsb2Nrc19wcm9ncmVzcykKIAkg KiBmb3IgdGhlIG91dGNvbWU6IGVpdGhlciBkb25lLCBvciBzb21ldGhpbmcgd2VudCB3cm9uZyBh bmQgd2Ugd2lsbAogCSAqIHJldHJ5LgogCSAqLwotCWlmICghUmVhZEJ1ZmZlcnNDYW5TdGFydElP KGJ1ZmZlcnNbbmJsb2Nrc19kb25lXSwgZmFsc2UpKQorCWlmICghUHJlcGFyZUhlYWRCdWZmZXJS ZWFkSU8oYnVmZmVyc1tuYmxvY2tzX2RvbmVdKSkKIAl7CiAJCS8qCi0JCSAqIFNvbWVvbmUgZWxz ZSBoYXMgYWxyZWFkeSBjb21wbGV0ZWQgdGhpcyBibG9jaywgd2UncmUgZG9uZS4KKwkJICogU29t ZW9uZSBoYXMgYWxyZWFkeSBjb21wbGV0ZWQgdGhpcyBibG9jaywgd2UncmUgZG9uZS4KIAkJICoK IAkJICogV2hlbiBJTyBpcyBuZWNlc3NhcnksIC0+bmJsb2Nrc19kb25lIGlzIHVwZGF0ZWQgaW4K IAkJICogUHJvY2Vzc1JlYWRCdWZmZXJzUmVzdWx0KCksIGJ1dCB0aGF0IGlzIG5vdCBjYWxsZWQg aWYgbm8gSU8gaXMKQEAgLTIwNDYsNyArMjE1Nyw3IEBAIEFzeW5jUmVhZEJ1ZmZlcnMoUmVhZEJ1 ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbiwgaW50ICpuYmxvY2tzX3Byb2dyZXNzKQogCQlBc3Nl cnQoQnVmZmVyR2V0QmxvY2tOdW1iZXIoYnVmZmVyc1tpIC0gMV0pID09CiAJCQkgICBCdWZmZXJH ZXRCbG9ja051bWJlcihidWZmZXJzW2ldKSAtIDEpOwogCi0JCWlmICghUmVhZEJ1ZmZlcnNDYW5T dGFydElPKGJ1ZmZlcnNbaV0sIHRydWUpKQorCQlpZiAoIVByZXBhcmVBZGRpdGlvbmFsQnVmZmVy UmVhZElPKGJ1ZmZlcnNbaV0pKQogCQkJYnJlYWs7CiAKIAkJQXNzZXJ0KGlvX2J1ZmZlcnNbaW9f YnVmZmVyc19sZW5dID09IGJ1ZmZlcnNbaV0pOwotLSAKMi40My4wCgo= --000000000000ba4671064d4f5fb2 Content-Type: text/x-patch; charset="US-ASCII"; name="v6-0008-AIO-Don-t-wait-for-already-in-progress-IO.patch" Content-Disposition: attachment; filename="v6-0008-AIO-Don-t-wait-for-already-in-progress-IO.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmwa95c37 RnJvbSA2M2NiNzMxMTc2YTYyMzIwZDI5NmY5NjhiMTJhNWQ0ZDM2ZTcwM2QwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBNZWxhbmllIFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21h aWwuY29tPgpEYXRlOiBXZWQsIDE4IE1hciAyMDI2IDExOjE3OjU3IC0wNDAwClN1YmplY3Q6IFtQ QVRDSCB2NiA4LzhdIEFJTzogRG9uJ3Qgd2FpdCBmb3IgYWxyZWFkeSBpbi1wcm9ncmVzcyBJTwoK V2hlbiBhIGJhY2tlbmQgYXR0ZW1wdHMgdG8gc3RhcnQgYSByZWFkIElPIGFuZCBmaW5kcyB0aGUg Zmlyc3QgYnVmZmVyCmFscmVhZHkgaGFzIEkvTyBpbiBwcm9ncmVzcywgcHJldmlvdXNseSBpdCB3 YWl0ZWQgZm9yIHRoYXQgSS9PIHRvCmNvbXBsZXRlIGJlZm9yZSBpbml0aWF0aW5nIHJlYWRzIGZv ciBhbnkgb2YgdGhlIHN1YnNlcXVlbnQgYnVmZmVycy4KCkFsdGhvdWdoIHRoZSBiYWNrZW5kIG11 c3Qgd2FpdCBmb3IgdGhlIEkvTyB0byBmaW5pc2ggd2hlbiBhY3F1aXJpbmcgdGhlCmJ1ZmZlciwg dGhlcmUncyBubyByZWFzb24gZm9yIGl0IHRvIHdhaXQgd2hlbiBzZXR0aW5nIHVwIHRoZSByZWFk Cm9wZXJhdGlvbi4gV2FpdGluZyBhdCB0aGlzIHBvaW50IHByZXZlbnRzIHRoZSBiYWNrZW5kIGZy b20gc3RhcnRpbmcgSS9PCm9uIHN1YnNlcXVlbnQgYnVmZmVycyBhbmQgY2FuIHNpZ25pZmljYW50 bHkgcmVkdWNlIGNvbmN1cnJlbmN5LgoKVGhpcyBtYXR0ZXJzIGluIHR3byB3b3JrbG9hZHM6IHdo ZW4gbXVsdGlwbGUgYmFja2VuZHMgc2NhbiB0aGUgc2FtZQpyZWxhdGlvbiBjb25jdXJyZW50bHks IGFuZCB3aGVuIGEgc2luZ2xlIGJhY2tlbmQgcmVxdWVzdHMgdGhlIHNhbWUgYmxvY2sKbXVsdGlw bGUgdGltZXMgd2l0aGluIHRoZSByZWFkYWhlYWQgZGlzdGFuY2UuCgpJZiBiYWNrZW5kcyB3YWl0 IGVhY2ggdGltZSB0aGV5IGVuY291bnRlciBhbiBpbi1wcm9ncmVzcyByZWFkLAp0aGUgYWNjZXNz IHBhdHRlcm4gZWZmZWN0aXZlbHkgZGVnZW5lcmF0ZXMgaW50byBzeW5jaHJvbm91cyBJL08uCgpU byBmaXggdGhpcywgd2hlbiBlbmNvdW50ZXJpbmcgYW4gYWxyZWFkeSBpbi1wcm9ncmVzcyBJTyBm b3IgdGhlIGhlYWQKYnVmZmVyLCBhIGJhY2tlbmQgbm93IHJlY29yZHMgdGhlIGJ1ZmZlcidzIHdh aXQgcmVmZXJlbmNlIGFuZCBkZWZlcnMKd2FpdGluZyB1bnRpbCBXYWl0UmVhZEJ1ZmZlcnMoKSwg d2hlbiBpdCBhY3R1YWxseSBuZWVkcyB0byBhY3F1aXJlIHRoZQpidWZmZXIuCgpJbiByYXJlIGNh c2VzLCBhIGJhY2tlbmQgbWF5IHN0aWxsIG5lZWQgdG8gd2FpdCBzeW5jaHJvbm91c2x5IGF0IElP CnN0YXJ0IHRpbWU6IGlmIGFub3RoZXIgYmFja2VuZCBoYXMgc2V0IEJNX0lPX0lOX1BST0dSRVNT IG9uIHRoZSBidWZmZXIKYnV0IGhhcyBub3QgeWV0IHNldCB0aGUgd2FpdCByZWZlcmVuY2UuIFN1 Y2ggd2luZG93cyBzaG91bGQgYmUgYnJpZWYgYW5kCnVuY29tbW9uLgoKQXV0aG9yOiBNZWxhbmll IFBsYWdlbWFuIDxtZWxhbmllcGxhZ2VtYW5AZ21haWwuY29tPgpSZXZpZXdlZC1ieTogQW5kcmVz IEZyZXVuZCA8YW5kcmVzQGFuYXJhemVsLmRlPgpSZXZpZXdlZC1ieTogTmF6aXIgQmlsYWwgWWF2 dXogPGJ5YXZ1ejgxQGdtYWlsLmNvbT4KRGlzY3Vzc2lvbjogaHR0cHM6Ly9wb3N0Z3IuZXMvbS9m bGF0L3psamVyZ3dlcXRpN3g2N2xnNWlqZTJyemp1c2llMzduc2xzbmtqa2tieTRsYXFxYmZ3JTQw M3AzenU1MjJ5eWt2Ci0tLQogc3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMgfCAy MDEgKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLQogc3JjL2luY2x1ZGUvc3RvcmFnZS9idWZt Z3IuaCAgICAgICAgfCAgIDQgKy0KIHNyYy90b29scy9wZ2luZGVudC90eXBlZGVmcy5saXN0ICAg IHwgICAxICsKIDMgZmlsZXMgY2hhbmdlZCwgMTQ1IGluc2VydGlvbnMoKyksIDYxIGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvYnVmZmVyL2J1Zm1nci5jIGIv c3JjL2JhY2tlbmQvc3RvcmFnZS9idWZmZXIvYnVmbWdyLmMKaW5kZXggMjE3OWFkZTA3Y2MuLjMx ZDE1NjNhNjlmIDEwMDY0NAotLS0gYS9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3Iu YworKysgYi9zcmMvYmFja2VuZC9zdG9yYWdlL2J1ZmZlci9idWZtZ3IuYwpAQCAtMTg1LDYgKzE4 NSwyMCBAQCB0eXBlZGVmIHN0cnVjdCBTTWdyU29ydEFycmF5CiAJU01nclJlbGF0aW9uIHNyZWw7 CiB9IFNNZ3JTb3J0QXJyYXk7CiAKKy8qCisgKiBJbiBBc3luY1JlYWRCdWZmZXJzKCksIHdoZW4g cHJlcGFyaW5nIGEgYnVmZmVyIGZvciByZWFkaW5nIGFuZCBzZXR0aW5nCisgKiBCTV9JT19JTl9Q Uk9HUkVTUywgdGhlIGJ1ZmZlciBtYXkgYWxyZWFkeSBoYXZlIEkvTyBpbiBwcm9ncmVzcyBvciBt YXkKKyAqIGFscmVhZHkgY29udGFpbiB0aGUgZGVzaXJlZCBibG9jay4gQXN5bmNSZWFkQnVmZmVy cygpIG11c3QgZGlzdGluZ3Vpc2gKKyAqIGJldHdlZW4gdGhlc2UgY2FzZXMgKGFuZCB0aGUgY2Fz ZSB3aGVyZSBpdCBzaG91bGQgaW5pdGlhdGUgSS9PKSBzbyBpdCBjYW4KKyAqIG1hcmsgYW4gaW4t cHJvZ3Jlc3MgYnVmZmVyIGFzIGZvcmVpZ24gSS9PIHJhdGhlciB0aGFuIHdhaXRpbmcgb24gaXQu CisgKi8KK3R5cGVkZWYgZW51bSBQcmVwYXJlUmVhZEJ1ZmZlclN0YXR1cworeworCVJFQURfQlVG RkVSX0FMUkVBRFlfRE9ORSwKKwlSRUFEX0JVRkZFUl9JTl9QUk9HUkVTUywKKwlSRUFEX0JVRkZF Ul9SRUFEWV9GT1JfSU8sCit9IFByZXBhcmVSZWFkQnVmZmVyU3RhdHVzOworCiAvKiBHVUMgdmFy aWFibGVzICovCiBib29sCQl6ZXJvX2RhbWFnZWRfcGFnZXMgPSBmYWxzZTsKIGludAkJCWJnd3Jp dGVyX2xydV9tYXhwYWdlcyA9IDEwMDsKQEAgLTE2NjMsOCArMTY3Nyw5IEBAIENoZWNrUmVhZEJ1 ZmZlcnNPcGVyYXRpb24oUmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbiwgYm9vbCBpc19j b21wbGV0ZSkKICAqIExvY2FsIHZlcnNpb24gb2YgUHJlcGFyZUhlYWRCdWZmZXJSZWFkSU8oKS4g SGVyZSBpbnN0ZWFkIG9mIGxvY2FsYnVmLmMgdG8KICAqIGF2b2lkIGFuIGV4dGVybmFsIGZ1bmN0 aW9uIGNhbGwuCiAgKi8KLXN0YXRpYyBib29sCi1QcmVwYXJlSGVhZExvY2FsQnVmZmVyUmVhZElP KEJ1ZmZlciBidWZmZXIpCitzdGF0aWMgUHJlcGFyZVJlYWRCdWZmZXJTdGF0dXMKK1ByZXBhcmVI ZWFkTG9jYWxCdWZmZXJSZWFkSU8oUmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbiwKKwkJ CQkJCQkgQnVmZmVyIGJ1ZmZlcikKIHsKIAlCdWZmZXJEZXNjICpkZXNjID0gR2V0TG9jYWxCdWZm ZXJEZXNjcmlwdG9yKC1idWZmZXIgLSAxKTsKIAl1aW50NjQJCWJ1Zl9zdGF0ZSA9IHBnX2F0b21p Y19yZWFkX3U2NCgmZGVzYy0+c3RhdGUpOwpAQCAtMTY3NSw0OSArMTY5MCw2MCBAQCBQcmVwYXJl SGVhZExvY2FsQnVmZmVyUmVhZElPKEJ1ZmZlciBidWZmZXIpCiAJICogaGFuZGxlKS4gT25seSB0 aGUgb3duaW5nIGJhY2tlbmQgY2FuIHNldCBCTV9WQUxJRCBvbiBhIGxvY2FsIGJ1ZmZlci4KIAkg Ki8KIAlpZiAoYnVmX3N0YXRlICYgQk1fVkFMSUQpCi0JCXJldHVybiBmYWxzZTsKKwkJcmV0dXJu IFJFQURfQlVGRkVSX0FMUkVBRFlfRE9ORTsKIAogCS8qCiAJICogU3VibWl0IGFueSBzdGFnZWQg SU8gYmVmb3JlIGNoZWNraW5nIGZvciBpbi1wcm9ncmVzcyBJTy4gV2l0aG91dCB0aGlzLAogCSAq IHRoZSB3cmVmIGNoZWNrIGJlbG93IGNvdWxkIGZpbmQgSU8gdGhhdCB0aGlzIGJhY2tlbmQgc3Rh Z2VkIGJ1dCBoYXNuJ3QKLQkgKiBzdWJtaXR0ZWQgeWV0LiBXYWl0aW5nIG9uIHRoYXQgd291bGQg UEFOSUMgYmVjYXVzZSB0aGUgb3duZXIgY2FuJ3Qgd2FpdAotCSAqIG9uIGl0cyBvd24gc3RhZ2Vk IElPLgorCSAqIHN1Ym1pdHRlZCB5ZXQuIElmIHdlIHJldHVybmVkIFJFQURfQlVGRkVSX0lOX1BS T0dSRVNTIGFuZAorCSAqIFdhaXRSZWFkQnVmZmVycygpIHRoZW4gdHJpZWQgdG8gd2FpdCBvbiBp dCwgd2UnZCBQQU5JQyBiZWNhdXNlIHRoZQorCSAqIG93bmVyIGNhbid0IHdhaXQgb24gaXRzIG93 biBzdGFnZWQgSU8uCiAJICovCiAJcGdhaW9fc3VibWl0X3N0YWdlZCgpOwogCi0JLyogV2FpdCBm b3IgaW4tcHJvZ3Jlc3MgSU8gKi8KKwkvKiBXZSd2ZSBhbHJlYWR5IGFzeW5jaHJvbm91c2x5IHN0 YXJ0ZWQgdGhpcyBJTywgc28gam9pbiBpdCAqLwogCWlmIChwZ2Fpb193cmVmX3ZhbGlkKCZkZXNj LT5pb193cmVmKSkKIAl7Ci0JCVBnQWlvV2FpdFJlZiBpb3cgPSBkZXNjLT5pb193cmVmOwotCi0J CXBnYWlvX3dyZWZfd2FpdCgmaW93KTsKLQotCQlidWZfc3RhdGUgPSBwZ19hdG9taWNfcmVhZF91 NjQoJmRlc2MtPnN0YXRlKTsKKwkJb3BlcmF0aW9uLT5pb193cmVmID0gZGVzYy0+aW9fd3JlZjsK KwkJb3BlcmF0aW9uLT5mb3JlaWduX2lvID0gdHJ1ZTsKKwkJcmV0dXJuIFJFQURfQlVGRkVSX0lO X1BST0dSRVNTOwogCX0KIAotCS8qCi0JICogSWYgQk1fVkFMSUQgaXMgc2V0LCB3ZSB3YWl0ZWQg b24gSU8gYW5kIGl0IGNvbXBsZXRlZCBzdWNjZXNzZnVsbHkuCi0JICogT3RoZXJ3aXNlLCB3ZSds bCBpbml0aWF0ZSBJTyBvbiB0aGUgYnVmZmVyLgotCSAqLwotCXJldHVybiAhKGJ1Zl9zdGF0ZSAm IEJNX1ZBTElEKTsKKwkvKiBQcmVwYXJlIHRvIHN0YXJ0IElPIG9uIHRoaXMgYnVmZmVyICovCisJ cmV0dXJuIFJFQURfQlVGRkVSX1JFQURZX0ZPUl9JTzsKIH0KIAogLyoKICAqIFRyeSB0byBzdGFy dCBJTyBvbiB0aGUgZmlyc3QgYnVmZmVyIGluIGEgbmV3IHJ1biBvZiBibG9ja3MuIElmIEFJTyBp cyBpbgotICogcHJvZ3Jlc3MsIGJlIGl0IGluIHRoaXMgYmFja2VuZCBvciBhbm90aGVyIGJhY2tl bmQsIHdlIHdhaXQgZm9yIGl0IHRvCi0gKiBmaW5pc2ggYW5kIHRoZW4gY2hlY2sgdGhlIHJlc3Vs dC4KKyAqIHByb2dyZXNzLCBiZSBpdCBpbiB0aGlzIGJhY2tlbmQgb3IgYW5vdGhlciBiYWNrZW5k LCB3ZSBqdXN0IGFzc29jaWF0ZSB0aGUKKyAqIHdhaXQgcmVmZXJlbmNlIHdpdGggdGhlIG9wZXJh dGlvbiBhbmQgd2FpdCBpbiBXYWl0UmVhZEJ1ZmZlcnMoKS4gVGhpcyB0dXJucworICogb3V0IHRv IGJlIGltcG9ydGFudCBmb3IgcGVyZm9ybWFuY2UgaW4gdHdvIHdvcmtsb2FkczoKKyAqCisgKiAx KSBBIHJlYWQgc3RyZWFtIHRoYXQgaGFzIHRvIHJlYWQgdGhlIHNhbWUgYmxvY2sgbXVsdGlwbGUg dGltZXMgd2l0aGluIHRoZQorICogICAgcmVhZGFoZWFkIGRpc3RhbmNlLiBUaGlzIGNhbiBoYXBw ZW4gZS5nLiBmb3IgdGhlIHRhYmxlIGFjY2Vzc2VzIG9mIGFuCisgKiAgICBpbmRleCBzY2FuLgor ICoKKyAqIDIpIENvbmN1cnJlbnQgc2NhbnMgYnkgbXVsdGlwbGUgYmFja2VuZHMgb24gdGhlIHNh bWUgcmVsYXRpb24uCisgKgorICogSWYgd2Ugd2VyZSB0byBzeW5jaHJvbm91c2x5IHdhaXQgZm9y IHRoZSBpbi1wcm9ncmVzcyBJTywgd2UnZCBub3QgYmUgYWJsZQorICogdG8ga2VlcCBlbm91Z2gg SS9PIGluIGZsaWdodC4KKyAqCisgKiBJZiB3ZSBkbyBmaW5kIHRoZXJlIGlzIG9uZ29pbmcgSS9P IGZvciB0aGUgYnVmZmVyLCB3ZSBzZXQgdXAgYSAxLWJsb2NrCisgKiBSZWFkQnVmZmVyc09wZXJh dGlvbiB0aGF0IFdhaXRSZWFkQnVmZmVycyB0aGVuIGNhbiB3YWl0IG9uLgogICoKLSAqIFJldHVy bnMgdHJ1ZSBpZiB0aGUgYnVmZmVyIGlzIHJlYWR5IGZvciBJTywgZmFsc2UgaWYgdGhlIGJ1ZmZl ciBpcyBhbHJlYWR5Ci0gKiB2YWxpZC4KKyAqIEl0J3MgcG9zc2libGUgdGhhdCBhbm90aGVyIGJh Y2tlbmQgaGFzIHN0YXJ0ZWQgSU8gb24gdGhlIGJ1ZmZlciBidXQgbm90IHlldAorICogc2V0IGl0 cyB3YWl0IHJlZmVyZW5jZS4gSW4gdGhpcyBjYXNlLCB3ZSBoYXZlIG5vIGNob2ljZSBidXQgdG8g d2FpdCBmb3IKKyAqIGVpdGhlciB0aGUgd2FpdCByZWZlcmVuY2UgdG8gYmUgdmFsaWQgb3IgdGhl IElPIHRvIGJlIGRvbmUuCiAgKi8KLXN0YXRpYyBib29sCi1QcmVwYXJlSGVhZEJ1ZmZlclJlYWRJ TyhCdWZmZXIgYnVmZmVyKQorc3RhdGljIFByZXBhcmVSZWFkQnVmZmVyU3RhdHVzCitQcmVwYXJl SGVhZEJ1ZmZlclJlYWRJTyhSZWFkQnVmZmVyc09wZXJhdGlvbiAqb3BlcmF0aW9uLAorCQkJCQkJ QnVmZmVyIGJ1ZmZlcikKIHsKIAl1aW50NjQJCWJ1Zl9zdGF0ZTsKIAlCdWZmZXJEZXNjICpkZXNj OwogCiAJaWYgKEJ1ZmZlcklzTG9jYWwoYnVmZmVyKSkKLQkJcmV0dXJuIFByZXBhcmVIZWFkTG9j YWxCdWZmZXJSZWFkSU8oYnVmZmVyKTsKKwkJcmV0dXJuIFByZXBhcmVIZWFkTG9jYWxCdWZmZXJS ZWFkSU8ob3BlcmF0aW9uLCBidWZmZXIpOwogCiAJUmVzb3VyY2VPd25lckVubGFyZ2UoQ3VycmVu dFJlc291cmNlT3duZXIpOwogCWRlc2MgPSBHZXRCdWZmZXJEZXNjcmlwdG9yKGJ1ZmZlciAtIDEp OwpAQCAtMTczMiwxMSArMTc1OCwyNSBAQCBQcmVwYXJlSGVhZEJ1ZmZlclJlYWRJTyhCdWZmZXIg YnVmZmVyKQogCQlpZiAoYnVmX3N0YXRlICYgQk1fVkFMSUQpCiAJCXsKIAkJCVVubG9ja0J1Zkhk cihkZXNjKTsKLQkJCXJldHVybiBmYWxzZTsKKwkJCXJldHVybiBSRUFEX0JVRkZFUl9BTFJFQURZ X0RPTkU7CiAJCX0KIAogCQlpZiAoYnVmX3N0YXRlICYgQk1fSU9fSU5fUFJPR1JFU1MpCiAJCXsK KwkJCS8qIEpvaW4gZXhpc3RpbmcgcmVhZCAqLworCQkJaWYgKHBnYWlvX3dyZWZfdmFsaWQoJmRl c2MtPmlvX3dyZWYpKQorCQkJeworCQkJCW9wZXJhdGlvbi0+aW9fd3JlZiA9IGRlc2MtPmlvX3dy ZWY7CisJCQkJb3BlcmF0aW9uLT5mb3JlaWduX2lvID0gdHJ1ZTsKKwkJCQlVbmxvY2tCdWZIZHIo ZGVzYyk7CisJCQkJcmV0dXJuIFJFQURfQlVGRkVSX0lOX1BST0dSRVNTOworCQkJfQorCisJCQkv KgorCQkJICogSWYgdGhlIHdhaXQgcmVmIGlzIG5vdCB2YWxpZCBidXQgdGhlIElPIGlzIGluIHBy b2dyZXNzLCBzb21lb25lCisJCQkgKiBlbHNlIHN0YXJ0ZWQgSU8gYnV0IGhhc24ndCBzZXQgdGhl IHdhaXQgcmVmIHlldC4gV2UgaGF2ZSBubworCQkJICogY2hvaWNlIGJ1dCB0byB3YWl0IHVudGls IHRoZSBJTyBjb21wbGV0ZXMuCisJCQkgKi8KIAkJCVVubG9ja0J1ZkhkcihkZXNjKTsKIAogCQkJ LyoKQEAgLTE3NTgsNyArMTc5OCw3IEBAIFByZXBhcmVIZWFkQnVmZmVyUmVhZElPKEJ1ZmZlciBi dWZmZXIpCiAJCVJlc291cmNlT3duZXJSZW1lbWJlckJ1ZmZlcklPKEN1cnJlbnRSZXNvdXJjZU93 bmVyLAogCQkJCQkJCQkJICBCdWZmZXJEZXNjcmlwdG9yR2V0QnVmZmVyKGRlc2MpKTsKIAotCQly ZXR1cm4gdHJ1ZTsKKwkJcmV0dXJuIFJFQURfQlVGRkVSX1JFQURZX0ZPUl9JTzsKIAl9CiB9CiAK QEAgLTE5MzksOCArMTk3OSwxMSBAQCBXYWl0UmVhZEJ1ZmZlcnMoUmVhZEJ1ZmZlcnNPcGVyYXRp b24gKm9wZXJhdGlvbikKIAkJCSAqIGIpIHJlcG9ydHMgc29tZSB0aW1lIGFzIHdhaXRpbmcsIGV2 ZW4gaWYgd2UgbmV2ZXIgd2FpdGVkCiAJCQkgKgogCQkJICogd2UgZmlyc3QgY2hlY2sgaWYgd2Ug YWxyZWFkeSBrbm93IHRoZSBJTyBpcyBjb21wbGV0ZS4KKwkJCSAqCisJCQkgKiBOb3RlIHRoYXQg b3BlcmF0aW9uLT5pb19yZXR1cm4gaXMgdW5pbml0aWFsaXplZCBmb3IgZm9yZWlnbiBJTywKKwkJ CSAqIHNvIHdlIGNhbm5vdCB1c2UgdGhlIGNoZWFwZXIgUEdBSU9fUlNfVU5LTk9XTiBwcmUtY2hl Y2suCiAJCQkgKi8KLQkJCWlmIChhaW9fcmV0LT5yZXN1bHQuc3RhdHVzID09IFBHQUlPX1JTX1VO S05PV04gJiYKKwkJCWlmICgob3BlcmF0aW9uLT5mb3JlaWduX2lvIHx8IGFpb19yZXQtPnJlc3Vs dC5zdGF0dXMgPT0gUEdBSU9fUlNfVU5LTk9XTikgJiYKIAkJCQkhcGdhaW9fd3JlZl9jaGVja19k b25lKCZvcGVyYXRpb24tPmlvX3dyZWYpKQogCQkJewogCQkJCWluc3RyX3RpbWUJaW9fc3RhcnQg PSBwZ3N0YXRfcHJlcGFyZV9pb190aW1lKHRyYWNrX2lvX3RpbWluZyk7CkBAIC0xOTU5LDExICsy MDAyLDQ1IEBAIFdhaXRSZWFkQnVmZmVycyhSZWFkQnVmZmVyc09wZXJhdGlvbiAqb3BlcmF0aW9u KQogCQkJCUFzc2VydChwZ2Fpb193cmVmX2NoZWNrX2RvbmUoJm9wZXJhdGlvbi0+aW9fd3JlZikp OwogCQkJfQogCi0JCQkvKgotCQkJICogV2Ugbm93IGFyZSBzdXJlIHRoZSBJTyBjb21wbGV0ZWQu IENoZWNrIHRoZSByZXN1bHRzLiBUaGlzCi0JCQkgKiBpbmNsdWRlcyByZXBvcnRpbmcgb24gZXJy b3JzIGlmIHRoZXJlIHdlcmUgYW55LgotCQkJICovCi0JCQlQcm9jZXNzUmVhZEJ1ZmZlcnNSZXN1 bHQob3BlcmF0aW9uKTsKKwkJCWlmICh1bmxpa2VseShvcGVyYXRpb24tPmZvcmVpZ25faW8pKQor CQkJeworCQkJCUJ1ZmZlcgkJYnVmZmVyID0gb3BlcmF0aW9uLT5idWZmZXJzW29wZXJhdGlvbi0+ bmJsb2Nrc19kb25lXTsKKwkJCQlCdWZmZXJEZXNjICpkZXNjID0gQnVmZmVySXNMb2NhbChidWZm ZXIpID8KKwkJCQkJR2V0TG9jYWxCdWZmZXJEZXNjcmlwdG9yKC1idWZmZXIgLSAxKSA6CisJCQkJ CUdldEJ1ZmZlckRlc2NyaXB0b3IoYnVmZmVyIC0gMSk7CisJCQkJdWludDY0CQlidWZfc3RhdGUg PSBwZ19hdG9taWNfcmVhZF91NjQoJmRlc2MtPnN0YXRlKTsKKworCQkJCWlmIChidWZfc3RhdGUg JiBCTV9WQUxJRCkKKwkJCQl7CisJCQkJCUJsb2NrTnVtYmVyIGJsb2NrbnVtID0gb3BlcmF0aW9u LT5ibG9ja251bSArIG9wZXJhdGlvbi0+bmJsb2Nrc19kb25lOworCisJCQkJCW9wZXJhdGlvbi0+ bmJsb2Nrc19kb25lICs9IDE7CisJCQkJCUFzc2VydChvcGVyYXRpb24tPm5ibG9ja3NfZG9uZSA8 PSBvcGVyYXRpb24tPm5ibG9ja3MpOworCisJCQkJCS8qCisJCQkJCSAqIFRyYWNrIHRoaXMgYXMg YSAnaGl0JyBmb3IgdGhpcyBiYWNrZW5kLiBUaGUgYmFja2VuZAorCQkJCQkgKiBwZXJmb3JtaW5n IHRoZSBJTyB3aWxsIHRyYWNrIGl0IGFzIGEgJ3JlYWQnLgorCQkJCQkgKi8KKwkJCQkJVHJhY2tC dWZmZXJIaXQoaW9fb2JqZWN0LCBpb19jb250ZXh0LAorCQkJCQkJCQkgICBvcGVyYXRpb24tPnJl bCwgb3BlcmF0aW9uLT5wZXJzaXN0ZW5jZSwKKwkJCQkJCQkJICAgb3BlcmF0aW9uLT5zbWdyLCBv cGVyYXRpb24tPmZvcmtudW0sCisJCQkJCQkJCSAgIGJsb2NrbnVtKTsKKwkJCQl9CisKKwkJCQkv KgorCQkJCSAqIElmIHRoZSBmb3JlaWduIElPIGZhaWxlZCBhbmQgbGVmdCB0aGUgYnVmZmVyIGlu dmFsaWQsCisJCQkJICogbmJsb2Nrc19kb25lIGlzIG5vdCBpbmNyZW1lbnRlZC4gVGhlIHJldHJ5 IGxvb3AgYmVsb3cgd2lsbAorCQkJCSAqIGNhbGwgQXN5bmNSZWFkQnVmZmVycygpIHdoaWNoIHdp bGwgYXR0ZW1wdCB0aGUgSU8gaXRzZWxmLgorCQkJCSAqLworCQkJfQorCQkJZWxzZQorCQkJewor CQkJCS8qCisJCQkJICogV2Ugbm93IGFyZSBzdXJlIHRoZSBJTyBjb21wbGV0ZWQuIENoZWNrIHRo ZSByZXN1bHRzLiBUaGlzCisJCQkJICogaW5jbHVkZXMgcmVwb3J0aW5nIG9uIGVycm9ycyBpZiB0 aGVyZSB3ZXJlIGFueS4KKwkJCQkgKi8KKwkJCQlQcm9jZXNzUmVhZEJ1ZmZlcnNSZXN1bHQob3Bl cmF0aW9uKTsKKwkJCX0KIAkJfQogCiAJCS8qCkBAIC0yMDA5LDcgKzIwODYsOCBAQCBXYWl0UmVh ZEJ1ZmZlcnMoUmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbikKICAqIGFmZmVjdGVkIGJ5 IHRoZSBjYWxsLiBJZiB0aGUgZmlyc3QgYnVmZmVyIGlzIHZhbGlkLCAqbmJsb2Nrc19wcm9ncmVz cyBpcwogICogc2V0IHRvIDEgYW5kIG9wZXJhdGlvbi0+bmJsb2Nrc19kb25lIGlzIGluY3JlbWVu dGVkLgogICoKLSAqIFJldHVybnMgdHJ1ZSBpZiBJTyB3YXMgaW5pdGlhdGVkLCBmYWxzZSBpZiBu byBJTyB3YXMgbmVjZXNzYXJ5LgorICogUmV0dXJucyB0cnVlIGlmIElPIHdhcyBpbml0aWF0ZWQg b3IgaXMgYWxyZWFkeSBpbiBwcm9ncmVzcyAoZm9yZWlnbiBJTyksCisgKiBmYWxzZSBpZiB0aGUg YnVmZmVyIHdhcyBhbHJlYWR5IHZhbGlkLgogICovCiBzdGF0aWMgYm9vbAogQXN5bmNSZWFkQnVm ZmVycyhSZWFkQnVmZmVyc09wZXJhdGlvbiAqb3BlcmF0aW9uLCBpbnQgKm5ibG9ja3NfcHJvZ3Jl c3MpCkBAIC0yMDI4LDYgKzIxMDYsNyBAQCBBc3luY1JlYWRCdWZmZXJzKFJlYWRCdWZmZXJzT3Bl cmF0aW9uICpvcGVyYXRpb24sIGludCAqbmJsb2Nrc19wcm9ncmVzcykKIAlJT0NvbnRleHQJaW9f Y29udGV4dDsKIAlJT09iamVjdAlpb19vYmplY3Q7CiAJaW5zdHJfdGltZQlpb19zdGFydDsKKwlQ cmVwYXJlUmVhZEJ1ZmZlclN0YXR1cyBzdGF0dXM7CiAKIAlpZiAocGVyc2lzdGVuY2UgPT0gUkVM UEVSU0lTVEVOQ0VfVEVNUCkKIAl7CkBAIC0yMDY2LDQwICsyMTQ1LDQyIEBAIEFzeW5jUmVhZEJ1 ZmZlcnMoUmVhZEJ1ZmZlcnNPcGVyYXRpb24gKm9wZXJhdGlvbiwgaW50ICpuYmxvY2tzX3Byb2dy ZXNzKQogCQlpb2ggPSBwZ2Fpb19pb19hY3F1aXJlKEN1cnJlbnRSZXNvdXJjZU93bmVyLCAmb3Bl cmF0aW9uLT5pb19yZXR1cm4pOwogCX0KIAorCW9wZXJhdGlvbi0+Zm9yZWlnbl9pbyA9IGZhbHNl OwogCXBnYWlvX3dyZWZfY2xlYXIoJm9wZXJhdGlvbi0+aW9fd3JlZik7CiAKLQkvKgotCSAqIENo ZWNrIGlmIHdlIGNhbiBzdGFydCBJTyBvbiB0aGUgZmlyc3QgdG8tYmUtcmVhZCBidWZmZXIuCi0J ICoKLQkgKiBJZiBhbiBJL08gaXMgYWxyZWFkeSBpbiBwcm9ncmVzcyBpbiBhbm90aGVyIGJhY2tl bmQsIHdlIHdhbnQgdG8gd2FpdAotCSAqIGZvciB0aGUgb3V0Y29tZTogZWl0aGVyIGRvbmUsIG9y IHNvbWV0aGluZyB3ZW50IHdyb25nIGFuZCB3ZSB3aWxsCi0JICogcmV0cnkuCi0JICovCi0JaWYg KCFQcmVwYXJlSGVhZEJ1ZmZlclJlYWRJTyhidWZmZXJzW25ibG9ja3NfZG9uZV0pKQorCS8qIENo ZWNrIGlmIHdlIGNhbiBzdGFydCBJTyBvbiB0aGUgZmlyc3QgdG8tYmUtcmVhZCBidWZmZXIgKi8K KwlzdGF0dXMgPSBQcmVwYXJlSGVhZEJ1ZmZlclJlYWRJTyhvcGVyYXRpb24sIGJ1ZmZlcnNbbmJs b2Nrc19kb25lXSk7CisJaWYgKHN0YXR1cyAhPSBSRUFEX0JVRkZFUl9SRUFEWV9GT1JfSU8pCiAJ ewotCQkvKgotCQkgKiBTb21lb25lIGhhcyBhbHJlYWR5IGNvbXBsZXRlZCB0aGlzIGJsb2NrLCB3 ZSdyZSBkb25lLgotCQkgKgotCQkgKiBXaGVuIElPIGlzIG5lY2Vzc2FyeSwgLT5uYmxvY2tzX2Rv bmUgaXMgdXBkYXRlZCBpbgotCQkgKiBQcm9jZXNzUmVhZEJ1ZmZlcnNSZXN1bHQoKSwgYnV0IHRo YXQgaXMgbm90IGNhbGxlZCBpZiBubyBJTyBpcwotCQkgKiBuZWNlc3NhcnkuIFRodXMgdXBkYXRl IGhlcmUuCi0JCSAqLwotCQlvcGVyYXRpb24tPm5ibG9ja3NfZG9uZSArPSAxOworCQlwZ2Fpb19p b19yZWxlYXNlKGlvaCk7CiAJCSpuYmxvY2tzX3Byb2dyZXNzID0gMTsKKwkJaWYgKHN0YXR1cyA9 PSBSRUFEX0JVRkZFUl9BTFJFQURZX0RPTkUpCisJCXsKKwkJCS8qCisJCQkgKiBTb21lb25lIGhh cyBhbHJlYWR5IGNvbXBsZXRlZCB0aGlzIGJsb2NrLCB3ZSdyZSBkb25lLgorCQkJICoKKwkJCSAq IFdoZW4gSU8gaXMgbmVjZXNzYXJ5LCAtPm5ibG9ja3NfZG9uZSBpcyB1cGRhdGVkIGluCisJCQkg KiBQcm9jZXNzUmVhZEJ1ZmZlcnNSZXN1bHQoKSwgYnV0IHRoYXQgaXMgbm90IGNhbGxlZCBpZiBu byBJTyBpcworCQkJICogbmVjZXNzYXJ5LiBUaHVzIHVwZGF0ZSBoZXJlLgorCQkJICovCisJCQlv cGVyYXRpb24tPm5ibG9ja3NfZG9uZSArPSAxOworCQkJQXNzZXJ0KG9wZXJhdGlvbi0+bmJsb2Nr c19kb25lIDw9IG9wZXJhdGlvbi0+bmJsb2Nrcyk7CiAKLQkJcGdhaW9faW9fcmVsZWFzZShpb2gp OwotCQlwZ2Fpb193cmVmX2NsZWFyKCZvcGVyYXRpb24tPmlvX3dyZWYpOworCQkJLyoKKwkJCSAq IFJlcG9ydCBhbmQgdHJhY2sgdGhpcyBhcyBhICdoaXQnIGZvciB0aGlzIGJhY2tlbmQsIGV2ZW4g dGhvdWdoCisJCQkgKiBpdCBtdXN0IGhhdmUgc3RhcnRlZCBvdXQgYXMgYSBtaXNzIGluIFBpbkJ1 ZmZlckZvckJsb2NrKCkuIFRoZQorCQkJICogb3RoZXIgYmFja2VuZCB3aWxsIHRyYWNrIHRoaXMg YXMgYSAncmVhZCcuCisJCQkgKi8KKwkJCVRyYWNrQnVmZmVySGl0KGlvX29iamVjdCwgaW9fY29u dGV4dCwKKwkJCQkJCSAgIG9wZXJhdGlvbi0+cmVsLCBvcGVyYXRpb24tPnBlcnNpc3RlbmNlLAor CQkJCQkJICAgb3BlcmF0aW9uLT5zbWdyLCBvcGVyYXRpb24tPmZvcmtudW0sCisJCQkJCQkgICBi bG9ja251bSk7CisJCQlyZXR1cm4gZmFsc2U7CisJCX0KIAotCQkvKgotCQkgKiBSZXBvcnQgYW5k IHRyYWNrIHRoaXMgYXMgYSAnaGl0JyBmb3IgdGhpcyBiYWNrZW5kLCBldmVuIHRob3VnaCBpdAot CQkgKiBtdXN0IGhhdmUgc3RhcnRlZCBvdXQgYXMgYSBtaXNzIGluIFBpbkJ1ZmZlckZvckJsb2Nr KCkuIFRoZSBvdGhlcgotCQkgKiBiYWNrZW5kIHdpbGwgdHJhY2sgdGhpcyBhcyBhICdyZWFkJy4K LQkJICovCi0JCVRyYWNrQnVmZmVySGl0KGlvX29iamVjdCwgaW9fY29udGV4dCwKLQkJCQkJICAg b3BlcmF0aW9uLT5yZWwsIG9wZXJhdGlvbi0+cGVyc2lzdGVuY2UsCi0JCQkJCSAgIG9wZXJhdGlv bi0+c21nciwgb3BlcmF0aW9uLT5mb3JrbnVtLAotCQkJCQkgICBibG9ja251bSk7Ci0JCXJldHVy biBmYWxzZTsKKwkJLyogVGhlIElPIGlzIGFscmVhZHkgaW4tcHJvZ3Jlc3MgKi8KKwkJQXNzZXJ0 KHN0YXR1cyA9PSBSRUFEX0JVRkZFUl9JTl9QUk9HUkVTUyk7CisJCXJldHVybiB0cnVlOwogCX0K IAogCS8qCmRpZmYgLS1naXQgYS9zcmMvaW5jbHVkZS9zdG9yYWdlL2J1Zm1nci5oIGIvc3JjL2lu Y2x1ZGUvc3RvcmFnZS9idWZtZ3IuaAppbmRleCA0MDE3ODk2Zjk1MS4uZGQ0MWI5MmY5NDQgMTAw NjQ0Ci0tLSBhL3NyYy9pbmNsdWRlL3N0b3JhZ2UvYnVmbWdyLmgKKysrIGIvc3JjL2luY2x1ZGUv c3RvcmFnZS9idWZtZ3IuaApAQCAtMTQ0LDkgKzE0NCwxMSBAQCBzdHJ1Y3QgUmVhZEJ1ZmZlcnNP cGVyYXRpb24KIAkgKi8KIAlCdWZmZXIJICAgKmJ1ZmZlcnM7CiAJQmxvY2tOdW1iZXIgYmxvY2tu dW07Ci0JaW50CQkJZmxhZ3M7CisJdWludDE2CQlmbGFnczsKIAlpbnQxNgkJbmJsb2NrczsKIAlp bnQxNgkJbmJsb2Nrc19kb25lOworCS8qIHRydWUgaWYgd2FpdGluZyBvbiBhbm90aGVyIGJhY2tl bmQncyBJTyAqLworCWJvb2wJCWZvcmVpZ25faW87CiAJUGdBaW9XYWl0UmVmIGlvX3dyZWY7CiAJ UGdBaW9SZXR1cm4gaW9fcmV0dXJuOwogfTsKZGlmZiAtLWdpdCBhL3NyYy90b29scy9wZ2luZGVu dC90eXBlZGVmcy5saXN0IGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKaW5kZXgg MzQwNjYyY2Y3MmMuLmZmYWVhNDI3OTUyIDEwMDY0NAotLS0gYS9zcmMvdG9vbHMvcGdpbmRlbnQv dHlwZWRlZnMubGlzdAorKysgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdApAQCAt MjM2NSw2ICsyMzY1LDcgQEAgUHJlZGljYXRlTG9ja0RhdGEKIFByZWRpY2F0ZUxvY2tUYXJnZXRU eXBlCiBQcmVmZXRjaEJ1ZmZlclJlc3VsdAogUHJlcFBhcmFsbGVsUmVzdG9yZVB0clR5cGUKK1By ZXBhcmVSZWFkQnVmZmVyU3RhdHVzCiBQcmVwYXJlU3RtdAogUHJlcGFyZWRTdGF0ZW1lbnQKIFBy ZXNvcnRlZEtleURhdGEKLS0gCjIuNDMuMAoK --000000000000ba4671064d4f5fb2--