From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:59344) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1cBTSY-0003Mq-1y for qemu-devel@nongnu.org; Mon, 28 Nov 2016 16:27:35 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1cBTSV-0003N7-Fq for qemu-devel@nongnu.org; Mon, 28 Nov 2016 16:27:34 -0500 Received: from mail.kernel.org ([198.145.29.136]:37630) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1cBTSV-0003MK-6M for qemu-devel@nongnu.org; Mon, 28 Nov 2016 16:27:31 -0500 From: Stefano Stabellini Date: Mon, 28 Nov 2016 13:27:22 -0800 Message-Id: <1480368444-4310-2-git-send-email-sstabellini@kernel.org> In-Reply-To: <1480368444-4310-1-git-send-email-sstabellini@kernel.org> References: <1480368444-4310-1-git-send-email-sstabellini@kernel.org> Subject: [Qemu-devel] [PATCH v2 2/4] 9pfs: introduce transport specific callbacks List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: aneesh.kumar@linux.vnet.ibm.com Cc: groug@kaod.org, sstabellini@kernel.org, qemu-devel@nongnu.org, xen-devel@lists.xensource.com, anthony.perard@citrix.com Don't call virtio functions from 9pfs generic code, use generic function callbacks instead. Signed-off-by: Stefano Stabellini --- Changes in v2: - constify virtio_9p_transport and V9fsTransport - assert !s->transport. - code style --- hw/9pfs/9p.c | 8 ++++---- hw/9pfs/9p.h | 19 +++++++++++++++++++ hw/9pfs/virtio-9p-device.c | 24 +++++++++++++++++------- hw/9pfs/virtio-9p.h | 9 --------- 4 files changed, 40 insertions(+), 20 deletions(-) diff --git a/hw/9pfs/9p.c b/hw/9pfs/9p.c index 05e950f..5a20a13 100644 --- a/hw/9pfs/9p.c +++ b/hw/9pfs/9p.c @@ -47,7 +47,7 @@ ssize_t pdu_marshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...) va_list ap; va_start(ap, fmt); - ret = virtio_pdu_vmarshal(pdu, offset, fmt, ap); + ret = pdu->s->transport->pdu_vmarshal(pdu, offset, fmt, ap); va_end(ap); return ret; @@ -59,7 +59,7 @@ ssize_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...) va_list ap; va_start(ap, fmt); - ret = virtio_pdu_vunmarshal(pdu, offset, fmt, ap); + ret = pdu->s->transport->pdu_vunmarshal(pdu, offset, fmt, ap); va_end(ap); return ret; @@ -67,7 +67,7 @@ ssize_t pdu_unmarshal(V9fsPDU *pdu, size_t offset, const char *fmt, ...) static void pdu_push_and_notify(V9fsPDU *pdu) { - virtio_9p_push_and_notify(pdu); + pdu->s->transport->push_and_notify(pdu); } static int omode_to_uflags(int8_t mode) @@ -1751,7 +1751,7 @@ static void v9fs_init_qiov_from_pdu(QEMUIOVector *qiov, V9fsPDU *pdu, struct iovec *iov; unsigned int niov; - virtio_init_iov_from_pdu(pdu, &iov, &niov, is_write); + pdu->s->transport->init_iov_from_pdu(pdu, &iov, &niov, is_write); qemu_iovec_init_external(&elem, iov, niov); qemu_iovec_init(qiov, niov); diff --git a/hw/9pfs/9p.h b/hw/9pfs/9p.h index 07cee01..c8c9aa8 100644 --- a/hw/9pfs/9p.h +++ b/hw/9pfs/9p.h @@ -230,6 +230,7 @@ typedef struct V9fsState enum p9_proto_version proto_version; int32_t msize; V9fsPDU pdus[MAX_REQ]; + const struct V9fsTransport *transport; /* * lock ensuring atomic path update * on rename. @@ -343,4 +344,22 @@ void pdu_free(V9fsPDU *pdu); void pdu_submit(V9fsPDU *pdu); void v9fs_reset(V9fsState *s); +struct V9fsTransport { + ssize_t (*pdu_vmarshal)(V9fsPDU *pdu, size_t offset, const char *fmt, + va_list ap); + ssize_t (*pdu_vunmarshal)(V9fsPDU *pdu, size_t offset, const char *fmt, + va_list ap); + void (*init_iov_from_pdu)(V9fsPDU *pdu, struct iovec **piov, + unsigned int *pniov, bool is_write); + void (*push_and_notify)(V9fsPDU *pdu); +}; + +static inline int v9fs_register_transport(V9fsState *s, + const struct V9fsTransport *t) +{ + assert(!s->transport); + s->transport = t; + return 0; +} + #endif diff --git a/hw/9pfs/virtio-9p-device.c b/hw/9pfs/virtio-9p-device.c index 1782e4a..273425b 100644 --- a/hw/9pfs/virtio-9p-device.c +++ b/hw/9pfs/virtio-9p-device.c @@ -20,7 +20,9 @@ #include "hw/virtio/virtio-access.h" #include "qemu/iov.h" -void virtio_9p_push_and_notify(V9fsPDU *pdu) +static const struct V9fsTransport virtio_9p_transport; + +static void virtio_9p_push_and_notify(V9fsPDU *pdu) { V9fsState *s = pdu->s; V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); @@ -126,6 +128,7 @@ static void virtio_9p_device_realize(DeviceState *dev, Error **errp) v->config_size = sizeof(struct virtio_9p_config) + strlen(s->fsconf.tag); virtio_init(vdev, "virtio-9p", VIRTIO_ID_9P, v->config_size); v->vq = virtio_add_queue(vdev, MAX_REQ, handle_9p_output); + v9fs_register_transport(s, &virtio_9p_transport); out: return; @@ -148,8 +151,8 @@ static void virtio_9p_reset(VirtIODevice *vdev) v9fs_reset(&v->state); } -ssize_t virtio_pdu_vmarshal(V9fsPDU *pdu, size_t offset, - const char *fmt, va_list ap) +static ssize_t virtio_pdu_vmarshal(V9fsPDU *pdu, size_t offset, + const char *fmt, va_list ap) { V9fsState *s = pdu->s; V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); @@ -158,8 +161,8 @@ ssize_t virtio_pdu_vmarshal(V9fsPDU *pdu, size_t offset, return v9fs_iov_vmarshal(elem->in_sg, elem->in_num, offset, 1, fmt, ap); } -ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset, - const char *fmt, va_list ap) +static ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset, + const char *fmt, va_list ap) { V9fsState *s = pdu->s; V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); @@ -168,8 +171,8 @@ ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset, return v9fs_iov_vunmarshal(elem->out_sg, elem->out_num, offset, 1, fmt, ap); } -void virtio_init_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, - unsigned int *pniov, bool is_write) +static void virtio_init_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, + unsigned int *pniov, bool is_write) { V9fsState *s = pdu->s; V9fsVirtioState *v = container_of(s, V9fsVirtioState, state); @@ -184,6 +187,13 @@ void virtio_init_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, } } +static const struct V9fsTransport virtio_9p_transport = { + .pdu_vmarshal = virtio_pdu_vmarshal, + .pdu_vunmarshal = virtio_pdu_vunmarshal, + .init_iov_from_pdu = virtio_init_iov_from_pdu, + .push_and_notify = virtio_9p_push_and_notify, +}; + /* virtio-9p device */ static const VMStateDescription vmstate_virtio_9p = { diff --git a/hw/9pfs/virtio-9p.h b/hw/9pfs/virtio-9p.h index 52c4b9d..e763da2c 100644 --- a/hw/9pfs/virtio-9p.h +++ b/hw/9pfs/virtio-9p.h @@ -14,15 +14,6 @@ typedef struct V9fsVirtioState V9fsState state; } V9fsVirtioState; -void virtio_9p_push_and_notify(V9fsPDU *pdu); - -ssize_t virtio_pdu_vmarshal(V9fsPDU *pdu, size_t offset, - const char *fmt, va_list ap); -ssize_t virtio_pdu_vunmarshal(V9fsPDU *pdu, size_t offset, - const char *fmt, va_list ap); -void virtio_init_iov_from_pdu(V9fsPDU *pdu, struct iovec **piov, - unsigned int *pniov, bool is_write); - #define TYPE_VIRTIO_9P "virtio-9p-device" #define VIRTIO_9P(obj) \ OBJECT_CHECK(V9fsVirtioState, (obj), TYPE_VIRTIO_9P) -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Stefano Stabellini Subject: [PATCH v2 2/4] 9pfs: introduce transport specific callbacks Date: Mon, 28 Nov 2016 13:27:22 -0800 Message-ID: <1480368444-4310-2-git-send-email-sstabellini@kernel.org> References: <1480368444-4310-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: <1480368444-4310-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: aneesh.kumar@linux.vnet.ibm.com Cc: xen-devel@lists.xensource.com, anthony.perard@citrix.com, sstabellini@kernel.org, groug@kaod.org, qemu-devel@nongnu.org List-Id: xen-devel@lists.xenproject.org RG9uJ3QgY2FsbCB2aXJ0aW8gZnVuY3Rpb25zIGZyb20gOXBmcyBnZW5lcmljIGNvZGUsIHVzZSBn ZW5lcmljIGZ1bmN0aW9uCmNhbGxiYWNrcyBpbnN0ZWFkLgoKU2lnbmVkLW9mZi1ieTogU3RlZmFu byBTdGFiZWxsaW5pIDxzc3RhYmVsbGluaUBrZXJuZWwub3JnPgoKLS0tCkNoYW5nZXMgaW4gdjI6 Ci0gY29uc3RpZnkgdmlydGlvXzlwX3RyYW5zcG9ydCBhbmQgVjlmc1RyYW5zcG9ydAotIGFzc2Vy dCAhcy0+dHJhbnNwb3J0LgotIGNvZGUgc3R5bGUKLS0tCiBody85cGZzLzlwLmMgICAgICAgICAg ICAgICB8ICA4ICsrKystLS0tCiBody85cGZzLzlwLmggICAgICAgICAgICAgICB8IDE5ICsrKysr KysrKysrKysrKysrKysKIGh3LzlwZnMvdmlydGlvLTlwLWRldmljZS5jIHwgMjQgKysrKysrKysr KysrKysrKystLS0tLS0tCiBody85cGZzL3ZpcnRpby05cC5oICAgICAgICB8ICA5IC0tLS0tLS0t LQogNCBmaWxlcyBjaGFuZ2VkLCA0MCBpbnNlcnRpb25zKCspLCAyMCBkZWxldGlvbnMoLSkKCmRp ZmYgLS1naXQgYS9ody85cGZzLzlwLmMgYi9ody85cGZzLzlwLmMKaW5kZXggMDVlOTUwZi4uNWEy MGExMyAxMDA2NDQKLS0tIGEvaHcvOXBmcy85cC5jCisrKyBiL2h3LzlwZnMvOXAuYwpAQCAtNDcs NyArNDcsNyBAQCBzc2l6ZV90IHBkdV9tYXJzaGFsKFY5ZnNQRFUgKnBkdSwgc2l6ZV90IG9mZnNl dCwgY29uc3QgY2hhciAqZm10LCAuLi4pCiAgICAgdmFfbGlzdCBhcDsKIAogICAgIHZhX3N0YXJ0 KGFwLCBmbXQpOwotICAgIHJldCA9IHZpcnRpb19wZHVfdm1hcnNoYWwocGR1LCBvZmZzZXQsIGZt dCwgYXApOworICAgIHJldCA9IHBkdS0+cy0+dHJhbnNwb3J0LT5wZHVfdm1hcnNoYWwocGR1LCBv ZmZzZXQsIGZtdCwgYXApOwogICAgIHZhX2VuZChhcCk7CiAKICAgICByZXR1cm4gcmV0OwpAQCAt NTksNyArNTksNyBAQCBzc2l6ZV90IHBkdV91bm1hcnNoYWwoVjlmc1BEVSAqcGR1LCBzaXplX3Qg b2Zmc2V0LCBjb25zdCBjaGFyICpmbXQsIC4uLikKICAgICB2YV9saXN0IGFwOwogCiAgICAgdmFf c3RhcnQoYXAsIGZtdCk7Ci0gICAgcmV0ID0gdmlydGlvX3BkdV92dW5tYXJzaGFsKHBkdSwgb2Zm c2V0LCBmbXQsIGFwKTsKKyAgICByZXQgPSBwZHUtPnMtPnRyYW5zcG9ydC0+cGR1X3Z1bm1hcnNo YWwocGR1LCBvZmZzZXQsIGZtdCwgYXApOwogICAgIHZhX2VuZChhcCk7CiAKICAgICByZXR1cm4g cmV0OwpAQCAtNjcsNyArNjcsNyBAQCBzc2l6ZV90IHBkdV91bm1hcnNoYWwoVjlmc1BEVSAqcGR1 LCBzaXplX3Qgb2Zmc2V0LCBjb25zdCBjaGFyICpmbXQsIC4uLikKIAogc3RhdGljIHZvaWQgcGR1 X3B1c2hfYW5kX25vdGlmeShWOWZzUERVICpwZHUpCiB7Ci0gICAgdmlydGlvXzlwX3B1c2hfYW5k X25vdGlmeShwZHUpOworICAgIHBkdS0+cy0+dHJhbnNwb3J0LT5wdXNoX2FuZF9ub3RpZnkocGR1 KTsKIH0KIAogc3RhdGljIGludCBvbW9kZV90b191ZmxhZ3MoaW50OF90IG1vZGUpCkBAIC0xNzUx LDcgKzE3NTEsNyBAQCBzdGF0aWMgdm9pZCB2OWZzX2luaXRfcWlvdl9mcm9tX3BkdShRRU1VSU9W ZWN0b3IgKnFpb3YsIFY5ZnNQRFUgKnBkdSwKICAgICBzdHJ1Y3QgaW92ZWMgKmlvdjsKICAgICB1 bnNpZ25lZCBpbnQgbmlvdjsKIAotICAgIHZpcnRpb19pbml0X2lvdl9mcm9tX3BkdShwZHUsICZp b3YsICZuaW92LCBpc193cml0ZSk7CisgICAgcGR1LT5zLT50cmFuc3BvcnQtPmluaXRfaW92X2Zy b21fcGR1KHBkdSwgJmlvdiwgJm5pb3YsIGlzX3dyaXRlKTsKIAogICAgIHFlbXVfaW92ZWNfaW5p dF9leHRlcm5hbCgmZWxlbSwgaW92LCBuaW92KTsKICAgICBxZW11X2lvdmVjX2luaXQocWlvdiwg bmlvdik7CmRpZmYgLS1naXQgYS9ody85cGZzLzlwLmggYi9ody85cGZzLzlwLmgKaW5kZXggMDdj ZWUwMS4uYzhjOWFhOCAxMDA2NDQKLS0tIGEvaHcvOXBmcy85cC5oCisrKyBiL2h3LzlwZnMvOXAu aApAQCAtMjMwLDYgKzIzMCw3IEBAIHR5cGVkZWYgc3RydWN0IFY5ZnNTdGF0ZQogICAgIGVudW0g cDlfcHJvdG9fdmVyc2lvbiBwcm90b192ZXJzaW9uOwogICAgIGludDMyX3QgbXNpemU7CiAgICAg Vjlmc1BEVSBwZHVzW01BWF9SRVFdOworICAgIGNvbnN0IHN0cnVjdCBWOWZzVHJhbnNwb3J0ICp0 cmFuc3BvcnQ7CiAgICAgLyoKICAgICAgKiBsb2NrIGVuc3VyaW5nIGF0b21pYyBwYXRoIHVwZGF0 ZQogICAgICAqIG9uIHJlbmFtZS4KQEAgLTM0Myw0ICszNDQsMjIgQEAgdm9pZCBwZHVfZnJlZShW OWZzUERVICpwZHUpOwogdm9pZCBwZHVfc3VibWl0KFY5ZnNQRFUgKnBkdSk7CiB2b2lkIHY5ZnNf cmVzZXQoVjlmc1N0YXRlICpzKTsKIAorc3RydWN0IFY5ZnNUcmFuc3BvcnQgeworICAgIHNzaXpl X3QgICAgICgqcGR1X3ZtYXJzaGFsKShWOWZzUERVICpwZHUsIHNpemVfdCBvZmZzZXQsIGNvbnN0 IGNoYXIgKmZtdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdmFfbGlzdCBhcCk7 CisgICAgc3NpemVfdCAgICAgKCpwZHVfdnVubWFyc2hhbCkoVjlmc1BEVSAqcGR1LCBzaXplX3Qg b2Zmc2V0LCBjb25zdCBjaGFyICpmbXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgdmFfbGlzdCBhcCk7CisgICAgdm9pZCAgICAgICAgKCppbml0X2lvdl9mcm9tX3BkdSkoVjlm c1BEVSAqcGR1LCBzdHJ1Y3QgaW92ZWMgKipwaW92LAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHVuc2lnbmVkIGludCAqcG5pb3YsIGJvb2wgaXNfd3JpdGUpOworICAgIHZv aWQgICAgICAgICgqcHVzaF9hbmRfbm90aWZ5KShWOWZzUERVICpwZHUpOworfTsKKworc3RhdGlj IGlubGluZSBpbnQgdjlmc19yZWdpc3Rlcl90cmFuc3BvcnQoVjlmc1N0YXRlICpzLAorICAgICAg ICBjb25zdCBzdHJ1Y3QgVjlmc1RyYW5zcG9ydCAqdCkKK3sKKyAgICBhc3NlcnQoIXMtPnRyYW5z cG9ydCk7CisgICAgcy0+dHJhbnNwb3J0ID0gdDsKKyAgICByZXR1cm4gMDsKK30KKwogI2VuZGlm CmRpZmYgLS1naXQgYS9ody85cGZzL3ZpcnRpby05cC1kZXZpY2UuYyBiL2h3LzlwZnMvdmlydGlv LTlwLWRldmljZS5jCmluZGV4IDE3ODJlNGEuLjI3MzQyNWIgMTAwNjQ0Ci0tLSBhL2h3LzlwZnMv dmlydGlvLTlwLWRldmljZS5jCisrKyBiL2h3LzlwZnMvdmlydGlvLTlwLWRldmljZS5jCkBAIC0y MCw3ICsyMCw5IEBACiAjaW5jbHVkZSAiaHcvdmlydGlvL3ZpcnRpby1hY2Nlc3MuaCIKICNpbmNs dWRlICJxZW11L2lvdi5oIgogCi12b2lkIHZpcnRpb185cF9wdXNoX2FuZF9ub3RpZnkoVjlmc1BE VSAqcGR1KQorc3RhdGljIGNvbnN0IHN0cnVjdCBWOWZzVHJhbnNwb3J0IHZpcnRpb185cF90cmFu c3BvcnQ7CisKK3N0YXRpYyB2b2lkIHZpcnRpb185cF9wdXNoX2FuZF9ub3RpZnkoVjlmc1BEVSAq cGR1KQogewogICAgIFY5ZnNTdGF0ZSAqcyA9IHBkdS0+czsKICAgICBWOWZzVmlydGlvU3RhdGUg KnYgPSBjb250YWluZXJfb2YocywgVjlmc1ZpcnRpb1N0YXRlLCBzdGF0ZSk7CkBAIC0xMjYsNiAr MTI4LDcgQEAgc3RhdGljIHZvaWQgdmlydGlvXzlwX2RldmljZV9yZWFsaXplKERldmljZVN0YXRl ICpkZXYsIEVycm9yICoqZXJycCkKICAgICB2LT5jb25maWdfc2l6ZSA9IHNpemVvZihzdHJ1Y3Qg dmlydGlvXzlwX2NvbmZpZykgKyBzdHJsZW4ocy0+ZnNjb25mLnRhZyk7CiAgICAgdmlydGlvX2lu aXQodmRldiwgInZpcnRpby05cCIsIFZJUlRJT19JRF85UCwgdi0+Y29uZmlnX3NpemUpOwogICAg IHYtPnZxID0gdmlydGlvX2FkZF9xdWV1ZSh2ZGV2LCBNQVhfUkVRLCBoYW5kbGVfOXBfb3V0cHV0 KTsKKyAgICB2OWZzX3JlZ2lzdGVyX3RyYW5zcG9ydChzLCAmdmlydGlvXzlwX3RyYW5zcG9ydCk7 CiAKIG91dDoKICAgICByZXR1cm47CkBAIC0xNDgsOCArMTUxLDggQEAgc3RhdGljIHZvaWQgdmly dGlvXzlwX3Jlc2V0KFZpcnRJT0RldmljZSAqdmRldikKICAgICB2OWZzX3Jlc2V0KCZ2LT5zdGF0 ZSk7CiB9CiAKLXNzaXplX3QgdmlydGlvX3BkdV92bWFyc2hhbChWOWZzUERVICpwZHUsIHNpemVf dCBvZmZzZXQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqZm10LCB2 YV9saXN0IGFwKQorc3RhdGljIHNzaXplX3QgdmlydGlvX3BkdV92bWFyc2hhbChWOWZzUERVICpw ZHUsIHNpemVfdCBvZmZzZXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNv bnN0IGNoYXIgKmZtdCwgdmFfbGlzdCBhcCkKIHsKICAgICBWOWZzU3RhdGUgKnMgPSBwZHUtPnM7 CiAgICAgVjlmc1ZpcnRpb1N0YXRlICp2ID0gY29udGFpbmVyX29mKHMsIFY5ZnNWaXJ0aW9TdGF0 ZSwgc3RhdGUpOwpAQCAtMTU4LDggKzE2MSw4IEBAIHNzaXplX3QgdmlydGlvX3BkdV92bWFyc2hh bChWOWZzUERVICpwZHUsIHNpemVfdCBvZmZzZXQsCiAgICAgcmV0dXJuIHY5ZnNfaW92X3ZtYXJz aGFsKGVsZW0tPmluX3NnLCBlbGVtLT5pbl9udW0sIG9mZnNldCwgMSwgZm10LCBhcCk7CiB9CiAK LXNzaXplX3QgdmlydGlvX3BkdV92dW5tYXJzaGFsKFY5ZnNQRFUgKnBkdSwgc2l6ZV90IG9mZnNl dCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKmZtdCwgdmFfbGlz dCBhcCkKK3N0YXRpYyBzc2l6ZV90IHZpcnRpb19wZHVfdnVubWFyc2hhbChWOWZzUERVICpwZHUs IHNpemVfdCBvZmZzZXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29u c3QgY2hhciAqZm10LCB2YV9saXN0IGFwKQogewogICAgIFY5ZnNTdGF0ZSAqcyA9IHBkdS0+czsK ICAgICBWOWZzVmlydGlvU3RhdGUgKnYgPSBjb250YWluZXJfb2YocywgVjlmc1ZpcnRpb1N0YXRl LCBzdGF0ZSk7CkBAIC0xNjgsOCArMTcxLDggQEAgc3NpemVfdCB2aXJ0aW9fcGR1X3Z1bm1hcnNo YWwoVjlmc1BEVSAqcGR1LCBzaXplX3Qgb2Zmc2V0LAogICAgIHJldHVybiB2OWZzX2lvdl92dW5t YXJzaGFsKGVsZW0tPm91dF9zZywgZWxlbS0+b3V0X251bSwgb2Zmc2V0LCAxLCBmbXQsIGFwKTsK IH0KIAotdm9pZCB2aXJ0aW9faW5pdF9pb3ZfZnJvbV9wZHUoVjlmc1BEVSAqcGR1LCBzdHJ1Y3Qg aW92ZWMgKipwaW92LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgaW50 ICpwbmlvdiwgYm9vbCBpc193cml0ZSkKK3N0YXRpYyB2b2lkIHZpcnRpb19pbml0X2lvdl9mcm9t X3BkdShWOWZzUERVICpwZHUsIHN0cnVjdCBpb3ZlYyAqKnBpb3YsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgdW5zaWduZWQgaW50ICpwbmlvdiwgYm9vbCBpc193cml0ZSkK IHsKICAgICBWOWZzU3RhdGUgKnMgPSBwZHUtPnM7CiAgICAgVjlmc1ZpcnRpb1N0YXRlICp2ID0g Y29udGFpbmVyX29mKHMsIFY5ZnNWaXJ0aW9TdGF0ZSwgc3RhdGUpOwpAQCAtMTg0LDYgKzE4Nywx MyBAQCB2b2lkIHZpcnRpb19pbml0X2lvdl9mcm9tX3BkdShWOWZzUERVICpwZHUsIHN0cnVjdCBp b3ZlYyAqKnBpb3YsCiAgICAgfQogfQogCitzdGF0aWMgY29uc3Qgc3RydWN0IFY5ZnNUcmFuc3Bv cnQgdmlydGlvXzlwX3RyYW5zcG9ydCA9IHsKKyAgICAucGR1X3ZtYXJzaGFsID0gdmlydGlvX3Bk dV92bWFyc2hhbCwKKyAgICAucGR1X3Z1bm1hcnNoYWwgPSB2aXJ0aW9fcGR1X3Z1bm1hcnNoYWws CisgICAgLmluaXRfaW92X2Zyb21fcGR1ID0gdmlydGlvX2luaXRfaW92X2Zyb21fcGR1LAorICAg IC5wdXNoX2FuZF9ub3RpZnkgPSB2aXJ0aW9fOXBfcHVzaF9hbmRfbm90aWZ5LAorfTsKKwogLyog dmlydGlvLTlwIGRldmljZSAqLwogCiBzdGF0aWMgY29uc3QgVk1TdGF0ZURlc2NyaXB0aW9uIHZt c3RhdGVfdmlydGlvXzlwID0gewpkaWZmIC0tZ2l0IGEvaHcvOXBmcy92aXJ0aW8tOXAuaCBiL2h3 LzlwZnMvdmlydGlvLTlwLmgKaW5kZXggNTJjNGI5ZC4uZTc2M2RhMmMgMTAwNjQ0Ci0tLSBhL2h3 LzlwZnMvdmlydGlvLTlwLmgKKysrIGIvaHcvOXBmcy92aXJ0aW8tOXAuaApAQCAtMTQsMTUgKzE0 LDYgQEAgdHlwZWRlZiBzdHJ1Y3QgVjlmc1ZpcnRpb1N0YXRlCiAgICAgVjlmc1N0YXRlIHN0YXRl OwogfSBWOWZzVmlydGlvU3RhdGU7CiAKLXZvaWQgdmlydGlvXzlwX3B1c2hfYW5kX25vdGlmeShW OWZzUERVICpwZHUpOwotCi1zc2l6ZV90IHZpcnRpb19wZHVfdm1hcnNoYWwoVjlmc1BEVSAqcGR1 LCBzaXplX3Qgb2Zmc2V0LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIg KmZtdCwgdmFfbGlzdCBhcCk7Ci1zc2l6ZV90IHZpcnRpb19wZHVfdnVubWFyc2hhbChWOWZzUERV ICpwZHUsIHNpemVfdCBvZmZzZXQsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25z dCBjaGFyICpmbXQsIHZhX2xpc3QgYXApOwotdm9pZCB2aXJ0aW9faW5pdF9pb3ZfZnJvbV9wZHUo Vjlmc1BEVSAqcGR1LCBzdHJ1Y3QgaW92ZWMgKipwaW92LAotICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgdW5zaWduZWQgaW50ICpwbmlvdiwgYm9vbCBpc193cml0ZSk7Ci0KICNkZWZpbmUg VFlQRV9WSVJUSU9fOVAgInZpcnRpby05cC1kZXZpY2UiCiAjZGVmaW5lIFZJUlRJT185UChvYmop IFwKICAgICAgICAgT0JKRUNUX0NIRUNLKFY5ZnNWaXJ0aW9TdGF0ZSwgKG9iaiksIFRZUEVfVklS VElPXzlQKQotLSAKMS45LjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW4ub3Jn Cmh0dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK