From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ig0-f179.google.com ([209.85.213.179]:54946 "EHLO mail-ig0-f179.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750941AbaH1W25 (ORCPT ); Thu, 28 Aug 2014 18:28:57 -0400 Received: by mail-ig0-f179.google.com with SMTP id r2so1705121igi.0 for ; Thu, 28 Aug 2014 15:28:57 -0700 (PDT) Date: Thu, 28 Aug 2014 15:28:54 -0700 From: Iustin Pop Subject: Re: [PATCH xfstests] xfs: add tests for XFS_IOC_FSSETXATTR behaviour Message-ID: <20140828222854.GB29940@google.com> References: <20140718191314.GB27801@teal.hq.k1024.org> <1409199840-16907-1-git-send-email-iusty@k1024.org> <20140828101628.GS20518@dastard> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20140828101628.GS20518@dastard> Sender: fstests-owner@vger.kernel.org To: Dave Chinner Cc: Iustin Pop , xfs@oss.sgi.com, hch@infradead.org, fstests@vger.kernel.org List-ID: On Don, Aug 28, 2014 at 08:16:28 +1000, Dave Chinner wrote: > [cc fstests@vger.kernel.org] > > On Wed, Aug 27, 2014 at 09:24:00PM -0700, Iustin Pop wrote: > > Add two tests that check for correct behaviour of XFS_IOC_FSSETXATTR: > > > > - 307: check that extent size can always be set on a directory > > - 308: check that setting a non-zero extent size directly via the ioctl > > sets the expected flags (EXTSIZE and EXTSZINHERIT) > > > > Signed-off-by: Iustin Pop > > Minor stuff first: > > - xfstests patches should be sent to fstests@vger.kernel.org now. OK, will do. There was nothing written in the git repository's README, hence I chose what I thought best. > - can you pick the first unused numbers in the sequence for new > tests (xfs/032, xfs/051) so I don't have to renumber them before > applying them? Will do - this is what the 'new' script did (or tried to do, as it doesn't seem to work reliably). > - a patch per new test - it makes it easier to review and apply as i > don't have to split patches into multiple commits... Will do so when resending. > > diff --git a/tests/xfs/307 b/tests/xfs/307 > > new file mode 100755 > > index 0000000..e8f3576 > > --- /dev/null > > +++ b/tests/xfs/307 > > @@ -0,0 +1,87 @@ > > +#! /bin/bash > > +# FS QA Test No. 307 > > +# > > +# Test that setting extent size on directories work even for large > > +# directories. > > What is a "large directory"? Wouldn't it be better to describe the > test as "Determine whether the extent size hint can be set on > directories with allocated extents correctly"? Indeed that's better, I'll update. > > +# > > +#----------------------------------------------------------------------- > > +# Copyright (c) 2014 Google Inc. All Rights Reserved. > > Is that correct? It doesn't match the email address you sent this > from and I've never seen you post from a @google.com address. I > always like to check that the copyright assignment is correct in > situations like this... It is correct indeed (and thanks for double-checking). I prefer to send my interactions/contributions done not as part of my job using my personal address (hence I always wrote to xfs@ from the same address), but even in that case, the copyright remains with my employer. Just as a confirmation, sending this email from my @google.com address. > > +# real QA test starts here > > + > > +# Modify as appropriate. > > +_supported_fs xfs > > +_supported_os Linux > > +_require_test > > Not needed, doesn't use the test device. Ack. > > +_require_scratch > > + > > +_scratch_mkfs_xfs >/dev/null 2>&1 > > +_scratch_mount > > + > > +small=$SCRATCH_MNT/small > > +big=$SCRATCH_MNT/big > > + > > +# sanity check on a small directory > > +mkdir $small > > +# expect that an empty directory has no extents > > +xfs_bmap $small | grep -q "no extents" > > Better to use xfs_io directly and filter out $SCRATCH_MNT into the > golden output file like so: > > $XFS_IO_PROG -c "bmap" $small | _filter_scratch > > which will give: > > SCRATCH_MNT/small: no extents Oh, nice, thanks! > > +# and that we can set an extent size on it > > +xfs_io -c 'extsize 8m' $small > > $XFS_IO_PROG Ack. > > +# and finally check that the extent size update has taken place > > +(cd $SCRATCH_MNT; xfs_io -c 'extsize' small) > > $XFS_IO_PROG -c 'extsize' $small | _filter_scratch Ack. > > +# now create a 'big' (with extents) directory > > +mkdir $big > > +idx=1 > > +while xfs_bmap $big | grep -q "no extents"; do > > + touch $big/$idx > > + idx=$((idx+1)) > > + if [ "$idx" -gt 1048576 ]; then > > + # still no extents? giving up > > + echo "Can't make a directory to have extents even after 1M files" 1>&2 > > + exit > > + fi > > +done > > urk. largest inode size is 2kb, which means at most it can fit less > than 100 dirents in the inode before spilling to extent form. So > just do a loop that creates 1000 files - there's no need to > overengineer the test code. Will do. It's fine to still check that the directory does have extents, I hope? > > +# expect that we can set the extent size on $big as well > > +xfs_io -c 'extsize 8m' $big > > $XFS_IO_PROG Ack. > > +# and that it took effect > > +(cd $SCRATCH_MNT; xfs_io -c 'extsize' big) > > $XFS_IO_PROG -c 'extsize' $big | _filter_scratch Ack. > > +# success, all done > > +status=0 > > +exit > > diff --git a/tests/xfs/307.out b/tests/xfs/307.out > > new file mode 100644 > > index 0000000..f825525 > > --- /dev/null > > +++ b/tests/xfs/307.out > > @@ -0,0 +1,3 @@ > > +QA output created by 307 > > +[8388608] small > > +[8388608] big > > diff --git a/tests/xfs/308 b/tests/xfs/308 > > new file mode 100755 > > index 0000000..7b43836 > > --- /dev/null > > +++ b/tests/xfs/308 > > @@ -0,0 +1,98 @@ > > +#! /bin/bash > > +# FS QA Test No. 308 > > +# > > +# Test that setting extent size on files and directories (directly via > > +# ioctl and not via xfs_io) sets the correct flags. > > xfs_io uses the ioctl directly - there's no need to write a special > c program to do this, especially as.... > > > +touch $file > > +mkdir $dir > > + > > +cat > $cprog << EOF > > +#include > > +#include > > + > > +int main(int argc, char **argv) { > > + struct fsxattr fa; > > + int fd = open(argv[1], O_RDONLY); > > + if (fd < 0) { > > + perror("open"); > > + return 1; > > + } > > + fa.fsx_xflags = 0; > > + fa.fsx_extsize = 1048576 * 8; > > + int r = xfsctl(argv[1], fd, XFS_IOC_FSSETXATTR, &fa); > > .... that code is quite broken. Yes, it would work to set the > appropriate extent size flags with the kernel > changes you made, but that's not how this ioctl works. > > i.e. it will cause any flag bits that are set on the inode to be > cleared Good point… > and it's likely to fail on old kernels beacuse they have > very different behaviour to what your patch does. OK, that I didn't know. (Would you mind quickly explaining?) > IOWs, setting fsx_extsize without setting either XFS_XFLAG_EXTSIZE > or XFS_XFLAG_EXTSZINHERIT is bad practice. The kernel is left to > guess what you actually wanted to be done - the flags are supposed > to tell the kernel that the fsx_extsize value is meaningful, not the > other way around. See below. > FWIW, the xfs_io code is *exactly* what applications should be > doing to set the extent size or any other inode flag. i.e: > > 1. stat the fd to determine the type. > 2. populate the fsxattr structure with the existing inode flags > 3. change the flags/fields of the fsxattr structure appropriately > 4. set the new values to the inode. > > i.e, from io/open.c: > > static int > set_extsize(const char *path, int fd, long extsz) > { > struct fsxattr fsx; > struct stat64 stat; > > if (fstat64(fd, &stat) < 0) { > perror("fstat64"); > return 0; > } > if ((xfsctl(path, fd, XFS_IOC_FSGETXATTR, &fsx)) < 0) { > printf("%s: XFS_IOC_FSGETXATTR %s: %s\n", > progname, path, strerror(errno)); > return 0; > } > > if (S_ISREG(stat.st_mode)) { > fsx.fsx_xflags |= XFS_XFLAG_EXTSIZE; > } else if (S_ISDIR(stat.st_mode)) { > fsx.fsx_xflags |= XFS_XFLAG_EXTSZINHERIT; > } else { > printf(_("invalid target file type - file %s\n"), path); > return 0; > } > fsx.fsx_extsize = extsz; > > if ((xfsctl(path, fd, XFS_IOC_FSSETXATTR, &fsx)) < 0) { > printf("%s: XFS_IOC_FSSETXATTR %s: %s\n", > progname, path, strerror(errno)); > return 0; > } > > return 0; > } > > We have xfs_io precisely so that we don't have to maintain random > test code like this throughout xfstests - do it once, do it right, > use it everywhere. I totally agree that xfs_io is what people should use, but I disagree on the use of xfs_io in this particular test, let me explain why. With 3.16-rc1 at least, it is possible to set fsx_extsize to a non-zero value, without setting the flags (if you call the ioctl directly). Such an inode will be (unless I'm mistaken) flagged with a warning by xfs_repair, which means that it's an invalid inode state. So in my view, there's a kernel bug, in that it allows a user land application to put an inode into a "wrong" state. This particular test is designed to reproduce this kernel bug, so that the kernel fix can be verified that is indeed a fix. I can't use xfs_io here, because it will do the "right" thing - set the EXTSIZE/EXTSZINHERIT flags correctly; but this is a test that the kernel protects the inode invariants, not that xfs_io does so. Alternatively, you could say that it's perfectly fine to have a non-zero fsx_extsize, and that only when the flag is set it should be taken into account; but I don't think that is what the rest of the code expects today. So, I'm fine either way, but I would to fix this so that all the code agrees what the correct states for an inode are, and that the kernel prevents user space from violating this assumption via a (documented) ioctl. Just let me know which are the correct states. Thanks for the feedback, and for such a quick reply. iustin From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from relay.sgi.com (relay2.corp.sgi.com [137.38.102.29]) by oss.sgi.com (Postfix) with ESMTP id 9B2BC7F3F for ; Thu, 28 Aug 2014 17:29:05 -0500 (CDT) Received: from cuda.sgi.com (cuda2.sgi.com [192.48.176.25]) by relay2.corp.sgi.com (Postfix) with ESMTP id 7B1CD304039 for ; Thu, 28 Aug 2014 15:29:02 -0700 (PDT) Received: from mail-ie0-f179.google.com (mail-ie0-f179.google.com [209.85.223.179]) by cuda.sgi.com with ESMTP id ampxFvk3diivjXCE (version=TLSv1 cipher=RC4-SHA bits=128 verify=NO) for ; Thu, 28 Aug 2014 15:28:57 -0700 (PDT) Received: by mail-ie0-f179.google.com with SMTP id tr6so1811617ieb.38 for ; Thu, 28 Aug 2014 15:28:57 -0700 (PDT) Date: Thu, 28 Aug 2014 15:28:54 -0700 From: Iustin Pop Subject: Re: [PATCH xfstests] xfs: add tests for XFS_IOC_FSSETXATTR behaviour Message-ID: <20140828222854.GB29940@google.com> References: <20140718191314.GB27801@teal.hq.k1024.org> <1409199840-16907-1-git-send-email-iusty@k1024.org> <20140828101628.GS20518@dastard> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20140828101628.GS20518@dastard> List-Id: XFS Filesystem from SGI List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xfs-bounces@oss.sgi.com Sender: xfs-bounces@oss.sgi.com To: Dave Chinner Cc: hch@infradead.org, Iustin Pop , fstests@vger.kernel.org, xfs@oss.sgi.com T24gRG9uLCBBdWcgMjgsIDIwMTQgYXQgMDg6MTY6MjggKzEwMDAsIERhdmUgQ2hpbm5lciB3cm90 ZToKPiBbY2MgZnN0ZXN0c0B2Z2VyLmtlcm5lbC5vcmddCj4gCj4gT24gV2VkLCBBdWcgMjcsIDIw MTQgYXQgMDk6MjQ6MDBQTSAtMDcwMCwgSXVzdGluIFBvcCB3cm90ZToKPiA+IEFkZCB0d28gdGVz dHMgdGhhdCBjaGVjayBmb3IgY29ycmVjdCBiZWhhdmlvdXIgb2YgWEZTX0lPQ19GU1NFVFhBVFRS Ogo+ID4gCj4gPiAtIDMwNzogY2hlY2sgdGhhdCBleHRlbnQgc2l6ZSBjYW4gYWx3YXlzIGJlIHNl dCBvbiBhIGRpcmVjdG9yeQo+ID4gLSAzMDg6IGNoZWNrIHRoYXQgc2V0dGluZyBhIG5vbi16ZXJv IGV4dGVudCBzaXplIGRpcmVjdGx5IHZpYSB0aGUgaW9jdGwKPiA+ICAgc2V0cyB0aGUgZXhwZWN0 ZWQgZmxhZ3MgKEVYVFNJWkUgYW5kIEVYVFNaSU5IRVJJVCkKPiA+IAo+ID4gU2lnbmVkLW9mZi1i eTogSXVzdGluIFBvcCA8aXVzdHlAazEwMjQub3JnPgo+IAo+IE1pbm9yIHN0dWZmIGZpcnN0Ogo+ IAo+IC0geGZzdGVzdHMgcGF0Y2hlcyBzaG91bGQgYmUgc2VudCB0byBmc3Rlc3RzQHZnZXIua2Vy bmVsLm9yZyBub3cuCgpPSywgd2lsbCBkby4gVGhlcmUgd2FzIG5vdGhpbmcgd3JpdHRlbiBpbiB0 aGUgZ2l0IHJlcG9zaXRvcnkncyBSRUFETUUsCmhlbmNlIEkgY2hvc2Ugd2hhdCBJIHRob3VnaHQg YmVzdC4KCj4gLSBjYW4geW91IHBpY2sgdGhlIGZpcnN0IHVudXNlZCBudW1iZXJzIGluIHRoZSBz ZXF1ZW5jZSBmb3IgbmV3Cj4gICB0ZXN0cyAoeGZzLzAzMiwgeGZzLzA1MSkgc28gSSBkb24ndCBo YXZlIHRvIHJlbnVtYmVyIHRoZW0gYmVmb3JlCj4gICBhcHBseWluZyB0aGVtPwoKV2lsbCBkbyAt IHRoaXMgaXMgd2hhdCB0aGUgJ25ldycgc2NyaXB0IGRpZCAob3IgdHJpZWQgdG8gZG8sIGFzIGl0 CmRvZXNuJ3Qgc2VlbSB0byB3b3JrIHJlbGlhYmx5KS4KCj4gLSBhIHBhdGNoIHBlciBuZXcgdGVz dCAtIGl0IG1ha2VzIGl0IGVhc2llciB0byByZXZpZXcgYW5kIGFwcGx5IGFzIGkKPiAgIGRvbid0 IGhhdmUgdG8gc3BsaXQgcGF0Y2hlcyBpbnRvIG11bHRpcGxlIGNvbW1pdHMuLi4KCldpbGwgZG8g c28gd2hlbiByZXNlbmRpbmcuCgo+ID4gZGlmZiAtLWdpdCBhL3Rlc3RzL3hmcy8zMDcgYi90ZXN0 cy94ZnMvMzA3Cj4gPiBuZXcgZmlsZSBtb2RlIDEwMDc1NQo+ID4gaW5kZXggMDAwMDAwMC4uZThm MzU3Ngo+ID4gLS0tIC9kZXYvbnVsbAo+ID4gKysrIGIvdGVzdHMveGZzLzMwNwo+ID4gQEAgLTAs MCArMSw4NyBAQAo+ID4gKyMhIC9iaW4vYmFzaAo+ID4gKyMgRlMgUUEgVGVzdCBOby4gMzA3Cj4g PiArIwo+ID4gKyMgVGVzdCB0aGF0IHNldHRpbmcgZXh0ZW50IHNpemUgb24gZGlyZWN0b3JpZXMg d29yayBldmVuIGZvciBsYXJnZQo+ID4gKyMgZGlyZWN0b3JpZXMuCj4gCj4gV2hhdCBpcyBhICJs YXJnZSBkaXJlY3RvcnkiPyBXb3VsZG4ndCBpdCBiZSBiZXR0ZXIgdG8gZGVzY3JpYmUgdGhlCj4g dGVzdCBhcyAiRGV0ZXJtaW5lIHdoZXRoZXIgdGhlIGV4dGVudCBzaXplIGhpbnQgY2FuIGJlIHNl dCBvbgo+IGRpcmVjdG9yaWVzIHdpdGggYWxsb2NhdGVkIGV4dGVudHMgY29ycmVjdGx5Ij8KCklu ZGVlZCB0aGF0J3MgYmV0dGVyLCBJJ2xsIHVwZGF0ZS4KCj4gPiArIwo+ID4gKyMtLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQo+ID4gKyMgQ29weXJpZ2h0IChjKSAyMDE0IEdvb2dsZSBJbmMuICBBbGwgUmlnaHRzIFJl c2VydmVkLgo+IAo+IElzIHRoYXQgY29ycmVjdD8gSXQgZG9lc24ndCBtYXRjaCB0aGUgZW1haWwg YWRkcmVzcyB5b3Ugc2VudCB0aGlzCj4gZnJvbSBhbmQgSSd2ZSBuZXZlciBzZWVuIHlvdSBwb3N0 IGZyb20gYSBAZ29vZ2xlLmNvbSBhZGRyZXNzLiAgSQo+IGFsd2F5cyBsaWtlIHRvIGNoZWNrIHRo YXQgdGhlIGNvcHlyaWdodCBhc3NpZ25tZW50IGlzIGNvcnJlY3QgaW4KPiBzaXR1YXRpb25zIGxp a2UgdGhpcy4uLgoKSXQgaXMgY29ycmVjdCBpbmRlZWQgKGFuZCB0aGFua3MgZm9yIGRvdWJsZS1j aGVja2luZykuIEkgcHJlZmVyIHRvIHNlbmQKbXkgaW50ZXJhY3Rpb25zL2NvbnRyaWJ1dGlvbnMg ZG9uZSBub3QgYXMgcGFydCBvZiBteSBqb2IgdXNpbmcgbXkKcGVyc29uYWwgYWRkcmVzcyAoaGVu Y2UgSSBhbHdheXMgd3JvdGUgdG8geGZzQCBmcm9tIHRoZSBzYW1lIGFkZHJlc3MpLApidXQgZXZl biBpbiB0aGF0IGNhc2UsIHRoZSBjb3B5cmlnaHQgcmVtYWlucyB3aXRoIG15IGVtcGxveWVyLgoK SnVzdCBhcyBhIGNvbmZpcm1hdGlvbiwgc2VuZGluZyB0aGlzIGVtYWlsIGZyb20gbXkgQGdvb2ds ZS5jb20gYWRkcmVzcy4KCj4gPiArIyByZWFsIFFBIHRlc3Qgc3RhcnRzIGhlcmUKPiA+ICsKPiA+ ICsjIE1vZGlmeSBhcyBhcHByb3ByaWF0ZS4KPiA+ICtfc3VwcG9ydGVkX2ZzIHhmcwo+ID4gK19z dXBwb3J0ZWRfb3MgTGludXgKPiA+ICtfcmVxdWlyZV90ZXN0Cj4gCj4gTm90IG5lZWRlZCwgZG9l c24ndCB1c2UgdGhlIHRlc3QgZGV2aWNlLgoKQWNrLgoKPiA+ICtfcmVxdWlyZV9zY3JhdGNoCj4g PiArCj4gPiArX3NjcmF0Y2hfbWtmc194ZnMgPi9kZXYvbnVsbCAyPiYxCj4gPiArX3NjcmF0Y2hf bW91bnQKPiA+ICsKPiA+ICtzbWFsbD0kU0NSQVRDSF9NTlQvc21hbGwKPiA+ICtiaWc9JFNDUkFU Q0hfTU5UL2JpZwo+ID4gKwo+ID4gKyMgc2FuaXR5IGNoZWNrIG9uIGEgc21hbGwgZGlyZWN0b3J5 Cj4gPiArbWtkaXIgJHNtYWxsCj4gPiArIyBleHBlY3QgdGhhdCBhbiBlbXB0eSBkaXJlY3Rvcnkg aGFzIG5vIGV4dGVudHMKPiA+ICt4ZnNfYm1hcCAkc21hbGwgfCBncmVwIC1xICJubyBleHRlbnRz Igo+IAo+IEJldHRlciB0byB1c2UgeGZzX2lvIGRpcmVjdGx5IGFuZCBmaWx0ZXIgb3V0ICRTQ1JB VENIX01OVCBpbnRvIHRoZQo+IGdvbGRlbiBvdXRwdXQgZmlsZSBsaWtlIHNvOgo+IAo+ICRYRlNf SU9fUFJPRyAtYyAiYm1hcCIgJHNtYWxsIHwgX2ZpbHRlcl9zY3JhdGNoCj4gCj4gd2hpY2ggd2ls bCBnaXZlOgo+IAo+IFNDUkFUQ0hfTU5UL3NtYWxsOiBubyBleHRlbnRzCgpPaCwgbmljZSwgdGhh bmtzIQoKPiA+ICsjIGFuZCB0aGF0IHdlIGNhbiBzZXQgYW4gZXh0ZW50IHNpemUgb24gaXQKPiA+ ICt4ZnNfaW8gLWMgJ2V4dHNpemUgOG0nICRzbWFsbAo+IAo+ICRYRlNfSU9fUFJPRwoKQWNrLgoK PiA+ICsjIGFuZCBmaW5hbGx5IGNoZWNrIHRoYXQgdGhlIGV4dGVudCBzaXplIHVwZGF0ZSBoYXMg dGFrZW4gcGxhY2UKPiA+ICsoY2QgJFNDUkFUQ0hfTU5UOyB4ZnNfaW8gLWMgJ2V4dHNpemUnIHNt YWxsKQo+IAo+ICRYRlNfSU9fUFJPRyAtYyAnZXh0c2l6ZScgJHNtYWxsIHwgX2ZpbHRlcl9zY3Jh dGNoCgpBY2suCgo+ID4gKyMgbm93IGNyZWF0ZSBhICdiaWcnICh3aXRoIGV4dGVudHMpIGRpcmVj dG9yeQo+ID4gK21rZGlyICRiaWcKPiA+ICtpZHg9MQo+ID4gK3doaWxlIHhmc19ibWFwICRiaWcg fCBncmVwIC1xICJubyBleHRlbnRzIjsgZG8KPiA+ICsJdG91Y2ggJGJpZy8kaWR4Cj4gPiArCWlk eD0kKChpZHgrMSkpCj4gPiArCWlmIFsgIiRpZHgiIC1ndCAxMDQ4NTc2IF07IHRoZW4KPiA+ICsJ CSMgc3RpbGwgbm8gZXh0ZW50cz8gZ2l2aW5nIHVwCj4gPiArCQllY2hvICJDYW4ndCBtYWtlIGEg ZGlyZWN0b3J5IHRvIGhhdmUgZXh0ZW50cyBldmVuIGFmdGVyIDFNIGZpbGVzIiAxPiYyCj4gPiAr CQlleGl0Cj4gPiArCWZpCj4gPiArZG9uZQo+IAo+IHVyay4gbGFyZ2VzdCBpbm9kZSBzaXplIGlz IDJrYiwgd2hpY2ggbWVhbnMgYXQgbW9zdCBpdCBjYW4gZml0IGxlc3MKPiB0aGFuIDEwMCBkaXJl bnRzIGluIHRoZSBpbm9kZSBiZWZvcmUgc3BpbGxpbmcgdG8gZXh0ZW50IGZvcm0uIFNvCj4ganVz dCBkbyBhIGxvb3AgdGhhdCBjcmVhdGVzIDEwMDAgZmlsZXMgLSB0aGVyZSdzIG5vIG5lZWQgdG8K PiBvdmVyZW5naW5lZXIgdGhlIHRlc3QgY29kZS4KCldpbGwgZG8uICBJdCdzIGZpbmUgdG8gc3Rp bGwgY2hlY2sgdGhhdCB0aGUgZGlyZWN0b3J5IGRvZXMgaGF2ZSBleHRlbnRzLApJIGhvcGU/Cgo+ ID4gKyMgZXhwZWN0IHRoYXQgd2UgY2FuIHNldCB0aGUgZXh0ZW50IHNpemUgb24gJGJpZyBhcyB3 ZWxsCj4gPiAreGZzX2lvIC1jICdleHRzaXplIDhtJyAkYmlnCj4gCj4gJFhGU19JT19QUk9HCgpB Y2suCgo+ID4gKyMgYW5kIHRoYXQgaXQgdG9vayBlZmZlY3QKPiA+ICsoY2QgJFNDUkFUQ0hfTU5U OyB4ZnNfaW8gLWMgJ2V4dHNpemUnIGJpZykKPiAKPiAkWEZTX0lPX1BST0cgLWMgJ2V4dHNpemUn ICRiaWcgfCBfZmlsdGVyX3NjcmF0Y2gKCkFjay4KCj4gPiArIyBzdWNjZXNzLCBhbGwgZG9uZQo+ ID4gK3N0YXR1cz0wCj4gPiArZXhpdAo+ID4gZGlmZiAtLWdpdCBhL3Rlc3RzL3hmcy8zMDcub3V0 IGIvdGVzdHMveGZzLzMwNy5vdXQKPiA+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gPiBpbmRleCAw MDAwMDAwLi5mODI1NTI1Cj4gPiAtLS0gL2Rldi9udWxsCj4gPiArKysgYi90ZXN0cy94ZnMvMzA3 Lm91dAo+ID4gQEAgLTAsMCArMSwzIEBACj4gPiArUUEgb3V0cHV0IGNyZWF0ZWQgYnkgMzA3Cj4g PiArWzgzODg2MDhdIHNtYWxsCj4gPiArWzgzODg2MDhdIGJpZwo+ID4gZGlmZiAtLWdpdCBhL3Rl c3RzL3hmcy8zMDggYi90ZXN0cy94ZnMvMzA4Cj4gPiBuZXcgZmlsZSBtb2RlIDEwMDc1NQo+ID4g aW5kZXggMDAwMDAwMC4uN2I0MzgzNgo+ID4gLS0tIC9kZXYvbnVsbAo+ID4gKysrIGIvdGVzdHMv eGZzLzMwOAo+ID4gQEAgLTAsMCArMSw5OCBAQAo+ID4gKyMhIC9iaW4vYmFzaAo+ID4gKyMgRlMg UUEgVGVzdCBOby4gMzA4Cj4gPiArIwo+ID4gKyMgVGVzdCB0aGF0IHNldHRpbmcgZXh0ZW50IHNp emUgb24gZmlsZXMgYW5kIGRpcmVjdG9yaWVzIChkaXJlY3RseSB2aWEKPiA+ICsjIGlvY3RsIGFu ZCBub3QgdmlhIHhmc19pbykgc2V0cyB0aGUgY29ycmVjdCBmbGFncy4KPiAKPiB4ZnNfaW8gdXNl cyB0aGUgaW9jdGwgZGlyZWN0bHkgLSB0aGVyZSdzIG5vIG5lZWQgdG8gd3JpdGUgYSBzcGVjaWFs Cj4gYyBwcm9ncmFtIHRvIGRvIHRoaXMsIGVzcGVjaWFsbHkgYXMuLi4uCj4gCj4gPiArdG91Y2gg JGZpbGUKPiA+ICtta2RpciAkZGlyCj4gPiArCj4gPiArY2F0ID4gJGNwcm9nIDw8IEVPRgo+ID4g KyNpbmNsdWRlIDxzdGRpby5oPgo+ID4gKyNpbmNsdWRlIDx4ZnMveGZzLmg+Cj4gPiArCj4gPiAr aW50IG1haW4oaW50IGFyZ2MsIGNoYXIgKiphcmd2KSB7Cj4gPiArCXN0cnVjdCBmc3hhdHRyIGZh Owo+ID4gKwlpbnQgZmQgPSBvcGVuKGFyZ3ZbMV0sIE9fUkRPTkxZKTsKPiA+ICsJaWYgKGZkIDwg MCkgewo+ID4gKwkJcGVycm9yKCJvcGVuIik7Cj4gPiArCQlyZXR1cm4gMTsKPiA+ICsJfQo+ID4g KwlmYS5mc3hfeGZsYWdzID0gMDsKPiA+ICsJZmEuZnN4X2V4dHNpemUgPSAxMDQ4NTc2ICogODsK PiA+ICsJaW50IHIgPSB4ZnNjdGwoYXJndlsxXSwgZmQsIFhGU19JT0NfRlNTRVRYQVRUUiwgJmZh KTsKPiAKPiAuLi4uIHRoYXQgY29kZSBpcyBxdWl0ZSBicm9rZW4uIFllcywgaXQgd291bGQgd29y ayB0byBzZXQgdGhlCj4gYXBwcm9wcmlhdGUgZXh0ZW50IHNpemUgZmxhZ3Mgd2l0aCB0aGUga2Vy bmVsCj4gY2hhbmdlcyB5b3UgbWFkZSwgYnV0IHRoYXQncyBub3QgaG93IHRoaXMgaW9jdGwgd29y a3MuCj4gCj4gaS5lLiBpdCB3aWxsIGNhdXNlIGFueSBmbGFnIGJpdHMgdGhhdCBhcmUgc2V0IG9u IHRoZSBpbm9kZSB0byBiZQo+IGNsZWFyZWQKCkdvb2QgcG9pbnTigKYKCj4gYW5kIGl0J3MgbGlr ZWx5IHRvIGZhaWwgb24gb2xkIGtlcm5lbHMgYmVhY3VzZSB0aGV5IGhhdmUKPiB2ZXJ5IGRpZmZl cmVudCBiZWhhdmlvdXIgdG8gd2hhdCB5b3VyIHBhdGNoIGRvZXMuCgpPSywgdGhhdCBJIGRpZG4n dCBrbm93LiAoV291bGQgeW91IG1pbmQgcXVpY2tseSBleHBsYWluaW5nPykKCj4gSU9Xcywgc2V0 dGluZyBmc3hfZXh0c2l6ZSB3aXRob3V0IHNldHRpbmcgZWl0aGVyIFhGU19YRkxBR19FWFRTSVpF Cj4gb3IgWEZTX1hGTEFHX0VYVFNaSU5IRVJJVCBpcyBiYWQgcHJhY3RpY2UuIFRoZSBrZXJuZWwg aXMgbGVmdCB0bwo+IGd1ZXNzIHdoYXQgeW91IGFjdHVhbGx5IHdhbnRlZCB0byBiZSBkb25lIC0g dGhlIGZsYWdzIGFyZSBzdXBwb3NlZAo+IHRvIHRlbGwgdGhlIGtlcm5lbCB0aGF0IHRoZSBmc3hf ZXh0c2l6ZSB2YWx1ZSBpcyBtZWFuaW5nZnVsLCBub3QgdGhlCj4gb3RoZXIgd2F5IGFyb3VuZC4K ClNlZSBiZWxvdy4KCj4gRldJVywgdGhlIHhmc19pbyBjb2RlIGlzICpleGFjdGx5KiB3aGF0IGFw cGxpY2F0aW9ucyBzaG91bGQgYmUKPiBkb2luZyB0byBzZXQgdGhlIGV4dGVudCBzaXplIG9yIGFu eSBvdGhlciBpbm9kZSBmbGFnLiBpLmU6Cj4gCj4gMS4gc3RhdCB0aGUgZmQgdG8gZGV0ZXJtaW5l IHRoZSB0eXBlLgo+IDIuIHBvcHVsYXRlIHRoZSBmc3hhdHRyIHN0cnVjdHVyZSB3aXRoIHRoZSBl eGlzdGluZyBpbm9kZSBmbGFncwo+IDMuIGNoYW5nZSB0aGUgZmxhZ3MvZmllbGRzIG9mIHRoZSBm c3hhdHRyIHN0cnVjdHVyZSBhcHByb3ByaWF0ZWx5Cj4gNC4gc2V0IHRoZSBuZXcgdmFsdWVzIHRv IHRoZSBpbm9kZS4KPiAKPiBpLmUsIGZyb20gaW8vb3Blbi5jOgo+IAo+IHN0YXRpYyBpbnQKPiBz ZXRfZXh0c2l6ZShjb25zdCBjaGFyICpwYXRoLCBpbnQgZmQsIGxvbmcgZXh0c3opCj4gewo+ICAg ICAgICAgc3RydWN0IGZzeGF0dHIgIGZzeDsKPiAgICAgICAgIHN0cnVjdCBzdGF0NjQgICBzdGF0 Owo+IAo+ICAgICAgICAgaWYgKGZzdGF0NjQoZmQsICZzdGF0KSA8IDApIHsKPiAgICAgICAgICAg ICAgICAgcGVycm9yKCJmc3RhdDY0Iik7Cj4gICAgICAgICAgICAgICAgIHJldHVybiAwOwo+ICAg ICAgICAgfQo+ICAgICAgICAgaWYgKCh4ZnNjdGwocGF0aCwgZmQsIFhGU19JT0NfRlNHRVRYQVRU UiwgJmZzeCkpIDwgMCkgewo+ICAgICAgICAgICAgICAgICBwcmludGYoIiVzOiBYRlNfSU9DX0ZT R0VUWEFUVFIgJXM6ICVzXG4iLAo+ICAgICAgICAgICAgICAgICAgICAgICAgIHByb2duYW1lLCBw YXRoLCBzdHJlcnJvcihlcnJubykpOwo+ICAgICAgICAgICAgICAgICByZXR1cm4gMDsKPiAgICAg ICAgIH0KPiAKPiAgICAgICAgIGlmIChTX0lTUkVHKHN0YXQuc3RfbW9kZSkpIHsKPiAgICAgICAg ICAgICAgICAgZnN4LmZzeF94ZmxhZ3MgfD0gWEZTX1hGTEFHX0VYVFNJWkU7Cj4gICAgICAgICB9 IGVsc2UgaWYgKFNfSVNESVIoc3RhdC5zdF9tb2RlKSkgewo+ICAgICAgICAgICAgICAgICBmc3gu ZnN4X3hmbGFncyB8PSBYRlNfWEZMQUdfRVhUU1pJTkhFUklUOwo+ICAgICAgICAgfSBlbHNlIHsK PiAgICAgICAgICAgICAgICAgcHJpbnRmKF8oImludmFsaWQgdGFyZ2V0IGZpbGUgdHlwZSAtIGZp bGUgJXNcbiIpLCBwYXRoKTsKPiAgICAgICAgICAgICAgICAgcmV0dXJuIDA7Cj4gICAgICAgICB9 Cj4gICAgICAgICBmc3guZnN4X2V4dHNpemUgPSBleHRzejsKPiAKPiAgICAgICAgIGlmICgoeGZz Y3RsKHBhdGgsIGZkLCBYRlNfSU9DX0ZTU0VUWEFUVFIsICZmc3gpKSA8IDApIHsKPiAgICAgICAg ICAgICAgICAgcHJpbnRmKCIlczogWEZTX0lPQ19GU1NFVFhBVFRSICVzOiAlc1xuIiwKPiAgICAg ICAgICAgICAgICAgICAgICAgICBwcm9nbmFtZSwgcGF0aCwgc3RyZXJyb3IoZXJybm8pKTsKPiAg ICAgICAgICAgICAgICAgcmV0dXJuIDA7Cj4gICAgICAgICB9Cj4gCj4gICAgICAgICByZXR1cm4g MDsKPiB9Cj4gCj4gV2UgaGF2ZSB4ZnNfaW8gcHJlY2lzZWx5IHNvIHRoYXQgd2UgZG9uJ3QgaGF2 ZSB0byBtYWludGFpbiByYW5kb20KPiB0ZXN0IGNvZGUgbGlrZSB0aGlzIHRocm91Z2hvdXQgeGZz dGVzdHMgLSBkbyBpdCBvbmNlLCBkbyBpdCByaWdodCwKPiB1c2UgaXQgZXZlcnl3aGVyZS4KCkkg dG90YWxseSBhZ3JlZSB0aGF0IHhmc19pbyBpcyB3aGF0IHBlb3BsZSBzaG91bGQgdXNlLCBidXQg SSBkaXNhZ3JlZSBvbgp0aGUgdXNlIG9mIHhmc19pbyBpbiB0aGlzIHBhcnRpY3VsYXIgdGVzdCwg bGV0IG1lIGV4cGxhaW4gd2h5LgoKV2l0aCAzLjE2LXJjMSBhdCBsZWFzdCwgaXQgaXMgcG9zc2li bGUgdG8gc2V0IGZzeF9leHRzaXplIHRvIGEgbm9uLXplcm8KdmFsdWUsIHdpdGhvdXQgc2V0dGlu ZyB0aGUgZmxhZ3MgKGlmIHlvdSBjYWxsIHRoZSBpb2N0bCBkaXJlY3RseSkuIFN1Y2gKYW4gaW5v ZGUgIHdpbGwgYmUgKHVubGVzcyBJJ20gbWlzdGFrZW4pIGZsYWdnZWQgd2l0aCBhIHdhcm5pbmcg YnkKeGZzX3JlcGFpciwgd2hpY2ggbWVhbnMgdGhhdCBpdCdzIGFuIGludmFsaWQgaW5vZGUgc3Rh dGUuCgpTbyBpbiBteSB2aWV3LCB0aGVyZSdzIGEga2VybmVsIGJ1ZywgaW4gdGhhdCBpdCBhbGxv d3MgYSB1c2VyIGxhbmQKYXBwbGljYXRpb24gdG8gcHV0IGFuIGlub2RlIGludG8gYSAid3Jvbmci IHN0YXRlLiBUaGlzIHBhcnRpY3VsYXIgdGVzdAppcyBkZXNpZ25lZCB0byByZXByb2R1Y2UgdGhp cyBrZXJuZWwgYnVnLCBzbyB0aGF0IHRoZSBrZXJuZWwgZml4IGNhbiBiZQp2ZXJpZmllZCB0aGF0 IGlzIGluZGVlZCBhIGZpeC4KCkkgY2FuJ3QgdXNlIHhmc19pbyBoZXJlLCBiZWNhdXNlIGl0IHdp bGwgZG8gdGhlICJyaWdodCIgdGhpbmcgLSBzZXQgdGhlCkVYVFNJWkUvRVhUU1pJTkhFUklUIGZs YWdzIGNvcnJlY3RseTsgYnV0IHRoaXMgaXMgYSB0ZXN0IHRoYXQgdGhlIGtlcm5lbApwcm90ZWN0 cyB0aGUgaW5vZGUgaW52YXJpYW50cywgbm90IHRoYXQgeGZzX2lvIGRvZXMgc28uCgpBbHRlcm5h dGl2ZWx5LCB5b3UgY291bGQgc2F5IHRoYXQgaXQncyBwZXJmZWN0bHkgZmluZSB0byBoYXZlIGEg bm9uLXplcm8KZnN4X2V4dHNpemUsIGFuZCB0aGF0IG9ubHkgd2hlbiB0aGUgZmxhZyBpcyBzZXQg aXQgc2hvdWxkIGJlIHRha2VuIGludG8KYWNjb3VudDsgYnV0IEkgZG9uJ3QgdGhpbmsgdGhhdCBp cyB3aGF0IHRoZSByZXN0IG9mIHRoZSBjb2RlIGV4cGVjdHMKdG9kYXkuCgpTbywgSSdtIGZpbmUg ZWl0aGVyIHdheSwgYnV0IEkgd291bGQgdG8gZml4IHRoaXMgc28gdGhhdCBhbGwgdGhlIGNvZGUK YWdyZWVzIHdoYXQgdGhlIGNvcnJlY3Qgc3RhdGVzIGZvciBhbiBpbm9kZSBhcmUsIGFuZCB0aGF0 IHRoZSBrZXJuZWwKcHJldmVudHMgdXNlciBzcGFjZSBmcm9tIHZpb2xhdGluZyB0aGlzIGFzc3Vt cHRpb24gdmlhIGEgKGRvY3VtZW50ZWQpCmlvY3RsLiBKdXN0IGxldCBtZSBrbm93IHdoaWNoIGFy ZSB0aGUgY29ycmVjdCBzdGF0ZXMuCgpUaGFua3MgZm9yIHRoZSBmZWVkYmFjaywgYW5kIGZvciBz dWNoIGEgcXVpY2sgcmVwbHkuCgppdXN0aW4KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCnhmcyBtYWlsaW5nIGxpc3QKeGZzQG9zcy5zZ2kuY29tCmh0dHA6 Ly9vc3Muc2dpLmNvbS9tYWlsbWFuL2xpc3RpbmZvL3hmcwo=