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 1w2wu1-000kvE-2W for pgsql-hackers@arkaria.postgresql.org; Wed, 18 Mar 2026 19:50:02 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.96) (envelope-from ) id 1w2wtz-00Du3T-1T for pgsql-hackers@arkaria.postgresql.org; Wed, 18 Mar 2026 19:49:59 +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 1w2wtz-00Du3I-0B for pgsql-hackers@lists.postgresql.org; Wed, 18 Mar 2026 19:49:59 +0000 Received: from mail-lj1-x234.google.com ([2a00:1450:4864:20::234]) by magus.postgresql.org with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (Exim 4.98.2) (envelope-from ) id 1w2wtw-00000000zgV-0QIl for pgsql-hackers@lists.postgresql.org; Wed, 18 Mar 2026 19:49:58 +0000 Received: by mail-lj1-x234.google.com with SMTP id 38308e7fff4ca-38ad12fb595so10986351fa.0 for ; Wed, 18 Mar 2026 12:49:55 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1773863395; cv=none; d=google.com; s=arc-20240605; b=AX5antKYpXWiuBwEIi54ZgjaUPJOJvmqyLSd0pajJmKp26Ja6h1qgeMhAwZXIyQeJ7 aLZqJaJutMK1LDZdhP3Ej585UbfJ99iA3MeMa8+24V95WdOJO5W7ZRAQbv0lqf8pfCgw 91Wz8G7ducTP3ntU4mS8f455ncL/mMtV/HfjmLnoeZiJpSNgRhTpe9mO65H/3MloTIBx I7aXcfWfwMpe6SjRbtO4qC0Zsst07Dov0fLDt8tGTrYE3lUTvyEmSDritrWmK7YmB/Vu gcezZCQAkIDtvtOLAGqyTHtSfpd6k0znvAmp6ExlEwNWRM4g3ypjiHdHfFNbIl4/qLhb w9rg== 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=JaamQTVWawaCNcvS343a3404e4cMCnVB71DLazM+ndc=; fh=jNW2JDe45J2oFc4wDiLJCFIF1KtnElvIQEM2zthyfzU=; b=ivTr/lW+CdY/txrVK6T4dLbQDPe49jqUIxho2RZXVEXpmMR21bD2I4k2rRiwghfPHE G4KVLHMyumzG0GmhkuKR+k3k/TQBScrmH01+5u5IXQdHASPM8TE7/i1mwjPxErUaeX7b BmbAi9hN4AT+qSOeGu2TktHw8NRhg5pUGiPWaSxVBa25zLWUYGSDjiEogol+a8d3OrMy vmlKK3T4Sb891fcLR0twoGwis+FQM/aHgLGt5MFxDlZOo9aiYhuCqVckdOWhosJaMru3 QaccTMUyE5Skw+tC2hKv+2eJk8DUwC+n0B6mjRYv/xzZOtesCrcoB1wTEAJZwDfaYEsc GN6g==; darn=lists.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=1773863395; x=1774468195; darn=lists.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=JaamQTVWawaCNcvS343a3404e4cMCnVB71DLazM+ndc=; b=WLCE7F4UU/K3v1Nwl762HC7ZdeN6FtEKOKflWZyeG+BsEFyNW5O4kAwRX1AKPVmCn7 zg5LaQHGU72Qy4WxInRd7xddR3dCLHVl+hBlNo1QpQlLNej6g//m6cOs/vYH2/YInPua tKwG2YjVz85SGE7i0NQJsk2I9JynlF3XW9tbQ5CWphsRiHC/QTrH/7ZPMSVpPnsx4Iwy e9/o1mC3eSnxGcskUE7/WNkhSzp9zKtMdBcbtmkOJp6dXvItRkWpBOqTI1QKIlTbbuSK FLYfjG+0WwoL1XoWj7EmPKYoma6RAVzOl+ZCsu00npXOpDI2XEkdBWokHHegNGSUParE FfaQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1773863395; x=1774468195; 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=JaamQTVWawaCNcvS343a3404e4cMCnVB71DLazM+ndc=; b=AH3CBaWKt9D+qoHz6EL4yfxGNJZBOypJbW/SPn3Wyz0STOGbdXLxf3O3CGqzMuUGx+ QoddbFO6TlemGz7Zcd92uuJhCNkhehI82XQMj8i2KIi58zdQrFZHco7cq5DDeLytlDs1 AUab5hzRgqarfMCAACna9k2BnmDdfPvJUlVOaTDDglfxFZuniW40/TSdjF9f+bfjP+y1 csagv0l2bvzPNO9Mo24mcgiDKzXbromBd6Q6HK5QRksnK+ZglDm9QnWf4YZxupO6rHCo 7dZXmlZRGbUhLHIep6yaEsTRMJY2sMEh5bd6zGddy3sqdhQ1mDwD0gl8OGrV2oUDPjeU xTiA== X-Forwarded-Encrypted: i=1; AJvYcCVazbqvP7d125oVNEP6l4ah+ISE5n/+P4csRVc53H+qby82jhWurYEuontD0ycsMkglHK1I2ui8GrF+1IYZ@lists.postgresql.org X-Gm-Message-State: AOJu0YzRTw00VFBPCnWqekgnT7H0D1WvEKf3LpvpBXc3iN+JsRp4VtnW rmEWMRf0swwwJTz/nyQ7u9TilGjTKqq95rXiw/tQL0JnI1mywK+UeD2kW6WEpmSMzM5/y+hPRbX KiUPsas4/4ZNycTTjjA9M9XFNeetxUyY= X-Gm-Gg: ATEYQzxu6ThE533cZmSHciyajKyx6/aKBDBw9s48oDmEcHvDOLA3JntGOfskI1iYFZX hQnIlSMmsEAyHOdGsyZRVW79mK7+Vei7zLx9qCTUeHeXgnFpdkIV/ZKebXlFu3GGILIuKexgMIM nwE5kLVFn5oO5ZT2LsmB2U3nOcx5FVYC05Wge2lJfqx/JGvmnn50krjrqS/ki/Jl4dS860IGerO HhytheoOrw5X6+ucooSh/0Vz63hELTdXMmCgkIzlB32ydYs20W8UipY9RQHYfJ7z1+Ex74aICi6 ueTKwFKt X-Received: by 2002:a05:6512:a96:b0:5a1:17a6:7268 with SMTP id 2adb3069b0e04-5a27ddf9cf5mr299146e87.11.1773863394708; Wed, 18 Mar 2026 12:49:54 -0700 (PDT) MIME-Version: 1.0 References: In-Reply-To: From: Masahiko Sawada Date: Wed, 18 Mar 2026 12:49:17 -0700 X-Gm-Features: AaiRm52FQUzZvctdP4i4ZScdq7gbLiheVQqvuUS6I-4CEebK3fAdjQaS77cRiFQ Message-ID: Subject: Re: POC: Parallel processing of indexes in autovacuum To: Daniil Davydov <3danissimo@gmail.com> Cc: Sami Imseih , Alexander Korotkov , Matheus Alcantara , Maxim Orlov , Postgres hackers Content-Type: multipart/mixed; boundary="00000000000085a5d2064d51c1e4" List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Archived-At: Precedence: bulk --00000000000085a5d2064d51c1e4 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable On Wed, Mar 18, 2026 at 2:23=E2=80=AFAM Daniil Davydov <3danissimo@gmail.co= m> wrote: > > Hi, > > On Tue, Mar 17, 2026 at 11:51=E2=80=AFPM Masahiko Sawada wrote: > > > > I find the current behavior of the autovacuum_parallel_workers storage > > parameter somewhat unintuitive for users. The documentation currently > > states: > > > > + > > + Sets the maximum number of parallel autovacuum workers that can = process > > + indexes of this table. > > + The default value is -1, which means no parallel index vacuuming= for > > + this table. If value is 0 then parallel degree will computed bas= ed on > > + number of indexes. > > + Note that the computed number of workers may not actually be ava= ilable at > > + run time. If this occurs, the autovacuum will run with fewer wor= kers > > + than expected. > > + > > > > It is quite confusing that setting the value to 0 does not actually > > disable the parallel vacuum. In many other PostgreSQL parameters, 0 > > typically means "off" or "no workers." I think that this parameter > > should behave as follows: > > > > -1: Use the value of autovacuum_max_parallel_workers (GUC) as the > > limit (fallback). > > >=3D0: Use the specified value as the limit, capped by autovacuum_max_p= arallel_workers. (Specifically, setting this to 0 would disable parallel va= cuum for the table). > > > > Actually we have several places in the code where "-1" means disabled and= "0" > means choosing a parallel degree based on the number of indexes. Since th= is > is an inner logic, I agree that we should make our parameter more intuiti= ve > to the user. But this will make the code a bit confusing. Yes, we already have such a code for PARALLEL option for the VACUUM command= : /* * Disable parallel vacuum, if user has specified parallel degree * as zero. */ if (nworkers =3D=3D 0) params.nworkers =3D -1; else params.nworkers =3D nworkers; I guess it's better that autovacuum codes also somewhat follow this code for better consistency. > > > Currently, the patch implements parallel autovacuum as an "opt-in" > > style. That is, even after setting the GUC to >0, users must manually > > set the storage parameter for each table. This assumes that users > > already know exactly which tables need parallel vacuum. > > > > However, I believe it would be more intuitive to let the system decide > > which tables are eligible for parallel vacuum based on index size and > > count (via min_parallel_index_scan_size, etc.), rather than forcing > > manual per-table configuration. Therefore, I'm thinking we might want > > to make it "opt-out" style by default instead: > > > > - Set the default value of the storage parameter to -1 (i.e., fallback = to GUC). > > - the default value of the GUC autovacuum_max_parallel_workers at 0. > > > > With this configuration: > > > > - Parallel autovacuum is disabled by default. > > - Users can enable it globally by simply setting the GUC to >0. > > - Users can still disable it for specific tables by setting the > > storage parameter to 0. > > > > What do you think? > > I'm afraid that I can't agree with you here. As I wrote above [1], the > parallel a/v feature will be useful when a user has a few huge tables wit= h > a big amount of indexes. Only these tables require parallel processing an= d a > user knows about it. Isn't it a case where users need to increase min_parallel_index_scan_size? Suppose that there are two tables that are big enough and have enough indexes, it's more natural to me to use parallel vacuum for both tables without user manual settings. > If we implement the feature as you suggested, then after setting the > av_max_parallel_workers to N > 0, the user will have to manually disable > processing for all tables except the largest ones. This will need to be d= one > to ensure that parallel workers are launched specifically to process the > largest tables and not wasting on the processing of little ones. > > I.e. I'm proposing a design that will require manual actions to *enable* > parallel a/v for several large tables rather than *disable* it for all of > the rest tables in the cluster. I'm sure that's what users want. > > Allowing the system to decide which tables to process in parallel is a go= od > way from a design perspective. But I'm thinking of the following example = : > Imagine that we have a threshold, when exceeded, parallel a/v is used. > Several a/v workers encounter tables which exceed this threshold by 1_000= and > each of these workers decides to launch a few parallel workers. Another a= /v > worker encounters a table which is beyond this threshold by 1_000_000 and > tries to launch N parallel workers, but facing the max_parallel_workers > shortage. Thus, processing of this table will take a very long time to > complete due to lack of resources. The only way for users to avoid it is = to > disable parallel a/v for all tables, which exceeds the threshold and are = not > of particular interest. I think the same thing happens even with the current design as long as users misconfigure max_parallel_workers, no? Setting autovacuum_max_parallel_workers to >0 would mean that users want to give additional resources for autovacuums in general, I think it makes sense to use parallel vacuum even for tables which exceed the threshold by 1000. Users who want to use parallel autovacuum would have to set max_parallel_workers (and max_worker_processes) high enough so that each autovacuum worker can use parallel workers. If resource contention occurs, it's a sign that the limits are not configured properly. > > > > +{ name =3D> 'autovacuum_max_parallel_workers', type =3D> 'int', contex= t > > =3D> 'PGC_SIGHUP', group =3D> 'VACUUM_AUTOVACUUM', > > + short_desc =3D> 'Maximum number of parallel workers that a single > > autovacuum worker can take from bgworkers pool.', > > + variable =3D> 'autovacuum_max_parallel_workers', > > + boot_val =3D> '2', > > + min =3D> '0', > > + max =3D> 'MAX_BACKENDS', > > +}, > > > > How about rephrasing the short description to "Maximum number of > > parallel processes per autovacuum operation."? > > I'm not sure if this phrase will be understandable to the user. > I don't see any places where we would define the "autovacuum operation" > concept, so I suppose it could be ambiguous. What about "Maximum number o= f > parallel processes per autovacuuming of one table"? "autovacuuming of one table" sounds unnatural to me. How about "Maximum number of parallel workers that can be used by a single autovacuum worker."? > > > We check only the server logs throughout the new tap tests. I think we > > should also confirm that the autovacuum successfully completes. I've > > attached the proposed change to the tap tests. > > > > I agree with proposed changes. BTW, don't we need to reduce the strings > length to 80 characters in the tests? In some tests, this rule is followe= d, > and in some it is not. Yeah, pgperltidy should be run for new tests. > Thank you very much for the review and proposed patches! > Please, see an updated set of patches. Note that the "logging for autovac= uum" > is considered as the first patch now. Thank you for updating the patches! The 0001 patch looks good to me. I've updated the commit message and attached it. I'm going to push the patch, barring any objections. While we need more discussion on the above points (opt-in vs. opt-out), I think that the rest of the patches are getting close. Regarding the documentation changes, I find that the current patch needs more explanation at appropriate sections. I think we need to: 1. describe the new autovacuum_max_parallel_workers GUC parameter (in config.sgml) 2. describe the new autovacuum_parallel_workers storage parameter (in create_table.sgml) 3. mention that autovacuum could use parallel vacuum (in maintenance.sgml). I think that part 1 should include the basic explanation of the GUC parameter as well as how the number of workers is decided (which could be similar to the description for PARALLEL options of the VACUUM command). Part 2 can explain the storage parameter as follow: Per-table value for parameter. If -1 is specified, autovacuum_max_parallel_workers value will be used. The default value is 0. Part 3 can briefly mention that autovacuum can perform parallel vacuum with parallel workers capped by autovacuum_max_parallel_workers as follow: For tables with the storage parameter set, an autovacuum worker can perform index vacuuming a= nd index cleanup with background workers. The number of workers launched by a single autovacuum worker is limited by the . What do you think? Regards, --=20 Masahiko Sawada Amazon Web Services: https://aws.amazon.com --00000000000085a5d2064d51c1e4 Content-Type: text/x-patch; charset="US-ASCII"; name="v30-0001-Add-parallel-vacuum-worker-usage-to-VACUUM-VERBO.patch" Content-Disposition: attachment; filename="v30-0001-Add-parallel-vacuum-worker-usage-to-VACUUM-VERBO.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_mmwfp57s0 RnJvbSAzMTU5MmFhNjk4NzI2YjBlYzNhNzJkNWMyYmFjNTlmNWVmOWYyODA2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBEYW5paWwgRGF2aWRvdiA8ZC5kYXZ5ZG92QHBvc3RncmVzcHJv LnJ1PgpEYXRlOiBNb24sIDE2IE1hciAyMDI2IDE5OjAxOjA1ICswNzAwClN1YmplY3Q6IFtQQVRD SCB2MzBdIEFkZCBwYXJhbGxlbCB2YWN1dW0gd29ya2VyIHVzYWdlIHRvIFZBQ1VVTSAoVkVSQk9T RSkgYW5kCiBhdXRvdmFjdXVtIGxvZ3MuCgpUaGlzIGNvbW1pdCBhZGRzIGJvdGggdGhlIG51bWJl ciBvZiBwYXJhbGxlbCB3b3JrZXJzIHBsYW5uZWQgYW5kIHRoZQpudW1iZXIgb2YgcGFyYWxsZWwg d29ya2VycyBhY3R1YWxseSBsYXVuY2hlZCB0byB0aGUgb3V0cHV0IG9mClZBQ1VVTSAoVkVSQk9T RSkgYW5kIGF1dG92YWN1dW0gbG9ncy4KClByZXZpb3VzbHksIHRoaXMgaW5mb3JtYXRpb24gd2Fz IG9ubHkgcmVwb3J0ZWQgYXMgYW4gSU5GTyBtZXNzYWdlCmR1cmluZyBWQUNVVU0gKFZFUkJPU0Up LCB3aGljaCBtZWFudCBpdCB3YXMgbm90IGluY2x1ZGVkIGluIGF1dG92YWN1dW0KbG9ncyBpbiBw cmFjdGljZS4gQWx0aG91Z2ggYXV0b3ZhY3V1bSBkb2VzIG5vdCB5ZXQgc3VwcG9ydCBwYXJhbGxl bAp2YWN1dW0sIGEgc3Vic2VxdWVudCBwYXRjaCB3aWxsIGVuYWJsZSBpdCBhbmQgdXRpbGl6ZSB0 aGVzZSBsb2dzIGluCml0cyByZWdyZXNzaW9uIHRlc3RzLiBUaGlzIGNoYW5nZSBhbHNvIGltcHJv dmVzIG9ic2VydmFiaWxpdHkgYnkKbWFraW5nIGl0IGVhc2llciB0byB2ZXJpZnkgaWYgcGFyYWxs ZWwgdmFjdXVtIGlzIHV0aWxpemluZyB0aGUKZXhwZWN0ZWQgbnVtYmVyIG9mIHdvcmtlcnMuCgpB dXRob3I6IERhbmlpbCBEYXZ5ZG92IDwzZGFuaXNzaW1vQGdtYWlsLmNvbT4KUmV2aWV3ZWQtYnk6 IE1hc2FoaWtvIFNhd2FkYSA8c2F3YWRhLm1zaGtAZ21haWwuY29tPgpSZXZpZXdlZC1ieTogU2Ft aSBJbXNlaWggPHNhbWltc2VpaEBnbWFpbC5jb20+CkRpc2N1c3Npb246IGh0dHBzOi8vcG9zdGdy LmVzL20vQ0FDRz1lelpPck5zdUxvRVRMRDFnQXN3Wk11SDJuR0dxN09nY2MwUU9FNWhoV2F3PWN3 QG1haWwuZ21haWwuY29tCi0tLQogc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5j ICB8IDMxICsrKysrKysrKysrKysrKysrKysrKysrKystLQogc3JjL2JhY2tlbmQvY29tbWFuZHMv dmFjdXVtcGFyYWxsZWwuYyB8IDIzICsrKysrKysrKysrKysrLS0tLS0tCiBzcmMvaW5jbHVkZS9j b21tYW5kcy92YWN1dW0uaCAgICAgICAgIHwgMjggKysrKysrKysrKysrKysrKysrKysrKy0tCiBz cmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdCAgICAgIHwgIDIgKysKIDQgZmlsZXMgY2hh bmdlZCwgNzQgaW5zZXJ0aW9ucygrKSwgMTAgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvc3Jj L2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jIGIvc3JjL2JhY2tlbmQvYWNjZXNzL2hl YXAvdmFjdXVtbGF6eS5jCmluZGV4IDgyYzViMjhlMGFkLi5jNTc0MzI2NzBlNyAxMDA2NDQKLS0t IGEvc3JjL2JhY2tlbmQvYWNjZXNzL2hlYXAvdmFjdXVtbGF6eS5jCisrKyBiL3NyYy9iYWNrZW5k L2FjY2Vzcy9oZWFwL3ZhY3V1bWxhenkuYwpAQCAtMzQzLDYgKzM0MywxMyBAQCB0eXBlZGVmIHN0 cnVjdCBMVlJlbFN0YXRlCiAJaW50CQkJbnVtX2luZGV4X3NjYW5zOwogCWludAkJCW51bV9kZWFk X2l0ZW1zX3Jlc2V0czsKIAlTaXplCQl0b3RhbF9kZWFkX2l0ZW1zX2J5dGVzOworCisJLyoKKwkg KiBUb3RhbCBudW1iZXIgb2YgcGxhbm5lZCBhbmQgYWN0dWFsbHkgbGF1bmNoZWQgcGFyYWxsZWwg d29ya2VycyBmb3IKKwkgKiBpbmRleCB2YWN1dW1pbmcgYW5kIGluZGV4IGNsZWFudXAuCisJICov CisJUFZXb3JrZXJVc2FnZSB3b3JrZXJfdXNhZ2U7CisKIAkvKiBDb3VudGVycyB0aGF0IGZvbGxv dyBhcmUgb25seSBmb3Igc2Nhbm5lZF9wYWdlcyAqLwogCWludDY0CQl0dXBsZXNfZGVsZXRlZDsg LyogIyBkZWxldGVkIGZyb20gdGFibGUgKi8KIAlpbnQ2NAkJdHVwbGVzX2Zyb3plbjsJLyogIyBu ZXdseSBmcm96ZW4gKi8KQEAgLTc4MSw2ICs3ODgsMTEgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0 aW9uIHJlbCwgY29uc3QgVmFjdXVtUGFyYW1zIHBhcmFtcywKIAl2YWNyZWwtPm5ld19hbGxfdmlz aWJsZV9hbGxfZnJvemVuX3BhZ2VzID0gMDsKIAl2YWNyZWwtPm5ld19hbGxfZnJvemVuX3BhZ2Vz ID0gMDsKIAorCXZhY3JlbC0+d29ya2VyX3VzYWdlLnZhY3V1bS5ubGF1bmNoZWQgPSAwOworCXZh Y3JlbC0+d29ya2VyX3VzYWdlLnZhY3V1bS5ucGxhbm5lZCA9IDA7CisJdmFjcmVsLT53b3JrZXJf dXNhZ2UuY2xlYW51cC5ubGF1bmNoZWQgPSAwOworCXZhY3JlbC0+d29ya2VyX3VzYWdlLmNsZWFu dXAubnBsYW5uZWQgPSAwOworCiAJLyoKIAkgKiBHZXQgY3V0b2ZmcyB0aGF0IGRldGVybWluZSB3 aGljaCBkZWxldGVkIHR1cGxlcyBhcmUgY29uc2lkZXJlZCBERUFELAogCSAqIG5vdCBqdXN0IFJF Q0VOVExZX0RFQUQsIGFuZCB3aGljaCBYSURzL01YSURzIHRvIGZyZWV6ZS4gIFRoZW4gZGV0ZXJt aW5lCkBAIC0xMTIzLDYgKzExMzUsMTkgQEAgaGVhcF92YWN1dW1fcmVsKFJlbGF0aW9uIHJlbCwg Y29uc3QgVmFjdXVtUGFyYW1zIHBhcmFtcywKIAkJCQkJCQkgb3JpZ19yZWxfcGFnZXMgPT0gMCA/ IDEwMC4wIDoKIAkJCQkJCQkgMTAwLjAgKiB2YWNyZWwtPmxwZGVhZF9pdGVtX3BhZ2VzIC8gb3Jp Z19yZWxfcGFnZXMsCiAJCQkJCQkJIHZhY3JlbC0+bHBkZWFkX2l0ZW1zKTsKKworCQkJaWYgKHZh Y3JlbC0+d29ya2VyX3VzYWdlLnZhY3V1bS5ucGxhbm5lZCA+IDApCisJCQkJYXBwZW5kU3RyaW5n SW5mbygmYnVmLAorCQkJCQkJCQkgXygicGFyYWxsZWwgd29ya2VyczogaW5kZXggdmFjdXVtOiAl ZCBwbGFubmVkLCAlZCBsYXVuY2hlZCBpbiB0b3RhbFxuIiksCisJCQkJCQkJCSB2YWNyZWwtPndv cmtlcl91c2FnZS52YWN1dW0ubnBsYW5uZWQsCisJCQkJCQkJCSB2YWNyZWwtPndvcmtlcl91c2Fn ZS52YWN1dW0ubmxhdW5jaGVkKTsKKworCQkJaWYgKHZhY3JlbC0+d29ya2VyX3VzYWdlLmNsZWFu dXAubnBsYW5uZWQgPiAwKQorCQkJCWFwcGVuZFN0cmluZ0luZm8oJmJ1ZiwKKwkJCQkJCQkJIF8o InBhcmFsbGVsIHdvcmtlcnM6IGluZGV4IGNsZWFudXA6ICVkIHBsYW5uZWQsICVkIGxhdW5jaGVk XG4iKSwKKwkJCQkJCQkJIHZhY3JlbC0+d29ya2VyX3VzYWdlLmNsZWFudXAubnBsYW5uZWQsCisJ CQkJCQkJCSB2YWNyZWwtPndvcmtlcl91c2FnZS5jbGVhbnVwLm5sYXVuY2hlZCk7CisKIAkJCWZv ciAoaW50IGkgPSAwOyBpIDwgdmFjcmVsLT5uaW5kZXhlczsgaSsrKQogCQkJewogCQkJCUluZGV4 QnVsa0RlbGV0ZVJlc3VsdCAqaXN0YXQgPSB2YWNyZWwtPmluZHN0YXRzW2ldOwpAQCAtMjY2OSw3 ICsyNjk0LDggQEAgbGF6eV92YWN1dW1fYWxsX2luZGV4ZXMoTFZSZWxTdGF0ZSAqdmFjcmVsKQog CXsKIAkJLyogT3V0c291cmNlIGV2ZXJ5dGhpbmcgdG8gcGFyYWxsZWwgdmFyaWFudCAqLwogCQlw YXJhbGxlbF92YWN1dW1fYnVsa2RlbF9hbGxfaW5kZXhlcyh2YWNyZWwtPnB2cywgb2xkX2xpdmVf dHVwbGVzLAotCQkJCQkJCQkJCQl2YWNyZWwtPm51bV9pbmRleF9zY2Fucyk7CisJCQkJCQkJCQkJ CXZhY3JlbC0+bnVtX2luZGV4X3NjYW5zLAorCQkJCQkJCQkJCQkmKHZhY3JlbC0+d29ya2VyX3Vz YWdlLnZhY3V1bSkpOwogCiAJCS8qCiAJCSAqIERvIGEgcG9zdGNoZWNrIHRvIGNvbnNpZGVyIGFw cGx5aW5nIHdyYXBhcm91bmQgZmFpbHNhZmUgbm93LiAgTm90ZQpAQCAtMzEwMyw3ICszMTI5LDgg QEAgbGF6eV9jbGVhbnVwX2FsbF9pbmRleGVzKExWUmVsU3RhdGUgKnZhY3JlbCkKIAkJLyogT3V0 c291cmNlIGV2ZXJ5dGhpbmcgdG8gcGFyYWxsZWwgdmFyaWFudCAqLwogCQlwYXJhbGxlbF92YWN1 dW1fY2xlYW51cF9hbGxfaW5kZXhlcyh2YWNyZWwtPnB2cywgcmVsdHVwbGVzLAogCQkJCQkJCQkJ CQl2YWNyZWwtPm51bV9pbmRleF9zY2FucywKLQkJCQkJCQkJCQkJZXN0aW1hdGVkX2NvdW50KTsK KwkJCQkJCQkJCQkJZXN0aW1hdGVkX2NvdW50LAorCQkJCQkJCQkJCQkmKHZhY3JlbC0+d29ya2Vy X3VzYWdlLmNsZWFudXApKTsKIAl9CiAKIAkvKiBSZXNldCB0aGUgcHJvZ3Jlc3MgY291bnRlcnMg Ki8KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL2NvbW1hbmRzL3ZhY3V1bXBhcmFsbGVsLmMgYi9z cmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCmluZGV4IDI3OTEwOGNhODlmLi43 NzgzNGI5NmEyMSAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY29tbWFuZHMvdmFjdXVtcGFyYWxs ZWwuYworKysgYi9zcmMvYmFja2VuZC9jb21tYW5kcy92YWN1dW1wYXJhbGxlbC5jCkBAIC0yMjUs NyArMjI1LDcgQEAgc3RydWN0IFBhcmFsbGVsVmFjdXVtU3RhdGUKIHN0YXRpYyBpbnQJcGFyYWxs ZWxfdmFjdXVtX2NvbXB1dGVfd29ya2VycyhSZWxhdGlvbiAqaW5kcmVscywgaW50IG5pbmRleGVz LCBpbnQgbnJlcXVlc3RlZCwKIAkJCQkJCQkJCQkJYm9vbCAqd2lsbF9wYXJhbGxlbF92YWN1dW0p Owogc3RhdGljIHZvaWQgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxs ZWxWYWN1dW1TdGF0ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW5zLAotCQkJCQkJCQkJCQkJYm9v bCB2YWN1dW0pOworCQkJCQkJCQkJCQkJYm9vbCB2YWN1dW0sIFBWV29ya2VyU3RhdHMgKndzdGF0 cyk7CiBzdGF0aWMgdm9pZCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19zYWZlX2luZGV4ZXMoUGFy YWxsZWxWYWN1dW1TdGF0ZSAqcHZzKTsKIHN0YXRpYyB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9wcm9j ZXNzX3Vuc2FmZV9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cyk7CiBzdGF0aWMgdm9p ZCBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19vbmVfaW5kZXgoUGFyYWxsZWxWYWN1dW1TdGF0ZSAq cHZzLCBSZWxhdGlvbiBpbmRyZWwsCkBAIC00OTksNyArNDk5LDcgQEAgcGFyYWxsZWxfdmFjdXVt X3Jlc2V0X2RlYWRfaXRlbXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzKQogICovCiB2b2lkCiBw YXJhbGxlbF92YWN1dW1fYnVsa2RlbF9hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpw dnMsIGxvbmcgbnVtX3RhYmxlX3R1cGxlcywKLQkJCQkJCQkJCWludCBudW1faW5kZXhfc2NhbnMp CisJCQkJCQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zLCBQVldvcmtlclN0YXRzICp3c3RhdHMpCiB7 CiAJQXNzZXJ0KCFJc1BhcmFsbGVsV29ya2VyKCkpOwogCkBAIC01MTAsNyArNTEwLDcgQEAgcGFy YWxsZWxfdmFjdXVtX2J1bGtkZWxfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZz LCBsb25nIG51bV90YWJsZV90dXAKIAlwdnMtPnNoYXJlZC0+cmVsdHVwbGVzID0gbnVtX3RhYmxl X3R1cGxlczsKIAlwdnMtPnNoYXJlZC0+ZXN0aW1hdGVkX2NvdW50ID0gdHJ1ZTsKIAotCXBhcmFs bGVsX3ZhY3V1bV9wcm9jZXNzX2FsbF9pbmRleGVzKHB2cywgbnVtX2luZGV4X3NjYW5zLCB0cnVl KTsKKwlwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMsIG51bV9pbmRleF9z Y2FucywgdHJ1ZSwgd3N0YXRzKTsKIH0KIAogLyoKQEAgLTUxOCw3ICs1MTgsOCBAQCBwYXJhbGxl bF92YWN1dW1fYnVsa2RlbF9hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGxv bmcgbnVtX3RhYmxlX3R1cAogICovCiB2b2lkCiBwYXJhbGxlbF92YWN1dW1fY2xlYW51cF9hbGxf aW5kZXhlcyhQYXJhbGxlbFZhY3V1bVN0YXRlICpwdnMsIGxvbmcgbnVtX3RhYmxlX3R1cGxlcywK LQkJCQkJCQkJCWludCBudW1faW5kZXhfc2NhbnMsIGJvb2wgZXN0aW1hdGVkX2NvdW50KQorCQkJ CQkJCQkJaW50IG51bV9pbmRleF9zY2FucywgYm9vbCBlc3RpbWF0ZWRfY291bnQsCisJCQkJCQkJ CQlQVldvcmtlclN0YXRzICp3c3RhdHMpCiB7CiAJQXNzZXJ0KCFJc1BhcmFsbGVsV29ya2VyKCkp OwogCkBAIC01MzAsNyArNTMxLDcgQEAgcGFyYWxsZWxfdmFjdXVtX2NsZWFudXBfYWxsX2luZGV4 ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLCBsb25nIG51bV90YWJsZV90dXAKIAlwdnMtPnNo YXJlZC0+cmVsdHVwbGVzID0gbnVtX3RhYmxlX3R1cGxlczsKIAlwdnMtPnNoYXJlZC0+ZXN0aW1h dGVkX2NvdW50ID0gZXN0aW1hdGVkX2NvdW50OwogCi0JcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3Nf YWxsX2luZGV4ZXMocHZzLCBudW1faW5kZXhfc2NhbnMsIGZhbHNlKTsKKwlwYXJhbGxlbF92YWN1 dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhwdnMsIG51bV9pbmRleF9zY2FucywgZmFsc2UsIHdzdGF0 cyk7CiB9CiAKIC8qCkBAIC02MDcsMTAgKzYwOCwxMiBAQCBwYXJhbGxlbF92YWN1dW1fY29tcHV0 ZV93b3JrZXJzKFJlbGF0aW9uICppbmRyZWxzLCBpbnQgbmluZGV4ZXMsIGludCBucmVxdWVzdGVk LAogLyoKICAqIFBlcmZvcm0gaW5kZXggdmFjdXVtIG9yIGluZGV4IGNsZWFudXAgd2l0aCBwYXJh bGxlbCB3b3JrZXJzLiAgVGhpcyBmdW5jdGlvbgogICogbXVzdCBiZSB1c2VkIGJ5IHRoZSBwYXJh bGxlbCB2YWN1dW0gbGVhZGVyIHByb2Nlc3MuCisgKgorICogSWYgd3N0YXRzIGlzIG5vdCBOVUxM LCB0aGUgcGFyYWxsZWwgd29ya2VyIHN0YXRpc3RpY3MgYXJlIHVwZGF0ZWQuCiAgKi8KIHN0YXRp YyB2b2lkCiBwYXJhbGxlbF92YWN1dW1fcHJvY2Vzc19hbGxfaW5kZXhlcyhQYXJhbGxlbFZhY3V1 bVN0YXRlICpwdnMsIGludCBudW1faW5kZXhfc2NhbnMsCi0JCQkJCQkJCQlib29sIHZhY3V1bSkK KwkJCQkJCQkJCWJvb2wgdmFjdXVtLCBQVldvcmtlclN0YXRzICp3c3RhdHMpCiB7CiAJaW50CQkJ bndvcmtlcnM7CiAJUFZJbmRWYWNTdGF0dXMgbmV3X3N0YXR1czsKQEAgLTY0Nyw2ICs2NTAsMTAg QEAgcGFyYWxsZWxfdmFjdXVtX3Byb2Nlc3NfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0 ZSAqcHZzLCBpbnQgbnVtX2luZGV4X3NjYW4KIAkgKi8KIAlud29ya2VycyA9IE1pbihud29ya2Vy cywgcHZzLT5wY3h0LT5ud29ya2Vycyk7CiAKKwkvKiBVcGRhdGUgdGhlIHN0YXRpc3RpY3MsIGlm IHdlIGFza2VkIHRvICovCisJaWYgKHdzdGF0cyAhPSBOVUxMICYmIG53b3JrZXJzID4gMCkKKwkJ d3N0YXRzLT5ucGxhbm5lZCArPSBud29ya2VyczsKKwogCS8qCiAJICogU2V0IGluZGV4IHZhY3V1 bSBzdGF0dXMgYW5kIG1hcmsgd2hldGhlciBwYXJhbGxlbCB2YWN1dW0gd29ya2VyIGNhbgogCSAq IHByb2Nlc3MgaXQuCkBAIC03MDMsNiArNzEwLDEwIEBAIHBhcmFsbGVsX3ZhY3V1bV9wcm9jZXNz X2FsbF9pbmRleGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywgaW50IG51bV9pbmRleF9zY2Fu CiAJCQkvKiBFbmFibGUgc2hhcmVkIGNvc3QgYmFsYW5jZSBmb3IgbGVhZGVyIGJhY2tlbmQgKi8K IAkJCVZhY3V1bVNoYXJlZENvc3RCYWxhbmNlID0gJihwdnMtPnNoYXJlZC0+Y29zdF9iYWxhbmNl KTsKIAkJCVZhY3V1bUFjdGl2ZU5Xb3JrZXJzID0gJihwdnMtPnNoYXJlZC0+YWN0aXZlX253b3Jr ZXJzKTsKKworCQkJLyogVXBkYXRlIHRoZSBzdGF0aXN0aWNzLCBpZiB3ZSBhc2tlZCB0byAqLwor CQkJaWYgKHdzdGF0cyAhPSBOVUxMKQorCQkJCXdzdGF0cy0+bmxhdW5jaGVkICs9IHB2cy0+cGN4 dC0+bndvcmtlcnNfbGF1bmNoZWQ7CiAJCX0KIAogCQlpZiAodmFjdXVtKQpkaWZmIC0tZ2l0IGEv c3JjL2luY2x1ZGUvY29tbWFuZHMvdmFjdXVtLmggYi9zcmMvaW5jbHVkZS9jb21tYW5kcy92YWN1 dW0uaAppbmRleCBlODg1YTRiOWM3Ny4uOTUzYTUwNjE4MWUgMTAwNjQ0Ci0tLSBhL3NyYy9pbmNs dWRlL2NvbW1hbmRzL3ZhY3V1bS5oCisrKyBiL3NyYy9pbmNsdWRlL2NvbW1hbmRzL3ZhY3V1bS5o CkBAIC0zMDAsNiArMzAwLDI4IEBAIHR5cGVkZWYgc3RydWN0IFZhY0RlYWRJdGVtc0luZm8KIAlp bnQ2NAkJbnVtX2l0ZW1zOwkJLyogY3VycmVudCAjIG9mIGVudHJpZXMgKi8KIH0gVmFjRGVhZEl0 ZW1zSW5mbzsKIAorLyoKKyAqIFN0YXRpc3RpY3MgZm9yIHBhcmFsbGVsIHZhY3V1bSB3b3JrZXJz IChwbGFubmVkIHZzLiBhY3R1YWwpCisgKi8KK3R5cGVkZWYgc3RydWN0IFBWV29ya2VyU3RhdHMK K3sKKwkvKiBOdW1iZXIgb2YgcGFyYWxsZWwgd29ya2VycyBwbGFubmVkIHRvIGxhdW5jaCAqLwor CWludAkJCW5wbGFubmVkOworCisJLyogTnVtYmVyIG9mIHBhcmFsbGVsIHdvcmtlcnMgdGhhdCB3 ZXJlIHN1Y2Nlc3NmdWxseSBsYXVuY2hlZCAqLworCWludAkJCW5sYXVuY2hlZDsKK30gUFZXb3Jr ZXJTdGF0czsKKworLyoKKyAqIFBWV29ya2VyVXNhZ2Ugc3RvcmVzIGluZm9ybWF0aW9uIGFib3V0 IHRvdGFsIG51bWJlciBvZiBsYXVuY2hlZCBhbmQKKyAqIHBsYW5uZWQgd29ya2VycyBkdXJpbmcg cGFyYWxsZWwgdmFjdXVtIChib3RoIGZvciBpbmRleCB2YWN1dW0gYW5kIGNsZWFudXApLgorICov Cit0eXBlZGVmIHN0cnVjdCBQVldvcmtlclVzYWdlCit7CisJUFZXb3JrZXJTdGF0cyB2YWN1dW07 CisJUFZXb3JrZXJTdGF0cyBjbGVhbnVwOworfSBQVldvcmtlclVzYWdlOworCiAvKiBHVUMgcGFy YW1ldGVycyAqLwogZXh0ZXJuIFBHRExMSU1QT1JUIGludCBkZWZhdWx0X3N0YXRpc3RpY3NfdGFy Z2V0OwkvKiBQR0RMTElNUE9SVCBmb3IgUG9zdEdJUyAqLwogZXh0ZXJuIFBHRExMSU1QT1JUIGlu dCB2YWN1dW1fZnJlZXplX21pbl9hZ2U7CkBAIC0zOTQsMTEgKzQxNiwxMyBAQCBleHRlcm4gVGlk U3RvcmUgKnBhcmFsbGVsX3ZhY3V1bV9nZXRfZGVhZF9pdGVtcyhQYXJhbGxlbFZhY3V1bVN0YXRl ICpwdnMsCiBleHRlcm4gdm9pZCBwYXJhbGxlbF92YWN1dW1fcmVzZXRfZGVhZF9pdGVtcyhQYXJh bGxlbFZhY3V1bVN0YXRlICpwdnMpOwogZXh0ZXJuIHZvaWQgcGFyYWxsZWxfdmFjdXVtX2J1bGtk ZWxfYWxsX2luZGV4ZXMoUGFyYWxsZWxWYWN1dW1TdGF0ZSAqcHZzLAogCQkJCQkJCQkJCQkJbG9u ZyBudW1fdGFibGVfdHVwbGVzLAotCQkJCQkJCQkJCQkJaW50IG51bV9pbmRleF9zY2Fucyk7CisJ CQkJCQkJCQkJCQlpbnQgbnVtX2luZGV4X3NjYW5zLAorCQkJCQkJCQkJCQkJUFZXb3JrZXJTdGF0 cyAqd3N0YXRzKTsKIGV4dGVybiB2b2lkIHBhcmFsbGVsX3ZhY3V1bV9jbGVhbnVwX2FsbF9pbmRl eGVzKFBhcmFsbGVsVmFjdXVtU3RhdGUgKnB2cywKIAkJCQkJCQkJCQkJCWxvbmcgbnVtX3RhYmxl X3R1cGxlcywKIAkJCQkJCQkJCQkJCWludCBudW1faW5kZXhfc2NhbnMsCi0JCQkJCQkJCQkJCQli b29sIGVzdGltYXRlZF9jb3VudCk7CisJCQkJCQkJCQkJCQlib29sIGVzdGltYXRlZF9jb3VudCwK KwkJCQkJCQkJCQkJCVBWV29ya2VyU3RhdHMgKndzdGF0cyk7CiBleHRlcm4gdm9pZCBwYXJhbGxl bF92YWN1dW1fbWFpbihkc21fc2VnbWVudCAqc2VnLCBzaG1fdG9jICp0b2MpOwogCiAvKiBpbiBj b21tYW5kcy9hbmFseXplLmMgKi8KZGlmZiAtLWdpdCBhL3NyYy90b29scy9wZ2luZGVudC90eXBl ZGVmcy5saXN0IGIvc3JjL3Rvb2xzL3BnaW5kZW50L3R5cGVkZWZzLmxpc3QKaW5kZXggMTc0ZTI3 OTg0NDMuLmE4NDdkMzdiNTI2IDEwMDY0NAotLS0gYS9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRl ZnMubGlzdAorKysgYi9zcmMvdG9vbHMvcGdpbmRlbnQvdHlwZWRlZnMubGlzdApAQCAtMjA5MCw2 ICsyMDkwLDggQEAgUFZJbmRTdGF0cwogUFZJbmRWYWNTdGF0dXMKIFBWT0lECiBQVlNoYXJlZAor UFZXb3JrZXJVc2FnZQorUFZXb3JrZXJTdGF0cwogUFhfQWxpYXMKIFBYX0NpcGhlcgogUFhfQ29t Ym8KLS0gCjIuNTMuMAoK --00000000000085a5d2064d51c1e4--