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 08B8EC433FE for ; Wed, 27 Apr 2022 05:56:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1357878AbiD0F76 (ORCPT ); Wed, 27 Apr 2022 01:59:58 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57026 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232683AbiD0F75 (ORCPT ); Wed, 27 Apr 2022 01:59:57 -0400 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id B3DE92B1A8 for ; Tue, 26 Apr 2022 22:56:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1651039005; 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=9qeULQ41fQcQFOy0CY9Heuj/JvDE2+huvj1l00MURAI=; b=hHqGFtTSHxBCJWqB7umqmZXlKNkLA8XmKEblGgaQellpB+Bk0n6oq4MsOry9RLExu6qqUC dfmYc/X6k5DlFjnBEPXo6wFIoKc4k7TZup2M7VHe+xebsMdGiBVP5Roh6/0nhUhljOmHOJ lHaiN1ZsAt4CXGNFpatmi9f7hyVLK1I= Received: from mail-pg1-f199.google.com (mail-pg1-f199.google.com [209.85.215.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-549-Os6V5G-eOE-me_OqgxyPJA-1; Wed, 27 Apr 2022 01:56:42 -0400 X-MC-Unique: Os6V5G-eOE-me_OqgxyPJA-1 Received: by mail-pg1-f199.google.com with SMTP id z18-20020a631912000000b003a392265b64so449034pgl.2 for ; Tue, 26 Apr 2022 22:56:42 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:to:cc:references:from:in-reply-to :content-transfer-encoding; bh=9qeULQ41fQcQFOy0CY9Heuj/JvDE2+huvj1l00MURAI=; b=x4ER9JDlc3IcXoByd3xf+pQycPFh54j28EP46gmDogJ1z2hYrjguiQ2J4eACzB1WLk 9EDsIktizTYgvukSqpP7J8GYi2WjauTpj6orpqTCedX78MWvIoIPwvZsa70HFKE+tw1g iPZu6HSgipZD7YCY4fDuHXKiHhDdQEJN++Hsx9AunHjMKysBZqKyYJfz+3OGfZaO2LKN HLOhctYOTCc0P4ZIdhr+bo2va5W03Ov5KSNZCQJyKKQbb9msmBJ2XlhPAuQoZ4F6JHuD WmsaB05bHtu+AhSb47tIfe2qnj3sEnDnY+6Myw+DbGJarYzpVQjxoA8Q0n8AgP8iyvGV TXBQ== X-Gm-Message-State: AOAM532jmJj3srWdsQlJkavVBhS5oERSWfDCWvLRkFYvh+MmPMnEtdCT iXwLTd2CoA2Fln8VdxPEQKwkGyJ0FGuFrZGTKQb/RkcZhjywToI/gY584OhT9X5SGm4oN5XvLR7 ssk7UFERdMz4f3jSd X-Received: by 2002:a62:b60f:0:b0:508:2a61:2c8b with SMTP id j15-20020a62b60f000000b005082a612c8bmr28370673pff.2.1651039001281; Tue, 26 Apr 2022 22:56:41 -0700 (PDT) X-Google-Smtp-Source: ABdhPJwiiea0IwzZ22wAsh+sUDv5wKE8S6Fn4TlE5ivWn54gAuceV6BckQLQRjvue0imRQT6365j+g== X-Received: by 2002:a62:b60f:0:b0:508:2a61:2c8b with SMTP id j15-20020a62b60f000000b005082a612c8bmr28370650pff.2.1651039000929; Tue, 26 Apr 2022 22:56:40 -0700 (PDT) Received: from [10.72.12.60] ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id 16-20020a621410000000b0050aca5f79f5sm17592732pfu.97.2022.04.26.22.56.38 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 26 Apr 2022 22:56:40 -0700 (PDT) Message-ID: Date: Wed, 27 Apr 2022 13:56:36 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.8.1 Subject: Re: [PATCH V2] vDPA/ifcvf: allow userspace to suspend a queue Content-Language: en-US To: Zhu Lingshan , mst@redhat.com Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org References: <20220424113321.7176-1-lingshan.zhu@intel.com> From: Jason Wang In-Reply-To: <20220424113321.7176-1-lingshan.zhu@intel.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org 在 2022/4/24 19:33, Zhu Lingshan 写道: > Formerly, ifcvf driver has implemented a lazy-initialization mechanism > for the virtqueues, it would store all virtqueue config fields that > passed down from the userspace, then load them to the virtqueues and > enable the queues upon DRIVER_OK. > > To allow the userspace to suspend a virtqueue, > this commit passes queue_enable to the virtqueue directly through > set_vq_ready(). > > This feature requires and this commits implementing all virtqueue > ops(set_vq_addr, set_vq_num and set_vq_ready) to take immediate > actions than lazy-initialization, so ifcvf_hw_enable() is retired. > > set_features() should take immediate actions as well. > > ifcvf_add_status() is retierd because we should not add > status like FEATURES_OK by ifcvf's decision, this driver should > only set device status upon vdpa_ops.set_status() > > To avoid losing virtqueue configurations caused by multiple > rounds of reset(), this commit also refactors thed evice reset > routine, now it simply reset the config handler and the virtqueues, > and only once device-reset(). It looks like the patch tries to do too many things at one run. I'd suggest to split them: 1) on-the-fly set via set_vq_ready(), but I don't see a reason why we need to change other lazy stuffs, since setting queue_enable to 1 before DRIVER_OK won't start the virtqueue anyhow 2) if necessary, converting the lazy stuffs 3) the synchornize_irq() fixes 4) other stuffs Thanks > > Signed-off-by: Zhu Lingshan > --- > drivers/vdpa/ifcvf/ifcvf_base.c | 150 +++++++++++++++++++------------- > drivers/vdpa/ifcvf/ifcvf_base.h | 16 ++-- > drivers/vdpa/ifcvf/ifcvf_main.c | 81 +++-------------- > 3 files changed, 111 insertions(+), 136 deletions(-) > > diff --git a/drivers/vdpa/ifcvf/ifcvf_base.c b/drivers/vdpa/ifcvf/ifcvf_base.c > index 48c4dadb0c7c..bbc9007a6f34 100644 > --- a/drivers/vdpa/ifcvf/ifcvf_base.c > +++ b/drivers/vdpa/ifcvf/ifcvf_base.c > @@ -179,20 +179,7 @@ void ifcvf_set_status(struct ifcvf_hw *hw, u8 status) > > void ifcvf_reset(struct ifcvf_hw *hw) > { > - hw->config_cb.callback = NULL; > - hw->config_cb.private = NULL; > - > ifcvf_set_status(hw, 0); > - /* flush set_status, make sure VF is stopped, reset */ > - ifcvf_get_status(hw); > -} > - > -static void ifcvf_add_status(struct ifcvf_hw *hw, u8 status) > -{ > - if (status != 0) > - status |= ifcvf_get_status(hw); > - > - ifcvf_set_status(hw, status); > ifcvf_get_status(hw); > } > > @@ -213,7 +200,7 @@ u64 ifcvf_get_hw_features(struct ifcvf_hw *hw) > return features; > } > > -u64 ifcvf_get_features(struct ifcvf_hw *hw) > +u64 ifcvf_get_device_features(struct ifcvf_hw *hw) > { > return hw->hw_features; > } > @@ -280,7 +267,7 @@ void ifcvf_write_dev_config(struct ifcvf_hw *hw, u64 offset, > vp_iowrite8(*p++, hw->dev_cfg + offset + i); > } > > -static void ifcvf_set_features(struct ifcvf_hw *hw, u64 features) > +void ifcvf_set_features(struct ifcvf_hw *hw, u64 features) > { > struct virtio_pci_common_cfg __iomem *cfg = hw->common_cfg; > > @@ -289,22 +276,22 @@ static void ifcvf_set_features(struct ifcvf_hw *hw, u64 features) > > vp_iowrite32(1, &cfg->guest_feature_select); > vp_iowrite32(features >> 32, &cfg->guest_feature); > + > + vp_ioread32(&cfg->guest_feature); > } > > -static int ifcvf_config_features(struct ifcvf_hw *hw) > +u64 ifcvf_get_features(struct ifcvf_hw *hw) > { > - struct ifcvf_adapter *ifcvf; > + struct virtio_pci_common_cfg __iomem *cfg = hw->common_cfg; > + u64 features; > > - ifcvf = vf_to_adapter(hw); > - ifcvf_set_features(hw, hw->req_features); > - ifcvf_add_status(hw, VIRTIO_CONFIG_S_FEATURES_OK); > + vp_iowrite32(0, &cfg->device_feature_select); > + features = vp_ioread32(&cfg->device_feature); > > - if (!(ifcvf_get_status(hw) & VIRTIO_CONFIG_S_FEATURES_OK)) { > - IFCVF_ERR(ifcvf->pdev, "Failed to set FEATURES_OK status\n"); > - return -EIO; > - } > + vp_iowrite32(1, &cfg->device_feature_select); > + features |= ((u64)vp_ioread32(&cfg->guest_feature) << 32); > > - return 0; > + return features; > } > > u16 ifcvf_get_vq_state(struct ifcvf_hw *hw, u16 qid) > @@ -331,68 +318,111 @@ int ifcvf_set_vq_state(struct ifcvf_hw *hw, u16 qid, u16 num) > ifcvf_lm = (struct ifcvf_lm_cfg __iomem *)hw->lm_cfg; > q_pair_id = qid / hw->nr_vring; > avail_idx_addr = &ifcvf_lm->vring_lm_cfg[q_pair_id].idx_addr[qid % 2]; > - hw->vring[qid].last_avail_idx = num; > vp_iowrite16(num, avail_idx_addr); > > return 0; > } > > -static int ifcvf_hw_enable(struct ifcvf_hw *hw) > +void ifcvf_set_vq_num(struct ifcvf_hw *hw, u16 qid, u32 num) > { > - struct virtio_pci_common_cfg __iomem *cfg; > - u32 i; > + struct virtio_pci_common_cfg __iomem *cfg = hw->common_cfg; > > - cfg = hw->common_cfg; > - for (i = 0; i < hw->nr_vring; i++) { > - if (!hw->vring[i].ready) > - break; > + vp_iowrite16(qid, &cfg->queue_select); > + vp_iowrite16(num, &cfg->queue_size); > +} > > - vp_iowrite16(i, &cfg->queue_select); > - vp_iowrite64_twopart(hw->vring[i].desc, &cfg->queue_desc_lo, > - &cfg->queue_desc_hi); > - vp_iowrite64_twopart(hw->vring[i].avail, &cfg->queue_avail_lo, > - &cfg->queue_avail_hi); > - vp_iowrite64_twopart(hw->vring[i].used, &cfg->queue_used_lo, > - &cfg->queue_used_hi); > - vp_iowrite16(hw->vring[i].size, &cfg->queue_size); > - ifcvf_set_vq_state(hw, i, hw->vring[i].last_avail_idx); > - vp_iowrite16(1, &cfg->queue_enable); > - } > +int ifcvf_set_vq_address(struct ifcvf_hw *hw, u16 qid, u64 desc_area, > + u64 driver_area, u64 device_area) > +{ > + struct virtio_pci_common_cfg __iomem *cfg = hw->common_cfg; > + > + vp_iowrite16(qid, &cfg->queue_select); > + vp_iowrite64_twopart(desc_area, &cfg->queue_desc_lo, > + &cfg->queue_desc_hi); > + vp_iowrite64_twopart(driver_area, &cfg->queue_avail_lo, > + &cfg->queue_avail_hi); > + vp_iowrite64_twopart(device_area, &cfg->queue_used_lo, > + &cfg->queue_used_hi); > > return 0; > } > > -static void ifcvf_hw_disable(struct ifcvf_hw *hw) > +void ifcvf_set_vq_ready(struct ifcvf_hw *hw, u16 qid, bool ready) > { > - u32 i; > + struct virtio_pci_common_cfg __iomem *cfg = hw->common_cfg; > + > + vp_iowrite16(qid, &cfg->queue_select); > + /* write 0 to queue_enable will suspend a queue*/ > + vp_iowrite16(ready, &cfg->queue_enable); > +} > + > +bool ifcvf_get_vq_ready(struct ifcvf_hw *hw, u16 qid) > +{ > + struct virtio_pci_common_cfg __iomem *cfg = hw->common_cfg; > + bool queue_enable; > + > + vp_iowrite16(qid, &cfg->queue_select); > + queue_enable = vp_ioread16(&cfg->queue_enable); > + > + return (bool)queue_enable; > +} > + > +static void synchronize_per_vq_irq(struct ifcvf_hw *hw) > +{ > + int i; > > - ifcvf_set_config_vector(hw, VIRTIO_MSI_NO_VECTOR); > for (i = 0; i < hw->nr_vring; i++) { > - ifcvf_set_vq_vector(hw, i, VIRTIO_MSI_NO_VECTOR); > + if (hw->vring[i].irq != -EINVAL) > + synchronize_irq(hw->vring[i].irq); > } > } > > -int ifcvf_start_hw(struct ifcvf_hw *hw) > +static void synchronize_vqs_reused_irq(struct ifcvf_hw *hw) > { > - ifcvf_reset(hw); > - ifcvf_add_status(hw, VIRTIO_CONFIG_S_ACKNOWLEDGE); > - ifcvf_add_status(hw, VIRTIO_CONFIG_S_DRIVER); > + if (hw->vqs_reused_irq != -EINVAL) > + synchronize_irq(hw->vqs_reused_irq); > +} > > - if (ifcvf_config_features(hw) < 0) > - return -EINVAL; > +static void synchronize_vq_irq(struct ifcvf_hw *hw) > +{ > + u8 status = hw->msix_vector_status; > > - if (ifcvf_hw_enable(hw) < 0) > - return -EINVAL; > + if (status == MSIX_VECTOR_PER_VQ_AND_CONFIG) > + synchronize_per_vq_irq(hw); > + else > + synchronize_vqs_reused_irq(hw); > +} > > - ifcvf_add_status(hw, VIRTIO_CONFIG_S_DRIVER_OK); > +static void synchronize_config_irq(struct ifcvf_hw *hw) > +{ > + if (hw->config_irq != -EINVAL) > + synchronize_irq(hw->config_irq); > +} > > - return 0; > +static void ifcvf_reset_vring(struct ifcvf_hw *hw) > +{ > + int i; > + > + for (i = 0; i < hw->nr_vring; i++) { > + synchronize_vq_irq(hw); > + hw->vring[i].cb.callback = NULL; > + hw->vring[i].cb.private = NULL; > + ifcvf_set_vq_vector(hw, i, VIRTIO_MSI_NO_VECTOR); > + } > +} > + > +static void ifcvf_reset_config_handler(struct ifcvf_hw *hw) > +{ > + synchronize_config_irq(hw); > + hw->config_cb.callback = NULL; > + hw->config_cb.private = NULL; > + ifcvf_set_config_vector(hw, VIRTIO_MSI_NO_VECTOR); > } > > void ifcvf_stop_hw(struct ifcvf_hw *hw) > { > - ifcvf_hw_disable(hw); > - ifcvf_reset(hw); > + ifcvf_reset_vring(hw); > + ifcvf_reset_config_handler(hw); > } > > void ifcvf_notify_queue(struct ifcvf_hw *hw, u16 qid) > diff --git a/drivers/vdpa/ifcvf/ifcvf_base.h b/drivers/vdpa/ifcvf/ifcvf_base.h > index 115b61f4924b..f3dce0d795cb 100644 > --- a/drivers/vdpa/ifcvf/ifcvf_base.h > +++ b/drivers/vdpa/ifcvf/ifcvf_base.h > @@ -49,12 +49,6 @@ > #define MSIX_VECTOR_DEV_SHARED 3 > > struct vring_info { > - u64 desc; > - u64 avail; > - u64 used; > - u16 size; > - u16 last_avail_idx; > - bool ready; > void __iomem *notify_addr; > phys_addr_t notify_pa; > u32 irq; > @@ -76,7 +70,6 @@ struct ifcvf_hw { > phys_addr_t notify_base_pa; > u32 notify_off_multiplier; > u32 dev_type; > - u64 req_features; > u64 hw_features; > struct virtio_pci_common_cfg __iomem *common_cfg; > void __iomem *dev_cfg; > @@ -123,7 +116,7 @@ u8 ifcvf_get_status(struct ifcvf_hw *hw); > void ifcvf_set_status(struct ifcvf_hw *hw, u8 status); > void io_write64_twopart(u64 val, u32 *lo, u32 *hi); > void ifcvf_reset(struct ifcvf_hw *hw); > -u64 ifcvf_get_features(struct ifcvf_hw *hw); > +u64 ifcvf_get_device_features(struct ifcvf_hw *hw); > u64 ifcvf_get_hw_features(struct ifcvf_hw *hw); > int ifcvf_verify_min_features(struct ifcvf_hw *hw, u64 features); > u16 ifcvf_get_vq_state(struct ifcvf_hw *hw, u16 qid); > @@ -131,6 +124,13 @@ int ifcvf_set_vq_state(struct ifcvf_hw *hw, u16 qid, u16 num); > struct ifcvf_adapter *vf_to_adapter(struct ifcvf_hw *hw); > int ifcvf_probed_virtio_net(struct ifcvf_hw *hw); > u32 ifcvf_get_config_size(struct ifcvf_hw *hw); > +int ifcvf_set_vq_address(struct ifcvf_hw *hw, u16 qid, u64 desc_area, > + u64 driver_area, u64 device_area); > u16 ifcvf_set_vq_vector(struct ifcvf_hw *hw, u16 qid, int vector); > u16 ifcvf_set_config_vector(struct ifcvf_hw *hw, int vector); > +void ifcvf_set_vq_num(struct ifcvf_hw *hw, u16 qid, u32 num); > +void ifcvf_set_vq_ready(struct ifcvf_hw *hw, u16 qid, bool ready); > +bool ifcvf_get_vq_ready(struct ifcvf_hw *hw, u16 qid); > +void ifcvf_set_features(struct ifcvf_hw *hw, u64 features); > +u64 ifcvf_get_features(struct ifcvf_hw *hw); > #endif /* _IFCVF_H_ */ > diff --git a/drivers/vdpa/ifcvf/ifcvf_main.c b/drivers/vdpa/ifcvf/ifcvf_main.c > index 4366320fb68d..0257ba98cffe 100644 > --- a/drivers/vdpa/ifcvf/ifcvf_main.c > +++ b/drivers/vdpa/ifcvf/ifcvf_main.c > @@ -358,53 +358,6 @@ static int ifcvf_request_irq(struct ifcvf_adapter *adapter) > return 0; > } > > -static int ifcvf_start_datapath(void *private) > -{ > - struct ifcvf_hw *vf = ifcvf_private_to_vf(private); > - u8 status; > - int ret; > - > - ret = ifcvf_start_hw(vf); > - if (ret < 0) { > - status = ifcvf_get_status(vf); > - status |= VIRTIO_CONFIG_S_FAILED; > - ifcvf_set_status(vf, status); > - } > - > - return ret; > -} > - > -static int ifcvf_stop_datapath(void *private) > -{ > - struct ifcvf_hw *vf = ifcvf_private_to_vf(private); > - int i; > - > - for (i = 0; i < vf->nr_vring; i++) > - vf->vring[i].cb.callback = NULL; > - > - ifcvf_stop_hw(vf); > - > - return 0; > -} > - > -static void ifcvf_reset_vring(struct ifcvf_adapter *adapter) > -{ > - struct ifcvf_hw *vf = ifcvf_private_to_vf(adapter); > - int i; > - > - for (i = 0; i < vf->nr_vring; i++) { > - vf->vring[i].last_avail_idx = 0; > - vf->vring[i].desc = 0; > - vf->vring[i].avail = 0; > - vf->vring[i].used = 0; > - vf->vring[i].ready = 0; > - vf->vring[i].cb.callback = NULL; > - vf->vring[i].cb.private = NULL; > - } > - > - ifcvf_reset(vf); > -} > - > static struct ifcvf_adapter *vdpa_to_adapter(struct vdpa_device *vdpa_dev) > { > return container_of(vdpa_dev, struct ifcvf_adapter, vdpa); > @@ -426,7 +379,7 @@ static u64 ifcvf_vdpa_get_device_features(struct vdpa_device *vdpa_dev) > u64 features; > > if (type == VIRTIO_ID_NET || type == VIRTIO_ID_BLOCK) > - features = ifcvf_get_features(vf); > + features = ifcvf_get_device_features(vf); > else { > features = 0; > IFCVF_ERR(pdev, "VIRTIO ID %u not supported\n", vf->dev_type); > @@ -444,7 +397,7 @@ static int ifcvf_vdpa_set_driver_features(struct vdpa_device *vdpa_dev, u64 feat > if (ret) > return ret; > > - vf->req_features = features; > + ifcvf_set_features(vf, features); > > return 0; > } > @@ -453,7 +406,7 @@ static u64 ifcvf_vdpa_get_driver_features(struct vdpa_device *vdpa_dev) > { > struct ifcvf_hw *vf = vdpa_to_vf(vdpa_dev); > > - return vf->req_features; > + return ifcvf_get_features(vf); > } > > static u8 ifcvf_vdpa_get_status(struct vdpa_device *vdpa_dev) > @@ -486,11 +439,6 @@ static void ifcvf_vdpa_set_status(struct vdpa_device *vdpa_dev, u8 status) > ifcvf_set_status(vf, status); > return; > } > - > - if (ifcvf_start_datapath(adapter) < 0) > - IFCVF_ERR(adapter->pdev, > - "Failed to set ifcvf vdpa status %u\n", > - status); > } > > ifcvf_set_status(vf, status); > @@ -509,12 +457,10 @@ static int ifcvf_vdpa_reset(struct vdpa_device *vdpa_dev) > if (status_old == 0) > return 0; > > - if (status_old & VIRTIO_CONFIG_S_DRIVER_OK) { > - ifcvf_stop_datapath(adapter); > - ifcvf_free_irq(adapter); > - } > + ifcvf_stop_hw(vf); > + ifcvf_free_irq(adapter); > > - ifcvf_reset_vring(adapter); > + ifcvf_reset(vf); > > return 0; > } > @@ -554,14 +500,17 @@ static void ifcvf_vdpa_set_vq_ready(struct vdpa_device *vdpa_dev, > { > struct ifcvf_hw *vf = vdpa_to_vf(vdpa_dev); > > - vf->vring[qid].ready = ready; > + ifcvf_set_vq_ready(vf, qid, ready); > } > > static bool ifcvf_vdpa_get_vq_ready(struct vdpa_device *vdpa_dev, u16 qid) > { > struct ifcvf_hw *vf = vdpa_to_vf(vdpa_dev); > + bool ready; > + > + ready = ifcvf_get_vq_ready(vf, qid); > > - return vf->vring[qid].ready; > + return ready; > } > > static void ifcvf_vdpa_set_vq_num(struct vdpa_device *vdpa_dev, u16 qid, > @@ -569,7 +518,7 @@ static void ifcvf_vdpa_set_vq_num(struct vdpa_device *vdpa_dev, u16 qid, > { > struct ifcvf_hw *vf = vdpa_to_vf(vdpa_dev); > > - vf->vring[qid].size = num; > + ifcvf_set_vq_num(vf, qid, num); > } > > static int ifcvf_vdpa_set_vq_address(struct vdpa_device *vdpa_dev, u16 qid, > @@ -578,11 +527,7 @@ static int ifcvf_vdpa_set_vq_address(struct vdpa_device *vdpa_dev, u16 qid, > { > struct ifcvf_hw *vf = vdpa_to_vf(vdpa_dev); > > - vf->vring[qid].desc = desc_area; > - vf->vring[qid].avail = driver_area; > - vf->vring[qid].used = device_area; > - > - return 0; > + return ifcvf_set_vq_address(vf, qid, desc_area, driver_area, device_area); > } > > static void ifcvf_vdpa_kick_vq(struct vdpa_device *vdpa_dev, u16 qid) 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 smtp4.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (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 6252FC43217 for ; Wed, 27 Apr 2022 05:56:51 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp4.osuosl.org (Postfix) with ESMTP id D40B3418C4; Wed, 27 Apr 2022 05:56:50 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp4.osuosl.org ([127.0.0.1]) by localhost (smtp4.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id bfVjOTW-NFoM; Wed, 27 Apr 2022 05:56:49 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp4.osuosl.org (Postfix) with ESMTPS id 87AD4416D9; Wed, 27 Apr 2022 05:56:48 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 55B0AC0039; Wed, 27 Apr 2022 05:56:48 +0000 (UTC) Received: from smtp1.osuosl.org (smtp1.osuosl.org [IPv6:2605:bc80:3010::138]) by lists.linuxfoundation.org (Postfix) with ESMTP id D748DC002D for ; Wed, 27 Apr 2022 05:56:46 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id B5DCC82F4F for ; Wed, 27 Apr 2022 05:56:46 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Authentication-Results: smtp1.osuosl.org (amavisd-new); dkim=pass (1024-bit key) header.d=redhat.com Received: from smtp1.osuosl.org ([127.0.0.1]) by localhost (smtp1.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id QPli_ap7ctYL for ; Wed, 27 Apr 2022 05:56:45 +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.133.124]) by smtp1.osuosl.org (Postfix) with ESMTPS id 6558A82DD9 for ; Wed, 27 Apr 2022 05:56:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1651039003; 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=9qeULQ41fQcQFOy0CY9Heuj/JvDE2+huvj1l00MURAI=; b=RCRhi63AqEx1FsWFWu06iq9gX20Eh9JvlqOJijWV/OcSQVQtIN4sQgLGG4eM4vQyLkTyMW YNX4eV33qAdWG/ey7NsoeCXwh0QMrwyWfXsB/jLYkdZbU7l7JbVs9f36jepgMWW0mi7eik tudeq28HUFqVo3k+jUA3eu2m77EkI+w= Received: from mail-pl1-f200.google.com (mail-pl1-f200.google.com [209.85.214.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-86-VSZIo8Y3PzCEL3ooJSR2SA-1; Wed, 27 Apr 2022 01:56:42 -0400 X-MC-Unique: VSZIo8Y3PzCEL3ooJSR2SA-1 Received: by mail-pl1-f200.google.com with SMTP id bj12-20020a170902850c00b0015adf30aaccso504910plb.15 for ; Tue, 26 Apr 2022 22:56:42 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:mime-version:user-agent:subject :content-language:to:cc:references:from:in-reply-to :content-transfer-encoding; bh=9qeULQ41fQcQFOy0CY9Heuj/JvDE2+huvj1l00MURAI=; b=CfLiHjh7fzTfIgmBIOVa29t0LE0IdH4lQx/09RjOR1b/630s75ky3xDmQmX/pQ5T4i LpR7KqGBpzQV1pslduLu9Y3Kkg5idn0C8r2fX1AS25mMs1fTEXGJwfPMSo8BvnpbVDHJ n/vhbFfS286Bmze5d+OJfMITRJ4Z1YYLxz4swom3ATYzzYxRmB0rD3LaZBfs4sNDQ7s2 HqEcPRjkhoZ6o1txj+nfIKEYM3yHxxq4dahUteU4V1ADldHFQ1iQ54yjnr7inlwS/UfG dGq/Kdjg8YKNm1QpSjSuTWqavKdfprtK9HlWt/uvyI9rjJ8ZueZsjjuKgov+rXdalzb2 nTsw== X-Gm-Message-State: AOAM530dxXRD+QoEuB6/GIu7Vi5nTnyRVBK+FF0VJ3s8QquViPaHfEPJ uG/JrQy2puAKiAXTFjjn/DTeiLD9Fi+agKDcBY1M9Rn1qJwg6KHf7EpxL1/jsOdOE3iorif5sy+ pvAwpCS//vDB9g3hroy+2GH11LFJ+UnZIhLoImiZkJg== X-Received: by 2002:a62:b60f:0:b0:508:2a61:2c8b with SMTP id j15-20020a62b60f000000b005082a612c8bmr28370677pff.2.1651039001298; Tue, 26 Apr 2022 22:56:41 -0700 (PDT) X-Google-Smtp-Source: ABdhPJwiiea0IwzZ22wAsh+sUDv5wKE8S6Fn4TlE5ivWn54gAuceV6BckQLQRjvue0imRQT6365j+g== X-Received: by 2002:a62:b60f:0:b0:508:2a61:2c8b with SMTP id j15-20020a62b60f000000b005082a612c8bmr28370650pff.2.1651039000929; Tue, 26 Apr 2022 22:56:40 -0700 (PDT) Received: from [10.72.12.60] ([209.132.188.80]) by smtp.gmail.com with ESMTPSA id 16-20020a621410000000b0050aca5f79f5sm17592732pfu.97.2022.04.26.22.56.38 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 26 Apr 2022 22:56:40 -0700 (PDT) Message-ID: Date: Wed, 27 Apr 2022 13:56:36 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.8.1 Subject: Re: [PATCH V2] vDPA/ifcvf: allow userspace to suspend a queue To: Zhu Lingshan , mst@redhat.com References: <20220424113321.7176-1-lingshan.zhu@intel.com> From: Jason Wang In-Reply-To: <20220424113321.7176-1-lingshan.zhu@intel.com> 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 Content-Language: en-US Cc: netdev@vger.kernel.org, virtualization@lists.linux-foundation.org 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-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" CuWcqCAyMDIyLzQvMjQgMTk6MzMsIFpodSBMaW5nc2hhbiDlhpnpgZM6Cj4gRm9ybWVybHksIGlm Y3ZmIGRyaXZlciBoYXMgaW1wbGVtZW50ZWQgYSBsYXp5LWluaXRpYWxpemF0aW9uIG1lY2hhbmlz bQo+IGZvciB0aGUgdmlydHF1ZXVlcywgaXQgd291bGQgc3RvcmUgYWxsIHZpcnRxdWV1ZSBjb25m aWcgZmllbGRzIHRoYXQKPiBwYXNzZWQgZG93biBmcm9tIHRoZSB1c2Vyc3BhY2UsIHRoZW4gbG9h ZCB0aGVtIHRvIHRoZSB2aXJ0cXVldWVzIGFuZAo+IGVuYWJsZSB0aGUgcXVldWVzIHVwb24gRFJJ VkVSX09LLgo+Cj4gVG8gYWxsb3cgdGhlIHVzZXJzcGFjZSB0byBzdXNwZW5kIGEgdmlydHF1ZXVl LAo+IHRoaXMgY29tbWl0IHBhc3NlcyBxdWV1ZV9lbmFibGUgdG8gdGhlIHZpcnRxdWV1ZSBkaXJl Y3RseSB0aHJvdWdoCj4gc2V0X3ZxX3JlYWR5KCkuCj4KPiBUaGlzIGZlYXR1cmUgcmVxdWlyZXMg YW5kIHRoaXMgY29tbWl0cyBpbXBsZW1lbnRpbmcgYWxsIHZpcnRxdWV1ZQo+IG9wcyhzZXRfdnFf YWRkciwgc2V0X3ZxX251bSBhbmQgc2V0X3ZxX3JlYWR5KSB0byB0YWtlIGltbWVkaWF0ZQo+IGFj dGlvbnMgdGhhbiBsYXp5LWluaXRpYWxpemF0aW9uLCBzbyBpZmN2Zl9od19lbmFibGUoKSBpcyBy ZXRpcmVkLgo+Cj4gc2V0X2ZlYXR1cmVzKCkgc2hvdWxkIHRha2UgaW1tZWRpYXRlIGFjdGlvbnMg YXMgd2VsbC4KPgo+IGlmY3ZmX2FkZF9zdGF0dXMoKSBpcyByZXRpZXJkIGJlY2F1c2Ugd2Ugc2hv dWxkIG5vdCBhZGQKPiBzdGF0dXMgbGlrZSBGRUFUVVJFU19PSyBieSBpZmN2ZidzIGRlY2lzaW9u LCB0aGlzIGRyaXZlciBzaG91bGQKPiBvbmx5IHNldCBkZXZpY2Ugc3RhdHVzIHVwb24gdmRwYV9v cHMuc2V0X3N0YXR1cygpCj4KPiBUbyBhdm9pZCBsb3NpbmcgdmlydHF1ZXVlIGNvbmZpZ3VyYXRp b25zIGNhdXNlZCBieSBtdWx0aXBsZQo+IHJvdW5kcyBvZiByZXNldCgpLCB0aGlzIGNvbW1pdCBh bHNvIHJlZmFjdG9ycyB0aGVkIGV2aWNlIHJlc2V0Cj4gcm91dGluZSwgbm93IGl0IHNpbXBseSBy ZXNldCB0aGUgY29uZmlnIGhhbmRsZXIgYW5kIHRoZSB2aXJ0cXVldWVzLAo+IGFuZCBvbmx5IG9u Y2UgZGV2aWNlLXJlc2V0KCkuCgoKSXQgbG9va3MgbGlrZSB0aGUgcGF0Y2ggdHJpZXMgdG8gZG8g dG9vIG1hbnkgdGhpbmdzIGF0IG9uZSBydW4uIEknZCAKc3VnZ2VzdCB0byBzcGxpdCB0aGVtOgoK CjEpIG9uLXRoZS1mbHkgc2V0IHZpYSBzZXRfdnFfcmVhZHkoKSwgYnV0IEkgZG9uJ3Qgc2VlIGEg cmVhc29uIHdoeSB3ZSAKbmVlZCB0byBjaGFuZ2Ugb3RoZXIgbGF6eSBzdHVmZnMsIHNpbmNlIHNl dHRpbmcgcXVldWVfZW5hYmxlIHRvIDEgYmVmb3JlIApEUklWRVJfT0sgd29uJ3Qgc3RhcnQgdGhl IHZpcnRxdWV1ZSBhbnlob3cKMikgaWYgbmVjZXNzYXJ5LCBjb252ZXJ0aW5nIHRoZSBsYXp5IHN0 dWZmcwozKSB0aGUgc3luY2hvcm5pemVfaXJxKCkgZml4ZXMKNCkgb3RoZXIgc3R1ZmZzCgpUaGFu a3MKCgo+Cj4gU2lnbmVkLW9mZi1ieTogWmh1IExpbmdzaGFuIDxsaW5nc2hhbi56aHVAaW50ZWwu Y29tPgo+IC0tLQo+ICAgZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX2Jhc2UuYyB8IDE1MCArKysr KysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLQo+ICAgZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3Zm X2Jhc2UuaCB8ICAxNiArKy0tCj4gICBkcml2ZXJzL3ZkcGEvaWZjdmYvaWZjdmZfbWFpbi5jIHwg IDgxICsrKy0tLS0tLS0tLS0tLS0tCj4gICAzIGZpbGVzIGNoYW5nZWQsIDExMSBpbnNlcnRpb25z KCspLCAxMzYgZGVsZXRpb25zKC0pCj4KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZHBhL2lmY3Zm L2lmY3ZmX2Jhc2UuYyBiL2RyaXZlcnMvdmRwYS9pZmN2Zi9pZmN2Zl9iYXNlLmMKPiBpbmRleCA0 OGM0ZGFkYjBjN2MuLmJiYzkwMDdhNmYzNCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZkcGEvaWZj dmYvaWZjdmZfYmFzZS5jCj4gKysrIGIvZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX2Jhc2UuYwo+ IEBAIC0xNzksMjAgKzE3OSw3IEBAIHZvaWQgaWZjdmZfc2V0X3N0YXR1cyhzdHJ1Y3QgaWZjdmZf aHcgKmh3LCB1OCBzdGF0dXMpCj4gICAKPiAgIHZvaWQgaWZjdmZfcmVzZXQoc3RydWN0IGlmY3Zm X2h3ICpodykKPiAgIHsKPiAtCWh3LT5jb25maWdfY2IuY2FsbGJhY2sgPSBOVUxMOwo+IC0JaHct PmNvbmZpZ19jYi5wcml2YXRlID0gTlVMTDsKPiAtCj4gICAJaWZjdmZfc2V0X3N0YXR1cyhodywg MCk7Cj4gLQkvKiBmbHVzaCBzZXRfc3RhdHVzLCBtYWtlIHN1cmUgVkYgaXMgc3RvcHBlZCwgcmVz ZXQgKi8KPiAtCWlmY3ZmX2dldF9zdGF0dXMoaHcpOwo+IC19Cj4gLQo+IC1zdGF0aWMgdm9pZCBp ZmN2Zl9hZGRfc3RhdHVzKHN0cnVjdCBpZmN2Zl9odyAqaHcsIHU4IHN0YXR1cykKPiAtewo+IC0J aWYgKHN0YXR1cyAhPSAwKQo+IC0JCXN0YXR1cyB8PSBpZmN2Zl9nZXRfc3RhdHVzKGh3KTsKPiAt Cj4gLQlpZmN2Zl9zZXRfc3RhdHVzKGh3LCBzdGF0dXMpOwo+ICAgCWlmY3ZmX2dldF9zdGF0dXMo aHcpOwo+ICAgfQo+ICAgCj4gQEAgLTIxMyw3ICsyMDAsNyBAQCB1NjQgaWZjdmZfZ2V0X2h3X2Zl YXR1cmVzKHN0cnVjdCBpZmN2Zl9odyAqaHcpCj4gICAJcmV0dXJuIGZlYXR1cmVzOwo+ICAgfQo+ ICAgCj4gLXU2NCBpZmN2Zl9nZXRfZmVhdHVyZXMoc3RydWN0IGlmY3ZmX2h3ICpodykKPiArdTY0 IGlmY3ZmX2dldF9kZXZpY2VfZmVhdHVyZXMoc3RydWN0IGlmY3ZmX2h3ICpodykKPiAgIHsKPiAg IAlyZXR1cm4gaHctPmh3X2ZlYXR1cmVzOwo+ICAgfQo+IEBAIC0yODAsNyArMjY3LDcgQEAgdm9p ZCBpZmN2Zl93cml0ZV9kZXZfY29uZmlnKHN0cnVjdCBpZmN2Zl9odyAqaHcsIHU2NCBvZmZzZXQs Cj4gICAJCXZwX2lvd3JpdGU4KCpwKyssIGh3LT5kZXZfY2ZnICsgb2Zmc2V0ICsgaSk7Cj4gICB9 Cj4gICAKPiAtc3RhdGljIHZvaWQgaWZjdmZfc2V0X2ZlYXR1cmVzKHN0cnVjdCBpZmN2Zl9odyAq aHcsIHU2NCBmZWF0dXJlcykKPiArdm9pZCBpZmN2Zl9zZXRfZmVhdHVyZXMoc3RydWN0IGlmY3Zm X2h3ICpodywgdTY0IGZlYXR1cmVzKQo+ICAgewo+ICAgCXN0cnVjdCB2aXJ0aW9fcGNpX2NvbW1v bl9jZmcgX19pb21lbSAqY2ZnID0gaHctPmNvbW1vbl9jZmc7Cj4gICAKPiBAQCAtMjg5LDIyICsy NzYsMjIgQEAgc3RhdGljIHZvaWQgaWZjdmZfc2V0X2ZlYXR1cmVzKHN0cnVjdCBpZmN2Zl9odyAq aHcsIHU2NCBmZWF0dXJlcykKPiAgIAo+ICAgCXZwX2lvd3JpdGUzMigxLCAmY2ZnLT5ndWVzdF9m ZWF0dXJlX3NlbGVjdCk7Cj4gICAJdnBfaW93cml0ZTMyKGZlYXR1cmVzID4+IDMyLCAmY2ZnLT5n dWVzdF9mZWF0dXJlKTsKPiArCj4gKwl2cF9pb3JlYWQzMigmY2ZnLT5ndWVzdF9mZWF0dXJlKTsK PiAgIH0KPiAgIAo+IC1zdGF0aWMgaW50IGlmY3ZmX2NvbmZpZ19mZWF0dXJlcyhzdHJ1Y3QgaWZj dmZfaHcgKmh3KQo+ICt1NjQgaWZjdmZfZ2V0X2ZlYXR1cmVzKHN0cnVjdCBpZmN2Zl9odyAqaHcp Cj4gICB7Cj4gLQlzdHJ1Y3QgaWZjdmZfYWRhcHRlciAqaWZjdmY7Cj4gKwlzdHJ1Y3QgdmlydGlv X3BjaV9jb21tb25fY2ZnIF9faW9tZW0gKmNmZyA9IGh3LT5jb21tb25fY2ZnOwo+ICsJdTY0IGZl YXR1cmVzOwo+ICAgCj4gLQlpZmN2ZiA9IHZmX3RvX2FkYXB0ZXIoaHcpOwo+IC0JaWZjdmZfc2V0 X2ZlYXR1cmVzKGh3LCBody0+cmVxX2ZlYXR1cmVzKTsKPiAtCWlmY3ZmX2FkZF9zdGF0dXMoaHcs IFZJUlRJT19DT05GSUdfU19GRUFUVVJFU19PSyk7Cj4gKwl2cF9pb3dyaXRlMzIoMCwgJmNmZy0+ ZGV2aWNlX2ZlYXR1cmVfc2VsZWN0KTsKPiArCWZlYXR1cmVzID0gdnBfaW9yZWFkMzIoJmNmZy0+ ZGV2aWNlX2ZlYXR1cmUpOwo+ICAgCj4gLQlpZiAoIShpZmN2Zl9nZXRfc3RhdHVzKGh3KSAmIFZJ UlRJT19DT05GSUdfU19GRUFUVVJFU19PSykpIHsKPiAtCQlJRkNWRl9FUlIoaWZjdmYtPnBkZXYs ICJGYWlsZWQgdG8gc2V0IEZFQVRVUkVTX09LIHN0YXR1c1xuIik7Cj4gLQkJcmV0dXJuIC1FSU87 Cj4gLQl9Cj4gKwl2cF9pb3dyaXRlMzIoMSwgJmNmZy0+ZGV2aWNlX2ZlYXR1cmVfc2VsZWN0KTsK PiArCWZlYXR1cmVzIHw9ICgodTY0KXZwX2lvcmVhZDMyKCZjZmctPmd1ZXN0X2ZlYXR1cmUpIDw8 IDMyKTsKPiAgIAo+IC0JcmV0dXJuIDA7Cj4gKwlyZXR1cm4gZmVhdHVyZXM7Cj4gICB9Cj4gICAK PiAgIHUxNiBpZmN2Zl9nZXRfdnFfc3RhdGUoc3RydWN0IGlmY3ZmX2h3ICpodywgdTE2IHFpZCkK PiBAQCAtMzMxLDY4ICszMTgsMTExIEBAIGludCBpZmN2Zl9zZXRfdnFfc3RhdGUoc3RydWN0IGlm Y3ZmX2h3ICpodywgdTE2IHFpZCwgdTE2IG51bSkKPiAgIAlpZmN2Zl9sbSA9IChzdHJ1Y3QgaWZj dmZfbG1fY2ZnIF9faW9tZW0gKilody0+bG1fY2ZnOwo+ICAgCXFfcGFpcl9pZCA9IHFpZCAvIGh3 LT5ucl92cmluZzsKPiAgIAlhdmFpbF9pZHhfYWRkciA9ICZpZmN2Zl9sbS0+dnJpbmdfbG1fY2Zn W3FfcGFpcl9pZF0uaWR4X2FkZHJbcWlkICUgMl07Cj4gLQlody0+dnJpbmdbcWlkXS5sYXN0X2F2 YWlsX2lkeCA9IG51bTsKPiAgIAl2cF9pb3dyaXRlMTYobnVtLCBhdmFpbF9pZHhfYWRkcik7Cj4g ICAKPiAgIAlyZXR1cm4gMDsKPiAgIH0KPiAgIAo+IC1zdGF0aWMgaW50IGlmY3ZmX2h3X2VuYWJs ZShzdHJ1Y3QgaWZjdmZfaHcgKmh3KQo+ICt2b2lkIGlmY3ZmX3NldF92cV9udW0oc3RydWN0IGlm Y3ZmX2h3ICpodywgdTE2IHFpZCwgdTMyIG51bSkKPiAgIHsKPiAtCXN0cnVjdCB2aXJ0aW9fcGNp X2NvbW1vbl9jZmcgX19pb21lbSAqY2ZnOwo+IC0JdTMyIGk7Cj4gKwlzdHJ1Y3QgdmlydGlvX3Bj aV9jb21tb25fY2ZnIF9faW9tZW0gKmNmZyA9IGh3LT5jb21tb25fY2ZnOwo+ICAgCj4gLQljZmcg PSBody0+Y29tbW9uX2NmZzsKPiAtCWZvciAoaSA9IDA7IGkgPCBody0+bnJfdnJpbmc7IGkrKykg ewo+IC0JCWlmICghaHctPnZyaW5nW2ldLnJlYWR5KQo+IC0JCQlicmVhazsKPiArCXZwX2lvd3Jp dGUxNihxaWQsICZjZmctPnF1ZXVlX3NlbGVjdCk7Cj4gKwl2cF9pb3dyaXRlMTYobnVtLCAmY2Zn LT5xdWV1ZV9zaXplKTsKPiArfQo+ICAgCj4gLQkJdnBfaW93cml0ZTE2KGksICZjZmctPnF1ZXVl X3NlbGVjdCk7Cj4gLQkJdnBfaW93cml0ZTY0X3R3b3BhcnQoaHctPnZyaW5nW2ldLmRlc2MsICZj ZmctPnF1ZXVlX2Rlc2NfbG8sCj4gLQkJCQkgICAgICZjZmctPnF1ZXVlX2Rlc2NfaGkpOwo+IC0J CXZwX2lvd3JpdGU2NF90d29wYXJ0KGh3LT52cmluZ1tpXS5hdmFpbCwgJmNmZy0+cXVldWVfYXZh aWxfbG8sCj4gLQkJCQkgICAgICAmY2ZnLT5xdWV1ZV9hdmFpbF9oaSk7Cj4gLQkJdnBfaW93cml0 ZTY0X3R3b3BhcnQoaHctPnZyaW5nW2ldLnVzZWQsICZjZmctPnF1ZXVlX3VzZWRfbG8sCj4gLQkJ CQkgICAgICZjZmctPnF1ZXVlX3VzZWRfaGkpOwo+IC0JCXZwX2lvd3JpdGUxNihody0+dnJpbmdb aV0uc2l6ZSwgJmNmZy0+cXVldWVfc2l6ZSk7Cj4gLQkJaWZjdmZfc2V0X3ZxX3N0YXRlKGh3LCBp LCBody0+dnJpbmdbaV0ubGFzdF9hdmFpbF9pZHgpOwo+IC0JCXZwX2lvd3JpdGUxNigxLCAmY2Zn LT5xdWV1ZV9lbmFibGUpOwo+IC0JfQo+ICtpbnQgaWZjdmZfc2V0X3ZxX2FkZHJlc3Moc3RydWN0 IGlmY3ZmX2h3ICpodywgdTE2IHFpZCwgdTY0IGRlc2NfYXJlYSwKPiArCQkJIHU2NCBkcml2ZXJf YXJlYSwgdTY0IGRldmljZV9hcmVhKQo+ICt7Cj4gKwlzdHJ1Y3QgdmlydGlvX3BjaV9jb21tb25f Y2ZnIF9faW9tZW0gKmNmZyA9IGh3LT5jb21tb25fY2ZnOwo+ICsKPiArCXZwX2lvd3JpdGUxNihx aWQsICZjZmctPnF1ZXVlX3NlbGVjdCk7Cj4gKwl2cF9pb3dyaXRlNjRfdHdvcGFydChkZXNjX2Fy ZWEsICZjZmctPnF1ZXVlX2Rlc2NfbG8sCj4gKwkJCSAgICAgJmNmZy0+cXVldWVfZGVzY19oaSk7 Cj4gKwl2cF9pb3dyaXRlNjRfdHdvcGFydChkcml2ZXJfYXJlYSwgJmNmZy0+cXVldWVfYXZhaWxf bG8sCj4gKwkJCSAgICAgJmNmZy0+cXVldWVfYXZhaWxfaGkpOwo+ICsJdnBfaW93cml0ZTY0X3R3 b3BhcnQoZGV2aWNlX2FyZWEsICZjZmctPnF1ZXVlX3VzZWRfbG8sCj4gKwkJCSAgICAgJmNmZy0+ cXVldWVfdXNlZF9oaSk7Cj4gICAKPiAgIAlyZXR1cm4gMDsKPiAgIH0KPiAgIAo+IC1zdGF0aWMg dm9pZCBpZmN2Zl9od19kaXNhYmxlKHN0cnVjdCBpZmN2Zl9odyAqaHcpCj4gK3ZvaWQgaWZjdmZf c2V0X3ZxX3JlYWR5KHN0cnVjdCBpZmN2Zl9odyAqaHcsIHUxNiBxaWQsIGJvb2wgcmVhZHkpCj4g ICB7Cj4gLQl1MzIgaTsKPiArCXN0cnVjdCB2aXJ0aW9fcGNpX2NvbW1vbl9jZmcgX19pb21lbSAq Y2ZnID0gaHctPmNvbW1vbl9jZmc7Cj4gKwo+ICsJdnBfaW93cml0ZTE2KHFpZCwgJmNmZy0+cXVl dWVfc2VsZWN0KTsKPiArCS8qIHdyaXRlIDAgdG8gcXVldWVfZW5hYmxlIHdpbGwgc3VzcGVuZCBh IHF1ZXVlKi8KPiArCXZwX2lvd3JpdGUxNihyZWFkeSwgJmNmZy0+cXVldWVfZW5hYmxlKTsKPiAr fQo+ICsKPiArYm9vbCBpZmN2Zl9nZXRfdnFfcmVhZHkoc3RydWN0IGlmY3ZmX2h3ICpodywgdTE2 IHFpZCkKPiArewo+ICsJc3RydWN0IHZpcnRpb19wY2lfY29tbW9uX2NmZyBfX2lvbWVtICpjZmcg PSBody0+Y29tbW9uX2NmZzsKPiArCWJvb2wgcXVldWVfZW5hYmxlOwo+ICsKPiArCXZwX2lvd3Jp dGUxNihxaWQsICZjZmctPnF1ZXVlX3NlbGVjdCk7Cj4gKwlxdWV1ZV9lbmFibGUgPSB2cF9pb3Jl YWQxNigmY2ZnLT5xdWV1ZV9lbmFibGUpOwo+ICsKPiArCXJldHVybiAoYm9vbClxdWV1ZV9lbmFi bGU7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHN5bmNocm9uaXplX3Blcl92cV9pcnEoc3RydWN0 IGlmY3ZmX2h3ICpodykKPiArewo+ICsJaW50IGk7Cj4gICAKPiAtCWlmY3ZmX3NldF9jb25maWdf dmVjdG9yKGh3LCBWSVJUSU9fTVNJX05PX1ZFQ1RPUik7Cj4gICAJZm9yIChpID0gMDsgaSA8IGh3 LT5ucl92cmluZzsgaSsrKSB7Cj4gLQkJaWZjdmZfc2V0X3ZxX3ZlY3RvcihodywgaSwgVklSVElP X01TSV9OT19WRUNUT1IpOwo+ICsJCWlmIChody0+dnJpbmdbaV0uaXJxICE9IC1FSU5WQUwpCj4g KwkJCXN5bmNocm9uaXplX2lycShody0+dnJpbmdbaV0uaXJxKTsKPiAgIAl9Cj4gICB9Cj4gICAK PiAtaW50IGlmY3ZmX3N0YXJ0X2h3KHN0cnVjdCBpZmN2Zl9odyAqaHcpCj4gK3N0YXRpYyB2b2lk IHN5bmNocm9uaXplX3Zxc19yZXVzZWRfaXJxKHN0cnVjdCBpZmN2Zl9odyAqaHcpCj4gICB7Cj4g LQlpZmN2Zl9yZXNldChodyk7Cj4gLQlpZmN2Zl9hZGRfc3RhdHVzKGh3LCBWSVJUSU9fQ09ORklH X1NfQUNLTk9XTEVER0UpOwo+IC0JaWZjdmZfYWRkX3N0YXR1cyhodywgVklSVElPX0NPTkZJR19T X0RSSVZFUik7Cj4gKwlpZiAoaHctPnZxc19yZXVzZWRfaXJxICE9IC1FSU5WQUwpCj4gKwkJc3lu Y2hyb25pemVfaXJxKGh3LT52cXNfcmV1c2VkX2lycSk7Cj4gK30KPiAgIAo+IC0JaWYgKGlmY3Zm X2NvbmZpZ19mZWF0dXJlcyhodykgPCAwKQo+IC0JCXJldHVybiAtRUlOVkFMOwo+ICtzdGF0aWMg dm9pZCBzeW5jaHJvbml6ZV92cV9pcnEoc3RydWN0IGlmY3ZmX2h3ICpodykKPiArewo+ICsJdTgg c3RhdHVzID0gaHctPm1zaXhfdmVjdG9yX3N0YXR1czsKPiAgIAo+IC0JaWYgKGlmY3ZmX2h3X2Vu YWJsZShodykgPCAwKQo+IC0JCXJldHVybiAtRUlOVkFMOwo+ICsJaWYgKHN0YXR1cyA9PSBNU0lY X1ZFQ1RPUl9QRVJfVlFfQU5EX0NPTkZJRykKPiArCQlzeW5jaHJvbml6ZV9wZXJfdnFfaXJxKGh3 KTsKPiArCWVsc2UKPiArCQlzeW5jaHJvbml6ZV92cXNfcmV1c2VkX2lycShodyk7Cj4gK30KPiAg IAo+IC0JaWZjdmZfYWRkX3N0YXR1cyhodywgVklSVElPX0NPTkZJR19TX0RSSVZFUl9PSyk7Cj4g K3N0YXRpYyB2b2lkIHN5bmNocm9uaXplX2NvbmZpZ19pcnEoc3RydWN0IGlmY3ZmX2h3ICpodykK PiArewo+ICsJaWYgKGh3LT5jb25maWdfaXJxICE9IC1FSU5WQUwpCj4gKwkJc3luY2hyb25pemVf aXJxKGh3LT5jb25maWdfaXJxKTsKPiArfQo+ICAgCj4gLQlyZXR1cm4gMDsKPiArc3RhdGljIHZv aWQgaWZjdmZfcmVzZXRfdnJpbmcoc3RydWN0IGlmY3ZmX2h3ICpodykKPiArewo+ICsJaW50IGk7 Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IGh3LT5ucl92cmluZzsgaSsrKSB7Cj4gKwkJc3luY2hy b25pemVfdnFfaXJxKGh3KTsKPiArCQlody0+dnJpbmdbaV0uY2IuY2FsbGJhY2sgPSBOVUxMOwo+ ICsJCWh3LT52cmluZ1tpXS5jYi5wcml2YXRlID0gTlVMTDsKPiArCQlpZmN2Zl9zZXRfdnFfdmVj dG9yKGh3LCBpLCBWSVJUSU9fTVNJX05PX1ZFQ1RPUik7Cj4gKwl9Cj4gK30KPiArCj4gK3N0YXRp YyB2b2lkIGlmY3ZmX3Jlc2V0X2NvbmZpZ19oYW5kbGVyKHN0cnVjdCBpZmN2Zl9odyAqaHcpCj4g K3sKPiArCXN5bmNocm9uaXplX2NvbmZpZ19pcnEoaHcpOwo+ICsJaHctPmNvbmZpZ19jYi5jYWxs YmFjayA9IE5VTEw7Cj4gKwlody0+Y29uZmlnX2NiLnByaXZhdGUgPSBOVUxMOwo+ICsJaWZjdmZf c2V0X2NvbmZpZ192ZWN0b3IoaHcsIFZJUlRJT19NU0lfTk9fVkVDVE9SKTsKPiAgIH0KPiAgIAo+ ICAgdm9pZCBpZmN2Zl9zdG9wX2h3KHN0cnVjdCBpZmN2Zl9odyAqaHcpCj4gICB7Cj4gLQlpZmN2 Zl9od19kaXNhYmxlKGh3KTsKPiAtCWlmY3ZmX3Jlc2V0KGh3KTsKPiArCWlmY3ZmX3Jlc2V0X3Zy aW5nKGh3KTsKPiArCWlmY3ZmX3Jlc2V0X2NvbmZpZ19oYW5kbGVyKGh3KTsKPiAgIH0KPiAgIAo+ ICAgdm9pZCBpZmN2Zl9ub3RpZnlfcXVldWUoc3RydWN0IGlmY3ZmX2h3ICpodywgdTE2IHFpZCkK PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX2Jhc2UuaCBiL2RyaXZlcnMv dmRwYS9pZmN2Zi9pZmN2Zl9iYXNlLmgKPiBpbmRleCAxMTViNjFmNDkyNGIuLmYzZGNlMGQ3OTVj YiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZkcGEvaWZjdmYvaWZjdmZfYmFzZS5oCj4gKysrIGIv ZHJpdmVycy92ZHBhL2lmY3ZmL2lmY3ZmX2Jhc2UuaAo+IEBAIC00OSwxMiArNDksNiBAQAo+ICAg I2RlZmluZSBNU0lYX1ZFQ1RPUl9ERVZfU0hBUkVECQkJMwo+ICAgCj4gICBzdHJ1Y3QgdnJpbmdf aW5mbyB7Cj4gLQl1NjQgZGVzYzsKPiAtCXU2NCBhdmFpbDsKPiAtCXU2NCB1c2VkOwo+IC0JdTE2 IHNpemU7Cj4gLQl1MTYgbGFzdF9hdmFpbF9pZHg7Cj4gLQlib29sIHJlYWR5Owo+ICAgCXZvaWQg X19pb21lbSAqbm90aWZ5X2FkZHI7Cj4gICAJcGh5c19hZGRyX3Qgbm90aWZ5X3BhOwo+ICAgCXUz MiBpcnE7Cj4gQEAgLTc2LDcgKzcwLDYgQEAgc3RydWN0IGlmY3ZmX2h3IHsKPiAgIAlwaHlzX2Fk ZHJfdCBub3RpZnlfYmFzZV9wYTsKPiAgIAl1MzIgbm90aWZ5X29mZl9tdWx0aXBsaWVyOwo+ICAg CXUzMiBkZXZfdHlwZTsKPiAtCXU2NCByZXFfZmVhdHVyZXM7Cj4gICAJdTY0IGh3X2ZlYXR1cmVz Owo+ICAgCXN0cnVjdCB2aXJ0aW9fcGNpX2NvbW1vbl9jZmcgX19pb21lbSAqY29tbW9uX2NmZzsK PiAgIAl2b2lkIF9faW9tZW0gKmRldl9jZmc7Cj4gQEAgLTEyMyw3ICsxMTYsNyBAQCB1OCBpZmN2 Zl9nZXRfc3RhdHVzKHN0cnVjdCBpZmN2Zl9odyAqaHcpOwo+ICAgdm9pZCBpZmN2Zl9zZXRfc3Rh dHVzKHN0cnVjdCBpZmN2Zl9odyAqaHcsIHU4IHN0YXR1cyk7Cj4gICB2b2lkIGlvX3dyaXRlNjRf dHdvcGFydCh1NjQgdmFsLCB1MzIgKmxvLCB1MzIgKmhpKTsKPiAgIHZvaWQgaWZjdmZfcmVzZXQo c3RydWN0IGlmY3ZmX2h3ICpodyk7Cj4gLXU2NCBpZmN2Zl9nZXRfZmVhdHVyZXMoc3RydWN0IGlm Y3ZmX2h3ICpodyk7Cj4gK3U2NCBpZmN2Zl9nZXRfZGV2aWNlX2ZlYXR1cmVzKHN0cnVjdCBpZmN2 Zl9odyAqaHcpOwo+ICAgdTY0IGlmY3ZmX2dldF9od19mZWF0dXJlcyhzdHJ1Y3QgaWZjdmZfaHcg Kmh3KTsKPiAgIGludCBpZmN2Zl92ZXJpZnlfbWluX2ZlYXR1cmVzKHN0cnVjdCBpZmN2Zl9odyAq aHcsIHU2NCBmZWF0dXJlcyk7Cj4gICB1MTYgaWZjdmZfZ2V0X3ZxX3N0YXRlKHN0cnVjdCBpZmN2 Zl9odyAqaHcsIHUxNiBxaWQpOwo+IEBAIC0xMzEsNiArMTI0LDEzIEBAIGludCBpZmN2Zl9zZXRf dnFfc3RhdGUoc3RydWN0IGlmY3ZmX2h3ICpodywgdTE2IHFpZCwgdTE2IG51bSk7Cj4gICBzdHJ1 Y3QgaWZjdmZfYWRhcHRlciAqdmZfdG9fYWRhcHRlcihzdHJ1Y3QgaWZjdmZfaHcgKmh3KTsKPiAg IGludCBpZmN2Zl9wcm9iZWRfdmlydGlvX25ldChzdHJ1Y3QgaWZjdmZfaHcgKmh3KTsKPiAgIHUz MiBpZmN2Zl9nZXRfY29uZmlnX3NpemUoc3RydWN0IGlmY3ZmX2h3ICpodyk7Cj4gK2ludCBpZmN2 Zl9zZXRfdnFfYWRkcmVzcyhzdHJ1Y3QgaWZjdmZfaHcgKmh3LCB1MTYgcWlkLCB1NjQgZGVzY19h cmVhLAo+ICsJCQkgdTY0IGRyaXZlcl9hcmVhLCB1NjQgZGV2aWNlX2FyZWEpOwo+ICAgdTE2IGlm Y3ZmX3NldF92cV92ZWN0b3Ioc3RydWN0IGlmY3ZmX2h3ICpodywgdTE2IHFpZCwgaW50IHZlY3Rv cik7Cj4gICB1MTYgaWZjdmZfc2V0X2NvbmZpZ192ZWN0b3Ioc3RydWN0IGlmY3ZmX2h3ICpodywg aW50IHZlY3Rvcik7Cj4gK3ZvaWQgaWZjdmZfc2V0X3ZxX251bShzdHJ1Y3QgaWZjdmZfaHcgKmh3 LCB1MTYgcWlkLCB1MzIgbnVtKTsKPiArdm9pZCBpZmN2Zl9zZXRfdnFfcmVhZHkoc3RydWN0IGlm Y3ZmX2h3ICpodywgdTE2IHFpZCwgYm9vbCByZWFkeSk7Cj4gK2Jvb2wgaWZjdmZfZ2V0X3ZxX3Jl YWR5KHN0cnVjdCBpZmN2Zl9odyAqaHcsIHUxNiBxaWQpOwo+ICt2b2lkIGlmY3ZmX3NldF9mZWF0 dXJlcyhzdHJ1Y3QgaWZjdmZfaHcgKmh3LCB1NjQgZmVhdHVyZXMpOwo+ICt1NjQgaWZjdmZfZ2V0 X2ZlYXR1cmVzKHN0cnVjdCBpZmN2Zl9odyAqaHcpOwo+ICAgI2VuZGlmIC8qIF9JRkNWRl9IXyAq Lwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvaWZjdmYvaWZjdmZfbWFpbi5jIGIvZHJpdmVy cy92ZHBhL2lmY3ZmL2lmY3ZmX21haW4uYwo+IGluZGV4IDQzNjYzMjBmYjY4ZC4uMDI1N2JhOThj ZmZlIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvdmRwYS9pZmN2Zi9pZmN2Zl9tYWluLmMKPiArKysg Yi9kcml2ZXJzL3ZkcGEvaWZjdmYvaWZjdmZfbWFpbi5jCj4gQEAgLTM1OCw1MyArMzU4LDYgQEAg c3RhdGljIGludCBpZmN2Zl9yZXF1ZXN0X2lycShzdHJ1Y3QgaWZjdmZfYWRhcHRlciAqYWRhcHRl cikKPiAgIAlyZXR1cm4gMDsKPiAgIH0KPiAgIAo+IC1zdGF0aWMgaW50IGlmY3ZmX3N0YXJ0X2Rh dGFwYXRoKHZvaWQgKnByaXZhdGUpCj4gLXsKPiAtCXN0cnVjdCBpZmN2Zl9odyAqdmYgPSBpZmN2 Zl9wcml2YXRlX3RvX3ZmKHByaXZhdGUpOwo+IC0JdTggc3RhdHVzOwo+IC0JaW50IHJldDsKPiAt Cj4gLQlyZXQgPSBpZmN2Zl9zdGFydF9odyh2Zik7Cj4gLQlpZiAocmV0IDwgMCkgewo+IC0JCXN0 YXR1cyA9IGlmY3ZmX2dldF9zdGF0dXModmYpOwo+IC0JCXN0YXR1cyB8PSBWSVJUSU9fQ09ORklH X1NfRkFJTEVEOwo+IC0JCWlmY3ZmX3NldF9zdGF0dXModmYsIHN0YXR1cyk7Cj4gLQl9Cj4gLQo+ IC0JcmV0dXJuIHJldDsKPiAtfQo+IC0KPiAtc3RhdGljIGludCBpZmN2Zl9zdG9wX2RhdGFwYXRo KHZvaWQgKnByaXZhdGUpCj4gLXsKPiAtCXN0cnVjdCBpZmN2Zl9odyAqdmYgPSBpZmN2Zl9wcml2 YXRlX3RvX3ZmKHByaXZhdGUpOwo+IC0JaW50IGk7Cj4gLQo+IC0JZm9yIChpID0gMDsgaSA8IHZm LT5ucl92cmluZzsgaSsrKQo+IC0JCXZmLT52cmluZ1tpXS5jYi5jYWxsYmFjayA9IE5VTEw7Cj4g LQo+IC0JaWZjdmZfc3RvcF9odyh2Zik7Cj4gLQo+IC0JcmV0dXJuIDA7Cj4gLX0KPiAtCj4gLXN0 YXRpYyB2b2lkIGlmY3ZmX3Jlc2V0X3ZyaW5nKHN0cnVjdCBpZmN2Zl9hZGFwdGVyICphZGFwdGVy KQo+IC17Cj4gLQlzdHJ1Y3QgaWZjdmZfaHcgKnZmID0gaWZjdmZfcHJpdmF0ZV90b192ZihhZGFw dGVyKTsKPiAtCWludCBpOwo+IC0KPiAtCWZvciAoaSA9IDA7IGkgPCB2Zi0+bnJfdnJpbmc7IGkr Kykgewo+IC0JCXZmLT52cmluZ1tpXS5sYXN0X2F2YWlsX2lkeCA9IDA7Cj4gLQkJdmYtPnZyaW5n W2ldLmRlc2MgPSAwOwo+IC0JCXZmLT52cmluZ1tpXS5hdmFpbCA9IDA7Cj4gLQkJdmYtPnZyaW5n W2ldLnVzZWQgPSAwOwo+IC0JCXZmLT52cmluZ1tpXS5yZWFkeSA9IDA7Cj4gLQkJdmYtPnZyaW5n W2ldLmNiLmNhbGxiYWNrID0gTlVMTDsKPiAtCQl2Zi0+dnJpbmdbaV0uY2IucHJpdmF0ZSA9IE5V TEw7Cj4gLQl9Cj4gLQo+IC0JaWZjdmZfcmVzZXQodmYpOwo+IC19Cj4gLQo+ICAgc3RhdGljIHN0 cnVjdCBpZmN2Zl9hZGFwdGVyICp2ZHBhX3RvX2FkYXB0ZXIoc3RydWN0IHZkcGFfZGV2aWNlICp2 ZHBhX2RldikKPiAgIHsKPiAgIAlyZXR1cm4gY29udGFpbmVyX29mKHZkcGFfZGV2LCBzdHJ1Y3Qg aWZjdmZfYWRhcHRlciwgdmRwYSk7Cj4gQEAgLTQyNiw3ICszNzksNyBAQCBzdGF0aWMgdTY0IGlm Y3ZmX3ZkcGFfZ2V0X2RldmljZV9mZWF0dXJlcyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGFfZGV2 KQo+ICAgCXU2NCBmZWF0dXJlczsKPiAgIAo+ICAgCWlmICh0eXBlID09IFZJUlRJT19JRF9ORVQg fHwgdHlwZSA9PSBWSVJUSU9fSURfQkxPQ0spCj4gLQkJZmVhdHVyZXMgPSBpZmN2Zl9nZXRfZmVh dHVyZXModmYpOwo+ICsJCWZlYXR1cmVzID0gaWZjdmZfZ2V0X2RldmljZV9mZWF0dXJlcyh2Zik7 Cj4gICAJZWxzZSB7Cj4gICAJCWZlYXR1cmVzID0gMDsKPiAgIAkJSUZDVkZfRVJSKHBkZXYsICJW SVJUSU8gSUQgJXUgbm90IHN1cHBvcnRlZFxuIiwgdmYtPmRldl90eXBlKTsKPiBAQCAtNDQ0LDcg KzM5Nyw3IEBAIHN0YXRpYyBpbnQgaWZjdmZfdmRwYV9zZXRfZHJpdmVyX2ZlYXR1cmVzKHN0cnVj dCB2ZHBhX2RldmljZSAqdmRwYV9kZXYsIHU2NCBmZWF0Cj4gICAJaWYgKHJldCkKPiAgIAkJcmV0 dXJuIHJldDsKPiAgIAo+IC0JdmYtPnJlcV9mZWF0dXJlcyA9IGZlYXR1cmVzOwo+ICsJaWZjdmZf c2V0X2ZlYXR1cmVzKHZmLCBmZWF0dXJlcyk7Cj4gICAKPiAgIAlyZXR1cm4gMDsKPiAgIH0KPiBA QCAtNDUzLDcgKzQwNiw3IEBAIHN0YXRpYyB1NjQgaWZjdmZfdmRwYV9nZXRfZHJpdmVyX2ZlYXR1 cmVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYV9kZXYpCj4gICB7Cj4gICAJc3RydWN0IGlmY3Zm X2h3ICp2ZiA9IHZkcGFfdG9fdmYodmRwYV9kZXYpOwo+ICAgCj4gLQlyZXR1cm4gdmYtPnJlcV9m ZWF0dXJlczsKPiArCXJldHVybiBpZmN2Zl9nZXRfZmVhdHVyZXModmYpOwo+ICAgfQo+ICAgCj4g ICBzdGF0aWMgdTggaWZjdmZfdmRwYV9nZXRfc3RhdHVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRw YV9kZXYpCj4gQEAgLTQ4NiwxMSArNDM5LDYgQEAgc3RhdGljIHZvaWQgaWZjdmZfdmRwYV9zZXRf c3RhdHVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYV9kZXYsIHU4IHN0YXR1cykKPiAgIAkJCWlm Y3ZmX3NldF9zdGF0dXModmYsIHN0YXR1cyk7Cj4gICAJCQlyZXR1cm47Cj4gICAJCX0KPiAtCj4g LQkJaWYgKGlmY3ZmX3N0YXJ0X2RhdGFwYXRoKGFkYXB0ZXIpIDwgMCkKPiAtCQkJSUZDVkZfRVJS KGFkYXB0ZXItPnBkZXYsCj4gLQkJCQkgICJGYWlsZWQgdG8gc2V0IGlmY3ZmIHZkcGEgIHN0YXR1 cyAldVxuIiwKPiAtCQkJCSAgc3RhdHVzKTsKPiAgIAl9Cj4gICAKPiAgIAlpZmN2Zl9zZXRfc3Rh dHVzKHZmLCBzdGF0dXMpOwo+IEBAIC01MDksMTIgKzQ1NywxMCBAQCBzdGF0aWMgaW50IGlmY3Zm X3ZkcGFfcmVzZXQoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhX2RldikKPiAgIAlpZiAoc3RhdHVz X29sZCA9PSAwKQo+ICAgCQlyZXR1cm4gMDsKPiAgIAo+IC0JaWYgKHN0YXR1c19vbGQgJiBWSVJU SU9fQ09ORklHX1NfRFJJVkVSX09LKSB7Cj4gLQkJaWZjdmZfc3RvcF9kYXRhcGF0aChhZGFwdGVy KTsKPiAtCQlpZmN2Zl9mcmVlX2lycShhZGFwdGVyKTsKPiAtCX0KPiArCWlmY3ZmX3N0b3BfaHco dmYpOwo+ICsJaWZjdmZfZnJlZV9pcnEoYWRhcHRlcik7Cj4gICAKPiAtCWlmY3ZmX3Jlc2V0X3Zy aW5nKGFkYXB0ZXIpOwo+ICsJaWZjdmZfcmVzZXQodmYpOwo+ICAgCj4gICAJcmV0dXJuIDA7Cj4g ICB9Cj4gQEAgLTU1NCwxNCArNTAwLDE3IEBAIHN0YXRpYyB2b2lkIGlmY3ZmX3ZkcGFfc2V0X3Zx X3JlYWR5KHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYV9kZXYsCj4gICB7Cj4gICAJc3RydWN0IGlm Y3ZmX2h3ICp2ZiA9IHZkcGFfdG9fdmYodmRwYV9kZXYpOwo+ICAgCj4gLQl2Zi0+dnJpbmdbcWlk XS5yZWFkeSA9IHJlYWR5Owo+ICsJaWZjdmZfc2V0X3ZxX3JlYWR5KHZmLCBxaWQsIHJlYWR5KTsK PiAgIH0KPiAgIAo+ICAgc3RhdGljIGJvb2wgaWZjdmZfdmRwYV9nZXRfdnFfcmVhZHkoc3RydWN0 IHZkcGFfZGV2aWNlICp2ZHBhX2RldiwgdTE2IHFpZCkKPiAgIHsKPiAgIAlzdHJ1Y3QgaWZjdmZf aHcgKnZmID0gdmRwYV90b192Zih2ZHBhX2Rldik7Cj4gKwlib29sIHJlYWR5Owo+ICsKPiArCXJl YWR5ID0gaWZjdmZfZ2V0X3ZxX3JlYWR5KHZmLCBxaWQpOwo+ICAgCj4gLQlyZXR1cm4gdmYtPnZy aW5nW3FpZF0ucmVhZHk7Cj4gKwlyZXR1cm4gcmVhZHk7Cj4gICB9Cj4gICAKPiAgIHN0YXRpYyB2 b2lkIGlmY3ZmX3ZkcGFfc2V0X3ZxX251bShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGFfZGV2LCB1 MTYgcWlkLAo+IEBAIC01NjksNyArNTE4LDcgQEAgc3RhdGljIHZvaWQgaWZjdmZfdmRwYV9zZXRf dnFfbnVtKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYV9kZXYsIHUxNiBxaWQsCj4gICB7Cj4gICAJ c3RydWN0IGlmY3ZmX2h3ICp2ZiA9IHZkcGFfdG9fdmYodmRwYV9kZXYpOwo+ICAgCj4gLQl2Zi0+ dnJpbmdbcWlkXS5zaXplID0gbnVtOwo+ICsJaWZjdmZfc2V0X3ZxX251bSh2ZiwgcWlkLCBudW0p Owo+ICAgfQo+ICAgCj4gICBzdGF0aWMgaW50IGlmY3ZmX3ZkcGFfc2V0X3ZxX2FkZHJlc3Moc3Ry dWN0IHZkcGFfZGV2aWNlICp2ZHBhX2RldiwgdTE2IHFpZCwKPiBAQCAtNTc4LDExICs1MjcsNyBA QCBzdGF0aWMgaW50IGlmY3ZmX3ZkcGFfc2V0X3ZxX2FkZHJlc3Moc3RydWN0IHZkcGFfZGV2aWNl ICp2ZHBhX2RldiwgdTE2IHFpZCwKPiAgIHsKPiAgIAlzdHJ1Y3QgaWZjdmZfaHcgKnZmID0gdmRw YV90b192Zih2ZHBhX2Rldik7Cj4gICAKPiAtCXZmLT52cmluZ1txaWRdLmRlc2MgPSBkZXNjX2Fy ZWE7Cj4gLQl2Zi0+dnJpbmdbcWlkXS5hdmFpbCA9IGRyaXZlcl9hcmVhOwo+IC0JdmYtPnZyaW5n W3FpZF0udXNlZCA9IGRldmljZV9hcmVhOwo+IC0KPiAtCXJldHVybiAwOwo+ICsJcmV0dXJuIGlm Y3ZmX3NldF92cV9hZGRyZXNzKHZmLCBxaWQsIGRlc2NfYXJlYSwgZHJpdmVyX2FyZWEsIGRldmlj ZV9hcmVhKTsKPiAgIH0KPiAgIAo+ICAgc3RhdGljIHZvaWQgaWZjdmZfdmRwYV9raWNrX3ZxKHN0 cnVjdCB2ZHBhX2RldmljZSAqdmRwYV9kZXYsIHUxNiBxaWQpCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpWaXJ0dWFsaXphdGlvbiBtYWlsaW5nIGxpc3QK VmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5s aW51eGZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vdmlydHVhbGl6YXRpb24=