From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753689AbdLSTlS (ORCPT ); Tue, 19 Dec 2017 14:41:18 -0500 Received: from mga01.intel.com ([192.55.52.88]:17633 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753253AbdLSThA (ORCPT ); Tue, 19 Dec 2017 14:37:00 -0500 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.45,428,1508828400"; d="scan'208";a="4018632" From: Dongwon Kim To: linux-kernel@vger.kernel.org Cc: dri-devel@lists.freedesktop.org, xen-devel@lists.xenproject.org, mateuszx.potrola@intel.com, dongwon.kim@intel.com Subject: [RFC PATCH 44/60] hyper_dmabuf: proper handling of sgt_info->priv Date: Tue, 19 Dec 2017 11:30:00 -0800 Message-Id: <1513711816-2618-44-git-send-email-dongwon.kim@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> References: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org sgt_info->priv will be used to store user private info passed in ioctl. Data in sgt_info->priv is transfered via comm channel to the importer VM whenever DMA_BUF is exported to keep the private data synchroized across VMs. This patch also adds hyper_dmabuf_send_export_msg that replaces some of export_remote_ioctl to make it more readable and compact. Signed-off-by: Dongwon Kim --- drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c | 110 ++++++++++++++----------- drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h | 6 +- 2 files changed, 65 insertions(+), 51 deletions(-) diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c index 3215003..dfdb889 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_ioctl.c @@ -82,17 +82,64 @@ static int hyper_dmabuf_rx_ch_setup_ioctl(struct file *filp, void *data) return ret; } +static int hyper_dmabuf_send_export_msg(struct hyper_dmabuf_sgt_info *sgt_info, + struct hyper_dmabuf_pages_info *page_info) +{ + struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; + struct hyper_dmabuf_req *req; + int operands[12] = {0}; + int ret, i; + + /* now create request for importer via ring */ + operands[0] = sgt_info->hid.id; + + for (i=0; i<3; i++) + operands[i+1] = sgt_info->hid.rng_key[i]; + + if (page_info) { + operands[4] = page_info->nents; + operands[5] = page_info->frst_ofst; + operands[6] = page_info->last_len; + operands[7] = ops->share_pages (page_info->pages, sgt_info->hyper_dmabuf_rdomain, + page_info->nents, &sgt_info->refs_info); + if (operands[7] < 0) { + dev_err(hyper_dmabuf_private.device, "pages sharing failed\n"); + return -1; + } + } + + /* driver/application specific private info, max 4x4 bytes */ + memcpy(&operands[8], &sgt_info->priv[0], sizeof(unsigned int) * 4); + + req = kcalloc(1, sizeof(*req), GFP_KERNEL); + + if(!req) { + dev_err(hyper_dmabuf_private.device, "no more space left\n"); + return -1; + } + + /* composing a message to the importer */ + hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT, &operands[0]); + + ret = ops->send_req(sgt_info->hyper_dmabuf_rdomain, req, false); + + if(ret) { + dev_err(hyper_dmabuf_private.device, "error while communicating\n"); + } + + kfree(req); + + return ret; +} + static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) { struct ioctl_hyper_dmabuf_export_remote *export_remote_attr; - struct hyper_dmabuf_backend_ops *ops = hyper_dmabuf_private.backend_ops; struct dma_buf *dma_buf; struct dma_buf_attachment *attachment; struct sg_table *sgt; struct hyper_dmabuf_pages_info *page_info; struct hyper_dmabuf_sgt_info *sgt_info; - struct hyper_dmabuf_req *req; - int operands[MAX_NUMBER_OF_OPERANDS]; hyper_dmabuf_id_t hid; int i; int ret = 0; @@ -138,6 +185,13 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) } sgt_info->unexport_scheduled = 0; } + + /* update private data in sgt_info with new ones */ + memcpy(&sgt_info->priv[0], &export_remote_attr->priv[0], sizeof(unsigned int) * 4); + + /* TODO: need to send this private info to the importer so that those + * on importer's side are also updated */ + dma_buf_put(dma_buf); export_remote_attr->hid = hid; return 0; @@ -225,6 +279,9 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) INIT_LIST_HEAD(&sgt_info->va_kmapped->list); INIT_LIST_HEAD(&sgt_info->va_vmapped->list); + /* copy private data to sgt_info */ + memcpy(&sgt_info->priv[0], &export_remote_attr->priv[0], sizeof(unsigned int) * 4); + page_info = hyper_dmabuf_ext_pgs(sgt); if (!page_info) { dev_err(hyper_dmabuf_private.device, "failed to construct page_info\n"); @@ -236,53 +293,15 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) /* now register it to export list */ hyper_dmabuf_register_exported(sgt_info); - page_info->hyper_dmabuf_rdomain = sgt_info->hyper_dmabuf_rdomain; - page_info->hid = sgt_info->hid; /* may not be needed */ - export_remote_attr->hid = sgt_info->hid; - /* now create request for importer via ring */ - operands[0] = page_info->hid.id; - - for (i=0; i<3; i++) - operands[i+1] = page_info->hid.rng_key[i]; - - operands[4] = page_info->nents; - operands[5] = page_info->frst_ofst; - operands[6] = page_info->last_len; - operands[7] = ops->share_pages (page_info->pages, export_remote_attr->remote_domain, - page_info->nents, &sgt_info->refs_info); - if (operands[7] < 0) { - dev_err(hyper_dmabuf_private.device, "pages sharing failed\n"); - goto fail_map_req; - } - - /* driver/application specific private info, max 4x4 bytes */ - operands[8] = export_remote_attr->priv[0]; - operands[9] = export_remote_attr->priv[1]; - operands[10] = export_remote_attr->priv[2]; - operands[11] = export_remote_attr->priv[3]; - - req = kcalloc(1, sizeof(*req), GFP_KERNEL); + ret = hyper_dmabuf_send_export_msg(sgt_info, page_info); - if(!req) { - dev_err(hyper_dmabuf_private.device, "no more space left\n"); - goto fail_map_req; - } - - /* composing a message to the importer */ - hyper_dmabuf_create_request(req, HYPER_DMABUF_EXPORT, &operands[0]); - - ret = ops->send_req(export_remote_attr->remote_domain, req, false); - - if(ret) { - dev_err(hyper_dmabuf_private.device, "error while communicating\n"); + if (ret < 0) { + dev_err(hyper_dmabuf_private.device, "failed to send out the export request\n"); goto fail_send_request; } - /* free msg */ - kfree(req); - /* free page_info */ kfree(page_info->pages); kfree(page_info); @@ -294,9 +313,6 @@ static int hyper_dmabuf_export_remote_ioctl(struct file *filp, void *data) /* Clean-up if error occurs */ fail_send_request: - kfree(req); - -fail_map_req: hyper_dmabuf_remove_exported(sgt_info->hid); /* free page_info */ diff --git a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h index 991a8d4..a1d3ec6 100644 --- a/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h +++ b/drivers/xen/hyper_dmabuf/hyper_dmabuf_struct.h @@ -51,8 +51,6 @@ struct vmap_vaddr_list { /* Exporter builds pages_info before sharing pages */ struct hyper_dmabuf_pages_info { - hyper_dmabuf_id_t hid; /* unique id to reference dmabuf in source domain */ - int hyper_dmabuf_rdomain; /* currenting considering just one remote domain access it */ int frst_ofst; /* offset of data in the first page */ int last_len; /* length of data in the last page */ int nents; /* # of pages */ @@ -71,7 +69,7 @@ struct hyper_dmabuf_sgt_info { int hyper_dmabuf_rdomain; /* domain importing this sgt */ struct dma_buf *dma_buf; /* needed to store this for freeing it later */ - int nents; /* number of pages, which may be different than sgt->nents */ + int nents; /* list of remote activities on dma_buf */ struct sgt_list *active_sgts; @@ -92,7 +90,7 @@ struct hyper_dmabuf_sgt_info { * uses releases hyper_dmabuf device */ struct file *filp; - int private[4]; /* device specific info (e.g. image's meta info?) */ + int priv[4]; /* device specific info (e.g. image's meta info?) */ }; /* Importer store references (before mapping) on shared pages -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dongwon Kim Subject: [RFC PATCH 44/60] hyper_dmabuf: proper handling of sgt_info->priv Date: Tue, 19 Dec 2017 11:30:00 -0800 Message-ID: <1513711816-2618-44-git-send-email-dongwon.kim@intel.com> References: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1513711816-2618-1-git-send-email-dongwon.kim@intel.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: linux-kernel@vger.kernel.org Cc: xen-devel@lists.xenproject.org, mateuszx.potrola@intel.com, dri-devel@lists.freedesktop.org, dongwon.kim@intel.com List-Id: dri-devel@lists.freedesktop.org c2d0X2luZm8tPnByaXYgd2lsbCBiZSB1c2VkIHRvIHN0b3JlIHVzZXIgcHJpdmF0ZSBpbmZvIHBh c3NlZCBpbgppb2N0bC4gRGF0YSBpbiBzZ3RfaW5mby0+cHJpdiBpcyB0cmFuc2ZlcmVkIHZpYSBj b21tIGNoYW5uZWwgdG8KdGhlIGltcG9ydGVyIFZNIHdoZW5ldmVyIERNQV9CVUYgaXMgZXhwb3J0 ZWQgdG8ga2VlcCB0aGUgcHJpdmF0ZQpkYXRhIHN5bmNocm9pemVkIGFjcm9zcyBWTXMuCgpUaGlz IHBhdGNoIGFsc28gYWRkcyBoeXBlcl9kbWFidWZfc2VuZF9leHBvcnRfbXNnIHRoYXQgcmVwbGFj ZXMKc29tZSBvZiBleHBvcnRfcmVtb3RlX2lvY3RsIHRvIG1ha2UgaXQgbW9yZSByZWFkYWJsZSBh bmQKY29tcGFjdC4KClNpZ25lZC1vZmYtYnk6IERvbmd3b24gS2ltIDxkb25nd29uLmtpbUBpbnRl bC5jb20+Ci0tLQogZHJpdmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5j ICB8IDExMCArKysrKysrKysrKysrKy0tLS0tLS0tLS0tCiBkcml2ZXJzL3hlbi9oeXBlcl9kbWFi dWYvaHlwZXJfZG1hYnVmX3N0cnVjdC5oIHwgICA2ICstCiAyIGZpbGVzIGNoYW5nZWQsIDY1IGlu c2VydGlvbnMoKyksIDUxIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5 cGVyX2RtYWJ1Zi9oeXBlcl9kbWFidWZfaW9jdGwuYyBiL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1 Zi9oeXBlcl9kbWFidWZfaW9jdGwuYwppbmRleCAzMjE1MDAzLi5kZmRiODg5IDEwMDY0NAotLS0g YS9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX2lvY3RsLmMKKysrIGIvZHJp dmVycy94ZW4vaHlwZXJfZG1hYnVmL2h5cGVyX2RtYWJ1Zl9pb2N0bC5jCkBAIC04MiwxNyArODIs NjQgQEAgc3RhdGljIGludCBoeXBlcl9kbWFidWZfcnhfY2hfc2V0dXBfaW9jdGwoc3RydWN0IGZp bGUgKmZpbHAsIHZvaWQgKmRhdGEpCiAJcmV0dXJuIHJldDsKIH0KIAorc3RhdGljIGludCBoeXBl cl9kbWFidWZfc2VuZF9leHBvcnRfbXNnKHN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gKnNn dF9pbmZvLAorCQkJCQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3BhZ2VzX2luZm8gKnBhZ2VfaW5mbykK K3sKKwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JhY2tlbmRfb3BzICpvcHMgPSBoeXBlcl9kbWFidWZf cHJpdmF0ZS5iYWNrZW5kX29wczsKKwlzdHJ1Y3QgaHlwZXJfZG1hYnVmX3JlcSAqcmVxOworCWlu dCBvcGVyYW5kc1sxMl0gPSB7MH07CisJaW50IHJldCwgaTsKKworCS8qIG5vdyBjcmVhdGUgcmVx dWVzdCBmb3IgaW1wb3J0ZXIgdmlhIHJpbmcgKi8KKwlvcGVyYW5kc1swXSA9IHNndF9pbmZvLT5o aWQuaWQ7CisKKwlmb3IgKGk9MDsgaTwzOyBpKyspCisJCW9wZXJhbmRzW2krMV0gPSBzZ3RfaW5m by0+aGlkLnJuZ19rZXlbaV07CisKKwlpZiAocGFnZV9pbmZvKSB7CisJCW9wZXJhbmRzWzRdID0g cGFnZV9pbmZvLT5uZW50czsKKwkJb3BlcmFuZHNbNV0gPSBwYWdlX2luZm8tPmZyc3Rfb2ZzdDsK KwkJb3BlcmFuZHNbNl0gPSBwYWdlX2luZm8tPmxhc3RfbGVuOworCQlvcGVyYW5kc1s3XSA9IG9w cy0+c2hhcmVfcGFnZXMgKHBhZ2VfaW5mby0+cGFnZXMsIHNndF9pbmZvLT5oeXBlcl9kbWFidWZf cmRvbWFpbiwKKwkJCQkJCXBhZ2VfaW5mby0+bmVudHMsICZzZ3RfaW5mby0+cmVmc19pbmZvKTsK KwkJaWYgKG9wZXJhbmRzWzddIDwgMCkgeworCQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0 ZS5kZXZpY2UsICJwYWdlcyBzaGFyaW5nIGZhaWxlZFxuIik7CisJCQlyZXR1cm4gLTE7CisJCX0K Kwl9CisKKwkvKiBkcml2ZXIvYXBwbGljYXRpb24gc3BlY2lmaWMgcHJpdmF0ZSBpbmZvLCBtYXgg NHg0IGJ5dGVzICovCisJbWVtY3B5KCZvcGVyYW5kc1s4XSwgJnNndF9pbmZvLT5wcml2WzBdLCBz aXplb2YodW5zaWduZWQgaW50KSAqIDQpOworCisJcmVxID0ga2NhbGxvYygxLCBzaXplb2YoKnJl cSksIEdGUF9LRVJORUwpOworCisJaWYoIXJlcSkgeworCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9w cml2YXRlLmRldmljZSwgIm5vIG1vcmUgc3BhY2UgbGVmdFxuIik7CisJCXJldHVybiAtMTsKKwl9 CisKKwkvKiBjb21wb3NpbmcgYSBtZXNzYWdlIHRvIHRoZSBpbXBvcnRlciAqLworCWh5cGVyX2Rt YWJ1Zl9jcmVhdGVfcmVxdWVzdChyZXEsIEhZUEVSX0RNQUJVRl9FWFBPUlQsICZvcGVyYW5kc1sw XSk7CisKKwlyZXQgPSBvcHMtPnNlbmRfcmVxKHNndF9pbmZvLT5oeXBlcl9kbWFidWZfcmRvbWFp biwgcmVxLCBmYWxzZSk7CisKKwlpZihyZXQpIHsKKwkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJp dmF0ZS5kZXZpY2UsICJlcnJvciB3aGlsZSBjb21tdW5pY2F0aW5nXG4iKTsKKwl9CisKKwlrZnJl ZShyZXEpOworCisJcmV0dXJuIHJldDsKK30KKwogc3RhdGljIGludCBoeXBlcl9kbWFidWZfZXhw b3J0X3JlbW90ZV9pb2N0bChzdHJ1Y3QgZmlsZSAqZmlscCwgdm9pZCAqZGF0YSkKIHsKIAlzdHJ1 Y3QgaW9jdGxfaHlwZXJfZG1hYnVmX2V4cG9ydF9yZW1vdGUgKmV4cG9ydF9yZW1vdGVfYXR0cjsK LQlzdHJ1Y3QgaHlwZXJfZG1hYnVmX2JhY2tlbmRfb3BzICpvcHMgPSBoeXBlcl9kbWFidWZfcHJp dmF0ZS5iYWNrZW5kX29wczsKIAlzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1ZjsKIAlzdHJ1Y3QgZG1h X2J1Zl9hdHRhY2htZW50ICphdHRhY2htZW50OwogCXN0cnVjdCBzZ190YWJsZSAqc2d0OwogCXN0 cnVjdCBoeXBlcl9kbWFidWZfcGFnZXNfaW5mbyAqcGFnZV9pbmZvOwogCXN0cnVjdCBoeXBlcl9k bWFidWZfc2d0X2luZm8gKnNndF9pbmZvOwotCXN0cnVjdCBoeXBlcl9kbWFidWZfcmVxICpyZXE7 Ci0JaW50IG9wZXJhbmRzW01BWF9OVU1CRVJfT0ZfT1BFUkFORFNdOwogCWh5cGVyX2RtYWJ1Zl9p ZF90IGhpZDsKIAlpbnQgaTsKIAlpbnQgcmV0ID0gMDsKQEAgLTEzOCw2ICsxODUsMTMgQEAgc3Rh dGljIGludCBoeXBlcl9kbWFidWZfZXhwb3J0X3JlbW90ZV9pb2N0bChzdHJ1Y3QgZmlsZSAqZmls cCwgdm9pZCAqZGF0YSkKIAkJCQkJfQogCQkJCQlzZ3RfaW5mby0+dW5leHBvcnRfc2NoZWR1bGVk ID0gMDsKIAkJCQl9CisKKwkJCQkvKiB1cGRhdGUgcHJpdmF0ZSBkYXRhIGluIHNndF9pbmZvIHdp dGggbmV3IG9uZXMgKi8KKwkJCQltZW1jcHkoJnNndF9pbmZvLT5wcml2WzBdLCAmZXhwb3J0X3Jl bW90ZV9hdHRyLT5wcml2WzBdLCBzaXplb2YodW5zaWduZWQgaW50KSAqIDQpOworCisJCQkJLyog VE9ETzogbmVlZCB0byBzZW5kIHRoaXMgcHJpdmF0ZSBpbmZvIHRvIHRoZSBpbXBvcnRlciBzbyB0 aGF0IHRob3NlCisJCQkJICogb24gaW1wb3J0ZXIncyBzaWRlIGFyZSBhbHNvIHVwZGF0ZWQgKi8K KwogCQkJCWRtYV9idWZfcHV0KGRtYV9idWYpOwogCQkJCWV4cG9ydF9yZW1vdGVfYXR0ci0+aGlk ID0gaGlkOwogCQkJCXJldHVybiAwOwpAQCAtMjI1LDYgKzI3OSw5IEBAIHN0YXRpYyBpbnQgaHlw ZXJfZG1hYnVmX2V4cG9ydF9yZW1vdGVfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHZvaWQgKmRh dGEpCiAJSU5JVF9MSVNUX0hFQUQoJnNndF9pbmZvLT52YV9rbWFwcGVkLT5saXN0KTsKIAlJTklU X0xJU1RfSEVBRCgmc2d0X2luZm8tPnZhX3ZtYXBwZWQtPmxpc3QpOwogCisJLyogY29weSBwcml2 YXRlIGRhdGEgdG8gc2d0X2luZm8gKi8KKwltZW1jcHkoJnNndF9pbmZvLT5wcml2WzBdLCAmZXhw b3J0X3JlbW90ZV9hdHRyLT5wcml2WzBdLCBzaXplb2YodW5zaWduZWQgaW50KSAqIDQpOworCiAJ cGFnZV9pbmZvID0gaHlwZXJfZG1hYnVmX2V4dF9wZ3Moc2d0KTsKIAlpZiAoIXBhZ2VfaW5mbykg ewogCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgImZhaWxlZCB0byBjb25z dHJ1Y3QgcGFnZV9pbmZvXG4iKTsKQEAgLTIzNiw1MyArMjkzLDE1IEBAIHN0YXRpYyBpbnQgaHlw ZXJfZG1hYnVmX2V4cG9ydF9yZW1vdGVfaW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHZvaWQgKmRh dGEpCiAJLyogbm93IHJlZ2lzdGVyIGl0IHRvIGV4cG9ydCBsaXN0ICovCiAJaHlwZXJfZG1hYnVm X3JlZ2lzdGVyX2V4cG9ydGVkKHNndF9pbmZvKTsKIAotCXBhZ2VfaW5mby0+aHlwZXJfZG1hYnVm X3Jkb21haW4gPSBzZ3RfaW5mby0+aHlwZXJfZG1hYnVmX3Jkb21haW47Ci0JcGFnZV9pbmZvLT5o aWQgPSBzZ3RfaW5mby0+aGlkOyAvKiBtYXkgbm90IGJlIG5lZWRlZCAqLwotCiAJZXhwb3J0X3Jl bW90ZV9hdHRyLT5oaWQgPSBzZ3RfaW5mby0+aGlkOwogCi0JLyogbm93IGNyZWF0ZSByZXF1ZXN0 IGZvciBpbXBvcnRlciB2aWEgcmluZyAqLwotCW9wZXJhbmRzWzBdID0gcGFnZV9pbmZvLT5oaWQu aWQ7Ci0KLQlmb3IgKGk9MDsgaTwzOyBpKyspCi0JCW9wZXJhbmRzW2krMV0gPSBwYWdlX2luZm8t PmhpZC5ybmdfa2V5W2ldOwotCi0Jb3BlcmFuZHNbNF0gPSBwYWdlX2luZm8tPm5lbnRzOwotCW9w ZXJhbmRzWzVdID0gcGFnZV9pbmZvLT5mcnN0X29mc3Q7Ci0Jb3BlcmFuZHNbNl0gPSBwYWdlX2lu Zm8tPmxhc3RfbGVuOwotCW9wZXJhbmRzWzddID0gb3BzLT5zaGFyZV9wYWdlcyAocGFnZV9pbmZv LT5wYWdlcywgZXhwb3J0X3JlbW90ZV9hdHRyLT5yZW1vdGVfZG9tYWluLAotCQkJCQlwYWdlX2lu Zm8tPm5lbnRzLCAmc2d0X2luZm8tPnJlZnNfaW5mbyk7Ci0JaWYgKG9wZXJhbmRzWzddIDwgMCkg ewotCQlkZXZfZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgInBhZ2VzIHNoYXJpbmcg ZmFpbGVkXG4iKTsKLQkJZ290byBmYWlsX21hcF9yZXE7Ci0JfQotCi0JLyogZHJpdmVyL2FwcGxp Y2F0aW9uIHNwZWNpZmljIHByaXZhdGUgaW5mbywgbWF4IDR4NCBieXRlcyAqLwotCW9wZXJhbmRz WzhdID0gZXhwb3J0X3JlbW90ZV9hdHRyLT5wcml2WzBdOwotCW9wZXJhbmRzWzldID0gZXhwb3J0 X3JlbW90ZV9hdHRyLT5wcml2WzFdOwotCW9wZXJhbmRzWzEwXSA9IGV4cG9ydF9yZW1vdGVfYXR0 ci0+cHJpdlsyXTsKLQlvcGVyYW5kc1sxMV0gPSBleHBvcnRfcmVtb3RlX2F0dHItPnByaXZbM107 Ci0KLQlyZXEgPSBrY2FsbG9jKDEsIHNpemVvZigqcmVxKSwgR0ZQX0tFUk5FTCk7CisJcmV0ID0g aHlwZXJfZG1hYnVmX3NlbmRfZXhwb3J0X21zZyhzZ3RfaW5mbywgcGFnZV9pbmZvKTsKIAotCWlm KCFyZXEpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2UsICJubyBtb3Jl IHNwYWNlIGxlZnRcbiIpOwotCQlnb3RvIGZhaWxfbWFwX3JlcTsKLQl9Ci0KLQkvKiBjb21wb3Np bmcgYSBtZXNzYWdlIHRvIHRoZSBpbXBvcnRlciAqLwotCWh5cGVyX2RtYWJ1Zl9jcmVhdGVfcmVx dWVzdChyZXEsIEhZUEVSX0RNQUJVRl9FWFBPUlQsICZvcGVyYW5kc1swXSk7Ci0KLQlyZXQgPSBv cHMtPnNlbmRfcmVxKGV4cG9ydF9yZW1vdGVfYXR0ci0+cmVtb3RlX2RvbWFpbiwgcmVxLCBmYWxz ZSk7Ci0KLQlpZihyZXQpIHsKLQkJZGV2X2VycihoeXBlcl9kbWFidWZfcHJpdmF0ZS5kZXZpY2Us ICJlcnJvciB3aGlsZSBjb21tdW5pY2F0aW5nXG4iKTsKKwlpZiAocmV0IDwgMCkgeworCQlkZXZf ZXJyKGh5cGVyX2RtYWJ1Zl9wcml2YXRlLmRldmljZSwgImZhaWxlZCB0byBzZW5kIG91dCB0aGUg ZXhwb3J0IHJlcXVlc3RcbiIpOwogCQlnb3RvIGZhaWxfc2VuZF9yZXF1ZXN0OwogCX0KIAotCS8q IGZyZWUgbXNnICovCi0Ja2ZyZWUocmVxKTsKLQogCS8qIGZyZWUgcGFnZV9pbmZvICovCiAJa2Zy ZWUocGFnZV9pbmZvLT5wYWdlcyk7CiAJa2ZyZWUocGFnZV9pbmZvKTsKQEAgLTI5NCw5ICszMTMs NiBAQCBzdGF0aWMgaW50IGh5cGVyX2RtYWJ1Zl9leHBvcnRfcmVtb3RlX2lvY3RsKHN0cnVjdCBm aWxlICpmaWxwLCB2b2lkICpkYXRhKQogLyogQ2xlYW4tdXAgaWYgZXJyb3Igb2NjdXJzICovCiAK IGZhaWxfc2VuZF9yZXF1ZXN0OgotCWtmcmVlKHJlcSk7Ci0KLWZhaWxfbWFwX3JlcToKIAloeXBl cl9kbWFidWZfcmVtb3ZlX2V4cG9ydGVkKHNndF9pbmZvLT5oaWQpOwogCiAJLyogZnJlZSBwYWdl X2luZm8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL2h5cGVyX2RtYWJ1Zi9oeXBlcl9kbWFi dWZfc3RydWN0LmggYi9kcml2ZXJzL3hlbi9oeXBlcl9kbWFidWYvaHlwZXJfZG1hYnVmX3N0cnVj dC5oCmluZGV4IDk5MWE4ZDQuLmExZDNlYzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2h5cGVy X2RtYWJ1Zi9oeXBlcl9kbWFidWZfc3RydWN0LmgKKysrIGIvZHJpdmVycy94ZW4vaHlwZXJfZG1h YnVmL2h5cGVyX2RtYWJ1Zl9zdHJ1Y3QuaApAQCAtNTEsOCArNTEsNiBAQCBzdHJ1Y3Qgdm1hcF92 YWRkcl9saXN0IHsKIAogLyogRXhwb3J0ZXIgYnVpbGRzIHBhZ2VzX2luZm8gYmVmb3JlIHNoYXJp bmcgcGFnZXMgKi8KIHN0cnVjdCBoeXBlcl9kbWFidWZfcGFnZXNfaW5mbyB7Ci0gICAgICAgIGh5 cGVyX2RtYWJ1Zl9pZF90IGhpZDsgLyogdW5pcXVlIGlkIHRvIHJlZmVyZW5jZSBkbWFidWYgaW4g c291cmNlIGRvbWFpbiAqLwotICAgICAgICBpbnQgaHlwZXJfZG1hYnVmX3Jkb21haW47IC8qIGN1 cnJlbnRpbmcgY29uc2lkZXJpbmcganVzdCBvbmUgcmVtb3RlIGRvbWFpbiBhY2Nlc3MgaXQgKi8K ICAgICAgICAgaW50IGZyc3Rfb2ZzdDsgLyogb2Zmc2V0IG9mIGRhdGEgaW4gdGhlIGZpcnN0IHBh Z2UgKi8KICAgICAgICAgaW50IGxhc3RfbGVuOyAvKiBsZW5ndGggb2YgZGF0YSBpbiB0aGUgbGFz dCBwYWdlICovCiAgICAgICAgIGludCBuZW50czsgLyogIyBvZiBwYWdlcyAqLwpAQCAtNzEsNyAr NjksNyBAQCBzdHJ1Y3QgaHlwZXJfZG1hYnVmX3NndF9pbmZvIHsKIAlpbnQgaHlwZXJfZG1hYnVm X3Jkb21haW47IC8qIGRvbWFpbiBpbXBvcnRpbmcgdGhpcyBzZ3QgKi8KIAogCXN0cnVjdCBkbWFf YnVmICpkbWFfYnVmOyAvKiBuZWVkZWQgdG8gc3RvcmUgdGhpcyBmb3IgZnJlZWluZyBpdCBsYXRl ciAqLwotCWludCBuZW50czsgLyogbnVtYmVyIG9mIHBhZ2VzLCB3aGljaCBtYXkgYmUgZGlmZmVy ZW50IHRoYW4gc2d0LT5uZW50cyAqLworCWludCBuZW50czsKIAogCS8qIGxpc3Qgb2YgcmVtb3Rl IGFjdGl2aXRpZXMgb24gZG1hX2J1ZiAqLwogCXN0cnVjdCBzZ3RfbGlzdCAqYWN0aXZlX3NndHM7 CkBAIC05Miw3ICs5MCw3IEBAIHN0cnVjdCBoeXBlcl9kbWFidWZfc2d0X2luZm8gewogCSAqIHVz ZXMgcmVsZWFzZXMgaHlwZXJfZG1hYnVmIGRldmljZQogCSAqLwogCXN0cnVjdCBmaWxlICpmaWxw OwotCWludCBwcml2YXRlWzRdOyAvKiBkZXZpY2Ugc3BlY2lmaWMgaW5mbyAoZS5nLiBpbWFnZSdz IG1ldGEgaW5mbz8pICovCisJaW50IHByaXZbNF07IC8qIGRldmljZSBzcGVjaWZpYyBpbmZvIChl LmcuIGltYWdlJ3MgbWV0YSBpbmZvPykgKi8KIH07CiAKIC8qIEltcG9ydGVyIHN0b3JlIHJlZmVy ZW5jZXMgKGJlZm9yZSBtYXBwaW5nKSBvbiBzaGFyZWQgcGFnZXMKLS0gCjIuNy40CgoKX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRldmVsIG1haWxp bmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5w cm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hlbi1kZXZlbA==