From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.2 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 761CBC6369E for ; Thu, 3 Dec 2020 01:16:44 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id EDCE1221FB for ; Thu, 3 Dec 2020 01:16:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728822AbgLCBQi (ORCPT ); Wed, 2 Dec 2020 20:16:38 -0500 Received: from szxga05-in.huawei.com ([45.249.212.191]:9095 "EHLO szxga05-in.huawei.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726479AbgLCBQh (ORCPT ); Wed, 2 Dec 2020 20:16:37 -0500 Received: from DGGEMS404-HUB.china.huawei.com (unknown [172.30.72.60]) by szxga05-in.huawei.com (SkyGuard) with ESMTP id 4CmdDl6ys1zLxjq; Thu, 3 Dec 2020 09:15:19 +0800 (CST) Received: from [10.136.114.67] (10.136.114.67) by smtp.huawei.com (10.3.19.204) with Microsoft SMTP Server (TLS) id 14.3.487.0; Thu, 3 Dec 2020 09:15:52 +0800 Subject: Re: [f2fs-dev] [PATCH v2 1/2] f2fs: add compress_mode mount option To: Daeho Jeong CC: , , , Daeho Jeong References: <20201201040803.3590442-1-daeho43@gmail.com> From: Chao Yu Message-ID: Date: Thu, 3 Dec 2020 09:15:52 +0800 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Thunderbird/52.9.1 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset="utf-8"; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit X-Originating-IP: [10.136.114.67] X-CFilter-Loop: Reflected Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 2020/12/2 18:54, Daeho Jeong wrote: > We might use compress_extension=*,compress_option=user. > In this option, we're gonna allocate all the writes in cold zone. Oh, so all files in data partition will be tagged as compressed file, but the compressing time will be controlled by user, then, only blocks belong to in-compress-process inode will go to cold area, right? Thanks, > > > 2020년 12월 2일 (수) 오후 3:31, Chao Yu >님이 작성: > > On 2020/12/1 12:08, Daeho Jeong wrote: > > From: Daeho Jeong > > > > > We will add a new "compress_mode" mount option to control file > > compression mode. This supports "fs" and "user". In "fs" mode (default), > > f2fs does automatic compression on the compression enabled files. > > In "user" mode, f2fs disables the automaic compression and gives the > > user discretion of choosing the target file and the timing. It means > > the user can do manual compression/decompression on the compression > > enabled files using ioctls. > > > > Signed-off-by: Daeho Jeong > > > --- > > v2: changed mount option name and added more explanation of mount option > > --- > >   Documentation/filesystems/f2fs.rst | 35 ++++++++++++++++++++++++++++++ > >   fs/f2fs/compress.c                 |  2 +- > >   fs/f2fs/data.c                     |  2 +- > >   fs/f2fs/f2fs.h                     | 30 +++++++++++++++++++++++++ > >   fs/f2fs/segment.c                  |  2 +- > >   fs/f2fs/super.c                    | 23 ++++++++++++++++++++ > >   6 files changed, 91 insertions(+), 3 deletions(-) > > > > diff --git a/Documentation/filesystems/f2fs.rst b/Documentation/filesystems/f2fs.rst > > index b8ee761c9922..5eb8d63439ec 100644 > > --- a/Documentation/filesystems/f2fs.rst > > +++ b/Documentation/filesystems/f2fs.rst > > @@ -260,6 +260,13 @@ compress_extension=%s     Support adding specified extension, so that f2fs can enab > >                        For other files, we can still enable compression via ioctl. > >                        Note that, there is one reserved special extension '*', it > >                        can be set to enable compression for all files. > > +compress_mode=%s      Control file compression mode. This supports "fs" and "user" > > +                      modes. In "fs" mode (default), f2fs does automatic compression > > +                      on the compression enabled files. In "user" mode, f2fs disables > > +                      the automaic compression and gives the user discretion of > > +                      choosing the target file and the timing. The user can do manual > > +                      compression/decompression on the compression enabled files using > > +                      ioctls. > >   inlinecrypt          When possible, encrypt/decrypt the contents of encrypted > >                        files using the blk-crypto framework rather than > >                        filesystem-layer encryption. This allows the use of > > @@ -810,6 +817,34 @@ Compress metadata layout:: > >       | data length | data chksum | reserved |      compressed data       | > >       +-------------+-------------+----------+----------------------------+ > > > > +Compression mode > > +-------------------------- > > + > > +f2fs supports "fs" and "user" compression modes with "compression_mode" mount option. > > +With this option, f2fs provides a choice to select the way how to compress the > > +compression enabled files (refer to "Compression implementation" section for how to > > +enable compression on a regular inode). > > + > > +1) compress_mode=fs > > +This is the default option. f2fs does automatic compression in the writeback of the > > +compression enabled files. > > + > > +2) compress_mode=user > > +This disables the automaic compression and gives the user discretion of choosing the > > +target file and the timing. The user can do manual compression/decompression on the > > +compression enabled files using F2FS_IOC_DECOMPRESS_FILE and F2FS_IOC_COMPRESS_FILE > > +ioctls like the below. > > + > > +To decompress a file, > > + > > +fd = open(filename, O_WRONLY, 0); > > +ret = ioctl(fd, F2FS_IOC_DECOMPRESS_FILE); > > + > > +To compress a file, > > + > > +fd = open(filename, O_WRONLY, 0); > > +ret = ioctl(fd, F2FS_IOC_COMPRESS_FILE); > > + > >   NVMe Zoned Namespace devices > >   ---------------------------- > > > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > > index 3957a84a185e..87090da8693d 100644 > > --- a/fs/f2fs/compress.c > > +++ b/fs/f2fs/compress.c > > @@ -926,7 +926,7 @@ int f2fs_is_compressed_cluster(struct inode *inode, pgoff_t index) > > > >   static bool cluster_may_compress(struct compress_ctx *cc) > >   { > > -     if (!f2fs_compressed_file(cc->inode)) > > +     if (!f2fs_need_compress_data(cc->inode)) > >               return false; > >       if (f2fs_is_atomic_file(cc->inode)) > >               return false; > > diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c > > index be4da52604ed..42254d3859c7 100644 > > --- a/fs/f2fs/data.c > > +++ b/fs/f2fs/data.c > > @@ -3164,7 +3164,7 @@ static inline bool __should_serialize_io(struct inode *inode, > >       if (IS_NOQUOTA(inode)) > >               return false; > > > > -     if (f2fs_compressed_file(inode)) > > +     if (f2fs_need_compress_data(inode)) > >               return true; > >       if (wbc->sync_mode != WB_SYNC_ALL) > >               return true; > > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > > index e0826779a101..94d16bde5e24 100644 > > --- a/fs/f2fs/f2fs.h > > +++ b/fs/f2fs/f2fs.h > > @@ -149,6 +149,7 @@ struct f2fs_mount_info { > >       unsigned char compress_algorithm;       /* algorithm type */ > >       unsigned compress_log_size;             /* cluster log size */ > >       unsigned char compress_ext_cnt;         /* extension count */ > > +     int compress_mode;                      /* compression mode */ > >       unsigned char extensions[COMPRESS_EXT_NUM][F2FS_EXTENSION_LEN]; /* extensions */ > >   }; > > > > @@ -677,6 +678,7 @@ enum { > >       FI_VERITY_IN_PROGRESS,  /* building fs-verity Merkle tree */ > >       FI_COMPRESSED_FILE,     /* indicate file's data can be compressed */ > >       FI_MMAP_FILE,           /* indicate file was mmapped */ > > +     FI_ENABLE_COMPRESS,     /* enable compression in "user" compression mode */ > >       FI_MAX,                 /* max flag, never be used */ > >   }; > > > > @@ -1243,6 +1245,18 @@ enum fsync_mode { > >       FSYNC_MODE_NOBARRIER,   /* fsync behaves nobarrier based on posix */ > >   }; > > > > +enum { > > +     COMPR_MODE_FS,          /* > > +                              * automatically compress compression > > +                              * enabled files > > +                              */ > > +     COMPR_MODE_USER,        /* > > +                              * automatical compression is disabled. > > +                              * user can control the file compression > > +                              * using ioctls > > +                              */ > > +}; > > + > >   /* > >    * this value is set in page as a private data which indicate that > >    * the page is atomically written, and it is in inmem_pages list. > > @@ -2752,6 +2766,22 @@ static inline int f2fs_compressed_file(struct inode *inode) > >               is_inode_flag_set(inode, FI_COMPRESSED_FILE); > >   } > > > > +static inline bool f2fs_need_compress_data(struct inode *inode) > > +{ > > +     int compress_mode = F2FS_OPTION(F2FS_I_SB(inode)).compress_mode; > > + > > +     if (!f2fs_compressed_file(inode)) > > +             return false; > > + > > +     if (compress_mode == COMPR_MODE_FS) > > +             return true; > > +     else if (compress_mode == COMPR_MODE_USER && > > +                     is_inode_flag_set(inode, FI_ENABLE_COMPRESS)) > > +             return true; > > + > > +     return false; > > +} > > + > >   static inline unsigned int addrs_per_inode(struct inode *inode) > >   { > >       unsigned int addrs = CUR_ADDRS_PER_INODE(inode) - > > diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c > > index 1596502f7375..5d6c9d6f237b 100644 > > --- a/fs/f2fs/segment.c > > +++ b/fs/f2fs/segment.c > > @@ -3254,7 +3254,7 @@ static int __get_segment_type_6(struct f2fs_io_info *fio) > >                       else > >                               return CURSEG_COLD_DATA; > >               } > > -             if (file_is_cold(inode) || f2fs_compressed_file(inode)) > > +             if (file_is_cold(inode) || f2fs_need_compress_data(inode)) > > Can we keep consistent about writting compressed file to code data area? > > Or there is other concern about this? > > Thanks, > > >                       return CURSEG_COLD_DATA; > >               if (file_is_hot(inode) || > >                               is_inode_flag_set(inode, FI_HOT_DATA) || > > diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c > > index 87f7a6e86370..cc6eb4ed80a2 100644 > > --- a/fs/f2fs/super.c > > +++ b/fs/f2fs/super.c > > @@ -146,6 +146,7 @@ enum { > >       Opt_compress_algorithm, > >       Opt_compress_log_size, > >       Opt_compress_extension, > > +     Opt_compress_mode, > >       Opt_atgc, > >       Opt_err, > >   }; > > @@ -214,6 +215,7 @@ static match_table_t f2fs_tokens = { > >       {Opt_compress_algorithm, "compress_algorithm=%s"}, > >       {Opt_compress_log_size, "compress_log_size=%u"}, > >       {Opt_compress_extension, "compress_extension=%s"}, > > +     {Opt_compress_mode, "compress_mode=%s"}, > >       {Opt_atgc, "atgc"}, > >       {Opt_err, NULL}, > >   }; > > @@ -934,10 +936,25 @@ static int parse_options(struct super_block *sb, char *options, bool is_remount) > >                       F2FS_OPTION(sbi).compress_ext_cnt++; > >                       kfree(name); > >                       break; > > +             case Opt_compress_mode: > > +                     name = match_strdup(&args[0]); > > +                     if (!name) > > +                             return -ENOMEM; > > +                     if (!strcmp(name, "fs")) { > > +                             F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS; > > +                     } else if (!strcmp(name, "user")) { > > +                             F2FS_OPTION(sbi).compress_mode = COMPR_MODE_USER; > > +                     } else { > > +                             kfree(name); > > +                             return -EINVAL; > > +                     } > > +                     kfree(name); > > +                     break; > >   #else > >               case Opt_compress_algorithm: > >               case Opt_compress_log_size: > >               case Opt_compress_extension: > > +             case Opt_compress_mode: > >                       f2fs_info(sbi, "compression options not supported"); > >                       break; > >   #endif > > @@ -1523,6 +1540,11 @@ static inline void f2fs_show_compress_options(struct seq_file *seq, > >               seq_printf(seq, ",compress_extension=%s", > >                       F2FS_OPTION(sbi).extensions[i]); > >       } > > + > > +     if (F2FS_OPTION(sbi).compress_mode == COMPR_MODE_FS) > > +             seq_printf(seq, ",compress_mode=%s", "fs"); > > +     else if (F2FS_OPTION(sbi).compress_mode == COMPR_MODE_USER) > > +             seq_printf(seq, ",compress_mode=%s", "user"); > >   } > > > >   static int f2fs_show_options(struct seq_file *seq, struct dentry *root) > > @@ -1672,6 +1694,7 @@ static void default_options(struct f2fs_sb_info *sbi) > >       F2FS_OPTION(sbi).compress_algorithm = COMPRESS_LZ4; > >       F2FS_OPTION(sbi).compress_log_size = MIN_COMPRESS_LOG_SIZE; > >       F2FS_OPTION(sbi).compress_ext_cnt = 0; > > +     F2FS_OPTION(sbi).compress_mode = COMPR_MODE_FS; > >       F2FS_OPTION(sbi).bggc_mode = BGGC_MODE_ON; > > > >       sbi->sb->s_flags &= ~SB_INLINECRYPT; > > > From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.1 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8771BC6369E for ; Thu, 3 Dec 2020 01:16:20 +0000 (UTC) Received: from lists.sourceforge.net (lists.sourceforge.net [216.105.38.7]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 63447221FB; Thu, 3 Dec 2020 01:16:19 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 63447221FB Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=huawei.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=linux-f2fs-devel-bounces@lists.sourceforge.net Received: from [127.0.0.1] (helo=sfs-ml-1.v29.lw.sourceforge.com) by sfs-ml-1.v29.lw.sourceforge.com with esmtp (Exim 4.90_1) (envelope-from ) id 1kkdEG-00063w-Pu; Thu, 03 Dec 2020 01:16:16 +0000 Received: from [172.30.20.202] (helo=mx.sourceforge.net) by sfs-ml-1.v29.lw.sourceforge.com with esmtps (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kkdEF-00063d-Gj for linux-f2fs-devel@lists.sourceforge.net; Thu, 03 Dec 2020 01:16:15 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sourceforge.net; s=x; h=Content-Transfer-Encoding:Content-Type:In-Reply-To: MIME-Version:Date:Message-ID:From:References:CC:To:Subject:Sender:Reply-To: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=1zmTm6OMZD+Fyo3kL/3M+9YxWmg+qnrN5WtwgJR+ANs=; b=M/gaQkJKWpgpyG7o+cpQn5nCOL 9or0GFDkIY+Ij51fBpXkfMyd19imD6IusMFLi5o6Gt4HetAPS+0Cm573oFkcXmBlXpctB/Qxt0nUo NsYPh6Zmxg6oT2fqOsBOEUUwltEr19BGPE0dYl1WOG3wUILeKaAy0bVWjiZyXZD39IXc=; DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=sf.net; s=x ; h=Content-Transfer-Encoding:Content-Type:In-Reply-To:MIME-Version:Date: Message-ID:From:References:CC:To:Subject:Sender:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Id:List-Help:List-Unsubscribe:List-Subscribe: List-Post:List-Owner:List-Archive; bh=1zmTm6OMZD+Fyo3kL/3M+9YxWmg+qnrN5WtwgJR+ANs=; b=LyWubotDA7GPiXZ+8/e3tFJFSv twtBW5jzJtBf0Xnfecy6eZPKcj3b5YoZxJOjQ5EFIeVhc1sFim52Dkkhy3MRKRmjgLZfL5LfzMcqk pOtEaKjDivcclwZwkFtJbNmO5ahvuInhSJYtXhLAyPksdglOQVKv1B9ypetzNgZp+gqM=; Received: from szxga05-in.huawei.com ([45.249.212.191]) by sfi-mx-1.v28.lw.sourceforge.com with esmtps (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.92.2) id 1kkdE3-00CMe9-E2 for linux-f2fs-devel@lists.sourceforge.net; Thu, 03 Dec 2020 01:16:15 +0000 Received: from DGGEMS404-HUB.china.huawei.com (unknown [172.30.72.60]) by szxga05-in.huawei.com (SkyGuard) with ESMTP id 4CmdDl6ys1zLxjq; Thu, 3 Dec 2020 09:15:19 +0800 (CST) Received: from [10.136.114.67] (10.136.114.67) by smtp.huawei.com (10.3.19.204) with Microsoft SMTP Server (TLS) id 14.3.487.0; Thu, 3 Dec 2020 09:15:52 +0800 To: Daeho Jeong References: <20201201040803.3590442-1-daeho43@gmail.com> From: Chao Yu Message-ID: Date: Thu, 3 Dec 2020 09:15:52 +0800 User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Thunderbird/52.9.1 MIME-Version: 1.0 In-Reply-To: Content-Language: en-US X-Originating-IP: [10.136.114.67] X-CFilter-Loop: Reflected X-Headers-End: 1kkdE3-00CMe9-E2 Subject: Re: [f2fs-dev] [PATCH v2 1/2] f2fs: add compress_mode mount option X-BeenThere: linux-f2fs-devel@lists.sourceforge.net X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Daeho Jeong , kernel-team@android.com, linux-kernel@vger.kernel.org, linux-f2fs-devel@lists.sourceforge.net Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: linux-f2fs-devel-bounces@lists.sourceforge.net T24gMjAyMC8xMi8yIDE4OjU0LCBEYWVobyBKZW9uZyB3cm90ZToKPiBXZSBtaWdodCB1c2UgY29t cHJlc3NfZXh0ZW5zaW9uPSosY29tcHJlc3Nfb3B0aW9uPXVzZXIuCj4gSW4gdGhpcyBvcHRpb24s IHdlJ3JlIGdvbm5hIGFsbG9jYXRlIGFsbCB0aGUgd3JpdGVzIGluIGNvbGQgem9uZS4KCk9oLCBz byBhbGwgZmlsZXMgaW4gZGF0YSBwYXJ0aXRpb24gd2lsbCBiZSB0YWdnZWQgYXMgY29tcHJlc3Nl ZCBmaWxlLApidXQgdGhlIGNvbXByZXNzaW5nIHRpbWUgd2lsbCBiZSBjb250cm9sbGVkIGJ5IHVz ZXIsIHRoZW4sIG9ubHkgYmxvY2tzCmJlbG9uZyB0byBpbi1jb21wcmVzcy1wcm9jZXNzIGlub2Rl IHdpbGwgZ28gdG8gY29sZCBhcmVhLCByaWdodD8KClRoYW5rcywKCj4gCj4gCj4gMjAyMOuFhCAx MuyblCAy7J28ICjsiJgpIOyYpO2bhCAzOjMxLCBDaGFvIFl1IDx5dWNoYW8wQGh1YXdlaS5jb20g PG1haWx0bzp5dWNoYW8wQGh1YXdlaS5jb20+PuuLmOydtCDsnpHshLE6Cj4gCj4gICAgIE9uIDIw MjAvMTIvMSAxMjowOCwgRGFlaG8gSmVvbmcgd3JvdGU6Cj4gICAgICA+IEZyb206IERhZWhvIEpl b25nIDxkYWVob2plb25nQGdvb2dsZS5jb20gPG1haWx0bzpkYWVob2plb25nQGdvb2dsZS5jb20+ Pgo+ICAgICAgPgo+ICAgICAgPiBXZSB3aWxsIGFkZCBhIG5ldyAiY29tcHJlc3NfbW9kZSIgbW91 bnQgb3B0aW9uIHRvIGNvbnRyb2wgZmlsZQo+ICAgICAgPiBjb21wcmVzc2lvbiBtb2RlLiBUaGlz IHN1cHBvcnRzICJmcyIgYW5kICJ1c2VyIi4gSW4gImZzIiBtb2RlIChkZWZhdWx0KSwKPiAgICAg ID4gZjJmcyBkb2VzIGF1dG9tYXRpYyBjb21wcmVzc2lvbiBvbiB0aGUgY29tcHJlc3Npb24gZW5h YmxlZCBmaWxlcy4KPiAgICAgID4gSW4gInVzZXIiIG1vZGUsIGYyZnMgZGlzYWJsZXMgdGhlIGF1 dG9tYWljIGNvbXByZXNzaW9uIGFuZCBnaXZlcyB0aGUKPiAgICAgID4gdXNlciBkaXNjcmV0aW9u IG9mIGNob29zaW5nIHRoZSB0YXJnZXQgZmlsZSBhbmQgdGhlIHRpbWluZy4gSXQgbWVhbnMKPiAg ICAgID4gdGhlIHVzZXIgY2FuIGRvIG1hbnVhbCBjb21wcmVzc2lvbi9kZWNvbXByZXNzaW9uIG9u IHRoZSBjb21wcmVzc2lvbgo+ICAgICAgPiBlbmFibGVkIGZpbGVzIHVzaW5nIGlvY3Rscy4KPiAg ICAgID4KPiAgICAgID4gU2lnbmVkLW9mZi1ieTogRGFlaG8gSmVvbmcgPGRhZWhvamVvbmdAZ29v Z2xlLmNvbSA8bWFpbHRvOmRhZWhvamVvbmdAZ29vZ2xlLmNvbT4+Cj4gICAgICA+IC0tLQo+ICAg ICAgPiB2MjogY2hhbmdlZCBtb3VudCBvcHRpb24gbmFtZSBhbmQgYWRkZWQgbW9yZSBleHBsYW5h dGlvbiBvZiBtb3VudCBvcHRpb24KPiAgICAgID4gLS0tCj4gICAgICA+wqAgwqBEb2N1bWVudGF0 aW9uL2ZpbGVzeXN0ZW1zL2YyZnMucnN0IHwgMzUgKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrCj4gICAgICA+wqAgwqBmcy9mMmZzL2NvbXByZXNzLmPCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoHzCoCAyICstCj4gICAgICA+wqAgwqBmcy9mMmZzL2RhdGEuY8KgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgfMKgIDIgKy0KPiAgICAgID7CoCDCoGZzL2YyZnMvZjJmcy5owqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqB8IDMwICsrKysrKysrKysrKysrKysrKysrKysrKysK PiAgICAgID7CoCDCoGZzL2YyZnMvc2VnbWVudC5jwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg fMKgIDIgKy0KPiAgICAgID7CoCDCoGZzL2YyZnMvc3VwZXIuY8KgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIHwgMjMgKysrKysrKysrKysrKysrKysrKysKPiAgICAgID7CoCDCoDYgZmlsZXMg Y2hhbmdlZCwgOTEgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlvbnMoLSkKPiAgICAgID4KPiAgICAg ID4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvZjJmcy5yc3QgYi9Eb2N1 bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2YyZnMucnN0Cj4gICAgICA+IGluZGV4IGI4ZWU3NjFjOTky Mi4uNWViOGQ2MzQzOWVjIDEwMDY0NAo+ICAgICAgPiAtLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVz eXN0ZW1zL2YyZnMucnN0Cj4gICAgICA+ICsrKyBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMv ZjJmcy5yc3QKPiAgICAgID4gQEAgLTI2MCw2ICsyNjAsMTMgQEAgY29tcHJlc3NfZXh0ZW5zaW9u PSVzwqAgwqAgwqBTdXBwb3J0IGFkZGluZyBzcGVjaWZpZWQgZXh0ZW5zaW9uLCBzbyB0aGF0IGYy ZnMgY2FuIGVuYWIKPiAgICAgID7CoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBG b3Igb3RoZXIgZmlsZXMsIHdlIGNhbiBzdGlsbCBlbmFibGUgY29tcHJlc3Npb24gdmlhIGlvY3Rs Lgo+ICAgICAgPsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIE5vdGUgdGhhdCwg dGhlcmUgaXMgb25lIHJlc2VydmVkIHNwZWNpYWwgZXh0ZW5zaW9uICcqJywgaXQKPiAgICAgID7C oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBjYW4gYmUgc2V0IHRvIGVuYWJsZSBj b21wcmVzc2lvbiBmb3IgYWxsIGZpbGVzLgo+ICAgICAgPiArY29tcHJlc3NfbW9kZT0lc8KgIMKg IMKgIENvbnRyb2wgZmlsZSBjb21wcmVzc2lvbiBtb2RlLiBUaGlzIHN1cHBvcnRzICJmcyIgYW5k ICJ1c2VyIgo+ICAgICAgPiArwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgbW9kZXMu IEluICJmcyIgbW9kZSAoZGVmYXVsdCksIGYyZnMgZG9lcyBhdXRvbWF0aWMgY29tcHJlc3Npb24K PiAgICAgID4gK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIG9uIHRoZSBjb21wcmVz c2lvbiBlbmFibGVkIGZpbGVzLiBJbiAidXNlciIgbW9kZSwgZjJmcyBkaXNhYmxlcwo+ICAgICAg PiArwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgdGhlIGF1dG9tYWljIGNvbXByZXNz aW9uIGFuZCBnaXZlcyB0aGUgdXNlciBkaXNjcmV0aW9uIG9mCj4gICAgICA+ICvCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBjaG9vc2luZyB0aGUgdGFyZ2V0IGZpbGUgYW5kIHRoZSB0 aW1pbmcuIFRoZSB1c2VyIGNhbiBkbyBtYW51YWwKPiAgICAgID4gK8KgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIGNvbXByZXNzaW9uL2RlY29tcHJlc3Npb24gb24gdGhlIGNvbXByZXNz aW9uIGVuYWJsZWQgZmlsZXMgdXNpbmcKPiAgICAgID4gK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIGlvY3Rscy4KPiAgICAgID7CoCDCoGlubGluZWNyeXB0wqAgwqAgwqAgwqAgwqAg V2hlbiBwb3NzaWJsZSwgZW5jcnlwdC9kZWNyeXB0IHRoZSBjb250ZW50cyBvZiBlbmNyeXB0ZWQK PiAgICAgID7CoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBmaWxlcyB1c2luZyB0 aGUgYmxrLWNyeXB0byBmcmFtZXdvcmsgcmF0aGVyIHRoYW4KPiAgICAgID7CoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCBmaWxlc3lzdGVtLWxheWVyIGVuY3J5cHRpb24uIFRoaXMg YWxsb3dzIHRoZSB1c2Ugb2YKPiAgICAgID4gQEAgLTgxMCw2ICs4MTcsMzQgQEAgQ29tcHJlc3Mg bWV0YWRhdGEgbGF5b3V0OjoKPiAgICAgID7CoCDCoCDCoCDCoHwgZGF0YSBsZW5ndGggfCBkYXRh IGNoa3N1bSB8IHJlc2VydmVkIHzCoCDCoCDCoCBjb21wcmVzc2VkIGRhdGHCoCDCoCDCoCDCoHwK PiAgICAgID7CoCDCoCDCoCDCoCstLS0tLS0tLS0tLS0tKy0tLS0tLS0tLS0tLS0rLS0tLS0tLS0t LSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKwo+ICAgICAgPgo+ICAgICAgPiArQ29tcHJl c3Npb24gbW9kZQo+ICAgICAgPiArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiAgICAgID4g Kwo+ICAgICAgPiArZjJmcyBzdXBwb3J0cyAiZnMiIGFuZCAidXNlciIgY29tcHJlc3Npb24gbW9k ZXMgd2l0aCAiY29tcHJlc3Npb25fbW9kZSIgbW91bnQgb3B0aW9uLgo+ICAgICAgPiArV2l0aCB0 aGlzIG9wdGlvbiwgZjJmcyBwcm92aWRlcyBhIGNob2ljZSB0byBzZWxlY3QgdGhlIHdheSBob3cg dG8gY29tcHJlc3MgdGhlCj4gICAgICA+ICtjb21wcmVzc2lvbiBlbmFibGVkIGZpbGVzIChyZWZl ciB0byAiQ29tcHJlc3Npb24gaW1wbGVtZW50YXRpb24iIHNlY3Rpb24gZm9yIGhvdyB0bwo+ICAg ICAgPiArZW5hYmxlIGNvbXByZXNzaW9uIG9uIGEgcmVndWxhciBpbm9kZSkuCj4gICAgICA+ICsK PiAgICAgID4gKzEpIGNvbXByZXNzX21vZGU9ZnMKPiAgICAgID4gK1RoaXMgaXMgdGhlIGRlZmF1 bHQgb3B0aW9uLiBmMmZzIGRvZXMgYXV0b21hdGljIGNvbXByZXNzaW9uIGluIHRoZSB3cml0ZWJh Y2sgb2YgdGhlCj4gICAgICA+ICtjb21wcmVzc2lvbiBlbmFibGVkIGZpbGVzLgo+ICAgICAgPiAr Cj4gICAgICA+ICsyKSBjb21wcmVzc19tb2RlPXVzZXIKPiAgICAgID4gK1RoaXMgZGlzYWJsZXMg dGhlIGF1dG9tYWljIGNvbXByZXNzaW9uIGFuZCBnaXZlcyB0aGUgdXNlciBkaXNjcmV0aW9uIG9m IGNob29zaW5nIHRoZQo+ICAgICAgPiArdGFyZ2V0IGZpbGUgYW5kIHRoZSB0aW1pbmcuIFRoZSB1 c2VyIGNhbiBkbyBtYW51YWwgY29tcHJlc3Npb24vZGVjb21wcmVzc2lvbiBvbiB0aGUKPiAgICAg ID4gK2NvbXByZXNzaW9uIGVuYWJsZWQgZmlsZXMgdXNpbmcgRjJGU19JT0NfREVDT01QUkVTU19G SUxFIGFuZCBGMkZTX0lPQ19DT01QUkVTU19GSUxFCj4gICAgICA+ICtpb2N0bHMgbGlrZSB0aGUg YmVsb3cuCj4gICAgICA+ICsKPiAgICAgID4gK1RvIGRlY29tcHJlc3MgYSBmaWxlLAo+ICAgICAg PiArCj4gICAgICA+ICtmZCA9IG9wZW4oZmlsZW5hbWUsIE9fV1JPTkxZLCAwKTsKPiAgICAgID4g K3JldCA9IGlvY3RsKGZkLCBGMkZTX0lPQ19ERUNPTVBSRVNTX0ZJTEUpOwo+ICAgICAgPiArCj4g ICAgICA+ICtUbyBjb21wcmVzcyBhIGZpbGUsCj4gICAgICA+ICsKPiAgICAgID4gK2ZkID0gb3Bl bihmaWxlbmFtZSwgT19XUk9OTFksIDApOwo+ICAgICAgPiArcmV0ID0gaW9jdGwoZmQsIEYyRlNf SU9DX0NPTVBSRVNTX0ZJTEUpOwo+ICAgICAgPiArCj4gICAgICA+wqAgwqBOVk1lIFpvbmVkIE5h bWVzcGFjZSBkZXZpY2VzCj4gICAgICA+wqAgwqAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t Cj4gICAgICA+Cj4gICAgICA+IGRpZmYgLS1naXQgYS9mcy9mMmZzL2NvbXByZXNzLmMgYi9mcy9m MmZzL2NvbXByZXNzLmMKPiAgICAgID4gaW5kZXggMzk1N2E4NGExODVlLi44NzA5MGRhODY5M2Qg MTAwNjQ0Cj4gICAgICA+IC0tLSBhL2ZzL2YyZnMvY29tcHJlc3MuYwo+ICAgICAgPiArKysgYi9m cy9mMmZzL2NvbXByZXNzLmMKPiAgICAgID4gQEAgLTkyNiw3ICs5MjYsNyBAQCBpbnQgZjJmc19p c19jb21wcmVzc2VkX2NsdXN0ZXIoc3RydWN0IGlub2RlICppbm9kZSwgcGdvZmZfdCBpbmRleCkK PiAgICAgID4KPiAgICAgID7CoCDCoHN0YXRpYyBib29sIGNsdXN0ZXJfbWF5X2NvbXByZXNzKHN0 cnVjdCBjb21wcmVzc19jdHggKmNjKQo+ICAgICAgPsKgIMKgewo+ICAgICAgPiAtwqAgwqAgwqBp ZiAoIWYyZnNfY29tcHJlc3NlZF9maWxlKGNjLT5pbm9kZSkpCj4gICAgICA+ICvCoCDCoCDCoGlm ICghZjJmc19uZWVkX2NvbXByZXNzX2RhdGEoY2MtPmlub2RlKSkKPiAgICAgID7CoCDCoCDCoCDC oCDCoCDCoCDCoCDCoHJldHVybiBmYWxzZTsKPiAgICAgID7CoCDCoCDCoCDCoGlmIChmMmZzX2lz X2F0b21pY19maWxlKGNjLT5pbm9kZSkpCj4gICAgICA+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBy ZXR1cm4gZmFsc2U7Cj4gICAgICA+IGRpZmYgLS1naXQgYS9mcy9mMmZzL2RhdGEuYyBiL2ZzL2Yy ZnMvZGF0YS5jCj4gICAgICA+IGluZGV4IGJlNGRhNTI2MDRlZC4uNDIyNTRkMzg1OWM3IDEwMDY0 NAo+ICAgICAgPiAtLS0gYS9mcy9mMmZzL2RhdGEuYwo+ICAgICAgPiArKysgYi9mcy9mMmZzL2Rh dGEuYwo+ICAgICAgPiBAQCAtMzE2NCw3ICszMTY0LDcgQEAgc3RhdGljIGlubGluZSBib29sIF9f c2hvdWxkX3NlcmlhbGl6ZV9pbyhzdHJ1Y3QgaW5vZGUgKmlub2RlLAo+ICAgICAgPsKgIMKgIMKg IMKgaWYgKElTX05PUVVPVEEoaW5vZGUpKQo+ICAgICAgPsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg cmV0dXJuIGZhbHNlOwo+ICAgICAgPgo+ICAgICAgPiAtwqAgwqAgwqBpZiAoZjJmc19jb21wcmVz c2VkX2ZpbGUoaW5vZGUpKQo+ICAgICAgPiArwqAgwqAgwqBpZiAoZjJmc19uZWVkX2NvbXByZXNz X2RhdGEoaW5vZGUpKQo+ICAgICAgPsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgcmV0dXJuIHRydWU7 Cj4gICAgICA+wqAgwqAgwqAgwqBpZiAod2JjLT5zeW5jX21vZGUgIT0gV0JfU1lOQ19BTEwpCj4g ICAgICA+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqByZXR1cm4gdHJ1ZTsKPiAgICAgID4gZGlmZiAt LWdpdCBhL2ZzL2YyZnMvZjJmcy5oIGIvZnMvZjJmcy9mMmZzLmgKPiAgICAgID4gaW5kZXggZTA4 MjY3NzlhMTAxLi45NGQxNmJkZTVlMjQgMTAwNjQ0Cj4gICAgICA+IC0tLSBhL2ZzL2YyZnMvZjJm cy5oCj4gICAgICA+ICsrKyBiL2ZzL2YyZnMvZjJmcy5oCj4gICAgICA+IEBAIC0xNDksNiArMTQ5 LDcgQEAgc3RydWN0IGYyZnNfbW91bnRfaW5mbyB7Cj4gICAgICA+wqAgwqAgwqAgwqB1bnNpZ25l ZCBjaGFyIGNvbXByZXNzX2FsZ29yaXRobTvCoCDCoCDCoCDCoC8qIGFsZ29yaXRobSB0eXBlICov Cj4gICAgICA+wqAgwqAgwqAgwqB1bnNpZ25lZCBjb21wcmVzc19sb2dfc2l6ZTvCoCDCoCDCoCDC oCDCoCDCoCDCoC8qIGNsdXN0ZXIgbG9nIHNpemUgKi8KPiAgICAgID7CoCDCoCDCoCDCoHVuc2ln bmVkIGNoYXIgY29tcHJlc3NfZXh0X2NudDvCoCDCoCDCoCDCoCDCoC8qIGV4dGVuc2lvbiBjb3Vu dCAqLwo+ICAgICAgPiArwqAgwqAgwqBpbnQgY29tcHJlc3NfbW9kZTvCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCAvKiBjb21wcmVzc2lvbiBtb2RlICovCj4gICAgICA+wqAgwqAgwqAg wqB1bnNpZ25lZCBjaGFyIGV4dGVuc2lvbnNbQ09NUFJFU1NfRVhUX05VTV1bRjJGU19FWFRFTlNJ T05fTEVOXTsgLyogZXh0ZW5zaW9ucyAqLwo+ICAgICAgPsKgIMKgfTsKPiAgICAgID4KPiAgICAg ID4gQEAgLTY3Nyw2ICs2NzgsNyBAQCBlbnVtIHsKPiAgICAgID7CoCDCoCDCoCDCoEZJX1ZFUklU WV9JTl9QUk9HUkVTUyzCoCAvKiBidWlsZGluZyBmcy12ZXJpdHkgTWVya2xlIHRyZWUgKi8KPiAg ICAgID7CoCDCoCDCoCDCoEZJX0NPTVBSRVNTRURfRklMRSzCoCDCoCDCoC8qIGluZGljYXRlIGZp bGUncyBkYXRhIGNhbiBiZSBjb21wcmVzc2VkICovCj4gICAgICA+wqAgwqAgwqAgwqBGSV9NTUFQ X0ZJTEUswqAgwqAgwqAgwqAgwqAgwqAvKiBpbmRpY2F0ZSBmaWxlIHdhcyBtbWFwcGVkICovCj4g ICAgICA+ICvCoCDCoCDCoEZJX0VOQUJMRV9DT01QUkVTUyzCoCDCoCDCoC8qIGVuYWJsZSBjb21w cmVzc2lvbiBpbiAidXNlciIgY29tcHJlc3Npb24gbW9kZSAqLwo+ICAgICAgPsKgIMKgIMKgIMKg RklfTUFYLMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgLyogbWF4IGZsYWcsIG5ldmVyIGJlIHVz ZWQgKi8KPiAgICAgID7CoCDCoH07Cj4gICAgICA+Cj4gICAgICA+IEBAIC0xMjQzLDYgKzEyNDUs MTggQEAgZW51bSBmc3luY19tb2RlIHsKPiAgICAgID7CoCDCoCDCoCDCoEZTWU5DX01PREVfTk9C QVJSSUVSLMKgIMKgLyogZnN5bmMgYmVoYXZlcyBub2JhcnJpZXIgYmFzZWQgb24gcG9zaXggKi8K PiAgICAgID7CoCDCoH07Cj4gICAgICA+Cj4gICAgICA+ICtlbnVtIHsKPiAgICAgID4gK8KgIMKg IMKgQ09NUFJfTU9ERV9GUyzCoCDCoCDCoCDCoCDCoCAvKgo+ICAgICAgPiArwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgKiBhdXRvbWF0aWNhbGx5IGNvbXByZXNz IGNvbXByZXNzaW9uCj4gICAgICA+ICvCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCAqIGVuYWJsZWQgZmlsZXMKPiAgICAgID4gK8KgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgICovCj4gICAgICA+ICvCoCDCoCDCoENPTVBSX01PREVf VVNFUizCoCDCoCDCoCDCoCAvKgo+ICAgICAgPiArwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgKiBhdXRvbWF0aWNhbCBjb21wcmVzc2lvbiBpcyBkaXNhYmxlZC4K PiAgICAgID4gK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgICog dXNlciBjYW4gY29udHJvbCB0aGUgZmlsZSBjb21wcmVzc2lvbgo+ICAgICAgPiArwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgKiB1c2luZyBpb2N0bHMKPiAgICAg ID4gK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgICovCj4gICAg ICA+ICt9Owo+ICAgICAgPiArCj4gICAgICA+wqAgwqAvKgo+ICAgICAgPsKgIMKgICogdGhpcyB2 YWx1ZSBpcyBzZXQgaW4gcGFnZSBhcyBhIHByaXZhdGUgZGF0YSB3aGljaCBpbmRpY2F0ZSB0aGF0 Cj4gICAgICA+wqAgwqAgKiB0aGUgcGFnZSBpcyBhdG9taWNhbGx5IHdyaXR0ZW4sIGFuZCBpdCBp cyBpbiBpbm1lbV9wYWdlcyBsaXN0Lgo+ICAgICAgPiBAQCAtMjc1Miw2ICsyNzY2LDIyIEBAIHN0 YXRpYyBpbmxpbmUgaW50IGYyZnNfY29tcHJlc3NlZF9maWxlKHN0cnVjdCBpbm9kZSAqaW5vZGUp Cj4gICAgICA+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBpc19pbm9kZV9mbGFnX3NldChpbm9kZSwg RklfQ09NUFJFU1NFRF9GSUxFKTsKPiAgICAgID7CoCDCoH0KPiAgICAgID4KPiAgICAgID4gK3N0 YXRpYyBpbmxpbmUgYm9vbCBmMmZzX25lZWRfY29tcHJlc3NfZGF0YShzdHJ1Y3QgaW5vZGUgKmlu b2RlKQo+ICAgICAgPiArewo+ICAgICAgPiArwqAgwqAgwqBpbnQgY29tcHJlc3NfbW9kZSA9IEYy RlNfT1BUSU9OKEYyRlNfSV9TQihpbm9kZSkpLmNvbXByZXNzX21vZGU7Cj4gICAgICA+ICsKPiAg ICAgID4gK8KgIMKgIMKgaWYgKCFmMmZzX2NvbXByZXNzZWRfZmlsZShpbm9kZSkpCj4gICAgICA+ ICvCoCDCoCDCoCDCoCDCoCDCoCDCoHJldHVybiBmYWxzZTsKPiAgICAgID4gKwo+ICAgICAgPiAr wqAgwqAgwqBpZiAoY29tcHJlc3NfbW9kZSA9PSBDT01QUl9NT0RFX0ZTKQo+ICAgICAgPiArwqAg wqAgwqAgwqAgwqAgwqAgwqByZXR1cm4gdHJ1ZTsKPiAgICAgID4gK8KgIMKgIMKgZWxzZSBpZiAo Y29tcHJlc3NfbW9kZSA9PSBDT01QUl9NT0RFX1VTRVIgJiYKPiAgICAgID4gK8KgIMKgIMKgIMKg IMKgIMKgIMKgIMKgIMKgIMKgIMKgaXNfaW5vZGVfZmxhZ19zZXQoaW5vZGUsIEZJX0VOQUJMRV9D T01QUkVTUykpCj4gICAgICA+ICvCoCDCoCDCoCDCoCDCoCDCoCDCoHJldHVybiB0cnVlOwo+ICAg ICAgPiArCj4gICAgICA+ICvCoCDCoCDCoHJldHVybiBmYWxzZTsKPiAgICAgID4gK30KPiAgICAg ID4gKwo+ICAgICAgPsKgIMKgc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQgYWRkcnNfcGVyX2lu b2RlKHN0cnVjdCBpbm9kZSAqaW5vZGUpCj4gICAgICA+wqAgwqB7Cj4gICAgICA+wqAgwqAgwqAg wqB1bnNpZ25lZCBpbnQgYWRkcnMgPSBDVVJfQUREUlNfUEVSX0lOT0RFKGlub2RlKSAtCj4gICAg ICA+IGRpZmYgLS1naXQgYS9mcy9mMmZzL3NlZ21lbnQuYyBiL2ZzL2YyZnMvc2VnbWVudC5jCj4g ICAgICA+IGluZGV4IDE1OTY1MDJmNzM3NS4uNWQ2YzlkNmYyMzdiIDEwMDY0NAo+ICAgICAgPiAt LS0gYS9mcy9mMmZzL3NlZ21lbnQuYwo+ICAgICAgPiArKysgYi9mcy9mMmZzL3NlZ21lbnQuYwo+ ICAgICAgPiBAQCAtMzI1NCw3ICszMjU0LDcgQEAgc3RhdGljIGludCBfX2dldF9zZWdtZW50X3R5 cGVfNihzdHJ1Y3QgZjJmc19pb19pbmZvICpmaW8pCj4gICAgICA+wqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqBlbHNlCj4gICAgICA+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqByZXR1cm4gQ1VSU0VHX0NPTERfREFUQTsKPiAgICAgID7CoCDC oCDCoCDCoCDCoCDCoCDCoCDCoH0KPiAgICAgID4gLcKgIMKgIMKgIMKgIMKgIMKgIMKgaWYgKGZp bGVfaXNfY29sZChpbm9kZSkgfHwgZjJmc19jb21wcmVzc2VkX2ZpbGUoaW5vZGUpKQo+ICAgICAg PiArwqAgwqAgwqAgwqAgwqAgwqAgwqBpZiAoZmlsZV9pc19jb2xkKGlub2RlKSB8fCBmMmZzX25l ZWRfY29tcHJlc3NfZGF0YShpbm9kZSkpCj4gCj4gICAgIENhbiB3ZSBrZWVwIGNvbnNpc3RlbnQg YWJvdXQgd3JpdHRpbmcgY29tcHJlc3NlZCBmaWxlIHRvIGNvZGUgZGF0YSBhcmVhPwo+IAo+ICAg ICBPciB0aGVyZSBpcyBvdGhlciBjb25jZXJuIGFib3V0IHRoaXM/Cj4gCj4gICAgIFRoYW5rcywK PiAKPiAgICAgID7CoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHJldHVybiBDVVJT RUdfQ09MRF9EQVRBOwo+ICAgICAgPsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgaWYgKGZpbGVfaXNf aG90KGlub2RlKSB8fAo+ICAgICAgPsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgaXNfaW5vZGVfZmxhZ19zZXQoaW5vZGUsIEZJX0hPVF9EQVRBKSB8fAo+ICAg ICAgPiBkaWZmIC0tZ2l0IGEvZnMvZjJmcy9zdXBlci5jIGIvZnMvZjJmcy9zdXBlci5jCj4gICAg ICA+IGluZGV4IDg3ZjdhNmU4NjM3MC4uY2M2ZWI0ZWQ4MGEyIDEwMDY0NAo+ICAgICAgPiAtLS0g YS9mcy9mMmZzL3N1cGVyLmMKPiAgICAgID4gKysrIGIvZnMvZjJmcy9zdXBlci5jCj4gICAgICA+ IEBAIC0xNDYsNiArMTQ2LDcgQEAgZW51bSB7Cj4gICAgICA+wqAgwqAgwqAgwqBPcHRfY29tcHJl c3NfYWxnb3JpdGhtLAo+ICAgICAgPsKgIMKgIMKgIMKgT3B0X2NvbXByZXNzX2xvZ19zaXplLAo+ ICAgICAgPsKgIMKgIMKgIMKgT3B0X2NvbXByZXNzX2V4dGVuc2lvbiwKPiAgICAgID4gK8KgIMKg IMKgT3B0X2NvbXByZXNzX21vZGUsCj4gICAgICA+wqAgwqAgwqAgwqBPcHRfYXRnYywKPiAgICAg ID7CoCDCoCDCoCDCoE9wdF9lcnIsCj4gICAgICA+wqAgwqB9Owo+ICAgICAgPiBAQCAtMjE0LDYg KzIxNSw3IEBAIHN0YXRpYyBtYXRjaF90YWJsZV90IGYyZnNfdG9rZW5zID0gewo+ICAgICAgPsKg IMKgIMKgIMKge09wdF9jb21wcmVzc19hbGdvcml0aG0sICJjb21wcmVzc19hbGdvcml0aG09JXMi fSwKPiAgICAgID7CoCDCoCDCoCDCoHtPcHRfY29tcHJlc3NfbG9nX3NpemUsICJjb21wcmVzc19s b2dfc2l6ZT0ldSJ9LAo+ICAgICAgPsKgIMKgIMKgIMKge09wdF9jb21wcmVzc19leHRlbnNpb24s ICJjb21wcmVzc19leHRlbnNpb249JXMifSwKPiAgICAgID4gK8KgIMKgIMKge09wdF9jb21wcmVz c19tb2RlLCAiY29tcHJlc3NfbW9kZT0lcyJ9LAo+ICAgICAgPsKgIMKgIMKgIMKge09wdF9hdGdj LCAiYXRnYyJ9LAo+ICAgICAgPsKgIMKgIMKgIMKge09wdF9lcnIsIE5VTEx9LAo+ICAgICAgPsKg IMKgfTsKPiAgICAgID4gQEAgLTkzNCwxMCArOTM2LDI1IEBAIHN0YXRpYyBpbnQgcGFyc2Vfb3B0 aW9ucyhzdHJ1Y3Qgc3VwZXJfYmxvY2sgKnNiLCBjaGFyICpvcHRpb25zLCBib29sIGlzX3JlbW91 bnQpCj4gICAgICA+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBGMkZTX09QVElP TihzYmkpLmNvbXByZXNzX2V4dF9jbnQrKzsKPiAgICAgID7CoCDCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoGtmcmVlKG5hbWUpOwo+ICAgICAgPsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKg IMKgIMKgIMKgIMKgYnJlYWs7Cj4gICAgICA+ICvCoCDCoCDCoCDCoCDCoCDCoCDCoGNhc2UgT3B0 X2NvbXByZXNzX21vZGU6Cj4gICAgICA+ICvCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDC oG5hbWUgPSBtYXRjaF9zdHJkdXAoJmFyZ3NbMF0pOwo+ICAgICAgPiArwqAgwqAgwqAgwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqBpZiAoIW5hbWUpCj4gICAgICA+ICvCoCDCoCDCoCDCoCDCoCDCoCDC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHJldHVybiAtRU5PTUVNOwo+ICAgICAgPiArwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBpZiAoIXN0cmNtcChuYW1lLCAiZnMiKSkgewo+ICAg ICAgPiArwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBGMkZTX09Q VElPTihzYmkpLmNvbXByZXNzX21vZGUgPSBDT01QUl9NT0RFX0ZTOwo+ICAgICAgPiArwqAgwqAg wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqB9IGVsc2UgaWYgKCFzdHJjbXAobmFtZSwgInVzZXIi KSkgewo+ICAgICAgPiArwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAg wqBGMkZTX09QVElPTihzYmkpLmNvbXByZXNzX21vZGUgPSBDT01QUl9NT0RFX1VTRVI7Cj4gICAg ICA+ICvCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoH0gZWxzZSB7Cj4gICAgICA+ICvC oCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoCDCoGtmcmVlKG5hbWUpOwo+ ICAgICAgPiArwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqByZXR1 cm4gLUVJTlZBTDsKPiAgICAgID4gK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgfQo+ ICAgICAgPiArwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBrZnJlZShuYW1lKTsKPiAg ICAgID4gK8KgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgYnJlYWs7Cj4gICAgICA+wqAg wqAjZWxzZQo+ICAgICAgPsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgY2FzZSBPcHRfY29tcHJlc3Nf YWxnb3JpdGhtOgo+ICAgICAgPsKgIMKgIMKgIMKgIMKgIMKgIMKgIMKgY2FzZSBPcHRfY29tcHJl c3NfbG9nX3NpemU6Cj4gICAgICA+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBjYXNlIE9wdF9jb21w cmVzc19leHRlbnNpb246Cj4gICAgICA+ICvCoCDCoCDCoCDCoCDCoCDCoCDCoGNhc2UgT3B0X2Nv bXByZXNzX21vZGU6Cj4gICAgICA+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBm MmZzX2luZm8oc2JpLCAiY29tcHJlc3Npb24gb3B0aW9ucyBub3Qgc3VwcG9ydGVkIik7Cj4gICAg ICA+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBicmVhazsKPiAgICAgID7CoCDC oCNlbmRpZgo+ICAgICAgPiBAQCAtMTUyMyw2ICsxNTQwLDExIEBAIHN0YXRpYyBpbmxpbmUgdm9p ZCBmMmZzX3Nob3dfY29tcHJlc3Nfb3B0aW9ucyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwKPiAgICAg ID7CoCDCoCDCoCDCoCDCoCDCoCDCoCDCoHNlcV9wcmludGYoc2VxLCAiLGNvbXByZXNzX2V4dGVu c2lvbj0lcyIsCj4gICAgICA+wqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqAgwqBGMkZT X09QVElPTihzYmkpLmV4dGVuc2lvbnNbaV0pOwo+ICAgICAgPsKgIMKgIMKgIMKgfQo+ICAgICAg PiArCj4gICAgICA+ICvCoCDCoCDCoGlmIChGMkZTX09QVElPTihzYmkpLmNvbXByZXNzX21vZGUg PT0gQ09NUFJfTU9ERV9GUykKPiAgICAgID4gK8KgIMKgIMKgIMKgIMKgIMKgIMKgc2VxX3ByaW50 ZihzZXEsICIsY29tcHJlc3NfbW9kZT0lcyIsICJmcyIpOwo+ICAgICAgPiArwqAgwqAgwqBlbHNl IGlmIChGMkZTX09QVElPTihzYmkpLmNvbXByZXNzX21vZGUgPT0gQ09NUFJfTU9ERV9VU0VSKQo+ ICAgICAgPiArwqAgwqAgwqAgwqAgwqAgwqAgwqBzZXFfcHJpbnRmKHNlcSwgIixjb21wcmVzc19t b2RlPSVzIiwgInVzZXIiKTsKPiAgICAgID7CoCDCoH0KPiAgICAgID4KPiAgICAgID7CoCDCoHN0 YXRpYyBpbnQgZjJmc19zaG93X29wdGlvbnMoc3RydWN0IHNlcV9maWxlICpzZXEsIHN0cnVjdCBk ZW50cnkgKnJvb3QpCj4gICAgICA+IEBAIC0xNjcyLDYgKzE2OTQsNyBAQCBzdGF0aWMgdm9pZCBk ZWZhdWx0X29wdGlvbnMoc3RydWN0IGYyZnNfc2JfaW5mbyAqc2JpKQo+ICAgICAgPsKgIMKgIMKg IMKgRjJGU19PUFRJT04oc2JpKS5jb21wcmVzc19hbGdvcml0aG0gPSBDT01QUkVTU19MWjQ7Cj4g ICAgICA+wqAgwqAgwqAgwqBGMkZTX09QVElPTihzYmkpLmNvbXByZXNzX2xvZ19zaXplID0gTUlO X0NPTVBSRVNTX0xPR19TSVpFOwo+ICAgICAgPsKgIMKgIMKgIMKgRjJGU19PUFRJT04oc2JpKS5j b21wcmVzc19leHRfY250ID0gMDsKPiAgICAgID4gK8KgIMKgIMKgRjJGU19PUFRJT04oc2JpKS5j b21wcmVzc19tb2RlID0gQ09NUFJfTU9ERV9GUzsKPiAgICAgID7CoCDCoCDCoCDCoEYyRlNfT1BU SU9OKHNiaSkuYmdnY19tb2RlID0gQkdHQ19NT0RFX09OOwo+ICAgICAgPgo+ICAgICAgPsKgIMKg IMKgIMKgc2JpLT5zYi0+c19mbGFncyAmPSB+U0JfSU5MSU5FQ1JZUFQ7Cj4gICAgICA+Cj4gCgoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXgtZjJm cy1kZXZlbCBtYWlsaW5nIGxpc3QKTGludXgtZjJmcy1kZXZlbEBsaXN0cy5zb3VyY2Vmb3JnZS5u ZXQKaHR0cHM6Ly9saXN0cy5zb3VyY2Vmb3JnZS5uZXQvbGlzdHMvbGlzdGluZm8vbGludXgtZjJm cy1kZXZlbAo=