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 1w61Cy-003rfW-1k for pgsql-hackers@arkaria.postgresql.org; Fri, 27 Mar 2026 07:02:16 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1w61Cu-007y5k-1c for pgsql-hackers@arkaria.postgresql.org; Fri, 27 Mar 2026 07:02:12 +0000 Received: from magus.postgresql.org ([2a02:c0:301:0:ffff::29]) by malur.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.96) (envelope-from ) id 1w61Cu-007y5c-0H for pgsql-hackers@lists.postgresql.org; Fri, 27 Mar 2026 07:02:12 +0000 Received: from mail-wr1-x42d.google.com ([2a00:1450:4864:20::42d]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1w61Cr-00000001QyH-2AUA for pgsql-hackers@postgresql.org; Fri, 27 Mar 2026 07:02:11 +0000 Received: by mail-wr1-x42d.google.com with SMTP id ffacd0b85a97d-43b87970468so1716876f8f.3 for ; Fri, 27 Mar 2026 00:02:09 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1774594928; cv=none; d=google.com; s=arc-20240605; b=lVcofxOs+ByGSGheEgoHgCgi+Hsz+WS+S3yoXkC6lEkmt/JJqdh66XieP/GZFIb0aS WkCEY7ziN3kRCJeVJSocHTfucG65kUU5K8p3TNdC7Y+bcVS0oQkAxQyXyVButxKQOpTa PEw5hTAMsL9y9j3wmvR1iQ5WpYEWex4KZKWBQ/ufmmrp1nf+iI577VJp4HiyrANRNwzG 0DAHVEWZPPDNBOPVMZEz2qyNlT8w0Mb0K78Gn4rmih0orZgaquyRZVLwRDQzED8SzVsM frQhyBcfnK3oncGH8q/cu380PvrmunSPxIN6pe7E2ckT2qTn4IGNUgMdazAKV7egH/KB UVYg== 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=IWNDSDpO3hmYc6qYWAOH5NDsePSWMmWDPG9dsML/AVc=; fh=7ETRCqb2GXr36Pu7/Gswy8eRe8w5SHyPMBNQkltAtKI=; b=E/uvxgxfg95w4+S0IPCfiYFxT0WgtzSDhayG0m//E+5CLnjYQhoVlLbvQbxY8jilgh JN9x54DXN0Xkay+XwJFXXhbD13f7XTylfUCS9uIT/4eIbk9BT72BWjuFnEj4AsPisIwO gPNw1VivJtMnK/Lob/18m+z+qOELULfcizBI7wd+5iV3KzflKWADbdqWUGjXVh1nVaGi SMAXfGncVdbuS6VV2DDRSrmODs+xntcFLY0SG0he+CynKWkYtFgvwCRTbP4KzsUElzgk 3Mak7Bz3sMITXs26BjcYj+mX9LC7wuvxQ5gVXHvVmJzTOSnBe8molYRLP5VOUQq/ZDxO 8CCQ==; 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=20251104; t=1774594928; x=1775199728; 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=IWNDSDpO3hmYc6qYWAOH5NDsePSWMmWDPG9dsML/AVc=; b=eM4Q4Uadx7vBaLKYfavyOvLOscmB8qlNh4fOrR9hHai+vhyCvJohUxlNwo1tOSmohh OjYthnAvlLr4dwc04sfQEv27pwbF3OcseZ5Y4xocHkhwaYKnkU9J0tZcSACuXmC9ifFC mRJU18krWA/xCbuq7YL0vmSMEloTsmojvpDnuDzXM+/S/WTvFKzZeOQPrt3gPScAmAlH X1jBFkRejbemwUOrbIsOfvSdVPOcA0MQn8gOPaRSMtN0T0UseOLauJbKcy7UEIHb7kZz mM3raxvOeuMeS4wpsO7p3VcgsMavH77WnF83ewLKJ5rh4RQ36m7mIwLTx1zmU+gdz/qc A8Dg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1774594928; x=1775199728; 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=IWNDSDpO3hmYc6qYWAOH5NDsePSWMmWDPG9dsML/AVc=; b=IvaOlZD375PC60yQa2efFZlS1Xt4NwXBkFkKo6dLeSjxWaFXNuOIeGfFa/k2pYX+Qk 1JV83aJpOyyzZtu35DqcmKHU9JCi4HVSQoTT4Nx84isxRi5KpLpo8VjWC4mvuiJEYKry PKuOO5BJCCD80HcP7w8q9ISwQShO4eA4f6xN+VX9arN7ECkBWoMdqtFbssN3qdNUmPB+ 11GXps5yKxByn4RfBvRkgPxqOgA1lf+MR5Y4aG0yhsuQEER+gbJ4URdDxdim4GOz8VcN rFqfn+v3c18s7PS2o+bfsFW7CcxOSW3y/uVqzqDOVRaCmDu3MzhjR1bpA6v8M1pK1qo4 qxdg== X-Forwarded-Encrypted: i=1; AJvYcCU2tdTJLRcBzR5hm1VITwOhm0AAoJ2tb3kTr1iU4MitpqBD0yqxWV2YqMtsciEKNdpLDoI3RUVIqGZvUb9f@postgresql.org X-Gm-Message-State: AOJu0YzioqlXguVL6gTrktj0DcWjw+BdJixfL/N++IgsTQZXGn9cH94e Vi8+W8mIv4YC0ltMo2dS+DqXPS6N5rpdYbn911pBPnnbokqHJO1m0f0Oen7MTYm7oGKfBGvTWvB dM5+hkhMOW+9yxrQxPBIGlqg4MuzOOD4= X-Gm-Gg: ATEYQzzr3ZC0hiofJC8DISDYKWlkb1ocxfhu5J4y9kT2V2jArj60n+NhRNWtRVaMCTt 766ZdmLfwGJYobfqTtmSFX3iWD58kb+xkRWB3Mz0lEBHpKLFkI/AAgEuGLSaqnzGV/SNkHxJ5dP ks3w2rHo+K5zpUrfxFxprj0ODYXVPOjcrwtt6ErY3xDeW4jznR3hJqUe48A/we3uAnThGV7JNbc swmMu3fOvfdeiUJbsDxT5qZlWLh/r98ocgwV8o3lYv+v6xzeHCkYRWUn85XecfOP4RqCtBcU8aP +SP/Tu8EmZkuK/HkCUtw8EMXGix3aew1vj6rOjST7tq0U7VLneJI X-Received: by 2002:a05:6000:200c:b0:43b:8f4e:27f8 with SMTP id ffacd0b85a97d-43b9ea34a8cmr1750399f8f.12.1774594927046; Fri, 27 Mar 2026 00:02:07 -0700 (PDT) MIME-Version: 1.0 References: <26c766d6-db0f-43d3-a618-44f8d40a3121@iki.fi> <62b8dc23-8f6a-4cac-91ff-f74bb5bc159a@iki.fi> <8a6799be-bd42-49fb-8914-856c97bb1977@iki.fi> <113724ab-0028-493f-9605-6e8570f0939f@iki.fi> In-Reply-To: From: Ashutosh Bapat Date: Fri, 27 Mar 2026 12:31:54 +0530 X-Gm-Features: AQROBzDnqSpbz_W0qgTijoYHGH1uYczz1u0xQTeqYEPtD3JWCMDH9gcBCSvgNkM Message-ID: Subject: Re: Better shared data structure management and resizable shared data structures To: Heikki Linnakangas Cc: Robert Haas , Andres Freund , pgsql-hackers , chaturvedipalak1911@gmail.com Content-Type: multipart/mixed; boundary="0000000000003f69c2064dfc14d7" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --0000000000003f69c2064dfc14d7 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable On Wed, Mar 25, 2026 at 9:35=E2=80=AFPM Ashutosh Bapat wrote: > > On Tue, Mar 24, 2026 at 9:02=E2=80=AFPM Ashutosh Bapat > wrote: > > > > > > I will continue from 0008 tomorrow. > > > > I reviewed the documentation part of 0008. I have a few edits attached. > > I have just one comment that's not covered in the edits > > @@ -4254,8 +4254,8 @@ SELECT * FROM pg_locks pl LEFT JOIN pg_prepared_xac= ts ppx > > Anonymous allocations are allocations that have been made > with ShmemAlloc() directly, rather than via > - ShmemInitStruct() or > - ShmemInitHash(). > + ShmemRequestStruct() or > + ShmemRequestHash(). > > > ShmemInitStruct() and ShmemInitHash() are still the functions to > allocate named structures. If we are going to keep ShmemInitStruct() > and ShmemInitHash() around for a while, I think it is more accurate to > mention them in this sentence along with the new functions. > > Will continue reviewing the patch tomorrow. > Here's a complete review of 0008 (from version 8). I see you have already posted v9 which I have not looked at. Please feel free to ignore comments which aren't applicable anymore. Attached patch has minor edits and some code arrangement to make it more readable as mentioned in the comments below. Please incorporate those changes as applicable if you find them useful. + The ShmemRequestStruct() can also be called after + system startup, which is useful to allow small allocations in add-in + libraries that are not specified in + share= d_preload_libraries. + However, after startup the allocation can fail if there is not enough + shared memory available. The system reserves a somes memory for + allocations after startup, but that reservation is small. Do we check the request against the reserved amount or overall memory available? If later, a large request after startup can cause memory allocated for hash tables to be taken away. This was a problem in the previous implementation as well, since ShmemAlloc() could be called after startup. But giving a formal API to do it might encourage more usage, so it would be good to have some checks in place. /* Restore basic shared memory pointers */ if (UsedShmemSegAddr !=3D NULL) + { InitShmemAllocator(UsedShmemSegAddr); + ShmemCallRequestCallbacks(); It's not clear how we keep the list of registered callbacks across the backends and also after restart in-sync. How do we make sure that the callbacks registered at this time are the same callbacks registered before creating the shared memory? How do we make sure that the callbacks registered after the startup are also registered after restart? - /* re-create shared memory and semaphores */ + /* + * Re-initialize shared memory and semaphores. Note: We don't call + * RegisterShmemStructs() here, we keep the old registrations. In There is no RegisterShmemStructs(). Probably this comment is not reuquired. + * This module provides facilities to allocate fixed-size structures in sh= ared + * memory, for things like variables shared between all backend processes. + * Each such structure has a string name to identify it, specified in the + * descriptor when it is requested. shmem_hash.c provides a shared hash ta= ble + * implementation on top of that. This wording works well for resizable structures. Thanks. + * Shared memory managed by shmem.c can never be freed, once allocated. Ea= ch + * hash table has its own free list, so hash buckets can be reused when an + * item is deleted. However, if one hash table grows very large and then + * shrinks, its space cannot be redistributed to other tables. We could bu= ild + * a simple hash bucket garbage collector if need be. Right now, it seems + * unnecessary. The second sentence onwards belong to shmem_hash.c. Don't they? +} shmem_startup_state; This isn't just startup state since the backend can toggle between DONE and LATE_ATTACH_OR_INIT states after the startup. Probably "shmem_state" would be a better name. Also, it might be better to separate the enum and the variable declaration. I was confused for a moment. What does B stand for in the enum values? +static bool AttachOrInit(ShmemStructDesc *desc, bool init_allowed, bool attach_allowed); Init in the name can easily lead into thinking that the function is going to invoke the init callback. I think a better name would be AttachOrAllocate() or something which can not be confused with Init. +/* + * ShmemRequestStruct() --- request a named shared memory area + * + * Subsystems call this to register their shared memory needs. This is + * usually done early in postmaster startup, before the shared memory segm= ent + * has been created, so that the size can be included in the estimate for + * total amount of shared memory needed. We set aside a small amount of + * memory for allocations that happen later, for the benefit of non-preloa= ded + * extensions, but that should not be relied upon. I don't think we need to reiterate the last sentence here, since it's already mentioned in the "Usage" section of the documentation and this API is unrelated to that. + * Attach to all the requested memory areas. + */ + LWLockAcquire(ShmemIndexLock, LW_SHARED); + while (!dclist_is_empty(&requested_shmem_areas)) + { + requested_shmem_area *area =3D dlist_container(requested_shmem_area, node= , + dclist_pop_head_node(&requested_shmem_areas)); Isn't requested_shmem_areas a List*? Why do we need to pop nodes from it? + ShmemStructDesc *desc =3D area->desc; + + AttachOrInit(desc, false, true); + } + list_free(requested_shmem_areas); + requested_shmem_areas =3D NIL; If we pop all the nodes from the list, then the list should be NIL right? Why do we need to free it? + else if (!init_allowed) + { For the sake of documentation and sanity, I would add Assert(!index_entry) here, possibly with a comment. Otherwise it feels like we might be leaving a half-initialized entry in the hash table. What if attach_allowed is false and the entry is not found? Should we throw an error in that case too? It would be foolish to call AttachOrInit with both init_allowed and attach_allowed set to false, but the API allows it and we should check for that. It feels like we should do something about the arguments. The function is hard to read. init_allowed is actually the action the caller wants to take if the entry is not found, and attach_allowed is the action the caller wants to take if the entry is found. Also explain in the comment what does attach mean here especially in case of fixed sized structures. Restructuring the code as attached reads better to me. +/* + * Reset state on postmaster crash restart. + */ +void +ResetShmemAllocator(void) +{ I still think this requires a different name since it's not undoing what InitShmemAllocator() did. Maybe ResetShmemState()? +void +RegisterShmemCallbacks(const ShmemCallbacks *callbacks) ... snip ... + foreach(lc, requested_shmem_areas) Doesn't this list contain all the areas, not just registered in this instance of the call. Does that mean that we need to have all the attach functions idempotent? Why can't we deal with the newly registered areas only? + * FIXME: What to do if multiple shmem areas were requested, and some + * of them are already initialized but not all? */ I doubt if we want to allow attaching to areas which are already attached since the attach_fn may not be idempotent. /* Initialize the hash header, plus a copy of the table name */ + Assert(tabname !=3D NULL); + Assert(CurrentDynaHashCxt !=3D NULL); This looks like a separate patch and separate commit. + + /* + * Extra space to reserve in the shared memory segment, but it's not part + * of the struct itself. This is used for shared memory hash tables that + * can grow beyond the initial size when more buckets are allocated. + */ + size_t extra_size; When we introduce resizable structures (where even the hash table directly itself could be resizable), we will introduce a new field max_size which is easy to get confused with extra_size. Maybe we can rename extra_size to something like "auxilliary_size" to mean size of the auxiliary parts of the structure which are not part of the main struct itself. + /* + * max_size is the estimated maximum number of hashtable entries. This is + * not a hard limit, but the access efficiency will degrade if it is + * exceeded substantially (since it's used to compute directory size and + * the hash table buckets will get overfull). + */ + size_t max_size; + + /* + * init_size is the number of hashtable entries to preallocate. For a + * table whose maximum size is certain, this should be equal to max_size; + * that ensures that no run-time out-of-shared-memory failures can occur. + */ + size_t init_size; Everytime I look at these two fields, I question whether those are the number of entries (i.e. size of the hash table) or number of bytes (size of the memory). I know it's the former, but it indicates that something needs to be changed here, like changing the names to have _entries instead of _size, or changing the type to int64 or some such. Renaming to _entries would conflict with dynahash APIs since they use _size, so maybe the latter? + +/* + * Shared memory is reserved and allocated in stages at postmaster startup= , + * and in EXEC_BACKEND mode, there's some extra work done to "attach" to t= hem The comma after EXEC_BACKEND mode is a bit confusing. It makes me think that the clause after the comma is detached from the EXEC_BACKEND mode. Maybe revise as "Shared memory is reserved and allocated to various shared memory structures in stages at postmaster startup. In EXEC_BACKEND mode, there's some extra work done to "attach" to them at backend startup. ShmemCallbacks holds callback functions that are called at different stages." + * at backend startup. ShmemCallbacks holds callback functions that are + * called at different stages. + */ +typedef struct ShmemCallbacks +{ + /* SHMEM_* flags */ + int flags; I think we should define the flags before this. Also SHMEM_ looks too generic prefix, maybe SHMEM_CALLBACKS_ or SHMEM_CB_. With those changes it will look something like the attached patch. @@ -50,7 +50,6 @@ static InjIoErrorState *inj_io_error_state; static shmem_request_hook_type prev_shmem_request_hook =3D NULL; static shmem_startup_hook_type prev_shmem_startup_hook =3D NULL; - It's good to get rid of an extra line, but maybe a separate commit. --=20 Best Wishes, Ashutosh Bapat --0000000000003f69c2064dfc14d7 Content-Type: application/octet-stream; name="0008_edits.patch.nocibot" Content-Disposition: attachment; filename="0008_edits.patch.nocibot" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mn8jwdzv0 ZGlmZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC94ZnVuYy5zZ21sIGIvZG9jL3NyYy9zZ21sL3hmdW5j LnNnbWwKaW5kZXggYWNmNmZmNzRmOTguLjFjMGYzOWUxMWVjIDEwMDY0NAotLS0gYS9kb2Mvc3Jj L3NnbWwveGZ1bmMuc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwveGZ1bmMuc2dtbApAQCAtMzYyOCw3 ICszNjI4LDcgQEAgQ1JFQVRFIEZVTkNUSU9OIG1ha2VfYXJyYXkoYW55ZWxlbWVudCkgUkVUVVJO UyBhbnlhcnJheQogICAgICAgQWRkLWlucyBjYW4gcmVzZXJ2ZSBzaGFyZWQgbWVtb3J5IG9uIHNl cnZlciBzdGFydHVwLiAgVG8gZG8gc28sIHRoZQogICAgICAgYWRkLWluJ3Mgc2hhcmVkIGxpYnJh cnkgbXVzdCBiZSBwcmVsb2FkZWQgYnkgc3BlY2lmeWluZyBpdCBpbgogICAgICAgPHhyZWYgbGlu a2VuZD0iZ3VjLXNoYXJlZC1wcmVsb2FkLWxpYnJhcmllcyIvPjxpbmRleHRlcm0+PHByaW1hcnk+ c2hhcmVkX3ByZWxvYWRfbGlicmFyaWVzPC9wcmltYXJ5PjwvaW5kZXh0ZXJtPi4KLSAgICAgIFRo ZSBzaGFyZWQgbGlicmFyeSBzaG91bGQgcmVnaXN0ZXIgY2FsbGJhY2tzIGluIGl0cworICAgICAg VGhlIHNoYXJlZCBsaWJyYXJ5IHNob3VsZCByZWdpc3RlciBjYWxsYmFja3MgaW4KICAgICAgIGl0 cyA8ZnVuY3Rpb24+X1BHX2luaXQ8L2Z1bmN0aW9uPiBmdW5jdGlvbiwgd2hpY2ggdGhlbiBnZXQg Y2FsbGVkIGF0IHRoZQogICAgICAgcmlnaHQgc3RhZ2VzIG9mIHRoZSBzeXN0ZW0gc3RhcnR1cCB0 byBpbml0aWFsaXplIHRoZSBzaGFyZWQgbWVtb3J5LgogICAgICAgSGVyZSBpcyBhbiBleGFtcGxl OgpAQCAtMzY5MiwxMSArMzY5MiwxMSBAQCBteV9zaG1lbV9pbml0KHZvaWQgKmFyZykKIH0KIAog PC9wcm9ncmFtbGlzdGluZz4KLSAgICAgIFRoZSA8ZnVuY3Rpb24+cmVxdWVzdF9mbjwvZnVuY3Rp b24+IGNhbGxiYWNrIGlzIGNhbGxlZCBkdXJpbmcgc3lzdGVtCisgICAgICBUaGUgPGZ1bmN0aW9u PnNobWVtX3JlcXVlc3RfZm48L2Z1bmN0aW9uPiBjYWxsYmFjayBpcyBjYWxsZWQgZHVyaW5nIHN5 c3RlbQogICAgICAgc3RhcnR1cCwgYmVmb3JlIHRoZSBzaGFyZWQgbWVtb3J5IGhhcyBiZWVuIGFs bG9jYXRlZC4gSXQgc2hvdWxkIGNhbGwKICAgICAgIDxmdW5jdGlvbj5TaG1lbVJlcXVlc3RTdHJ1 Y3QoKTwvZnVuY3Rpb24+IHRvIHJlZ2lzdGVyIHRoZSBhZGQtaW4ncwogICAgICAgc2hhcmVkIG1l bW9yeSBuZWVkcy4gTm90ZSB0aGF0IDxmdW5jdGlvbj5TaG1lbVJlcXVlc3RTdHJ1Y3QoKTwvZnVu Y3Rpb24+Ci0gICAgICBkb2VzbicnIGltbWVkaWF0ZWx5IGFsbG9jYXRlIG9yIGluaXRpYWxpemUg dGhlIG1lbW9yeSwgaXQgbWVyZWx5CisgICAgICBkb2Vzbid0IGltbWVkaWF0ZWx5IGFsbG9jYXRl IG9yIGluaXRpYWxpemUgdGhlIG1lbW9yeSwgaXQgbWVyZWx5CiAgICAgICByZWdpc3RlcnMgdGhl IHNwYWNlIHRvIGJlIGFsbG9jYXRlZCBsYXRlciBpbiB0aGUgc3RhcnR1cCBzZXF1ZW5jZS4gIFdo ZW4KICAgICAgIHRoZSBtZW1vcnkgaXMgYWxsb2NhdGVkLCBpdCBpcyBpbml0aWFsaXplZCB0byB6 ZXJvLiAgVG8gYW55IG1vcmUgY29tcGxleAogICAgICAgaW5pdGlhbGl6YXRpb24sIHNldCB0aGUg PGZ1bmN0aW9uPmluaXRfZm4oKTwvZnVuY3Rpb24+IGNhbGxiYWNrLCB3aGljaApAQCAtMzcyNiw3 ICszNzI2LDcgQEAgbXlfc2htZW1faW5pdCh2b2lkICphcmcpCiAgICAgICBsaWJyYXJpZXMgdGhh dCBhcmUgbm90IHNwZWNpZmllZCBpbgogICAgICAgPHhyZWYgbGlua2VuZD0iZ3VjLXNoYXJlZC1w cmVsb2FkLWxpYnJhcmllcyIvPjxpbmRleHRlcm0+PHByaW1hcnk+c2hhcmVkX3ByZWxvYWRfbGli cmFyaWVzPC9wcmltYXJ5PjwvaW5kZXh0ZXJtPi4KICAgICAgIEhvd2V2ZXIsIGFmdGVyIHN0YXJ0 dXAgdGhlIGFsbG9jYXRpb24gY2FuIGZhaWwgaWYgdGhlcmUgaXMgbm90IGVub3VnaAotICAgICAg c2hhcmVkIG1lbW9yeSBhdmFpbGFibGUuIFRoZSBzeXN0ZW0gcmVzZXJ2ZXMgYSBzb21lcyBtZW1v cnkgZm9yCisgICAgICBzaGFyZWQgbWVtb3J5IGF2YWlsYWJsZS4gVGhlIHN5c3RlbSByZXNlcnZl cyBzb21lIG1lbW9yeSBmb3IKICAgICAgIGFsbG9jYXRpb25zIGFmdGVyIHN0YXJ0dXAsIGJ1dCB0 aGF0IHJlc2VydmF0aW9uIGlzIHNtYWxsLgogICAgICA8L3BhcmE+CiAgICAgIDxwYXJhPgpAQCAt MzczOSw4ICszNzM5LDggQEAgbXlfc2htZW1faW5pdCh2b2lkICphcmcpCiAgICAgICBXaGVuIDxm dW5jdGlvbj5SZWdpc3RlclNobWVtQ2FsbGJhY2tzKCk8L2Z1bmN0aW9uPiBpcyBjYWxsZWQgYWZ0 ZXIKICAgICAgIHN0YXJ0dXAsIGl0IHdpbGwgaW1tZWRpYXRlbHkgY2FsbCB0aGUgYXBwcm9wcmlh dGUgY2FsbGJhY2tzLCBkZXBlbmRpbmcKICAgICAgIG9uIHdoZXRoZXIgdGhlIHJlcXVlc3RlZCBt ZW1vcnkgYXJlYXMgd2VyZSBhbHJlYWR5IGluaXRpYWxpemVkIGJ5Ci0gICAgICBhbm90aGVyIGJh Y2tlbmQuIFRoZSBjYWxsYmFja3Mgd2lsbCBiZSBoZWxkIHdoaWxlIGhvbGRpbmcgYW4gaW50ZXJu YWwKLSAgICAgIGxvY2ssIHdoaWNoIHByZXZlbnRzIGNvbmN1cnJlbnQgdHdvIGJhY2tlbmRzIGZy b20gaW5pdGlhbGl6YXRpbmcgdGhlCisgICAgICBhbm90aGVyIGJhY2tlbmQuIFRoZSBjYWxsYmFj a3Mgd2lsbCBiZSBjYWxsZWQgd2hpbGUgaG9sZGluZyBhbiBpbnRlcm5hbAorICAgICAgbG9jaywg d2hpY2ggcHJldmVudHMgbXVsdGlwbGUgYmFja2VuZHMgZnJvbSBpbml0aWFsaXphdGluZyB0aGUK ICAgICAgIG1lbW9yeSBhcmVhIGNvbmN1cnJlbnRseS4KICAgICAgPC9wYXJhPgogICAgIDwvc2Vj dDM+CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9zdG9yYWdlL2lwYy9zaG1lbS5jIGIvc3JjL2Jh Y2tlbmQvc3RvcmFnZS9pcGMvc2htZW0uYwppbmRleCBkZTg0M2QwM2M1MC4uY2VmMTYzMjcyNjMg MTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3N0b3JhZ2UvaXBjL3NobWVtLmMKKysrIGIvc3JjL2Jh Y2tlbmQvc3RvcmFnZS9pcGMvc2htZW0uYwpAQCAtMjcsNyArMjcsNyBAQAogICoKICAqIFNoYXJl ZCBtZW1vcnkgYXJlYXMgc2hvdWxkIHVzdWFsbHkgbm90IGJlIGFsbG9jYXRlZCBhZnRlciBwb3N0 bWFzdGVyCiAgKiBzdGFydHVwLCBhbHRob3VnaCB3ZSBkbyBhbGxvdyBzbWFsbCBhbGxvY2F0aW9u cyBsYXRlciBmb3IgdGhlIGJlbmVmaXQgb2YKLSAqIGV4dGVuc2lvbiBtb2R1bGVzIHRoYXQgbG9h ZGVkIGFmdGVyIHN0YXJ0dXAuICBEZXNwaXRlIHRoYXQgYWxsb3dhbmNlLAorICogZXh0ZW5zaW9u IG1vZHVsZXMgdGhhdCBhcmUgbG9hZGVkIGFmdGVyIHN0YXJ0dXAuICBEZXNwaXRlIHRoYXQgYWxs b3dhbmNlLAogICogZXh0ZW5zaW9ucyB0aGF0IG5lZWQgc2hhcmVkIG1lbW9yeSBzaG91bGQgYmUg YWRkZWQgaW4KICAqIHNoYXJlZF9wcmVsb2FkX2xpYnJhcmllcywgYmVjYXVzZSB0aGUgYWxsb3dh bmNlIGlzIHF1aXRlIHNtYWxsIGFuZCB0aGVyZSBpcwogICogbm8gZ3VhcmFudGVlIHRoYXQgYW55 IG1lbW9yeSBpcyBhdmFpbGFibGUgYWZ0ZXIgc3RhcnR1cC4KQEAgLTUwLDcgKzUwLDcgQEAKICAq IC0tLS0tCiAgKgogICogVG8gYWxsb2NhdGUgc2hhcmVkIG1lbW9yeSwgeW91IG5lZWQgdG8gcmVn aXN0ZXIgYSBzZXQgb2YgY2FsbGJhY2sgZnVuY3Rpb25zCi0gKiB3aGljaCBoYW5kbGUgdGhlIGxp ZmVjeWNsZSBvZiB0aGUgYWxsb2NhdGlvbi4gIEluIHRoZSByZWdpc3Rlcl9mbgorICogd2hpY2gg aGFuZGxlIHRoZSBsaWZlY3ljbGUgb2YgdGhlIGFsbG9jYXRpb24uICBJbiB0aGUgcmVxdWVzdF9m biAKICAqIGNhbGxiYWNrLCBmaWxsIGluIGEgU2htZW1TdHJ1Y3REZXNjIGRlc2NyaXB0b3Igd2l0 aCB0aGUgbmFtZSwgc2l6ZSwgYW5kIGFueQogICogb3RoZXIgb3B0aW9ucywgYW5kIGNhbGwgU2ht ZW1SZXF1ZXN0U3RydWN0KCkuICBMZWF2ZSBhbnkgdW51c2VkIGZpZWxkcyBhcwogICogemVyb3Mu CkBAIC05MCwxMiArOTAsMTIgQEAKICAqIC0tLS0tLS0tLQogICoKICAqIEluaXRpYWxpemluZyBz aGFyZWQgbWVtb3J5IGhhcHBlbnMgaW4gbXVsdGlwbGUgcGhhc2VzLiBJbiB0aGUgZmlyc3QgcGhh c2UsCi0gKiBkdXJpbmcgcG9zdG1hc3RlciBzdGFydHVwLCBhbGwgdGhlIHNobWVtX3JlcXVlc3Qg Y2FsbGJhY2tzIGFyZSBjYWxsZWQuCi0gKiBPbmx5IGFmdGVyIGFsbCBhbGwgdGhlIHJlcXVlc3Qg Y2FsbGJhY2tzIGhhdmUgYmVlbiBjYWxsZWQgYW5kIGFsbCB0aGUgc2htZW0KLSAqIGFyZWFzIGhh dmUgYmVlbiByZXF1ZXN0ZWQgYnkgdGhlIFNobWVtUmVxdWVzdFN0cnVjdCgpIGNhbGxzIHdlIGtu b3cgaG93Ci0gKiBtdWNoIHNoYXJlZCBtZW1vcnkgd2UgbmVlZCBpbiB0b3RhbC4gQWZ0ZXIgdGhh dCwgcG9zdG1hc3RlciBhbGxvY2F0ZXMKLSAqIGdsb2JhbCBzaGFyZWQgbWVtb3J5IHNlZ21lbnQs IGFuZCBjYWxscyBhbGwgdGhlIGluaXRfZm4gY2FsbGJhY2tzIHRvCi0gKiBpbml0aWFsaXplIGFs bCB0aGUgcmVxdWVzdGVkIHNobWVtIGFyZWFzLgorICogZHVyaW5nIHBvc3RtYXN0ZXIgc3RhcnR1 cCwgYWxsIHRoZSBzaG1lbV9yZXF1ZXN0IGNhbGxiYWNrcyBhcmUgY2FsbGVkLiAgT25seQorICog YWZ0ZXIgYWxsIHRoZSByZXF1ZXN0IGNhbGxiYWNrcyBoYXZlIGJlZW4gY2FsbGVkIGFuZCBhbGwg dGhlIHNobWVtIGFyZWFzIGhhdmUKKyAqIGJlZW4gcmVxdWVzdGVkIGJ5IHRoZSBTaG1lbVJlcXVl c3RTdHJ1Y3QoKSBjYWxscyB3ZSBrbm93IGhvdyBtdWNoIHNoYXJlZAorICogbWVtb3J5IHdlIG5l ZWQgaW4gdG90YWwuIEFmdGVyIHRoYXQsIHBvc3RtYXN0ZXIgYWxsb2NhdGVzIGdsb2JhbCBzaGFy ZWQKKyAqIG1lbW9yeSBzZWdtZW50LCBhbGxvY2F0ZXMgbWVtb3J5IHRvIHRoZSByZXF1ZXN0ZWQg YXJlYXMsIGFuZCBjYWxscyBhbGwgdGhlCisgKiBpbml0X2ZuIGNhbGxiYWNrcyB0byBpbml0aWFs aXplIGFsbCB0aGUgcmVxdWVzdGVkIHNobWVtIGFyZWFzLgogICoKICAqIEluIHN0YW5kYXJkIFVu aXgtaXNoIGVudmlyb25tZW50cywgaW5kaXZpZHVhbCBiYWNrZW5kcyBkbyBub3QgbmVlZCB0bwog ICogcmUtZXN0YWJsaXNoIHRoZWlyIGxvY2FsIHBvaW50ZXJzIGludG8gc2hhcmVkIG1lbW9yeSwg YmVjYXVzZSB0aGV5IGluaGVyaXQKQEAgLTI5MCwxNiArMjkwLDEyIEBAIERhdHVtCQlwZ19udW1h X2F2YWlsYWJsZShQR19GVU5DVElPTl9BUkdTKTsKIHZvaWQKIFNobWVtUmVxdWVzdFN0cnVjdChT aG1lbVN0cnVjdERlc2MgKmRlc2MpCiB7Ci0JTGlzdENlbGwgKmxjOwotCiAJaWYgKHNobWVtX3N0 YXJ0dXBfc3RhdGUgIT0gU0JfUkVRVUVTVElORykKIAkJZWxvZyhFUlJPUiwgIlNobWVtUmVxdWVz dFN0cnVjdCBjYW4gb25seSBiZSBjYWxsZWQgZnJvbSBhIHNobWVtX3JlcXVlc3QgY2FsbGJhY2si KTsKIAogCS8qIENoZWNrIHRoYXQgaXQncyBub3QgYWxyZWFkeSByZWdpc3RlcmVkIGluIHRoaXMg cHJvY2VzcyAqLwotCWZvcmVhY2gobGMsIHJlcXVlc3RlZF9zaG1lbV9hcmVhcykKKwlmb3JlYWNo X3B0cihTaG1lbVN0cnVjdERlc2MsIGV4aXN0aW5nLCByZXF1ZXN0ZWRfc2htZW1fYXJlYXMpCiAJ ewotCQlTaG1lbVN0cnVjdERlc2MgKmV4aXN0aW5nID0gKFNobWVtU3RydWN0RGVzYyAqKSBsZmly c3QobGMpOwotCiAJCWlmIChzdHJjbXAoZXhpc3RpbmctPm5hbWUsIGRlc2MtPm5hbWUpID09IDAp CiAJCQllcmVwb3J0KEVSUk9SLAogCQkJCQkoZXJybXNnKCJzaGFyZWQgbWVtb3J5IHN0cnVjdCBc IiVzXCIgaXMgYWxyZWFkeSByZWdpc3RlcmVkIiwKQEAgLTMxOSw3ICszMTUsNiBAQCBTaG1lbVJl cXVlc3RTdHJ1Y3QoU2htZW1TdHJ1Y3REZXNjICpkZXNjKQogc2l6ZV90CiBTaG1lbUdldFJlcXVl c3RlZFNpemUodm9pZCkKIHsKLQlMaXN0Q2VsbCAgICpsYzsKIAlzaXplX3QJCXNpemU7CiAKIAkv KiBtZW1vcnkgbmVlZGVkIGZvciB0aGUgU2htZW1JbmRleCAqLwpAQCAtMzI3LDEwICszMjIsOCBA QCBTaG1lbUdldFJlcXVlc3RlZFNpemUodm9pZCkKIAkJCQkJCQkgIHNpemVvZihTaG1lbUluZGV4 RW50KSk7CiAKIAkvKiBtZW1vcnkgbmVlZGVkIGZvciBhbGwgdGhlIHJlcXVlc3RlZCBhcmVhcyAq LwotCWZvcmVhY2gobGMsIHJlcXVlc3RlZF9zaG1lbV9hcmVhcykKKwlmb3JlYWNoX3B0cihTaG1l bVN0cnVjdERlc2MsIGRlc2MsIHJlcXVlc3RlZF9zaG1lbV9hcmVhcykKIAl7Ci0JCVNobWVtU3Ry dWN0RGVzYyAqZGVzYyA9IChTaG1lbVN0cnVjdERlc2MgKikgbGZpcnN0KGxjKTsKLQogCQlzaXpl ID0gYWRkX3NpemUoc2l6ZSwgZGVzYy0+c2l6ZSk7CiAJCXNpemUgPSBhZGRfc2l6ZShzaXplLCBk ZXNjLT5leHRyYV9zaXplKTsKIAl9CkBAIC0zNTgsMTIgKzM1MSw5IEBAIFNobWVtSW5pdFJlcXVl c3RlZCh2b2lkKQogCSAqIEluaXRpYWxpemUgYWxsIHRoZSByZXF1ZXN0ZWQgbWVtb3J5IGFyZWFz LiAgVGhlcmUgYXJlIG5vIGNvbmN1cnJlbnQKIAkgKiBwcm9jZXNzZXMgeWV0LCBzbyBubyBuZWVk IGZvciBsb2NraW5nLgogCSAqLwotCWZvcmVhY2gobGMsIHJlcXVlc3RlZF9zaG1lbV9hcmVhcykK LQl7Ci0JCVNobWVtU3RydWN0RGVzYyAqZGVzYyA9IChTaG1lbVN0cnVjdERlc2MgKikgbGZpcnN0 KGxjKTsKLQorCWZvcmVhY2hfcHRyKFNobWVtU3RydWN0RGVzYywgZGVzYywgcmVxdWVzdGVkX3No bWVtX2FyZWFzKQogCQlBdHRhY2hPckluaXQoZGVzYywgdHJ1ZSwgZmFsc2UpOwotCX0KKwogCWxp c3RfZnJlZShyZXF1ZXN0ZWRfc2htZW1fYXJlYXMpOwogCXJlcXVlc3RlZF9zaG1lbV9hcmVhcyA9 IE5JTDsKIApAQCAtNDY1LDI0ICs0NTUsMjYgQEAgQXR0YWNoT3JJbml0KFNobWVtU3RydWN0RGVz YyAqZGVzYywgYm9vbCBpbml0X2FsbG93ZWQsIGJvb2wgYXR0YWNoX2FsbG93ZWQpCiAJCQkJYnJl YWs7CiAJCX0KIAl9Ci0JZWxzZSBpZiAoIWluaXRfYWxsb3dlZCkKLQl7Ci0JCS8qIGF0dGFjaCB3 YXMgcmVxdWVzdGVkLCBidXQgaXQgd2FzIG5vdCBmb3VuZCAqLwotCQllcmVwb3J0KEZBVEFMLAot CQkJCShlcnJjb2RlKEVSUkNPREVfT1VUX09GX01FTU9SWSksCi0JCQkJIGVycm1zZygiY291bGQg bm90IGZpbmQgU2htZW1JbmRleCBlbnRyeSBmb3IgZGF0YSBzdHJ1Y3R1cmUgXCIlc1wiIiwKLQkJ CQkJCWRlc2MtPm5hbWUpKSk7Ci0JfQotCWVsc2UgaWYgKCFpbmRleF9lbnRyeSkKLQl7Ci0JCS8q IHRyaWVkIHRvIGFkZCBpdCB0byB0aGUgaGFzaCB0YWJsZSwgYnV0IHRoZXJlIHdhcyBubyBzcGFj ZSAqLwotCQllcmVwb3J0KEVSUk9SLAotCQkJCShlcnJjb2RlKEVSUkNPREVfT1VUX09GX01FTU9S WSksCi0JCQkJIGVycm1zZygiY291bGQgbm90IGNyZWF0ZSBTaG1lbUluZGV4IGVudHJ5IGZvciBk YXRhIHN0cnVjdHVyZSBcIiVzXCIiLAotCQkJCQkJZGVzYy0+bmFtZSkpKTsKLQl9CiAJZWxzZQog CXsKKwkJaWYgKCFpbml0X2FsbG93ZWQpCisJCXsKKwkJCS8qIFRoZSBlbnRyeSBpcyBub3QgZm91 bmQgYW5kIHRoZSBjYWxsZXIgZXhwZWN0ZWQgaXQgdG8gYmUgcHJlc2VudC4gKi8KKwkJCWVyZXBv cnQoRkFUQUwsCisJCQkJCShlcnJjb2RlKEVSUkNPREVfT1VUX09GX01FTU9SWSksCisJCQkJCSBl cnJtc2coImNvdWxkIG5vdCBmaW5kIFNobWVtSW5kZXggZW50cnkgZm9yIGRhdGEgc3RydWN0dXJl IFwiJXNcIiIsCisJCQkJCQkJZGVzYy0+bmFtZSkpKTsKKwkJfQorCisJCWlmICghaW5kZXhfZW50 cnkpCisJCXsKKwkJCS8qIHRyaWVkIHRvIGFkZCBpdCB0byB0aGUgaGFzaCB0YWJsZSwgYnV0IHRo ZXJlIHdhcyBubyBzcGFjZSAqLworCQkJZXJlcG9ydChFUlJPUiwKKwkJCQkJKGVycmNvZGUoRVJS Q09ERV9PVVRfT0ZfTUVNT1JZKSwKKwkJCQkJIGVycm1zZygiY291bGQgbm90IGNyZWF0ZSBTaG1l bUluZGV4IGVudHJ5IGZvciBkYXRhIHN0cnVjdHVyZSBcIiVzXCIiLAorCQkJCQkJCWRlc2MtPm5h bWUpKSk7CisJCX0KKwogCQkvKgogCQkgKiBXZSBpbnNlcnRlZCB0aGUgZW50cnkgdG8gdGhlIHNo YXJlZCBtZW1vcnkgaW5kZXguIEFsbG9jYXRlCiAJCSAqIHJlcXVlc3RlZCBhbW91bnQgb2Ygc2hh cmVkIG1lbW9yeSBmb3IgaXQsIGFuZCBkbyBiYXNpYwpAQCAtNzI5LDcgKzcyMSw3IEBAIFNobWVt QWRkcklzVmFsaWQoY29uc3Qgdm9pZCAqYWRkcikKICAqIGJhY2tlbmQgc3RhcnR1cCwgdG8gYWxs b2NhdGUgYW5kIGluaXRpYWxpemUgdGhlIGFyZWEuCiAgKgogICogVGhpcyBpcyBub3JtYWxseSBj YWxsZWQgZWFybHkgZHVyaW5nIHBvc3RtYXN0ZXIgc3RhcnR1cCwgYnV0IGlmIHRoZQotICogU0hN RU1fQUxMT1dfQUZURVJfU1RBUlRVUCBpcyBzZXQsIHRoaXMgY2FuIGFsc28gYmUgdXNlZCBhZnRl ciBzdGFydHVwLAorICogU0hNRU1fQ0JfQUxMT1dfQUZURVJfU1RBUlRVUCBpcyBzZXQsIHRoaXMg Y2FuIGFsc28gYmUgdXNlZCBhZnRlciBzdGFydHVwLAogICogYWx0aG91Z2ggYWZ0ZXIgc3RhcnR1 cCB0aGVyZSdzIG5vIGd1YXJhbnRlZSB0aGF0IHRoZXJlJ3MgZW5vdWdoIHNoYXJlZAogICogbWVt b3J5IGF2YWlsYWJsZS4gIFdoZW4gY2FsbGVkIGFmdGVyIHN0YXJ0dXAsIHRoaXMgaW1tZWRpYXRl bHkgY2FsbHMgdGhlCiAgKiByaWdodCBjYWxsYmFja3MgZGVwZW5kaW5nIG9uIHdoZXRoZXIgYW5v dGhlciBiYWNrZW5kIGhhZCBhbHJlYWR5CkBAIC03NDQsNyArNzM2LDcgQEAgUmVnaXN0ZXJTaG1l bUNhbGxiYWNrcyhjb25zdCBTaG1lbUNhbGxiYWNrcyAqY2FsbGJhY2tzKQogCQlMaXN0Q2VsbCAg ICpsYzsKIAkJYm9vbAkJZm91bmQgPSBmYWxzZTsKIAotCQlpZiAoKGNhbGxiYWNrcy0+ZmxhZ3Mg JiBTSE1FTV9BTExPV19BRlRFUl9TVEFSVFVQKSA9PSAwKQorCQlpZiAoKGNhbGxiYWNrcy0+Zmxh Z3MgJiBTSE1FTV9DQl9BTExPV19BRlRFUl9TVEFSVFVQKSA9PSAwKQogCQkJZWxvZyhFUlJPUiwg IkZJWE1FOiBub3QgYWxsb3dlZCBhZnRlciBzdGFydHVwIik7CiAKIAkJQXNzZXJ0KHJlcXVlc3Rl ZF9zaG1lbV9hcmVhcyA9PSBOSUwpOwpAQCAtNzU2LDEyICs3NDgsOCBAQCBSZWdpc3RlclNobWVt Q2FsbGJhY2tzKGNvbnN0IFNobWVtQ2FsbGJhY2tzICpjYWxsYmFja3MpCiAKIAkJTFdMb2NrQWNx dWlyZShTaG1lbUluZGV4TG9jaywgTFdfRVhDTFVTSVZFKTsKIAotCQlmb3JlYWNoKGxjLCByZXF1 ZXN0ZWRfc2htZW1fYXJlYXMpCi0JCXsKLQkJCVNobWVtU3RydWN0RGVzYyAqZGVzYyA9IChTaG1l bVN0cnVjdERlc2MgKikgbGZpcnN0KGxjKTsKLQorCQlmb3JlYWNoX3B0cihTaG1lbVN0cnVjdERl c2MsIGRlc2MsIHJlcXVlc3RlZF9zaG1lbV9hcmVhcykKIAkJCWZvdW5kID0gQXR0YWNoT3JJbml0 KGRlc2MsIHRydWUsIHRydWUpOwotCQl9CiAKIAkJLyoKIAkJICogRklYTUU6IFdoYXQgdG8gZG8g aWYgbXVsdGlwbGUgc2htZW0gYXJlYXMgd2VyZSByZXF1ZXN0ZWQsIGFuZCBzb21lCmRpZmYgLS1n aXQgYS9zcmMvaW5jbHVkZS9zdG9yYWdlL3NobWVtLmggYi9zcmMvaW5jbHVkZS9zdG9yYWdlL3No bWVtLmgKaW5kZXggNzIwOTQxZTIxOWUuLmE3OWQwYTUyNTI4IDEwMDY0NAotLS0gYS9zcmMvaW5j bHVkZS9zdG9yYWdlL3NobWVtLmgKKysrIGIvc3JjL2luY2x1ZGUvc3RvcmFnZS9zaG1lbS5oCkBA IC02MiwxMCArNjIsMTAgQEAgdHlwZWRlZiBzdHJ1Y3QgU2htZW1TdHJ1Y3REZXNjCiAJc2l6ZV90 CQlleHRyYV9zaXplOwogCiAJLyoKLQkgKiBXaGVuIHRoZSBzaG1lbSBhcmVhIGlzIGluaXRpYWxp emVkIG9yIGF0dGFjaGVkIHRvLCBwb2ludGVyIHRvIGl0IGlzCi0JICogc3RvcmVkIGluICpwdHIu ICBJdCB1c3VhbGx5IHBvaW50cyB0byBhIGdsb2JhbCB2YXJpYWJsZSwgdXNlZCB0byBhY2Nlc3MK LQkgKiB0aGUgc2hhcmVkIG1lbW9yeSBhcmVhIGxhdGVyLiAgKnB0ciBpcyBzZXQgYmVmb3JlIHRo ZSBpbml0X2ZuIG9yCi0JICogYXR0YWNoX2ZuIGNhbGxiYWNrIGlzIGNhbGxlZC4KKwkgKiBXaGVu IHRoZSBzaG1lbSBhcmVhIGlzIGluaXRpYWxpemVkIG9yIGF0dGFjaGVkIHRvLCBwb2ludGVyIHRv IGl0IGlzIHN0b3JlZAorCSAqIGluICpwdHIgd2hpY2ggaXMgZXhwZWN0ZWQgdG8gcG9pbnQgdG8g YSBnbG9iYWwgdmFyaWFibGUsIHVzZWQgdG8gYWNjZXNzCisJICogdGhlIHNoYXJlZCBtZW1vcnkg YXJlYSBsYXRlci4gICpwdHIgaXMgc2V0IGJlZm9yZSB0aGUgaW5pdF9mbiBvciBhdHRhY2hfZm4K KwkgKiBjYWxsYmFjayBpcyBjYWxsZWQuCiAJICovCiAJdm9pZAkgICoqcHRyOwogfSBTaG1lbVN0 cnVjdERlc2M7CkBAIC0xMjcsNiArMTI3LDIwIEBAIHR5cGVkZWYgdm9pZCAoKlNobWVtUmVxdWVz dENhbGxiYWNrKSAodm9pZCAqYXJnKTsKIHR5cGVkZWYgdm9pZCAoKlNobWVtSW5pdENhbGxiYWNr KSAodm9pZCAqYXJnKTsKIHR5cGVkZWYgdm9pZCAoKlNobWVtQXR0YWNoQ2FsbGJhY2spICh2b2lk ICphcmcpOwogCisKKy8qCisgKiBGbGFncyB0byBjb250cm9sIHRoZSBiZWhhdmlvciBvZiBSZWdp c3RlclNobWVtQ2FsbGJhY2tzKCkuCisgKgorICogU0hNRU1fQ0JfQUxMT1dfQUZURVJfU1RBUlRV UDogQWxsb3cgdGhlc2Ugc2hhcmVkIG1lbW9yeSB1c2FnZXMgdG8gYmUgcmVnaXN0ZXJlZAorICog YWZ0ZXIgcG9zdG1hc3RlciBzdGFydHVwLiBOb3JtYWxseSwgcmVnaXN0ZXJpbmcgYSBzaGFyZWQg bWVtb3J5IHN5c3RlbSBhZnRlcgorICogcG9zdG1hc3RlciBzdGFydHVwIGlzIG5vdCBhbGxvd2Vk IGUuZy4gaW4gYW4gYWRkLWluIGxpYnJhcnkgbG9hZGVkIG9uLWRlbWFpbmQKKyAqIGluIGEgYmFj a2VuZC4gIElmIGEgc3Vic3lzdGVtIHNldHMgdGhpcyBmbGFnLCB0aGUgY2FsbGJhY2tzIGFyZSBj YWxsZWQKKyAqIGltbWVkaWF0ZWx5IGFmdGVyIHJlZ2lzdHJhdGlvbiwgdG8gaW5pdGlhbGl6ZSBv ciBhdHRhY2ggdG8gdGhlIHJlcXVlc3RlZAorICogc2hhcmVkIG1lbW9yeSBhcmVhcy4gVGhpcyBp cyBub3QgdXNlZCBieSBhbnkgYnVpbHQtaW4gc3Vic3lzdGVtcywgYnV0CisgKiBleHRlbnNpb25z IGNhbiBmaW5kIGl0IHVzZWZ1bC4KKyAqLworI2RlZmluZSBTSE1FTV9DQl9BTExPV19BRlRFUl9T VEFSVFVQCQkweDAwMDAwMDAxCisKIC8qCiAgKiBTaGFyZWQgbWVtb3J5IGlzIHJlc2VydmVkIGFu ZCBhbGxvY2F0ZWQgaW4gc3RhZ2VzIGF0IHBvc3RtYXN0ZXIgc3RhcnR1cCwKICAqIGFuZCBpbiBF WEVDX0JBQ0tFTkQgbW9kZSwgdGhlcmUncyBzb21lIGV4dHJhIHdvcmsgZG9uZSB0byAiYXR0YWNo IiB0byB0aGVtCkBAIC0xMzUsNyArMTQ5LDcgQEAgdHlwZWRlZiB2b2lkICgqU2htZW1BdHRhY2hD YWxsYmFjaykgKHZvaWQgKmFyZyk7CiAgKi8KIHR5cGVkZWYgc3RydWN0IFNobWVtQ2FsbGJhY2tz CiB7Ci0JLyogU0hNRU1fKiBmbGFncyAqLworCS8qIFNITUVNX0NCXyogZmxhZ3MgKi8KIAlpbnQJ CQlmbGFnczsKIAogCS8qCkBAIC0xNjQsMTggKzE3OCw2IEBAIHR5cGVkZWYgc3RydWN0IFNobWVt Q2FsbGJhY2tzCiAJdm9pZAkgICAqYXR0YWNoX2ZuX2FyZzsKIH0gU2htZW1DYWxsYmFja3M7CiAK LS8qCi0gKiBBbGxvdyB0aGVzZSBzaGFyZWQgbWVtb3J5IGFsbG9jYXRpb25zIGFmdGVyIHBvc3Rt YXN0ZXIgc3RhcnR1cC4gIE5vcm1hbGx5LAotICogUmVnaXN0ZXJTaG1lbUNhbGxiYWNrcygpIGVy cm9ycyBvdXQgaWYgaXQncyBjYWxsZWQgYWZ0ZXIgcG9zdG1hc3RlciBzdGFydHVwCi0gKiBlLmcu IGluIGFuIGFkZC1pbiBsaWJyYXJ5IGxvYWRlZCBvbi1kZW1haW5kIGluIGEgYmFja2VuZC4gIElm IHlvdSBzZXQgdGhpcwotICogZmxhZywgUmVnaXN0ZXJTaG1lbUNhbGxiYWNrcygpIHdpbGwgaW5z dGVhZCBpbW1lZGlhdGVseSBjYWxsIHRoZSBjYWxsYmFja3MsCi0gKiB0byBpbml0aWFsaXplIG9y IGF0dGFjaCB0byB0aGUgcmVxdWVzdGVkIHNoYXJlZCBtZW1vcnkgYXJlYXMuCi0gKgotICogVGhp cyBpcyBub3QgdXNlZCBieSBhbnkgYnVpbHQtaW4gc3Vic3lzdGVtcywgYnV0IGV4dGVuc2lvbnMg Y2FuIGZpbmQgaXQKLSAqIHVzZWZ1bC4KLSAqLwotI2RlZmluZSBTSE1FTV9BTExPV19BRlRFUl9T VEFSVFVQCQkweDAwMDAwMDAxCi0KIC8qIHNobWVtLmMgKi8KIGV4dGVybiBQR0RMTElNUE9SVCBz bG9ja190ICpTaG1lbUxvY2s7CiB0eXBlZGVmIHN0cnVjdCBQR1NobWVtSGVhZGVyIFBHU2htZW1I ZWFkZXI7IC8qIGF2b2lkIGluY2x1ZGluZwo= --0000000000003f69c2064dfc14d7--