From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755979AbcB0CSS (ORCPT ); Fri, 26 Feb 2016 21:18:18 -0500 Received: from mail-wm0-f49.google.com ([74.125.82.49]:34165 "EHLO mail-wm0-f49.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755825AbcB0CSR (ORCPT ); Fri, 26 Feb 2016 21:18:17 -0500 MIME-Version: 1.0 In-Reply-To: <1456520410-28195-1-git-send-email-gustavo@padovan.org> References: <1456511507-2534-4-git-send-email-gustavo@padovan.org> <1456520410-28195-1-git-send-email-gustavo@padovan.org> Date: Sat, 27 Feb 2016 02:18:15 +0000 Message-ID: Subject: Re: [PATCH] staging/android: refactor SYNC_IOC_FILE_INFO From: Emil Velikov To: Gustavo Padovan Cc: Greg Kroah-Hartman , devel@driverdev.osuosl.org, Daniel Stone , Daniel Vetter , Riley Andrews , ML dri-devel , "Linux-Kernel@Vger. Kernel. Org" , =?UTF-8?B?QXJ2ZSBIasO4bm5ldsOlZw==?= , Gustavo Padovan , John Harrison Content-Type: text/plain; charset=UTF-8 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Gustavo, On 26 February 2016 at 21:00, Gustavo Padovan wrote: > From: Gustavo Padovan > > Change SYNC_IOC_FILE_INFO behaviour to avoid future API breaks and > optimize buffer allocation. In the new approach the ioctl needs to be called > twice to retrieve the array of fence_infos pointed by info->sync_fence_info. > I might have misunderstood things but I no one says you "need" to call it twice - you can just request a "random" amount of fences_info. Upon return (if num_fences was non zero) it will report how many fence_info were retrieved. > The first call should pass num_fences = 0, the kernel will then fill > info->num_fences. Userspace receives back the number of fences and > allocates a buffer size num_fences * sizeof(struct sync_fence_info) on > info->sync_fence_info. > > It then call the ioctl again passing num_fences received in info->num_fences. "calls" > The kernel checks if info->num_fences > 0 and if yes it fill > info->sync_fence_info with an array containing all fence_infos. > The above sentence sounds a bit strange. I believe you meant to say something like "Then the kernel fills the fence_infos array with data. One should read back the actual number from info->num_fences." ? > info->len now represents the length of the buffer sync_fence_info points > to. Now that I think about it, I'm wondering if there'll be a case where len != info->num_fences * sizeof(struct sync_file_info). If that's not possible one could just drop len and nicely simplify things. > Also, info->sync_fence_info was converted to __u64 pointer. > ... pointer to prevent 32bit compatibility issues. > An example userspace code would be: > > struct sync_file_info *info; > int err, size, num_fences; > > info = malloc(sizeof(*info)); > > memset(info, 0, sizeof(*info)); > > err = ioctl(fd, SYNC_IOC_FILE_INFO, info); > num_fences = info->num_fences; > > if (num_fences) { > memset(info, 0, sizeof(*info)); > size = sizeof(struct sync_fence_info) * num_fences; > info->len = size; > info->num_fences = num_fences; > info->sync_fence_info = (uint64_t) calloc(num_fences, > sizeof(struct sync_fence_info)); > > err = ioctl(fd, SYNC_IOC_FILE_INFO, info); > } > > v2: fix fence_info memory leak > > Signed-off-by: Gustavo Padovan > --- > drivers/staging/android/sync.c | 52 +++++++++++++++++++++++++++++-------- > drivers/staging/android/uapi/sync.h | 9 +++---- > 2 files changed, 45 insertions(+), 16 deletions(-) > > diff --git a/drivers/staging/android/sync.c b/drivers/staging/android/sync.c > index dc5f382..2379f23 100644 > --- a/drivers/staging/android/sync.c > +++ b/drivers/staging/android/sync.c > @@ -502,21 +502,22 @@ static int sync_fill_fence_info(struct fence *fence, void *data, int size) > static long sync_file_ioctl_fence_info(struct sync_file *sync_file, > unsigned long arg) > { > - struct sync_file_info *info; > + struct sync_file_info in, *info; > + struct sync_fence_info *fence_info = NULL; > __u32 size; > __u32 len = 0; > int ret, i; > > - if (copy_from_user(&size, (void __user *)arg, sizeof(size))) > + if (copy_from_user(&in, (void __user *)arg, sizeof(*info))) s/*info/in/ > return -EFAULT; > > - if (size < sizeof(struct sync_file_info)) > - return -EINVAL; > + if (in.status || strcmp(in.name, "\0")) Afaict these two are outputs, so we should be checking them ? > + return -EFAULT; > As originally, input validation should return -EINVAL on error. > - if (size > 4096) > - size = 4096; > + if (in.num_fences && !in.sync_fence_info) > + return -EFAULT; > Ditto. > - info = kzalloc(size, GFP_KERNEL); > + info = kzalloc(sizeof(*info), GFP_KERNEL); > if (!info) > return -ENOMEM; > > @@ -525,14 +526,33 @@ static long sync_file_ioctl_fence_info(struct sync_file *sync_file, > if (info->status >= 0) > info->status = !info->status; > > - info->num_fences = sync_file->num_fences; > + /* > + * Passing num_fences = 0 means that userspace want to know how > + * many fences are in the sync_file to be able to allocate a buffer to > + * fit all sync_fence_infos and call the ioctl again with the buffer > + * assigned to info->sync_fence_info. The second call pass the > + * num_fences value received in the first call. > + */ > + if (!in.num_fences) > + goto no_fences; > + We should clamp in.num_fences to min2(in.num_fences, sync_file->num_fences) and use it over sync_file->num_fences though the rest of the function. Or just bail out when the two are not the same. Depends on what the planned semantics are. Fwiw I'm leaning towards the former. > + size = sync_file->num_fences * sizeof(*fence_info); > + if (in.len != size) { > + ret = -EFAULT; EINVAL or just drop len from the struct. > + goto out; > + } > > - len = sizeof(struct sync_file_info); > + fence_info = kzalloc(size, GFP_KERNEL); > + if (!fence_info) { > + ret = -ENOMEM; > + goto out; > + } > > for (i = 0; i < sync_file->num_fences; ++i) { > struct fence *fence = sync_file->cbs[i].fence; > > - ret = sync_fill_fence_info(fence, (u8 *)info + len, size - len); > + ret = sync_fill_fence_info(fence, (u8 *)fence_info + len, A few comments about sync_fill_fence_info() - Internal function so make the second argument of the correct type - struct sync_fence_info * - Drop the third argument size, as that one is always sizeof(sync_fence_info). - Remove the size checking in the same function and make its return type void Then one can simplify this loop even further :-) > + size - len); > > if (ret < 0) > goto out; > @@ -540,14 +560,24 @@ static long sync_file_ioctl_fence_info(struct sync_file *sync_file, > len += ret; > } > > + if (copy_to_user((void __user *)in.sync_fence_info, fence_info, size)) { > + ret = -EFAULT; > + goto out; > + } > + > info->len = len; > + info->sync_fence_info = (__u64) in.sync_fence_info; Why the cast ? > + > +no_fences: > + info->num_fences = sync_file->num_fences; > > - if (copy_to_user((void __user *)arg, info, len)) > + if (copy_to_user((void __user *)arg, info, sizeof(*info))) Don't know if we should be returning (copying) any other information but info->num_fences in case of "no_fences". In case it's not clear - I'm thinking about the data we already have in in info->name and info->status. Regards, Emil From mboxrd@z Thu Jan 1 00:00:00 1970 From: Emil Velikov Subject: Re: [PATCH] staging/android: refactor SYNC_IOC_FILE_INFO Date: Sat, 27 Feb 2016 02:18:15 +0000 Message-ID: References: <1456511507-2534-4-git-send-email-gustavo@padovan.org> <1456520410-28195-1-git-send-email-gustavo@padovan.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x22c.google.com (mail-wm0-x22c.google.com [IPv6:2a00:1450:400c:c09::22c]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1C7636E00C for ; Sat, 27 Feb 2016 02:18:17 +0000 (UTC) Received: by mail-wm0-x22c.google.com with SMTP id g62so93270487wme.0 for ; Fri, 26 Feb 2016 18:18:17 -0800 (PST) In-Reply-To: <1456520410-28195-1-git-send-email-gustavo@padovan.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Gustavo Padovan Cc: devel@driverdev.osuosl.org, Daniel Stone , Greg Kroah-Hartman , "Linux-Kernel@Vger. Kernel. Org" , ML dri-devel , Riley Andrews , =?UTF-8?B?QXJ2ZSBIasO4bm5ldsOlZw==?= , Daniel Vetter , Gustavo Padovan , John Harrison List-Id: dri-devel@lists.freedesktop.org SGkgR3VzdGF2bywKCk9uIDI2IEZlYnJ1YXJ5IDIwMTYgYXQgMjE6MDAsIEd1c3Rhdm8gUGFkb3Zh biA8Z3VzdGF2b0BwYWRvdmFuLm9yZz4gd3JvdGU6Cj4gRnJvbTogR3VzdGF2byBQYWRvdmFuIDxn dXN0YXZvLnBhZG92YW5AY29sbGFib3JhLmNvLnVrPgo+Cj4gQ2hhbmdlIFNZTkNfSU9DX0ZJTEVf SU5GTyBiZWhhdmlvdXIgdG8gYXZvaWQgZnV0dXJlIEFQSSBicmVha3MgYW5kCj4gb3B0aW1pemUg YnVmZmVyIGFsbG9jYXRpb24uIEluIHRoZSBuZXcgYXBwcm9hY2ggdGhlIGlvY3RsIG5lZWRzIHRv IGJlIGNhbGxlZAo+IHR3aWNlIHRvIHJldHJpZXZlIHRoZSBhcnJheSBvZiBmZW5jZV9pbmZvcyBw b2ludGVkIGJ5IGluZm8tPnN5bmNfZmVuY2VfaW5mby4KPgpJIG1pZ2h0IGhhdmUgbWlzdW5kZXJz dG9vZCB0aGluZ3MgYnV0IEkgbm8gb25lIHNheXMgeW91ICJuZWVkIiB0byBjYWxsCml0IHR3aWNl IC0geW91IGNhbiBqdXN0IHJlcXVlc3QgYSAicmFuZG9tIiBhbW91bnQgb2YgZmVuY2VzX2luZm8u IFVwb24KcmV0dXJuIChpZiBudW1fZmVuY2VzIHdhcyBub24gemVybykgaXQgd2lsbCByZXBvcnQg aG93IG1hbnkgZmVuY2VfaW5mbwp3ZXJlIHJldHJpZXZlZC4KCj4gVGhlIGZpcnN0IGNhbGwgc2hv dWxkIHBhc3MgbnVtX2ZlbmNlcyA9IDAsIHRoZSBrZXJuZWwgd2lsbCB0aGVuIGZpbGwKPiBpbmZv LT5udW1fZmVuY2VzLiBVc2Vyc3BhY2UgcmVjZWl2ZXMgYmFjayB0aGUgbnVtYmVyIG9mIGZlbmNl cyBhbmQKPiBhbGxvY2F0ZXMgYSBidWZmZXIgc2l6ZSBudW1fZmVuY2VzICogc2l6ZW9mKHN0cnVj dCBzeW5jX2ZlbmNlX2luZm8pIG9uCj4gaW5mby0+c3luY19mZW5jZV9pbmZvLgo+Cj4gSXQgdGhl biBjYWxsIHRoZSBpb2N0bCBhZ2FpbiBwYXNzaW5nIG51bV9mZW5jZXMgcmVjZWl2ZWQgaW4gaW5m by0+bnVtX2ZlbmNlcy4KImNhbGxzIgoKPiBUaGUga2VybmVsIGNoZWNrcyBpZiBpbmZvLT5udW1f ZmVuY2VzID4gMCBhbmQgaWYgeWVzIGl0IGZpbGwKPiBpbmZvLT5zeW5jX2ZlbmNlX2luZm8gd2l0 aCBhbiBhcnJheSBjb250YWluaW5nIGFsbCBmZW5jZV9pbmZvcy4KPgpUaGUgYWJvdmUgc2VudGVu Y2Ugc291bmRzIGEgYml0IHN0cmFuZ2UuIEkgYmVsaWV2ZSB5b3UgbWVhbnQgdG8gc2F5CnNvbWV0 aGluZyBsaWtlICJUaGVuIHRoZSBrZXJuZWwgZmlsbHMgdGhlIGZlbmNlX2luZm9zIGFycmF5IHdp dGggZGF0YS4KT25lIHNob3VsZCByZWFkIGJhY2sgdGhlIGFjdHVhbCBudW1iZXIgZnJvbSBpbmZv LT5udW1fZmVuY2VzLiIgPwoKPiBpbmZvLT5sZW4gbm93IHJlcHJlc2VudHMgdGhlIGxlbmd0aCBv ZiB0aGUgYnVmZmVyIHN5bmNfZmVuY2VfaW5mbyBwb2ludHMKPiB0by4KTm93IHRoYXQgSSB0aGlu ayBhYm91dCBpdCwgSSdtIHdvbmRlcmluZyBpZiB0aGVyZSdsbCBiZSBhIGNhc2Ugd2hlcmUKbGVu ICE9IGluZm8tPm51bV9mZW5jZXMgKiBzaXplb2Yoc3RydWN0IHN5bmNfZmlsZV9pbmZvKS4gSWYg dGhhdCdzIG5vdApwb3NzaWJsZSBvbmUgY291bGQganVzdCBkcm9wIGxlbiBhbmQgbmljZWx5IHNp bXBsaWZ5IHRoaW5ncy4KCj4gQWxzbywgaW5mby0+c3luY19mZW5jZV9pbmZvIHdhcyBjb252ZXJ0 ZWQgdG8gX191NjQgcG9pbnRlci4KPgouLi4gcG9pbnRlciB0byBwcmV2ZW50IDMyYml0IGNvbXBh dGliaWxpdHkgaXNzdWVzLgoKPiBBbiBleGFtcGxlIHVzZXJzcGFjZSBjb2RlIHdvdWxkIGJlOgo+ Cj4gICAgICAgICBzdHJ1Y3Qgc3luY19maWxlX2luZm8gKmluZm87Cj4gICAgICAgICBpbnQgZXJy LCBzaXplLCBudW1fZmVuY2VzOwo+Cj4gICAgICAgICBpbmZvID0gbWFsbG9jKHNpemVvZigqaW5m bykpOwo+Cj4gICAgICAgICBtZW1zZXQoaW5mbywgMCwgc2l6ZW9mKCppbmZvKSk7Cj4KPiAgICAg ICAgIGVyciA9IGlvY3RsKGZkLCBTWU5DX0lPQ19GSUxFX0lORk8sIGluZm8pOwo+ICAgICAgICAg bnVtX2ZlbmNlcyA9IGluZm8tPm51bV9mZW5jZXM7Cj4KPiAgICAgICAgIGlmIChudW1fZmVuY2Vz KSB7Cj4gICAgICAgICAgICAgICAgIG1lbXNldChpbmZvLCAwLCBzaXplb2YoKmluZm8pKTsKPiAg ICAgICAgICAgICAgICAgc2l6ZSA9IHNpemVvZihzdHJ1Y3Qgc3luY19mZW5jZV9pbmZvKSAqIG51 bV9mZW5jZXM7Cj4gICAgICAgICAgICAgICAgIGluZm8tPmxlbiA9IHNpemU7Cj4gICAgICAgICAg ICAgICAgIGluZm8tPm51bV9mZW5jZXMgPSBudW1fZmVuY2VzOwo+ICAgICAgICAgICAgICAgICBp bmZvLT5zeW5jX2ZlbmNlX2luZm8gPSAodWludDY0X3QpIGNhbGxvYyhudW1fZmVuY2VzLAo+ICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBz aXplb2Yoc3RydWN0IHN5bmNfZmVuY2VfaW5mbykpOwo+Cj4gICAgICAgICAgICAgICAgIGVyciA9 IGlvY3RsKGZkLCBTWU5DX0lPQ19GSUxFX0lORk8sIGluZm8pOwo+ICAgICAgICAgfQo+Cj4gdjI6 IGZpeCBmZW5jZV9pbmZvIG1lbW9yeSBsZWFrCj4KPiBTaWduZWQtb2ZmLWJ5OiBHdXN0YXZvIFBh ZG92YW4gPGd1c3Rhdm8ucGFkb3ZhbkBjb2xsYWJvcmEuY28udWs+Cj4gLS0tCj4gIGRyaXZlcnMv c3RhZ2luZy9hbmRyb2lkL3N5bmMuYyAgICAgIHwgNTIgKysrKysrKysrKysrKysrKysrKysrKysr KysrKystLS0tLS0tLQo+ICBkcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC91YXBpL3N5bmMuaCB8ICA5 ICsrKy0tLS0KPiAgMiBmaWxlcyBjaGFuZ2VkLCA0NSBpbnNlcnRpb25zKCspLCAxNiBkZWxldGlv bnMoLSkKPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jLmMgYi9k cml2ZXJzL3N0YWdpbmcvYW5kcm9pZC9zeW5jLmMKPiBpbmRleCBkYzVmMzgyLi4yMzc5ZjIzIDEw MDY0NAo+IC0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMuYwo+ICsrKyBiL2RyaXZl cnMvc3RhZ2luZy9hbmRyb2lkL3N5bmMuYwo+IEBAIC01MDIsMjEgKzUwMiwyMiBAQCBzdGF0aWMg aW50IHN5bmNfZmlsbF9mZW5jZV9pbmZvKHN0cnVjdCBmZW5jZSAqZmVuY2UsIHZvaWQgKmRhdGEs IGludCBzaXplKQo+ICBzdGF0aWMgbG9uZyBzeW5jX2ZpbGVfaW9jdGxfZmVuY2VfaW5mbyhzdHJ1 Y3Qgc3luY19maWxlICpzeW5jX2ZpbGUsCj4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHVuc2lnbmVkIGxvbmcgYXJnKQo+ICB7Cj4gLSAgICAgICBzdHJ1Y3Qgc3luY19m aWxlX2luZm8gKmluZm87Cj4gKyAgICAgICBzdHJ1Y3Qgc3luY19maWxlX2luZm8gaW4sICppbmZv Owo+ICsgICAgICAgc3RydWN0IHN5bmNfZmVuY2VfaW5mbyAqZmVuY2VfaW5mbyA9IE5VTEw7Cj4g ICAgICAgICBfX3UzMiBzaXplOwo+ICAgICAgICAgX191MzIgbGVuID0gMDsKPiAgICAgICAgIGlu dCByZXQsIGk7Cj4KPiAtICAgICAgIGlmIChjb3B5X2Zyb21fdXNlcigmc2l6ZSwgKHZvaWQgX191 c2VyICopYXJnLCBzaXplb2Yoc2l6ZSkpKQo+ICsgICAgICAgaWYgKGNvcHlfZnJvbV91c2VyKCZp biwgKHZvaWQgX191c2VyICopYXJnLCBzaXplb2YoKmluZm8pKSkKcy8qaW5mby9pbi8KCj4gICAg ICAgICAgICAgICAgIHJldHVybiAtRUZBVUxUOwo+Cj4gLSAgICAgICBpZiAoc2l6ZSA8IHNpemVv ZihzdHJ1Y3Qgc3luY19maWxlX2luZm8pKQo+IC0gICAgICAgICAgICAgICByZXR1cm4gLUVJTlZB TDsKPiArICAgICAgIGlmIChpbi5zdGF0dXMgfHwgc3RyY21wKGluLm5hbWUsICJcMCIpKQpBZmFp Y3QgdGhlc2UgdHdvIGFyZSBvdXRwdXRzLCBzbyB3ZSBzaG91bGQgYmUgY2hlY2tpbmcgdGhlbSA/ Cgo+ICsgICAgICAgICAgICAgICByZXR1cm4gLUVGQVVMVDsKPgpBcyBvcmlnaW5hbGx5LCBpbnB1 dCB2YWxpZGF0aW9uIHNob3VsZCByZXR1cm4gLUVJTlZBTCBvbiBlcnJvci4KCgo+IC0gICAgICAg aWYgKHNpemUgPiA0MDk2KQo+IC0gICAgICAgICAgICAgICBzaXplID0gNDA5NjsKPiArICAgICAg IGlmIChpbi5udW1fZmVuY2VzICYmICFpbi5zeW5jX2ZlbmNlX2luZm8pCj4gKyAgICAgICAgICAg ICAgIHJldHVybiAtRUZBVUxUOwo+CkRpdHRvLgoKPiAtICAgICAgIGluZm8gPSBremFsbG9jKHNp emUsIEdGUF9LRVJORUwpOwo+ICsgICAgICAgaW5mbyA9IGt6YWxsb2Moc2l6ZW9mKCppbmZvKSwg R0ZQX0tFUk5FTCk7Cj4gICAgICAgICBpZiAoIWluZm8pCj4gICAgICAgICAgICAgICAgIHJldHVy biAtRU5PTUVNOwo+Cj4gQEAgLTUyNSwxNCArNTI2LDMzIEBAIHN0YXRpYyBsb25nIHN5bmNfZmls ZV9pb2N0bF9mZW5jZV9pbmZvKHN0cnVjdCBzeW5jX2ZpbGUgKnN5bmNfZmlsZSwKPiAgICAgICAg IGlmIChpbmZvLT5zdGF0dXMgPj0gMCkKPiAgICAgICAgICAgICAgICAgaW5mby0+c3RhdHVzID0g IWluZm8tPnN0YXR1czsKPgo+IC0gICAgICAgaW5mby0+bnVtX2ZlbmNlcyA9IHN5bmNfZmlsZS0+ bnVtX2ZlbmNlczsKPiArICAgICAgIC8qCj4gKyAgICAgICAgKiBQYXNzaW5nIG51bV9mZW5jZXMg PSAwIG1lYW5zIHRoYXQgdXNlcnNwYWNlIHdhbnQgdG8ga25vdyBob3cKPiArICAgICAgICAqIG1h bnkgZmVuY2VzIGFyZSBpbiB0aGUgc3luY19maWxlIHRvIGJlIGFibGUgdG8gYWxsb2NhdGUgYSBi dWZmZXIgdG8KPiArICAgICAgICAqIGZpdCBhbGwgc3luY19mZW5jZV9pbmZvcyBhbmQgY2FsbCB0 aGUgaW9jdGwgYWdhaW4gd2l0aCB0aGUgYnVmZmVyCj4gKyAgICAgICAgKiBhc3NpZ25lZCB0byBp bmZvLT5zeW5jX2ZlbmNlX2luZm8uIFRoZSBzZWNvbmQgY2FsbCBwYXNzIHRoZQo+ICsgICAgICAg ICogbnVtX2ZlbmNlcyB2YWx1ZSByZWNlaXZlZCBpbiB0aGUgZmlyc3QgY2FsbC4KPiArICAgICAg ICAqLwo+ICsgICAgICAgaWYgKCFpbi5udW1fZmVuY2VzKQo+ICsgICAgICAgICAgICAgICBnb3Rv IG5vX2ZlbmNlczsKPiArCldlIHNob3VsZCBjbGFtcCBpbi5udW1fZmVuY2VzIHRvIG1pbjIoaW4u bnVtX2ZlbmNlcywKc3luY19maWxlLT5udW1fZmVuY2VzKSBhbmQgdXNlIGl0IG92ZXIgc3luY19m aWxlLT5udW1fZmVuY2VzIHRob3VnaAp0aGUgcmVzdCBvZiB0aGUgZnVuY3Rpb24uIE9yIGp1c3Qg YmFpbCBvdXQgd2hlbiB0aGUgdHdvIGFyZSBub3QgdGhlCnNhbWUuCgpEZXBlbmRzIG9uIHdoYXQg dGhlIHBsYW5uZWQgc2VtYW50aWNzIGFyZS4gRndpdyBJJ20gbGVhbmluZyB0b3dhcmRzIHRoZSBm b3JtZXIuCgo+ICsgICAgICAgc2l6ZSA9IHN5bmNfZmlsZS0+bnVtX2ZlbmNlcyAqIHNpemVvZigq ZmVuY2VfaW5mbyk7Cj4gKyAgICAgICBpZiAoaW4ubGVuICE9IHNpemUpIHsKPiArICAgICAgICAg ICAgICAgcmV0ID0gLUVGQVVMVDsKRUlOVkFMIG9yIGp1c3QgZHJvcCBsZW4gZnJvbSB0aGUgc3Ry dWN0LgoKPiArICAgICAgICAgICAgICAgZ290byBvdXQ7Cj4gKyAgICAgICB9Cj4KPiAtICAgICAg IGxlbiA9IHNpemVvZihzdHJ1Y3Qgc3luY19maWxlX2luZm8pOwo+ICsgICAgICAgZmVuY2VfaW5m byA9IGt6YWxsb2Moc2l6ZSwgR0ZQX0tFUk5FTCk7Cj4gKyAgICAgICBpZiAoIWZlbmNlX2luZm8p IHsKPiArICAgICAgICAgICAgICAgcmV0ID0gLUVOT01FTTsKPiArICAgICAgICAgICAgICAgZ290 byBvdXQ7Cj4gKyAgICAgICB9Cj4KPiAgICAgICAgIGZvciAoaSA9IDA7IGkgPCBzeW5jX2ZpbGUt Pm51bV9mZW5jZXM7ICsraSkgewo+ICAgICAgICAgICAgICAgICBzdHJ1Y3QgZmVuY2UgKmZlbmNl ID0gc3luY19maWxlLT5jYnNbaV0uZmVuY2U7Cj4KPiAtICAgICAgICAgICAgICAgcmV0ID0gc3lu Y19maWxsX2ZlbmNlX2luZm8oZmVuY2UsICh1OCAqKWluZm8gKyBsZW4sIHNpemUgLSBsZW4pOwo+ ICsgICAgICAgICAgICAgICByZXQgPSBzeW5jX2ZpbGxfZmVuY2VfaW5mbyhmZW5jZSwgKHU4ICop ZmVuY2VfaW5mbyArIGxlbiwKQSBmZXcgY29tbWVudHMgYWJvdXQgc3luY19maWxsX2ZlbmNlX2lu Zm8oKQogLSBJbnRlcm5hbCBmdW5jdGlvbiBzbyBtYWtlIHRoZSBzZWNvbmQgYXJndW1lbnQgb2Yg dGhlIGNvcnJlY3QgdHlwZSAtCnN0cnVjdCBzeW5jX2ZlbmNlX2luZm8gKgogLSBEcm9wIHRoZSB0 aGlyZCBhcmd1bWVudCBzaXplLCBhcyB0aGF0IG9uZSBpcyBhbHdheXMgc2l6ZW9mKHN5bmNfZmVu Y2VfaW5mbykuCiAtIFJlbW92ZSB0aGUgc2l6ZSBjaGVja2luZyBpbiB0aGUgc2FtZSBmdW5jdGlv biBhbmQgbWFrZSBpdHMgcmV0dXJuIHR5cGUgdm9pZAoKVGhlbiBvbmUgY2FuIHNpbXBsaWZ5IHRo aXMgbG9vcCBldmVuIGZ1cnRoZXIgOi0pCgo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBzaXplIC0gbGVuKTsKPgo+ICAgICAgICAgICAgICAgICBpZiAocmV0IDwg MCkKPiAgICAgICAgICAgICAgICAgICAgICAgICBnb3RvIG91dDsKPiBAQCAtNTQwLDE0ICs1NjAs MjQgQEAgc3RhdGljIGxvbmcgc3luY19maWxlX2lvY3RsX2ZlbmNlX2luZm8oc3RydWN0IHN5bmNf ZmlsZSAqc3luY19maWxlLAo+ICAgICAgICAgICAgICAgICBsZW4gKz0gcmV0Owo+ICAgICAgICAg fQo+Cj4gKyAgICAgICBpZiAoY29weV90b191c2VyKCh2b2lkIF9fdXNlciAqKWluLnN5bmNfZmVu Y2VfaW5mbywgZmVuY2VfaW5mbywgc2l6ZSkpIHsKPiArICAgICAgICAgICAgICAgcmV0ID0gLUVG QVVMVDsKPiArICAgICAgICAgICAgICAgZ290byBvdXQ7Cj4gKyAgICAgICB9Cj4gKwo+ICAgICAg ICAgaW5mby0+bGVuID0gbGVuOwo+ICsgICAgICAgaW5mby0+c3luY19mZW5jZV9pbmZvID0gKF9f dTY0KSBpbi5zeW5jX2ZlbmNlX2luZm87CldoeSB0aGUgY2FzdCA/Cgo+ICsKPiArbm9fZmVuY2Vz Ogo+ICsgICAgICAgaW5mby0+bnVtX2ZlbmNlcyA9IHN5bmNfZmlsZS0+bnVtX2ZlbmNlczsKPgo+ IC0gICAgICAgaWYgKGNvcHlfdG9fdXNlcigodm9pZCBfX3VzZXIgKilhcmcsIGluZm8sIGxlbikp Cj4gKyAgICAgICBpZiAoY29weV90b191c2VyKCh2b2lkIF9fdXNlciAqKWFyZywgaW5mbywgc2l6 ZW9mKCppbmZvKSkpCkRvbid0IGtub3cgaWYgd2Ugc2hvdWxkIGJlIHJldHVybmluZyAoY29weWlu ZykgYW55IG90aGVyIGluZm9ybWF0aW9uCmJ1dCBpbmZvLT5udW1fZmVuY2VzIGluIGNhc2Ugb2Yg Im5vX2ZlbmNlcyIuIEluIGNhc2UgaXQncyBub3QgY2xlYXIgLQpJJ20gdGhpbmtpbmcgYWJvdXQg dGhlIGRhdGEgd2UgYWxyZWFkeSBoYXZlIGluIGluIGluZm8tPm5hbWUgYW5kCmluZm8tPnN0YXR1 cy4KClJlZ2FyZHMsCkVtaWwKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0 b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJp LWRldmVsCg==