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 X-Spam-Level: X-Spam-Status: No, score=-12.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7439DC433B4 for ; Tue, 4 May 2021 16:28:48 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 454CF611AD for ; Tue, 4 May 2021 16:28:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231849AbhEDQ3m (ORCPT ); Tue, 4 May 2021 12:29:42 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:56810 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231781AbhEDQ3j (ORCPT ); Tue, 4 May 2021 12:29:39 -0400 Received: from mail-ej1-x632.google.com (mail-ej1-x632.google.com [IPv6:2a00:1450:4864:20::632]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6914DC061574 for ; Tue, 4 May 2021 09:28:44 -0700 (PDT) Received: by mail-ej1-x632.google.com with SMTP id l4so14104775ejc.10 for ; Tue, 04 May 2021 09:28:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc:content-transfer-encoding; bh=Z/XXSFGnjR3kTMpJJL6/uEtZkYFyQ/w68fOcgUqaYlI=; b=fSG+EnJ4/Jz4+DPhjR6ISzcENbWM+pbYGKUks+Ht4ZvggWaqPazOFyOeJ7C5d5rGDq 4d67Wzzyh4TdCjODf3CkgRff5Dw8ILTb8Mkull623Yim9x1h5hOTTDaIpIWYZ5xEpC1K HbNnO5ofZre31jvUACfZebE4Z43EGJMQAtQEQV/L9UBYT+uZ6B3vFo3BD1HLe5n2aDUM ohe06UzqqXPETBm4M7GKVjQQNndpzsOSzhuOGgctsgk8b2WSHDOJIdK5jV2WaSh2zMqh 5pmBD03c5KBZ+D2U9BC0bDjP8pGc7alEQ4puJflgtRtebAJMokKvB6WOuRweAKt0c4Vm KbYg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=Z/XXSFGnjR3kTMpJJL6/uEtZkYFyQ/w68fOcgUqaYlI=; b=qrMaJVApjIvWwGm0QXabjQzs6nLeLkiLZn+QGnQrmLcmqyOvG2AFr+M18HeYBa49Ux NicI0NBVhq0uwGlaG9ayg/qjrZ26ZJCbCyNbZWELfsAMrXWWTPQv8w5WYMTM0ZSiuasH yYxsynzibvfSByliMUEG4EdXuE7bN5Y84iSX56P4RNmLUghQCWW10//diQNa7jNf+ogU geNChhlsVf0jhnp62gGANrdj/8/MhQSH+jAUOHhyEa47Bphemukl2freRYDXVhPDP8YL JAABlwF6V0lewh8VzYwSDYUUrCcO6GiKIF7y5dRf/QNNBbndiclJ5R/+ZAmdDOrRTyMO 1KJQ== X-Gm-Message-State: AOAM530GAkDV8oaCQf03BRTdiPwYf12VKZaSmfdpjougnTGlQUGSOgQU REmLEpGXx6G5A0ZA/s7jg8HhqnLgIlhygewRW0k= X-Google-Smtp-Source: ABdhPJw+Vlo2wIuop4v3nZVy7vgehSUoi7d132w3jP1ADPLQ0eTE4PsDNriD8KCc8jHFcIlCRwp2/LnimF9wrQAQlLs= X-Received: by 2002:a17:906:90b:: with SMTP id i11mr22848207ejd.168.1620145723009; Tue, 04 May 2021 09:28:43 -0700 (PDT) MIME-Version: 1.0 References: <20210429190926.5086-1-smalin@marvell.com> <20210429190926.5086-7-smalin@marvell.com> <88d052a4-4a91-b5e7-5d53-1fb2a1507909@suse.de> In-Reply-To: <88d052a4-4a91-b5e7-5d53-1fb2a1507909@suse.de> From: Shai Malin Date: Tue, 4 May 2021 19:28:30 +0300 Message-ID: Subject: Re: [RFC PATCH v4 06/27] qed: Add NVMeTCP Offload IO Level FW Initializations To: Hannes Reinecke Cc: Shai Malin , netdev@vger.kernel.org, davem@davemloft.net, kuba@kernel.org, linux-nvme@lists.infradead.org, sagi@grimberg.me, hch@lst.de, axboe@fb.com, kbusch@kernel.org, Ariel Elior , Michal Kalderon , okulkarni@marvell.com, pkushwaha@marvell.com Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org On 5/2/21 2:25 PM, Hannes Reinecke wrote: > On 4/29/21 9:09 PM, Shai Malin wrote: > > This patch introduces the NVMeTCP FW initializations which is used > > to initialize the IO level configuration into a per IO HW > > resource ("task") as part of the IO path flow. > > > > This includes: > > - Write IO FW initialization > > - Read IO FW initialization. > > - IC-Req and IC-Resp FW exchange. > > - FW Cleanup flow (Flush IO). > > > > Acked-by: Igor Russkikh > > Signed-off-by: Prabhakar Kushwaha > > Signed-off-by: Omkar Kulkarni > > Signed-off-by: Shai Malin > > Signed-off-by: Michal Kalderon > > Signed-off-by: Ariel Elior > > --- > > drivers/net/ethernet/qlogic/qed/Makefile | 5 +- > > drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c | 7 +- > > .../qlogic/qed/qed_nvmetcp_fw_funcs.c | 372 +++++++++++++++++= + > > .../qlogic/qed/qed_nvmetcp_fw_funcs.h | 43 ++ > > include/linux/qed/nvmetcp_common.h | 3 + > > include/linux/qed/qed_nvmetcp_if.h | 17 + > > 6 files changed, 445 insertions(+), 2 deletions(-) > > create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_fun= cs.c > > create mode 100644 drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_fun= cs.h > > > > diff --git a/drivers/net/ethernet/qlogic/qed/Makefile b/drivers/net/eth= ernet/qlogic/qed/Makefile > > index 7cb0db67ba5b..0d9c2fe0245d 100644 > > --- a/drivers/net/ethernet/qlogic/qed/Makefile > > +++ b/drivers/net/ethernet/qlogic/qed/Makefile > > @@ -28,7 +28,10 @@ qed-$(CONFIG_QED_ISCSI) +=3D qed_iscsi.o > > qed-$(CONFIG_QED_LL2) +=3D qed_ll2.o > > qed-$(CONFIG_QED_OOO) +=3D qed_ooo.o > > > > -qed-$(CONFIG_QED_NVMETCP) +=3D qed_nvmetcp.o > > +qed-$(CONFIG_QED_NVMETCP) +=3D \ > > + qed_nvmetcp.o \ > > + qed_nvmetcp_fw_funcs.o \ > > + qed_nvmetcp_ip_services.o > > > > qed-$(CONFIG_QED_RDMA) +=3D \ > > qed_iwarp.o \ > > diff --git a/drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c b/drivers/ne= t/ethernet/qlogic/qed/qed_nvmetcp.c > > index 1e2eb6dcbd6e..434363f8b5c0 100644 > > --- a/drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c > > +++ b/drivers/net/ethernet/qlogic/qed/qed_nvmetcp.c > > @@ -27,6 +27,7 @@ > > #include "qed_mcp.h" > > #include "qed_sp.h" > > #include "qed_reg_addr.h" > > +#include "qed_nvmetcp_fw_funcs.h" > > > > static int qed_nvmetcp_async_event(struct qed_hwfn *p_hwfn, u8 fw_eve= nt_code, > > u16 echo, union event_ring_data *data, > > @@ -848,7 +849,11 @@ static const struct qed_nvmetcp_ops qed_nvmetcp_op= s_pass =3D { > > .remove_src_tcp_port_filter =3D &qed_llh_remove_src_tcp_port_filt= er, > > .add_dst_tcp_port_filter =3D &qed_llh_add_dst_tcp_port_filter, > > .remove_dst_tcp_port_filter =3D &qed_llh_remove_dst_tcp_port_filt= er, > > - .clear_all_filters =3D &qed_llh_clear_all_filters > > + .clear_all_filters =3D &qed_llh_clear_all_filters, > > + .init_read_io =3D &init_nvmetcp_host_read_task, > > + .init_write_io =3D &init_nvmetcp_host_write_task, > > + .init_icreq_exchange =3D &init_nvmetcp_init_conn_req_task, > > + .init_task_cleanup =3D &init_cleanup_task_nvmetcp > > }; > > > > const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops(void) > > diff --git a/drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c b/d= rivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c > > new file mode 100644 > > index 000000000000..8485ad678284 > > --- /dev/null > > +++ b/drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.c > > @@ -0,0 +1,372 @@ > > +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) > > +/* Copyright 2021 Marvell. All rights reserved. */ > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include "qed_nvmetcp_fw_funcs.h" > > + > > +#define NVMETCP_NUM_SGES_IN_CACHE 0x4 > > + > > +bool nvmetcp_is_slow_sgl(u16 num_sges, bool small_mid_sge) > > +{ > > + return (num_sges > SCSI_NUM_SGES_SLOW_SGL_THR && small_mid_sge); > > +} > > + > > +void init_scsi_sgl_context(struct scsi_sgl_params *ctx_sgl_params, > > + struct scsi_cached_sges *ctx_data_desc, > > + struct storage_sgl_task_params *sgl_params) > > +{ > > + u8 num_sges_to_init =3D (u8)(sgl_params->num_sges > NVMETCP_NUM_S= GES_IN_CACHE ? > > + NVMETCP_NUM_SGES_IN_CACHE : sgl_params= ->num_sges); > > + u8 sge_index; > > + > > + /* sgl params */ > > + ctx_sgl_params->sgl_addr.lo =3D cpu_to_le32(sgl_params->sgl_phys_= addr.lo); > > + ctx_sgl_params->sgl_addr.hi =3D cpu_to_le32(sgl_params->sgl_phys_= addr.hi); > > + ctx_sgl_params->sgl_total_length =3D cpu_to_le32(sgl_params->tota= l_buffer_size); > > + ctx_sgl_params->sgl_num_sges =3D cpu_to_le16(sgl_params->num_sges= ); > > + > > + for (sge_index =3D 0; sge_index < num_sges_to_init; sge_index++) = { > > + ctx_data_desc->sge[sge_index].sge_addr.lo =3D > > + cpu_to_le32(sgl_params->sgl[sge_index].sge_addr.l= o); > > + ctx_data_desc->sge[sge_index].sge_addr.hi =3D > > + cpu_to_le32(sgl_params->sgl[sge_index].sge_addr.h= i); > > + ctx_data_desc->sge[sge_index].sge_len =3D > > + cpu_to_le32(sgl_params->sgl[sge_index].sge_len); > > + } > > +} > > + > > +static inline u32 calc_rw_task_size(struct nvmetcp_task_params *task_p= arams, > > + enum nvmetcp_task_type task_type) > > +{ > > + u32 io_size; > > + > > + if (task_type =3D=3D NVMETCP_TASK_TYPE_HOST_WRITE) > > + io_size =3D task_params->tx_io_size; > > + else > > + io_size =3D task_params->rx_io_size; > > + > > + if (unlikely(!io_size)) > > + return 0; > > + > > + return io_size; > > +} > > + > > +static inline void init_sqe(struct nvmetcp_task_params *task_params, > > + struct storage_sgl_task_params *sgl_task_para= ms, > > + enum nvmetcp_task_type task_type) > > +{ > > + if (!task_params->sqe) > > + return; > > + > > + memset(task_params->sqe, 0, sizeof(*task_params->sqe)); > > + task_params->sqe->task_id =3D cpu_to_le16(task_params->itid); > > + > > + switch (task_type) { > > + case NVMETCP_TASK_TYPE_HOST_WRITE: { > > + u32 buf_size =3D 0; > > + u32 num_sges =3D 0; > > + > > + SET_FIELD(task_params->sqe->contlen_cdbsize, > > + NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD, 1); > > + SET_FIELD(task_params->sqe->flags, NVMETCP_WQE_WQE_TYPE, > > + NVMETCP_WQE_TYPE_NORMAL); > > + if (task_params->tx_io_size) { > > + if (task_params->send_write_incapsule) > > + buf_size =3D calc_rw_task_size(task_param= s, task_type); > > + > > + if (nvmetcp_is_slow_sgl(sgl_task_params->num_sges= , > > + sgl_task_params->small_mi= d_sge)) > > + num_sges =3D NVMETCP_WQE_NUM_SGES_SLOWIO; > > + else > > + num_sges =3D min((u16)sgl_task_params->nu= m_sges, > > + (u16)SCSI_NUM_SGES_SLOW_SG= L_THR); > > + } > > + SET_FIELD(task_params->sqe->flags, NVMETCP_WQE_NUM_SGES, = num_sges); > > + SET_FIELD(task_params->sqe->contlen_cdbsize, NVMETCP_WQE_= CONT_LEN, buf_size); > > + } break; > > + > > + case NVMETCP_TASK_TYPE_HOST_READ: { > > + SET_FIELD(task_params->sqe->flags, NVMETCP_WQE_WQE_TYPE, > > + NVMETCP_WQE_TYPE_NORMAL); > > + SET_FIELD(task_params->sqe->contlen_cdbsize, > > + NVMETCP_WQE_CDB_SIZE_OR_NVMETCP_CMD, 1); > > + } break; > > + > > + case NVMETCP_TASK_TYPE_INIT_CONN_REQUEST: { > > + SET_FIELD(task_params->sqe->flags, NVMETCP_WQE_WQE_TYPE, > > + NVMETCP_WQE_TYPE_MIDDLE_PATH); > > + > > + if (task_params->tx_io_size) { > > + SET_FIELD(task_params->sqe->contlen_cdbsize, NVME= TCP_WQE_CONT_LEN, > > + task_params->tx_io_size); > > + SET_FIELD(task_params->sqe->flags, NVMETCP_WQE_NU= M_SGES, > > + min((u16)sgl_task_params->num_sges, > > + (u16)SCSI_NUM_SGES_SLOW_SGL_THR)); > > + } > > + } break; > > + > > + case NVMETCP_TASK_TYPE_CLEANUP: > > + SET_FIELD(task_params->sqe->flags, NVMETCP_WQE_WQE_TYPE, > > + NVMETCP_WQE_TYPE_TASK_CLEANUP); > > + > > + default: > > + break; > > + } > > +} > > + > > +/* The following function initializes of NVMeTCP task params */ > > +static inline void > > +init_nvmetcp_task_params(struct e5_nvmetcp_task_context *context, > > + struct nvmetcp_task_params *task_params, > > + enum nvmetcp_task_type task_type) > > +{ > > + context->ystorm_st_context.state.cccid =3D task_params->host_ccci= d; > > + SET_FIELD(context->ustorm_st_context.error_flags, USTORM_NVMETCP_= TASK_ST_CTX_NVME_TCP, 1); > > + context->ustorm_st_context.nvme_tcp_opaque_lo =3D cpu_to_le32(tas= k_params->opq.lo); > > + context->ustorm_st_context.nvme_tcp_opaque_hi =3D cpu_to_le32(tas= k_params->opq.hi); > > +} > > + > > +/* The following function initializes default values to all tasks */ > > +static inline void > > +init_default_nvmetcp_task(struct nvmetcp_task_params *task_params, voi= d *pdu_header, > > + enum nvmetcp_task_type task_type) > > +{ > > + struct e5_nvmetcp_task_context *context =3D task_params->context; > > + const u8 val_byte =3D context->mstorm_ag_context.cdu_validation; > > + u8 dw_index; > > + > > + memset(context, 0, sizeof(*context)); > > + > > + init_nvmetcp_task_params(context, task_params, > > + (enum nvmetcp_task_type)task_type); > > + > > + if (task_type =3D=3D NVMETCP_TASK_TYPE_HOST_WRITE || > > + task_type =3D=3D NVMETCP_TASK_TYPE_HOST_READ) { > > + for (dw_index =3D 0; dw_index < QED_NVMETCP_CMD_HDR_SIZE = / 4; dw_index++) > > + context->ystorm_st_context.pdu_hdr.task_hdr.reg[d= w_index] =3D > > + cpu_to_le32(((u32 *)pdu_header)[dw_index]= ); > > + } else { > > + for (dw_index =3D 0; dw_index < QED_NVMETCP_CMN_HDR_SIZE = / 4; dw_index++) > > + context->ystorm_st_context.pdu_hdr.task_hdr.reg[d= w_index] =3D > > + cpu_to_le32(((u32 *)pdu_header)[dw_index]= ); > > + } > > + > > And this is what I meant. You are twiddling with the bytes already, so > why bother with a separate struct at all? We agree, will be fixed in V5. > > > + /* M-Storm Context: */ > > + context->mstorm_ag_context.cdu_validation =3D val_byte; > > + context->mstorm_st_context.task_type =3D (u8)(task_type); > > + context->mstorm_ag_context.task_cid =3D cpu_to_le16(task_params->= conn_icid); > > + > > + /* Ustorm Context: */ > > + SET_FIELD(context->ustorm_ag_context.flags1, E5_USTORM_NVMETCP_TA= SK_AG_CTX_R2T2RECV, 1); > > + context->ustorm_st_context.task_type =3D (u8)(task_type); > > + context->ustorm_st_context.cq_rss_number =3D task_params->cq_rss_= number; > > + context->ustorm_ag_context.icid =3D cpu_to_le16(task_params->conn= _icid); > > +} > > + > > +/* The following function initializes the U-Storm Task Contexts */ > > +static inline void > > +init_ustorm_task_contexts(struct ustorm_nvmetcp_task_st_ctx *ustorm_st= _context, > > + struct e5_ustorm_nvmetcp_task_ag_ctx *ustorm_ag= _context, > > + u32 remaining_recv_len, > > + u32 expected_data_transfer_len, u8 num_sges, > > + bool tx_dif_conn_err_en) > > +{ > > + /* Remaining data to be received in bytes. Used in validations*/ > > + ustorm_st_context->rem_rcv_len =3D cpu_to_le32(remaining_recv_len= ); > > + ustorm_ag_context->exp_data_acked =3D cpu_to_le32(expected_data_t= ransfer_len); > > + ustorm_st_context->exp_data_transfer_len =3D cpu_to_le32(expected= _data_transfer_len); > > + SET_FIELD(ustorm_st_context->reg1.reg1_map, NVMETCP_REG1_NUM_SGES= , num_sges); > > + SET_FIELD(ustorm_ag_context->flags2, E5_USTORM_NVMETCP_TASK_AG_CT= X_DIF_ERROR_CF_EN, > > + tx_dif_conn_err_en ? 1 : 0); > > +} > > + > > +/* The following function initializes Local Completion Contexts: */ > > +static inline void > > +set_local_completion_context(struct e5_nvmetcp_task_context *context) > > +{ > > + SET_FIELD(context->ystorm_st_context.state.flags, > > + YSTORM_NVMETCP_TASK_STATE_LOCAL_COMP, 1); > > + SET_FIELD(context->ustorm_st_context.flags, > > + USTORM_NVMETCP_TASK_ST_CTX_LOCAL_COMP, 1); > > +} > > + > > +/* Common Fastpath task init function: */ > > +static inline void > > +init_rw_nvmetcp_task(struct nvmetcp_task_params *task_params, > > + enum nvmetcp_task_type task_type, > > + struct nvmetcp_conn_params *conn_params, void *pdu_h= eader, > > + struct storage_sgl_task_params *sgl_task_params) > > +{ > > + struct e5_nvmetcp_task_context *context =3D task_params->context; > > + u32 task_size =3D calc_rw_task_size(task_params, task_type); > > + u32 exp_data_transfer_len =3D conn_params->max_burst_length; > > + bool slow_io =3D false; > > + u8 num_sges =3D 0; > > + > > + init_default_nvmetcp_task(task_params, pdu_header, task_type); > > + > > + /* Tx/Rx: */ > > + if (task_params->tx_io_size) { > > + /* if data to transmit: */ > > + init_scsi_sgl_context(&context->ystorm_st_context.state.s= gl_params, > > + &context->ystorm_st_context.state.d= ata_desc, > > + sgl_task_params); > > + slow_io =3D nvmetcp_is_slow_sgl(sgl_task_params->num_sges= , > > + sgl_task_params->small_mid_= sge); > > + num_sges =3D > > + (u8)(!slow_io ? min((u32)sgl_task_params->num_sge= s, > > + (u32)SCSI_NUM_SGES_SLOW_SGL_T= HR) : > > + NVMETCP_WQE_NUM_SGES_SLOWIO); > > + if (slow_io) { > > + SET_FIELD(context->ystorm_st_context.state.flags, > > + YSTORM_NVMETCP_TASK_STATE_SLOW_IO, 1); > > + } > > + } else if (task_params->rx_io_size) { > > + /* if data to receive: */ > > + init_scsi_sgl_context(&context->mstorm_st_context.sgl_par= ams, > > + &context->mstorm_st_context.data_de= sc, > > + sgl_task_params); > > + num_sges =3D > > + (u8)(!nvmetcp_is_slow_sgl(sgl_task_params->num_sg= es, > > + sgl_task_params->small_= mid_sge) ? > > + min((u32)sgl_task_param= s->num_sges, > > + (u32)SCSI_NUM_SGES_= SLOW_SGL_THR) : > > + NVMETCP_WQE_NUM_SGE= S_SLOWIO); > > + context->mstorm_st_context.rem_task_size =3D cpu_to_le32(= task_size); > > + } > > + > > + /* Ustorm context: */ > > + if (exp_data_transfer_len > task_size) > > + /* The size of the transmitted task*/ > > + exp_data_transfer_len =3D task_size; > > + init_ustorm_task_contexts(&context->ustorm_st_context, > > + &context->ustorm_ag_context, > > + /* Remaining Receive length is the Task= Size */ > > + task_size, > > + /* The size of the transmitted task */ > > + exp_data_transfer_len, > > + /* num_sges */ > > + num_sges, > > + false); > > + > > + /* Set exp_data_acked */ > > + if (task_type =3D=3D NVMETCP_TASK_TYPE_HOST_WRITE) { > > + if (task_params->send_write_incapsule) > > + context->ustorm_ag_context.exp_data_acked =3D tas= k_size; > > + else > > + context->ustorm_ag_context.exp_data_acked =3D 0; > > + } else if (task_type =3D=3D NVMETCP_TASK_TYPE_HOST_READ) { > > + context->ustorm_ag_context.exp_data_acked =3D 0; > > + } > > + > > + context->ustorm_ag_context.exp_cont_len =3D 0; > > + > > + init_sqe(task_params, sgl_task_params, task_type); > > +} > > + > > +static void > > +init_common_initiator_read_task(struct nvmetcp_task_params *task_param= s, > > + struct nvmetcp_conn_params *conn_params, > > + struct nvmetcp_cmd_capsule_hdr *cmd_pdu_h= eader, > > + struct storage_sgl_task_params *sgl_task_= params) > > +{ > > + init_rw_nvmetcp_task(task_params, NVMETCP_TASK_TYPE_HOST_READ, > > + conn_params, cmd_pdu_header, sgl_task_params= ); > > +} > > + > > +void init_nvmetcp_host_read_task(struct nvmetcp_task_params *task_para= ms, > > + struct nvmetcp_conn_params *conn_params, > > + struct nvmetcp_cmd_capsule_hdr *cmd_pdu_= header, > > + struct storage_sgl_task_params *sgl_task= _params) > > +{ > > + init_common_initiator_read_task(task_params, conn_params, > > + (void *)cmd_pdu_header, sgl_task_= params); > > +} > > + > > +static void > > +init_common_initiator_write_task(struct nvmetcp_task_params *task_para= ms, > > + struct nvmetcp_conn_params *conn_params, > > + struct nvmetcp_cmd_capsule_hdr *cmd_pdu_= header, > > + struct storage_sgl_task_params *sgl_task= _params) > > +{ > > + init_rw_nvmetcp_task(task_params, NVMETCP_TASK_TYPE_HOST_WRITE, > > + conn_params, cmd_pdu_header, sgl_task_params= ); > > +} > > + > > +void init_nvmetcp_host_write_task(struct nvmetcp_task_params *task_par= ams, > > + struct nvmetcp_conn_params *conn_params= , > > + struct nvmetcp_cmd_capsule_hdr *cmd_pdu= _header, > > + struct storage_sgl_task_params *sgl_tas= k_params) > > +{ > > + init_common_initiator_write_task(task_params, conn_params, > > + (void *)cmd_pdu_header, > > + sgl_task_params); > > +} > > + > > +static void > > +init_common_login_request_task(struct nvmetcp_task_params *task_params= , > > + void *login_req_pdu_header, > > + struct storage_sgl_task_params *tx_sgl_tas= k_params, > > + struct storage_sgl_task_params *rx_sgl_tas= k_params) > > +{ > > + struct e5_nvmetcp_task_context *context =3D task_params->context; > > + > > + init_default_nvmetcp_task(task_params, (void *)login_req_pdu_head= er, > > + NVMETCP_TASK_TYPE_INIT_CONN_REQUEST); > > + > > + /* Ustorm Context: */ > > + init_ustorm_task_contexts(&context->ustorm_st_context, > > + &context->ustorm_ag_context, > > + > > + /* Remaining Receive length is the Task= Size */ > > + task_params->rx_io_size ? > > + rx_sgl_task_params->total_buffer_size := 0, > > + > > + /* The size of the transmitted task */ > > + task_params->tx_io_size ? > > + tx_sgl_task_params->total_buffer_size := 0, > > + 0, /* num_sges */ > > + 0); /* tx_dif_conn_err_en */ > > + > > + /* SGL context: */ > > + if (task_params->tx_io_size) > > + init_scsi_sgl_context(&context->ystorm_st_context.state.s= gl_params, > > + &context->ystorm_st_context.state.d= ata_desc, > > + tx_sgl_task_params); > > + if (task_params->rx_io_size) > > + init_scsi_sgl_context(&context->mstorm_st_context.sgl_par= ams, > > + &context->mstorm_st_context.data_de= sc, > > + rx_sgl_task_params); > > + > > + context->mstorm_st_context.rem_task_size =3D > > + cpu_to_le32(task_params->rx_io_size ? > > + rx_sgl_task_params->total_buffer_size : = 0); > > + > > + init_sqe(task_params, tx_sgl_task_params, NVMETCP_TASK_TYPE_INIT_= CONN_REQUEST); > > +} > > + > > +/* The following function initializes Login task in Host mode: */ > > +void init_nvmetcp_init_conn_req_task(struct nvmetcp_task_params *task_= params, > > + struct nvmetcp_init_conn_req_hdr *in= it_conn_req_pdu_hdr, > > + struct storage_sgl_task_params *tx_s= gl_task_params, > > + struct storage_sgl_task_params *rx_s= gl_task_params) > > +{ > > + init_common_login_request_task(task_params, init_conn_req_pdu_hdr= , > > + tx_sgl_task_params, rx_sgl_task_pa= rams); > > +} > > + > > +void init_cleanup_task_nvmetcp(struct nvmetcp_task_params *task_params= ) > > +{ > > + init_sqe(task_params, NULL, NVMETCP_TASK_TYPE_CLEANUP); > > +} > > diff --git a/drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.h b/d= rivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.h > > new file mode 100644 > > index 000000000000..3a8c74356c4c > > --- /dev/null > > +++ b/drivers/net/ethernet/qlogic/qed/qed_nvmetcp_fw_funcs.h > > @@ -0,0 +1,43 @@ > > +/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ > > +/* Copyright 2021 Marvell. All rights reserved. */ > > + > > +#ifndef _QED_NVMETCP_FW_FUNCS_H > > +#define _QED_NVMETCP_FW_FUNCS_H > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#if IS_ENABLED(CONFIG_QED_NVMETCP) > > + > > +void init_nvmetcp_host_read_task(struct nvmetcp_task_params *task_para= ms, > > + struct nvmetcp_conn_params *conn_params, > > + struct nvmetcp_cmd_capsule_hdr *cmd_pdu_= header, > > + struct storage_sgl_task_params *sgl_task= _params); > > + > > +void init_nvmetcp_host_write_task(struct nvmetcp_task_params *task_par= ams, > > + struct nvmetcp_conn_params *conn_params= , > > + struct nvmetcp_cmd_capsule_hdr *cmd_pdu= _header, > > + struct storage_sgl_task_params *sgl_tas= k_params); > > + > > +void init_nvmetcp_init_conn_req_task(struct nvmetcp_task_params *task_= params, > > + struct nvmetcp_init_conn_req_hdr *in= it_conn_req_pdu_hdr, > > + struct storage_sgl_task_params *tx_s= gl_task_params, > > + struct storage_sgl_task_params *rx_s= gl_task_params); > > + > > +void init_cleanup_task_nvmetcp(struct nvmetcp_task_params *task_params= ); > > + > > +#else /* IS_ENABLED(CONFIG_QED_NVMETCP) */ > > + > > +#endif /* IS_ENABLED(CONFIG_QED_NVMETCP) */ > > + > > +#endif /* _QED_NVMETCP_FW_FUNCS_H */ > > diff --git a/include/linux/qed/nvmetcp_common.h b/include/linux/qed/nvm= etcp_common.h > > index dda7a785c321..c0023bb185dd 100644 > > --- a/include/linux/qed/nvmetcp_common.h > > +++ b/include/linux/qed/nvmetcp_common.h > > @@ -9,6 +9,9 @@ > > #define NVMETCP_SLOW_PATH_LAYER_CODE (6) > > #define NVMETCP_WQE_NUM_SGES_SLOWIO (0xf) > > > > +#define QED_NVMETCP_CMD_HDR_SIZE 72 > > +#define QED_NVMETCP_CMN_HDR_SIZE 24 > > + > > /* NVMeTCP firmware function init parameters */ > > struct nvmetcp_spe_func_init { > > __le16 half_way_close_timeout; > > diff --git a/include/linux/qed/qed_nvmetcp_if.h b/include/linux/qed/qed= _nvmetcp_if.h > > index 04e90dc42c12..d971be84f804 100644 > > --- a/include/linux/qed/qed_nvmetcp_if.h > > +++ b/include/linux/qed/qed_nvmetcp_if.h > > @@ -220,6 +220,23 @@ struct qed_nvmetcp_ops { > > void (*remove_dst_tcp_port_filter)(struct qed_dev *cdev, u16 dest= _port); > > > > void (*clear_all_filters)(struct qed_dev *cdev); > > + > > + void (*init_read_io)(struct nvmetcp_task_params *task_params, > > + struct nvmetcp_conn_params *conn_params, > > + struct nvmetcp_cmd_capsule_hdr *cmd_pdu_head= er, > > + struct storage_sgl_task_params *sgl_task_par= ams); > > + > > + void (*init_write_io)(struct nvmetcp_task_params *task_params, > > + struct nvmetcp_conn_params *conn_params, > > + struct nvmetcp_cmd_capsule_hdr *cmd_pdu_hea= der, > > + struct storage_sgl_task_params *sgl_task_pa= rams); > > + > > + void (*init_icreq_exchange)(struct nvmetcp_task_params *task_para= ms, > > + struct nvmetcp_init_conn_req_hdr *ini= t_conn_req_pdu_hdr, > > + struct storage_sgl_task_params *tx_sg= l_task_params, > > + struct storage_sgl_task_params *rx_sg= l_task_params); > > + > > + void (*init_task_cleanup)(struct nvmetcp_task_params *task_params= ); > > }; > > > > const struct qed_nvmetcp_ops *qed_get_nvmetcp_ops(void); > > > Cheers, > > Hannes > -- > Dr. Hannes Reinecke Kernel Storage Architect > hare@suse.de +49 911 74053 688 > SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 N=C3=BCrnberg > HRB 36809 (AG N=C3=BCrnberg), Gesch=C3=A4ftsf=C3=BChrer: Felix Imend=C3= =B6rffer 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 X-Spam-Level: X-Spam-Status: No, score=-10.8 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9D4C9C433ED for ; Tue, 4 May 2021 16:28:57 +0000 (UTC) Received: from desiato.infradead.org (desiato.infradead.org [90.155.92.199]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id D1AEA611AD for ; Tue, 4 May 2021 16:28:56 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D1AEA611AD Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-nvme-bounces+linux-nvme=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=desiato.20200630; h=Sender:Content-Transfer-Encoding :Content-Type:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:Cc:To:Subject:Message-ID:Date:From:In-Reply-To: References:MIME-Version:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=6D618NRDY0UhKZtaX8sVCY4aYBWt8ZloZS2lDdSuWa4=; b=YZAknWSvLHFJmOC8RJbeUEhm7 4gEkbelXW8mm1oaHFFzZ3934SwHCQBzs4B1SIqkM2/Dv8dw0+xs8tE6eEoBHS2tDlQNkqOqUsvTS/ 0HuV/cBVfRR3TkBzMafxmkpYJI3M2ruwqbCichPquGqNGjDVPeAlR4AD1UZMIe8919nEUmhXq8nxs 9QpHOhftUcepQUmIavKEqhaMR1PKCjw3EOws8cxLUngqUYH5Zx+I6sWDMyEtQFUtdPqCpCB2tzMsC 0Q6LG71ouz0QgDDcx2yr7dZsOMVuCmfILnceF1LIz9ZOj8UjNYozpNhh/OZ8iC89W1YcsPTbikSDi MEfiXynGA==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1ldxuk-00GXV5-I3; Tue, 04 May 2021 16:28:50 +0000 Received: from bombadil.infradead.org ([2607:7c80:54:e::133]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1ldxui-00GXTy-Pc for linux-nvme@desiato.infradead.org; Tue, 04 May 2021 16:28:49 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Content-Transfer-Encoding: Content-Type:Cc:To:Subject:Message-ID:Date:From:In-Reply-To:References: MIME-Version:Sender:Reply-To:Content-ID:Content-Description; bh=Z/XXSFGnjR3kTMpJJL6/uEtZkYFyQ/w68fOcgUqaYlI=; b=JpjC4tdS95dLJyD85MBboXfU2u hzqh9gjr6l8dCCCAOBac0FOtaIPOQfcMb3bATGzy/7kM86NJGMli4RhZo/nrcM06tkBA5lPjj+kmH xzum+G+HMNVu7Q/Vyp6/sG2w2iP57rnJCyJs7Qinjw0toXoM7E4KYlbiJgjj53+cNaKk1/d5Em3jB JserbZE5ioFq3jLcp7dIjxnTbnm31lAsIMoAEbWShjPX3w8LolRDRbLfVIfbs4Fvhg40Cxol8uDyj o2K1D+WHKld2wWuEjbBJRxURev0quFFvlP+R2VwMTofwKlUEdE5x4ia830cWyWXtSr6TUfrlNO+U/ BnVQFkQA==; Received: from mail-ej1-x62c.google.com ([2a00:1450:4864:20::62c]) by bombadil.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1ldxue-0046aQ-Ry for linux-nvme@lists.infradead.org; Tue, 04 May 2021 16:28:47 +0000 Received: by mail-ej1-x62c.google.com with SMTP id gx5so14098222ejb.11 for ; Tue, 04 May 2021 09:28:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc:content-transfer-encoding; bh=Z/XXSFGnjR3kTMpJJL6/uEtZkYFyQ/w68fOcgUqaYlI=; b=fSG+EnJ4/Jz4+DPhjR6ISzcENbWM+pbYGKUks+Ht4ZvggWaqPazOFyOeJ7C5d5rGDq 4d67Wzzyh4TdCjODf3CkgRff5Dw8ILTb8Mkull623Yim9x1h5hOTTDaIpIWYZ5xEpC1K HbNnO5ofZre31jvUACfZebE4Z43EGJMQAtQEQV/L9UBYT+uZ6B3vFo3BD1HLe5n2aDUM ohe06UzqqXPETBm4M7GKVjQQNndpzsOSzhuOGgctsgk8b2WSHDOJIdK5jV2WaSh2zMqh 5pmBD03c5KBZ+D2U9BC0bDjP8pGc7alEQ4puJflgtRtebAJMokKvB6WOuRweAKt0c4Vm KbYg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc:content-transfer-encoding; bh=Z/XXSFGnjR3kTMpJJL6/uEtZkYFyQ/w68fOcgUqaYlI=; b=fM0RO4XrHmdhhVnIjv85wTXFYsct7+I3aDAcoov43YdIs9GBnR2mIRcdD8dsKY70DV A7phDkURxaY2rB7DdoEvp4RbMZnlQkkQGCzSbi/uhW7pZT6ocrIty3iHN/+pa9tMLUzJ AKdn5knFGoYOyfJAJK5kmeLGrfhRZY8yogU+2z14wk8jNR1SFxKGr8EJSbvBN8vA+pWf 2nwaBGe9B/R9Nfh4N0U037oI1W9MB7A7cvA3SKV2+oJgvbWwQvCl5RL+HPM30uyn5SUq rAqb5jk9psMS5xMgKxOFPW3djSvksbrU8HRtITJhrbSQWJWVlmKSNr0n0Urjlt8R7pbF 1h5Q== X-Gm-Message-State: AOAM531rZGAF5Qpv3tmP1fK8XZQveuQGN+dmij2ygNodq8Yn4dR8R/Qu fSXZF3TGS7ypzcv5eVORZWxPTNA8XUCnHAd81ZRXGzFT9Dw= X-Google-Smtp-Source: ABdhPJw+Vlo2wIuop4v3nZVy7vgehSUoi7d132w3jP1ADPLQ0eTE4PsDNriD8KCc8jHFcIlCRwp2/LnimF9wrQAQlLs= X-Received: by 2002:a17:906:90b:: with SMTP id i11mr22848207ejd.168.1620145723009; Tue, 04 May 2021 09:28:43 -0700 (PDT) MIME-Version: 1.0 References: <20210429190926.5086-1-smalin@marvell.com> <20210429190926.5086-7-smalin@marvell.com> <88d052a4-4a91-b5e7-5d53-1fb2a1507909@suse.de> In-Reply-To: <88d052a4-4a91-b5e7-5d53-1fb2a1507909@suse.de> From: Shai Malin Date: Tue, 4 May 2021 19:28:30 +0300 Message-ID: Subject: Re: [RFC PATCH v4 06/27] qed: Add NVMeTCP Offload IO Level FW Initializations To: Hannes Reinecke Cc: Shai Malin , netdev@vger.kernel.org, davem@davemloft.net, kuba@kernel.org, linux-nvme@lists.infradead.org, sagi@grimberg.me, hch@lst.de, axboe@fb.com, kbusch@kernel.org, Ariel Elior , Michal Kalderon , okulkarni@marvell.com, pkushwaha@marvell.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210504_092844_963182_C70915E1 X-CRM114-Status: GOOD ( 29.38 ) X-BeenThere: linux-nvme@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-nvme" Errors-To: linux-nvme-bounces+linux-nvme=archiver.kernel.org@lists.infradead.org T24gNS8yLzIxIDI6MjUgUE0sIEhhbm5lcyBSZWluZWNrZSB3cm90ZToKPiBPbiA0LzI5LzIxIDk6 MDkgUE0sIFNoYWkgTWFsaW4gd3JvdGU6Cj4gPiBUaGlzIHBhdGNoIGludHJvZHVjZXMgdGhlIE5W TWVUQ1AgRlcgaW5pdGlhbGl6YXRpb25zIHdoaWNoIGlzIHVzZWQKPiA+IHRvIGluaXRpYWxpemUg dGhlIElPIGxldmVsIGNvbmZpZ3VyYXRpb24gaW50byBhIHBlciBJTyBIVwo+ID4gcmVzb3VyY2Ug KCJ0YXNrIikgYXMgcGFydCBvZiB0aGUgSU8gcGF0aCBmbG93Lgo+ID4KPiA+IFRoaXMgaW5jbHVk ZXM6Cj4gPiAtIFdyaXRlIElPIEZXIGluaXRpYWxpemF0aW9uCj4gPiAtIFJlYWQgSU8gRlcgaW5p dGlhbGl6YXRpb24uCj4gPiAtIElDLVJlcSBhbmQgSUMtUmVzcCBGVyBleGNoYW5nZS4KPiA+IC0g RlcgQ2xlYW51cCBmbG93IChGbHVzaCBJTykuCj4gPgo+ID4gQWNrZWQtYnk6IElnb3IgUnVzc2tp a2ggPGlydXNza2lraEBtYXJ2ZWxsLmNvbT4KPiA+IFNpZ25lZC1vZmYtYnk6IFByYWJoYWthciBL dXNod2FoYSA8cGt1c2h3YWhhQG1hcnZlbGwuY29tPgo+ID4gU2lnbmVkLW9mZi1ieTogT21rYXIg S3Vsa2FybmkgPG9rdWxrYXJuaUBtYXJ2ZWxsLmNvbT4KPiA+IFNpZ25lZC1vZmYtYnk6IFNoYWkg TWFsaW4gPHNtYWxpbkBtYXJ2ZWxsLmNvbT4KPiA+IFNpZ25lZC1vZmYtYnk6IE1pY2hhbCBLYWxk ZXJvbiA8bWthbGRlcm9uQG1hcnZlbGwuY29tPgo+ID4gU2lnbmVkLW9mZi1ieTogQXJpZWwgRWxp b3IgPGFlbGlvckBtYXJ2ZWxsLmNvbT4KPiA+IC0tLQo+ID4gICBkcml2ZXJzL25ldC9ldGhlcm5l dC9xbG9naWMvcWVkL01ha2VmaWxlICAgICAgfCAgIDUgKy0KPiA+ICAgZHJpdmVycy9uZXQvZXRo ZXJuZXQvcWxvZ2ljL3FlZC9xZWRfbnZtZXRjcC5jIHwgICA3ICstCj4gPiAgIC4uLi9xbG9naWMv cWVkL3FlZF9udm1ldGNwX2Z3X2Z1bmNzLmMgICAgICAgICB8IDM3MiArKysrKysrKysrKysrKysr KysKPiA+ICAgLi4uL3Fsb2dpYy9xZWQvcWVkX252bWV0Y3BfZndfZnVuY3MuaCAgICAgICAgIHwg IDQzICsrCj4gPiAgIGluY2x1ZGUvbGludXgvcWVkL252bWV0Y3BfY29tbW9uLmggICAgICAgICAg ICB8ICAgMyArCj4gPiAgIGluY2x1ZGUvbGludXgvcWVkL3FlZF9udm1ldGNwX2lmLmggICAgICAg ICAgICB8ICAxNyArCj4gPiAgIDYgZmlsZXMgY2hhbmdlZCwgNDQ1IGluc2VydGlvbnMoKyksIDIg ZGVsZXRpb25zKC0pCj4gPiAgIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL25ldC9ldGhlcm5l dC9xbG9naWMvcWVkL3FlZF9udm1ldGNwX2Z3X2Z1bmNzLmMKPiA+ICAgY3JlYXRlIG1vZGUgMTAw NjQ0IGRyaXZlcnMvbmV0L2V0aGVybmV0L3Fsb2dpYy9xZWQvcWVkX252bWV0Y3BfZndfZnVuY3Mu aAo+ID4KPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9xbG9naWMvcWVkL01h a2VmaWxlIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvcWxvZ2ljL3FlZC9NYWtlZmlsZQo+ID4gaW5k ZXggN2NiMGRiNjdiYTViLi4wZDljMmZlMDI0NWQgMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL25l dC9ldGhlcm5ldC9xbG9naWMvcWVkL01ha2VmaWxlCj4gPiArKysgYi9kcml2ZXJzL25ldC9ldGhl cm5ldC9xbG9naWMvcWVkL01ha2VmaWxlCj4gPiBAQCAtMjgsNyArMjgsMTAgQEAgcWVkLSQoQ09O RklHX1FFRF9JU0NTSSkgKz0gcWVkX2lzY3NpLm8KPiA+ICAgcWVkLSQoQ09ORklHX1FFRF9MTDIp ICs9IHFlZF9sbDIubwo+ID4gICBxZWQtJChDT05GSUdfUUVEX09PTykgKz0gcWVkX29vby5vCj4g Pgo+ID4gLXFlZC0kKENPTkZJR19RRURfTlZNRVRDUCkgKz0gcWVkX252bWV0Y3Aubwo+ID4gK3Fl ZC0kKENPTkZJR19RRURfTlZNRVRDUCkgKz0gXAo+ID4gKyAgICAgcWVkX252bWV0Y3AubyAgICAg ICAgICAgXAo+ID4gKyAgICAgcWVkX252bWV0Y3BfZndfZnVuY3MubyAgXAo+ID4gKyAgICAgcWVk X252bWV0Y3BfaXBfc2VydmljZXMubwo+ID4KPiA+ICAgcWVkLSQoQ09ORklHX1FFRF9SRE1BKSAr PSAgIFwKPiA+ICAgICAgIHFlZF9pd2FycC5vICAgICAgICAgICAgIFwKPiA+IGRpZmYgLS1naXQg YS9kcml2ZXJzL25ldC9ldGhlcm5ldC9xbG9naWMvcWVkL3FlZF9udm1ldGNwLmMgYi9kcml2ZXJz L25ldC9ldGhlcm5ldC9xbG9naWMvcWVkL3FlZF9udm1ldGNwLmMKPiA+IGluZGV4IDFlMmViNmRj YmQ2ZS4uNDM0MzYzZjhiNWMwIDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9uZXQvZXRoZXJuZXQv cWxvZ2ljL3FlZC9xZWRfbnZtZXRjcC5jCj4gPiArKysgYi9kcml2ZXJzL25ldC9ldGhlcm5ldC9x bG9naWMvcWVkL3FlZF9udm1ldGNwLmMKPiA+IEBAIC0yNyw2ICsyNyw3IEBACj4gPiAgICNpbmNs dWRlICJxZWRfbWNwLmgiCj4gPiAgICNpbmNsdWRlICJxZWRfc3AuaCIKPiA+ICAgI2luY2x1ZGUg InFlZF9yZWdfYWRkci5oIgo+ID4gKyNpbmNsdWRlICJxZWRfbnZtZXRjcF9md19mdW5jcy5oIgo+ ID4KPiA+ICAgc3RhdGljIGludCBxZWRfbnZtZXRjcF9hc3luY19ldmVudChzdHJ1Y3QgcWVkX2h3 Zm4gKnBfaHdmbiwgdTggZndfZXZlbnRfY29kZSwKPiA+ICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHUxNiBlY2hvLCB1bmlvbiBldmVudF9yaW5nX2RhdGEgKmRhdGEsCj4gPiBAQCAt ODQ4LDcgKzg0OSwxMSBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHFlZF9udm1ldGNwX29wcyBxZWRf bnZtZXRjcF9vcHNfcGFzcyA9IHsKPiA+ICAgICAgIC5yZW1vdmVfc3JjX3RjcF9wb3J0X2ZpbHRl ciA9ICZxZWRfbGxoX3JlbW92ZV9zcmNfdGNwX3BvcnRfZmlsdGVyLAo+ID4gICAgICAgLmFkZF9k c3RfdGNwX3BvcnRfZmlsdGVyID0gJnFlZF9sbGhfYWRkX2RzdF90Y3BfcG9ydF9maWx0ZXIsCj4g PiAgICAgICAucmVtb3ZlX2RzdF90Y3BfcG9ydF9maWx0ZXIgPSAmcWVkX2xsaF9yZW1vdmVfZHN0 X3RjcF9wb3J0X2ZpbHRlciwKPiA+IC0gICAgIC5jbGVhcl9hbGxfZmlsdGVycyA9ICZxZWRfbGxo X2NsZWFyX2FsbF9maWx0ZXJzCj4gPiArICAgICAuY2xlYXJfYWxsX2ZpbHRlcnMgPSAmcWVkX2xs aF9jbGVhcl9hbGxfZmlsdGVycywKPiA+ICsgICAgIC5pbml0X3JlYWRfaW8gPSAmaW5pdF9udm1l dGNwX2hvc3RfcmVhZF90YXNrLAo+ID4gKyAgICAgLmluaXRfd3JpdGVfaW8gPSAmaW5pdF9udm1l dGNwX2hvc3Rfd3JpdGVfdGFzaywKPiA+ICsgICAgIC5pbml0X2ljcmVxX2V4Y2hhbmdlID0gJmlu aXRfbnZtZXRjcF9pbml0X2Nvbm5fcmVxX3Rhc2ssCj4gPiArICAgICAuaW5pdF90YXNrX2NsZWFu dXAgPSAmaW5pdF9jbGVhbnVwX3Rhc2tfbnZtZXRjcAo+ID4gICB9Owo+ID4KPiA+ICAgY29uc3Qg c3RydWN0IHFlZF9udm1ldGNwX29wcyAqcWVkX2dldF9udm1ldGNwX29wcyh2b2lkKQo+ID4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3Fsb2dpYy9xZWQvcWVkX252bWV0Y3BfZndf ZnVuY3MuYyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3Fsb2dpYy9xZWQvcWVkX252bWV0Y3BfZndf ZnVuY3MuYwo+ID4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAwMDAwMDAwMC4u ODQ4NWFkNjc4Mjg0Cj4gPiAtLS0gL2Rldi9udWxsCj4gPiArKysgYi9kcml2ZXJzL25ldC9ldGhl cm5ldC9xbG9naWMvcWVkL3FlZF9udm1ldGNwX2Z3X2Z1bmNzLmMKPiA+IEBAIC0wLDAgKzEsMzcy IEBACj4gPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IChHUEwtMi4wLW9ubHkgT1IgQlNE LTMtQ2xhdXNlKQo+ID4gKy8qIENvcHlyaWdodCAyMDIxIE1hcnZlbGwuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuICovCj4gPiArCj4gPiArI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgo+ID4gKyNpbmNs dWRlIDxsaW51eC9tb2R1bGUuaD4KPiA+ICsjaW5jbHVkZSA8bGludXgvcGNpLmg+Cj4gPiArI2lu Y2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC9saXN0Lmg+Cj4gPiAr I2luY2x1ZGUgPGxpbnV4L21tLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+Cj4gPiAr I2luY2x1ZGUgPGFzbS9ieXRlb3JkZXIuaD4KPiA+ICsjaW5jbHVkZSA8bGludXgvcWVkL2NvbW1v bl9oc2kuaD4KPiA+ICsjaW5jbHVkZSA8bGludXgvcWVkL3N0b3JhZ2VfY29tbW9uLmg+Cj4gPiAr I2luY2x1ZGUgPGxpbnV4L3FlZC9udm1ldGNwX2NvbW1vbi5oPgo+ID4gKyNpbmNsdWRlIDxsaW51 eC9xZWQvcWVkX252bWV0Y3BfaWYuaD4KPiA+ICsjaW5jbHVkZSAicWVkX252bWV0Y3BfZndfZnVu Y3MuaCIKPiA+ICsKPiA+ICsjZGVmaW5lIE5WTUVUQ1BfTlVNX1NHRVNfSU5fQ0FDSEUgMHg0Cj4g PiArCj4gPiArYm9vbCBudm1ldGNwX2lzX3Nsb3dfc2dsKHUxNiBudW1fc2dlcywgYm9vbCBzbWFs bF9taWRfc2dlKQo+ID4gK3sKPiA+ICsgICAgIHJldHVybiAobnVtX3NnZXMgPiBTQ1NJX05VTV9T R0VTX1NMT1dfU0dMX1RIUiAmJiBzbWFsbF9taWRfc2dlKTsKPiA+ICt9Cj4gPiArCj4gPiArdm9p ZCBpbml0X3Njc2lfc2dsX2NvbnRleHQoc3RydWN0IHNjc2lfc2dsX3BhcmFtcyAqY3R4X3NnbF9w YXJhbXMsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHNjc2lfY2FjaGVkX3Nn ZXMgKmN0eF9kYXRhX2Rlc2MsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHN0 b3JhZ2Vfc2dsX3Rhc2tfcGFyYW1zICpzZ2xfcGFyYW1zKQo+ID4gK3sKPiA+ICsgICAgIHU4IG51 bV9zZ2VzX3RvX2luaXQgPSAodTgpKHNnbF9wYXJhbXMtPm51bV9zZ2VzID4gTlZNRVRDUF9OVU1f U0dFU19JTl9DQUNIRSA/Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVk1F VENQX05VTV9TR0VTX0lOX0NBQ0hFIDogc2dsX3BhcmFtcy0+bnVtX3NnZXMpOwo+ID4gKyAgICAg dTggc2dlX2luZGV4Owo+ID4gKwo+ID4gKyAgICAgLyogc2dsIHBhcmFtcyAqLwo+ID4gKyAgICAg Y3R4X3NnbF9wYXJhbXMtPnNnbF9hZGRyLmxvID0gY3B1X3RvX2xlMzIoc2dsX3BhcmFtcy0+c2ds X3BoeXNfYWRkci5sbyk7Cj4gPiArICAgICBjdHhfc2dsX3BhcmFtcy0+c2dsX2FkZHIuaGkgPSBj cHVfdG9fbGUzMihzZ2xfcGFyYW1zLT5zZ2xfcGh5c19hZGRyLmhpKTsKPiA+ICsgICAgIGN0eF9z Z2xfcGFyYW1zLT5zZ2xfdG90YWxfbGVuZ3RoID0gY3B1X3RvX2xlMzIoc2dsX3BhcmFtcy0+dG90 YWxfYnVmZmVyX3NpemUpOwo+ID4gKyAgICAgY3R4X3NnbF9wYXJhbXMtPnNnbF9udW1fc2dlcyA9 IGNwdV90b19sZTE2KHNnbF9wYXJhbXMtPm51bV9zZ2VzKTsKPiA+ICsKPiA+ICsgICAgIGZvciAo c2dlX2luZGV4ID0gMDsgc2dlX2luZGV4IDwgbnVtX3NnZXNfdG9faW5pdDsgc2dlX2luZGV4Kysp IHsKPiA+ICsgICAgICAgICAgICAgY3R4X2RhdGFfZGVzYy0+c2dlW3NnZV9pbmRleF0uc2dlX2Fk ZHIubG8gPQo+ID4gKyAgICAgICAgICAgICAgICAgICAgIGNwdV90b19sZTMyKHNnbF9wYXJhbXMt PnNnbFtzZ2VfaW5kZXhdLnNnZV9hZGRyLmxvKTsKPiA+ICsgICAgICAgICAgICAgY3R4X2RhdGFf ZGVzYy0+c2dlW3NnZV9pbmRleF0uc2dlX2FkZHIuaGkgPQo+ID4gKyAgICAgICAgICAgICAgICAg ICAgIGNwdV90b19sZTMyKHNnbF9wYXJhbXMtPnNnbFtzZ2VfaW5kZXhdLnNnZV9hZGRyLmhpKTsK PiA+ICsgICAgICAgICAgICAgY3R4X2RhdGFfZGVzYy0+c2dlW3NnZV9pbmRleF0uc2dlX2xlbiA9 Cj4gPiArICAgICAgICAgICAgICAgICAgICAgY3B1X3RvX2xlMzIoc2dsX3BhcmFtcy0+c2dsW3Nn ZV9pbmRleF0uc2dlX2xlbik7Cj4gPiArICAgICB9Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyBp bmxpbmUgdTMyIGNhbGNfcndfdGFza19zaXplKHN0cnVjdCBudm1ldGNwX3Rhc2tfcGFyYW1zICp0 YXNrX3BhcmFtcywKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnVtIG52 bWV0Y3BfdGFza190eXBlIHRhc2tfdHlwZSkKPiA+ICt7Cj4gPiArICAgICB1MzIgaW9fc2l6ZTsK PiA+ICsKPiA+ICsgICAgIGlmICh0YXNrX3R5cGUgPT0gTlZNRVRDUF9UQVNLX1RZUEVfSE9TVF9X UklURSkKPiA+ICsgICAgICAgICAgICAgaW9fc2l6ZSA9IHRhc2tfcGFyYW1zLT50eF9pb19zaXpl Owo+ID4gKyAgICAgZWxzZQo+ID4gKyAgICAgICAgICAgICBpb19zaXplID0gdGFza19wYXJhbXMt PnJ4X2lvX3NpemU7Cj4gPiArCj4gPiArICAgICBpZiAodW5saWtlbHkoIWlvX3NpemUpKQo+ID4g KyAgICAgICAgICAgICByZXR1cm4gMDsKPiA+ICsKPiA+ICsgICAgIHJldHVybiBpb19zaXplOwo+ ID4gK30KPiA+ICsKPiA+ICtzdGF0aWMgaW5saW5lIHZvaWQgaW5pdF9zcWUoc3RydWN0IG52bWV0 Y3BfdGFza19wYXJhbXMgKnRhc2tfcGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAg ICBzdHJ1Y3Qgc3RvcmFnZV9zZ2xfdGFza19wYXJhbXMgKnNnbF90YXNrX3BhcmFtcywKPiA+ICsg ICAgICAgICAgICAgICAgICAgICAgICAgZW51bSBudm1ldGNwX3Rhc2tfdHlwZSB0YXNrX3R5cGUp Cj4gPiArewo+ID4gKyAgICAgaWYgKCF0YXNrX3BhcmFtcy0+c3FlKQo+ID4gKyAgICAgICAgICAg ICByZXR1cm47Cj4gPiArCj4gPiArICAgICBtZW1zZXQodGFza19wYXJhbXMtPnNxZSwgMCwgc2l6 ZW9mKCp0YXNrX3BhcmFtcy0+c3FlKSk7Cj4gPiArICAgICB0YXNrX3BhcmFtcy0+c3FlLT50YXNr X2lkID0gY3B1X3RvX2xlMTYodGFza19wYXJhbXMtPml0aWQpOwo+ID4gKwo+ID4gKyAgICAgc3dp dGNoICh0YXNrX3R5cGUpIHsKPiA+ICsgICAgIGNhc2UgTlZNRVRDUF9UQVNLX1RZUEVfSE9TVF9X UklURTogewo+ID4gKyAgICAgICAgICAgICB1MzIgYnVmX3NpemUgPSAwOwo+ID4gKyAgICAgICAg ICAgICB1MzIgbnVtX3NnZXMgPSAwOwo+ID4gKwo+ID4gKyAgICAgICAgICAgICBTRVRfRklFTEQo dGFza19wYXJhbXMtPnNxZS0+Y29udGxlbl9jZGJzaXplLAo+ID4gKyAgICAgICAgICAgICAgICAg ICAgICAgTlZNRVRDUF9XUUVfQ0RCX1NJWkVfT1JfTlZNRVRDUF9DTUQsIDEpOwo+ID4gKyAgICAg ICAgICAgICBTRVRfRklFTEQodGFza19wYXJhbXMtPnNxZS0+ZmxhZ3MsIE5WTUVUQ1BfV1FFX1dR RV9UWVBFLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgTlZNRVRDUF9XUUVfVFlQRV9OT1JN QUwpOwo+ID4gKyAgICAgICAgICAgICBpZiAodGFza19wYXJhbXMtPnR4X2lvX3NpemUpIHsKPiA+ ICsgICAgICAgICAgICAgICAgICAgICBpZiAodGFza19wYXJhbXMtPnNlbmRfd3JpdGVfaW5jYXBz dWxlKQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnVmX3NpemUgPSBjYWxjX3J3 X3Rhc2tfc2l6ZSh0YXNrX3BhcmFtcywgdGFza190eXBlKTsKPiA+ICsKPiA+ICsgICAgICAgICAg ICAgICAgICAgICBpZiAobnZtZXRjcF9pc19zbG93X3NnbChzZ2xfdGFza19wYXJhbXMtPm51bV9z Z2VzLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNn bF90YXNrX3BhcmFtcy0+c21hbGxfbWlkX3NnZSkpCj4gPiArICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBudW1fc2dlcyA9IE5WTUVUQ1BfV1FFX05VTV9TR0VTX1NMT1dJTzsKPiA+ICsgICAg ICAgICAgICAgICAgICAgICBlbHNlCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICBu dW1fc2dlcyA9IG1pbigodTE2KXNnbF90YXNrX3BhcmFtcy0+bnVtX3NnZXMsCj4gPiArICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAodTE2KVNDU0lfTlVNX1NHRVNf U0xPV19TR0xfVEhSKTsKPiA+ICsgICAgICAgICAgICAgfQo+ID4gKyAgICAgICAgICAgICBTRVRf RklFTEQodGFza19wYXJhbXMtPnNxZS0+ZmxhZ3MsIE5WTUVUQ1BfV1FFX05VTV9TR0VTLCBudW1f c2dlcyk7Cj4gPiArICAgICAgICAgICAgIFNFVF9GSUVMRCh0YXNrX3BhcmFtcy0+c3FlLT5jb250 bGVuX2NkYnNpemUsIE5WTUVUQ1BfV1FFX0NPTlRfTEVOLCBidWZfc2l6ZSk7Cj4gPiArICAgICB9 IGJyZWFrOwo+ID4gKwo+ID4gKyAgICAgY2FzZSBOVk1FVENQX1RBU0tfVFlQRV9IT1NUX1JFQUQ6 IHsKPiA+ICsgICAgICAgICAgICAgU0VUX0ZJRUxEKHRhc2tfcGFyYW1zLT5zcWUtPmZsYWdzLCBO Vk1FVENQX1dRRV9XUUVfVFlQRSwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgIE5WTUVUQ1Bf V1FFX1RZUEVfTk9STUFMKTsKPiA+ICsgICAgICAgICAgICAgU0VUX0ZJRUxEKHRhc2tfcGFyYW1z LT5zcWUtPmNvbnRsZW5fY2Ric2l6ZSwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgIE5WTUVU Q1BfV1FFX0NEQl9TSVpFX09SX05WTUVUQ1BfQ01ELCAxKTsKPiA+ICsgICAgIH0gYnJlYWs7Cj4g PiArCj4gPiArICAgICBjYXNlIE5WTUVUQ1BfVEFTS19UWVBFX0lOSVRfQ09OTl9SRVFVRVNUOiB7 Cj4gPiArICAgICAgICAgICAgIFNFVF9GSUVMRCh0YXNrX3BhcmFtcy0+c3FlLT5mbGFncywgTlZN RVRDUF9XUUVfV1FFX1RZUEUsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICBOVk1FVENQX1dR RV9UWVBFX01JRERMRV9QQVRIKTsKPiA+ICsKPiA+ICsgICAgICAgICAgICAgaWYgKHRhc2tfcGFy YW1zLT50eF9pb19zaXplKSB7Cj4gPiArICAgICAgICAgICAgICAgICAgICAgU0VUX0ZJRUxEKHRh c2tfcGFyYW1zLT5zcWUtPmNvbnRsZW5fY2Ric2l6ZSwgTlZNRVRDUF9XUUVfQ09OVF9MRU4sCj4g PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRhc2tfcGFyYW1zLT50eF9pb19zaXpl KTsKPiA+ICsgICAgICAgICAgICAgICAgICAgICBTRVRfRklFTEQodGFza19wYXJhbXMtPnNxZS0+ ZmxhZ3MsIE5WTUVUQ1BfV1FFX05VTV9TR0VTLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBtaW4oKHUxNilzZ2xfdGFza19wYXJhbXMtPm51bV9zZ2VzLAo+ID4gKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgKHUxNilTQ1NJX05VTV9TR0VTX1NMT1dfU0dMX1RI UikpOwo+ID4gKyAgICAgICAgICAgICB9Cj4gPiArICAgICB9IGJyZWFrOwo+ID4gKwo+ID4gKyAg ICAgY2FzZSBOVk1FVENQX1RBU0tfVFlQRV9DTEVBTlVQOgo+ID4gKyAgICAgICAgICAgICBTRVRf RklFTEQodGFza19wYXJhbXMtPnNxZS0+ZmxhZ3MsIE5WTUVUQ1BfV1FFX1dRRV9UWVBFLAo+ID4g KyAgICAgICAgICAgICAgICAgICAgICAgTlZNRVRDUF9XUUVfVFlQRV9UQVNLX0NMRUFOVVApOwo+ ID4gKwo+ID4gKyAgICAgZGVmYXVsdDoKPiA+ICsgICAgICAgICAgICAgYnJlYWs7Cj4gPiArICAg ICB9Cj4gPiArfQo+ID4gKwo+ID4gKy8qIFRoZSBmb2xsb3dpbmcgZnVuY3Rpb24gaW5pdGlhbGl6 ZXMgb2YgTlZNZVRDUCB0YXNrIHBhcmFtcyAqLwo+ID4gK3N0YXRpYyBpbmxpbmUgdm9pZAo+ID4g K2luaXRfbnZtZXRjcF90YXNrX3BhcmFtcyhzdHJ1Y3QgZTVfbnZtZXRjcF90YXNrX2NvbnRleHQg KmNvbnRleHQsCj4gPiArICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBudm1ldGNwX3Rhc2tf cGFyYW1zICp0YXNrX3BhcmFtcywKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgZW51bSBudm1l dGNwX3Rhc2tfdHlwZSB0YXNrX3R5cGUpCj4gPiArewo+ID4gKyAgICAgY29udGV4dC0+eXN0b3Jt X3N0X2NvbnRleHQuc3RhdGUuY2NjaWQgPSB0YXNrX3BhcmFtcy0+aG9zdF9jY2NpZDsKPiA+ICsg ICAgIFNFVF9GSUVMRChjb250ZXh0LT51c3Rvcm1fc3RfY29udGV4dC5lcnJvcl9mbGFncywgVVNU T1JNX05WTUVUQ1BfVEFTS19TVF9DVFhfTlZNRV9UQ1AsIDEpOwo+ID4gKyAgICAgY29udGV4dC0+ dXN0b3JtX3N0X2NvbnRleHQubnZtZV90Y3Bfb3BhcXVlX2xvID0gY3B1X3RvX2xlMzIodGFza19w YXJhbXMtPm9wcS5sbyk7Cj4gPiArICAgICBjb250ZXh0LT51c3Rvcm1fc3RfY29udGV4dC5udm1l X3RjcF9vcGFxdWVfaGkgPSBjcHVfdG9fbGUzMih0YXNrX3BhcmFtcy0+b3BxLmhpKTsKPiA+ICt9 Cj4gPiArCj4gPiArLyogVGhlIGZvbGxvd2luZyBmdW5jdGlvbiBpbml0aWFsaXplcyBkZWZhdWx0 IHZhbHVlcyB0byBhbGwgdGFza3MgKi8KPiA+ICtzdGF0aWMgaW5saW5lIHZvaWQKPiA+ICtpbml0 X2RlZmF1bHRfbnZtZXRjcF90YXNrKHN0cnVjdCBudm1ldGNwX3Rhc2tfcGFyYW1zICp0YXNrX3Bh cmFtcywgdm9pZCAqcGR1X2hlYWRlciwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgIGVudW0g bnZtZXRjcF90YXNrX3R5cGUgdGFza190eXBlKQo+ID4gK3sKPiA+ICsgICAgIHN0cnVjdCBlNV9u dm1ldGNwX3Rhc2tfY29udGV4dCAqY29udGV4dCA9IHRhc2tfcGFyYW1zLT5jb250ZXh0Owo+ID4g KyAgICAgY29uc3QgdTggdmFsX2J5dGUgPSBjb250ZXh0LT5tc3Rvcm1fYWdfY29udGV4dC5jZHVf dmFsaWRhdGlvbjsKPiA+ICsgICAgIHU4IGR3X2luZGV4Owo+ID4gKwo+ID4gKyAgICAgbWVtc2V0 KGNvbnRleHQsIDAsIHNpemVvZigqY29udGV4dCkpOwo+ID4gKwo+ID4gKyAgICAgaW5pdF9udm1l dGNwX3Rhc2tfcGFyYW1zKGNvbnRleHQsIHRhc2tfcGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIChlbnVtIG52bWV0Y3BfdGFza190eXBlKXRhc2tfdHlwZSk7Cj4gPiAr Cj4gPiArICAgICBpZiAodGFza190eXBlID09IE5WTUVUQ1BfVEFTS19UWVBFX0hPU1RfV1JJVEUg fHwKPiA+ICsgICAgICAgICB0YXNrX3R5cGUgPT0gTlZNRVRDUF9UQVNLX1RZUEVfSE9TVF9SRUFE KSB7Cj4gPiArICAgICAgICAgICAgIGZvciAoZHdfaW5kZXggPSAwOyBkd19pbmRleCA8IFFFRF9O Vk1FVENQX0NNRF9IRFJfU0laRSAvIDQ7IGR3X2luZGV4KyspCj4gPiArICAgICAgICAgICAgICAg ICAgICAgY29udGV4dC0+eXN0b3JtX3N0X2NvbnRleHQucGR1X2hkci50YXNrX2hkci5yZWdbZHdf aW5kZXhdID0KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNwdV90b19sZTMyKCgo dTMyICopcGR1X2hlYWRlcilbZHdfaW5kZXhdKTsKPiA+ICsgICAgIH0gZWxzZSB7Cj4gPiArICAg ICAgICAgICAgIGZvciAoZHdfaW5kZXggPSAwOyBkd19pbmRleCA8IFFFRF9OVk1FVENQX0NNTl9I RFJfU0laRSAvIDQ7IGR3X2luZGV4KyspCj4gPiArICAgICAgICAgICAgICAgICAgICAgY29udGV4 dC0+eXN0b3JtX3N0X2NvbnRleHQucGR1X2hkci50YXNrX2hkci5yZWdbZHdfaW5kZXhdID0KPiA+ ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNwdV90b19sZTMyKCgodTMyICopcGR1X2hl YWRlcilbZHdfaW5kZXhdKTsKPiA+ICsgICAgIH0KPiA+ICsKPgo+IEFuZCB0aGlzIGlzIHdoYXQg SSBtZWFudC4gWW91IGFyZSB0d2lkZGxpbmcgd2l0aCB0aGUgYnl0ZXMgYWxyZWFkeSwgc28KPiB3 aHkgYm90aGVyIHdpdGggYSBzZXBhcmF0ZSBzdHJ1Y3QgYXQgYWxsPwoKV2UgYWdyZWUsIHdpbGwg YmUgZml4ZWQgaW4gVjUuCgo+Cj4gPiArICAgICAvKiBNLVN0b3JtIENvbnRleHQ6ICovCj4gPiAr ICAgICBjb250ZXh0LT5tc3Rvcm1fYWdfY29udGV4dC5jZHVfdmFsaWRhdGlvbiA9IHZhbF9ieXRl Owo+ID4gKyAgICAgY29udGV4dC0+bXN0b3JtX3N0X2NvbnRleHQudGFza190eXBlID0gKHU4KSh0 YXNrX3R5cGUpOwo+ID4gKyAgICAgY29udGV4dC0+bXN0b3JtX2FnX2NvbnRleHQudGFza19jaWQg PSBjcHVfdG9fbGUxNih0YXNrX3BhcmFtcy0+Y29ubl9pY2lkKTsKPiA+ICsKPiA+ICsgICAgIC8q IFVzdG9ybSBDb250ZXh0OiAqLwo+ID4gKyAgICAgU0VUX0ZJRUxEKGNvbnRleHQtPnVzdG9ybV9h Z19jb250ZXh0LmZsYWdzMSwgRTVfVVNUT1JNX05WTUVUQ1BfVEFTS19BR19DVFhfUjJUMlJFQ1Ys IDEpOwo+ID4gKyAgICAgY29udGV4dC0+dXN0b3JtX3N0X2NvbnRleHQudGFza190eXBlID0gKHU4 KSh0YXNrX3R5cGUpOwo+ID4gKyAgICAgY29udGV4dC0+dXN0b3JtX3N0X2NvbnRleHQuY3FfcnNz X251bWJlciA9IHRhc2tfcGFyYW1zLT5jcV9yc3NfbnVtYmVyOwo+ID4gKyAgICAgY29udGV4dC0+ dXN0b3JtX2FnX2NvbnRleHQuaWNpZCA9IGNwdV90b19sZTE2KHRhc2tfcGFyYW1zLT5jb25uX2lj aWQpOwo+ID4gK30KPiA+ICsKPiA+ICsvKiBUaGUgZm9sbG93aW5nIGZ1bmN0aW9uIGluaXRpYWxp emVzIHRoZSBVLVN0b3JtIFRhc2sgQ29udGV4dHMgKi8KPiA+ICtzdGF0aWMgaW5saW5lIHZvaWQK PiA+ICtpbml0X3VzdG9ybV90YXNrX2NvbnRleHRzKHN0cnVjdCB1c3Rvcm1fbnZtZXRjcF90YXNr X3N0X2N0eCAqdXN0b3JtX3N0X2NvbnRleHQsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICBz dHJ1Y3QgZTVfdXN0b3JtX252bWV0Y3BfdGFza19hZ19jdHggKnVzdG9ybV9hZ19jb250ZXh0LAo+ ID4gKyAgICAgICAgICAgICAgICAgICAgICAgdTMyIHJlbWFpbmluZ19yZWN2X2xlbiwKPiA+ICsg ICAgICAgICAgICAgICAgICAgICAgIHUzMiBleHBlY3RlZF9kYXRhX3RyYW5zZmVyX2xlbiwgdTgg bnVtX3NnZXMsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICBib29sIHR4X2RpZl9jb25uX2Vy cl9lbikKPiA+ICt7Cj4gPiArICAgICAvKiBSZW1haW5pbmcgZGF0YSB0byBiZSByZWNlaXZlZCBp biBieXRlcy4gVXNlZCBpbiB2YWxpZGF0aW9ucyovCj4gPiArICAgICB1c3Rvcm1fc3RfY29udGV4 dC0+cmVtX3Jjdl9sZW4gPSBjcHVfdG9fbGUzMihyZW1haW5pbmdfcmVjdl9sZW4pOwo+ID4gKyAg ICAgdXN0b3JtX2FnX2NvbnRleHQtPmV4cF9kYXRhX2Fja2VkID0gY3B1X3RvX2xlMzIoZXhwZWN0 ZWRfZGF0YV90cmFuc2Zlcl9sZW4pOwo+ID4gKyAgICAgdXN0b3JtX3N0X2NvbnRleHQtPmV4cF9k YXRhX3RyYW5zZmVyX2xlbiA9IGNwdV90b19sZTMyKGV4cGVjdGVkX2RhdGFfdHJhbnNmZXJfbGVu KTsKPiA+ICsgICAgIFNFVF9GSUVMRCh1c3Rvcm1fc3RfY29udGV4dC0+cmVnMS5yZWcxX21hcCwg TlZNRVRDUF9SRUcxX05VTV9TR0VTLCBudW1fc2dlcyk7Cj4gPiArICAgICBTRVRfRklFTEQodXN0 b3JtX2FnX2NvbnRleHQtPmZsYWdzMiwgRTVfVVNUT1JNX05WTUVUQ1BfVEFTS19BR19DVFhfRElG X0VSUk9SX0NGX0VOLAo+ID4gKyAgICAgICAgICAgICAgIHR4X2RpZl9jb25uX2Vycl9lbiA/IDEg OiAwKTsKPiA+ICt9Cj4gPiArCj4gPiArLyogVGhlIGZvbGxvd2luZyBmdW5jdGlvbiBpbml0aWFs aXplcyBMb2NhbCBDb21wbGV0aW9uIENvbnRleHRzOiAqLwo+ID4gK3N0YXRpYyBpbmxpbmUgdm9p ZAo+ID4gK3NldF9sb2NhbF9jb21wbGV0aW9uX2NvbnRleHQoc3RydWN0IGU1X252bWV0Y3BfdGFz a19jb250ZXh0ICpjb250ZXh0KQo+ID4gK3sKPiA+ICsgICAgIFNFVF9GSUVMRChjb250ZXh0LT55 c3Rvcm1fc3RfY29udGV4dC5zdGF0ZS5mbGFncywKPiA+ICsgICAgICAgICAgICAgICBZU1RPUk1f TlZNRVRDUF9UQVNLX1NUQVRFX0xPQ0FMX0NPTVAsIDEpOwo+ID4gKyAgICAgU0VUX0ZJRUxEKGNv bnRleHQtPnVzdG9ybV9zdF9jb250ZXh0LmZsYWdzLAo+ID4gKyAgICAgICAgICAgICAgIFVTVE9S TV9OVk1FVENQX1RBU0tfU1RfQ1RYX0xPQ0FMX0NPTVAsIDEpOwo+ID4gK30KPiA+ICsKPiA+ICsv KiBDb21tb24gRmFzdHBhdGggdGFzayBpbml0IGZ1bmN0aW9uOiAqLwo+ID4gK3N0YXRpYyBpbmxp bmUgdm9pZAo+ID4gK2luaXRfcndfbnZtZXRjcF90YXNrKHN0cnVjdCBudm1ldGNwX3Rhc2tfcGFy YW1zICp0YXNrX3BhcmFtcywKPiA+ICsgICAgICAgICAgICAgICAgICBlbnVtIG52bWV0Y3BfdGFz a190eXBlIHRhc2tfdHlwZSwKPiA+ICsgICAgICAgICAgICAgICAgICBzdHJ1Y3QgbnZtZXRjcF9j b25uX3BhcmFtcyAqY29ubl9wYXJhbXMsIHZvaWQgKnBkdV9oZWFkZXIsCj4gPiArICAgICAgICAg ICAgICAgICAgc3RydWN0IHN0b3JhZ2Vfc2dsX3Rhc2tfcGFyYW1zICpzZ2xfdGFza19wYXJhbXMp Cj4gPiArewo+ID4gKyAgICAgc3RydWN0IGU1X252bWV0Y3BfdGFza19jb250ZXh0ICpjb250ZXh0 ID0gdGFza19wYXJhbXMtPmNvbnRleHQ7Cj4gPiArICAgICB1MzIgdGFza19zaXplID0gY2FsY19y d190YXNrX3NpemUodGFza19wYXJhbXMsIHRhc2tfdHlwZSk7Cj4gPiArICAgICB1MzIgZXhwX2Rh dGFfdHJhbnNmZXJfbGVuID0gY29ubl9wYXJhbXMtPm1heF9idXJzdF9sZW5ndGg7Cj4gPiArICAg ICBib29sIHNsb3dfaW8gPSBmYWxzZTsKPiA+ICsgICAgIHU4IG51bV9zZ2VzID0gMDsKPiA+ICsK PiA+ICsgICAgIGluaXRfZGVmYXVsdF9udm1ldGNwX3Rhc2sodGFza19wYXJhbXMsIHBkdV9oZWFk ZXIsIHRhc2tfdHlwZSk7Cj4gPiArCj4gPiArICAgICAvKiBUeC9SeDogKi8KPiA+ICsgICAgIGlm ICh0YXNrX3BhcmFtcy0+dHhfaW9fc2l6ZSkgewo+ID4gKyAgICAgICAgICAgICAvKiBpZiBkYXRh IHRvIHRyYW5zbWl0OiAqLwo+ID4gKyAgICAgICAgICAgICBpbml0X3Njc2lfc2dsX2NvbnRleHQo JmNvbnRleHQtPnlzdG9ybV9zdF9jb250ZXh0LnN0YXRlLnNnbF9wYXJhbXMsCj4gPiArICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmY29udGV4dC0+eXN0b3JtX3N0X2NvbnRleHQu c3RhdGUuZGF0YV9kZXNjLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg c2dsX3Rhc2tfcGFyYW1zKTsKPiA+ICsgICAgICAgICAgICAgc2xvd19pbyA9IG52bWV0Y3BfaXNf c2xvd19zZ2woc2dsX3Rhc2tfcGFyYW1zLT5udW1fc2dlcywKPiA+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgc2dsX3Rhc2tfcGFyYW1zLT5zbWFsbF9taWRfc2dl KTsKPiA+ICsgICAgICAgICAgICAgbnVtX3NnZXMgPQo+ID4gKyAgICAgICAgICAgICAgICAgICAg ICh1OCkoIXNsb3dfaW8gPyBtaW4oKHUzMilzZ2xfdGFza19wYXJhbXMtPm51bV9zZ2VzLAo+ID4g KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKHUzMilTQ1NJX05VTV9T R0VTX1NMT1dfU0dMX1RIUikgOgo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgTlZNRVRDUF9XUUVfTlVNX1NHRVNfU0xPV0lPKTsKPiA+ICsgICAgICAgICAgICAg aWYgKHNsb3dfaW8pIHsKPiA+ICsgICAgICAgICAgICAgICAgICAgICBTRVRfRklFTEQoY29udGV4 dC0+eXN0b3JtX3N0X2NvbnRleHQuc3RhdGUuZmxhZ3MsCj4gPiArICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIFlTVE9STV9OVk1FVENQX1RBU0tfU1RBVEVfU0xPV19JTywgMSk7Cj4gPiAr ICAgICAgICAgICAgIH0KPiA+ICsgICAgIH0gZWxzZSBpZiAodGFza19wYXJhbXMtPnJ4X2lvX3Np emUpIHsKPiA+ICsgICAgICAgICAgICAgLyogaWYgZGF0YSB0byByZWNlaXZlOiAqLwo+ID4gKyAg ICAgICAgICAgICBpbml0X3Njc2lfc2dsX2NvbnRleHQoJmNvbnRleHQtPm1zdG9ybV9zdF9jb250 ZXh0LnNnbF9wYXJhbXMsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAm Y29udGV4dC0+bXN0b3JtX3N0X2NvbnRleHQuZGF0YV9kZXNjLAo+ID4gKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgc2dsX3Rhc2tfcGFyYW1zKTsKPiA+ICsgICAgICAgICAgICAg bnVtX3NnZXMgPQo+ID4gKyAgICAgICAgICAgICAgICAgICAgICh1OCkoIW52bWV0Y3BfaXNfc2xv d19zZ2woc2dsX3Rhc2tfcGFyYW1zLT5udW1fc2dlcywKPiA+ICsgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNnbF90YXNrX3BhcmFtcy0+c21hbGxfbWlkX3Nn ZSkgPwo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg bWluKCh1MzIpc2dsX3Rhc2tfcGFyYW1zLT5udW1fc2dlcywKPiA+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAodTMyKVNDU0lfTlVNX1NHRVNfU0xP V19TR0xfVEhSKSA6Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgTlZNRVRDUF9XUUVfTlVNX1NHRVNfU0xPV0lPKTsKPiA+ICsgICAgICAgICAg ICAgY29udGV4dC0+bXN0b3JtX3N0X2NvbnRleHQucmVtX3Rhc2tfc2l6ZSA9IGNwdV90b19sZTMy KHRhc2tfc2l6ZSk7Cj4gPiArICAgICB9Cj4gPiArCj4gPiArICAgICAvKiBVc3Rvcm0gY29udGV4 dDogKi8KPiA+ICsgICAgIGlmIChleHBfZGF0YV90cmFuc2Zlcl9sZW4gPiB0YXNrX3NpemUpCj4g PiArICAgICAgICAgICAgIC8qIFRoZSBzaXplIG9mIHRoZSB0cmFuc21pdHRlZCB0YXNrKi8KPiA+ ICsgICAgICAgICAgICAgZXhwX2RhdGFfdHJhbnNmZXJfbGVuID0gdGFza19zaXplOwo+ID4gKyAg ICAgaW5pdF91c3Rvcm1fdGFza19jb250ZXh0cygmY29udGV4dC0+dXN0b3JtX3N0X2NvbnRleHQs Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZjb250ZXh0LT51c3Rvcm1fYWdf Y29udGV4dCwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogUmVtYWluaW5n IFJlY2VpdmUgbGVuZ3RoIGlzIHRoZSBUYXNrIFNpemUgKi8KPiA+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgdGFza19zaXplLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAvKiBUaGUgc2l6ZSBvZiB0aGUgdHJhbnNtaXR0ZWQgdGFzayAqLwo+ID4gKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBleHBfZGF0YV90cmFuc2Zlcl9sZW4sCj4gPiArICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIC8qIG51bV9zZ2VzICovCj4gPiArICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIG51bV9zZ2VzLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBmYWxzZSk7Cj4gPiArCj4gPiArICAgICAvKiBTZXQgZXhwX2RhdGFfYWNrZWQgKi8K PiA+ICsgICAgIGlmICh0YXNrX3R5cGUgPT0gTlZNRVRDUF9UQVNLX1RZUEVfSE9TVF9XUklURSkg ewo+ID4gKyAgICAgICAgICAgICBpZiAodGFza19wYXJhbXMtPnNlbmRfd3JpdGVfaW5jYXBzdWxl KQo+ID4gKyAgICAgICAgICAgICAgICAgICAgIGNvbnRleHQtPnVzdG9ybV9hZ19jb250ZXh0LmV4 cF9kYXRhX2Fja2VkID0gdGFza19zaXplOwo+ID4gKyAgICAgICAgICAgICBlbHNlCj4gPiArICAg ICAgICAgICAgICAgICAgICAgY29udGV4dC0+dXN0b3JtX2FnX2NvbnRleHQuZXhwX2RhdGFfYWNr ZWQgPSAwOwo+ID4gKyAgICAgfSBlbHNlIGlmICh0YXNrX3R5cGUgPT0gTlZNRVRDUF9UQVNLX1RZ UEVfSE9TVF9SRUFEKSB7Cj4gPiArICAgICAgICAgICAgIGNvbnRleHQtPnVzdG9ybV9hZ19jb250 ZXh0LmV4cF9kYXRhX2Fja2VkID0gMDsKPiA+ICsgICAgIH0KPiA+ICsKPiA+ICsgICAgIGNvbnRl eHQtPnVzdG9ybV9hZ19jb250ZXh0LmV4cF9jb250X2xlbiA9IDA7Cj4gPiArCj4gPiArICAgICBp bml0X3NxZSh0YXNrX3BhcmFtcywgc2dsX3Rhc2tfcGFyYW1zLCB0YXNrX3R5cGUpOwo+ID4gK30K PiA+ICsKPiA+ICtzdGF0aWMgdm9pZAo+ID4gK2luaXRfY29tbW9uX2luaXRpYXRvcl9yZWFkX3Rh c2soc3RydWN0IG52bWV0Y3BfdGFza19wYXJhbXMgKnRhc2tfcGFyYW1zLAo+ID4gKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgc3RydWN0IG52bWV0Y3BfY29ubl9wYXJhbXMgKmNvbm5fcGFy YW1zLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IG52bWV0Y3BfY21k X2NhcHN1bGVfaGRyICpjbWRfcGR1X2hlYWRlciwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHN0cnVjdCBzdG9yYWdlX3NnbF90YXNrX3BhcmFtcyAqc2dsX3Rhc2tfcGFyYW1zKQo+ ID4gK3sKPiA+ICsgICAgIGluaXRfcndfbnZtZXRjcF90YXNrKHRhc2tfcGFyYW1zLCBOVk1FVENQ X1RBU0tfVFlQRV9IT1NUX1JFQUQsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICBjb25u X3BhcmFtcywgY21kX3BkdV9oZWFkZXIsIHNnbF90YXNrX3BhcmFtcyk7Cj4gPiArfQo+ID4gKwo+ ID4gK3ZvaWQgaW5pdF9udm1ldGNwX2hvc3RfcmVhZF90YXNrKHN0cnVjdCBudm1ldGNwX3Rhc2tf cGFyYW1zICp0YXNrX3BhcmFtcywKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBz dHJ1Y3QgbnZtZXRjcF9jb25uX3BhcmFtcyAqY29ubl9wYXJhbXMsCj4gPiArICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgc3RydWN0IG52bWV0Y3BfY21kX2NhcHN1bGVfaGRyICpjbWRfcGR1 X2hlYWRlciwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qgc3RvcmFn ZV9zZ2xfdGFza19wYXJhbXMgKnNnbF90YXNrX3BhcmFtcykKPiA+ICt7Cj4gPiArICAgICBpbml0 X2NvbW1vbl9pbml0aWF0b3JfcmVhZF90YXNrKHRhc2tfcGFyYW1zLCBjb25uX3BhcmFtcywKPiA+ ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKHZvaWQgKiljbWRfcGR1X2hl YWRlciwgc2dsX3Rhc2tfcGFyYW1zKTsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGljIHZvaWQKPiA+ ICtpbml0X2NvbW1vbl9pbml0aWF0b3Jfd3JpdGVfdGFzayhzdHJ1Y3QgbnZtZXRjcF90YXNrX3Bh cmFtcyAqdGFza19wYXJhbXMsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3Ry dWN0IG52bWV0Y3BfY29ubl9wYXJhbXMgKmNvbm5fcGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHN0cnVjdCBudm1ldGNwX2NtZF9jYXBzdWxlX2hkciAqY21kX3BkdV9o ZWFkZXIsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHN0b3JhZ2Vf c2dsX3Rhc2tfcGFyYW1zICpzZ2xfdGFza19wYXJhbXMpCj4gPiArewo+ID4gKyAgICAgaW5pdF9y d19udm1ldGNwX3Rhc2sodGFza19wYXJhbXMsIE5WTUVUQ1BfVEFTS19UWVBFX0hPU1RfV1JJVEUs Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICBjb25uX3BhcmFtcywgY21kX3BkdV9oZWFk ZXIsIHNnbF90YXNrX3BhcmFtcyk7Cj4gPiArfQo+ID4gKwo+ID4gK3ZvaWQgaW5pdF9udm1ldGNw X2hvc3Rfd3JpdGVfdGFzayhzdHJ1Y3QgbnZtZXRjcF90YXNrX3BhcmFtcyAqdGFza19wYXJhbXMs Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBudm1ldGNwX2Nvbm5f cGFyYW1zICpjb25uX3BhcmFtcywKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg c3RydWN0IG52bWV0Y3BfY21kX2NhcHN1bGVfaGRyICpjbWRfcGR1X2hlYWRlciwKPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHN0b3JhZ2Vfc2dsX3Rhc2tfcGFyYW1z ICpzZ2xfdGFza19wYXJhbXMpCj4gPiArewo+ID4gKyAgICAgaW5pdF9jb21tb25faW5pdGlhdG9y X3dyaXRlX3Rhc2sodGFza19wYXJhbXMsIGNvbm5fcGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgKHZvaWQgKiljbWRfcGR1X2hlYWRlciwKPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNnbF90YXNrX3BhcmFtcyk7Cj4gPiAr fQo+ID4gKwo+ID4gK3N0YXRpYyB2b2lkCj4gPiAraW5pdF9jb21tb25fbG9naW5fcmVxdWVzdF90 YXNrKHN0cnVjdCBudm1ldGNwX3Rhc2tfcGFyYW1zICp0YXNrX3BhcmFtcywKPiA+ICsgICAgICAg ICAgICAgICAgICAgICAgICAgICAgdm9pZCAqbG9naW5fcmVxX3BkdV9oZWFkZXIsCj4gPiArICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBzdG9yYWdlX3NnbF90YXNrX3BhcmFtcyAq dHhfc2dsX3Rhc2tfcGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1 Y3Qgc3RvcmFnZV9zZ2xfdGFza19wYXJhbXMgKnJ4X3NnbF90YXNrX3BhcmFtcykKPiA+ICt7Cj4g PiArICAgICBzdHJ1Y3QgZTVfbnZtZXRjcF90YXNrX2NvbnRleHQgKmNvbnRleHQgPSB0YXNrX3Bh cmFtcy0+Y29udGV4dDsKPiA+ICsKPiA+ICsgICAgIGluaXRfZGVmYXVsdF9udm1ldGNwX3Rhc2so dGFza19wYXJhbXMsICh2b2lkICopbG9naW5fcmVxX3BkdV9oZWFkZXIsCj4gPiArICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIE5WTUVUQ1BfVEFTS19UWVBFX0lOSVRfQ09OTl9SRVFVRVNU KTsKPiA+ICsKPiA+ICsgICAgIC8qIFVzdG9ybSBDb250ZXh0OiAqLwo+ID4gKyAgICAgaW5pdF91 c3Rvcm1fdGFza19jb250ZXh0cygmY29udGV4dC0+dXN0b3JtX3N0X2NvbnRleHQsCj4gPiArICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICZjb250ZXh0LT51c3Rvcm1fYWdfY29udGV4dCwK PiA+ICsKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogUmVtYWluaW5nIFJl Y2VpdmUgbGVuZ3RoIGlzIHRoZSBUYXNrIFNpemUgKi8KPiA+ICsgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgdGFza19wYXJhbXMtPnJ4X2lvX3NpemUgPwo+ID4gKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICByeF9zZ2xfdGFza19wYXJhbXMtPnRvdGFsX2J1ZmZlcl9zaXplIDog MCwKPiA+ICsKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogVGhlIHNpemUg b2YgdGhlIHRyYW5zbWl0dGVkIHRhc2sgKi8KPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgdGFza19wYXJhbXMtPnR4X2lvX3NpemUgPwo+ID4gKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB0eF9zZ2xfdGFza19wYXJhbXMtPnRvdGFsX2J1ZmZlcl9zaXplIDogMCwKPiA+ ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMCwgLyogbnVtX3NnZXMgKi8KPiA+ICsg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMCk7IC8qIHR4X2RpZl9jb25uX2Vycl9lbiAq Lwo+ID4gKwo+ID4gKyAgICAgLyogU0dMIGNvbnRleHQ6ICovCj4gPiArICAgICBpZiAodGFza19w YXJhbXMtPnR4X2lvX3NpemUpCj4gPiArICAgICAgICAgICAgIGluaXRfc2NzaV9zZ2xfY29udGV4 dCgmY29udGV4dC0+eXN0b3JtX3N0X2NvbnRleHQuc3RhdGUuc2dsX3BhcmFtcywKPiA+ICsgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZjb250ZXh0LT55c3Rvcm1fc3RfY29udGV4 dC5zdGF0ZS5kYXRhX2Rlc2MsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB0eF9zZ2xfdGFza19wYXJhbXMpOwo+ID4gKyAgICAgaWYgKHRhc2tfcGFyYW1zLT5yeF9pb19z aXplKQo+ID4gKyAgICAgICAgICAgICBpbml0X3Njc2lfc2dsX2NvbnRleHQoJmNvbnRleHQtPm1z dG9ybV9zdF9jb250ZXh0LnNnbF9wYXJhbXMsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAmY29udGV4dC0+bXN0b3JtX3N0X2NvbnRleHQuZGF0YV9kZXNjLAo+ID4gKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcnhfc2dsX3Rhc2tfcGFyYW1zKTsKPiA+ ICsKPiA+ICsgICAgIGNvbnRleHQtPm1zdG9ybV9zdF9jb250ZXh0LnJlbV90YXNrX3NpemUgPQo+ ID4gKyAgICAgICAgICAgICBjcHVfdG9fbGUzMih0YXNrX3BhcmFtcy0+cnhfaW9fc2l6ZSA/Cj4g PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcnhfc2dsX3Rhc2tfcGFyYW1zLT50b3Rh bF9idWZmZXJfc2l6ZSA6IDApOwo+ID4gKwo+ID4gKyAgICAgaW5pdF9zcWUodGFza19wYXJhbXMs IHR4X3NnbF90YXNrX3BhcmFtcywgTlZNRVRDUF9UQVNLX1RZUEVfSU5JVF9DT05OX1JFUVVFU1Qp Owo+ID4gK30KPiA+ICsKPiA+ICsvKiBUaGUgZm9sbG93aW5nIGZ1bmN0aW9uIGluaXRpYWxpemVz IExvZ2luIHRhc2sgaW4gSG9zdCBtb2RlOiAqLwo+ID4gK3ZvaWQgaW5pdF9udm1ldGNwX2luaXRf Y29ubl9yZXFfdGFzayhzdHJ1Y3QgbnZtZXRjcF90YXNrX3BhcmFtcyAqdGFza19wYXJhbXMsCj4g PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBudm1ldGNwX2luaXRf Y29ubl9yZXFfaGRyICppbml0X2Nvbm5fcmVxX3BkdV9oZHIsCj4gPiArICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHN0cnVjdCBzdG9yYWdlX3NnbF90YXNrX3BhcmFtcyAqdHhfc2ds X3Rhc2tfcGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1 Y3Qgc3RvcmFnZV9zZ2xfdGFza19wYXJhbXMgKnJ4X3NnbF90YXNrX3BhcmFtcykKPiA+ICt7Cj4g PiArICAgICBpbml0X2NvbW1vbl9sb2dpbl9yZXF1ZXN0X3Rhc2sodGFza19wYXJhbXMsIGluaXRf Y29ubl9yZXFfcGR1X2hkciwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB0eF9zZ2xfdGFza19wYXJhbXMsIHJ4X3NnbF90YXNrX3BhcmFtcyk7Cj4gPiArfQo+ID4gKwo+ ID4gK3ZvaWQgaW5pdF9jbGVhbnVwX3Rhc2tfbnZtZXRjcChzdHJ1Y3QgbnZtZXRjcF90YXNrX3Bh cmFtcyAqdGFza19wYXJhbXMpCj4gPiArewo+ID4gKyAgICAgaW5pdF9zcWUodGFza19wYXJhbXMs IE5VTEwsIE5WTUVUQ1BfVEFTS19UWVBFX0NMRUFOVVApOwo+ID4gK30KPiA+IGRpZmYgLS1naXQg YS9kcml2ZXJzL25ldC9ldGhlcm5ldC9xbG9naWMvcWVkL3FlZF9udm1ldGNwX2Z3X2Z1bmNzLmgg Yi9kcml2ZXJzL25ldC9ldGhlcm5ldC9xbG9naWMvcWVkL3FlZF9udm1ldGNwX2Z3X2Z1bmNzLmgK PiA+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gPiBpbmRleCAwMDAwMDAwMDAwMDAuLjNhOGM3NDM1 NmM0Ywo+ID4gLS0tIC9kZXYvbnVsbAo+ID4gKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvcWxv Z2ljL3FlZC9xZWRfbnZtZXRjcF9md19mdW5jcy5oCj4gPiBAQCAtMCwwICsxLDQzIEBACj4gPiAr LyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IChHUEwtMi4wLW9ubHkgT1IgQlNELTMtQ2xhdXNl KSAqLwo+ID4gKy8qIENvcHlyaWdodCAyMDIxIE1hcnZlbGwuIEFsbCByaWdodHMgcmVzZXJ2ZWQu ICovCj4gPiArCj4gPiArI2lmbmRlZiBfUUVEX05WTUVUQ1BfRldfRlVOQ1NfSAo+ID4gKyNkZWZp bmUgX1FFRF9OVk1FVENQX0ZXX0ZVTkNTX0gKPiA+ICsKPiA+ICsjaW5jbHVkZSA8bGludXgva2Vy bmVsLmg+Cj4gPiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ID4gKyNpbmNsdWRlIDxsaW51 eC9wY2kuaD4KPiA+ICsjaW5jbHVkZSA8bGludXgva2VybmVsLmg+Cj4gPiArI2luY2x1ZGUgPGxp bnV4L2xpc3QuaD4KPiA+ICsjaW5jbHVkZSA8bGludXgvbW0uaD4KPiA+ICsjaW5jbHVkZSA8bGlu dXgvdHlwZXMuaD4KPiA+ICsjaW5jbHVkZSA8YXNtL2J5dGVvcmRlci5oPgo+ID4gKyNpbmNsdWRl IDxsaW51eC9xZWQvY29tbW9uX2hzaS5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC9xZWQvc3RvcmFn ZV9jb21tb24uaD4KPiA+ICsjaW5jbHVkZSA8bGludXgvcWVkL252bWV0Y3BfY29tbW9uLmg+Cj4g PiArI2luY2x1ZGUgPGxpbnV4L3FlZC9xZWRfbnZtZXRjcF9pZi5oPgo+ID4gKwo+ID4gKyNpZiBJ U19FTkFCTEVEKENPTkZJR19RRURfTlZNRVRDUCkKPiA+ICsKPiA+ICt2b2lkIGluaXRfbnZtZXRj cF9ob3N0X3JlYWRfdGFzayhzdHJ1Y3QgbnZtZXRjcF90YXNrX3BhcmFtcyAqdGFza19wYXJhbXMs Cj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IG52bWV0Y3BfY29ubl9w YXJhbXMgKmNvbm5fcGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0 cnVjdCBudm1ldGNwX2NtZF9jYXBzdWxlX2hkciAqY21kX3BkdV9oZWFkZXIsCj4gPiArICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IHN0b3JhZ2Vfc2dsX3Rhc2tfcGFyYW1zICpz Z2xfdGFza19wYXJhbXMpOwo+ID4gKwo+ID4gK3ZvaWQgaW5pdF9udm1ldGNwX2hvc3Rfd3JpdGVf dGFzayhzdHJ1Y3QgbnZtZXRjcF90YXNrX3BhcmFtcyAqdGFza19wYXJhbXMsCj4gPiArICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBudm1ldGNwX2Nvbm5fcGFyYW1zICpjb25u X3BhcmFtcywKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IG52bWV0 Y3BfY21kX2NhcHN1bGVfaGRyICpjbWRfcGR1X2hlYWRlciwKPiA+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgc3RydWN0IHN0b3JhZ2Vfc2dsX3Rhc2tfcGFyYW1zICpzZ2xfdGFza19w YXJhbXMpOwo+ID4gKwo+ID4gK3ZvaWQgaW5pdF9udm1ldGNwX2luaXRfY29ubl9yZXFfdGFzayhz dHJ1Y3QgbnZtZXRjcF90YXNrX3BhcmFtcyAqdGFza19wYXJhbXMsCj4gPiArICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBudm1ldGNwX2luaXRfY29ubl9yZXFfaGRyICpp bml0X2Nvbm5fcmVxX3BkdV9oZHIsCj4gPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHN0cnVjdCBzdG9yYWdlX3NnbF90YXNrX3BhcmFtcyAqdHhfc2dsX3Rhc2tfcGFyYW1zLAo+ ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qgc3RvcmFnZV9zZ2xf dGFza19wYXJhbXMgKnJ4X3NnbF90YXNrX3BhcmFtcyk7Cj4gPiArCj4gPiArdm9pZCBpbml0X2Ns ZWFudXBfdGFza19udm1ldGNwKHN0cnVjdCBudm1ldGNwX3Rhc2tfcGFyYW1zICp0YXNrX3BhcmFt cyk7Cj4gPiArCj4gPiArI2Vsc2UgLyogSVNfRU5BQkxFRChDT05GSUdfUUVEX05WTUVUQ1ApICov Cj4gPiArCj4gPiArI2VuZGlmIC8qIElTX0VOQUJMRUQoQ09ORklHX1FFRF9OVk1FVENQKSAqLwo+ ID4gKwo+ID4gKyNlbmRpZiAvKiBfUUVEX05WTUVUQ1BfRldfRlVOQ1NfSCAqLwo+ID4gZGlmZiAt LWdpdCBhL2luY2x1ZGUvbGludXgvcWVkL252bWV0Y3BfY29tbW9uLmggYi9pbmNsdWRlL2xpbnV4 L3FlZC9udm1ldGNwX2NvbW1vbi5oCj4gPiBpbmRleCBkZGE3YTc4NWMzMjEuLmMwMDIzYmIxODVk ZCAxMDA2NDQKPiA+IC0tLSBhL2luY2x1ZGUvbGludXgvcWVkL252bWV0Y3BfY29tbW9uLmgKPiA+ ICsrKyBiL2luY2x1ZGUvbGludXgvcWVkL252bWV0Y3BfY29tbW9uLmgKPiA+IEBAIC05LDYgKzks OSBAQAo+ID4gICAjZGVmaW5lIE5WTUVUQ1BfU0xPV19QQVRIX0xBWUVSX0NPREUgKDYpCj4gPiAg ICNkZWZpbmUgTlZNRVRDUF9XUUVfTlVNX1NHRVNfU0xPV0lPICgweGYpCj4gPgo+ID4gKyNkZWZp bmUgUUVEX05WTUVUQ1BfQ01EX0hEUl9TSVpFIDcyCj4gPiArI2RlZmluZSBRRURfTlZNRVRDUF9D TU5fSERSX1NJWkUgMjQKPiA+ICsKPiA+ICAgLyogTlZNZVRDUCBmaXJtd2FyZSBmdW5jdGlvbiBp bml0IHBhcmFtZXRlcnMgKi8KPiA+ICAgc3RydWN0IG52bWV0Y3Bfc3BlX2Z1bmNfaW5pdCB7Cj4g PiAgICAgICBfX2xlMTYgaGFsZl93YXlfY2xvc2VfdGltZW91dDsKPiA+IGRpZmYgLS1naXQgYS9p bmNsdWRlL2xpbnV4L3FlZC9xZWRfbnZtZXRjcF9pZi5oIGIvaW5jbHVkZS9saW51eC9xZWQvcWVk X252bWV0Y3BfaWYuaAo+ID4gaW5kZXggMDRlOTBkYzQyYzEyLi5kOTcxYmU4NGY4MDQgMTAwNjQ0 Cj4gPiAtLS0gYS9pbmNsdWRlL2xpbnV4L3FlZC9xZWRfbnZtZXRjcF9pZi5oCj4gPiArKysgYi9p bmNsdWRlL2xpbnV4L3FlZC9xZWRfbnZtZXRjcF9pZi5oCj4gPiBAQCAtMjIwLDYgKzIyMCwyMyBA QCBzdHJ1Y3QgcWVkX252bWV0Y3Bfb3BzIHsKPiA+ICAgICAgIHZvaWQgKCpyZW1vdmVfZHN0X3Rj cF9wb3J0X2ZpbHRlcikoc3RydWN0IHFlZF9kZXYgKmNkZXYsIHUxNiBkZXN0X3BvcnQpOwo+ID4K PiA+ICAgICAgIHZvaWQgKCpjbGVhcl9hbGxfZmlsdGVycykoc3RydWN0IHFlZF9kZXYgKmNkZXYp Owo+ID4gKwo+ID4gKyAgICAgdm9pZCAoKmluaXRfcmVhZF9pbykoc3RydWN0IG52bWV0Y3BfdGFz a19wYXJhbXMgKnRhc2tfcGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgc3Ry dWN0IG52bWV0Y3BfY29ubl9wYXJhbXMgKmNvbm5fcGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAg ICAgICAgICAgICAgc3RydWN0IG52bWV0Y3BfY21kX2NhcHN1bGVfaGRyICpjbWRfcGR1X2hlYWRl ciwKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBzdG9yYWdlX3NnbF90YXNr X3BhcmFtcyAqc2dsX3Rhc2tfcGFyYW1zKTsKPiA+ICsKPiA+ICsgICAgIHZvaWQgKCppbml0X3dy aXRlX2lvKShzdHJ1Y3QgbnZtZXRjcF90YXNrX3BhcmFtcyAqdGFza19wYXJhbXMsCj4gPiArICAg ICAgICAgICAgICAgICAgICAgICAgICAgc3RydWN0IG52bWV0Y3BfY29ubl9wYXJhbXMgKmNvbm5f cGFyYW1zLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBudm1ldGNwX2Nt ZF9jYXBzdWxlX2hkciAqY21kX3BkdV9oZWFkZXIsCj4gPiArICAgICAgICAgICAgICAgICAgICAg ICAgICAgc3RydWN0IHN0b3JhZ2Vfc2dsX3Rhc2tfcGFyYW1zICpzZ2xfdGFza19wYXJhbXMpOwo+ ID4gKwo+ID4gKyAgICAgdm9pZCAoKmluaXRfaWNyZXFfZXhjaGFuZ2UpKHN0cnVjdCBudm1ldGNw X3Rhc2tfcGFyYW1zICp0YXNrX3BhcmFtcywKPiA+ICsgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBzdHJ1Y3QgbnZtZXRjcF9pbml0X2Nvbm5fcmVxX2hkciAqaW5pdF9jb25uX3JlcV9w ZHVfaGRyLAo+ID4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBzdG9y YWdlX3NnbF90YXNrX3BhcmFtcyAqdHhfc2dsX3Rhc2tfcGFyYW1zLAo+ID4gKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBzdG9yYWdlX3NnbF90YXNrX3BhcmFtcyAqcnhf c2dsX3Rhc2tfcGFyYW1zKTsKPiA+ICsKPiA+ICsgICAgIHZvaWQgKCppbml0X3Rhc2tfY2xlYW51 cCkoc3RydWN0IG52bWV0Y3BfdGFza19wYXJhbXMgKnRhc2tfcGFyYW1zKTsKPiA+ICAgfTsKPiA+ Cj4gPiAgIGNvbnN0IHN0cnVjdCBxZWRfbnZtZXRjcF9vcHMgKnFlZF9nZXRfbnZtZXRjcF9vcHMo dm9pZCk7Cj4gPgo+IENoZWVycywKPgo+IEhhbm5lcwo+IC0tCj4gRHIuIEhhbm5lcyBSZWluZWNr ZSAgICAgICAgICAgICAgICBLZXJuZWwgU3RvcmFnZSBBcmNoaXRlY3QKPiBoYXJlQHN1c2UuZGUg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICArNDkgOTExIDc0MDUzIDY4OAo+IFNVU0UgU29m dHdhcmUgU29sdXRpb25zIEdtYkgsIE1heGZlbGRzdHIuIDUsIDkwNDA5IE7DvHJuYmVyZwo+IEhS QiAzNjgwOSAoQUcgTsO8cm5iZXJnKSwgR2VzY2jDpGZ0c2bDvGhyZXI6IEZlbGl4IEltZW5kw7Zy ZmZlcgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGlu dXgtbnZtZSBtYWlsaW5nIGxpc3QKTGludXgtbnZtZUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6 Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtbnZtZQo=