From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751803AbdIOXDA (ORCPT ); Fri, 15 Sep 2017 19:03:00 -0400 Received: from mail.kernel.org ([198.145.29.99]:37056 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751541AbdIOXAo (ORCPT ); Fri, 15 Sep 2017 19:00:44 -0400 DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E1A6722A78 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=sstabellini@kernel.org From: Stefano Stabellini To: xen-devel@lists.xen.org Cc: linux-kernel@vger.kernel.org, sstabellini@kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, Stefano Stabellini Subject: [PATCH v4 04/13] xen/pvcalls: implement socket command and handle events Date: Fri, 15 Sep 2017 16:00:31 -0700 Message-Id: <1505516440-11111-4-git-send-email-sstabellini@kernel.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1505516440-11111-1-git-send-email-sstabellini@kernel.org> References: <1505516440-11111-1-git-send-email-sstabellini@kernel.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Send a PVCALLS_SOCKET command to the backend, use the masked req_prod_pvt as req_id. This way, req_id is guaranteed to be between 0 and PVCALLS_NR_REQ_PER_RING. We already have a slot in the rsp array ready for the response, and there cannot be two outstanding responses with the same req_id. Wait for the response by waiting on the inflight_req waitqueue and check for the req_id field in rsp[req_id]. Use atomic accesses and barriers to read the field. Note that the barriers are simple smp barriers (as opposed to virt barriers) because they are for internal frontend synchronization, not frontend<->backend communication. Once a response is received, clear the corresponding rsp slot by setting req_id to PVCALLS_INVALID_ID. Note that PVCALLS_INVALID_ID is invalid only from the frontend point of view. It is not part of the PVCalls protocol. pvcalls_front_event_handler is in charge of copying responses from the ring to the appropriate rsp slot. It is done by copying the body of the response first, then by copying req_id atomically. After the copies, wake up anybody waiting on waitqueue. socket_lock protects accesses to the ring. Create a new struct sock_mapping and convert the pointer into an uint64_t and use it as id for the new socket to pass to the backend. The struct will be fully initialized later on connect or bind. In this patch the struct sock_mapping is empty, the fields will be added by the next patch. sock->sk->sk_send_head is not used for ip sockets: reuse the field to store a pointer to the struct sock_mapping corresponding to the socket. This way, we can easily get the struct sock_mapping from the struct socket. Signed-off-by: Stefano Stabellini CC: boris.ostrovsky@oracle.com CC: jgross@suse.com --- drivers/xen/pvcalls-front.c | 135 ++++++++++++++++++++++++++++++++++++++++++++ drivers/xen/pvcalls-front.h | 8 +++ 2 files changed, 143 insertions(+) create mode 100644 drivers/xen/pvcalls-front.h diff --git a/drivers/xen/pvcalls-front.c b/drivers/xen/pvcalls-front.c index ffbbcd1..1bad1b1 100644 --- a/drivers/xen/pvcalls-front.c +++ b/drivers/xen/pvcalls-front.c @@ -20,6 +20,8 @@ #include #include +#include "pvcalls-front.h" + #define PVCALLS_INVALID_ID UINT_MAX #define PVCALLS_RING_ORDER XENBUS_MAX_RING_GRANT_ORDER #define PVCALLS_NR_REQ_PER_RING __CONST_RING_SIZE(xen_pvcalls, XEN_PAGE_SIZE) @@ -51,11 +53,144 @@ struct pvcalls_bedata { atomic_dec(&pvcalls_refcount); \ } +struct sock_mapping { + bool active_socket; + struct list_head list; + struct socket *sock; +}; + +static inline int get_request(struct pvcalls_bedata *bedata, int *req_id) +{ + *req_id = bedata->ring.req_prod_pvt & (RING_SIZE(&bedata->ring) - 1); + if (RING_FULL(&bedata->ring) || + READ_ONCE(bedata->rsp[*req_id].req_id) != PVCALLS_INVALID_ID) + return -EAGAIN; + return 0; +} + static irqreturn_t pvcalls_front_event_handler(int irq, void *dev_id) { + struct xenbus_device *dev = dev_id; + struct pvcalls_bedata *bedata; + struct xen_pvcalls_response *rsp; + uint8_t *src, *dst; + int req_id = 0, more = 0, done = 0; + + if (dev == NULL) + return IRQ_HANDLED; + + pvcalls_enter; + bedata = dev_get_drvdata(&dev->dev); + if (bedata == NULL) { + pvcalls_exit; + return IRQ_HANDLED; + } + +again: + while (RING_HAS_UNCONSUMED_RESPONSES(&bedata->ring)) { + rsp = RING_GET_RESPONSE(&bedata->ring, bedata->ring.rsp_cons); + + req_id = rsp->req_id; + dst = (uint8_t *)&bedata->rsp[req_id] + sizeof(rsp->req_id); + src = (uint8_t *)rsp + sizeof(rsp->req_id); + memcpy(dst, src, sizeof(*rsp) - sizeof(rsp->req_id)); + /* + * First copy the rest of the data, then req_id. It is + * paired with the barrier when accessing bedata->rsp. + */ + smp_wmb(); + WRITE_ONCE(bedata->rsp[req_id].req_id, rsp->req_id); + + done = 1; + bedata->ring.rsp_cons++; + } + + RING_FINAL_CHECK_FOR_RESPONSES(&bedata->ring, more); + if (more) + goto again; + if (done) + wake_up(&bedata->inflight_req); + pvcalls_exit; return IRQ_HANDLED; } +int pvcalls_front_socket(struct socket *sock) +{ + struct pvcalls_bedata *bedata; + struct sock_mapping *map = NULL; + struct xen_pvcalls_request *req; + int notify, req_id, ret; + + pvcalls_enter; + if (!pvcalls_front_dev) { + pvcalls_exit; + return -EACCES; + } + /* + * PVCalls only supports domain AF_INET, + * type SOCK_STREAM and protocol 0 sockets for now. + * + * Check socket type here, AF_INET and protocol checks are done + * by the caller. + */ + if (sock->type != SOCK_STREAM) { + pvcalls_exit; + return -ENOTSUPP; + } + + bedata = dev_get_drvdata(&pvcalls_front_dev->dev); + + map = kzalloc(sizeof(*map), GFP_KERNEL); + if (map == NULL) { + pvcalls_exit; + return -ENOMEM; + } + + spin_lock(&bedata->socket_lock); + + ret = get_request(bedata, &req_id); + if (ret < 0) { + kfree(map); + spin_unlock(&bedata->socket_lock); + pvcalls_exit; + return ret; + } + + /* + * sock->sk->sk_send_head is not used for ip sockets: reuse the + * field to store a pointer to the struct sock_mapping + * corresponding to the socket. This way, we can easily get the + * struct sock_mapping from the struct socket. + */ + sock->sk->sk_send_head = (void *)map; + list_add_tail(&map->list, &bedata->socket_mappings); + + req = RING_GET_REQUEST(&bedata->ring, req_id); + req->req_id = req_id; + req->cmd = PVCALLS_SOCKET; + req->u.socket.id = (uint64_t) map; + req->u.socket.domain = AF_INET; + req->u.socket.type = SOCK_STREAM; + req->u.socket.protocol = IPPROTO_IP; + + bedata->ring.req_prod_pvt++; + RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&bedata->ring, notify); + spin_unlock(&bedata->socket_lock); + if (notify) + notify_remote_via_irq(bedata->irq); + + wait_event(bedata->inflight_req, + READ_ONCE(bedata->rsp[req_id].req_id) == req_id); + + ret = bedata->rsp[req_id].ret; + /* read ret, then set this rsp slot to be reused */ + smp_mb(); + WRITE_ONCE(bedata->rsp[req_id].req_id, PVCALLS_INVALID_ID); + + pvcalls_exit; + return ret; +} + static const struct xenbus_device_id pvcalls_front_ids[] = { { "pvcalls" }, { "" } diff --git a/drivers/xen/pvcalls-front.h b/drivers/xen/pvcalls-front.h new file mode 100644 index 0000000..b7dabed --- /dev/null +++ b/drivers/xen/pvcalls-front.h @@ -0,0 +1,8 @@ +#ifndef __PVCALLS_FRONT_H__ +#define __PVCALLS_FRONT_H__ + +#include + +int pvcalls_front_socket(struct socket *sock); + +#endif -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Stefano Stabellini Subject: [PATCH v4 04/13] xen/pvcalls: implement socket command and handle events Date: Fri, 15 Sep 2017 16:00:31 -0700 Message-ID: <1505516440-11111-4-git-send-email-sstabellini@kernel.org> References: <1505516440-11111-1-git-send-email-sstabellini@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1505516440-11111-1-git-send-email-sstabellini@kernel.org> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: xen-devel@lists.xen.org Cc: jgross@suse.com, Stefano Stabellini , boris.ostrovsky@oracle.com, sstabellini@kernel.org, linux-kernel@vger.kernel.org List-Id: xen-devel@lists.xenproject.org U2VuZCBhIFBWQ0FMTFNfU09DS0VUIGNvbW1hbmQgdG8gdGhlIGJhY2tlbmQsIHVzZSB0aGUgbWFz a2VkCnJlcV9wcm9kX3B2dCBhcyByZXFfaWQuIFRoaXMgd2F5LCByZXFfaWQgaXMgZ3VhcmFudGVl ZCB0byBiZSBiZXR3ZWVuIDAKYW5kIFBWQ0FMTFNfTlJfUkVRX1BFUl9SSU5HLiBXZSBhbHJlYWR5 IGhhdmUgYSBzbG90IGluIHRoZSByc3AgYXJyYXkKcmVhZHkgZm9yIHRoZSByZXNwb25zZSwgYW5k IHRoZXJlIGNhbm5vdCBiZSB0d28gb3V0c3RhbmRpbmcgcmVzcG9uc2VzCndpdGggdGhlIHNhbWUg cmVxX2lkLgoKV2FpdCBmb3IgdGhlIHJlc3BvbnNlIGJ5IHdhaXRpbmcgb24gdGhlIGluZmxpZ2h0 X3JlcSB3YWl0cXVldWUgYW5kCmNoZWNrIGZvciB0aGUgcmVxX2lkIGZpZWxkIGluIHJzcFtyZXFf aWRdLiBVc2UgYXRvbWljIGFjY2Vzc2VzIGFuZApiYXJyaWVycyB0byByZWFkIHRoZSBmaWVsZC4g Tm90ZSB0aGF0IHRoZSBiYXJyaWVycyBhcmUgc2ltcGxlIHNtcApiYXJyaWVycyAoYXMgb3Bwb3Nl ZCB0byB2aXJ0IGJhcnJpZXJzKSBiZWNhdXNlIHRoZXkgYXJlIGZvciBpbnRlcm5hbApmcm9udGVu ZCBzeW5jaHJvbml6YXRpb24sIG5vdCBmcm9udGVuZDwtPmJhY2tlbmQgY29tbXVuaWNhdGlvbi4K Ck9uY2UgYSByZXNwb25zZSBpcyByZWNlaXZlZCwgY2xlYXIgdGhlIGNvcnJlc3BvbmRpbmcgcnNw IHNsb3QgYnkgc2V0dGluZwpyZXFfaWQgdG8gUFZDQUxMU19JTlZBTElEX0lELiBOb3RlIHRoYXQg UFZDQUxMU19JTlZBTElEX0lEIGlzIGludmFsaWQKb25seSBmcm9tIHRoZSBmcm9udGVuZCBwb2lu dCBvZiB2aWV3LiBJdCBpcyBub3QgcGFydCBvZiB0aGUgUFZDYWxscwpwcm90b2NvbC4KCnB2Y2Fs bHNfZnJvbnRfZXZlbnRfaGFuZGxlciBpcyBpbiBjaGFyZ2Ugb2YgY29weWluZyByZXNwb25zZXMg ZnJvbSB0aGUKcmluZyB0byB0aGUgYXBwcm9wcmlhdGUgcnNwIHNsb3QuIEl0IGlzIGRvbmUgYnkg Y29weWluZyB0aGUgYm9keSBvZiB0aGUKcmVzcG9uc2UgZmlyc3QsIHRoZW4gYnkgY29weWluZyBy ZXFfaWQgYXRvbWljYWxseS4gQWZ0ZXIgdGhlIGNvcGllcywKd2FrZSB1cCBhbnlib2R5IHdhaXRp bmcgb24gd2FpdHF1ZXVlLgoKc29ja2V0X2xvY2sgcHJvdGVjdHMgYWNjZXNzZXMgdG8gdGhlIHJp bmcuCgpDcmVhdGUgYSBuZXcgc3RydWN0IHNvY2tfbWFwcGluZyBhbmQgY29udmVydCB0aGUgcG9p bnRlciBpbnRvIGFuCnVpbnQ2NF90IGFuZCB1c2UgaXQgYXMgaWQgZm9yIHRoZSBuZXcgc29ja2V0 IHRvIHBhc3MgdG8gdGhlIGJhY2tlbmQuIFRoZQpzdHJ1Y3Qgd2lsbCBiZSBmdWxseSBpbml0aWFs aXplZCBsYXRlciBvbiBjb25uZWN0IG9yIGJpbmQuIEluIHRoaXMgcGF0Y2gKdGhlIHN0cnVjdCBz b2NrX21hcHBpbmcgaXMgZW1wdHksIHRoZSBmaWVsZHMgd2lsbCBiZSBhZGRlZCBieSB0aGUgbmV4 dApwYXRjaC4KCnNvY2stPnNrLT5za19zZW5kX2hlYWQgaXMgbm90IHVzZWQgZm9yIGlwIHNvY2tl dHM6IHJldXNlIHRoZSBmaWVsZCB0bwpzdG9yZSBhIHBvaW50ZXIgdG8gdGhlIHN0cnVjdCBzb2Nr X21hcHBpbmcgY29ycmVzcG9uZGluZyB0byB0aGUgc29ja2V0LgpUaGlzIHdheSwgd2UgY2FuIGVh c2lseSBnZXQgdGhlIHN0cnVjdCBzb2NrX21hcHBpbmcgZnJvbSB0aGUgc3RydWN0CnNvY2tldC4K ClNpZ25lZC1vZmYtYnk6IFN0ZWZhbm8gU3RhYmVsbGluaSA8c3RlZmFub0BhcG9yZXRvLmNvbT4K Q0M6IGJvcmlzLm9zdHJvdnNreUBvcmFjbGUuY29tCkNDOiBqZ3Jvc3NAc3VzZS5jb20KLS0tCiBk cml2ZXJzL3hlbi9wdmNhbGxzLWZyb250LmMgfCAxMzUgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMveGVuL3B2Y2FsbHMtZnJvbnQuaCB8ICAgOCAr KysKIDIgZmlsZXMgY2hhbmdlZCwgMTQzIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL3hlbi9wdmNhbGxzLWZyb250LmgKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9w dmNhbGxzLWZyb250LmMgYi9kcml2ZXJzL3hlbi9wdmNhbGxzLWZyb250LmMKaW5kZXggZmZiYmNk MS4uMWJhZDFiMSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vcHZjYWxscy1mcm9udC5jCisrKyBi L2RyaXZlcnMveGVuL3B2Y2FsbHMtZnJvbnQuYwpAQCAtMjAsNiArMjAsOCBAQAogI2luY2x1ZGUg PHhlbi94ZW5idXMuaD4KICNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNlL2lvL3B2Y2FsbHMuaD4KIAor I2luY2x1ZGUgInB2Y2FsbHMtZnJvbnQuaCIKKwogI2RlZmluZSBQVkNBTExTX0lOVkFMSURfSUQg VUlOVF9NQVgKICNkZWZpbmUgUFZDQUxMU19SSU5HX09SREVSIFhFTkJVU19NQVhfUklOR19HUkFO VF9PUkRFUgogI2RlZmluZSBQVkNBTExTX05SX1JFUV9QRVJfUklORyBfX0NPTlNUX1JJTkdfU0la RSh4ZW5fcHZjYWxscywgWEVOX1BBR0VfU0laRSkKQEAgLTUxLDExICs1MywxNDQgQEAgc3RydWN0 IHB2Y2FsbHNfYmVkYXRhIHsKIAlhdG9taWNfZGVjKCZwdmNhbGxzX3JlZmNvdW50KTsgICAgICBc CiB9CiAKK3N0cnVjdCBzb2NrX21hcHBpbmcgeworCWJvb2wgYWN0aXZlX3NvY2tldDsKKwlzdHJ1 Y3QgbGlzdF9oZWFkIGxpc3Q7CisJc3RydWN0IHNvY2tldCAqc29jazsKK307CisKK3N0YXRpYyBp bmxpbmUgaW50IGdldF9yZXF1ZXN0KHN0cnVjdCBwdmNhbGxzX2JlZGF0YSAqYmVkYXRhLCBpbnQg KnJlcV9pZCkKK3sKKwkqcmVxX2lkID0gYmVkYXRhLT5yaW5nLnJlcV9wcm9kX3B2dCAmIChSSU5H X1NJWkUoJmJlZGF0YS0+cmluZykgLSAxKTsKKwlpZiAoUklOR19GVUxMKCZiZWRhdGEtPnJpbmcp IHx8CisJICAgIFJFQURfT05DRShiZWRhdGEtPnJzcFsqcmVxX2lkXS5yZXFfaWQpICE9IFBWQ0FM TFNfSU5WQUxJRF9JRCkKKwkJcmV0dXJuIC1FQUdBSU47CisJcmV0dXJuIDA7Cit9CisKIHN0YXRp YyBpcnFyZXR1cm5fdCBwdmNhbGxzX2Zyb250X2V2ZW50X2hhbmRsZXIoaW50IGlycSwgdm9pZCAq ZGV2X2lkKQogeworCXN0cnVjdCB4ZW5idXNfZGV2aWNlICpkZXYgPSBkZXZfaWQ7CisJc3RydWN0 IHB2Y2FsbHNfYmVkYXRhICpiZWRhdGE7CisJc3RydWN0IHhlbl9wdmNhbGxzX3Jlc3BvbnNlICpy c3A7CisJdWludDhfdCAqc3JjLCAqZHN0OworCWludCByZXFfaWQgPSAwLCBtb3JlID0gMCwgZG9u ZSA9IDA7CisKKwlpZiAoZGV2ID09IE5VTEwpCisJCXJldHVybiBJUlFfSEFORExFRDsKKworCXB2 Y2FsbHNfZW50ZXI7CisJYmVkYXRhID0gZGV2X2dldF9kcnZkYXRhKCZkZXYtPmRldik7CisJaWYg KGJlZGF0YSA9PSBOVUxMKSB7CisJCXB2Y2FsbHNfZXhpdDsKKwkJcmV0dXJuIElSUV9IQU5ETEVE OworCX0KKworYWdhaW46CisJd2hpbGUgKFJJTkdfSEFTX1VOQ09OU1VNRURfUkVTUE9OU0VTKCZi ZWRhdGEtPnJpbmcpKSB7CisJCXJzcCA9IFJJTkdfR0VUX1JFU1BPTlNFKCZiZWRhdGEtPnJpbmcs IGJlZGF0YS0+cmluZy5yc3BfY29ucyk7CisKKwkJcmVxX2lkID0gcnNwLT5yZXFfaWQ7CisJCWRz dCA9ICh1aW50OF90ICopJmJlZGF0YS0+cnNwW3JlcV9pZF0gKyBzaXplb2YocnNwLT5yZXFfaWQp OworCQlzcmMgPSAodWludDhfdCAqKXJzcCArIHNpemVvZihyc3AtPnJlcV9pZCk7CisJCW1lbWNw eShkc3QsIHNyYywgc2l6ZW9mKCpyc3ApIC0gc2l6ZW9mKHJzcC0+cmVxX2lkKSk7CisJCS8qCisJ CSAqIEZpcnN0IGNvcHkgdGhlIHJlc3Qgb2YgdGhlIGRhdGEsIHRoZW4gcmVxX2lkLiBJdCBpcwor CQkgKiBwYWlyZWQgd2l0aCB0aGUgYmFycmllciB3aGVuIGFjY2Vzc2luZyBiZWRhdGEtPnJzcC4K KwkJICovCisJCXNtcF93bWIoKTsKKwkJV1JJVEVfT05DRShiZWRhdGEtPnJzcFtyZXFfaWRdLnJl cV9pZCwgcnNwLT5yZXFfaWQpOworCisJCWRvbmUgPSAxOworCQliZWRhdGEtPnJpbmcucnNwX2Nv bnMrKzsKKwl9CisKKwlSSU5HX0ZJTkFMX0NIRUNLX0ZPUl9SRVNQT05TRVMoJmJlZGF0YS0+cmlu ZywgbW9yZSk7CisJaWYgKG1vcmUpCisJCWdvdG8gYWdhaW47CisJaWYgKGRvbmUpCisJCXdha2Vf dXAoJmJlZGF0YS0+aW5mbGlnaHRfcmVxKTsKKwlwdmNhbGxzX2V4aXQ7CiAJcmV0dXJuIElSUV9I QU5ETEVEOwogfQogCitpbnQgcHZjYWxsc19mcm9udF9zb2NrZXQoc3RydWN0IHNvY2tldCAqc29j aykKK3sKKwlzdHJ1Y3QgcHZjYWxsc19iZWRhdGEgKmJlZGF0YTsKKwlzdHJ1Y3Qgc29ja19tYXBw aW5nICptYXAgPSBOVUxMOworCXN0cnVjdCB4ZW5fcHZjYWxsc19yZXF1ZXN0ICpyZXE7CisJaW50 IG5vdGlmeSwgcmVxX2lkLCByZXQ7CisKKwlwdmNhbGxzX2VudGVyOworCWlmICghcHZjYWxsc19m cm9udF9kZXYpIHsKKwkJcHZjYWxsc19leGl0OworCQlyZXR1cm4gLUVBQ0NFUzsKKwl9CisJLyoK KwkgKiBQVkNhbGxzIG9ubHkgc3VwcG9ydHMgZG9tYWluIEFGX0lORVQsCisJICogdHlwZSBTT0NL X1NUUkVBTSBhbmQgcHJvdG9jb2wgMCBzb2NrZXRzIGZvciBub3cuCisJICoKKwkgKiBDaGVjayBz b2NrZXQgdHlwZSBoZXJlLCBBRl9JTkVUIGFuZCBwcm90b2NvbCBjaGVja3MgYXJlIGRvbmUKKwkg KiBieSB0aGUgY2FsbGVyLgorCSAqLworCWlmIChzb2NrLT50eXBlICE9IFNPQ0tfU1RSRUFNKSB7 CisJCXB2Y2FsbHNfZXhpdDsKKwkJcmV0dXJuIC1FTk9UU1VQUDsKKwl9CisKKwliZWRhdGEgPSBk ZXZfZ2V0X2RydmRhdGEoJnB2Y2FsbHNfZnJvbnRfZGV2LT5kZXYpOworCisJbWFwID0ga3phbGxv YyhzaXplb2YoKm1hcCksIEdGUF9LRVJORUwpOworCWlmIChtYXAgPT0gTlVMTCkgeworCQlwdmNh bGxzX2V4aXQ7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCXNwaW5fbG9jaygmYmVkYXRhLT5z b2NrZXRfbG9jayk7CisKKwlyZXQgPSBnZXRfcmVxdWVzdChiZWRhdGEsICZyZXFfaWQpOworCWlm IChyZXQgPCAwKSB7CisJCWtmcmVlKG1hcCk7CisJCXNwaW5fdW5sb2NrKCZiZWRhdGEtPnNvY2tl dF9sb2NrKTsKKwkJcHZjYWxsc19leGl0OworCQlyZXR1cm4gcmV0OworCX0KKworCS8qCisJICog c29jay0+c2stPnNrX3NlbmRfaGVhZCBpcyBub3QgdXNlZCBmb3IgaXAgc29ja2V0czogcmV1c2Ug dGhlCisJICogZmllbGQgdG8gc3RvcmUgYSBwb2ludGVyIHRvIHRoZSBzdHJ1Y3Qgc29ja19tYXBw aW5nCisJICogY29ycmVzcG9uZGluZyB0byB0aGUgc29ja2V0LiBUaGlzIHdheSwgd2UgY2FuIGVh c2lseSBnZXQgdGhlCisJICogc3RydWN0IHNvY2tfbWFwcGluZyBmcm9tIHRoZSBzdHJ1Y3Qgc29j a2V0LgorCSAqLworCXNvY2stPnNrLT5za19zZW5kX2hlYWQgPSAodm9pZCAqKW1hcDsKKwlsaXN0 X2FkZF90YWlsKCZtYXAtPmxpc3QsICZiZWRhdGEtPnNvY2tldF9tYXBwaW5ncyk7CisKKwlyZXEg PSBSSU5HX0dFVF9SRVFVRVNUKCZiZWRhdGEtPnJpbmcsIHJlcV9pZCk7CisJcmVxLT5yZXFfaWQg PSByZXFfaWQ7CisJcmVxLT5jbWQgPSBQVkNBTExTX1NPQ0tFVDsKKwlyZXEtPnUuc29ja2V0Lmlk ID0gKHVpbnQ2NF90KSBtYXA7CisJcmVxLT51LnNvY2tldC5kb21haW4gPSBBRl9JTkVUOworCXJl cS0+dS5zb2NrZXQudHlwZSA9IFNPQ0tfU1RSRUFNOworCXJlcS0+dS5zb2NrZXQucHJvdG9jb2wg PSBJUFBST1RPX0lQOworCisJYmVkYXRhLT5yaW5nLnJlcV9wcm9kX3B2dCsrOworCVJJTkdfUFVT SF9SRVFVRVNUU19BTkRfQ0hFQ0tfTk9USUZZKCZiZWRhdGEtPnJpbmcsIG5vdGlmeSk7CisJc3Bp bl91bmxvY2soJmJlZGF0YS0+c29ja2V0X2xvY2spOworCWlmIChub3RpZnkpCisJCW5vdGlmeV9y ZW1vdGVfdmlhX2lycShiZWRhdGEtPmlycSk7CisKKwl3YWl0X2V2ZW50KGJlZGF0YS0+aW5mbGln aHRfcmVxLAorCQkgICBSRUFEX09OQ0UoYmVkYXRhLT5yc3BbcmVxX2lkXS5yZXFfaWQpID09IHJl cV9pZCk7CisKKwlyZXQgPSBiZWRhdGEtPnJzcFtyZXFfaWRdLnJldDsKKwkvKiByZWFkIHJldCwg dGhlbiBzZXQgdGhpcyByc3Agc2xvdCB0byBiZSByZXVzZWQgKi8KKwlzbXBfbWIoKTsKKwlXUklU RV9PTkNFKGJlZGF0YS0+cnNwW3JlcV9pZF0ucmVxX2lkLCBQVkNBTExTX0lOVkFMSURfSUQpOwor CisJcHZjYWxsc19leGl0OworCXJldHVybiByZXQ7Cit9CisKIHN0YXRpYyBjb25zdCBzdHJ1Y3Qg eGVuYnVzX2RldmljZV9pZCBwdmNhbGxzX2Zyb250X2lkc1tdID0gewogCXsgInB2Y2FsbHMiIH0s CiAJeyAiIiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9wdmNhbGxzLWZyb250LmggYi9kcml2 ZXJzL3hlbi9wdmNhbGxzLWZyb250LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MC4uYjdkYWJlZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMveGVuL3B2Y2FsbHMtZnJvbnQu aApAQCAtMCwwICsxLDggQEAKKyNpZm5kZWYgX19QVkNBTExTX0ZST05UX0hfXworI2RlZmluZSBf X1BWQ0FMTFNfRlJPTlRfSF9fCisKKyNpbmNsdWRlIDxsaW51eC9uZXQuaD4KKworaW50IHB2Y2Fs bHNfZnJvbnRfc29ja2V0KHN0cnVjdCBzb2NrZXQgKnNvY2spOworCisjZW5kaWYKLS0gCjEuOS4x CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KWGVuLWRl dmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVuLm9yZwpodHRwczovL2xpc3RzLnhl bi5vcmcveGVuLWRldmVsCg==