From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 218C8C433EF for ; Sun, 24 Apr 2022 06:21:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238357AbiDXGYq (ORCPT ); Sun, 24 Apr 2022 02:24:46 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39778 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S237413AbiDXGYl (ORCPT ); Sun, 24 Apr 2022 02:24:41 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id A93D127CD4 for ; Sat, 23 Apr 2022 23:21:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1650781299; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=pn5vZufU+wZDPtEw0CFV7kn4KWKqaAcFWOLs0ntfZac=; b=bf2szs2UYG0MvPhcwYFfW8LdlhKuDG5s71lQ1cT11u5E8qQ0+dswToTsCzX7ZxXifrl5mg 5DC1cOUfYdQ1Wqqc0SVqQtwbyfyxHgBTl8s5CCXpIGJYjJXDrroCkK+crU78tYGM1ov6Xe NWYQJW/0OaSOGBSJPLGojIJD+rChLvk= Received: from mail-lf1-f70.google.com (mail-lf1-f70.google.com [209.85.167.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-532-eEk_ztnaPpiMk_P0027zxw-1; Sun, 24 Apr 2022 02:21:38 -0400 X-MC-Unique: eEk_ztnaPpiMk_P0027zxw-1 Received: by mail-lf1-f70.google.com with SMTP id d13-20020a056512320d00b0046f5098597eso4925130lfe.16 for ; Sat, 23 Apr 2022 23:21:37 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=pn5vZufU+wZDPtEw0CFV7kn4KWKqaAcFWOLs0ntfZac=; b=zjHxAqlFEZMKYWz9oVLbGKRXZ4rdFVR8pTAYJuv9BR6aclymGbqKTofwYEP3xE5lM8 x7dSPW8IeAgaHpk8G3Edva5vI1b3l638bnoit9PVesGW3Qzmj7DLXp1/31IjZno0aGpb 5BnrJkJ7mAnZeBk1/GhToEB5ic+dkNlz8ok4/WILvKr8ryDwPOOyn4Wqh1KmYlYt4Cvm rZlIy2dthiG8CIqvwpMV2MmDsJaLxQFQ5dLAEWv2sf0WsLookLNTDtWkA3cEtthWm71j x68LikcmviXa64ppaYcZrlCC0qTC2eZTtlNcPDjMYATdJgmQatpdyTdLIk9+ns/x9FaO Yaog== X-Gm-Message-State: AOAM531CEq0DSWpI6BSm4I60mWhrJexy1Axlb0D1gUZKUNWkJj/tqwSF 9JevKFWuCXB/vkNHS1F9zmqs43hY/LUIIExsw/L77aHj6tEniZHaoQc0V7KK+GZYJEFqcQTZsGP K3dRinqenEUnZhOrZrAFvzdF2oO3kzXHmKcWmsAWp X-Received: by 2002:a05:6512:1293:b0:471:a1bb:d55d with SMTP id u19-20020a056512129300b00471a1bbd55dmr8776247lfs.190.1650781296309; Sat, 23 Apr 2022 23:21:36 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzMmn8zJap4RF0U5O3fAKz3sI59WuUzJ31zf05jpgT2C2tst+mp5petO9CvsrPyt/DXHj/5ufUwbFjHQ7xrJ14= X-Received: by 2002:a05:6512:1293:b0:471:a1bb:d55d with SMTP id u19-20020a056512129300b00471a1bbd55dmr8776242lfs.190.1650781296086; Sat, 23 Apr 2022 23:21:36 -0700 (PDT) MIME-Version: 1.0 References: <20220421104016.453458-1-pizhenwei@bytedance.com> <20220421104016.453458-2-pizhenwei@bytedance.com> <7996f495-3bb8-fa80-7866-fa1fbff3e80a@redhat.com> In-Reply-To: From: Jason Wang Date: Sun, 24 Apr 2022 14:21:24 +0800 Message-ID: Subject: Re: Re: [PATCH v3 1/5] virtio-crypto: use private buffer for control request To: zhenwei pi Cc: "Gonglei (Arei)" , mst , Herbert Xu , linux-kernel , virtualization , linux-crypto@vger.kernel.org, helei.sig11@bytedance.com, davem Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-crypto@vger.kernel.org On Fri, Apr 22, 2022 at 5:12 PM zhenwei pi wrote: > > On 4/22/22 15:41, Jason Wang wrote: > > > > =E5=9C=A8 2022/4/21 18:40, zhenwei pi =E5=86=99=E9=81=93: > >> Originally, all of the control requests share a single buffer( > >> ctrl & input & ctrl_status fields in struct virtio_crypto), this > >> allows queue depth 1 only, the performance of control queue gets > >> limited by this design. > >> > >> In this patch, each request allocates request buffer dynamically, and > >> free buffer after request, it's possible to optimize control queue > >> depth in the next step. > >> > >> A necessary comment is already in code, still describe it again: > >> /* > >> * Note: there are padding fields in request, clear them to zero befo= re > >> * sending to host, > >> * Ex, virtio_crypto_ctrl_request::ctrl::u::destroy_session::padding[= 48] > >> */ > >> So use kzalloc to allocate buffer of struct virtio_crypto_ctrl_request= . > >> > >> Cc: Michael S. Tsirkin > >> Cc: Jason Wang > >> Cc: Gonglei > >> Signed-off-by: zhenwei pi > >> --- > >> drivers/crypto/virtio/Makefile | 1 + > >> .../virtio/virtio_crypto_akcipher_algs.c | 90 ++++++------ > >> drivers/crypto/virtio/virtio_crypto_common.c | 39 +++++ > > > > > > Any reason we can't use virtio_crypto_core.c? > > > Another patch in this series: [PATCH v3 3/5] virtio-crypto: move helpers > into virtio_crypto_common.c > > Move virtcrypto_clear_request and virtcrypto_dataq_callback into > virtio_crypto_common.c to make code clear. Then the xx_core.c > supports: > - probe/remove/irq affinity seting for a virtio device > - basic virtio related operations > > xx_common.c supports: > - common helpers/functions for algos > > So I put this into a new file. I don't see obvious differences but we can leave it to the virtio-crypto maintainers to decide. > > > > >> drivers/crypto/virtio/virtio_crypto_common.h | 19 ++- > >> .../virtio/virtio_crypto_skcipher_algs.c | 133 ++++++++--------= -- > >> 5 files changed, 156 insertions(+), 126 deletions(-) > >> create mode 100644 drivers/crypto/virtio/virtio_crypto_common.c > >> > >> diff --git a/drivers/crypto/virtio/Makefile > >> b/drivers/crypto/virtio/Makefile > >> index bfa6cbae342e..49c1fa80e465 100644 > >> --- a/drivers/crypto/virtio/Makefile > >> +++ b/drivers/crypto/virtio/Makefile > >> @@ -3,5 +3,6 @@ obj-$(CONFIG_CRYPTO_DEV_VIRTIO) +=3D virtio_crypto.o > >> virtio_crypto-objs :=3D \ > >> virtio_crypto_skcipher_algs.o \ > >> virtio_crypto_akcipher_algs.o \ > >> + virtio_crypto_common.o \ > >> virtio_crypto_mgr.o \ > >> virtio_crypto_core.o > >> diff --git a/drivers/crypto/virtio/virtio_crypto_akcipher_algs.c > >> b/drivers/crypto/virtio/virtio_crypto_akcipher_algs.c > >> index f3ec9420215e..9561bc2df62b 100644 > >> --- a/drivers/crypto/virtio/virtio_crypto_akcipher_algs.c > >> +++ b/drivers/crypto/virtio/virtio_crypto_akcipher_algs.c > >> @@ -102,8 +102,8 @@ static int > >> virtio_crypto_alg_akcipher_init_session(struct virtio_crypto_akcipher > >> { > >> struct scatterlist outhdr_sg, key_sg, inhdr_sg, *sgs[3]; > >> struct virtio_crypto *vcrypto =3D ctx->vcrypto; > >> + struct virtio_crypto_ctrl_request *vc_ctrl_req; > >> uint8_t *pkey; > >> - unsigned int inlen; > >> int err; > >> unsigned int num_out =3D 0, num_in =3D 0; > >> @@ -111,98 +111,91 @@ static int > >> virtio_crypto_alg_akcipher_init_session(struct virtio_crypto_akcipher > >> if (!pkey) > >> return -ENOMEM; > >> - spin_lock(&vcrypto->ctrl_lock); > >> - memcpy(&vcrypto->ctrl.header, header, sizeof(vcrypto->ctrl.header= )); > >> - memcpy(&vcrypto->ctrl.u, para, sizeof(vcrypto->ctrl.u)); > >> - vcrypto->input.status =3D cpu_to_le32(VIRTIO_CRYPTO_ERR); > >> + vc_ctrl_req =3D kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); > >> + if (!vc_ctrl_req) { > >> + err =3D -ENOMEM; > >> + goto out; > >> + } > >> - sg_init_one(&outhdr_sg, &vcrypto->ctrl, sizeof(vcrypto->ctrl)); > >> + memcpy(&vc_ctrl_req->ctrl.header, header, > >> sizeof(vc_ctrl_req->ctrl.header)); > >> + memcpy(&vc_ctrl_req->ctrl.u, para, sizeof(vc_ctrl_req->ctrl.u)); > >> + sg_init_one(&outhdr_sg, &vc_ctrl_req->ctrl, > >> sizeof(vc_ctrl_req->ctrl)); > >> sgs[num_out++] =3D &outhdr_sg; > >> sg_init_one(&key_sg, pkey, keylen); > >> sgs[num_out++] =3D &key_sg; > >> - sg_init_one(&inhdr_sg, &vcrypto->input, sizeof(vcrypto->input)); > >> + vc_ctrl_req->input.status =3D cpu_to_le32(VIRTIO_CRYPTO_ERR); > > > > > > Nit: if there's no special reason, let's move this after the above > > memcpys as what's done previously. > > > > > >> + sg_init_one(&inhdr_sg, &vc_ctrl_req->input, > >> sizeof(vc_ctrl_req->input)); > >> sgs[num_out + num_in++] =3D &inhdr_sg; > >> - err =3D virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, num_out, num_in, > >> vcrypto, GFP_ATOMIC); > >> + err =3D virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, > >> num_in, vc_ctrl_req); > > > > > > I'd split this into a separate patch. > > > > OK! > > > >> if (err < 0) > >> goto out; > >> - virtqueue_kick(vcrypto->ctrl_vq); > >> - while (!virtqueue_get_buf(vcrypto->ctrl_vq, &inlen) && > >> - !virtqueue_is_broken(vcrypto->ctrl_vq)) > >> - cpu_relax(); > >> - > >> - if (le32_to_cpu(vcrypto->input.status) !=3D VIRTIO_CRYPTO_OK) { > >> + if (le32_to_cpu(vc_ctrl_req->input.status) !=3D VIRTIO_CRYPTO_OK)= { > >> + pr_err("virtio_crypto: Create session failed status: %u\n", > >> + le32_to_cpu(vc_ctrl_req->input.status)); > >> err =3D -EINVAL; > >> goto out; > >> } > > > > > > Do we need a warning for -ENOMEM? > > > > Memory(especially small size) allocation is unlikely case, I also check > the virtio_net and virtio_blk, both handles -ENOMEM only without error > reporting. Ok. > > > > >> - ctx->session_id =3D le64_to_cpu(vcrypto->input.session_id); > >> + ctx->session_id =3D le64_to_cpu(vc_ctrl_req->input.session_id); > >> ctx->session_valid =3D true; > >> err =3D 0; > >> out: > >> - spin_unlock(&vcrypto->ctrl_lock); > >> + kfree(vc_ctrl_req); > >> kfree_sensitive(pkey); > >> - if (err < 0) > >> - pr_err("virtio_crypto: Create session failed status: %u\n", > >> - le32_to_cpu(vcrypto->input.status)); > >> - > >> return err; > >> } > >> static int virtio_crypto_alg_akcipher_close_session(struct > >> virtio_crypto_akcipher_ctx *ctx) > >> { > >> struct scatterlist outhdr_sg, inhdr_sg, *sgs[2]; > >> + struct virtio_crypto_ctrl_request *vc_ctrl_req; > >> struct virtio_crypto_destroy_session_req *destroy_session; > >> struct virtio_crypto *vcrypto =3D ctx->vcrypto; > >> - unsigned int num_out =3D 0, num_in =3D 0, inlen; > >> + unsigned int num_out =3D 0, num_in =3D 0; > >> int err; > >> - spin_lock(&vcrypto->ctrl_lock); > >> - if (!ctx->session_valid) { > >> - err =3D 0; > >> - goto out; > >> - } > >> - vcrypto->ctrl_status.status =3D VIRTIO_CRYPTO_ERR; > >> - vcrypto->ctrl.header.opcode =3D > >> cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION); > >> - vcrypto->ctrl.header.queue_id =3D 0; > >> + if (!ctx->session_valid) > >> + return 0; > >> - destroy_session =3D &vcrypto->ctrl.u.destroy_session; > >> + vc_ctrl_req =3D kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); > >> + if (!vc_ctrl_req) > >> + return -ENOMEM; > >> + > >> + vc_ctrl_req->ctrl.header.opcode =3D > >> cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION); > >> + vc_ctrl_req->ctrl.header.queue_id =3D 0; > >> + > >> + destroy_session =3D &vc_ctrl_req->ctrl.u.destroy_session; > >> destroy_session->session_id =3D cpu_to_le64(ctx->session_id); > >> - sg_init_one(&outhdr_sg, &vcrypto->ctrl, sizeof(vcrypto->ctrl)); > >> + sg_init_one(&outhdr_sg, &vc_ctrl_req->ctrl, > >> sizeof(vc_ctrl_req->ctrl)); > >> sgs[num_out++] =3D &outhdr_sg; > >> - sg_init_one(&inhdr_sg, &vcrypto->ctrl_status.status, > >> sizeof(vcrypto->ctrl_status.status)); > >> + vc_ctrl_req->ctrl_status.status =3D VIRTIO_CRYPTO_ERR; > > > > > > If no special reason, let's move this above: > > > > vc_ctrl_req->ctrl.header.opcode =3D > > cpu_to_le32(VIRTIO_CRYPTO_AKCIPHER_DESTROY_SESSION); > > > > OK! > > > >> + sg_init_one(&inhdr_sg, &vc_ctrl_req->ctrl_status.status, > >> + sizeof(vc_ctrl_req->ctrl_status.status)); > >> sgs[num_out + num_in++] =3D &inhdr_sg; > >> - err =3D virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, num_out, num_in, > >> vcrypto, GFP_ATOMIC); > >> + err =3D virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, > >> num_in, vc_ctrl_req); > >> if (err < 0) > >> goto out; > >> - virtqueue_kick(vcrypto->ctrl_vq); > >> - while (!virtqueue_get_buf(vcrypto->ctrl_vq, &inlen) && > >> - !virtqueue_is_broken(vcrypto->ctrl_vq)) > >> - cpu_relax(); > >> - > >> - if (vcrypto->ctrl_status.status !=3D VIRTIO_CRYPTO_OK) { > >> + if (vc_ctrl_req->ctrl_status.status !=3D VIRTIO_CRYPTO_OK) { > >> err =3D -EINVAL; > >> + pr_err("virtio_crypto: Close session failed status: %u, > >> session_id: 0x%llx\n", > >> + vc_ctrl_req->ctrl_status.status, > >> destroy_session->session_id); > >> goto out; > >> } > >> err =3D 0; > >> ctx->session_valid =3D false; > >> - > >> out: > >> - spin_unlock(&vcrypto->ctrl_lock); > >> - if (err < 0) { > >> - pr_err("virtio_crypto: Close session failed status: %u, > >> session_id: 0x%llx\n", > >> - vcrypto->ctrl_status.status, destroy_session->session_id)= ; > >> - } > >> + kfree(vc_ctrl_req); > >> return err; > >> } > >> @@ -210,14 +203,11 @@ static int > >> virtio_crypto_alg_akcipher_close_session(struct virtio_crypto_akciphe > >> static int __virtio_crypto_akcipher_do_req(struct > >> virtio_crypto_akcipher_request *vc_akcipher_req, > >> struct akcipher_request *req, struct data_queue *data_vq) > >> { > >> - struct virtio_crypto_akcipher_ctx *ctx =3D > >> vc_akcipher_req->akcipher_ctx; > >> struct virtio_crypto_request *vc_req =3D &vc_akcipher_req->base; > >> - struct virtio_crypto *vcrypto =3D ctx->vcrypto; > >> struct virtio_crypto_op_data_req *req_data =3D vc_req->req_data; > >> struct scatterlist *sgs[4], outhdr_sg, inhdr_sg, srcdata_sg, > >> dstdata_sg; > >> void *src_buf =3D NULL, *dst_buf =3D NULL; > >> unsigned int num_out =3D 0, num_in =3D 0; > >> - int node =3D dev_to_node(&vcrypto->vdev->dev); > >> unsigned long flags; > >> int ret =3D -ENOMEM; > >> bool verify =3D vc_akcipher_req->opcode =3D=3D > >> VIRTIO_CRYPTO_AKCIPHER_VERIFY; > >> @@ -228,7 +218,7 @@ static int __virtio_crypto_akcipher_do_req(struct > >> virtio_crypto_akcipher_request > >> sgs[num_out++] =3D &outhdr_sg; > >> /* src data */ > >> - src_buf =3D kcalloc_node(src_len, 1, GFP_KERNEL, node); > >> + src_buf =3D kcalloc(src_len, 1, GFP_KERNEL); > > > > > > This seems not a relevant change. If it is a must we need use a separat= e > > for this and describe the rationale. > > > > > >> if (!src_buf) > >> goto err; > >> @@ -243,7 +233,7 @@ static int __virtio_crypto_akcipher_do_req(struct > >> virtio_crypto_akcipher_request > >> sgs[num_out++] =3D &srcdata_sg; > >> /* dst data */ > >> - dst_buf =3D kcalloc_node(req->dst_len, 1, GFP_KERNEL, node); > >> + dst_buf =3D kcalloc(req->dst_len, 1, GFP_KERNEL); > > > > > > And this. > > > > > >> if (!dst_buf) > >> goto err; > >> diff --git a/drivers/crypto/virtio/virtio_crypto_common.c > >> b/drivers/crypto/virtio/virtio_crypto_common.c > >> new file mode 100644 > >> index 000000000000..e65125a74db2 > >> --- /dev/null > >> +++ b/drivers/crypto/virtio/virtio_crypto_common.c > >> @@ -0,0 +1,39 @@ > >> +// SPDX-License-Identifier: GPL-2.0-or-later > >> +/* Common functions and helpers > >> + * > >> + * Authors: zhenwei pi > >> + * > >> + * Copyright 2022 Bytedance CO., LTD. > >> + */ > >> + > >> +#include "virtio_crypto_common.h" > >> + > >> +int virtio_crypto_ctrl_vq_request(struct virtio_crypto *vcrypto, > >> struct scatterlist *sgs[], > >> + unsigned int out_sgs, unsigned int in_sgs, > >> + struct virtio_crypto_ctrl_request *vc_ctrl_req) > >> +{ > >> + int err; > >> + unsigned int inlen; > >> + unsigned long flags; > >> + > >> + spin_lock_irqsave(&vcrypto->ctrl_lock, flags); > >> + err =3D virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, out_sgs, in_sgs, > >> vc_ctrl_req, GFP_ATOMIC); > >> + if (err < 0) { > >> + spin_unlock_irqrestore(&vcrypto->ctrl_lock, flags); > >> + return err; > >> + } > >> + > >> + virtqueue_kick(vcrypto->ctrl_vq); > >> + > >> + /* > >> + * Trapping into the hypervisor, so the request should be > >> + * handled immediately. > >> + */ > >> + while (!virtqueue_get_buf(vcrypto->ctrl_vq, &inlen) && > >> + !virtqueue_is_broken(vcrypto->ctrl_vq)) > >> + cpu_relax(); > >> + > >> + spin_unlock_irqrestore(&vcrypto->ctrl_lock, flags); > >> + > >> + return 0; > >> +} > >> diff --git a/drivers/crypto/virtio/virtio_crypto_common.h > >> b/drivers/crypto/virtio/virtio_crypto_common.h > >> index e693d4ee83a6..d2a20fe6e13e 100644 > >> --- a/drivers/crypto/virtio/virtio_crypto_common.h > >> +++ b/drivers/crypto/virtio/virtio_crypto_common.h > >> @@ -13,6 +13,7 @@ > >> #include > >> #include > >> #include > >> +#include > >> /* Internal representation of a data virtqueue */ > >> @@ -65,11 +66,6 @@ struct virtio_crypto { > >> /* Maximum size of per request */ > >> u64 max_size; > >> - /* Control VQ buffers: protected by the ctrl_lock */ > >> - struct virtio_crypto_op_ctrl_req ctrl; > >> - struct virtio_crypto_session_input input; > >> - struct virtio_crypto_inhdr ctrl_status; > >> - > >> unsigned long status; > >> atomic_t ref_count; > >> struct list_head list; > >> @@ -85,6 +81,16 @@ struct virtio_crypto_sym_session_info { > >> __u64 session_id; > >> }; > >> +/* > >> + * Note: there are padding fields in request, clear them to zero > >> before sending to host, > >> + * Ex, virtio_crypto_ctrl_request::ctrl::u::destroy_session::padding[= 48] > >> + */ > >> +struct virtio_crypto_ctrl_request { > >> + struct virtio_crypto_op_ctrl_req ctrl; > >> + struct virtio_crypto_session_input input; > >> + struct virtio_crypto_inhdr ctrl_status; > >> +}; > >> + > >> struct virtio_crypto_request; > >> typedef void (*virtio_crypto_data_callback) > >> (struct virtio_crypto_request *vc_req, int len); > >> @@ -135,4 +141,7 @@ void virtio_crypto_skcipher_algs_unregister(struct > >> virtio_crypto *vcrypto); > >> int virtio_crypto_akcipher_algs_register(struct virtio_crypto > >> *vcrypto); > >> void virtio_crypto_akcipher_algs_unregister(struct virtio_crypto > >> *vcrypto); > >> +int virtio_crypto_ctrl_vq_request(struct virtio_crypto *vcrypto, > >> struct scatterlist *sgs[], > >> + unsigned int out_sgs, unsigned int in_sgs, > >> + struct virtio_crypto_ctrl_request *vc_ctrl_req); > >> #endif /* _VIRTIO_CRYPTO_COMMON_H */ > >> diff --git a/drivers/crypto/virtio/virtio_crypto_skcipher_algs.c > >> b/drivers/crypto/virtio/virtio_crypto_skcipher_algs.c > >> index a618c46a52b8..fef355ff461c 100644 > >> --- a/drivers/crypto/virtio/virtio_crypto_skcipher_algs.c > >> +++ b/drivers/crypto/virtio/virtio_crypto_skcipher_algs.c > >> @@ -118,11 +118,13 @@ static int virtio_crypto_alg_skcipher_init_sessi= on( > >> int encrypt) > >> { > >> struct scatterlist outhdr, key_sg, inhdr, *sgs[3]; > >> - unsigned int tmp; > >> struct virtio_crypto *vcrypto =3D ctx->vcrypto; > > > > > > Can we simply rename this to virtcrypto and then we can use the name > > "vcrypto" for virtio_crypto_ctrl_request then we save tons lot changes? > > > > It simplify the life of reviewers and backporting. > > > > Thanks > > > > This series focuses on performance improvment, and keeps the style with > the orignal style. What about fixing this in another series? (If so, > I'll fix this later) Just in case we are at the same page, what I suggest can save hundreds lines of codes: E.g: > >> - vcrypto->ctrl.header.queue_id =3D 0; > >> + header->queue_id =3D 0; If we stick to the name of "vcrypto" we don't need this change at all. It can simplify: 1) future context difference when backporting patches to -stable 2) reviewing Thanks > > > >> int op =3D encrypt ? VIRTIO_CRYPTO_OP_ENCRYPT : > >> VIRTIO_CRYPTO_OP_DECRYPT; > >> int err; > >> unsigned int num_out =3D 0, num_in =3D 0; > >> + struct virtio_crypto_ctrl_request *vc_ctrl_req; > >> + struct virtio_crypto_ctrl_header *header; > >> + struct virtio_crypto_sym_create_session_req *sym_create_session; > >> /* > >> * Avoid to do DMA from the stack, switch to using > >> @@ -133,26 +135,27 @@ static int virtio_crypto_alg_skcipher_init_sessi= on( > >> if (!cipher_key) > >> return -ENOMEM; > >> - spin_lock(&vcrypto->ctrl_lock); > >> + vc_ctrl_req =3D kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); > >> + if (!vc_ctrl_req) { > >> + err =3D -ENOMEM; > >> + goto out; > >> + } > >> + > >> /* Pad ctrl header */ > >> - vcrypto->ctrl.header.opcode =3D > >> - cpu_to_le32(VIRTIO_CRYPTO_CIPHER_CREATE_SESSION); > >> - vcrypto->ctrl.header.algo =3D cpu_to_le32(alg); > >> + header =3D &vc_ctrl_req->ctrl.header; > >> + header->opcode =3D cpu_to_le32(VIRTIO_CRYPTO_CIPHER_CREATE_SESSIO= N); > >> + header->algo =3D cpu_to_le32(alg); > >> /* Set the default dataqueue id to 0 */ > >> - vcrypto->ctrl.header.queue_id =3D 0; > >> + header->queue_id =3D 0; > >> - vcrypto->input.status =3D cpu_to_le32(VIRTIO_CRYPTO_ERR); > >> /* Pad cipher's parameters */ > >> - vcrypto->ctrl.u.sym_create_session.op_type =3D > >> - cpu_to_le32(VIRTIO_CRYPTO_SYM_OP_CIPHER); > >> - vcrypto->ctrl.u.sym_create_session.u.cipher.para.algo =3D > >> - vcrypto->ctrl.header.algo; > >> - vcrypto->ctrl.u.sym_create_session.u.cipher.para.keylen =3D > >> - cpu_to_le32(keylen); > >> - vcrypto->ctrl.u.sym_create_session.u.cipher.para.op =3D > >> - cpu_to_le32(op); > >> - > >> - sg_init_one(&outhdr, &vcrypto->ctrl, sizeof(vcrypto->ctrl)); > >> + sym_create_session =3D &vc_ctrl_req->ctrl.u.sym_create_session; > >> + sym_create_session->op_type =3D > >> cpu_to_le32(VIRTIO_CRYPTO_SYM_OP_CIPHER); > >> + sym_create_session->u.cipher.para.algo =3D header->algo; > >> + sym_create_session->u.cipher.para.keylen =3D cpu_to_le32(keylen); > >> + sym_create_session->u.cipher.para.op =3D cpu_to_le32(op); > >> + > >> + sg_init_one(&outhdr, &vc_ctrl_req->ctrl, sizeof(vc_ctrl_req->ctrl= )); > >> sgs[num_out++] =3D &outhdr; > >> /* Set key */ > >> @@ -160,45 +163,34 @@ static int virtio_crypto_alg_skcipher_init_sessi= on( > >> sgs[num_out++] =3D &key_sg; > >> /* Return status and session id back */ > >> - sg_init_one(&inhdr, &vcrypto->input, sizeof(vcrypto->input)); > >> + vc_ctrl_req->input.status =3D cpu_to_le32(VIRTIO_CRYPTO_ERR); > >> + sg_init_one(&inhdr, &vc_ctrl_req->input, > >> sizeof(vc_ctrl_req->input)); > >> sgs[num_out + num_in++] =3D &inhdr; > >> - err =3D virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, num_out, > >> - num_in, vcrypto, GFP_ATOMIC); > >> - if (err < 0) { > >> - spin_unlock(&vcrypto->ctrl_lock); > >> - kfree_sensitive(cipher_key); > >> - return err; > >> - } > >> - virtqueue_kick(vcrypto->ctrl_vq); > >> - > >> - /* > >> - * Trapping into the hypervisor, so the request should be > >> - * handled immediately. > >> - */ > >> - while (!virtqueue_get_buf(vcrypto->ctrl_vq, &tmp) && > >> - !virtqueue_is_broken(vcrypto->ctrl_vq)) > >> - cpu_relax(); > >> + err =3D virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, > >> num_in, vc_ctrl_req); > >> + if (err < 0) > >> + goto out; > >> - if (le32_to_cpu(vcrypto->input.status) !=3D VIRTIO_CRYPTO_OK) { > >> - spin_unlock(&vcrypto->ctrl_lock); > >> + if (le32_to_cpu(vc_ctrl_req->input.status) !=3D VIRTIO_CRYPTO_OK)= { > >> pr_err("virtio_crypto: Create session failed status: %u\n", > >> - le32_to_cpu(vcrypto->input.status)); > >> - kfree_sensitive(cipher_key); > >> - return -EINVAL; > >> + le32_to_cpu(vc_ctrl_req->input.status)); > >> + err =3D -EINVAL; > >> + goto out; > >> } > >> if (encrypt) > >> ctx->enc_sess_info.session_id =3D > >> - le64_to_cpu(vcrypto->input.session_id); > >> + le64_to_cpu(vc_ctrl_req->input.session_id); > >> else > >> ctx->dec_sess_info.session_id =3D > >> - le64_to_cpu(vcrypto->input.session_id); > >> - > >> - spin_unlock(&vcrypto->ctrl_lock); > >> + le64_to_cpu(vc_ctrl_req->input.session_id); > >> + err =3D 0; > >> +out: > >> + kfree(vc_ctrl_req); > >> kfree_sensitive(cipher_key); > >> - return 0; > >> + > >> + return err; > >> } > >> static int virtio_crypto_alg_skcipher_close_session( > >> @@ -206,21 +198,24 @@ static int > >> virtio_crypto_alg_skcipher_close_session( > >> int encrypt) > >> { > >> struct scatterlist outhdr, status_sg, *sgs[2]; > >> - unsigned int tmp; > >> struct virtio_crypto_destroy_session_req *destroy_session; > >> struct virtio_crypto *vcrypto =3D ctx->vcrypto; > >> int err; > >> unsigned int num_out =3D 0, num_in =3D 0; > >> + struct virtio_crypto_ctrl_request *vc_ctrl_req; > >> + struct virtio_crypto_ctrl_header *header; > >> + > >> + vc_ctrl_req =3D kzalloc(sizeof(*vc_ctrl_req), GFP_KERNEL); > >> + if (!vc_ctrl_req) > >> + return -ENOMEM; > >> - spin_lock(&vcrypto->ctrl_lock); > >> - vcrypto->ctrl_status.status =3D VIRTIO_CRYPTO_ERR; > >> /* Pad ctrl header */ > >> - vcrypto->ctrl.header.opcode =3D > >> - cpu_to_le32(VIRTIO_CRYPTO_CIPHER_DESTROY_SESSION); > >> + header =3D &vc_ctrl_req->ctrl.header; > >> + header->opcode =3D cpu_to_le32(VIRTIO_CRYPTO_CIPHER_DESTROY_SESSI= ON); > >> /* Set the default virtqueue id to 0 */ > >> - vcrypto->ctrl.header.queue_id =3D 0; > >> + header->queue_id =3D 0; > >> - destroy_session =3D &vcrypto->ctrl.u.destroy_session; > >> + destroy_session =3D &vc_ctrl_req->ctrl.u.destroy_session; > >> if (encrypt) > >> destroy_session->session_id =3D > >> @@ -229,37 +224,33 @@ static int > >> virtio_crypto_alg_skcipher_close_session( > >> destroy_session->session_id =3D > >> cpu_to_le64(ctx->dec_sess_info.session_id); > >> - sg_init_one(&outhdr, &vcrypto->ctrl, sizeof(vcrypto->ctrl)); > >> + sg_init_one(&outhdr, &vc_ctrl_req->ctrl, sizeof(vc_ctrl_req->ctrl= )); > >> sgs[num_out++] =3D &outhdr; > >> /* Return status and session id back */ > >> - sg_init_one(&status_sg, &vcrypto->ctrl_status.status, > >> - sizeof(vcrypto->ctrl_status.status)); > >> + vc_ctrl_req->ctrl_status.status =3D VIRTIO_CRYPTO_ERR; > >> + sg_init_one(&status_sg, &vc_ctrl_req->ctrl_status.status, > >> + sizeof(vc_ctrl_req->ctrl_status.status)); > >> sgs[num_out + num_in++] =3D &status_sg; > >> - err =3D virtqueue_add_sgs(vcrypto->ctrl_vq, sgs, num_out, > >> - num_in, vcrypto, GFP_ATOMIC); > >> - if (err < 0) { > >> - spin_unlock(&vcrypto->ctrl_lock); > >> - return err; > >> - } > >> - virtqueue_kick(vcrypto->ctrl_vq); > >> - > >> - while (!virtqueue_get_buf(vcrypto->ctrl_vq, &tmp) && > >> - !virtqueue_is_broken(vcrypto->ctrl_vq)) > >> - cpu_relax(); > >> + err =3D virtio_crypto_ctrl_vq_request(vcrypto, sgs, num_out, > >> num_in, vc_ctrl_req); > >> + if (err < 0) > >> + goto out; > >> - if (vcrypto->ctrl_status.status !=3D VIRTIO_CRYPTO_OK) { > >> - spin_unlock(&vcrypto->ctrl_lock); > >> + if (vc_ctrl_req->ctrl_status.status !=3D VIRTIO_CRYPTO_OK) { > >> pr_err("virtio_crypto: Close session failed status: %u, > >> session_id: 0x%llx\n", > >> - vcrypto->ctrl_status.status, > >> + vc_ctrl_req->ctrl_status.status, > >> destroy_session->session_id); > >> - return -EINVAL; > >> + err =3D -EINVAL; > >> + goto out; > >> } > >> - spin_unlock(&vcrypto->ctrl_lock); > >> - return 0; > >> + err =3D 0; > >> +out: > >> + kfree(vc_ctrl_req); > >> + > >> + return err; > >> } > >> static int virtio_crypto_alg_skcipher_init_sessions( > > > > -- > zhenwei pi > From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 5E88FC433F5 for ; Sun, 24 Apr 2022 06:21:47 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id DBCCE400DD; Sun, 24 Apr 2022 06:21:46 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id enrI--EkTL1z; Sun, 24 Apr 2022 06:21:45 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp2.osuosl.org (Postfix) with ESMTPS id C982B405F8; Sun, 24 Apr 2022 06:21:44 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 80C90C0032; Sun, 24 Apr 2022 06:21:44 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id 4B064C002D for ; Sun, 24 Apr 2022 06:21:43 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp2.osuosl.org (Postfix) with ESMTP id 38480405F8 for ; Sun, 24 Apr 2022 06:21:43 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id lFUZpHfmfWIZ for ; Sun, 24 Apr 2022 06:21:41 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by smtp2.osuosl.org (Postfix) with ESMTPS id 511B4400DD for ; Sun, 24 Apr 2022 06:21:41 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1650781299; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=pn5vZufU+wZDPtEw0CFV7kn4KWKqaAcFWOLs0ntfZac=; b=bf2szs2UYG0MvPhcwYFfW8LdlhKuDG5s71lQ1cT11u5E8qQ0+dswToTsCzX7ZxXifrl5mg 5DC1cOUfYdQ1Wqqc0SVqQtwbyfyxHgBTl8s5CCXpIGJYjJXDrroCkK+crU78tYGM1ov6Xe NWYQJW/0OaSOGBSJPLGojIJD+rChLvk= Received: from mail-lf1-f69.google.com (mail-lf1-f69.google.com [209.85.167.69]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-193-6VwqyvBiN2aK1lfm4CKL9Q-1; Sun, 24 Apr 2022 02:21:38 -0400 X-MC-Unique: 6VwqyvBiN2aK1lfm4CKL9Q-1 Received: by mail-lf1-f69.google.com with SMTP id b16-20020a056512305000b00471effe87f9so1689898lfb.2 for ; Sat, 23 Apr 2022 23:21:38 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=pn5vZufU+wZDPtEw0CFV7kn4KWKqaAcFWOLs0ntfZac=; b=dP+oEHGVUwLapsePLfldvRq1GbXRQ3tMN5Y/JDUjl/VcoC2kT4gnM1p++LIhEinMO4 exbh5geb8Rbq/w5akQW0mll0CI2RMt/Cp1Tp6OL2nYSsiKUruy3ZrrfCRIo3emWvbELw K50ikOoJikqIpszWkz+Q8AXg/cR/5XWJj/6yWFcUxFVyFuL1sWDSjfpAS8fdmmB58hOn GVBDkkz6y5GltuiMxAaKcEKk7ClL+xLNt0WZik5LVmc7HHeEEq2eW4qwMbzlQ5KR/vLT L1uzI3wXZNNyFSruzGRcCu2AvkZY+ETSrngn3cYJYoTAiGThBL5euTwkax2ddBnjD8Rm zO6g== X-Gm-Message-State: AOAM531Pyq3GvrU1grWxKF+/JrCBo6qiYfz3YxEmxn4+KzlvnOd7Cn1L H1dTgEtcONDSNNVDgZbio3ZcI7yEtSPyMTr7gKnSjFUDLK1cW+eLIrkeIbQSlnlC0tn348+odbT gV7pQEJm/FOWsv30FR0NcvPjToctkWy5IS5HydaF1hi8y4Z3y3gopgGFJcw== X-Received: by 2002:a05:6512:1293:b0:471:a1bb:d55d with SMTP id u19-20020a056512129300b00471a1bbd55dmr8776254lfs.190.1650781296329; Sat, 23 Apr 2022 23:21:36 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzMmn8zJap4RF0U5O3fAKz3sI59WuUzJ31zf05jpgT2C2tst+mp5petO9CvsrPyt/DXHj/5ufUwbFjHQ7xrJ14= X-Received: by 2002:a05:6512:1293:b0:471:a1bb:d55d with SMTP id u19-20020a056512129300b00471a1bbd55dmr8776242lfs.190.1650781296086; Sat, 23 Apr 2022 23:21:36 -0700 (PDT) MIME-Version: 1.0 References: <20220421104016.453458-1-pizhenwei@bytedance.com> <20220421104016.453458-2-pizhenwei@bytedance.com> <7996f495-3bb8-fa80-7866-fa1fbff3e80a@redhat.com> In-Reply-To: From: Jason Wang Date: Sun, 24 Apr 2022 14:21:24 +0800 Message-ID: Subject: Re: Re: [PATCH v3 1/5] virtio-crypto: use private buffer for control request To: zhenwei pi Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=jasowang@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Cc: Herbert Xu , mst , linux-kernel , virtualization , linux-crypto@vger.kernel.org, davem , helei.sig11@bytedance.com X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" T24gRnJpLCBBcHIgMjIsIDIwMjIgYXQgNToxMiBQTSB6aGVud2VpIHBpIDxwaXpoZW53ZWlAYnl0 ZWRhbmNlLmNvbT4gd3JvdGU6Cj4KPiBPbiA0LzIyLzIyIDE1OjQxLCBKYXNvbiBXYW5nIHdyb3Rl Ogo+ID4KPiA+IOWcqCAyMDIyLzQvMjEgMTg6NDAsIHpoZW53ZWkgcGkg5YaZ6YGTOgo+ID4+IE9y aWdpbmFsbHksIGFsbCBvZiB0aGUgY29udHJvbCByZXF1ZXN0cyBzaGFyZSBhIHNpbmdsZSBidWZm ZXIoCj4gPj4gY3RybCAmIGlucHV0ICYgY3RybF9zdGF0dXMgZmllbGRzIGluIHN0cnVjdCB2aXJ0 aW9fY3J5cHRvKSwgdGhpcwo+ID4+IGFsbG93cyBxdWV1ZSBkZXB0aCAxIG9ubHksIHRoZSBwZXJm b3JtYW5jZSBvZiBjb250cm9sIHF1ZXVlIGdldHMKPiA+PiBsaW1pdGVkIGJ5IHRoaXMgZGVzaWdu Lgo+ID4+Cj4gPj4gSW4gdGhpcyBwYXRjaCwgZWFjaCByZXF1ZXN0IGFsbG9jYXRlcyByZXF1ZXN0 IGJ1ZmZlciBkeW5hbWljYWxseSwgYW5kCj4gPj4gZnJlZSBidWZmZXIgYWZ0ZXIgcmVxdWVzdCwg aXQncyBwb3NzaWJsZSB0byBvcHRpbWl6ZSBjb250cm9sIHF1ZXVlCj4gPj4gZGVwdGggaW4gdGhl IG5leHQgc3RlcC4KPiA+Pgo+ID4+IEEgbmVjZXNzYXJ5IGNvbW1lbnQgaXMgYWxyZWFkeSBpbiBj b2RlLCBzdGlsbCBkZXNjcmliZSBpdCBhZ2FpbjoKPiA+PiAvKgo+ID4+ICAgKiBOb3RlOiB0aGVy ZSBhcmUgcGFkZGluZyBmaWVsZHMgaW4gcmVxdWVzdCwgY2xlYXIgdGhlbSB0byB6ZXJvIGJlZm9y ZQo+ID4+ICAgKiBzZW5kaW5nIHRvIGhvc3QsCj4gPj4gICAqIEV4LCB2aXJ0aW9fY3J5cHRvX2N0 cmxfcmVxdWVzdDo6Y3RybDo6dTo6ZGVzdHJveV9zZXNzaW9uOjpwYWRkaW5nWzQ4XQo+ID4+ICAg Ki8KPiA+PiBTbyB1c2Uga3phbGxvYyB0byBhbGxvY2F0ZSBidWZmZXIgb2Ygc3RydWN0IHZpcnRp b19jcnlwdG9fY3RybF9yZXF1ZXN0Lgo+ID4+Cj4gPj4gQ2M6IE1pY2hhZWwgUy4gVHNpcmtpbiA8 bXN0QHJlZGhhdC5jb20+Cj4gPj4gQ2M6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+ Cj4gPj4gQ2M6IEdvbmdsZWkgPGFyZWkuZ29uZ2xlaUBodWF3ZWkuY29tPgo+ID4+IFNpZ25lZC1v ZmYtYnk6IHpoZW53ZWkgcGkgPHBpemhlbndlaUBieXRlZGFuY2UuY29tPgo+ID4+IC0tLQo+ID4+ ICAgZHJpdmVycy9jcnlwdG8vdmlydGlvL01ha2VmaWxlICAgICAgICAgICAgICAgIHwgICAxICsK PiA+PiAgIC4uLi92aXJ0aW8vdmlydGlvX2NyeXB0b19ha2NpcGhlcl9hbGdzLmMgICAgICB8ICA5 MCArKysrKystLS0tLS0KPiA+PiAgIGRyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRv X2NvbW1vbi5jICB8ICAzOSArKysrKwo+ID4KPiA+Cj4gPiBBbnkgcmVhc29uIHdlIGNhbid0IHVz ZSB2aXJ0aW9fY3J5cHRvX2NvcmUuYz8KPiA+Cj4gQW5vdGhlciBwYXRjaCBpbiB0aGlzIHNlcmll czogW1BBVENIIHYzIDMvNV0gdmlydGlvLWNyeXB0bzogbW92ZSBoZWxwZXJzCj4gaW50byB2aXJ0 aW9fY3J5cHRvX2NvbW1vbi5jCj4KPiBNb3ZlIHZpcnRjcnlwdG9fY2xlYXJfcmVxdWVzdCBhbmQg dmlydGNyeXB0b19kYXRhcV9jYWxsYmFjayBpbnRvCj4gdmlydGlvX2NyeXB0b19jb21tb24uYyB0 byBtYWtlIGNvZGUgY2xlYXIuIFRoZW4gdGhlIHh4X2NvcmUuYwo+IHN1cHBvcnRzOgo+ICAgIC0g cHJvYmUvcmVtb3ZlL2lycSBhZmZpbml0eSBzZXRpbmcgZm9yIGEgdmlydGlvIGRldmljZQo+ICAg IC0gYmFzaWMgdmlydGlvIHJlbGF0ZWQgb3BlcmF0aW9ucwo+Cj4geHhfY29tbW9uLmMgc3VwcG9y dHM6Cj4gICAgLSBjb21tb24gaGVscGVycy9mdW5jdGlvbnMgZm9yIGFsZ29zCj4KPiBTbyBJIHB1 dCB0aGlzIGludG8gYSBuZXcgZmlsZS4KCkkgZG9uJ3Qgc2VlIG9idmlvdXMgZGlmZmVyZW5jZXMg YnV0IHdlIGNhbiBsZWF2ZSBpdCB0byB0aGUKdmlydGlvLWNyeXB0byBtYWludGFpbmVycyB0byBk ZWNpZGUuCgo+Cj4gPgo+ID4+ICAgZHJpdmVycy9jcnlwdG8vdmlydGlvL3ZpcnRpb19jcnlwdG9f Y29tbW9uLmggIHwgIDE5ICsrLQo+ID4+ICAgLi4uL3ZpcnRpby92aXJ0aW9fY3J5cHRvX3NrY2lw aGVyX2FsZ3MuYyAgICAgIHwgMTMzICsrKysrKysrLS0tLS0tLS0tLQo+ID4+ICAgNSBmaWxlcyBj aGFuZ2VkLCAxNTYgaW5zZXJ0aW9ucygrKSwgMTI2IGRlbGV0aW9ucygtKQo+ID4+ICAgY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2NvbW1vbi5j Cj4gPj4KPiA+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9jcnlwdG8vdmlydGlvL01ha2VmaWxlCj4g Pj4gYi9kcml2ZXJzL2NyeXB0by92aXJ0aW8vTWFrZWZpbGUKPiA+PiBpbmRleCBiZmE2Y2JhZTM0 MmUuLjQ5YzFmYTgwZTQ2NSAxMDA2NDQKPiA+PiAtLS0gYS9kcml2ZXJzL2NyeXB0by92aXJ0aW8v TWFrZWZpbGUKPiA+PiArKysgYi9kcml2ZXJzL2NyeXB0by92aXJ0aW8vTWFrZWZpbGUKPiA+PiBA QCAtMyw1ICszLDYgQEAgb2JqLSQoQ09ORklHX0NSWVBUT19ERVZfVklSVElPKSArPSB2aXJ0aW9f Y3J5cHRvLm8KPiA+PiAgIHZpcnRpb19jcnlwdG8tb2JqcyA6PSBcCj4gPj4gICAgICAgdmlydGlv X2NyeXB0b19za2NpcGhlcl9hbGdzLm8gXAo+ID4+ICAgICAgIHZpcnRpb19jcnlwdG9fYWtjaXBo ZXJfYWxncy5vIFwKPiA+PiArICAgIHZpcnRpb19jcnlwdG9fY29tbW9uLm8gXAo+ID4+ICAgICAg IHZpcnRpb19jcnlwdG9fbWdyLm8gXAo+ID4+ICAgICAgIHZpcnRpb19jcnlwdG9fY29yZS5vCj4g Pj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2FrY2lw aGVyX2FsZ3MuYwo+ID4+IGIvZHJpdmVycy9jcnlwdG8vdmlydGlvL3ZpcnRpb19jcnlwdG9fYWtj aXBoZXJfYWxncy5jCj4gPj4gaW5kZXggZjNlYzk0MjAyMTVlLi45NTYxYmMyZGY2MmIgMTAwNjQ0 Cj4gPj4gLS0tIGEvZHJpdmVycy9jcnlwdG8vdmlydGlvL3ZpcnRpb19jcnlwdG9fYWtjaXBoZXJf YWxncy5jCj4gPj4gKysrIGIvZHJpdmVycy9jcnlwdG8vdmlydGlvL3ZpcnRpb19jcnlwdG9fYWtj aXBoZXJfYWxncy5jCj4gPj4gQEAgLTEwMiw4ICsxMDIsOCBAQCBzdGF0aWMgaW50Cj4gPj4gdmly dGlvX2NyeXB0b19hbGdfYWtjaXBoZXJfaW5pdF9zZXNzaW9uKHN0cnVjdCB2aXJ0aW9fY3J5cHRv X2FrY2lwaGVyCj4gPj4gICB7Cj4gPj4gICAgICAgc3RydWN0IHNjYXR0ZXJsaXN0IG91dGhkcl9z Zywga2V5X3NnLCBpbmhkcl9zZywgKnNnc1szXTsKPiA+PiAgICAgICBzdHJ1Y3QgdmlydGlvX2Ny eXB0byAqdmNyeXB0byA9IGN0eC0+dmNyeXB0bzsKPiA+PiArICAgIHN0cnVjdCB2aXJ0aW9fY3J5 cHRvX2N0cmxfcmVxdWVzdCAqdmNfY3RybF9yZXE7Cj4gPj4gICAgICAgdWludDhfdCAqcGtleTsK PiA+PiAtICAgIHVuc2lnbmVkIGludCBpbmxlbjsKPiA+PiAgICAgICBpbnQgZXJyOwo+ID4+ICAg ICAgIHVuc2lnbmVkIGludCBudW1fb3V0ID0gMCwgbnVtX2luID0gMDsKPiA+PiBAQCAtMTExLDk4 ICsxMTEsOTEgQEAgc3RhdGljIGludAo+ID4+IHZpcnRpb19jcnlwdG9fYWxnX2FrY2lwaGVyX2lu aXRfc2Vzc2lvbihzdHJ1Y3QgdmlydGlvX2NyeXB0b19ha2NpcGhlcgo+ID4+ICAgICAgIGlmICgh cGtleSkKPiA+PiAgICAgICAgICAgcmV0dXJuIC1FTk9NRU07Cj4gPj4gLSAgICBzcGluX2xvY2so JnZjcnlwdG8tPmN0cmxfbG9jayk7Cj4gPj4gLSAgICBtZW1jcHkoJnZjcnlwdG8tPmN0cmwuaGVh ZGVyLCBoZWFkZXIsIHNpemVvZih2Y3J5cHRvLT5jdHJsLmhlYWRlcikpOwo+ID4+IC0gICAgbWVt Y3B5KCZ2Y3J5cHRvLT5jdHJsLnUsIHBhcmEsIHNpemVvZih2Y3J5cHRvLT5jdHJsLnUpKTsKPiA+ PiAtICAgIHZjcnlwdG8tPmlucHV0LnN0YXR1cyA9IGNwdV90b19sZTMyKFZJUlRJT19DUllQVE9f RVJSKTsKPiA+PiArICAgIHZjX2N0cmxfcmVxID0ga3phbGxvYyhzaXplb2YoKnZjX2N0cmxfcmVx KSwgR0ZQX0tFUk5FTCk7Cj4gPj4gKyAgICBpZiAoIXZjX2N0cmxfcmVxKSB7Cj4gPj4gKyAgICAg ICAgZXJyID0gLUVOT01FTTsKPiA+PiArICAgICAgICBnb3RvIG91dDsKPiA+PiArICAgIH0KPiA+ PiAtICAgIHNnX2luaXRfb25lKCZvdXRoZHJfc2csICZ2Y3J5cHRvLT5jdHJsLCBzaXplb2YodmNy eXB0by0+Y3RybCkpOwo+ID4+ICsgICAgbWVtY3B5KCZ2Y19jdHJsX3JlcS0+Y3RybC5oZWFkZXIs IGhlYWRlciwKPiA+PiBzaXplb2YodmNfY3RybF9yZXEtPmN0cmwuaGVhZGVyKSk7Cj4gPj4gKyAg ICBtZW1jcHkoJnZjX2N0cmxfcmVxLT5jdHJsLnUsIHBhcmEsIHNpemVvZih2Y19jdHJsX3JlcS0+ Y3RybC51KSk7Cj4gPj4gKyAgICBzZ19pbml0X29uZSgmb3V0aGRyX3NnLCAmdmNfY3RybF9yZXEt PmN0cmwsCj4gPj4gc2l6ZW9mKHZjX2N0cmxfcmVxLT5jdHJsKSk7Cj4gPj4gICAgICAgc2dzW251 bV9vdXQrK10gPSAmb3V0aGRyX3NnOwo+ID4+ICAgICAgIHNnX2luaXRfb25lKCZrZXlfc2csIHBr ZXksIGtleWxlbik7Cj4gPj4gICAgICAgc2dzW251bV9vdXQrK10gPSAma2V5X3NnOwo+ID4+IC0g ICAgc2dfaW5pdF9vbmUoJmluaGRyX3NnLCAmdmNyeXB0by0+aW5wdXQsIHNpemVvZih2Y3J5cHRv LT5pbnB1dCkpOwo+ID4+ICsgICAgdmNfY3RybF9yZXEtPmlucHV0LnN0YXR1cyA9IGNwdV90b19s ZTMyKFZJUlRJT19DUllQVE9fRVJSKTsKPiA+Cj4gPgo+ID4gTml0OiBpZiB0aGVyZSdzIG5vIHNw ZWNpYWwgcmVhc29uLCBsZXQncyBtb3ZlIHRoaXMgYWZ0ZXIgdGhlIGFib3ZlCj4gPiBtZW1jcHlz IGFzIHdoYXQncyBkb25lIHByZXZpb3VzbHkuCj4gPgo+ID4KPiA+PiArICAgIHNnX2luaXRfb25l KCZpbmhkcl9zZywgJnZjX2N0cmxfcmVxLT5pbnB1dCwKPiA+PiBzaXplb2YodmNfY3RybF9yZXEt PmlucHV0KSk7Cj4gPj4gICAgICAgc2dzW251bV9vdXQgKyBudW1faW4rK10gPSAmaW5oZHJfc2c7 Cj4gPj4gLSAgICBlcnIgPSB2aXJ0cXVldWVfYWRkX3Nncyh2Y3J5cHRvLT5jdHJsX3ZxLCBzZ3Ms IG51bV9vdXQsIG51bV9pbiwKPiA+PiB2Y3J5cHRvLCBHRlBfQVRPTUlDKTsKPiA+PiArICAgIGVy ciA9IHZpcnRpb19jcnlwdG9fY3RybF92cV9yZXF1ZXN0KHZjcnlwdG8sIHNncywgbnVtX291dCwK PiA+PiBudW1faW4sIHZjX2N0cmxfcmVxKTsKPiA+Cj4gPgo+ID4gSSdkIHNwbGl0IHRoaXMgaW50 byBhIHNlcGFyYXRlIHBhdGNoLgo+ID4KPgo+IE9LIQo+ID4KPiA+PiAgICAgICBpZiAoZXJyIDwg MCkKPiA+PiAgICAgICAgICAgZ290byBvdXQ7Cj4gPj4gLSAgICB2aXJ0cXVldWVfa2ljayh2Y3J5 cHRvLT5jdHJsX3ZxKTsKPiA+PiAtICAgIHdoaWxlICghdmlydHF1ZXVlX2dldF9idWYodmNyeXB0 by0+Y3RybF92cSwgJmlubGVuKSAmJgo+ID4+IC0gICAgICAgICAgICF2aXJ0cXVldWVfaXNfYnJv a2VuKHZjcnlwdG8tPmN0cmxfdnEpKQo+ID4+IC0gICAgICAgIGNwdV9yZWxheCgpOwo+ID4+IC0K PiA+PiAtICAgIGlmIChsZTMyX3RvX2NwdSh2Y3J5cHRvLT5pbnB1dC5zdGF0dXMpICE9IFZJUlRJ T19DUllQVE9fT0spIHsKPiA+PiArICAgIGlmIChsZTMyX3RvX2NwdSh2Y19jdHJsX3JlcS0+aW5w dXQuc3RhdHVzKSAhPSBWSVJUSU9fQ1JZUFRPX09LKSB7Cj4gPj4gKyAgICAgICAgcHJfZXJyKCJ2 aXJ0aW9fY3J5cHRvOiBDcmVhdGUgc2Vzc2lvbiBmYWlsZWQgc3RhdHVzOiAldVxuIiwKPiA+PiAr ICAgICAgICAgICAgbGUzMl90b19jcHUodmNfY3RybF9yZXEtPmlucHV0LnN0YXR1cykpOwo+ID4+ ICAgICAgICAgICBlcnIgPSAtRUlOVkFMOwo+ID4+ICAgICAgICAgICBnb3RvIG91dDsKPiA+PiAg ICAgICB9Cj4gPgo+ID4KPiA+IERvIHdlIG5lZWQgYSB3YXJuaW5nIGZvciAtRU5PTUVNPwo+ID4K Pgo+IE1lbW9yeShlc3BlY2lhbGx5IHNtYWxsIHNpemUpIGFsbG9jYXRpb24gaXMgdW5saWtlbHkg Y2FzZSwgSSBhbHNvIGNoZWNrCj4gdGhlIHZpcnRpb19uZXQgYW5kIHZpcnRpb19ibGssIGJvdGgg aGFuZGxlcyAtRU5PTUVNIG9ubHkgd2l0aG91dCBlcnJvcgo+IHJlcG9ydGluZy4KCk9rLgoKPgo+ ID4KPiA+PiAtICAgIGN0eC0+c2Vzc2lvbl9pZCA9IGxlNjRfdG9fY3B1KHZjcnlwdG8tPmlucHV0 LnNlc3Npb25faWQpOwo+ID4+ICsgICAgY3R4LT5zZXNzaW9uX2lkID0gbGU2NF90b19jcHUodmNf Y3RybF9yZXEtPmlucHV0LnNlc3Npb25faWQpOwo+ID4+ICAgICAgIGN0eC0+c2Vzc2lvbl92YWxp ZCA9IHRydWU7Cj4gPj4gICAgICAgZXJyID0gMDsKPiA+PiAgIG91dDoKPiA+PiAtICAgIHNwaW5f dW5sb2NrKCZ2Y3J5cHRvLT5jdHJsX2xvY2spOwo+ID4+ICsgICAga2ZyZWUodmNfY3RybF9yZXEp Owo+ID4+ICAgICAgIGtmcmVlX3NlbnNpdGl2ZShwa2V5KTsKPiA+PiAtICAgIGlmIChlcnIgPCAw KQo+ID4+IC0gICAgICAgIHByX2VycigidmlydGlvX2NyeXB0bzogQ3JlYXRlIHNlc3Npb24gZmFp bGVkIHN0YXR1czogJXVcbiIsCj4gPj4gLSAgICAgICAgICAgIGxlMzJfdG9fY3B1KHZjcnlwdG8t PmlucHV0LnN0YXR1cykpOwo+ID4+IC0KPiA+PiAgICAgICByZXR1cm4gZXJyOwo+ID4+ICAgfQo+ ID4+ICAgc3RhdGljIGludCB2aXJ0aW9fY3J5cHRvX2FsZ19ha2NpcGhlcl9jbG9zZV9zZXNzaW9u KHN0cnVjdAo+ID4+IHZpcnRpb19jcnlwdG9fYWtjaXBoZXJfY3R4ICpjdHgpCj4gPj4gICB7Cj4g Pj4gICAgICAgc3RydWN0IHNjYXR0ZXJsaXN0IG91dGhkcl9zZywgaW5oZHJfc2csICpzZ3NbMl07 Cj4gPj4gKyAgICBzdHJ1Y3QgdmlydGlvX2NyeXB0b19jdHJsX3JlcXVlc3QgKnZjX2N0cmxfcmVx Owo+ID4+ICAgICAgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX2Rlc3Ryb3lfc2Vzc2lvbl9yZXEgKmRl c3Ryb3lfc2Vzc2lvbjsKPiA+PiAgICAgICBzdHJ1Y3QgdmlydGlvX2NyeXB0byAqdmNyeXB0byA9 IGN0eC0+dmNyeXB0bzsKPiA+PiAtICAgIHVuc2lnbmVkIGludCBudW1fb3V0ID0gMCwgbnVtX2lu ID0gMCwgaW5sZW47Cj4gPj4gKyAgICB1bnNpZ25lZCBpbnQgbnVtX291dCA9IDAsIG51bV9pbiA9 IDA7Cj4gPj4gICAgICAgaW50IGVycjsKPiA+PiAtICAgIHNwaW5fbG9jaygmdmNyeXB0by0+Y3Ry bF9sb2NrKTsKPiA+PiAtICAgIGlmICghY3R4LT5zZXNzaW9uX3ZhbGlkKSB7Cj4gPj4gLSAgICAg ICAgZXJyID0gMDsKPiA+PiAtICAgICAgICBnb3RvIG91dDsKPiA+PiAtICAgIH0KPiA+PiAtICAg IHZjcnlwdG8tPmN0cmxfc3RhdHVzLnN0YXR1cyA9IFZJUlRJT19DUllQVE9fRVJSOwo+ID4+IC0g ICAgdmNyeXB0by0+Y3RybC5oZWFkZXIub3Bjb2RlID0KPiA+PiBjcHVfdG9fbGUzMihWSVJUSU9f Q1JZUFRPX0FLQ0lQSEVSX0RFU1RST1lfU0VTU0lPTik7Cj4gPj4gLSAgICB2Y3J5cHRvLT5jdHJs LmhlYWRlci5xdWV1ZV9pZCA9IDA7Cj4gPj4gKyAgICBpZiAoIWN0eC0+c2Vzc2lvbl92YWxpZCkK PiA+PiArICAgICAgICByZXR1cm4gMDsKPiA+PiAtICAgIGRlc3Ryb3lfc2Vzc2lvbiA9ICZ2Y3J5 cHRvLT5jdHJsLnUuZGVzdHJveV9zZXNzaW9uOwo+ID4+ICsgICAgdmNfY3RybF9yZXEgPSBremFs bG9jKHNpemVvZigqdmNfY3RybF9yZXEpLCBHRlBfS0VSTkVMKTsKPiA+PiArICAgIGlmICghdmNf Y3RybF9yZXEpCj4gPj4gKyAgICAgICAgcmV0dXJuIC1FTk9NRU07Cj4gPj4gKwo+ID4+ICsgICAg dmNfY3RybF9yZXEtPmN0cmwuaGVhZGVyLm9wY29kZSA9Cj4gPj4gY3B1X3RvX2xlMzIoVklSVElP X0NSWVBUT19BS0NJUEhFUl9ERVNUUk9ZX1NFU1NJT04pOwo+ID4+ICsgICAgdmNfY3RybF9yZXEt PmN0cmwuaGVhZGVyLnF1ZXVlX2lkID0gMDsKPiA+PiArCj4gPj4gKyAgICBkZXN0cm95X3Nlc3Np b24gPSAmdmNfY3RybF9yZXEtPmN0cmwudS5kZXN0cm95X3Nlc3Npb247Cj4gPj4gICAgICAgZGVz dHJveV9zZXNzaW9uLT5zZXNzaW9uX2lkID0gY3B1X3RvX2xlNjQoY3R4LT5zZXNzaW9uX2lkKTsK PiA+PiAtICAgIHNnX2luaXRfb25lKCZvdXRoZHJfc2csICZ2Y3J5cHRvLT5jdHJsLCBzaXplb2Yo dmNyeXB0by0+Y3RybCkpOwo+ID4+ICsgICAgc2dfaW5pdF9vbmUoJm91dGhkcl9zZywgJnZjX2N0 cmxfcmVxLT5jdHJsLAo+ID4+IHNpemVvZih2Y19jdHJsX3JlcS0+Y3RybCkpOwo+ID4+ICAgICAg IHNnc1tudW1fb3V0KytdID0gJm91dGhkcl9zZzsKPiA+PiAtICAgIHNnX2luaXRfb25lKCZpbmhk cl9zZywgJnZjcnlwdG8tPmN0cmxfc3RhdHVzLnN0YXR1cywKPiA+PiBzaXplb2YodmNyeXB0by0+ Y3RybF9zdGF0dXMuc3RhdHVzKSk7Cj4gPj4gKyAgICB2Y19jdHJsX3JlcS0+Y3RybF9zdGF0dXMu c3RhdHVzID0gVklSVElPX0NSWVBUT19FUlI7Cj4gPgo+ID4KPiA+IElmIG5vIHNwZWNpYWwgcmVh c29uLCBsZXQncyBtb3ZlIHRoaXMgYWJvdmU6Cj4gPgo+ID4gdmNfY3RybF9yZXEtPmN0cmwuaGVh ZGVyLm9wY29kZSA9Cj4gPiBjcHVfdG9fbGUzMihWSVJUSU9fQ1JZUFRPX0FLQ0lQSEVSX0RFU1RS T1lfU0VTU0lPTik7Cj4gPgo+Cj4gT0shCj4gPgo+ID4+ICsgICAgc2dfaW5pdF9vbmUoJmluaGRy X3NnLCAmdmNfY3RybF9yZXEtPmN0cmxfc3RhdHVzLnN0YXR1cywKPiA+PiArICAgICAgICBzaXpl b2YodmNfY3RybF9yZXEtPmN0cmxfc3RhdHVzLnN0YXR1cykpOwo+ID4+ICAgICAgIHNnc1tudW1f b3V0ICsgbnVtX2luKytdID0gJmluaGRyX3NnOwo+ID4+IC0gICAgZXJyID0gdmlydHF1ZXVlX2Fk ZF9zZ3ModmNyeXB0by0+Y3RybF92cSwgc2dzLCBudW1fb3V0LCBudW1faW4sCj4gPj4gdmNyeXB0 bywgR0ZQX0FUT01JQyk7Cj4gPj4gKyAgICBlcnIgPSB2aXJ0aW9fY3J5cHRvX2N0cmxfdnFfcmVx dWVzdCh2Y3J5cHRvLCBzZ3MsIG51bV9vdXQsCj4gPj4gbnVtX2luLCB2Y19jdHJsX3JlcSk7Cj4g Pj4gICAgICAgaWYgKGVyciA8IDApCj4gPj4gICAgICAgICAgIGdvdG8gb3V0Owo+ID4+IC0gICAg dmlydHF1ZXVlX2tpY2sodmNyeXB0by0+Y3RybF92cSk7Cj4gPj4gLSAgICB3aGlsZSAoIXZpcnRx dWV1ZV9nZXRfYnVmKHZjcnlwdG8tPmN0cmxfdnEsICZpbmxlbikgJiYKPiA+PiAtICAgICAgICAg ICAhdmlydHF1ZXVlX2lzX2Jyb2tlbih2Y3J5cHRvLT5jdHJsX3ZxKSkKPiA+PiAtICAgICAgICBj cHVfcmVsYXgoKTsKPiA+PiAtCj4gPj4gLSAgICBpZiAodmNyeXB0by0+Y3RybF9zdGF0dXMuc3Rh dHVzICE9IFZJUlRJT19DUllQVE9fT0spIHsKPiA+PiArICAgIGlmICh2Y19jdHJsX3JlcS0+Y3Ry bF9zdGF0dXMuc3RhdHVzICE9IFZJUlRJT19DUllQVE9fT0spIHsKPiA+PiAgICAgICAgICAgZXJy ID0gLUVJTlZBTDsKPiA+PiArICAgICAgICBwcl9lcnIoInZpcnRpb19jcnlwdG86IENsb3NlIHNl c3Npb24gZmFpbGVkIHN0YXR1czogJXUsCj4gPj4gc2Vzc2lvbl9pZDogMHglbGx4XG4iLAo+ID4+ ICsgICAgICAgICAgICB2Y19jdHJsX3JlcS0+Y3RybF9zdGF0dXMuc3RhdHVzLAo+ID4+IGRlc3Ry b3lfc2Vzc2lvbi0+c2Vzc2lvbl9pZCk7Cj4gPj4gICAgICAgICAgIGdvdG8gb3V0Owo+ID4+ICAg ICAgIH0KPiA+PiAgICAgICBlcnIgPSAwOwo+ID4+ICAgICAgIGN0eC0+c2Vzc2lvbl92YWxpZCA9 IGZhbHNlOwo+ID4+IC0KPiA+PiAgIG91dDoKPiA+PiAtICAgIHNwaW5fdW5sb2NrKCZ2Y3J5cHRv LT5jdHJsX2xvY2spOwo+ID4+IC0gICAgaWYgKGVyciA8IDApIHsKPiA+PiAtICAgICAgICBwcl9l cnIoInZpcnRpb19jcnlwdG86IENsb3NlIHNlc3Npb24gZmFpbGVkIHN0YXR1czogJXUsCj4gPj4g c2Vzc2lvbl9pZDogMHglbGx4XG4iLAo+ID4+IC0gICAgICAgICAgICB2Y3J5cHRvLT5jdHJsX3N0 YXR1cy5zdGF0dXMsIGRlc3Ryb3lfc2Vzc2lvbi0+c2Vzc2lvbl9pZCk7Cj4gPj4gLSAgICB9Cj4g Pj4gKyAgICBrZnJlZSh2Y19jdHJsX3JlcSk7Cj4gPj4gICAgICAgcmV0dXJuIGVycjsKPiA+PiAg IH0KPiA+PiBAQCAtMjEwLDE0ICsyMDMsMTEgQEAgc3RhdGljIGludAo+ID4+IHZpcnRpb19jcnlw dG9fYWxnX2FrY2lwaGVyX2Nsb3NlX3Nlc3Npb24oc3RydWN0IHZpcnRpb19jcnlwdG9fYWtjaXBo ZQo+ID4+ICAgc3RhdGljIGludCBfX3ZpcnRpb19jcnlwdG9fYWtjaXBoZXJfZG9fcmVxKHN0cnVj dAo+ID4+IHZpcnRpb19jcnlwdG9fYWtjaXBoZXJfcmVxdWVzdCAqdmNfYWtjaXBoZXJfcmVxLAo+ ID4+ICAgICAgICAgICBzdHJ1Y3QgYWtjaXBoZXJfcmVxdWVzdCAqcmVxLCBzdHJ1Y3QgZGF0YV9x dWV1ZSAqZGF0YV92cSkKPiA+PiAgIHsKPiA+PiAtICAgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX2Fr Y2lwaGVyX2N0eCAqY3R4ID0KPiA+PiB2Y19ha2NpcGhlcl9yZXEtPmFrY2lwaGVyX2N0eDsKPiA+ PiAgICAgICBzdHJ1Y3QgdmlydGlvX2NyeXB0b19yZXF1ZXN0ICp2Y19yZXEgPSAmdmNfYWtjaXBo ZXJfcmVxLT5iYXNlOwo+ID4+IC0gICAgc3RydWN0IHZpcnRpb19jcnlwdG8gKnZjcnlwdG8gPSBj dHgtPnZjcnlwdG87Cj4gPj4gICAgICAgc3RydWN0IHZpcnRpb19jcnlwdG9fb3BfZGF0YV9yZXEg KnJlcV9kYXRhID0gdmNfcmVxLT5yZXFfZGF0YTsKPiA+PiAgICAgICBzdHJ1Y3Qgc2NhdHRlcmxp c3QgKnNnc1s0XSwgb3V0aGRyX3NnLCBpbmhkcl9zZywgc3JjZGF0YV9zZywKPiA+PiBkc3RkYXRh X3NnOwo+ID4+ICAgICAgIHZvaWQgKnNyY19idWYgPSBOVUxMLCAqZHN0X2J1ZiA9IE5VTEw7Cj4g Pj4gICAgICAgdW5zaWduZWQgaW50IG51bV9vdXQgPSAwLCBudW1faW4gPSAwOwo+ID4+IC0gICAg aW50IG5vZGUgPSBkZXZfdG9fbm9kZSgmdmNyeXB0by0+dmRldi0+ZGV2KTsKPiA+PiAgICAgICB1 bnNpZ25lZCBsb25nIGZsYWdzOwo+ID4+ICAgICAgIGludCByZXQgPSAtRU5PTUVNOwo+ID4+ICAg ICAgIGJvb2wgdmVyaWZ5ID0gdmNfYWtjaXBoZXJfcmVxLT5vcGNvZGUgPT0KPiA+PiBWSVJUSU9f Q1JZUFRPX0FLQ0lQSEVSX1ZFUklGWTsKPiA+PiBAQCAtMjI4LDcgKzIxOCw3IEBAIHN0YXRpYyBp bnQgX192aXJ0aW9fY3J5cHRvX2FrY2lwaGVyX2RvX3JlcShzdHJ1Y3QKPiA+PiB2aXJ0aW9fY3J5 cHRvX2FrY2lwaGVyX3JlcXVlc3QKPiA+PiAgICAgICBzZ3NbbnVtX291dCsrXSA9ICZvdXRoZHJf c2c7Cj4gPj4gICAgICAgLyogc3JjIGRhdGEgKi8KPiA+PiAtICAgIHNyY19idWYgPSBrY2FsbG9j X25vZGUoc3JjX2xlbiwgMSwgR0ZQX0tFUk5FTCwgbm9kZSk7Cj4gPj4gKyAgICBzcmNfYnVmID0g a2NhbGxvYyhzcmNfbGVuLCAxLCBHRlBfS0VSTkVMKTsKPiA+Cj4gPgo+ID4gVGhpcyBzZWVtcyBu b3QgYSByZWxldmFudCBjaGFuZ2UuIElmIGl0IGlzIGEgbXVzdCB3ZSBuZWVkIHVzZSBhIHNlcGFy YXRlCj4gPiBmb3IgdGhpcyBhbmQgZGVzY3JpYmUgdGhlIHJhdGlvbmFsZS4KPiA+Cj4gPgo+ID4+ ICAgICAgIGlmICghc3JjX2J1ZikKPiA+PiAgICAgICAgICAgZ290byBlcnI7Cj4gPj4gQEAgLTI0 Myw3ICsyMzMsNyBAQCBzdGF0aWMgaW50IF9fdmlydGlvX2NyeXB0b19ha2NpcGhlcl9kb19yZXEo c3RydWN0Cj4gPj4gdmlydGlvX2NyeXB0b19ha2NpcGhlcl9yZXF1ZXN0Cj4gPj4gICAgICAgICAg IHNnc1tudW1fb3V0KytdID0gJnNyY2RhdGFfc2c7Cj4gPj4gICAgICAgICAgIC8qIGRzdCBkYXRh ICovCj4gPj4gLSAgICAgICAgZHN0X2J1ZiA9IGtjYWxsb2Nfbm9kZShyZXEtPmRzdF9sZW4sIDEs IEdGUF9LRVJORUwsIG5vZGUpOwo+ID4+ICsgICAgICAgIGRzdF9idWYgPSBrY2FsbG9jKHJlcS0+ ZHN0X2xlbiwgMSwgR0ZQX0tFUk5FTCk7Cj4gPgo+ID4KPiA+IEFuZCB0aGlzLgo+ID4KPiA+Cj4g Pj4gICAgICAgICAgIGlmICghZHN0X2J1ZikKPiA+PiAgICAgICAgICAgICAgIGdvdG8gZXJyOwo+ ID4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2NyeXB0by92aXJ0aW8vdmlydGlvX2NyeXB0b19jb21t b24uYwo+ID4+IGIvZHJpdmVycy9jcnlwdG8vdmlydGlvL3ZpcnRpb19jcnlwdG9fY29tbW9uLmMK PiA+PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+ID4+IGluZGV4IDAwMDAwMDAwMDAwMC4uZTY1MTI1 YTc0ZGIyCj4gPj4gLS0tIC9kZXYvbnVsbAo+ID4+ICsrKyBiL2RyaXZlcnMvY3J5cHRvL3ZpcnRp by92aXJ0aW9fY3J5cHRvX2NvbW1vbi5jCj4gPj4gQEAgLTAsMCArMSwzOSBAQAo+ID4+ICsvLyBT UERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vci1sYXRlcgo+ID4+ICsvKiBDb21tb24g ZnVuY3Rpb25zIGFuZCBoZWxwZXJzCj4gPj4gKyAqCj4gPj4gKyAqIEF1dGhvcnM6IHpoZW53ZWkg cGkgPHBpemhlbndlaUBieXRlZGFuY2UuY29tPgo+ID4+ICsgKgo+ID4+ICsgKiBDb3B5cmlnaHQg MjAyMiBCeXRlZGFuY2UgQ08uLCBMVEQuCj4gPj4gKyAqLwo+ID4+ICsKPiA+PiArI2luY2x1ZGUg InZpcnRpb19jcnlwdG9fY29tbW9uLmgiCj4gPj4gKwo+ID4+ICtpbnQgdmlydGlvX2NyeXB0b19j dHJsX3ZxX3JlcXVlc3Qoc3RydWN0IHZpcnRpb19jcnlwdG8gKnZjcnlwdG8sCj4gPj4gc3RydWN0 IHNjYXR0ZXJsaXN0ICpzZ3NbXSwKPiA+PiArICAgICAgICAgICAgICAgICAgdW5zaWduZWQgaW50 IG91dF9zZ3MsIHVuc2lnbmVkIGludCBpbl9zZ3MsCj4gPj4gKyAgICAgICAgICAgICAgICAgIHN0 cnVjdCB2aXJ0aW9fY3J5cHRvX2N0cmxfcmVxdWVzdCAqdmNfY3RybF9yZXEpCj4gPj4gK3sKPiA+ PiArICAgIGludCBlcnI7Cj4gPj4gKyAgICB1bnNpZ25lZCBpbnQgaW5sZW47Cj4gPj4gKyAgICB1 bnNpZ25lZCBsb25nIGZsYWdzOwo+ID4+ICsKPiA+PiArICAgIHNwaW5fbG9ja19pcnFzYXZlKCZ2 Y3J5cHRvLT5jdHJsX2xvY2ssIGZsYWdzKTsKPiA+PiArICAgIGVyciA9IHZpcnRxdWV1ZV9hZGRf c2dzKHZjcnlwdG8tPmN0cmxfdnEsIHNncywgb3V0X3NncywgaW5fc2dzLAo+ID4+IHZjX2N0cmxf cmVxLCBHRlBfQVRPTUlDKTsKPiA+PiArICAgIGlmIChlcnIgPCAwKSB7Cj4gPj4gKyAgICAgICAg c3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdmNyeXB0by0+Y3RybF9sb2NrLCBmbGFncyk7Cj4gPj4g KyAgICAgICAgcmV0dXJuIGVycjsKPiA+PiArICAgIH0KPiA+PiArCj4gPj4gKyAgICB2aXJ0cXVl dWVfa2ljayh2Y3J5cHRvLT5jdHJsX3ZxKTsKPiA+PiArCj4gPj4gKyAgICAvKgo+ID4+ICsgICAg ICogVHJhcHBpbmcgaW50byB0aGUgaHlwZXJ2aXNvciwgc28gdGhlIHJlcXVlc3Qgc2hvdWxkIGJl Cj4gPj4gKyAgICAgKiBoYW5kbGVkIGltbWVkaWF0ZWx5Lgo+ID4+ICsgICAgICovCj4gPj4gKyAg ICB3aGlsZSAoIXZpcnRxdWV1ZV9nZXRfYnVmKHZjcnlwdG8tPmN0cmxfdnEsICZpbmxlbikgJiYK PiA+PiArICAgICAgICAhdmlydHF1ZXVlX2lzX2Jyb2tlbih2Y3J5cHRvLT5jdHJsX3ZxKSkKPiA+ PiArICAgICAgICBjcHVfcmVsYXgoKTsKPiA+PiArCj4gPj4gKyAgICBzcGluX3VubG9ja19pcnFy ZXN0b3JlKCZ2Y3J5cHRvLT5jdHJsX2xvY2ssIGZsYWdzKTsKPiA+PiArCj4gPj4gKyAgICByZXR1 cm4gMDsKPiA+PiArfQo+ID4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2NyeXB0by92aXJ0aW8vdmly dGlvX2NyeXB0b19jb21tb24uaAo+ID4+IGIvZHJpdmVycy9jcnlwdG8vdmlydGlvL3ZpcnRpb19j cnlwdG9fY29tbW9uLmgKPiA+PiBpbmRleCBlNjkzZDRlZTgzYTYuLmQyYTIwZmU2ZTEzZSAxMDA2 NDQKPiA+PiAtLS0gYS9kcml2ZXJzL2NyeXB0by92aXJ0aW8vdmlydGlvX2NyeXB0b19jb21tb24u aAo+ID4+ICsrKyBiL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX2NvbW1vbi5o Cj4gPj4gQEAgLTEzLDYgKzEzLDcgQEAKPiA+PiAgICNpbmNsdWRlIDxjcnlwdG8vYWVhZC5oPgo+ ID4+ICAgI2luY2x1ZGUgPGNyeXB0by9hZXMuaD4KPiA+PiAgICNpbmNsdWRlIDxjcnlwdG8vZW5n aW5lLmg+Cj4gPj4gKyNpbmNsdWRlIDx1YXBpL2xpbnV4L3ZpcnRpb19jcnlwdG8uaD4KPiA+PiAg IC8qIEludGVybmFsIHJlcHJlc2VudGF0aW9uIG9mIGEgZGF0YSB2aXJ0cXVldWUgKi8KPiA+PiBA QCAtNjUsMTEgKzY2LDYgQEAgc3RydWN0IHZpcnRpb19jcnlwdG8gewo+ID4+ICAgICAgIC8qIE1h eGltdW0gc2l6ZSBvZiBwZXIgcmVxdWVzdCAqLwo+ID4+ICAgICAgIHU2NCBtYXhfc2l6ZTsKPiA+ PiAtICAgIC8qIENvbnRyb2wgVlEgYnVmZmVyczogcHJvdGVjdGVkIGJ5IHRoZSBjdHJsX2xvY2sg Ki8KPiA+PiAtICAgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX29wX2N0cmxfcmVxIGN0cmw7Cj4gPj4g LSAgICBzdHJ1Y3QgdmlydGlvX2NyeXB0b19zZXNzaW9uX2lucHV0IGlucHV0Owo+ID4+IC0gICAg c3RydWN0IHZpcnRpb19jcnlwdG9faW5oZHIgY3RybF9zdGF0dXM7Cj4gPj4gLQo+ID4+ICAgICAg IHVuc2lnbmVkIGxvbmcgc3RhdHVzOwo+ID4+ICAgICAgIGF0b21pY190IHJlZl9jb3VudDsKPiA+ PiAgICAgICBzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7Cj4gPj4gQEAgLTg1LDYgKzgxLDE2IEBAIHN0 cnVjdCB2aXJ0aW9fY3J5cHRvX3N5bV9zZXNzaW9uX2luZm8gewo+ID4+ICAgICAgIF9fdTY0IHNl c3Npb25faWQ7Cj4gPj4gICB9Owo+ID4+ICsvKgo+ID4+ICsgKiBOb3RlOiB0aGVyZSBhcmUgcGFk ZGluZyBmaWVsZHMgaW4gcmVxdWVzdCwgY2xlYXIgdGhlbSB0byB6ZXJvCj4gPj4gYmVmb3JlIHNl bmRpbmcgdG8gaG9zdCwKPiA+PiArICogRXgsIHZpcnRpb19jcnlwdG9fY3RybF9yZXF1ZXN0Ojpj dHJsOjp1OjpkZXN0cm95X3Nlc3Npb246OnBhZGRpbmdbNDhdCj4gPj4gKyAqLwo+ID4+ICtzdHJ1 Y3QgdmlydGlvX2NyeXB0b19jdHJsX3JlcXVlc3Qgewo+ID4+ICsgICAgc3RydWN0IHZpcnRpb19j cnlwdG9fb3BfY3RybF9yZXEgY3RybDsKPiA+PiArICAgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX3Nl c3Npb25faW5wdXQgaW5wdXQ7Cj4gPj4gKyAgICBzdHJ1Y3QgdmlydGlvX2NyeXB0b19pbmhkciBj dHJsX3N0YXR1czsKPiA+PiArfTsKPiA+PiArCj4gPj4gICBzdHJ1Y3QgdmlydGlvX2NyeXB0b19y ZXF1ZXN0Owo+ID4+ICAgdHlwZWRlZiB2b2lkICgqdmlydGlvX2NyeXB0b19kYXRhX2NhbGxiYWNr KQo+ID4+ICAgICAgICAgICAoc3RydWN0IHZpcnRpb19jcnlwdG9fcmVxdWVzdCAqdmNfcmVxLCBp bnQgbGVuKTsKPiA+PiBAQCAtMTM1LDQgKzE0MSw3IEBAIHZvaWQgdmlydGlvX2NyeXB0b19za2Np cGhlcl9hbGdzX3VucmVnaXN0ZXIoc3RydWN0Cj4gPj4gdmlydGlvX2NyeXB0byAqdmNyeXB0byk7 Cj4gPj4gICBpbnQgdmlydGlvX2NyeXB0b19ha2NpcGhlcl9hbGdzX3JlZ2lzdGVyKHN0cnVjdCB2 aXJ0aW9fY3J5cHRvCj4gPj4gKnZjcnlwdG8pOwo+ID4+ICAgdm9pZCB2aXJ0aW9fY3J5cHRvX2Fr Y2lwaGVyX2FsZ3NfdW5yZWdpc3RlcihzdHJ1Y3QgdmlydGlvX2NyeXB0bwo+ID4+ICp2Y3J5cHRv KTsKPiA+PiAraW50IHZpcnRpb19jcnlwdG9fY3RybF92cV9yZXF1ZXN0KHN0cnVjdCB2aXJ0aW9f Y3J5cHRvICp2Y3J5cHRvLAo+ID4+IHN0cnVjdCBzY2F0dGVybGlzdCAqc2dzW10sCj4gPj4gKyAg ICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBvdXRfc2dzLCB1bnNpZ25lZCBpbnQgaW5fc2dz LAo+ID4+ICsgICAgICAgICAgICAgICAgICBzdHJ1Y3QgdmlydGlvX2NyeXB0b19jdHJsX3JlcXVl c3QgKnZjX2N0cmxfcmVxKTsKPiA+PiAgICNlbmRpZiAvKiBfVklSVElPX0NSWVBUT19DT01NT05f SCAqLwo+ID4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2NyeXB0by92aXJ0aW8vdmlydGlvX2NyeXB0 b19za2NpcGhlcl9hbGdzLmMKPiA+PiBiL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5 cHRvX3NrY2lwaGVyX2FsZ3MuYwo+ID4+IGluZGV4IGE2MThjNDZhNTJiOC4uZmVmMzU1ZmY0NjFj IDEwMDY0NAo+ID4+IC0tLSBhL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5cHRvX3Nr Y2lwaGVyX2FsZ3MuYwo+ID4+ICsrKyBiL2RyaXZlcnMvY3J5cHRvL3ZpcnRpby92aXJ0aW9fY3J5 cHRvX3NrY2lwaGVyX2FsZ3MuYwo+ID4+IEBAIC0xMTgsMTEgKzExOCwxMyBAQCBzdGF0aWMgaW50 IHZpcnRpb19jcnlwdG9fYWxnX3NrY2lwaGVyX2luaXRfc2Vzc2lvbigKPiA+PiAgICAgICAgICAg aW50IGVuY3J5cHQpCj4gPj4gICB7Cj4gPj4gICAgICAgc3RydWN0IHNjYXR0ZXJsaXN0IG91dGhk ciwga2V5X3NnLCBpbmhkciwgKnNnc1szXTsKPiA+PiAtICAgIHVuc2lnbmVkIGludCB0bXA7Cj4g Pj4gICAgICAgc3RydWN0IHZpcnRpb19jcnlwdG8gKnZjcnlwdG8gPSBjdHgtPnZjcnlwdG87Cj4g Pgo+ID4KPiA+IENhbiB3ZSBzaW1wbHkgcmVuYW1lIHRoaXMgdG8gdmlydGNyeXB0byBhbmQgdGhl biB3ZSBjYW4gdXNlIHRoZSBuYW1lCj4gPiAidmNyeXB0byIgZm9yIHZpcnRpb19jcnlwdG9fY3Ry bF9yZXF1ZXN0IHRoZW4gd2Ugc2F2ZSB0b25zIGxvdCBjaGFuZ2VzPwo+ID4KPiA+IEl0IHNpbXBs aWZ5IHRoZSBsaWZlIG9mIHJldmlld2VycyBhbmQgYmFja3BvcnRpbmcuCj4gPgo+ID4gVGhhbmtz Cj4gPgo+Cj4gVGhpcyBzZXJpZXMgZm9jdXNlcyBvbiBwZXJmb3JtYW5jZSBpbXByb3ZtZW50LCBh bmQga2VlcHMgdGhlIHN0eWxlIHdpdGgKPiB0aGUgb3JpZ25hbCBzdHlsZS4gV2hhdCBhYm91dCBm aXhpbmcgdGhpcyBpbiBhbm90aGVyIHNlcmllcz8gKElmIHNvLAo+IEknbGwgZml4IHRoaXMgbGF0 ZXIpCgpKdXN0IGluIGNhc2Ugd2UgYXJlIGF0IHRoZSBzYW1lIHBhZ2UsIHdoYXQgSSBzdWdnZXN0 IGNhbiBzYXZlIGh1bmRyZWRzCmxpbmVzIG9mIGNvZGVzOgoKRS5nOgoKPiA+PiAtICAgIHZjcnlw dG8tPmN0cmwuaGVhZGVyLnF1ZXVlX2lkID0gMDsKPiA+PiArICAgIGhlYWRlci0+cXVldWVfaWQg PSAwOwoKSWYgd2Ugc3RpY2sgdG8gdGhlIG5hbWUgb2YgInZjcnlwdG8iIHdlIGRvbid0IG5lZWQg dGhpcyBjaGFuZ2UgYXQgYWxsLgoKSXQgY2FuIHNpbXBsaWZ5OgoKMSkgZnV0dXJlIGNvbnRleHQg ZGlmZmVyZW5jZSB3aGVuIGJhY2twb3J0aW5nIHBhdGNoZXMgdG8gLXN0YWJsZQoyKSByZXZpZXdp bmcKClRoYW5rcwoKPiA+Cj4gPj4gICAgICAgaW50IG9wID0gZW5jcnlwdCA/IFZJUlRJT19DUllQ VE9fT1BfRU5DUllQVCA6Cj4gPj4gVklSVElPX0NSWVBUT19PUF9ERUNSWVBUOwo+ID4+ICAgICAg IGludCBlcnI7Cj4gPj4gICAgICAgdW5zaWduZWQgaW50IG51bV9vdXQgPSAwLCBudW1faW4gPSAw Owo+ID4+ICsgICAgc3RydWN0IHZpcnRpb19jcnlwdG9fY3RybF9yZXF1ZXN0ICp2Y19jdHJsX3Jl cTsKPiA+PiArICAgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX2N0cmxfaGVhZGVyICpoZWFkZXI7Cj4g Pj4gKyAgICBzdHJ1Y3QgdmlydGlvX2NyeXB0b19zeW1fY3JlYXRlX3Nlc3Npb25fcmVxICpzeW1f Y3JlYXRlX3Nlc3Npb247Cj4gPj4gICAgICAgLyoKPiA+PiAgICAgICAgKiBBdm9pZCB0byBkbyBE TUEgZnJvbSB0aGUgc3RhY2ssIHN3aXRjaCB0byB1c2luZwo+ID4+IEBAIC0xMzMsMjYgKzEzNSwy NyBAQCBzdGF0aWMgaW50IHZpcnRpb19jcnlwdG9fYWxnX3NrY2lwaGVyX2luaXRfc2Vzc2lvbigK PiA+PiAgICAgICBpZiAoIWNpcGhlcl9rZXkpCj4gPj4gICAgICAgICAgIHJldHVybiAtRU5PTUVN Owo+ID4+IC0gICAgc3Bpbl9sb2NrKCZ2Y3J5cHRvLT5jdHJsX2xvY2spOwo+ID4+ICsgICAgdmNf Y3RybF9yZXEgPSBremFsbG9jKHNpemVvZigqdmNfY3RybF9yZXEpLCBHRlBfS0VSTkVMKTsKPiA+ PiArICAgIGlmICghdmNfY3RybF9yZXEpIHsKPiA+PiArICAgICAgICBlcnIgPSAtRU5PTUVNOwo+ ID4+ICsgICAgICAgIGdvdG8gb3V0Owo+ID4+ICsgICAgfQo+ID4+ICsKPiA+PiAgICAgICAvKiBQ YWQgY3RybCBoZWFkZXIgKi8KPiA+PiAtICAgIHZjcnlwdG8tPmN0cmwuaGVhZGVyLm9wY29kZSA9 Cj4gPj4gLSAgICAgICAgY3B1X3RvX2xlMzIoVklSVElPX0NSWVBUT19DSVBIRVJfQ1JFQVRFX1NF U1NJT04pOwo+ID4+IC0gICAgdmNyeXB0by0+Y3RybC5oZWFkZXIuYWxnbyA9IGNwdV90b19sZTMy KGFsZyk7Cj4gPj4gKyAgICBoZWFkZXIgPSAmdmNfY3RybF9yZXEtPmN0cmwuaGVhZGVyOwo+ID4+ ICsgICAgaGVhZGVyLT5vcGNvZGUgPSBjcHVfdG9fbGUzMihWSVJUSU9fQ1JZUFRPX0NJUEhFUl9D UkVBVEVfU0VTU0lPTik7Cj4gPj4gKyAgICBoZWFkZXItPmFsZ28gPSBjcHVfdG9fbGUzMihhbGcp Owo+ID4+ICAgICAgIC8qIFNldCB0aGUgZGVmYXVsdCBkYXRhcXVldWUgaWQgdG8gMCAqLwo+ID4+ IC0gICAgdmNyeXB0by0+Y3RybC5oZWFkZXIucXVldWVfaWQgPSAwOwo+ID4+ICsgICAgaGVhZGVy LT5xdWV1ZV9pZCA9IDA7Cj4gPj4gLSAgICB2Y3J5cHRvLT5pbnB1dC5zdGF0dXMgPSBjcHVfdG9f bGUzMihWSVJUSU9fQ1JZUFRPX0VSUik7Cj4gPj4gICAgICAgLyogUGFkIGNpcGhlcidzIHBhcmFt ZXRlcnMgKi8KPiA+PiAtICAgIHZjcnlwdG8tPmN0cmwudS5zeW1fY3JlYXRlX3Nlc3Npb24ub3Bf dHlwZSA9Cj4gPj4gLSAgICAgICAgY3B1X3RvX2xlMzIoVklSVElPX0NSWVBUT19TWU1fT1BfQ0lQ SEVSKTsKPiA+PiAtICAgIHZjcnlwdG8tPmN0cmwudS5zeW1fY3JlYXRlX3Nlc3Npb24udS5jaXBo ZXIucGFyYS5hbGdvID0KPiA+PiAtICAgICAgICB2Y3J5cHRvLT5jdHJsLmhlYWRlci5hbGdvOwo+ ID4+IC0gICAgdmNyeXB0by0+Y3RybC51LnN5bV9jcmVhdGVfc2Vzc2lvbi51LmNpcGhlci5wYXJh LmtleWxlbiA9Cj4gPj4gLSAgICAgICAgY3B1X3RvX2xlMzIoa2V5bGVuKTsKPiA+PiAtICAgIHZj cnlwdG8tPmN0cmwudS5zeW1fY3JlYXRlX3Nlc3Npb24udS5jaXBoZXIucGFyYS5vcCA9Cj4gPj4g LSAgICAgICAgY3B1X3RvX2xlMzIob3ApOwo+ID4+IC0KPiA+PiAtICAgIHNnX2luaXRfb25lKCZv dXRoZHIsICZ2Y3J5cHRvLT5jdHJsLCBzaXplb2YodmNyeXB0by0+Y3RybCkpOwo+ID4+ICsgICAg c3ltX2NyZWF0ZV9zZXNzaW9uID0gJnZjX2N0cmxfcmVxLT5jdHJsLnUuc3ltX2NyZWF0ZV9zZXNz aW9uOwo+ID4+ICsgICAgc3ltX2NyZWF0ZV9zZXNzaW9uLT5vcF90eXBlID0KPiA+PiBjcHVfdG9f bGUzMihWSVJUSU9fQ1JZUFRPX1NZTV9PUF9DSVBIRVIpOwo+ID4+ICsgICAgc3ltX2NyZWF0ZV9z ZXNzaW9uLT51LmNpcGhlci5wYXJhLmFsZ28gPSBoZWFkZXItPmFsZ287Cj4gPj4gKyAgICBzeW1f Y3JlYXRlX3Nlc3Npb24tPnUuY2lwaGVyLnBhcmEua2V5bGVuID0gY3B1X3RvX2xlMzIoa2V5bGVu KTsKPiA+PiArICAgIHN5bV9jcmVhdGVfc2Vzc2lvbi0+dS5jaXBoZXIucGFyYS5vcCA9IGNwdV90 b19sZTMyKG9wKTsKPiA+PiArCj4gPj4gKyAgICBzZ19pbml0X29uZSgmb3V0aGRyLCAmdmNfY3Ry bF9yZXEtPmN0cmwsIHNpemVvZih2Y19jdHJsX3JlcS0+Y3RybCkpOwo+ID4+ICAgICAgIHNnc1tu dW1fb3V0KytdID0gJm91dGhkcjsKPiA+PiAgICAgICAvKiBTZXQga2V5ICovCj4gPj4gQEAgLTE2 MCw0NSArMTYzLDM0IEBAIHN0YXRpYyBpbnQgdmlydGlvX2NyeXB0b19hbGdfc2tjaXBoZXJfaW5p dF9zZXNzaW9uKAo+ID4+ICAgICAgIHNnc1tudW1fb3V0KytdID0gJmtleV9zZzsKPiA+PiAgICAg ICAvKiBSZXR1cm4gc3RhdHVzIGFuZCBzZXNzaW9uIGlkIGJhY2sgKi8KPiA+PiAtICAgIHNnX2lu aXRfb25lKCZpbmhkciwgJnZjcnlwdG8tPmlucHV0LCBzaXplb2YodmNyeXB0by0+aW5wdXQpKTsK PiA+PiArICAgIHZjX2N0cmxfcmVxLT5pbnB1dC5zdGF0dXMgPSBjcHVfdG9fbGUzMihWSVJUSU9f Q1JZUFRPX0VSUik7Cj4gPj4gKyAgICBzZ19pbml0X29uZSgmaW5oZHIsICZ2Y19jdHJsX3JlcS0+ aW5wdXQsCj4gPj4gc2l6ZW9mKHZjX2N0cmxfcmVxLT5pbnB1dCkpOwo+ID4+ICAgICAgIHNnc1tu dW1fb3V0ICsgbnVtX2luKytdID0gJmluaGRyOwo+ID4+IC0gICAgZXJyID0gdmlydHF1ZXVlX2Fk ZF9zZ3ModmNyeXB0by0+Y3RybF92cSwgc2dzLCBudW1fb3V0LAo+ID4+IC0gICAgICAgICAgICAg ICAgbnVtX2luLCB2Y3J5cHRvLCBHRlBfQVRPTUlDKTsKPiA+PiAtICAgIGlmIChlcnIgPCAwKSB7 Cj4gPj4gLSAgICAgICAgc3Bpbl91bmxvY2soJnZjcnlwdG8tPmN0cmxfbG9jayk7Cj4gPj4gLSAg ICAgICAga2ZyZWVfc2Vuc2l0aXZlKGNpcGhlcl9rZXkpOwo+ID4+IC0gICAgICAgIHJldHVybiBl cnI7Cj4gPj4gLSAgICB9Cj4gPj4gLSAgICB2aXJ0cXVldWVfa2ljayh2Y3J5cHRvLT5jdHJsX3Zx KTsKPiA+PiAtCj4gPj4gLSAgICAvKgo+ID4+IC0gICAgICogVHJhcHBpbmcgaW50byB0aGUgaHlw ZXJ2aXNvciwgc28gdGhlIHJlcXVlc3Qgc2hvdWxkIGJlCj4gPj4gLSAgICAgKiBoYW5kbGVkIGlt bWVkaWF0ZWx5Lgo+ID4+IC0gICAgICovCj4gPj4gLSAgICB3aGlsZSAoIXZpcnRxdWV1ZV9nZXRf YnVmKHZjcnlwdG8tPmN0cmxfdnEsICZ0bXApICYmCj4gPj4gLSAgICAgICAgICAgIXZpcnRxdWV1 ZV9pc19icm9rZW4odmNyeXB0by0+Y3RybF92cSkpCj4gPj4gLSAgICAgICAgY3B1X3JlbGF4KCk7 Cj4gPj4gKyAgICBlcnIgPSB2aXJ0aW9fY3J5cHRvX2N0cmxfdnFfcmVxdWVzdCh2Y3J5cHRvLCBz Z3MsIG51bV9vdXQsCj4gPj4gbnVtX2luLCB2Y19jdHJsX3JlcSk7Cj4gPj4gKyAgICBpZiAoZXJy IDwgMCkKPiA+PiArICAgICAgICBnb3RvIG91dDsKPiA+PiAtICAgIGlmIChsZTMyX3RvX2NwdSh2 Y3J5cHRvLT5pbnB1dC5zdGF0dXMpICE9IFZJUlRJT19DUllQVE9fT0spIHsKPiA+PiAtICAgICAg ICBzcGluX3VubG9jaygmdmNyeXB0by0+Y3RybF9sb2NrKTsKPiA+PiArICAgIGlmIChsZTMyX3Rv X2NwdSh2Y19jdHJsX3JlcS0+aW5wdXQuc3RhdHVzKSAhPSBWSVJUSU9fQ1JZUFRPX09LKSB7Cj4g Pj4gICAgICAgICAgIHByX2VycigidmlydGlvX2NyeXB0bzogQ3JlYXRlIHNlc3Npb24gZmFpbGVk IHN0YXR1czogJXVcbiIsCj4gPj4gLSAgICAgICAgICAgIGxlMzJfdG9fY3B1KHZjcnlwdG8tPmlu cHV0LnN0YXR1cykpOwo+ID4+IC0gICAgICAgIGtmcmVlX3NlbnNpdGl2ZShjaXBoZXJfa2V5KTsK PiA+PiAtICAgICAgICByZXR1cm4gLUVJTlZBTDsKPiA+PiArICAgICAgICAgICAgbGUzMl90b19j cHUodmNfY3RybF9yZXEtPmlucHV0LnN0YXR1cykpOwo+ID4+ICsgICAgICAgIGVyciA9IC1FSU5W QUw7Cj4gPj4gKyAgICAgICAgZ290byBvdXQ7Cj4gPj4gICAgICAgfQo+ID4+ICAgICAgIGlmIChl bmNyeXB0KQo+ID4+ICAgICAgICAgICBjdHgtPmVuY19zZXNzX2luZm8uc2Vzc2lvbl9pZCA9Cj4g Pj4gLSAgICAgICAgICAgIGxlNjRfdG9fY3B1KHZjcnlwdG8tPmlucHV0LnNlc3Npb25faWQpOwo+ ID4+ICsgICAgICAgICAgICBsZTY0X3RvX2NwdSh2Y19jdHJsX3JlcS0+aW5wdXQuc2Vzc2lvbl9p ZCk7Cj4gPj4gICAgICAgZWxzZQo+ID4+ICAgICAgICAgICBjdHgtPmRlY19zZXNzX2luZm8uc2Vz c2lvbl9pZCA9Cj4gPj4gLSAgICAgICAgICAgIGxlNjRfdG9fY3B1KHZjcnlwdG8tPmlucHV0LnNl c3Npb25faWQpOwo+ID4+IC0KPiA+PiAtICAgIHNwaW5fdW5sb2NrKCZ2Y3J5cHRvLT5jdHJsX2xv Y2spOwo+ID4+ICsgICAgICAgICAgICBsZTY0X3RvX2NwdSh2Y19jdHJsX3JlcS0+aW5wdXQuc2Vz c2lvbl9pZCk7Cj4gPj4gKyAgICBlcnIgPSAwOwo+ID4+ICtvdXQ6Cj4gPj4gKyAgICBrZnJlZSh2 Y19jdHJsX3JlcSk7Cj4gPj4gICAgICAga2ZyZWVfc2Vuc2l0aXZlKGNpcGhlcl9rZXkpOwo+ID4+ IC0gICAgcmV0dXJuIDA7Cj4gPj4gKwo+ID4+ICsgICAgcmV0dXJuIGVycjsKPiA+PiAgIH0KPiA+ PiAgIHN0YXRpYyBpbnQgdmlydGlvX2NyeXB0b19hbGdfc2tjaXBoZXJfY2xvc2Vfc2Vzc2lvbigK PiA+PiBAQCAtMjA2LDIxICsxOTgsMjQgQEAgc3RhdGljIGludAo+ID4+IHZpcnRpb19jcnlwdG9f YWxnX3NrY2lwaGVyX2Nsb3NlX3Nlc3Npb24oCj4gPj4gICAgICAgICAgIGludCBlbmNyeXB0KQo+ ID4+ICAgewo+ID4+ICAgICAgIHN0cnVjdCBzY2F0dGVybGlzdCBvdXRoZHIsIHN0YXR1c19zZywg KnNnc1syXTsKPiA+PiAtICAgIHVuc2lnbmVkIGludCB0bXA7Cj4gPj4gICAgICAgc3RydWN0IHZp cnRpb19jcnlwdG9fZGVzdHJveV9zZXNzaW9uX3JlcSAqZGVzdHJveV9zZXNzaW9uOwo+ID4+ICAg ICAgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvICp2Y3J5cHRvID0gY3R4LT52Y3J5cHRvOwo+ID4+ICAg ICAgIGludCBlcnI7Cj4gPj4gICAgICAgdW5zaWduZWQgaW50IG51bV9vdXQgPSAwLCBudW1faW4g PSAwOwo+ID4+ICsgICAgc3RydWN0IHZpcnRpb19jcnlwdG9fY3RybF9yZXF1ZXN0ICp2Y19jdHJs X3JlcTsKPiA+PiArICAgIHN0cnVjdCB2aXJ0aW9fY3J5cHRvX2N0cmxfaGVhZGVyICpoZWFkZXI7 Cj4gPj4gKwo+ID4+ICsgICAgdmNfY3RybF9yZXEgPSBremFsbG9jKHNpemVvZigqdmNfY3RybF9y ZXEpLCBHRlBfS0VSTkVMKTsKPiA+PiArICAgIGlmICghdmNfY3RybF9yZXEpCj4gPj4gKyAgICAg ICAgcmV0dXJuIC1FTk9NRU07Cj4gPj4gLSAgICBzcGluX2xvY2soJnZjcnlwdG8tPmN0cmxfbG9j ayk7Cj4gPj4gLSAgICB2Y3J5cHRvLT5jdHJsX3N0YXR1cy5zdGF0dXMgPSBWSVJUSU9fQ1JZUFRP X0VSUjsKPiA+PiAgICAgICAvKiBQYWQgY3RybCBoZWFkZXIgKi8KPiA+PiAtICAgIHZjcnlwdG8t PmN0cmwuaGVhZGVyLm9wY29kZSA9Cj4gPj4gLSAgICAgICAgY3B1X3RvX2xlMzIoVklSVElPX0NS WVBUT19DSVBIRVJfREVTVFJPWV9TRVNTSU9OKTsKPiA+PiArICAgIGhlYWRlciA9ICZ2Y19jdHJs X3JlcS0+Y3RybC5oZWFkZXI7Cj4gPj4gKyAgICBoZWFkZXItPm9wY29kZSA9IGNwdV90b19sZTMy KFZJUlRJT19DUllQVE9fQ0lQSEVSX0RFU1RST1lfU0VTU0lPTik7Cj4gPj4gICAgICAgLyogU2V0 IHRoZSBkZWZhdWx0IHZpcnRxdWV1ZSBpZCB0byAwICovCj4gPj4gLSAgICB2Y3J5cHRvLT5jdHJs LmhlYWRlci5xdWV1ZV9pZCA9IDA7Cj4gPj4gKyAgICBoZWFkZXItPnF1ZXVlX2lkID0gMDsKPiA+ PiAtICAgIGRlc3Ryb3lfc2Vzc2lvbiA9ICZ2Y3J5cHRvLT5jdHJsLnUuZGVzdHJveV9zZXNzaW9u Owo+ID4+ICsgICAgZGVzdHJveV9zZXNzaW9uID0gJnZjX2N0cmxfcmVxLT5jdHJsLnUuZGVzdHJv eV9zZXNzaW9uOwo+ID4+ICAgICAgIGlmIChlbmNyeXB0KQo+ID4+ICAgICAgICAgICBkZXN0cm95 X3Nlc3Npb24tPnNlc3Npb25faWQgPQo+ID4+IEBAIC0yMjksMzcgKzIyNCwzMyBAQCBzdGF0aWMg aW50Cj4gPj4gdmlydGlvX2NyeXB0b19hbGdfc2tjaXBoZXJfY2xvc2Vfc2Vzc2lvbigKPiA+PiAg ICAgICAgICAgZGVzdHJveV9zZXNzaW9uLT5zZXNzaW9uX2lkID0KPiA+PiAgICAgICAgICAgICAg IGNwdV90b19sZTY0KGN0eC0+ZGVjX3Nlc3NfaW5mby5zZXNzaW9uX2lkKTsKPiA+PiAtICAgIHNn X2luaXRfb25lKCZvdXRoZHIsICZ2Y3J5cHRvLT5jdHJsLCBzaXplb2YodmNyeXB0by0+Y3RybCkp Owo+ID4+ICsgICAgc2dfaW5pdF9vbmUoJm91dGhkciwgJnZjX2N0cmxfcmVxLT5jdHJsLCBzaXpl b2YodmNfY3RybF9yZXEtPmN0cmwpKTsKPiA+PiAgICAgICBzZ3NbbnVtX291dCsrXSA9ICZvdXRo ZHI7Cj4gPj4gICAgICAgLyogUmV0dXJuIHN0YXR1cyBhbmQgc2Vzc2lvbiBpZCBiYWNrICovCj4g Pj4gLSAgICBzZ19pbml0X29uZSgmc3RhdHVzX3NnLCAmdmNyeXB0by0+Y3RybF9zdGF0dXMuc3Rh dHVzLAo+ID4+IC0gICAgICAgIHNpemVvZih2Y3J5cHRvLT5jdHJsX3N0YXR1cy5zdGF0dXMpKTsK PiA+PiArICAgIHZjX2N0cmxfcmVxLT5jdHJsX3N0YXR1cy5zdGF0dXMgPSBWSVJUSU9fQ1JZUFRP X0VSUjsKPiA+PiArICAgIHNnX2luaXRfb25lKCZzdGF0dXNfc2csICZ2Y19jdHJsX3JlcS0+Y3Ry bF9zdGF0dXMuc3RhdHVzLAo+ID4+ICsgICAgICAgIHNpemVvZih2Y19jdHJsX3JlcS0+Y3RybF9z dGF0dXMuc3RhdHVzKSk7Cj4gPj4gICAgICAgc2dzW251bV9vdXQgKyBudW1faW4rK10gPSAmc3Rh dHVzX3NnOwo+ID4+IC0gICAgZXJyID0gdmlydHF1ZXVlX2FkZF9zZ3ModmNyeXB0by0+Y3RybF92 cSwgc2dzLCBudW1fb3V0LAo+ID4+IC0gICAgICAgICAgICBudW1faW4sIHZjcnlwdG8sIEdGUF9B VE9NSUMpOwo+ID4+IC0gICAgaWYgKGVyciA8IDApIHsKPiA+PiAtICAgICAgICBzcGluX3VubG9j aygmdmNyeXB0by0+Y3RybF9sb2NrKTsKPiA+PiAtICAgICAgICByZXR1cm4gZXJyOwo+ID4+IC0g ICAgfQo+ID4+IC0gICAgdmlydHF1ZXVlX2tpY2sodmNyeXB0by0+Y3RybF92cSk7Cj4gPj4gLQo+ ID4+IC0gICAgd2hpbGUgKCF2aXJ0cXVldWVfZ2V0X2J1Zih2Y3J5cHRvLT5jdHJsX3ZxLCAmdG1w KSAmJgo+ID4+IC0gICAgICAgICAgICF2aXJ0cXVldWVfaXNfYnJva2VuKHZjcnlwdG8tPmN0cmxf dnEpKQo+ID4+IC0gICAgICAgIGNwdV9yZWxheCgpOwo+ID4+ICsgICAgZXJyID0gdmlydGlvX2Ny eXB0b19jdHJsX3ZxX3JlcXVlc3QodmNyeXB0bywgc2dzLCBudW1fb3V0LAo+ID4+IG51bV9pbiwg dmNfY3RybF9yZXEpOwo+ID4+ICsgICAgaWYgKGVyciA8IDApCj4gPj4gKyAgICAgICAgZ290byBv dXQ7Cj4gPj4gLSAgICBpZiAodmNyeXB0by0+Y3RybF9zdGF0dXMuc3RhdHVzICE9IFZJUlRJT19D UllQVE9fT0spIHsKPiA+PiAtICAgICAgICBzcGluX3VubG9jaygmdmNyeXB0by0+Y3RybF9sb2Nr KTsKPiA+PiArICAgIGlmICh2Y19jdHJsX3JlcS0+Y3RybF9zdGF0dXMuc3RhdHVzICE9IFZJUlRJ T19DUllQVE9fT0spIHsKPiA+PiAgICAgICAgICAgcHJfZXJyKCJ2aXJ0aW9fY3J5cHRvOiBDbG9z ZSBzZXNzaW9uIGZhaWxlZCBzdGF0dXM6ICV1LAo+ID4+IHNlc3Npb25faWQ6IDB4JWxseFxuIiwK PiA+PiAtICAgICAgICAgICAgdmNyeXB0by0+Y3RybF9zdGF0dXMuc3RhdHVzLAo+ID4+ICsgICAg ICAgICAgICB2Y19jdHJsX3JlcS0+Y3RybF9zdGF0dXMuc3RhdHVzLAo+ID4+ICAgICAgICAgICAg ICAgZGVzdHJveV9zZXNzaW9uLT5zZXNzaW9uX2lkKTsKPiA+PiAtICAgICAgICByZXR1cm4gLUVJ TlZBTDsKPiA+PiArICAgICAgICBlcnIgPSAtRUlOVkFMOwo+ID4+ICsgICAgICAgIGdvdG8gb3V0 Owo+ID4+ICAgICAgIH0KPiA+PiAtICAgIHNwaW5fdW5sb2NrKCZ2Y3J5cHRvLT5jdHJsX2xvY2sp Owo+ID4+IC0gICAgcmV0dXJuIDA7Cj4gPj4gKyAgICBlcnIgPSAwOwo+ID4+ICtvdXQ6Cj4gPj4g KyAgICBrZnJlZSh2Y19jdHJsX3JlcSk7Cj4gPj4gKwo+ID4+ICsgICAgcmV0dXJuIGVycjsKPiA+ PiAgIH0KPiA+PiAgIHN0YXRpYyBpbnQgdmlydGlvX2NyeXB0b19hbGdfc2tjaXBoZXJfaW5pdF9z ZXNzaW9ucygKPiA+Cj4KPiAtLQo+IHpoZW53ZWkgcGkKPgoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KVmlydHVhbGl6YXRpb24gbWFpbGluZyBsaXN0ClZp cnR1YWxpemF0aW9uQGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGlu dXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL3ZpcnR1YWxpemF0aW9u