Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1keZ2w-00065V-Ti for pgsql-hackers@arkaria.postgresql.org; Mon, 16 Nov 2020 07:35:31 +0000 Received: from localhost ([127.0.0.1] helo=malur.postgresql.org) by malur.postgresql.org with esmtp (Exim 4.92) (envelope-from ) id 1keZ2v-0002z8-NR for pgsql-hackers@arkaria.postgresql.org; Mon, 16 Nov 2020 07:35:29 +0000 Received: from makus.postgresql.org ([2001:4800:3e1:1::229]) by malur.postgresql.org with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1keZ2v-0002z1-7N for pgsql-hackers@lists.postgresql.org; Mon, 16 Nov 2020 07:35:29 +0000 Received: from oss.nttdata.com ([49.212.34.109]) by makus.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1keZ2r-0007yi-RN for pgsql-hackers@postgresql.org; Mon, 16 Nov 2020 07:35:28 +0000 Received: from oss.nttdata.com (localhost [127.0.0.1]) by oss.nttdata.com (Postfix) with ESMTP id 0996D623C6; Mon, 16 Nov 2020 16:35:23 +0900 (JST) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.102.3 at oss.nttdata.com MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="=_56561b64bce6027c1ac9a0c08856b10b" Date: Mon, 16 Nov 2020 16:35:23 +0900 From: Masahiro Ikeda To: Fujii Masao Cc: pgsql-hackers Subject: Re: Add statistics to pg_stat_wal view for wal related parameter tuning In-Reply-To: References: <35ef960128b90bfae3b3fdf60a3a860f@oss.nttdata.com> Message-ID: <11e81f0b7d90dd69077d3d964a9a4da9@oss.nttdata.com> X-Sender: ikedamsh@oss.nttdata.com User-Agent: Roundcube Webmail/1.1.9 List-Id: List-Help: List-Subscribe: List-Post: List-Owner: List-Archive: Precedence: bulk --=_56561b64bce6027c1ac9a0c08856b10b Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset=UTF-8; format=flowed On 2020-11-12 14:58, Fujii Masao wrote: > On 2020/11/06 10:25, Masahiro Ikeda wrote: >> On 2020-10-30 11:50, Fujii Masao wrote: >>> On 2020/10/29 17:03, Masahiro Ikeda wrote: >>>> Hi, >>>> >>>> Thanks for your comments and advice. I updated the patch. >>>> >>>> On 2020-10-21 18:03, Kyotaro Horiguchi wrote: >>>>> At Tue, 20 Oct 2020 16:11:29 +0900, Masahiro Ikeda >>>>> wrote in >>>>>> On 2020-10-20 12:46, Amit Kapila wrote: >>>>>> > I see that we also need to add extra code to capture these stats (some >>>>>> > of which is in performance-critical path especially in >>>>>> > XLogInsertRecord) which again makes me a bit uncomfortable. It might >>>>>> > be that it is all fine as it is very important to collect these stats >>>>>> > at cluster-level in spite that the same information can be gathered at >>>>>> > statement-level to help customers but I don't see a very strong case >>>>>> > for that in your proposal. >>>>> >>>>> We should avoid that duplication as possible even if the both >>>>> number >>>>> are important. >>>>> >>>>>> Also about performance, I thought there are few impacts because it >>>>>> increments stats in memory. If I can implement to reuse >>>>>> pgWalUsage's >>>>>> value which already collects these stats, there is no impact in >>>>>> XLogInsertRecord. >>>>>> For example, how about pg_stat_wal() calculates the accumulated >>>>>> value of wal_records, wal_fpi, and wal_bytes to use pgWalUsage's >>>>>> value? >>>>> >>>>> I don't think that works, but it would work that pgstat_send_wal() >>>>> takes the difference of that values between two successive calls. >>>>> >>>>> WalUsage prevWalUsage; >>>>> ... >>>>> pgstat_send_wal() >>>>> { >>>>> .. >>>>>    /* fill in some values using pgWalUsage */ >>>>>    WalStats.m_wal_bytes   = pgWalUsage.wal_bytes   - >>>>> prevWalUsage.wal_bytes; >>>>>    WalStats.m_wal_records = pgWalUsage.wal_records - >>>>> prevWalUsage.wal_records; >>>>>    WalStats.m_wal_wal_fpi = pgWalUsage.wal_fpi     - >>>>> prevWalUsage.wal_fpi; >>>>> ... >>>>>    pgstat_send(&WalStats, sizeof(WalStats)); >>>>> >>>>>    /* remember the current numbers */ >>>>>    prevWalUsage = pgWalUsage; >>>> >>>> Thanks for Horiguchi-san's advice, I changed to reuse pgWalUsage >>>> which is already defined and eliminates the extra overhead. >>> >>> +    /* fill in some values using pgWalUsage */ >>> +    WalStats.m_wal_bytes = pgWalUsage.wal_bytes - >>> prevWalUsage.wal_bytes; >>> +    WalStats.m_wal_records = pgWalUsage.wal_records - >>> prevWalUsage.wal_records; >>> +    WalStats.m_wal_fpi = pgWalUsage.wal_fpi - prevWalUsage.wal_fpi; >>> >>> It's better to use WalUsageAccumDiff() here? >> >> Yes, thanks. I fixed it. >> >>> prevWalUsage needs to be initialized with pgWalUsage? >>> >>> +                if (AmWalWriterProcess()){ >>> +                    WalStats.m_wal_write_walwriter++; >>> +                } >>> +                else >>> +                { >>> +                    WalStats.m_wal_write_backend++; >>> +                } >>> >>> I think that it's better not to separate m_wal_write_xxx into two for >>> walwriter and other processes. Instead, we can use one >>> m_wal_write_xxx >>> counter and make pgstat_send_wal() send also the process type to >>> the stats collector. Then the stats collector can accumulate the >>> counters >>> per process type if necessary. If we adopt this approach, we can >>> easily >>> extend pg_stat_wal so that any fields can be reported per process >>> type. >> >> I'll remove the above source code because these counters are not >> useful. >> >> >> On 2020-10-30 12:00, Fujii Masao wrote: >>> On 2020/10/20 11:31, Masahiro Ikeda wrote: >>>> Hi, >>>> >>>> I think we need to add some statistics to pg_stat_wal view. >>>> >>>> Although there are some parameter related WAL, >>>> there are few statistics for tuning them. >>>> >>>> I think it's better to provide the following statistics. >>>> Please let me know your comments. >>>> >>>> ``` >>>> postgres=# SELECT * from pg_stat_wal; >>>> -[ RECORD 1 ]-------+------------------------------ >>>> wal_records         | 2000224 >>>> wal_fpi             | 47 >>>> wal_bytes           | 248216337 >>>> wal_buffers_full    | 20954 >>>> wal_init_file       | 8 >>>> wal_write_backend   | 20960 >>>> wal_write_walwriter | 46 >>>> wal_write_time      | 51 >>>> wal_sync_backend    | 7 >>>> wal_sync_walwriter  | 8 >>>> wal_sync_time       | 0 >>>> stats_reset         | 2020-10-20 11:04:51.307771+09 >>>> ``` >>>> >>>> 1. Basic statistics of WAL activity >>>> >>>> - wal_records: Total number of WAL records generated >>>> - wal_fpi: Total number of WAL full page images generated >>>> - wal_bytes: Total amount of WAL bytes generated >>>> >>>> To understand DB's performance, first, we will check the performance >>>> trends for the entire database instance. >>>> For example, if the number of wal_fpi becomes higher, users may tune >>>> "wal_compression", "checkpoint_timeout" and so on. >>>> >>>> Although users can check the above statistics via EXPLAIN, >>>> auto_explain, >>>> autovacuum and pg_stat_statements now, >>>> if users want to see the performance trends  for the entire >>>> database, >>>> they must recalculate the statistics. >>>> >>>> I think it is useful to add the sum of the basic statistics. >>>> >>>> >>>> 2.  WAL segment file creation >>>> >>>> - wal_init_file: Total number of WAL segment files created. >>>> >>>> To create a new WAL file may have an impact on the performance of >>>> a write-heavy workload generating lots of WAL. If this number is >>>> reported high, >>>> to reduce the number of this initialization, we can tune WAL-related >>>> parameters >>>> so that more "recycled" WAL files can be held. >>>> >>>> >>>> >>>> 3. Number of when WAL is flushed >>>> >>>> - wal_write_backend : Total number of WAL data written to the disk >>>> by backends >>>> - wal_write_walwriter : Total number of WAL data written to the disk >>>> by walwriter >>>> - wal_sync_backend : Total number of WAL data synced to the disk by >>>> backends >>>> - wal_sync_walwriter : Total number of WAL data synced to the disk >>>> by walwrite >>>> >>>> I think it's useful for tuning "synchronous_commit" and >>>> "commit_delay" for query executions. >>>> If the number of WAL is flushed is high, users can know >>>> "synchronous_commit" is useful for the workload. >>> >>> I just wonder how useful these counters are. Even without these >>> counters, >>> we already know synchronous_commit=off is likely to cause the better >>> performance (but has the risk of data loss). So ISTM that these >>> counters are >>> not so useful when tuning synchronous_commit. >> >> Thanks, my understanding was wrong. >> I agreed that your comments. >> >> I merged the statistics of *_backend and *_walwriter. >> I think the sum of them is useful to calculate the average per >> write/sync time. >> For example, per write time is equals wal_write_time / wal_write. > > Understood. > > Thanks for updating the patch! Thanks for your comments. > patching file src/include/catalog/pg_proc.dat > Hunk #1 FAILED at 5491. > 1 out of 1 hunk FAILED -- saving rejects to file > src/include/catalog/pg_proc.dat.rej > > I got this failure when applying the patch. Could you update the patch? Thanks, I updated the patch. > - Number of times WAL data was written to the disk because WAL > buffers got full > + Total number of times WAL data written to the disk because WAL > buffers got full > > Isn't "was" necessary between "data" and "written"? Yes, I fixed it. > + role="column_definition"> > + wal_bytes bigint > > Shouldn't the type of wal_bytes be numeric because the total number of > WAL bytes can exceed the range of bigint? I think that the type of > pg_stat_statements.wal_bytes is also numeric for the same reason. Thanks, I fixed it. Since I cast the type of wal_bytes from PgStat_Counter to uint64, I changed the type of PgStat_MsgWal and PgStat_WalStats too. > + role="column_definition"> > + wal_write_time bigint > > Shouldn't the type of wal_xxx_time be double precision, > like pg_stat_database.blk_write_time? Thanks, I changed it. > Even when fsync is set to off or wal_sync_method is set to open_sync, > wal_sync is incremented. Isn't this behavior confusing? > > > + Total amount of time that has been spent in the portion of > + WAL data was written to disk by backend and walwriter, in > milliseconds > + (if is enabled, otherwise > zero) > > With the patch, track_io_timing controls both IO for data files and > WAL files. But we may want to track only either of them. So it's better > to extend track_io_timing so that we can specify the tracking target > in the parameter? For example, we can make track_io_timing accept > data, wal and all. Or we should introduce new GUC for WAL, e.g., > track_wal_io_timing? Thought? OK, I introduced the new GUC "track_wal_io_timing". > I'm afraid that "by backend and walwriter" part can make us thinkg > incorrectly that WAL writes by other processes like autovacuum > are not tracked. Sorry, I removed "by backend and walwriter". Regards, -- Masahiro Ikeda NTT DATA CORPORATION --=_56561b64bce6027c1ac9a0c08856b10b Content-Transfer-Encoding: base64 Content-Type: text/x-diff; name=0004_add_statistics_to_pg_stat_wal_view.patch Content-Disposition: attachment; filename=0004_add_statistics_to_pg_stat_wal_view.patch; size=18811 ZGlmZiAtLWdpdCBhL2RvYy9zcmMvc2dtbC9jb25maWcuc2dtbCBiL2RvYy9zcmMvc2dtbC9jb25m aWcuc2dtbAppbmRleCBmMDQzNDMzZS4uMTcxZDVkNTkgMTAwNjQ0Ci0tLSBhL2RvYy9zcmMvc2dt bC9jb25maWcuc2dtbAorKysgYi9kb2Mvc3JjL3NnbWwvY29uZmlnLnNnbWwKQEAgLTczNjUsNiAr NzM2NSwyNyBAQCBDT1BZIHBvc3RncmVzX2xvZyBGUk9NICcvZnVsbC9wYXRoL3RvL2xvZ2ZpbGUu Y3N2JyBXSVRIIGNzdjsKICAgICAgIDwvbGlzdGl0ZW0+CiAgICAgIDwvdmFybGlzdGVudHJ5Pgog CisgICAgIDx2YXJsaXN0ZW50cnkgaWQ9Imd1Yy10cmFjay13YWwtaW8tdGltaW5nIiB4cmVmbGFi ZWw9InRyYWNrX3dhbF9pb190aW1pbmciPgorICAgICAgPHRlcm0+PHZhcm5hbWU+dHJhY2tfd2Fs X2lvX3RpbWluZzwvdmFybmFtZT4gKDx0eXBlPmJvb2xlYW48L3R5cGU+KQorICAgICAgPGluZGV4 dGVybT4KKyAgICAgICA8cHJpbWFyeT48dmFybmFtZT50cmFja193YWxfaW9fdGltaW5nPC92YXJu YW1lPiBjb25maWd1cmF0aW9uIHBhcmFtZXRlcjwvcHJpbWFyeT4KKyAgICAgIDwvaW5kZXh0ZXJt PgorICAgICAgPC90ZXJtPgorICAgICAgPGxpc3RpdGVtPgorICAgICAgIDxwYXJhPgorICAgICAg ICBFbmFibGVzIHRpbWluZyBvZiBXQUwgSS9PIGNhbGxzLiBUaGlzIHBhcmFtZXRlciBpcyBvZmYg YnkgZGVmYXVsdCwKKyAgICAgICAgYmVjYXVzZSBpdCB3aWxsIHJlcGVhdGVkbHkgcXVlcnkgdGhl IG9wZXJhdGluZyBzeXN0ZW0gZm9yCisgICAgICAgIHRoZSBjdXJyZW50IHRpbWUsIHdoaWNoIG1h eSBjYXVzZSBzaWduaWZpY2FudCBvdmVyaGVhZCBvbiBzb21lCisgICAgICAgIHBsYXRmb3Jtcy4g IFlvdSBjYW4gdXNlIHRoZSA8eHJlZiBsaW5rZW5kPSJwZ3Rlc3R0aW1pbmciLz4gdG9vbCB0bwor ICAgICAgICBtZWFzdXJlIHRoZSBvdmVyaGVhZCBvZiB0aW1pbmcgb24geW91ciBzeXN0ZW0uCisg ICAgICAgIEkvTyB0aW1pbmcgaW5mb3JtYXRpb24gaXMKKyAgICAgICAgZGlzcGxheWVkIGluIDxs aW5rIGxpbmtlbmQ9Im1vbml0b3JpbmctcGctc3RhdC13YWwtdmlldyI+CisgICAgICAgIDxzdHJ1 Y3RuYW1lPnBnX3N0YXRfd2FsPC9zdHJ1Y3RuYW1lPjwvbGluaz4uICBPbmx5IHN1cGVydXNlcnMg Y2FuCisgICAgICAgIGNoYW5nZSB0aGlzIHNldHRpbmcuCisgICAgICAgPC9wYXJhPgorICAgICAg PC9saXN0aXRlbT4KKyAgICAgPC92YXJsaXN0ZW50cnk+CisKICAgICAgPHZhcmxpc3RlbnRyeSBp ZD0iZ3VjLXRyYWNrLWZ1bmN0aW9ucyIgeHJlZmxhYmVsPSJ0cmFja19mdW5jdGlvbnMiPgogICAg ICAgPHRlcm0+PHZhcm5hbWU+dHJhY2tfZnVuY3Rpb25zPC92YXJuYW1lPiAoPHR5cGU+ZW51bTwv dHlwZT4pCiAgICAgICA8aW5kZXh0ZXJtPgpkaWZmIC0tZ2l0IGEvZG9jL3NyYy9zZ21sL21vbml0 b3Jpbmcuc2dtbCBiL2RvYy9zcmMvc2dtbC9tb25pdG9yaW5nLnNnbWwKaW5kZXggOThlMTk5NTQu LjZkNWQ1OGU2IDEwMDY0NAotLS0gYS9kb2Mvc3JjL3NnbWwvbW9uaXRvcmluZy5zZ21sCisrKyBi L2RvYy9zcmMvc2dtbC9tb25pdG9yaW5nLnNnbWwKQEAgLTM0NDcsMTIgKzM0NDcsODggQEAgU0VM RUNUIHBpZCwgd2FpdF9ldmVudF90eXBlLCB3YWl0X2V2ZW50IEZST00gcGdfc3RhdF9hY3Rpdml0 eSBXSEVSRSB3YWl0X2V2ZW50IGkKICAgICA8L3RoZWFkPgogCiAgICAgPHRib2R5PgorICAgICA8 cm93PgorICAgICAgPGVudHJ5IHJvbGU9ImNhdGFsb2dfdGFibGVfZW50cnkiPjxwYXJhIHJvbGU9 ImNvbHVtbl9kZWZpbml0aW9uIj4KKyAgICAgICA8c3RydWN0ZmllbGQ+d2FsX3JlY29yZHM8L3N0 cnVjdGZpZWxkPiA8dHlwZT5iaWdpbnQ8L3R5cGU+CisgICAgICA8L3BhcmE+CisgICAgICA8cGFy YT4KKyAgICAgICBUb3RhbCBudW1iZXIgb2YgV0FMIHJlY29yZHMgZ2VuZXJhdGVkCisgICAgICA8 L3BhcmE+PC9lbnRyeT4KKyAgICAgPC9yb3c+CisKKyAgICAgPHJvdz4KKyAgICAgIDxlbnRyeSBy b2xlPSJjYXRhbG9nX3RhYmxlX2VudHJ5Ij48cGFyYSByb2xlPSJjb2x1bW5fZGVmaW5pdGlvbiI+ CisgICAgICAgPHN0cnVjdGZpZWxkPndhbF9mcGk8L3N0cnVjdGZpZWxkPiA8dHlwZT5iaWdpbnQ8 L3R5cGU+CisgICAgICA8L3BhcmE+CisgICAgICA8cGFyYT4KKyAgICAgICBUb3RhbCBudW1iZXIg b2YgV0FMIGZ1bGwgcGFnZSBpbWFnZXMgZ2VuZXJhdGVkCisgICAgICA8L3BhcmE+PC9lbnRyeT4K KyAgICAgPC9yb3c+CisKKyAgICAgPHJvdz4KKyAgICAgIDxlbnRyeSByb2xlPSJjYXRhbG9nX3Rh YmxlX2VudHJ5Ij48cGFyYSByb2xlPSJjb2x1bW5fZGVmaW5pdGlvbiI+CisgICAgICAgPHN0cnVj dGZpZWxkPndhbF9ieXRlczwvc3RydWN0ZmllbGQ+IDx0eXBlPm51bWVyaWM8L3R5cGU+CisgICAg ICA8L3BhcmE+CisgICAgICA8cGFyYT4KKyAgICAgICBUb3RhbCBhbW91bnQgb2YgV0FMIGJ5dGVz IGdlbmVyYXRlZAorICAgICAgPC9wYXJhPjwvZW50cnk+CisgICAgIDwvcm93PgorCiAgICAgIDxy b3c+CiAgICAgICA8ZW50cnkgcm9sZT0iY2F0YWxvZ190YWJsZV9lbnRyeSI+PHBhcmEgcm9sZT0i Y29sdW1uX2RlZmluaXRpb24iPgogICAgICAgIDxzdHJ1Y3RmaWVsZD53YWxfYnVmZmVyc19mdWxs PC9zdHJ1Y3RmaWVsZD4gPHR5cGU+YmlnaW50PC90eXBlPgogICAgICAgPC9wYXJhPgogICAgICAg PHBhcmE+Ci0gICAgICAgTnVtYmVyIG9mIHRpbWVzIFdBTCBkYXRhIHdhcyB3cml0dGVuIHRvIHRo ZSBkaXNrIGJlY2F1c2UgV0FMIGJ1ZmZlcnMgZ290IGZ1bGwKKyAgICAgICBUb3RhbCBudW1iZXIg b2YgdGltZXMgV0FMIGRhdGEgd2FzIHdyaXR0ZW4gdG8gdGhlIGRpc2sgYmVjYXVzZSBXQUwgYnVm ZmVycyBnb3QgZnVsbAorICAgICAgPC9wYXJhPjwvZW50cnk+CisgICAgIDwvcm93PgorCisgICAg IDxyb3c+CisgICAgICA8ZW50cnkgcm9sZT0iY2F0YWxvZ190YWJsZV9lbnRyeSI+PHBhcmEgcm9s ZT0iY29sdW1uX2RlZmluaXRpb24iPgorICAgICAgIDxzdHJ1Y3RmaWVsZD53YWxfaW5pdF9maWxl PC9zdHJ1Y3RmaWVsZD4gPHR5cGU+YmlnaW50PC90eXBlPgorICAgICAgPC9wYXJhPgorICAgICAg PHBhcmE+CisgICAgICAgVG90YWwgbnVtYmVyIG9mIHRpbWVzIFdBTCBmaWxlIHNlZ21lbnQgd2Fz IGNyZWF0ZWQKKyAgICAgIDwvcGFyYT48L2VudHJ5PgorICAgICA8L3Jvdz4KKworICAgICA8cm93 PgorICAgICAgPGVudHJ5IHJvbGU9ImNhdGFsb2dfdGFibGVfZW50cnkiPjxwYXJhIHJvbGU9ImNv bHVtbl9kZWZpbml0aW9uIj4KKyAgICAgICA8c3RydWN0ZmllbGQ+d2FsX3dyaXRlPC9zdHJ1Y3Rm aWVsZD4gPHR5cGU+YmlnaW50PC90eXBlPgorICAgICAgPC9wYXJhPgorICAgICAgPHBhcmE+Cisg ICAgICAgVG90YWwgbnVtYmVyIG9mIHRpbWVzIFdBTCBkYXRhIHdhcyB3cml0dGVuIHRvIHRoZSBk aXNrCisgICAgICA8L3BhcmE+PC9lbnRyeT4KKyAgICAgPC9yb3c+CisKKyAgICAgPHJvdz4KKyAg ICAgIDxlbnRyeSByb2xlPSJjYXRhbG9nX3RhYmxlX2VudHJ5Ij48cGFyYSByb2xlPSJjb2x1bW5f ZGVmaW5pdGlvbiI+CisgICAgICAgPHN0cnVjdGZpZWxkPndhbF93cml0ZV90aW1lPC9zdHJ1Y3Rm aWVsZD4gPHR5cGU+ZG91YmxlIHByZWNpc2lvbjwvdHlwZT4KKyAgICAgIDwvcGFyYT4KKyAgICAg IDxwYXJhPgorICAgICAgIFRvdGFsIGFtb3VudCBvZiB0aW1lIHRoYXQgaGFzIGJlZW4gc3BlbnQg aW4gdGhlIHBvcnRpb24gb2YKKyAgICAgICBXQUwgZGF0YSB3YXMgd3JpdHRlbiB0byBkaXNrLCBp biBtaWxsaXNlY29uZHMKKyAgICAgICAoaWYgPHhyZWYgbGlua2VuZD0iZ3VjLXRyYWNrLXdhbC1p by10aW1pbmciLz4gaXMgZW5hYmxlZCwgb3RoZXJ3aXNlIHplcm8pCisgICAgICA8L3BhcmE+PC9l bnRyeT4KKyAgICAgPC9yb3c+CisKKyAgICAgPHJvdz4KKyAgICAgIDxlbnRyeSByb2xlPSJjYXRh bG9nX3RhYmxlX2VudHJ5Ij48cGFyYSByb2xlPSJjb2x1bW5fZGVmaW5pdGlvbiI+CisgICAgICAg PHN0cnVjdGZpZWxkPndhbF9zeW5jPC9zdHJ1Y3RmaWVsZD4gPHR5cGU+YmlnaW50PC90eXBlPgor ICAgICAgPC9wYXJhPgorICAgICAgPHBhcmE+CisgICAgICAgVG90YWwgbnVtYmVyIG9mIHRpbWVz IFdBTCBkYXRhIHdhcyBzeW5jZWQgdG8gdGhlIGRpc2sKKyAgICAgIDwvcGFyYT48L2VudHJ5Pgor ICAgICA8L3Jvdz4KKworICAgICA8cm93PgorICAgICAgPGVudHJ5IHJvbGU9ImNhdGFsb2dfdGFi bGVfZW50cnkiPjxwYXJhIHJvbGU9ImNvbHVtbl9kZWZpbml0aW9uIj4KKyAgICAgICA8c3RydWN0 ZmllbGQ+d2FsX3N5bmNfdGltZTwvc3RydWN0ZmllbGQ+IDx0eXBlPmRvdWJsZSBwcmVjaXNpb248 L3R5cGU+CisgICAgICA8L3BhcmE+CisgICAgICA8cGFyYT4KKyAgICAgICBUb3RhbCBhbW91bnQg b2YgdGltZSB0aGF0IGhhcyBiZWVuIHNwZW50IGluIHRoZSBwb3J0aW9uIG9mCisgICAgICAgV0FM IGRhdGEgd2FzIHN5bmNlZCB0byBkaXNrLCBpbiBtaWxsaXNlY29uZHMKKyAgICAgICAoaWYgPHhy ZWYgbGlua2VuZD0iZ3VjLXRyYWNrLXdhbC1pby10aW1pbmciLz4gaXMgZW5hYmxlZCwgb3RoZXJ3 aXNlIHplcm8pCiAgICAgICA8L3BhcmE+PC9lbnRyeT4KICAgICAgPC9yb3c+CiAKZGlmZiAtLWdp dCBhL3NyYy9iYWNrZW5kL2FjY2Vzcy90cmFuc2FtL3hsb2cuYyBiL3NyYy9iYWNrZW5kL2FjY2Vz cy90cmFuc2FtL3hsb2cuYwppbmRleCBhYTYzZjM3Ni4uMzA0NDJmYjEgMTAwNjQ0Ci0tLSBhL3Ny Yy9iYWNrZW5kL2FjY2Vzcy90cmFuc2FtL3hsb2cuYworKysgYi9zcmMvYmFja2VuZC9hY2Nlc3Mv dHJhbnNhbS94bG9nLmMKQEAgLTEwOSw2ICsxMDksNyBAQCBpbnQJCQlDb21taXREZWxheSA9IDA7 CS8qIHByZWNvbW1pdCBkZWxheSBpbiBtaWNyb3NlY29uZHMgKi8KIGludAkJCUNvbW1pdFNpYmxp bmdzID0gNTsgLyogIyBjb25jdXJyZW50IHhhY3RzIG5lZWRlZCB0byBzbGVlcCAqLwogaW50CQkJ d2FsX3JldHJpZXZlX3JldHJ5X2ludGVydmFsID0gNTAwMDsKIGludAkJCW1heF9zbG90X3dhbF9r ZWVwX3NpemVfbWIgPSAtMTsKK2Jvb2wJCXRyYWNrX3dhbF9pb190aW1pbmcgPSBmYWxzZTsKIAog I2lmZGVmIFdBTF9ERUJVRwogYm9vbAkJWExPR19ERUJVRyA9IGZhbHNlOwpAQCAtMjUyNyw2ICsy NTI4LDggQEAgWExvZ1dyaXRlKFhMb2d3cnRScXN0IFdyaXRlUnFzdCwgYm9vbCBmbGV4aWJsZSkK IAkJCVNpemUJCW5ieXRlczsKIAkJCVNpemUJCW5sZWZ0OwogCQkJaW50CQkJd3JpdHRlbjsKKwkJ CWluc3RyX3RpbWUJc3RhcnQ7CisJCQlpbnN0cl90aW1lCWR1cmF0aW9uOwogCiAJCQkvKiBPSyB0 byB3cml0ZSB0aGUgcGFnZShzKSAqLwogCQkJZnJvbSA9IFhMb2dDdGwtPnBhZ2VzICsgc3RhcnRp ZHggKiAoU2l6ZSkgWExPR19CTENLU1o7CkBAIC0yNTM1LDkgKzI1MzgsMjIgQEAgWExvZ1dyaXRl KFhMb2d3cnRScXN0IFdyaXRlUnFzdCwgYm9vbCBmbGV4aWJsZSkKIAkJCWRvCiAJCQl7CiAJCQkJ ZXJybm8gPSAwOworCQkJCWlmICh0cmFja193YWxfaW9fdGltaW5nKQorCQkJCQlJTlNUUl9USU1F X1NFVF9DVVJSRU5UKHN0YXJ0KTsKKwogCQkJCXBnc3RhdF9yZXBvcnRfd2FpdF9zdGFydChXQUlU X0VWRU5UX1dBTF9XUklURSk7CiAJCQkJd3JpdHRlbiA9IHBnX3B3cml0ZShvcGVuTG9nRmlsZSwg ZnJvbSwgbmxlZnQsIHN0YXJ0b2Zmc2V0KTsKIAkJCQlwZ3N0YXRfcmVwb3J0X3dhaXRfZW5kKCk7 CisKKwkJCQlpZiAodHJhY2tfd2FsX2lvX3RpbWluZykKKwkJCQl7CisJCQkJCUlOU1RSX1RJTUVf U0VUX0NVUlJFTlQoZHVyYXRpb24pOworCQkJCQlJTlNUUl9USU1FX1NVQlRSQUNUKGR1cmF0aW9u LCBzdGFydCk7CisJCQkJCVdhbFN0YXRzLm1fd2FsX3dyaXRlX3RpbWUgKz0gSU5TVFJfVElNRV9H RVRfTUlMTElTRUMoZHVyYXRpb24pOworCQkJCX0KKworCQkJCVdhbFN0YXRzLm1fd2FsX3dyaXRl Kys7CisKIAkJCQlpZiAod3JpdHRlbiA8PSAwKQogCQkJCXsKIAkJCQkJY2hhcgkJeGxvZ2ZuYW1l W01BWEZOQU1FTEVOXTsKQEAgLTM0MTgsNiArMzQzNCw3IEBAIFhMb2dGaWxlSW5pdChYTG9nU2Vn Tm8gbG9nc2Vnbm8sIGJvb2wgKnVzZV9leGlzdGVudCwgYm9vbCB1c2VfbG9jaykKIAkJCQkgZXJy bXNnKCJjb3VsZCBub3Qgb3BlbiBmaWxlIFwiJXNcIjogJW0iLCBwYXRoKSkpOwogCiAJZWxvZyhE RUJVRzIsICJkb25lIGNyZWF0aW5nIGFuZCBmaWxsaW5nIG5ldyBXQUwgZmlsZSIpOworCVdhbFN0 YXRzLm1fd2FsX2luaXRfZmlsZSsrOwogCiAJcmV0dXJuIGZkOwogfQpAQCAtMTA0MDYsOCArMTA0 MjMsMTMgQEAgYXNzaWduX3hsb2dfc3luY19tZXRob2QoaW50IG5ld19zeW5jX21ldGhvZCwgdm9p ZCAqZXh0cmEpCiB2b2lkCiBpc3N1ZV94bG9nX2ZzeW5jKGludCBmZCwgWExvZ1NlZ05vIHNlZ25v KQogeworCWluc3RyX3RpbWUJc3RhcnQ7CisJaW5zdHJfdGltZQlkdXJhdGlvbjsKIAljaGFyCSAg ICptc2cgPSBOVUxMOwogCisJaWYgKHRyYWNrX3dhbF9pb190aW1pbmcpCisJCUlOU1RSX1RJTUVf U0VUX0NVUlJFTlQoc3RhcnQpOworCiAJcGdzdGF0X3JlcG9ydF93YWl0X3N0YXJ0KFdBSVRfRVZF TlRfV0FMX1NZTkMpOwogCXN3aXRjaCAoc3luY19tZXRob2QpCiAJewpAQCAtMTA0NTEsNiArMTA0 NzMsMTUgQEAgaXNzdWVfeGxvZ19mc3luYyhpbnQgZmQsIFhMb2dTZWdObyBzZWdubykKIAl9CiAK IAlwZ3N0YXRfcmVwb3J0X3dhaXRfZW5kKCk7CisKKwlpZiAodHJhY2tfd2FsX2lvX3RpbWluZykK Kwl7CisJCUlOU1RSX1RJTUVfU0VUX0NVUlJFTlQoZHVyYXRpb24pOworCQlJTlNUUl9USU1FX1NV QlRSQUNUKGR1cmF0aW9uLCBzdGFydCk7CisJCVdhbFN0YXRzLm1fd2FsX3N5bmNfdGltZSArPSBJ TlNUUl9USU1FX0dFVF9NSUxMSVNFQyhkdXJhdGlvbik7CisJfQorCisJV2FsU3RhdHMubV93YWxf c3luYysrOwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvc3JjL2JhY2tlbmQvY2F0YWxvZy9zeXN0ZW1f dmlld3Muc3FsIGIvc3JjL2JhY2tlbmQvY2F0YWxvZy9zeXN0ZW1fdmlld3Muc3FsCmluZGV4IDJl NGFhMWM0Li44OTdiYjU5YiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvY2F0YWxvZy9zeXN0ZW1f dmlld3Muc3FsCisrKyBiL3NyYy9iYWNrZW5kL2NhdGFsb2cvc3lzdGVtX3ZpZXdzLnNxbApAQCAt OTkzLDcgKzk5MywxNSBAQCBDUkVBVEUgVklFVyBwZ19zdGF0X2Jnd3JpdGVyIEFTCiAKIENSRUFU RSBWSUVXIHBnX3N0YXRfd2FsIEFTCiAgICAgU0VMRUNUCisgICAgICAgIHcud2FsX3JlY29yZHMs CisgICAgICAgIHcud2FsX2ZwaSwKKyAgICAgICAgdy53YWxfYnl0ZXMsCiAgICAgICAgIHcud2Fs X2J1ZmZlcnNfZnVsbCwKKyAgICAgICAgdy53YWxfaW5pdF9maWxlLAorICAgICAgICB3LndhbF93 cml0ZSwKKyAgICAgICAgdy53YWxfd3JpdGVfdGltZSwKKyAgICAgICAgdy53YWxfc3luYywKKyAg ICAgICAgdy53YWxfc3luY190aW1lLAogICAgICAgICB3LnN0YXRzX3Jlc2V0CiAgICAgRlJPTSBw Z19zdGF0X2dldF93YWwoKSB3OwogCmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC9wb3N0bWFzdGVy L3Bnc3RhdC5jIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9wZ3N0YXQuYwppbmRleCBlNzZlNjI3 Yy4uNTg3MDRlYTUgMTAwNjQ0Ci0tLSBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvcGdzdGF0LmMK KysrIGIvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci9wZ3N0YXQuYwpAQCAtNDEsNiArNDEsNyBAQAog I2luY2x1ZGUgImNhdGFsb2cvcGdfZGF0YWJhc2UuaCIKICNpbmNsdWRlICJjYXRhbG9nL3BnX3By b2MuaCIKICNpbmNsdWRlICJjb21tb24vaXAuaCIKKyNpbmNsdWRlICJleGVjdXRvci9pbnN0cnVt ZW50LmgiCiAjaW5jbHVkZSAibGlicHEvbGlicHEuaCIKICNpbmNsdWRlICJsaWJwcS9wcXNpZ25h bC5oIgogI2luY2x1ZGUgIm1iL3BnX3djaGFyLmgiCkBAIC0xNDIsNiArMTQzLDcgQEAgY2hhcgkg ICAqcGdzdGF0X3N0YXRfdG1wbmFtZSA9IE5VTEw7CiAgKi8KIFBnU3RhdF9Nc2dCZ1dyaXRlciBC Z1dyaXRlclN0YXRzOwogUGdTdGF0X01zZ1dhbCBXYWxTdGF0czsKK1dhbFVzYWdlIHByZXZXYWxV c2FnZTsKIAogLyoKICAqIExpc3Qgb2YgU0xSVSBuYW1lcyB0aGF0IHdlIGtlZXAgc3RhdHMgZm9y LiAgVGhlcmUgaXMgbm8gY2VudHJhbCByZWdpc3RyeSBvZgpAQCAtMzA0OCw2ICszMDUwLDkgQEAg cGdzdGF0X2luaXRpYWxpemUodm9pZCkKIAkJTXlCRUVudHJ5ID0gJkJhY2tlbmRTdGF0dXNBcnJh eVtNYXhCYWNrZW5kcyArIE15QXV4UHJvY1R5cGVdOwogCX0KIAorCS8qIEluaXRpYWxpemUgV0FM IHVzYWdlIHN0YXR1cyBpbmZvcm1hdGlvbiAqLworCXByZXZXYWxVc2FnZSA9IHBnV2FsVXNhZ2U7 CisKIAkvKiBTZXQgdXAgYSBwcm9jZXNzLWV4aXQgaG9vayB0byBjbGVhbiB1cCAqLwogCW9uX3No bWVtX2V4aXQocGdzdGF0X2Jlc2h1dGRvd25faG9vaywgMCk7CiB9CkBAIC00NTc0LDYgKzQ1Nzks MTUgQEAgcGdzdGF0X3NlbmRfYmd3cml0ZXIodm9pZCkKIHZvaWQKIHBnc3RhdF9zZW5kX3dhbCh2 b2lkKQogeworCS8qIGZpbGwgaW4gc29tZSB2YWx1ZXMgdXNpbmcgcGdXYWxVc2FnZSAqLworCVdh bFVzYWdlIHdhbHVzYWdlOworCW1lbXNldCgmd2FsdXNhZ2UsIDAsIHNpemVvZihXYWxVc2FnZSkp OworCVdhbFVzYWdlQWNjdW1EaWZmKCZ3YWx1c2FnZSwgJnBnV2FsVXNhZ2UsICZwcmV2V2FsVXNh Z2UpOworCisJV2FsU3RhdHMubV93YWxfYnl0ZXMgPSB3YWx1c2FnZS53YWxfYnl0ZXM7CisJV2Fs U3RhdHMubV93YWxfcmVjb3JkcyA9IHdhbHVzYWdlLndhbF9yZWNvcmRzOworCVdhbFN0YXRzLm1f d2FsX2ZwaSA9IHdhbHVzYWdlLndhbF9mcGk7CisKIAkvKiBXZSBhc3N1bWUgdGhpcyBpbml0aWFs aXplcyB0byB6ZXJvZXMgKi8KIAlzdGF0aWMgY29uc3QgUGdTdGF0X01zZ1dhbCBhbGxfemVyb2Vz OwogCkBAIC00NTkxLDYgKzQ2MDUsOSBAQCBwZ3N0YXRfc2VuZF93YWwodm9pZCkKIAlwZ3N0YXRf c2V0aGVhZGVyKCZXYWxTdGF0cy5tX2hkciwgUEdTVEFUX01UWVBFX1dBTCk7CiAJcGdzdGF0X3Nl bmQoJldhbFN0YXRzLCBzaXplb2YoV2FsU3RhdHMpKTsKIAorCS8qIHJlbWVtYmVyIHRoZSBjdXJy ZW50IG51bWJlcnMgKi8KKwlwcmV2V2FsVXNhZ2UgPSBwZ1dhbFVzYWdlOworCiAJLyoKIAkgKiBD bGVhciBvdXQgdGhlIHN0YXRpc3RpY3MgYnVmZmVyLCBzbyBpdCBjYW4gYmUgcmUtdXNlZC4KIAkg Ki8KQEAgLTY3NTksNyArNjc3NiwxNSBAQCBwZ3N0YXRfcmVjdl9iZ3dyaXRlcihQZ1N0YXRfTXNn QmdXcml0ZXIgKm1zZywgaW50IGxlbikKIHN0YXRpYyB2b2lkCiBwZ3N0YXRfcmVjdl93YWwoUGdT dGF0X01zZ1dhbCAqbXNnLCBpbnQgbGVuKQogeworCXdhbFN0YXRzLndhbF9yZWNvcmRzICs9IG1z Zy0+bV93YWxfcmVjb3JkczsKKwl3YWxTdGF0cy53YWxfZnBpICs9IG1zZy0+bV93YWxfZnBpOwor CXdhbFN0YXRzLndhbF9ieXRlcyArPSBtc2ctPm1fd2FsX2J5dGVzOwogCXdhbFN0YXRzLndhbF9i dWZmZXJzX2Z1bGwgKz0gbXNnLT5tX3dhbF9idWZmZXJzX2Z1bGw7CisJd2FsU3RhdHMud2FsX2lu aXRfZmlsZSArPSBtc2ctPm1fd2FsX2luaXRfZmlsZTsKKwl3YWxTdGF0cy53YWxfd3JpdGUgKz0g bXNnLT5tX3dhbF93cml0ZTsKKwl3YWxTdGF0cy53YWxfd3JpdGVfdGltZSArPSBtc2ctPm1fd2Fs X3dyaXRlX3RpbWU7CisJd2FsU3RhdHMud2FsX3N5bmMgKz0gbXNnLT5tX3dhbF9zeW5jOworCXdh bFN0YXRzLndhbF9zeW5jX3RpbWUgKz0gbXNnLT5tX3dhbF9zeW5jX3RpbWU7CiB9CiAKIC8qIC0t LS0tLS0tLS0KZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3Bvc3RtYXN0ZXIvd2Fsd3JpdGVyLmMg Yi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL3dhbHdyaXRlci5jCmluZGV4IGE1MjgzMmZlLi5jZTlm NGI3YyAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvcG9zdG1hc3Rlci93YWx3cml0ZXIuYworKysg Yi9zcmMvYmFja2VuZC9wb3N0bWFzdGVyL3dhbHdyaXRlci5jCkBAIC0yNTMsNiArMjUzLDkgQEAg V2FsV3JpdGVyTWFpbih2b2lkKQogCQllbHNlIGlmIChsZWZ0X3RpbGxfaGliZXJuYXRlID4gMCkK IAkJCWxlZnRfdGlsbF9oaWJlcm5hdGUtLTsKIAorCQkvKiBTZW5kIFdBTCBzdGF0aXN0aWNzICov CisJCXBnc3RhdF9zZW5kX3dhbCgpOworCiAJCS8qCiAJCSAqIFNsZWVwIHVudGlsIHdlIGFyZSBz aWduYWxlZCBvciBXYWxXcml0ZXJEZWxheSBoYXMgZWxhcHNlZC4gIElmIHdlCiAJCSAqIGhhdmVu J3QgZG9uZSBhbnl0aGluZyB1c2VmdWwgZm9yIHF1aXRlIHNvbWUgdGltZSwgbGVuZ3RoZW4gdGhl CmRpZmYgLS1naXQgYS9zcmMvYmFja2VuZC91dGlscy9hZHQvcGdzdGF0ZnVuY3MuYyBiL3NyYy9i YWNrZW5kL3V0aWxzL2FkdC9wZ3N0YXRmdW5jcy5jCmluZGV4IGEyMTBmYzkzLi4zZDFmNzg4ZCAx MDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRpbHMvYWR0L3Bnc3RhdGZ1bmNzLmMKKysrIGIvc3Jj L2JhY2tlbmQvdXRpbHMvYWR0L3Bnc3RhdGZ1bmNzLmMKQEAgLTE3MDMsMTAgKzE3MDMsMTEgQEAg cGdfc3RhdF9nZXRfYnVmX2FsbG9jKFBHX0ZVTkNUSU9OX0FSR1MpCiBEYXR1bQogcGdfc3RhdF9n ZXRfd2FsKFBHX0ZVTkNUSU9OX0FSR1MpCiB7Ci0jZGVmaW5lIFBHX1NUQVRfR0VUX1dBTF9DT0xT CTIKKyNkZWZpbmUgUEdfU1RBVF9HRVRfV0FMX0NPTFMJMTAKIAlUdXBsZURlc2MJdHVwZGVzYzsK IAlEYXR1bQkJdmFsdWVzW1BHX1NUQVRfR0VUX1dBTF9DT0xTXTsKIAlib29sCQludWxsc1tQR19T VEFUX0dFVF9XQUxfQ09MU107CisJY2hhcgkJYnVmWzI1Nl07CiAJUGdTdGF0X1dhbFN0YXRzICp3 YWxfc3RhdHM7CiAKIAkvKiBJbml0aWFsaXNlIHZhbHVlcyBhbmQgTlVMTCBmbGFncyBhcnJheXMg Ki8KQEAgLTE3MTUsMTkgKzE3MTYsNTcgQEAgcGdfc3RhdF9nZXRfd2FsKFBHX0ZVTkNUSU9OX0FS R1MpCiAKIAkvKiBJbml0aWFsaXNlIGF0dHJpYnV0ZXMgaW5mb3JtYXRpb24gaW4gdGhlIHR1cGxl IGRlc2NyaXB0b3IgKi8KIAl0dXBkZXNjID0gQ3JlYXRlVGVtcGxhdGVUdXBsZURlc2MoUEdfU1RB VF9HRVRfV0FMX0NPTFMpOwotCVR1cGxlRGVzY0luaXRFbnRyeSh0dXBkZXNjLCAoQXR0ck51bWJl cikgMSwgIndhbF9idWZmZXJzX2Z1bGwiLAorCVR1cGxlRGVzY0luaXRFbnRyeSh0dXBkZXNjLCAo QXR0ck51bWJlcikgMSwgIndhbF9yZWNvcmRzIiwKIAkJCQkJICAgSU5UOE9JRCwgLTEsIDApOwot CVR1cGxlRGVzY0luaXRFbnRyeSh0dXBkZXNjLCAoQXR0ck51bWJlcikgMiwgInN0YXRzX3Jlc2V0 IiwKKwlUdXBsZURlc2NJbml0RW50cnkodHVwZGVzYywgKEF0dHJOdW1iZXIpIDIsICJ3YWxfZnBp IiwKKwkJCQkJICAgSU5UOE9JRCwgLTEsIDApOworCVR1cGxlRGVzY0luaXRFbnRyeSh0dXBkZXNj LCAoQXR0ck51bWJlcikgMywgIndhbF9ieXRlcyIsCisJCQkJCSAgIE5VTUVSSUNPSUQsIC0xLCAw KTsKKwlUdXBsZURlc2NJbml0RW50cnkodHVwZGVzYywgKEF0dHJOdW1iZXIpIDQsICJ3YWxfYnVm ZmVyc19mdWxsIiwKKwkJCQkJICAgSU5UOE9JRCwgLTEsIDApOworCVR1cGxlRGVzY0luaXRFbnRy eSh0dXBkZXNjLCAoQXR0ck51bWJlcikgNSwgIndhbF9pbml0X2ZpbGUiLAorCQkJCQkgICBJTlQ4 T0lELCAtMSwgMCk7CisJVHVwbGVEZXNjSW5pdEVudHJ5KHR1cGRlc2MsIChBdHRyTnVtYmVyKSA2 LCAid2FsX3dyaXRlIiwKKwkJCQkJICAgSU5UOE9JRCwgLTEsIDApOworCVR1cGxlRGVzY0luaXRF bnRyeSh0dXBkZXNjLCAoQXR0ck51bWJlcikgNywgIndhbF93cml0ZV90aW1lIiwKKwkJCQkJICAg RkxPQVQ4T0lELCAtMSwgMCk7CisJVHVwbGVEZXNjSW5pdEVudHJ5KHR1cGRlc2MsIChBdHRyTnVt YmVyKSA4LCAid2FsX3N5bmMiLAorCQkJCQkgICBJTlQ4T0lELCAtMSwgMCk7CisJVHVwbGVEZXNj SW5pdEVudHJ5KHR1cGRlc2MsIChBdHRyTnVtYmVyKSA5LCAid2FsX3N5bmNfdGltZSIsCisJCQkJ CSAgIEZMT0FUOE9JRCwgLTEsIDApOworCVR1cGxlRGVzY0luaXRFbnRyeSh0dXBkZXNjLCAoQXR0 ck51bWJlcikgMTAsICJzdGF0c19yZXNldCIsCiAJCQkJCSAgIFRJTUVTVEFNUFRaT0lELCAtMSwg MCk7CiAKIAlCbGVzc1R1cGxlRGVzYyh0dXBkZXNjKTsKIAorCiAJLyogR2V0IHN0YXRpc3RpY3Mg YWJvdXQgV0FMIGFjdGl2aXR5ICovCiAJd2FsX3N0YXRzID0gcGdzdGF0X2ZldGNoX3N0YXRfd2Fs KCk7CiAKIAkvKiBGaWxsIHZhbHVlcyBhbmQgTlVMTHMgKi8KLQl2YWx1ZXNbMF0gPSBJbnQ2NEdl dERhdHVtKHdhbF9zdGF0cy0+d2FsX2J1ZmZlcnNfZnVsbCk7Ci0JdmFsdWVzWzFdID0gVGltZXN0 YW1wVHpHZXREYXR1bSh3YWxfc3RhdHMtPnN0YXRfcmVzZXRfdGltZXN0YW1wKTsKKwl2YWx1ZXNb MF0gPSBJbnQ2NEdldERhdHVtKHdhbF9zdGF0cy0+d2FsX3JlY29yZHMpOworCXZhbHVlc1sxXSA9 IEludDY0R2V0RGF0dW0od2FsX3N0YXRzLT53YWxfZnBpKTsKKworCS8qIENvbnZlcnQgdG8gbnVt ZXJpYy4gKi8KKwlzbnByaW50ZihidWYsIHNpemVvZiBidWYsIFVJTlQ2NF9GT1JNQVQsIHdhbF9z dGF0cy0+d2FsX2J5dGVzKTsKKwl2YWx1ZXNbMl0gPSBEaXJlY3RGdW5jdGlvbkNhbGwzKG51bWVy aWNfaW4sCisJCQkJCQkJCQlDU3RyaW5nR2V0RGF0dW0oYnVmKSwKKwkJCQkJCQkJCU9iamVjdElk R2V0RGF0dW0oMCksCisJCQkJCQkJCQlJbnQzMkdldERhdHVtKC0xKSk7CisKKwl2YWx1ZXNbM10g PSBJbnQ2NEdldERhdHVtKHdhbF9zdGF0cy0+d2FsX2J1ZmZlcnNfZnVsbCk7CisJdmFsdWVzWzRd ID0gSW50NjRHZXREYXR1bSh3YWxfc3RhdHMtPndhbF9pbml0X2ZpbGUpOworCXZhbHVlc1s1XSA9 IEludDY0R2V0RGF0dW0od2FsX3N0YXRzLT53YWxfd3JpdGUpOworCisJLyogdGltZSBpcyBhbHJl YWR5IGluIG1zZWMsIGp1c3QgY29udmVydCB0byBkb3VibGUgZm9yIHByZXNlbnRhdGlvbiAqLwor CXZhbHVlc1s2XSA9IEZsb2F0OEdldERhdHVtKChkb3VibGUpIHdhbF9zdGF0cy0+d2FsX3dyaXRl X3RpbWUpOworCisJdmFsdWVzWzddID0gSW50NjRHZXREYXR1bSh3YWxfc3RhdHMtPndhbF9zeW5j KTsKKworCS8qIHRpbWUgaXMgYWxyZWFkeSBpbiBtc2VjLCBqdXN0IGNvbnZlcnQgdG8gZG91Ymxl IGZvciBwcmVzZW50YXRpb24gKi8KKwl2YWx1ZXNbOF0gPSBGbG9hdDhHZXREYXR1bSgoZG91Ymxl KSB3YWxfc3RhdHMtPndhbF9zeW5jX3RpbWUpOworCisJdmFsdWVzWzldID0gVGltZXN0YW1wVHpH ZXREYXR1bSh3YWxfc3RhdHMtPnN0YXRfcmVzZXRfdGltZXN0YW1wKTsKIAogCS8qIFJldHVybnMg dGhlIHJlY29yZCBhcyBEYXR1bSAqLwogCVBHX1JFVFVSTl9EQVRVTShIZWFwVHVwbGVHZXREYXR1 bShoZWFwX2Zvcm1fdHVwbGUodHVwZGVzYywgdmFsdWVzLCBudWxscykpKTsKZGlmZiAtLWdpdCBh L3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvZ3VjLmMgYi9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1 Yy5jCmluZGV4IGJiMzQ2MzBlLi4yYTNmNDUyZiAxMDA2NDQKLS0tIGEvc3JjL2JhY2tlbmQvdXRp bHMvbWlzYy9ndWMuYworKysgYi9zcmMvYmFja2VuZC91dGlscy9taXNjL2d1Yy5jCkBAIC0xNDgy LDYgKzE0ODIsMTUgQEAgc3RhdGljIHN0cnVjdCBjb25maWdfYm9vbCBDb25maWd1cmVOYW1lc0Jv b2xbXSA9CiAJCWZhbHNlLAogCQlOVUxMLCBOVUxMLCBOVUxMCiAJfSwKKwl7CisJCXsidHJhY2tf d2FsX2lvX3RpbWluZyIsIFBHQ19TVVNFVCwgU1RBVFNfQ09MTEVDVE9SLAorCQkJZ2V0dGV4dF9u b29wKCJDb2xsZWN0cyB0aW1pbmcgc3RhdGlzdGljcyBmb3IgV0FMIEkvTyBhY3Rpdml0eS4iKSwK KwkJCU5VTEwKKwkJfSwKKwkJJnRyYWNrX3dhbF9pb190aW1pbmcsCisJCWZhbHNlLAorCQlOVUxM LCBOVUxMLCBOVUxMCisJfSwKIAogCXsKIAkJeyJ1cGRhdGVfcHJvY2Vzc190aXRsZSIsIFBHQ19T VVNFVCwgUFJPQ0VTU19USVRMRSwKZGlmZiAtLWdpdCBhL3NyYy9iYWNrZW5kL3V0aWxzL21pc2Mv cG9zdGdyZXNxbC5jb25mLnNhbXBsZSBiL3NyYy9iYWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNx bC5jb25mLnNhbXBsZQppbmRleCA5Y2I1NzFmNy4uNDZjODc1ODQgMTAwNjQ0Ci0tLSBhL3NyYy9i YWNrZW5kL3V0aWxzL21pc2MvcG9zdGdyZXNxbC5jb25mLnNhbXBsZQorKysgYi9zcmMvYmFja2Vu ZC91dGlscy9taXNjL3Bvc3RncmVzcWwuY29uZi5zYW1wbGUKQEAgLTU4NCw2ICs1ODQsNyBAQAog I3RyYWNrX2FjdGl2aXRpZXMgPSBvbgogI3RyYWNrX2NvdW50cyA9IG9uCiAjdHJhY2tfaW9fdGlt aW5nID0gb2ZmCisjdHJhY2tfd2FsX2lvX3RpbWluZyA9IG9mZgogI3RyYWNrX2Z1bmN0aW9ucyA9 IG5vbmUJCQkjIG5vbmUsIHBsLCBhbGwKICN0cmFja19hY3Rpdml0eV9xdWVyeV9zaXplID0gMTAy NAkjIChjaGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkKICNzdGF0c190ZW1wX2RpcmVjdG9yeSA9ICdw Z19zdGF0X3RtcCcKZGlmZiAtLWdpdCBhL3NyYy9pbmNsdWRlL2FjY2Vzcy94bG9nLmggYi9zcmMv aW5jbHVkZS9hY2Nlc3MveGxvZy5oCmluZGV4IDIyMWFmODdlLi5jZTY5NTcwOCAxMDA2NDQKLS0t IGEvc3JjL2luY2x1ZGUvYWNjZXNzL3hsb2cuaAorKysgYi9zcmMvaW5jbHVkZS9hY2Nlc3MveGxv Zy5oCkBAIC0xMzEsNiArMTMxLDcgQEAgZXh0ZXJuIGludAlyZWNvdmVyeV9taW5fYXBwbHlfZGVs YXk7CiBleHRlcm4gY2hhciAqUHJpbWFyeUNvbm5JbmZvOwogZXh0ZXJuIGNoYXIgKlByaW1hcnlT bG90TmFtZTsKIGV4dGVybiBib29sIHdhbF9yZWNlaXZlcl9jcmVhdGVfdGVtcF9zbG90OworZXh0 ZXJuIGJvb2wgdHJhY2tfd2FsX2lvX3RpbWluZzsKIAogLyogaW5kaXJlY3RseSBzZXQgdmlhIEdV QyBzeXN0ZW0gKi8KIGV4dGVybiBUcmFuc2FjdGlvbklkIHJlY292ZXJ5VGFyZ2V0WGlkOwpkaWZm IC0tZ2l0IGEvc3JjL2luY2x1ZGUvY2F0YWxvZy9wZ19wcm9jLmRhdCBiL3NyYy9pbmNsdWRlL2Nh dGFsb2cvcGdfcHJvYy5kYXQKaW5kZXggYzAxZGE0YmYuLjRjN2I3ZjVmIDEwMDY0NAotLS0gYS9z cmMvaW5jbHVkZS9jYXRhbG9nL3BnX3Byb2MuZGF0CisrKyBiL3NyYy9pbmNsdWRlL2NhdGFsb2cv cGdfcHJvYy5kYXQKQEAgLTU1MDAsMTIgKzU1MDAsMTMgQEAKICAgcHJvbmFtZSA9PiAncGdfc3Rh dF9nZXRfYnVmX2FsbG9jJywgcHJvdm9sYXRpbGUgPT4gJ3MnLCBwcm9wYXJhbGxlbCA9PiAncics CiAgIHByb3JldHR5cGUgPT4gJ2ludDgnLCBwcm9hcmd0eXBlcyA9PiAnJywgcHJvc3JjID0+ICdw Z19zdGF0X2dldF9idWZfYWxsb2MnIH0sCiAKLXsgb2lkID0+ICcxMTM2JywgZGVzY3IgPT4gJ3N0 YXRpc3RpY3M6IGluZm9ybWF0aW9uIGFib3V0IFdBTCBhY3Rpdml0eScsCi0gIHByb25hbWUgPT4g J3BnX3N0YXRfZ2V0X3dhbCcsIHByb2lzc3RyaWN0ID0+ICdmJywgcHJvdm9sYXRpbGUgPT4gJ3Mn LAotICBwcm9wYXJhbGxlbCA9PiAncicsIHByb3JldHR5cGUgPT4gJ3JlY29yZCcsIHByb2FyZ3R5 cGVzID0+ICcnLAotICBwcm9hbGxhcmd0eXBlcyA9PiAne2ludDgsdGltZXN0YW1wdHp9JywgcHJv YXJnbW9kZXMgPT4gJ3tvLG99JywKLSAgcHJvYXJnbmFtZXMgPT4gJ3t3YWxfYnVmZmVyc19mdWxs LHN0YXRzX3Jlc2V0fScsCi0gIHByb3NyYyA9PiAncGdfc3RhdF9nZXRfd2FsJyB9LAorIHsgb2lk ID0+ICcxMTM2JywgZGVzY3IgPT4gJ3N0YXRpc3RpY3M6IGluZm9ybWF0aW9uIGFib3V0IFdBTCBh Y3Rpdml0eScsCisgICBwcm9uYW1lID0+ICdwZ19zdGF0X2dldF93YWwnLCBwcm9pc3N0cmljdCA9 PiAnZicsIHByb3ZvbGF0aWxlID0+ICdzJywKKyAgIHByb3BhcmFsbGVsID0+ICdyJywgcHJvcmV0 dHlwZSA9PiAncmVjb3JkJywgcHJvYXJndHlwZXMgPT4gJycsCisgICBwcm9hbGxhcmd0eXBlcyA9 PiAne2ludDgsaW50OCxudW1lcmljLGludDgsaW50OCxpbnQ4LGZsb2F0OCxpbnQ4LGZsb2F0OCx0 aW1lc3RhbXB0en0nLAorICAgcHJvYXJnbW9kZXMgPT4gJ3tvLG8sbyxvLG8sbyxvLG8sbyxvfScs CisgICBwcm9hcmduYW1lcyA9PiAne3dhbF9yZWNvcmRzLHdhbF9mcGksd2FsX2J5dGVzLHdhbF9i dWZmZXJzX2Z1bGwsd2FsX2luaXRfZmlsZSx3YWxfd3JpdGUsd2FsX3dyaXRlX3RpbWUsd2FsX3N5 bmMsd2FsX3N5bmNfdGltZSxzdGF0c19yZXNldH0nLAorICAgcHJvc3JjID0+ICdwZ19zdGF0X2dl dF93YWwnIH0sCiAKIHsgb2lkID0+ICcyMzA2JywgZGVzY3IgPT4gJ3N0YXRpc3RpY3M6IGluZm9y bWF0aW9uIGFib3V0IFNMUlUgY2FjaGVzJywKICAgcHJvbmFtZSA9PiAncGdfc3RhdF9nZXRfc2xy dScsIHByb3Jvd3MgPT4gJzEwMCcsIHByb2lzc3RyaWN0ID0+ICdmJywKZGlmZiAtLWdpdCBhL3Ny Yy9pbmNsdWRlL3Bnc3RhdC5oIGIvc3JjL2luY2x1ZGUvcGdzdGF0LmgKaW5kZXggMjU3ZTUxNWIu LmRjYzYyNDUyIDEwMDY0NAotLS0gYS9zcmMvaW5jbHVkZS9wZ3N0YXQuaAorKysgYi9zcmMvaW5j bHVkZS9wZ3N0YXQuaApAQCAtMTIsNiArMTIsNyBAQAogI2RlZmluZSBQR1NUQVRfSAogCiAjaW5j bHVkZSAiZGF0YXR5cGUvdGltZXN0YW1wLmgiCisjaW5jbHVkZSAiZXhlY3V0b3IvaW5zdHJ1bWVu dC5oIgogI2luY2x1ZGUgImxpYnBxL3BxY29tbS5oIgogI2luY2x1ZGUgIm1pc2NhZG1pbi5oIgog I2luY2x1ZGUgInBvcnQvYXRvbWljcy5oIgpAQCAtNDU5LDcgKzQ2MCwxNSBAQCB0eXBlZGVmIHN0 cnVjdCBQZ1N0YXRfTXNnQmdXcml0ZXIKIHR5cGVkZWYgc3RydWN0IFBnU3RhdF9Nc2dXYWwKIHsK IAlQZ1N0YXRfTXNnSGRyIG1faGRyOworCVBnU3RhdF9Db3VudGVyIG1fd2FsX3JlY29yZHM7CisJ UGdTdGF0X0NvdW50ZXIgbV93YWxfZnBpOworCXVpbnQ2NCBtX3dhbF9ieXRlczsKIAlQZ1N0YXRf Q291bnRlciBtX3dhbF9idWZmZXJzX2Z1bGw7CisJUGdTdGF0X0NvdW50ZXIgbV93YWxfaW5pdF9m aWxlOworCVBnU3RhdF9Db3VudGVyIG1fd2FsX3dyaXRlOworCVBnU3RhdF9Db3VudGVyIG1fd2Fs X3dyaXRlX3RpbWU7CS8qIGFjY3VtdWxhdGUgdGltZXMgaW4gbWlsbGlzZWNvbmRzICovCisJUGdT dGF0X0NvdW50ZXIgbV93YWxfc3luYzsKKwlQZ1N0YXRfQ291bnRlciBtX3dhbF9zeW5jX3RpbWU7 CS8qIGFjY3VtdWxhdGUgdGltZXMgaW4gbWlsbGlzZWNvbmRzICovCiB9IFBnU3RhdF9Nc2dXYWw7 CiAKIC8qIC0tLS0tLS0tLS0KQEAgLTc5OCw3ICs4MDcsMTYgQEAgdHlwZWRlZiBzdHJ1Y3QgUGdT dGF0X0dsb2JhbFN0YXRzCiAgKi8KIHR5cGVkZWYgc3RydWN0IFBnU3RhdF9XYWxTdGF0cwogewor CVBnU3RhdF9Db3VudGVyIHdhbF9yZWNvcmRzOworCVBnU3RhdF9Db3VudGVyIHdhbF9mcGk7CisJ dWludDY0IHdhbF9ieXRlczsKIAlQZ1N0YXRfQ291bnRlciB3YWxfYnVmZmVyc19mdWxsOworCVBn U3RhdF9Db3VudGVyIHdhbF9pbml0X2ZpbGU7CisJUGdTdGF0X0NvdW50ZXIgd2FsX3dyaXRlOwor CVBnU3RhdF9Db3VudGVyIHdhbF93cml0ZV90aW1lOworCVBnU3RhdF9Db3VudGVyIHdhbF9zeW5j OworCVBnU3RhdF9Db3VudGVyIHdhbF9zeW5jX3RpbWU7CisKIAlUaW1lc3RhbXBUeiBzdGF0X3Jl c2V0X3RpbWVzdGFtcDsKIH0gUGdTdGF0X1dhbFN0YXRzOwogCkBAIC0xMzQwLDYgKzEzNTgsNyBA QCBleHRlcm4gUGdTdGF0X01zZ0JnV3JpdGVyIEJnV3JpdGVyU3RhdHM7CiAgKiBXQUwgc3RhdGlz dGljcyBjb3VudGVyIGlzIHVwZGF0ZWQgYnkgYmFja2VuZHMgYW5kIGJhY2tncm91bmQgcHJvY2Vz c2VzCiAgKi8KIGV4dGVybiBQZ1N0YXRfTXNnV2FsIFdhbFN0YXRzOworZXh0ZXJuIFdhbFVzYWdl IHByZXZXYWxVc2FnZTsKIAogLyoKICAqIFVwZGF0ZWQgYnkgcGdzdGF0X2NvdW50X2J1ZmZlcl8q X3RpbWUgbWFjcm9zCmRpZmYgLS1naXQgYS9zcmMvdGVzdC9yZWdyZXNzL2V4cGVjdGVkL3J1bGVz Lm91dCBiL3NyYy90ZXN0L3JlZ3Jlc3MvZXhwZWN0ZWQvcnVsZXMub3V0CmluZGV4IDA5N2ZmNWQx Li4zMDJlY2FhOCAxMDA2NDQKLS0tIGEvc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9ydWxlcy5v dXQKKysrIGIvc3JjL3Rlc3QvcmVncmVzcy9leHBlY3RlZC9ydWxlcy5vdXQKQEAgLTIxMzgsOSAr MjEzOCwxNyBAQCBwZ19zdGF0X3VzZXJfdGFibGVzfCBTRUxFQ1QgcGdfc3RhdF9hbGxfdGFibGVz LnJlbGlkLAogICAgIHBnX3N0YXRfYWxsX3RhYmxlcy5hdXRvYW5hbHl6ZV9jb3VudAogICAgRlJP TSBwZ19zdGF0X2FsbF90YWJsZXMKICAgV0hFUkUgKChwZ19zdGF0X2FsbF90YWJsZXMuc2NoZW1h bmFtZSA8PiBBTEwgKEFSUkFZWydwZ19jYXRhbG9nJzo6bmFtZSwgJ2luZm9ybWF0aW9uX3NjaGVt YSc6Om5hbWVdKSkgQU5EIChwZ19zdGF0X2FsbF90YWJsZXMuc2NoZW1hbmFtZSAhfiAnXnBnX3Rv YXN0Jzo6dGV4dCkpOwotcGdfc3RhdF93YWx8IFNFTEVDVCB3LndhbF9idWZmZXJzX2Z1bGwsCitw Z19zdGF0X3dhbHwgU0VMRUNUIHcud2FsX3JlY29yZHMsCisgICAgdy53YWxfZnBpLAorICAgIHcu d2FsX2J5dGVzLAorICAgIHcud2FsX2J1ZmZlcnNfZnVsbCwKKyAgICB3LndhbF9pbml0X2ZpbGUs CisgICAgdy53YWxfd3JpdGUsCisgICAgdy53YWxfd3JpdGVfdGltZSwKKyAgICB3LndhbF9zeW5j LAorICAgIHcud2FsX3N5bmNfdGltZSwKICAgICB3LnN0YXRzX3Jlc2V0Ci0gICBGUk9NIHBnX3N0 YXRfZ2V0X3dhbCgpIHcod2FsX2J1ZmZlcnNfZnVsbCwgc3RhdHNfcmVzZXQpOworICAgRlJPTSBw Z19zdGF0X2dldF93YWwoKSB3KHdhbF9yZWNvcmRzLCB3YWxfZnBpLCB3YWxfYnl0ZXMsIHdhbF9i dWZmZXJzX2Z1bGwsIHdhbF9pbml0X2ZpbGUsIHdhbF93cml0ZSwgd2FsX3dyaXRlX3RpbWUsIHdh bF9zeW5jLCB3YWxfc3luY190aW1lLCBzdGF0c19yZXNldCk7CiBwZ19zdGF0X3dhbF9yZWNlaXZl cnwgU0VMRUNUIHMucGlkLAogICAgIHMuc3RhdHVzLAogICAgIHMucmVjZWl2ZV9zdGFydF9sc24s Cg== --=_56561b64bce6027c1ac9a0c08856b10b--