From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752021AbeBUIE1 (ORCPT ); Wed, 21 Feb 2018 03:04:27 -0500 Received: from mail-lf0-f65.google.com ([209.85.215.65]:35418 "EHLO mail-lf0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751983AbeBUIEI (ORCPT ); Wed, 21 Feb 2018 03:04:08 -0500 X-Google-Smtp-Source: AH8x225dcnXszYm6b/+SAVHMcA+7Q5nLHtJqREvJOTmnHIvJr6G5nYHQEl9o5VHN7/GsDuqIzrIYGg== From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko Subject: [PATCH 9/9] drm/xen-front: Implement communication with backend Date: Wed, 21 Feb 2018 10:03:42 +0200 Message-Id: <1519200222-20623-10-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1519200222-20623-1-git-send-email-andr2000@gmail.com> References: <1519200222-20623-1-git-send-email-andr2000@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Oleksandr Andrushchenko Handle communication with the backend: - send requests and wait for the responses according to the displif protocol - serialize access to the communication channel - time-out used for backend communication is set to 3000 ms - manage display buffers shared with the backend Signed-off-by: Oleksandr Andrushchenko --- drivers/gpu/drm/xen/xen_drm_front.c | 327 +++++++++++++++++++++++++++++++++++- drivers/gpu/drm/xen/xen_drm_front.h | 5 + 2 files changed, 327 insertions(+), 5 deletions(-) diff --git a/drivers/gpu/drm/xen/xen_drm_front.c b/drivers/gpu/drm/xen/xen_drm_front.c index 8de88e359d5e..5ad546231d30 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.c +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -31,12 +31,146 @@ #include "xen_drm_front_evtchnl.h" #include "xen_drm_front_shbuf.h" +/* timeout in ms to wait for backend to respond */ +#define VDRM_WAIT_BACK_MS 3000 + +struct xen_drm_front_dbuf { + struct list_head list; + uint64_t dbuf_cookie; + uint64_t fb_cookie; + struct xen_drm_front_shbuf *shbuf; +}; + +static int dbuf_add_to_list(struct xen_drm_front_info *front_info, + struct xen_drm_front_shbuf *shbuf, uint64_t dbuf_cookie) +{ + struct xen_drm_front_dbuf *dbuf; + + dbuf = kzalloc(sizeof(*dbuf), GFP_KERNEL); + if (!dbuf) + return -ENOMEM; + + dbuf->dbuf_cookie = dbuf_cookie; + dbuf->shbuf = shbuf; + list_add(&dbuf->list, &front_info->dbuf_list); + return 0; +} + +static struct xen_drm_front_dbuf *dbuf_get(struct list_head *dbuf_list, + uint64_t dbuf_cookie) +{ + struct xen_drm_front_dbuf *buf, *q; + + list_for_each_entry_safe(buf, q, dbuf_list, list) + if (buf->dbuf_cookie == dbuf_cookie) + return buf; + + return NULL; +} + +static void dbuf_flush_fb(struct list_head *dbuf_list, uint64_t fb_cookie) +{ + struct xen_drm_front_dbuf *buf, *q; + + list_for_each_entry_safe(buf, q, dbuf_list, list) + if (buf->fb_cookie == fb_cookie) + xen_drm_front_shbuf_flush(buf->shbuf); +} + +static void dbuf_free(struct list_head *dbuf_list, uint64_t dbuf_cookie) +{ + struct xen_drm_front_dbuf *buf, *q; + + list_for_each_entry_safe(buf, q, dbuf_list, list) + if (buf->dbuf_cookie == dbuf_cookie) { + list_del(&buf->list); + xen_drm_front_shbuf_unmap(buf->shbuf); + xen_drm_front_shbuf_free(buf->shbuf); + kfree(buf); + break; + } +} + +static void dbuf_free_all(struct list_head *dbuf_list) +{ + struct xen_drm_front_dbuf *buf, *q; + + list_for_each_entry_safe(buf, q, dbuf_list, list) { + list_del(&buf->list); + xen_drm_front_shbuf_unmap(buf->shbuf); + xen_drm_front_shbuf_free(buf->shbuf); + kfree(buf); + } +} + +static struct xendispl_req *be_prepare_req( + struct xen_drm_front_evtchnl *evtchnl, uint8_t operation) +{ + struct xendispl_req *req; + + req = RING_GET_REQUEST(&evtchnl->u.req.ring, + evtchnl->u.req.ring.req_prod_pvt); + req->operation = operation; + req->id = evtchnl->evt_next_id++; + evtchnl->evt_id = req->id; + return req; +} + +static int be_stream_do_io(struct xen_drm_front_evtchnl *evtchnl, + struct xendispl_req *req) +{ + reinit_completion(&evtchnl->u.req.completion); + if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED)) + return -EIO; + + xen_drm_front_evtchnl_flush(evtchnl); + return 0; +} + +static int be_stream_wait_io(struct xen_drm_front_evtchnl *evtchnl) +{ + if (wait_for_completion_timeout(&evtchnl->u.req.completion, + msecs_to_jiffies(VDRM_WAIT_BACK_MS)) <= 0) + return -ETIMEDOUT; + + return evtchnl->u.req.resp_status; +} + static int be_mode_set(struct xen_drm_front_drm_pipeline *pipeline, uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint32_t bpp, uint64_t fb_cookie) { - return 0; + struct xen_drm_front_evtchnl *evtchnl; + struct xen_drm_front_info *front_info; + struct xendispl_req *req; + unsigned long flags; + int ret; + + front_info = pipeline->drm_info->front_info; + evtchnl = &front_info->evt_pairs[pipeline->index].req; + if (unlikely(!evtchnl)) + return -EIO; + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_SET_CONFIG); + req->op.set_config.x = x; + req->op.set_config.y = y; + req->op.set_config.width = width; + req->op.set_config.height = height; + req->op.set_config.bpp = bpp; + req->op.set_config.fb_cookie = fb_cookie; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + mutex_unlock(&front_info->req_io_lock); + return ret; } static int be_dbuf_create_int(struct xen_drm_front_info *front_info, @@ -44,7 +178,69 @@ static int be_dbuf_create_int(struct xen_drm_front_info *front_info, uint32_t bpp, uint64_t size, struct page **pages, struct sg_table *sgt) { + struct xen_drm_front_evtchnl *evtchnl; + struct xen_drm_front_shbuf *shbuf; + struct xendispl_req *req; + struct xen_drm_front_shbuf_cfg buf_cfg; + unsigned long flags; + int ret; + + evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req; + if (unlikely(!evtchnl)) + return -EIO; + + memset(&buf_cfg, 0, sizeof(buf_cfg)); + buf_cfg.xb_dev = front_info->xb_dev; + buf_cfg.pages = pages; + buf_cfg.size = size; + buf_cfg.sgt = sgt; + buf_cfg.be_alloc = front_info->cfg.be_alloc; + + shbuf = xen_drm_front_shbuf_alloc(&buf_cfg); + if (!shbuf) + return -ENOMEM; + + ret = dbuf_add_to_list(front_info, shbuf, dbuf_cookie); + if (ret < 0) { + xen_drm_front_shbuf_free(shbuf); + return ret; + } + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_DBUF_CREATE); + req->op.dbuf_create.gref_directory = + xen_drm_front_shbuf_get_dir_start(shbuf); + req->op.dbuf_create.buffer_sz = size; + req->op.dbuf_create.dbuf_cookie = dbuf_cookie; + req->op.dbuf_create.width = width; + req->op.dbuf_create.height = height; + req->op.dbuf_create.bpp = bpp; + if (buf_cfg.be_alloc) + req->op.dbuf_create.flags |= XENDISPL_DBUF_FLG_REQ_ALLOC; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret < 0) + goto fail; + + ret = be_stream_wait_io(evtchnl); + if (ret < 0) + goto fail; + + ret = xen_drm_front_shbuf_map(shbuf); + if (ret < 0) + goto fail; + + mutex_unlock(&front_info->req_io_lock); return 0; + +fail: + mutex_unlock(&front_info->req_io_lock); + dbuf_free(&front_info->dbuf_list, dbuf_cookie); + return ret; } static int be_dbuf_create_from_sgt(struct xen_drm_front_info *front_info, @@ -66,26 +262,144 @@ static int be_dbuf_create_from_pages(struct xen_drm_front_info *front_info, static int be_dbuf_destroy(struct xen_drm_front_info *front_info, uint64_t dbuf_cookie) { - return 0; + struct xen_drm_front_evtchnl *evtchnl; + struct xendispl_req *req; + unsigned long flags; + bool be_alloc; + int ret; + + evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req; + if (unlikely(!evtchnl)) + return -EIO; + + be_alloc = front_info->cfg.be_alloc; + + /* + * for the backend allocated buffer release references now, so backend + * can free the buffer + */ + if (be_alloc) + dbuf_free(&front_info->dbuf_list, dbuf_cookie); + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_DBUF_DESTROY); + req->op.dbuf_destroy.dbuf_cookie = dbuf_cookie; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + /* + * do this regardless of communication status with the backend: + * if we cannot remove remote resources remove what we can locally + */ + if (!be_alloc) + dbuf_free(&front_info->dbuf_list, dbuf_cookie); + + mutex_unlock(&front_info->req_io_lock); + return ret; } static int be_fb_attach(struct xen_drm_front_info *front_info, uint64_t dbuf_cookie, uint64_t fb_cookie, uint32_t width, uint32_t height, uint32_t pixel_format) { - return 0; + struct xen_drm_front_evtchnl *evtchnl; + struct xen_drm_front_dbuf *buf; + struct xendispl_req *req; + unsigned long flags; + int ret; + + evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req; + if (unlikely(!evtchnl)) + return -EIO; + + buf = dbuf_get(&front_info->dbuf_list, dbuf_cookie); + if (!buf) + return -EINVAL; + + buf->fb_cookie = fb_cookie; + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_FB_ATTACH); + req->op.fb_attach.dbuf_cookie = dbuf_cookie; + req->op.fb_attach.fb_cookie = fb_cookie; + req->op.fb_attach.width = width; + req->op.fb_attach.height = height; + req->op.fb_attach.pixel_format = pixel_format; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + mutex_unlock(&front_info->req_io_lock); + return ret; } static int be_fb_detach(struct xen_drm_front_info *front_info, uint64_t fb_cookie) { - return 0; + struct xen_drm_front_evtchnl *evtchnl; + struct xendispl_req *req; + unsigned long flags; + int ret; + + evtchnl = &front_info->evt_pairs[GENERIC_OP_EVT_CHNL].req; + if (unlikely(!evtchnl)) + return -EIO; + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_FB_DETACH); + req->op.fb_detach.fb_cookie = fb_cookie; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + mutex_unlock(&front_info->req_io_lock); + return ret; } static int be_page_flip(struct xen_drm_front_info *front_info, int conn_idx, uint64_t fb_cookie) { - return 0; + struct xen_drm_front_evtchnl *evtchnl; + struct xendispl_req *req; + unsigned long flags; + int ret; + + if (unlikely(conn_idx >= front_info->num_evt_pairs)) + return -EINVAL; + + dbuf_flush_fb(&front_info->dbuf_list, fb_cookie); + evtchnl = &front_info->evt_pairs[conn_idx].req; + + mutex_lock(&front_info->req_io_lock); + + spin_lock_irqsave(&front_info->io_lock, flags); + req = be_prepare_req(evtchnl, XENDISPL_OP_PG_FLIP); + req->op.pg_flip.fb_cookie = fb_cookie; + + ret = be_stream_do_io(evtchnl, req); + spin_unlock_irqrestore(&front_info->io_lock, flags); + + if (ret == 0) + ret = be_stream_wait_io(evtchnl); + + mutex_unlock(&front_info->req_io_lock); + return ret; } static void xen_drm_drv_unload(struct xen_drm_front_info *front_info) @@ -183,6 +497,7 @@ static void xen_drv_remove_internal(struct xen_drm_front_info *front_info) { xen_drm_drv_deinit(front_info); xen_drm_front_evtchnl_free_all(front_info); + dbuf_free_all(&front_info->dbuf_list); } static int backend_on_initwait(struct xen_drm_front_info *front_info) @@ -310,6 +625,8 @@ static int xen_drv_probe(struct xenbus_device *xb_dev, front_info->xb_dev = xb_dev; spin_lock_init(&front_info->io_lock); + mutex_init(&front_info->req_io_lock); + INIT_LIST_HEAD(&front_info->dbuf_list); front_info->drm_pdrv_registered = false; dev_set_drvdata(&xb_dev->dev, front_info); return xenbus_switch_state(xb_dev, XenbusStateInitialising); diff --git a/drivers/gpu/drm/xen/xen_drm_front.h b/drivers/gpu/drm/xen/xen_drm_front.h index c6f52c892434..db32d00145d1 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.h +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -137,6 +137,8 @@ struct xen_drm_front_info { struct xenbus_device *xb_dev; /* to protect data between backend IO code and interrupt handler */ spinlock_t io_lock; + /* serializer for backend IO: request/response */ + struct mutex req_io_lock; bool drm_pdrv_registered; /* virtual DRM platform device */ struct platform_device *drm_pdev; @@ -144,6 +146,9 @@ struct xen_drm_front_info { int num_evt_pairs; struct xen_drm_front_evtchnl_pair *evt_pairs; struct xen_drm_front_cfg cfg; + + /* display buffers */ + struct list_head dbuf_list; }; #endif /* __XEN_DRM_FRONT_H_ */ -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 9/9] drm/xen-front: Implement communication with backend Date: Wed, 21 Feb 2018 10:03:42 +0200 Message-ID: <1519200222-20623-10-git-send-email-andr2000@gmail.com> References: <1519200222-20623-1-git-send-email-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x241.google.com (mail-lf0-x241.google.com [IPv6:2a00:1450:4010:c07::241]) by gabe.freedesktop.org (Postfix) with ESMTPS id C22D06E550 for ; Wed, 21 Feb 2018 08:04:08 +0000 (UTC) Received: by mail-lf0-x241.google.com with SMTP id f19so1086472lfg.0 for ; Wed, 21 Feb 2018 00:04:08 -0800 (PST) In-Reply-To: <1519200222-20623-1-git-send-email-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKSGFuZGxlIGNvbW11bmljYXRpb24gd2l0aCB0aGUgYmFja2VuZDoKIC0gc2VuZCBy ZXF1ZXN0cyBhbmQgd2FpdCBmb3IgdGhlIHJlc3BvbnNlcyBhY2NvcmRpbmcKICAgdG8gdGhlIGRp c3BsaWYgcHJvdG9jb2wKIC0gc2VyaWFsaXplIGFjY2VzcyB0byB0aGUgY29tbXVuaWNhdGlvbiBj aGFubmVsCiAtIHRpbWUtb3V0IHVzZWQgZm9yIGJhY2tlbmQgY29tbXVuaWNhdGlvbiBpcyBzZXQg dG8gMzAwMCBtcwogLSBtYW5hZ2UgZGlzcGxheSBidWZmZXJzIHNoYXJlZCB3aXRoIHRoZSBiYWNr ZW5kCgpTaWduZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2Fu ZHJ1c2hjaGVua29AZXBhbS5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zy b250LmMgfCAzMjcgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiBkcml2ZXJz L2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaCB8ICAgNSArCiAyIGZpbGVzIGNoYW5nZWQsIDMy NyBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS94ZW4veGVuX2RybV9mcm9udC5jIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zy b250LmMKaW5kZXggOGRlODhlMzU5ZDVlLi41YWQ1NDYyMzFkMzAgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udC5jCkBAIC0zMSwxMiArMzEsMTQ2IEBACiAjaW5jbHVkZSAieGVuX2RybV9m cm9udF9ldnRjaG5sLmgiCiAjaW5jbHVkZSAieGVuX2RybV9mcm9udF9zaGJ1Zi5oIgogCisvKiB0 aW1lb3V0IGluIG1zIHRvIHdhaXQgZm9yIGJhY2tlbmQgdG8gcmVzcG9uZCAqLworI2RlZmluZSBW RFJNX1dBSVRfQkFDS19NUwkzMDAwCisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2RidWYgeworCXN0 cnVjdCBsaXN0X2hlYWQgbGlzdDsKKwl1aW50NjRfdCBkYnVmX2Nvb2tpZTsKKwl1aW50NjRfdCBm Yl9jb29raWU7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfc2hidWYgKnNoYnVmOworfTsKKworc3Rh dGljIGludCBkYnVmX2FkZF90b19saXN0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250 X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X3NoYnVmICpzaGJ1ZiwgdWludDY0X3QgZGJ1 Zl9jb29raWUpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZGJ1ZiAqZGJ1ZjsKKworCWRidWYg PSBremFsbG9jKHNpemVvZigqZGJ1ZiksIEdGUF9LRVJORUwpOworCWlmICghZGJ1ZikKKwkJcmV0 dXJuIC1FTk9NRU07CisKKwlkYnVmLT5kYnVmX2Nvb2tpZSA9IGRidWZfY29va2llOworCWRidWYt PnNoYnVmID0gc2hidWY7CisJbGlzdF9hZGQoJmRidWYtPmxpc3QsICZmcm9udF9pbmZvLT5kYnVm X2xpc3QpOworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHhlbl9kcm1fZnJvbnRfZGJ1 ZiAqZGJ1Zl9nZXQoc3RydWN0IGxpc3RfaGVhZCAqZGJ1Zl9saXN0LAorCQl1aW50NjRfdCBkYnVm X2Nvb2tpZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kYnVmICpidWYsICpxOworCisJbGlz dF9mb3JfZWFjaF9lbnRyeV9zYWZlKGJ1ZiwgcSwgZGJ1Zl9saXN0LCBsaXN0KQorCQlpZiAoYnVm LT5kYnVmX2Nvb2tpZSA9PSBkYnVmX2Nvb2tpZSkKKwkJCXJldHVybiBidWY7CisKKwlyZXR1cm4g TlVMTDsKK30KKworc3RhdGljIHZvaWQgZGJ1Zl9mbHVzaF9mYihzdHJ1Y3QgbGlzdF9oZWFkICpk YnVmX2xpc3QsIHVpbnQ2NF90IGZiX2Nvb2tpZSkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9k YnVmICpidWYsICpxOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGJ1ZiwgcSwgZGJ1Zl9s aXN0LCBsaXN0KQorCQlpZiAoYnVmLT5mYl9jb29raWUgPT0gZmJfY29va2llKQorCQkJeGVuX2Ry bV9mcm9udF9zaGJ1Zl9mbHVzaChidWYtPnNoYnVmKTsKK30KKworc3RhdGljIHZvaWQgZGJ1Zl9m cmVlKHN0cnVjdCBsaXN0X2hlYWQgKmRidWZfbGlzdCwgdWludDY0X3QgZGJ1Zl9jb29raWUpCit7 CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZGJ1ZiAqYnVmLCAqcTsKKworCWxpc3RfZm9yX2VhY2hf ZW50cnlfc2FmZShidWYsIHEsIGRidWZfbGlzdCwgbGlzdCkKKwkJaWYgKGJ1Zi0+ZGJ1Zl9jb29r aWUgPT0gZGJ1Zl9jb29raWUpIHsKKwkJCWxpc3RfZGVsKCZidWYtPmxpc3QpOworCQkJeGVuX2Ry bV9mcm9udF9zaGJ1Zl91bm1hcChidWYtPnNoYnVmKTsKKwkJCXhlbl9kcm1fZnJvbnRfc2hidWZf ZnJlZShidWYtPnNoYnVmKTsKKwkJCWtmcmVlKGJ1Zik7CisJCQlicmVhazsKKwkJfQorfQorCitz dGF0aWMgdm9pZCBkYnVmX2ZyZWVfYWxsKHN0cnVjdCBsaXN0X2hlYWQgKmRidWZfbGlzdCkKK3sK KwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kYnVmICpidWYsICpxOworCisJbGlzdF9mb3JfZWFjaF9l bnRyeV9zYWZlKGJ1ZiwgcSwgZGJ1Zl9saXN0LCBsaXN0KSB7CisJCWxpc3RfZGVsKCZidWYtPmxp c3QpOworCQl4ZW5fZHJtX2Zyb250X3NoYnVmX3VubWFwKGJ1Zi0+c2hidWYpOworCQl4ZW5fZHJt X2Zyb250X3NoYnVmX2ZyZWUoYnVmLT5zaGJ1Zik7CisJCWtmcmVlKGJ1Zik7CisJfQorfQorCitz dGF0aWMgc3RydWN0IHhlbmRpc3BsX3JlcSAqYmVfcHJlcGFyZV9yZXEoCisJCXN0cnVjdCB4ZW5f ZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmwsIHVpbnQ4X3Qgb3BlcmF0aW9uKQoreworCXN0cnVj dCB4ZW5kaXNwbF9yZXEgKnJlcTsKKworCXJlcSA9IFJJTkdfR0VUX1JFUVVFU1QoJmV2dGNobmwt PnUucmVxLnJpbmcsCisJCQlldnRjaG5sLT51LnJlcS5yaW5nLnJlcV9wcm9kX3B2dCk7CisJcmVx LT5vcGVyYXRpb24gPSBvcGVyYXRpb247CisJcmVxLT5pZCA9IGV2dGNobmwtPmV2dF9uZXh0X2lk Kys7CisJZXZ0Y2hubC0+ZXZ0X2lkID0gcmVxLT5pZDsKKwlyZXR1cm4gcmVxOworfQorCitzdGF0 aWMgaW50IGJlX3N0cmVhbV9kb19pbyhzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRj aG5sLAorCQlzdHJ1Y3QgeGVuZGlzcGxfcmVxICpyZXEpCit7CisJcmVpbml0X2NvbXBsZXRpb24o JmV2dGNobmwtPnUucmVxLmNvbXBsZXRpb24pOworCWlmICh1bmxpa2VseShldnRjaG5sLT5zdGF0 ZSAhPSBFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCkpCisJCXJldHVybiAtRUlPOworCisJeGVuX2Ry bV9mcm9udF9ldnRjaG5sX2ZsdXNoKGV2dGNobmwpOworCXJldHVybiAwOworfQorCitzdGF0aWMg aW50IGJlX3N0cmVhbV93YWl0X2lvKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNo bmwpCit7CisJaWYgKHdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmZXZ0Y2hubC0+dS5yZXEu Y29tcGxldGlvbiwKKwkJCW1zZWNzX3RvX2ppZmZpZXMoVkRSTV9XQUlUX0JBQ0tfTVMpKSA8PSAw KQorCQlyZXR1cm4gLUVUSU1FRE9VVDsKKworCXJldHVybiBldnRjaG5sLT51LnJlcS5yZXNwX3N0 YXR1czsKK30KKwogc3RhdGljIGludCBiZV9tb2RlX3NldChzdHJ1Y3QgeGVuX2RybV9mcm9udF9k cm1fcGlwZWxpbmUgKnBpcGVsaW5lLCB1aW50MzJfdCB4LAogCQl1aW50MzJfdCB5LCB1aW50MzJf dCB3aWR0aCwgdWludDMyX3QgaGVpZ2h0LCB1aW50MzJfdCBicHAsCiAJCXVpbnQ2NF90IGZiX2Nv b2tpZSkKIAogewotCXJldHVybiAwOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2 dGNobmw7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKKwlzdHJ1Y3Qg eGVuZGlzcGxfcmVxICpyZXE7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgcmV0OworCisJ ZnJvbnRfaW5mbyA9IHBpcGVsaW5lLT5kcm1faW5mby0+ZnJvbnRfaW5mbzsKKwlldnRjaG5sID0g JmZyb250X2luZm8tPmV2dF9wYWlyc1twaXBlbGluZS0+aW5kZXhdLnJlcTsKKwlpZiAodW5saWtl bHkoIWV2dGNobmwpKQorCQlyZXR1cm4gLUVJTzsKKworCW11dGV4X2xvY2soJmZyb250X2luZm8t PnJlcV9pb19sb2NrKTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZmcm9udF9pbmZvLT5pb19sb2Nr LCBmbGFncyk7CisJcmVxID0gYmVfcHJlcGFyZV9yZXEoZXZ0Y2hubCwgWEVORElTUExfT1BfU0VU X0NPTkZJRyk7CisJcmVxLT5vcC5zZXRfY29uZmlnLnggPSB4OworCXJlcS0+b3Auc2V0X2NvbmZp Zy55ID0geTsKKwlyZXEtPm9wLnNldF9jb25maWcud2lkdGggPSB3aWR0aDsKKwlyZXEtPm9wLnNl dF9jb25maWcuaGVpZ2h0ID0gaGVpZ2h0OworCXJlcS0+b3Auc2V0X2NvbmZpZy5icHAgPSBicHA7 CisJcmVxLT5vcC5zZXRfY29uZmlnLmZiX2Nvb2tpZSA9IGZiX2Nvb2tpZTsKKworCXJldCA9IGJl X3N0cmVhbV9kb19pbyhldnRjaG5sLCByZXEpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZy b250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCWlmIChyZXQgPT0gMCkKKwkJcmV0ID0gYmVf c3RyZWFtX3dhaXRfaW8oZXZ0Y2hubCk7CisKKwltdXRleF91bmxvY2soJmZyb250X2luZm8tPnJl cV9pb19sb2NrKTsKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMgaW50IGJlX2RidWZfY3JlYXRl X2ludChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLApAQCAtNDQsNyArMTc4 LDY5IEBAIHN0YXRpYyBpbnQgYmVfZGJ1Zl9jcmVhdGVfaW50KHN0cnVjdCB4ZW5fZHJtX2Zyb250 X2luZm8gKmZyb250X2luZm8sCiAJCXVpbnQzMl90IGJwcCwgdWludDY0X3Qgc2l6ZSwgc3RydWN0 IHBhZ2UgKipwYWdlcywKIAkJc3RydWN0IHNnX3RhYmxlICpzZ3QpCiB7CisJc3RydWN0IHhlbl9k cm1fZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9zaGJ1ZiAq c2hidWY7CisJc3RydWN0IHhlbmRpc3BsX3JlcSAqcmVxOworCXN0cnVjdCB4ZW5fZHJtX2Zyb250 X3NoYnVmX2NmZyBidWZfY2ZnOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IHJldDsKKwor CWV2dGNobmwgPSAmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW0dFTkVSSUNfT1BfRVZUX0NITkxdLnJl cTsKKwlpZiAodW5saWtlbHkoIWV2dGNobmwpKQorCQlyZXR1cm4gLUVJTzsKKworCW1lbXNldCgm YnVmX2NmZywgMCwgc2l6ZW9mKGJ1Zl9jZmcpKTsKKwlidWZfY2ZnLnhiX2RldiA9IGZyb250X2lu Zm8tPnhiX2RldjsKKwlidWZfY2ZnLnBhZ2VzID0gcGFnZXM7CisJYnVmX2NmZy5zaXplID0gc2l6 ZTsKKwlidWZfY2ZnLnNndCA9IHNndDsKKwlidWZfY2ZnLmJlX2FsbG9jID0gZnJvbnRfaW5mby0+ Y2ZnLmJlX2FsbG9jOworCisJc2hidWYgPSB4ZW5fZHJtX2Zyb250X3NoYnVmX2FsbG9jKCZidWZf Y2ZnKTsKKwlpZiAoIXNoYnVmKQorCQlyZXR1cm4gLUVOT01FTTsKKworCXJldCA9IGRidWZfYWRk X3RvX2xpc3QoZnJvbnRfaW5mbywgc2hidWYsIGRidWZfY29va2llKTsKKwlpZiAocmV0IDwgMCkg eworCQl4ZW5fZHJtX2Zyb250X3NoYnVmX2ZyZWUoc2hidWYpOworCQlyZXR1cm4gcmV0OworCX0K KworCW11dGV4X2xvY2soJmZyb250X2luZm8tPnJlcV9pb19sb2NrKTsKKworCXNwaW5fbG9ja19p cnFzYXZlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJcmVxID0gYmVfcHJlcGFyZV9y ZXEoZXZ0Y2hubCwgWEVORElTUExfT1BfREJVRl9DUkVBVEUpOworCXJlcS0+b3AuZGJ1Zl9jcmVh dGUuZ3JlZl9kaXJlY3RvcnkgPQorCQkJeGVuX2RybV9mcm9udF9zaGJ1Zl9nZXRfZGlyX3N0YXJ0 KHNoYnVmKTsKKwlyZXEtPm9wLmRidWZfY3JlYXRlLmJ1ZmZlcl9zeiA9IHNpemU7CisJcmVxLT5v cC5kYnVmX2NyZWF0ZS5kYnVmX2Nvb2tpZSA9IGRidWZfY29va2llOworCXJlcS0+b3AuZGJ1Zl9j cmVhdGUud2lkdGggPSB3aWR0aDsKKwlyZXEtPm9wLmRidWZfY3JlYXRlLmhlaWdodCA9IGhlaWdo dDsKKwlyZXEtPm9wLmRidWZfY3JlYXRlLmJwcCA9IGJwcDsKKwlpZiAoYnVmX2NmZy5iZV9hbGxv YykKKwkJcmVxLT5vcC5kYnVmX2NyZWF0ZS5mbGFncyB8PSBYRU5ESVNQTF9EQlVGX0ZMR19SRVFf QUxMT0M7CisKKwlyZXQgPSBiZV9zdHJlYW1fZG9faW8oZXZ0Y2hubCwgcmVxKTsKKwlzcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwlpZiAocmV0 IDwgMCkKKwkJZ290byBmYWlsOworCisJcmV0ID0gYmVfc3RyZWFtX3dhaXRfaW8oZXZ0Y2hubCk7 CisJaWYgKHJldCA8IDApCisJCWdvdG8gZmFpbDsKKworCXJldCA9IHhlbl9kcm1fZnJvbnRfc2hi dWZfbWFwKHNoYnVmKTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBmYWlsOworCisJbXV0ZXhfdW5s b2NrKCZmcm9udF9pbmZvLT5yZXFfaW9fbG9jayk7CiAJcmV0dXJuIDA7CisKK2ZhaWw6CisJbXV0 ZXhfdW5sb2NrKCZmcm9udF9pbmZvLT5yZXFfaW9fbG9jayk7CisJZGJ1Zl9mcmVlKCZmcm9udF9p bmZvLT5kYnVmX2xpc3QsIGRidWZfY29va2llKTsKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMg aW50IGJlX2RidWZfY3JlYXRlX2Zyb21fc2d0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZy b250X2luZm8sCkBAIC02NiwyNiArMjYyLDE0NCBAQCBzdGF0aWMgaW50IGJlX2RidWZfY3JlYXRl X2Zyb21fcGFnZXMoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKIHN0YXRp YyBpbnQgYmVfZGJ1Zl9kZXN0cm95KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8sCiAJCXVpbnQ2NF90IGRidWZfY29va2llKQogewotCXJldHVybiAwOworCXN0cnVjdCB4ZW5f ZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmw7CisJc3RydWN0IHhlbmRpc3BsX3JlcSAqcmVxOwor CXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJYm9vbCBiZV9hbGxvYzsKKwlpbnQgcmV0OworCisJZXZ0 Y2hubCA9ICZmcm9udF9pbmZvLT5ldnRfcGFpcnNbR0VORVJJQ19PUF9FVlRfQ0hOTF0ucmVxOwor CWlmICh1bmxpa2VseSghZXZ0Y2hubCkpCisJCXJldHVybiAtRUlPOworCisJYmVfYWxsb2MgPSBm cm9udF9pbmZvLT5jZmcuYmVfYWxsb2M7CisKKwkvKgorCSAqIGZvciB0aGUgYmFja2VuZCBhbGxv Y2F0ZWQgYnVmZmVyIHJlbGVhc2UgcmVmZXJlbmNlcyBub3csIHNvIGJhY2tlbmQKKwkgKiBjYW4g ZnJlZSB0aGUgYnVmZmVyCisJICovCisJaWYgKGJlX2FsbG9jKQorCQlkYnVmX2ZyZWUoJmZyb250 X2luZm8tPmRidWZfbGlzdCwgZGJ1Zl9jb29raWUpOworCisJbXV0ZXhfbG9jaygmZnJvbnRfaW5m by0+cmVxX2lvX2xvY2spOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmZyb250X2luZm8tPmlvX2xv Y2ssIGZsYWdzKTsKKwlyZXEgPSBiZV9wcmVwYXJlX3JlcShldnRjaG5sLCBYRU5ESVNQTF9PUF9E QlVGX0RFU1RST1kpOworCXJlcS0+b3AuZGJ1Zl9kZXN0cm95LmRidWZfY29va2llID0gZGJ1Zl9j b29raWU7CisKKwlyZXQgPSBiZV9zdHJlYW1fZG9faW8oZXZ0Y2hubCwgcmVxKTsKKwlzcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisKKwlpZiAocmV0 ID09IDApCisJCXJldCA9IGJlX3N0cmVhbV93YWl0X2lvKGV2dGNobmwpOworCisJLyoKKwkgKiBk byB0aGlzIHJlZ2FyZGxlc3Mgb2YgY29tbXVuaWNhdGlvbiBzdGF0dXMgd2l0aCB0aGUgYmFja2Vu ZDoKKwkgKiBpZiB3ZSBjYW5ub3QgcmVtb3ZlIHJlbW90ZSByZXNvdXJjZXMgcmVtb3ZlIHdoYXQg d2UgY2FuIGxvY2FsbHkKKwkgKi8KKwlpZiAoIWJlX2FsbG9jKQorCQlkYnVmX2ZyZWUoJmZyb250 X2luZm8tPmRidWZfbGlzdCwgZGJ1Zl9jb29raWUpOworCisJbXV0ZXhfdW5sb2NrKCZmcm9udF9p bmZvLT5yZXFfaW9fbG9jayk7CisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGludCBiZV9mYl9h dHRhY2goc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKIAkJdWludDY0X3Qg ZGJ1Zl9jb29raWUsIHVpbnQ2NF90IGZiX2Nvb2tpZSwgdWludDMyX3Qgd2lkdGgsCiAJCXVpbnQz Ml90IGhlaWdodCwgdWludDMyX3QgcGl4ZWxfZm9ybWF0KQogewotCXJldHVybiAwOworCXN0cnVj dCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmw7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRf ZGJ1ZiAqYnVmOworCXN0cnVjdCB4ZW5kaXNwbF9yZXEgKnJlcTsKKwl1bnNpZ25lZCBsb25nIGZs YWdzOworCWludCByZXQ7CisKKwlldnRjaG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1tHRU5F UklDX09QX0VWVF9DSE5MXS5yZXE7CisJaWYgKHVubGlrZWx5KCFldnRjaG5sKSkKKwkJcmV0dXJu IC1FSU87CisKKwlidWYgPSBkYnVmX2dldCgmZnJvbnRfaW5mby0+ZGJ1Zl9saXN0LCBkYnVmX2Nv b2tpZSk7CisJaWYgKCFidWYpCisJCXJldHVybiAtRUlOVkFMOworCisJYnVmLT5mYl9jb29raWUg PSBmYl9jb29raWU7CisKKwltdXRleF9sb2NrKCZmcm9udF9pbmZvLT5yZXFfaW9fbG9jayk7CisK KwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJlcSA9 IGJlX3ByZXBhcmVfcmVxKGV2dGNobmwsIFhFTkRJU1BMX09QX0ZCX0FUVEFDSCk7CisJcmVxLT5v cC5mYl9hdHRhY2guZGJ1Zl9jb29raWUgPSBkYnVmX2Nvb2tpZTsKKwlyZXEtPm9wLmZiX2F0dGFj aC5mYl9jb29raWUgPSBmYl9jb29raWU7CisJcmVxLT5vcC5mYl9hdHRhY2gud2lkdGggPSB3aWR0 aDsKKwlyZXEtPm9wLmZiX2F0dGFjaC5oZWlnaHQgPSBoZWlnaHQ7CisJcmVxLT5vcC5mYl9hdHRh Y2gucGl4ZWxfZm9ybWF0ID0gcGl4ZWxfZm9ybWF0OworCisJcmV0ID0gYmVfc3RyZWFtX2RvX2lv KGV2dGNobmwsIHJlcSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9f bG9jaywgZmxhZ3MpOworCisJaWYgKHJldCA9PSAwKQorCQlyZXQgPSBiZV9zdHJlYW1fd2FpdF9p byhldnRjaG5sKTsKKworCW11dGV4X3VubG9jaygmZnJvbnRfaW5mby0+cmVxX2lvX2xvY2spOwor CXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyBpbnQgYmVfZmJfZGV0YWNoKHN0cnVjdCB4ZW5fZHJt X2Zyb250X2luZm8gKmZyb250X2luZm8sCiAJCXVpbnQ2NF90IGZiX2Nvb2tpZSkKIHsKLQlyZXR1 cm4gMDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sOworCXN0cnVjdCB4 ZW5kaXNwbF9yZXEgKnJlcTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCByZXQ7CisKKwll dnRjaG5sID0gJmZyb250X2luZm8tPmV2dF9wYWlyc1tHRU5FUklDX09QX0VWVF9DSE5MXS5yZXE7 CisJaWYgKHVubGlrZWx5KCFldnRjaG5sKSkKKwkJcmV0dXJuIC1FSU87CisKKwltdXRleF9sb2Nr KCZmcm9udF9pbmZvLT5yZXFfaW9fbG9jayk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRf aW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJlcSA9IGJlX3ByZXBhcmVfcmVxKGV2dGNobmwsIFhF TkRJU1BMX09QX0ZCX0RFVEFDSCk7CisJcmVxLT5vcC5mYl9kZXRhY2guZmJfY29va2llID0gZmJf Y29va2llOworCisJcmV0ID0gYmVfc3RyZWFtX2RvX2lvKGV2dGNobmwsIHJlcSk7CisJc3Bpbl91 bmxvY2tfaXJxcmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCisJaWYgKHJl dCA9PSAwKQorCQlyZXQgPSBiZV9zdHJlYW1fd2FpdF9pbyhldnRjaG5sKTsKKworCW11dGV4X3Vu bG9jaygmZnJvbnRfaW5mby0+cmVxX2lvX2xvY2spOworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRp YyBpbnQgYmVfcGFnZV9mbGlwKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8s IGludCBjb25uX2lkeCwKIAkJdWludDY0X3QgZmJfY29va2llKQogewotCXJldHVybiAwOworCXN0 cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmw7CisJc3RydWN0IHhlbmRpc3BsX3Jl cSAqcmVxOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IHJldDsKKworCWlmICh1bmxpa2Vs eShjb25uX2lkeCA+PSBmcm9udF9pbmZvLT5udW1fZXZ0X3BhaXJzKSkKKwkJcmV0dXJuIC1FSU5W QUw7CisKKwlkYnVmX2ZsdXNoX2ZiKCZmcm9udF9pbmZvLT5kYnVmX2xpc3QsIGZiX2Nvb2tpZSk7 CisJZXZ0Y2hubCA9ICZmcm9udF9pbmZvLT5ldnRfcGFpcnNbY29ubl9pZHhdLnJlcTsKKworCW11 dGV4X2xvY2soJmZyb250X2luZm8tPnJlcV9pb19sb2NrKTsKKworCXNwaW5fbG9ja19pcnFzYXZl KCZmcm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJcmVxID0gYmVfcHJlcGFyZV9yZXEoZXZ0 Y2hubCwgWEVORElTUExfT1BfUEdfRkxJUCk7CisJcmVxLT5vcC5wZ19mbGlwLmZiX2Nvb2tpZSA9 IGZiX2Nvb2tpZTsKKworCXJldCA9IGJlX3N0cmVhbV9kb19pbyhldnRjaG5sLCByZXEpOworCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCWlm IChyZXQgPT0gMCkKKwkJcmV0ID0gYmVfc3RyZWFtX3dhaXRfaW8oZXZ0Y2hubCk7CisKKwltdXRl eF91bmxvY2soJmZyb250X2luZm8tPnJlcV9pb19sb2NrKTsKKwlyZXR1cm4gcmV0OwogfQogCiBz dGF0aWMgdm9pZCB4ZW5fZHJtX2Rydl91bmxvYWQoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAq ZnJvbnRfaW5mbykKQEAgLTE4Myw2ICs0OTcsNyBAQCBzdGF0aWMgdm9pZCB4ZW5fZHJ2X3JlbW92 ZV9pbnRlcm5hbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQogewogCXhl bl9kcm1fZHJ2X2RlaW5pdChmcm9udF9pbmZvKTsKIAl4ZW5fZHJtX2Zyb250X2V2dGNobmxfZnJl ZV9hbGwoZnJvbnRfaW5mbyk7CisJZGJ1Zl9mcmVlX2FsbCgmZnJvbnRfaW5mby0+ZGJ1Zl9saXN0 KTsKIH0KIAogc3RhdGljIGludCBiYWNrZW5kX29uX2luaXR3YWl0KHN0cnVjdCB4ZW5fZHJtX2Zy b250X2luZm8gKmZyb250X2luZm8pCkBAIC0zMTAsNiArNjI1LDggQEAgc3RhdGljIGludCB4ZW5f ZHJ2X3Byb2JlKHN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYsCiAKIAlmcm9udF9pbmZvLT54 Yl9kZXYgPSB4Yl9kZXY7CiAJc3Bpbl9sb2NrX2luaXQoJmZyb250X2luZm8tPmlvX2xvY2spOwor CW11dGV4X2luaXQoJmZyb250X2luZm8tPnJlcV9pb19sb2NrKTsKKwlJTklUX0xJU1RfSEVBRCgm ZnJvbnRfaW5mby0+ZGJ1Zl9saXN0KTsKIAlmcm9udF9pbmZvLT5kcm1fcGRydl9yZWdpc3RlcmVk ID0gZmFsc2U7CiAJZGV2X3NldF9kcnZkYXRhKCZ4Yl9kZXYtPmRldiwgZnJvbnRfaW5mbyk7CiAJ cmV0dXJuIHhlbmJ1c19zd2l0Y2hfc3RhdGUoeGJfZGV2LCBYZW5idXNTdGF0ZUluaXRpYWxpc2lu Zyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaCBiL2Ry aXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5oCmluZGV4IGM2ZjUyYzg5MjQzNC4uZGIz MmQwMDE0NWQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQu aAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaApAQCAtMTM3LDYgKzEz Nyw4IEBAIHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gewogCXN0cnVjdCB4ZW5idXNfZGV2aWNl ICp4Yl9kZXY7CiAJLyogdG8gcHJvdGVjdCBkYXRhIGJldHdlZW4gYmFja2VuZCBJTyBjb2RlIGFu ZCBpbnRlcnJ1cHQgaGFuZGxlciAqLwogCXNwaW5sb2NrX3QgaW9fbG9jazsKKwkvKiBzZXJpYWxp emVyIGZvciBiYWNrZW5kIElPOiByZXF1ZXN0L3Jlc3BvbnNlICovCisJc3RydWN0IG11dGV4IHJl cV9pb19sb2NrOwogCWJvb2wgZHJtX3BkcnZfcmVnaXN0ZXJlZDsKIAkvKiB2aXJ0dWFsIERSTSBw bGF0Zm9ybSBkZXZpY2UgKi8KIAlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpkcm1fcGRldjsKQEAg LTE0NCw2ICsxNDYsOSBAQCBzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvIHsKIAlpbnQgbnVtX2V2 dF9wYWlyczsKIAlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sX3BhaXIgKmV2dF9wYWlyczsK IAlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgY2ZnOworCisJLyogZGlzcGxheSBidWZmZXJzICov CisJc3RydWN0IGxpc3RfaGVhZCBkYnVmX2xpc3Q7CiB9OwogCiAjZW5kaWYgLyogX19YRU5fRFJN X0ZST05UX0hfICovCi0tIAoyLjcuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGlu Zm8vZHJpLWRldmVsCg==