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=-9.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT 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 1C7A3C33C9E for ; Sat, 11 Jan 2020 03:44:27 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C2CB3206ED for ; Sat, 11 Jan 2020 03:44:26 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="d3HmNF+t" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728213AbgAKDoZ (ORCPT ); Fri, 10 Jan 2020 22:44:25 -0500 Received: from wout2-smtp.messagingengine.com ([64.147.123.25]:35189 "EHLO wout2-smtp.messagingengine.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728195AbgAKDoZ (ORCPT ); Fri, 10 Jan 2020 22:44:25 -0500 Received: from compute7.internal (compute7.nyi.internal [10.202.2.47]) by mailout.west.internal (Postfix) with ESMTP id 4E2E9482; Fri, 10 Jan 2020 22:44:23 -0500 (EST) Received: from mailfrontend1 ([10.202.2.162]) by compute7.internal (MEProxy); Fri, 10 Jan 2020 22:44:23 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:content-transfer-encoding:content-type :date:from:message-id:mime-version:subject:to:x-me-proxy :x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s=fm1; bh=6uIvn1 HcLzYl+j8NNQCQcaaAEZy0NhPLBJ6H1hgc4oQ=; b=d3HmNF+tZAqXdGHgMoOsm5 csPReTqgFRcVG5qAUr2JErqog6Bluu9GNaLurCXNzOAOOobmtz/Ye7x6tVJzhQSK 1HzSx21JZXyRvlipN32KTvcDqLiMP/hpK2wUqaFte27uXTpChagdIrG/ABQsjnxS eQuGJpNu1tf0ShIdg/tDreTORuBPEhDE96+xL4ujM7a+i/CzavZlXG5W06owGo4C hv5RDbLUKd1O2fZsMIL3a7GMt9Y0hQmFTl/Oy+He2pKfLrN8w638npJOHjWhsnSc pbTEMK6rYr4pOQ9kjQ41i0iSHd007j2eGYtLIeYfr0ZAel2yhNyB2UQ2RbIST/TA == X-ME-Sender: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedufedrvdeigedgieduucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmne cujfgurhephffvufffkffogggtohfgsehtkeertdertdejnecuhfhrohhmpeforghrvghk ucforghrtgiihihkohifshhkihdqifpkrhgvtghkihcuoehmrghrmhgrrhgvkhesihhnvh hishhisghlvghthhhinhhgshhlrggsrdgtohhmqeenucffohhmrghinhepmhgrrhhkmhgr ihhlrdhorhhgpdhinhhvihhsihgslhgvthhhihhnghhslhgrsgdrtghomhenucfkpheple durdeihedrfeegrdeffeenucfrrghrrghmpehmrghilhhfrhhomhepmhgrrhhmrghrvghk sehinhhvihhsihgslhgvthhhihhnghhslhgrsgdrtghomhenucevlhhushhtvghrufhiii gvpedt X-ME-Proxy: Received: from localhost.localdomain (ip5b412221.dynamic.kabel-deutschland.de [91.65.34.33]) by mail.messagingengine.com (Postfix) with ESMTPA id AB58580063; Fri, 10 Jan 2020 22:44:20 -0500 (EST) From: =?UTF-8?q?Marek=20Marczykowski-G=C3=B3recki?= To: xen-devel@lists.xenproject.org Cc: =?UTF-8?q?Marek=20Marczykowski-G=C3=B3recki?= , Jan Beulich , Simon Gaiser , Boris Ostrovsky , Juergen Gross , Stefano Stabellini , YueHaibing , linux-kernel@vger.kernel.org (open list) Subject: [PATCH v3] xen-pciback: optionally allow interrupt enable flag writes Date: Sat, 11 Jan 2020 04:43:31 +0100 Message-Id: <20200111034347.5270-1-marmarek@invisiblethingslab.com> X-Mailer: git-send-email 2.21.0 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Organization: Invisible Things Lab Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org QEMU running in a stubdom needs to be able to set INTX_DISABLE, and the MSI(-X) enable flags in the PCI config space. This adds an attribute 'allow_interrupt_control' which when set for a PCI device allows writes to this flag(s). The toolstack will need to set this for stubdoms. When enabled, guest (stubdomain) will be allowed to set relevant enable flags, but only one at a time - i.e. it refuses to enable more than one of INTx, MSI, MSI-X at a time. This functionality is needed only for config space access done by device model (stubdomain) serving a HVM with the actual PCI device. It is not necessary and unsafe to enable direct access to those bits for PV domain with the device attached. For PV domains, there are separate protocol messages (XEN_PCI_OP_{enable,disable}_{msi,msix}) for this purpose. Those ops in addition to setting enable bits, also configure MSI(-X) in dom0 kernel - which is undesirable for PCI passthrough to HVM guests. This should not introduce any new security issues since a malicious guest (or stubdom) can already generate MSIs through other ways, see [1] page 8. Additionally, when qemu runs in dom0, it already have direct access to those bits. This is the second iteration of this feature. First was proposed as a direct Xen interface through a new hypercall, but ultimately it was rejected by the maintainer, because of mixing pciback and hypercalls for PCI config space access isn't a good design. Full discussion at [2]. [1]: https://invisiblethingslab.com/resources/2011/Software%20Attacks%20on%20Intel%20VT-d.pdf [2]: https://xen.markmail.org/thread/smpgpws4umdzizze [part of the commit message and sysfs handling] Signed-off-by: Simon Gaiser [the rest] Signed-off-by: Marek Marczykowski-Górecki --- Changes in v3: - return bitmap (or negative error) from xen_pcibk_get_interrupt_type(), to implicitly handle cases when multiple interrupt types are already enabled - disallow enabling in that case - add documentation Changes in v2: - introduce xen_pcibk_get_interrupt_type() to deduplicate current INTx/MSI/MSI-X state check - fix checking MSI/MSI-X state on devices not supporting it --- .../ABI/testing/sysfs-driver-pciback | 13 +++ drivers/xen/xen-pciback/conf_space.c | 36 ++++++++ drivers/xen/xen-pciback/conf_space.h | 7 ++ .../xen/xen-pciback/conf_space_capability.c | 88 +++++++++++++++++++ drivers/xen/xen-pciback/conf_space_header.c | 18 ++++ drivers/xen/xen-pciback/pci_stub.c | 66 ++++++++++++++ drivers/xen/xen-pciback/pciback.h | 1 + 7 files changed, 229 insertions(+) diff --git a/Documentation/ABI/testing/sysfs-driver-pciback b/Documentation/ABI/testing/sysfs-driver-pciback index 6a733bfa37e6..566a11f2c12f 100644 --- a/Documentation/ABI/testing/sysfs-driver-pciback +++ b/Documentation/ABI/testing/sysfs-driver-pciback @@ -11,3 +11,16 @@ Description: #echo 00:19.0-E0:2:FF > /sys/bus/pci/drivers/pciback/quirks will allow the guest to read and write to the configuration register 0x0E. + +What: /sys/bus/pci/drivers/pciback/allow_interrupt_control +Date: Jan 2020 +KernelVersion: 5.5 +Contact: xen-devel@lists.xenproject.org +Description: + List of devices which can have interrupt control flag (INTx, + MSI, MSI-X) set by a connected guest. It is meant to be set + only when the guest is a stubdomain hosting device model (qemu) + and the actual device is assigned to a HVM. It is not safe + (similar to permissive attribute) to set for a devices assigned + to a PV guest. The device is automatically removed from this + list when the connected pcifront terminates. diff --git a/drivers/xen/xen-pciback/conf_space.c b/drivers/xen/xen-pciback/conf_space.c index 60111719b01f..7697001e8ffc 100644 --- a/drivers/xen/xen-pciback/conf_space.c +++ b/drivers/xen/xen-pciback/conf_space.c @@ -286,6 +286,42 @@ int xen_pcibk_config_write(struct pci_dev *dev, int offset, int size, u32 value) return xen_pcibios_err_to_errno(err); } +int xen_pcibk_get_interrupt_type(struct pci_dev *dev) +{ + int err; + u16 val; + int ret = 0; + + err = pci_read_config_word(dev, PCI_COMMAND, &val); + if (err) + return err; + if (!(val & PCI_COMMAND_INTX_DISABLE)) + ret |= INTERRUPT_TYPE_INTX; + + /* Do not trust dev->msi(x)_enabled here, as enabling could be done + * bypassing the pci_*msi* functions, by the qemu. + */ + if (dev->msi_cap) { + err = pci_read_config_word(dev, + dev->msi_cap + PCI_MSI_FLAGS, + &val); + if (err) + return err; + if (val & PCI_MSI_FLAGS_ENABLE) + ret |= INTERRUPT_TYPE_MSI; + } + if (dev->msix_cap) { + err = pci_read_config_word(dev, + dev->msix_cap + PCI_MSIX_FLAGS, + &val); + if (err) + return err; + if (val & PCI_MSIX_FLAGS_ENABLE) + ret |= INTERRUPT_TYPE_MSIX; + } + return ret; +} + void xen_pcibk_config_free_dyn_fields(struct pci_dev *dev) { struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev); diff --git a/drivers/xen/xen-pciback/conf_space.h b/drivers/xen/xen-pciback/conf_space.h index 22db630717ea..6ba6aa26dcee 100644 --- a/drivers/xen/xen-pciback/conf_space.h +++ b/drivers/xen/xen-pciback/conf_space.h @@ -65,6 +65,11 @@ struct config_field_entry { void *data; }; +#define INTERRUPT_TYPE_NONE 0 +#define INTERRUPT_TYPE_INTX 1 +#define INTERRUPT_TYPE_MSI 2 +#define INTERRUPT_TYPE_MSIX 4 + extern bool xen_pcibk_permissive; #define OFFSET(cfg_entry) ((cfg_entry)->base_offset+(cfg_entry)->field->offset) @@ -126,4 +131,6 @@ int xen_pcibk_config_capability_init(void); int xen_pcibk_config_header_add_fields(struct pci_dev *dev); int xen_pcibk_config_capability_add_fields(struct pci_dev *dev); +int xen_pcibk_get_interrupt_type(struct pci_dev *dev); + #endif /* __XEN_PCIBACK_CONF_SPACE_H__ */ diff --git a/drivers/xen/xen-pciback/conf_space_capability.c b/drivers/xen/xen-pciback/conf_space_capability.c index e5694133ebe5..d3a846119974 100644 --- a/drivers/xen/xen-pciback/conf_space_capability.c +++ b/drivers/xen/xen-pciback/conf_space_capability.c @@ -189,6 +189,84 @@ static const struct config_field caplist_pm[] = { {} }; +static struct msi_msix_field_config { + u16 enable_bit; /* bit for enabling MSI/MSI-X */ + int int_type; /* interrupt type for exclusiveness check */ +} msi_field_config = { + .enable_bit = PCI_MSI_FLAGS_ENABLE, + .int_type = INTERRUPT_TYPE_MSI, +}, msix_field_config = { + .enable_bit = PCI_MSIX_FLAGS_ENABLE, + .int_type = INTERRUPT_TYPE_MSIX, +}; + +static void *msi_field_init(struct pci_dev *dev, int offset) +{ + return &msi_field_config; +} + +static void *msix_field_init(struct pci_dev *dev, int offset) +{ + return &msix_field_config; +} + +static int msi_msix_flags_write(struct pci_dev *dev, int offset, u16 new_value, + void *data) +{ + int err; + u16 old_value; + const struct msi_msix_field_config *field_config = data; + const struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev); + + if (xen_pcibk_permissive || dev_data->permissive) + goto write; + + err = pci_read_config_word(dev, offset, &old_value); + if (err) + return err; + + if (new_value == old_value) + return 0; + + if (!dev_data->allow_interrupt_control || + (new_value ^ old_value) & ~field_config->enable_bit) + return PCIBIOS_SET_FAILED; + + if (new_value & field_config->enable_bit) { + /* don't allow enabling together with other interrupt types */ + int int_type = xen_pcibk_get_interrupt_type(dev); + if (int_type == INTERRUPT_TYPE_NONE || + int_type == field_config->int_type) + goto write; + return PCIBIOS_SET_FAILED; + } + +write: + return pci_write_config_word(dev, offset, new_value); +} + +static const struct config_field caplist_msix[] = { + { + .offset = PCI_MSIX_FLAGS, + .size = 2, + .init = msix_field_init, + .u.w.read = xen_pcibk_read_config_word, + .u.w.write = msi_msix_flags_write, + }, + {} +}; + +static const struct config_field caplist_msi[] = { + { + .offset = PCI_MSI_FLAGS, + .size = 2, + .init = msi_field_init, + .u.w.read = xen_pcibk_read_config_word, + .u.w.write = msi_msix_flags_write, + }, + {} +}; + static struct xen_pcibk_config_capability xen_pcibk_config_capability_pm = { .capability = PCI_CAP_ID_PM, .fields = caplist_pm, @@ -197,11 +275,21 @@ static struct xen_pcibk_config_capability xen_pcibk_config_capability_vpd = { .capability = PCI_CAP_ID_VPD, .fields = caplist_vpd, }; +static struct xen_pcibk_config_capability xen_pcibk_config_capability_msi = { + .capability = PCI_CAP_ID_MSI, + .fields = caplist_msi, +}; +static struct xen_pcibk_config_capability xen_pcibk_config_capability_msix = { + .capability = PCI_CAP_ID_MSIX, + .fields = caplist_msix, +}; int xen_pcibk_config_capability_init(void) { register_capability(&xen_pcibk_config_capability_vpd); register_capability(&xen_pcibk_config_capability_pm); + register_capability(&xen_pcibk_config_capability_msi); + register_capability(&xen_pcibk_config_capability_msix); return 0; } diff --git a/drivers/xen/xen-pciback/conf_space_header.c b/drivers/xen/xen-pciback/conf_space_header.c index 10ae24b5a76e..ab60361d5a8a 100644 --- a/drivers/xen/xen-pciback/conf_space_header.c +++ b/drivers/xen/xen-pciback/conf_space_header.c @@ -117,6 +117,24 @@ static int command_write(struct pci_dev *dev, int offset, u16 value, void *data) pci_clear_mwi(dev); } + if (dev_data && dev_data->allow_interrupt_control) { + if ((cmd->val ^ val) & PCI_COMMAND_INTX_DISABLE) { + if (value & PCI_COMMAND_INTX_DISABLE) { + pci_intx(dev, 0); + } else { + /* Do not allow enabling INTx together with MSI or MSI-X. */ + switch (xen_pcibk_get_interrupt_type(dev)) { + case INTERRUPT_TYPE_NONE: + case INTERRUPT_TYPE_INTX: + pci_intx(dev, 1); + break; + default: + return PCIBIOS_SET_FAILED; + } + } + } + } + cmd->val = value; if (!xen_pcibk_permissive && (!dev_data || !dev_data->permissive)) diff --git a/drivers/xen/xen-pciback/pci_stub.c b/drivers/xen/xen-pciback/pci_stub.c index 097410a7cdb7..7af93d65ed51 100644 --- a/drivers/xen/xen-pciback/pci_stub.c +++ b/drivers/xen/xen-pciback/pci_stub.c @@ -304,6 +304,8 @@ void pcistub_put_pci_dev(struct pci_dev *dev) xen_pcibk_config_reset_dev(dev); xen_pcibk_config_free_dyn_fields(dev); + dev_data->allow_interrupt_control = 0; + xen_unregister_device_domain_owner(dev); spin_lock_irqsave(&found_psdev->lock, flags); @@ -1431,6 +1433,65 @@ static ssize_t permissive_show(struct device_driver *drv, char *buf) } static DRIVER_ATTR_RW(permissive); +static ssize_t allow_interrupt_control_store(struct device_driver *drv, + const char *buf, size_t count) +{ + int domain, bus, slot, func; + int err; + struct pcistub_device *psdev; + struct xen_pcibk_dev_data *dev_data; + + err = str_to_slot(buf, &domain, &bus, &slot, &func); + if (err) + goto out; + + psdev = pcistub_device_find(domain, bus, slot, func); + if (!psdev) { + err = -ENODEV; + goto out; + } + + dev_data = pci_get_drvdata(psdev->dev); + /* the driver data for a device should never be null at this point */ + if (!dev_data) { + err = -ENXIO; + goto release; + } + dev_data->allow_interrupt_control = 1; +release: + pcistub_device_put(psdev); +out: + if (!err) + err = count; + return err; +} + +static ssize_t allow_interrupt_control_show(struct device_driver *drv, + char *buf) +{ + struct pcistub_device *psdev; + struct xen_pcibk_dev_data *dev_data; + size_t count = 0; + unsigned long flags; + + spin_lock_irqsave(&pcistub_devices_lock, flags); + list_for_each_entry(psdev, &pcistub_devices, dev_list) { + if (count >= PAGE_SIZE) + break; + if (!psdev->dev) + continue; + dev_data = pci_get_drvdata(psdev->dev); + if (!dev_data || !dev_data->allow_interrupt_control) + continue; + count += + scnprintf(buf + count, PAGE_SIZE - count, "%s\n", + pci_name(psdev->dev)); + } + spin_unlock_irqrestore(&pcistub_devices_lock, flags); + return count; +} +static DRIVER_ATTR_RW(allow_interrupt_control); + static void pcistub_exit(void) { driver_remove_file(&xen_pcibk_pci_driver.driver, &driver_attr_new_slot); @@ -1440,6 +1501,8 @@ static void pcistub_exit(void) driver_remove_file(&xen_pcibk_pci_driver.driver, &driver_attr_quirks); driver_remove_file(&xen_pcibk_pci_driver.driver, &driver_attr_permissive); + driver_remove_file(&xen_pcibk_pci_driver.driver, + &driver_attr_allow_interrupt_control); driver_remove_file(&xen_pcibk_pci_driver.driver, &driver_attr_irq_handlers); driver_remove_file(&xen_pcibk_pci_driver.driver, @@ -1530,6 +1593,9 @@ static int __init pcistub_init(void) if (!err) err = driver_create_file(&xen_pcibk_pci_driver.driver, &driver_attr_permissive); + if (!err) + err = driver_create_file(&xen_pcibk_pci_driver.driver, + &driver_attr_allow_interrupt_control); if (!err) err = driver_create_file(&xen_pcibk_pci_driver.driver, diff --git a/drivers/xen/xen-pciback/pciback.h b/drivers/xen/xen-pciback/pciback.h index 263c059bff90..ce1077e32466 100644 --- a/drivers/xen/xen-pciback/pciback.h +++ b/drivers/xen/xen-pciback/pciback.h @@ -45,6 +45,7 @@ struct xen_pcibk_dev_data { struct list_head config_fields; struct pci_saved_state *pci_saved_state; unsigned int permissive:1; + unsigned int allow_interrupt_control:1; unsigned int warned_on_write:1; unsigned int enable_intx:1; unsigned int isr_on:1; /* Whether the IRQ handler is installed. */ -- 2.21.0 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=-9.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT 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 AE8AAC33C9E for ; Sat, 11 Jan 2020 03:45:08 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (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 65928206ED for ; Sat, 11 Jan 2020 03:45:08 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="d3HmNF+t" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 65928206ED Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=invisiblethingslab.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iq7hM-0001ai-Rc; Sat, 11 Jan 2020 03:44:28 +0000 Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1iq7hK-0001ad-UM for xen-devel@lists.xenproject.org; Sat, 11 Jan 2020 03:44:27 +0000 X-Inumbo-ID: a8ca98d2-3424-11ea-bfea-12813bfff9fa Received: from wout2-smtp.messagingengine.com (unknown [64.147.123.25]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id a8ca98d2-3424-11ea-bfea-12813bfff9fa; Sat, 11 Jan 2020 03:44:24 +0000 (UTC) Received: from compute7.internal (compute7.nyi.internal [10.202.2.47]) by mailout.west.internal (Postfix) with ESMTP id 4E2E9482; Fri, 10 Jan 2020 22:44:23 -0500 (EST) Received: from mailfrontend1 ([10.202.2.162]) by compute7.internal (MEProxy); Fri, 10 Jan 2020 22:44:23 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:content-transfer-encoding:content-type :date:from:message-id:mime-version:subject:to:x-me-proxy :x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s=fm1; bh=6uIvn1 HcLzYl+j8NNQCQcaaAEZy0NhPLBJ6H1hgc4oQ=; b=d3HmNF+tZAqXdGHgMoOsm5 csPReTqgFRcVG5qAUr2JErqog6Bluu9GNaLurCXNzOAOOobmtz/Ye7x6tVJzhQSK 1HzSx21JZXyRvlipN32KTvcDqLiMP/hpK2wUqaFte27uXTpChagdIrG/ABQsjnxS eQuGJpNu1tf0ShIdg/tDreTORuBPEhDE96+xL4ujM7a+i/CzavZlXG5W06owGo4C hv5RDbLUKd1O2fZsMIL3a7GMt9Y0hQmFTl/Oy+He2pKfLrN8w638npJOHjWhsnSc pbTEMK6rYr4pOQ9kjQ41i0iSHd007j2eGYtLIeYfr0ZAel2yhNyB2UQ2RbIST/TA == X-ME-Sender: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedufedrvdeigedgieduucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmne cujfgurhephffvufffkffogggtohfgsehtkeertdertdejnecuhfhrohhmpeforghrvghk ucforghrtgiihihkohifshhkihdqifpkrhgvtghkihcuoehmrghrmhgrrhgvkhesihhnvh hishhisghlvghthhhinhhgshhlrggsrdgtohhmqeenucffohhmrghinhepmhgrrhhkmhgr ihhlrdhorhhgpdhinhhvihhsihgslhgvthhhihhnghhslhgrsgdrtghomhenucfkpheple durdeihedrfeegrdeffeenucfrrghrrghmpehmrghilhhfrhhomhepmhgrrhhmrghrvghk sehinhhvihhsihgslhgvthhhihhnghhslhgrsgdrtghomhenucevlhhushhtvghrufhiii gvpedt X-ME-Proxy: Received: from localhost.localdomain (ip5b412221.dynamic.kabel-deutschland.de [91.65.34.33]) by mail.messagingengine.com (Postfix) with ESMTPA id AB58580063; Fri, 10 Jan 2020 22:44:20 -0500 (EST) From: =?UTF-8?q?Marek=20Marczykowski-G=C3=B3recki?= To: xen-devel@lists.xenproject.org Date: Sat, 11 Jan 2020 04:43:31 +0100 Message-Id: <20200111034347.5270-1-marmarek@invisiblethingslab.com> X-Mailer: git-send-email 2.21.0 MIME-Version: 1.0 Organization: Invisible Things Lab Subject: [Xen-devel] [PATCH v3] xen-pciback: optionally allow interrupt enable flag writes X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Juergen Gross , Stefano Stabellini , YueHaibing , =?UTF-8?q?Marek=20Marczykowski-G=C3=B3recki?= , open list , Simon Gaiser , Jan Beulich , Boris Ostrovsky Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" UUVNVSBydW5uaW5nIGluIGEgc3R1YmRvbSBuZWVkcyB0byBiZSBhYmxlIHRvIHNldCBJTlRYX0RJ U0FCTEUsIGFuZCB0aGUKTVNJKC1YKSBlbmFibGUgZmxhZ3MgaW4gdGhlIFBDSSBjb25maWcgc3Bh Y2UuIFRoaXMgYWRkcyBhbiBhdHRyaWJ1dGUKJ2FsbG93X2ludGVycnVwdF9jb250cm9sJyB3aGlj aCB3aGVuIHNldCBmb3IgYSBQQ0kgZGV2aWNlIGFsbG93cyB3cml0ZXMKdG8gdGhpcyBmbGFnKHMp LiBUaGUgdG9vbHN0YWNrIHdpbGwgbmVlZCB0byBzZXQgdGhpcyBmb3Igc3R1YmRvbXMuCldoZW4g ZW5hYmxlZCwgZ3Vlc3QgKHN0dWJkb21haW4pIHdpbGwgYmUgYWxsb3dlZCB0byBzZXQgcmVsZXZh bnQgZW5hYmxlCmZsYWdzLCBidXQgb25seSBvbmUgYXQgYSB0aW1lIC0gaS5lLiBpdCByZWZ1c2Vz IHRvIGVuYWJsZSBtb3JlIHRoYW4gb25lCm9mIElOVHgsIE1TSSwgTVNJLVggYXQgYSB0aW1lLgoK VGhpcyBmdW5jdGlvbmFsaXR5IGlzIG5lZWRlZCBvbmx5IGZvciBjb25maWcgc3BhY2UgYWNjZXNz IGRvbmUgYnkgZGV2aWNlCm1vZGVsIChzdHViZG9tYWluKSBzZXJ2aW5nIGEgSFZNIHdpdGggdGhl IGFjdHVhbCBQQ0kgZGV2aWNlLiBJdCBpcyBub3QKbmVjZXNzYXJ5IGFuZCB1bnNhZmUgdG8gZW5h YmxlIGRpcmVjdCBhY2Nlc3MgdG8gdGhvc2UgYml0cyBmb3IgUFYgZG9tYWluCndpdGggdGhlIGRl dmljZSBhdHRhY2hlZC4gRm9yIFBWIGRvbWFpbnMsIHRoZXJlIGFyZSBzZXBhcmF0ZSBwcm90b2Nv bAptZXNzYWdlcyAoWEVOX1BDSV9PUF97ZW5hYmxlLGRpc2FibGV9X3ttc2ksbXNpeH0pIGZvciB0 aGlzIHB1cnBvc2UuClRob3NlIG9wcyBpbiBhZGRpdGlvbiB0byBzZXR0aW5nIGVuYWJsZSBiaXRz LCBhbHNvIGNvbmZpZ3VyZSBNU0koLVgpIGluCmRvbTAga2VybmVsIC0gd2hpY2ggaXMgdW5kZXNp cmFibGUgZm9yIFBDSSBwYXNzdGhyb3VnaCB0byBIVk0gZ3Vlc3RzLgoKVGhpcyBzaG91bGQgbm90 IGludHJvZHVjZSBhbnkgbmV3IHNlY3VyaXR5IGlzc3VlcyBzaW5jZSBhIG1hbGljaW91cwpndWVz dCAob3Igc3R1YmRvbSkgY2FuIGFscmVhZHkgZ2VuZXJhdGUgTVNJcyB0aHJvdWdoIG90aGVyIHdh eXMsIHNlZQpbMV0gcGFnZSA4LiBBZGRpdGlvbmFsbHksIHdoZW4gcWVtdSBydW5zIGluIGRvbTAs IGl0IGFscmVhZHkgaGF2ZSBkaXJlY3QKYWNjZXNzIHRvIHRob3NlIGJpdHMuCgpUaGlzIGlzIHRo ZSBzZWNvbmQgaXRlcmF0aW9uIG9mIHRoaXMgZmVhdHVyZS4gRmlyc3Qgd2FzIHByb3Bvc2VkIGFz IGEKZGlyZWN0IFhlbiBpbnRlcmZhY2UgdGhyb3VnaCBhIG5ldyBoeXBlcmNhbGwsIGJ1dCB1bHRp bWF0ZWx5IGl0IHdhcwpyZWplY3RlZCBieSB0aGUgbWFpbnRhaW5lciwgYmVjYXVzZSBvZiBtaXhp bmcgcGNpYmFjayBhbmQgaHlwZXJjYWxscyBmb3IKUENJIGNvbmZpZyBzcGFjZSBhY2Nlc3MgaXNu J3QgYSBnb29kIGRlc2lnbi4gRnVsbCBkaXNjdXNzaW9uIGF0IFsyXS4KClsxXTogaHR0cHM6Ly9p bnZpc2libGV0aGluZ3NsYWIuY29tL3Jlc291cmNlcy8yMDExL1NvZnR3YXJlJTIwQXR0YWNrcyUy MG9uJTIwSW50ZWwlMjBWVC1kLnBkZgpbMl06IGh0dHBzOi8veGVuLm1hcmttYWlsLm9yZy90aHJl YWQvc21wZ3B3czR1bWR6aXp6ZQoKW3BhcnQgb2YgdGhlIGNvbW1pdCBtZXNzYWdlIGFuZCBzeXNm cyBoYW5kbGluZ10KU2lnbmVkLW9mZi1ieTogU2ltb24gR2Fpc2VyIDxzaW1vbkBpbnZpc2libGV0 aGluZ3NsYWIuY29tPgpbdGhlIHJlc3RdClNpZ25lZC1vZmYtYnk6IE1hcmVrIE1hcmN6eWtvd3Nr aS1Hw7NyZWNraSA8bWFybWFyZWtAaW52aXNpYmxldGhpbmdzbGFiLmNvbT4KLS0tCkNoYW5nZXMg aW4gdjM6CiAtIHJldHVybiBiaXRtYXAgKG9yIG5lZ2F0aXZlIGVycm9yKSBmcm9tCiAgIHhlbl9w Y2lia19nZXRfaW50ZXJydXB0X3R5cGUoKSwgdG8gaW1wbGljaXRseSBoYW5kbGUgY2FzZXMgd2hl bgogICBtdWx0aXBsZSBpbnRlcnJ1cHQgdHlwZXMgYXJlIGFscmVhZHkgZW5hYmxlZCAtIGRpc2Fs bG93IGVuYWJsaW5nIGluCiAgIHRoYXQgY2FzZQogLSBhZGQgZG9jdW1lbnRhdGlvbgpDaGFuZ2Vz IGluIHYyOgogLSBpbnRyb2R1Y2UgeGVuX3BjaWJrX2dldF9pbnRlcnJ1cHRfdHlwZSgpIHRvIGRl ZHVwbGljYXRlIGN1cnJlbnQKICAgSU5UeC9NU0kvTVNJLVggc3RhdGUgY2hlY2sKIC0gZml4IGNo ZWNraW5nIE1TSS9NU0ktWCBzdGF0ZSBvbiBkZXZpY2VzIG5vdCBzdXBwb3J0aW5nIGl0CgotLS0K IC4uLi9BQkkvdGVzdGluZy9zeXNmcy1kcml2ZXItcGNpYmFjayAgICAgICAgICB8IDEzICsrKwog ZHJpdmVycy94ZW4veGVuLXBjaWJhY2svY29uZl9zcGFjZS5jICAgICAgICAgIHwgMzYgKysrKysr KysKIGRyaXZlcnMveGVuL3hlbi1wY2liYWNrL2NvbmZfc3BhY2UuaCAgICAgICAgICB8ICA3ICsr CiAuLi4veGVuL3hlbi1wY2liYWNrL2NvbmZfc3BhY2VfY2FwYWJpbGl0eS5jICAgfCA4OCArKysr KysrKysrKysrKysrKysrCiBkcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9jb25mX3NwYWNlX2hlYWRl ci5jICAgfCAxOCArKysrCiBkcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9wY2lfc3R1Yi5jICAgICAg ICAgICAgfCA2NiArKysrKysrKysrKysrKwogZHJpdmVycy94ZW4veGVuLXBjaWJhY2svcGNpYmFj ay5oICAgICAgICAgICAgIHwgIDEgKwogNyBmaWxlcyBjaGFuZ2VkLCAyMjkgaW5zZXJ0aW9ucygr KQoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtZHJpdmVyLXBj aWJhY2sgYi9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLWRyaXZlci1wY2liYWNrCmlu ZGV4IDZhNzMzYmZhMzdlNi4uNTY2YTExZjJjMTJmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9u L0FCSS90ZXN0aW5nL3N5c2ZzLWRyaXZlci1wY2liYWNrCisrKyBiL0RvY3VtZW50YXRpb24vQUJJ L3Rlc3Rpbmcvc3lzZnMtZHJpdmVyLXBjaWJhY2sKQEAgLTExLDMgKzExLDE2IEBAIERlc2NyaXB0 aW9uOgogICAgICAgICAgICAgICAgICNlY2hvIDAwOjE5LjAtRTA6MjpGRiA+IC9zeXMvYnVzL3Bj aS9kcml2ZXJzL3BjaWJhY2svcXVpcmtzCiAgICAgICAgICAgICAgICAgd2lsbCBhbGxvdyB0aGUg Z3Vlc3QgdG8gcmVhZCBhbmQgd3JpdGUgdG8gdGhlIGNvbmZpZ3VyYXRpb24KICAgICAgICAgICAg ICAgICByZWdpc3RlciAweDBFLgorCitXaGF0OiAgICAgICAgICAgL3N5cy9idXMvcGNpL2RyaXZl cnMvcGNpYmFjay9hbGxvd19pbnRlcnJ1cHRfY29udHJvbAorRGF0ZTogICAgICAgICAgIEphbiAy MDIwCitLZXJuZWxWZXJzaW9uOiAgNS41CitDb250YWN0OiAgICAgICAgeGVuLWRldmVsQGxpc3Rz LnhlbnByb2plY3Qub3JnCitEZXNjcmlwdGlvbjoKKyAgICAgICAgICAgICAgICBMaXN0IG9mIGRl dmljZXMgd2hpY2ggY2FuIGhhdmUgaW50ZXJydXB0IGNvbnRyb2wgZmxhZyAoSU5UeCwKKyAgICAg ICAgICAgICAgICBNU0ksIE1TSS1YKSBzZXQgYnkgYSBjb25uZWN0ZWQgZ3Vlc3QuIEl0IGlzIG1l YW50IHRvIGJlIHNldAorICAgICAgICAgICAgICAgIG9ubHkgd2hlbiB0aGUgZ3Vlc3QgaXMgYSBz dHViZG9tYWluIGhvc3RpbmcgZGV2aWNlIG1vZGVsIChxZW11KQorICAgICAgICAgICAgICAgIGFu ZCB0aGUgYWN0dWFsIGRldmljZSBpcyBhc3NpZ25lZCB0byBhIEhWTS4gSXQgaXMgbm90IHNhZmUK KyAgICAgICAgICAgICAgICAoc2ltaWxhciB0byBwZXJtaXNzaXZlIGF0dHJpYnV0ZSkgdG8gc2V0 IGZvciBhIGRldmljZXMgYXNzaWduZWQKKyAgICAgICAgICAgICAgICB0byBhIFBWIGd1ZXN0LiBU aGUgZGV2aWNlIGlzIGF1dG9tYXRpY2FsbHkgcmVtb3ZlZCBmcm9tIHRoaXMKKyAgICAgICAgICAg ICAgICBsaXN0IHdoZW4gdGhlIGNvbm5lY3RlZCBwY2lmcm9udCB0ZXJtaW5hdGVzLgpkaWZmIC0t Z2l0IGEvZHJpdmVycy94ZW4veGVuLXBjaWJhY2svY29uZl9zcGFjZS5jIGIvZHJpdmVycy94ZW4v eGVuLXBjaWJhY2svY29uZl9zcGFjZS5jCmluZGV4IDYwMTExNzE5YjAxZi4uNzY5NzAwMWU4ZmZj IDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9jb25mX3NwYWNlLmMKKysrIGIv ZHJpdmVycy94ZW4veGVuLXBjaWJhY2svY29uZl9zcGFjZS5jCkBAIC0yODYsNiArMjg2LDQyIEBA IGludCB4ZW5fcGNpYmtfY29uZmlnX3dyaXRlKHN0cnVjdCBwY2lfZGV2ICpkZXYsIGludCBvZmZz ZXQsIGludCBzaXplLCB1MzIgdmFsdWUpCiAJcmV0dXJuIHhlbl9wY2liaW9zX2Vycl90b19lcnJu byhlcnIpOwogfQogCitpbnQgeGVuX3BjaWJrX2dldF9pbnRlcnJ1cHRfdHlwZShzdHJ1Y3QgcGNp X2RldiAqZGV2KQoreworCWludCBlcnI7CisJdTE2IHZhbDsKKwlpbnQgcmV0ID0gMDsKKworCWVy ciA9IHBjaV9yZWFkX2NvbmZpZ193b3JkKGRldiwgUENJX0NPTU1BTkQsICZ2YWwpOworCWlmIChl cnIpCisJCXJldHVybiBlcnI7CisJaWYgKCEodmFsICYgUENJX0NPTU1BTkRfSU5UWF9ESVNBQkxF KSkKKwkJcmV0IHw9IElOVEVSUlVQVF9UWVBFX0lOVFg7CisKKwkvKiBEbyBub3QgdHJ1c3QgZGV2 LT5tc2koeClfZW5hYmxlZCBoZXJlLCBhcyBlbmFibGluZyBjb3VsZCBiZSBkb25lCisJICogYnlw YXNzaW5nIHRoZSBwY2lfKm1zaSogZnVuY3Rpb25zLCBieSB0aGUgcWVtdS4KKwkgKi8KKwlpZiAo ZGV2LT5tc2lfY2FwKSB7CisJCWVyciA9IHBjaV9yZWFkX2NvbmZpZ193b3JkKGRldiwKKwkJCQlk ZXYtPm1zaV9jYXAgKyBQQ0lfTVNJX0ZMQUdTLAorCQkJCSZ2YWwpOworCQlpZiAoZXJyKQorCQkJ cmV0dXJuIGVycjsKKwkJaWYgKHZhbCAmIFBDSV9NU0lfRkxBR1NfRU5BQkxFKQorCQkJcmV0IHw9 IElOVEVSUlVQVF9UWVBFX01TSTsKKwl9CisJaWYgKGRldi0+bXNpeF9jYXApIHsKKwkJZXJyID0g cGNpX3JlYWRfY29uZmlnX3dvcmQoZGV2LAorCQkJCWRldi0+bXNpeF9jYXAgKyBQQ0lfTVNJWF9G TEFHUywKKwkJCQkmdmFsKTsKKwkJaWYgKGVycikKKwkJCXJldHVybiBlcnI7CisJCWlmICh2YWwg JiBQQ0lfTVNJWF9GTEFHU19FTkFCTEUpCisJCQlyZXQgfD0gSU5URVJSVVBUX1RZUEVfTVNJWDsK Kwl9CisJcmV0dXJuIHJldDsKK30KKwogdm9pZCB4ZW5fcGNpYmtfY29uZmlnX2ZyZWVfZHluX2Zp ZWxkcyhzdHJ1Y3QgcGNpX2RldiAqZGV2KQogewogCXN0cnVjdCB4ZW5fcGNpYmtfZGV2X2RhdGEg KmRldl9kYXRhID0gcGNpX2dldF9kcnZkYXRhKGRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hl bi94ZW4tcGNpYmFjay9jb25mX3NwYWNlLmggYi9kcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9jb25m X3NwYWNlLmgKaW5kZXggMjJkYjYzMDcxN2VhLi42YmE2YWEyNmRjZWUgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMveGVuL3hlbi1wY2liYWNrL2NvbmZfc3BhY2UuaAorKysgYi9kcml2ZXJzL3hlbi94ZW4t cGNpYmFjay9jb25mX3NwYWNlLmgKQEAgLTY1LDYgKzY1LDExIEBAIHN0cnVjdCBjb25maWdfZmll bGRfZW50cnkgewogCXZvaWQgKmRhdGE7CiB9OwogCisjZGVmaW5lIElOVEVSUlVQVF9UWVBFX05P TkUgMAorI2RlZmluZSBJTlRFUlJVUFRfVFlQRV9JTlRYIDEKKyNkZWZpbmUgSU5URVJSVVBUX1RZ UEVfTVNJICAyCisjZGVmaW5lIElOVEVSUlVQVF9UWVBFX01TSVggNAorCiBleHRlcm4gYm9vbCB4 ZW5fcGNpYmtfcGVybWlzc2l2ZTsKIAogI2RlZmluZSBPRkZTRVQoY2ZnX2VudHJ5KSAoKGNmZ19l bnRyeSktPmJhc2Vfb2Zmc2V0KyhjZmdfZW50cnkpLT5maWVsZC0+b2Zmc2V0KQpAQCAtMTI2LDQg KzEzMSw2IEBAIGludCB4ZW5fcGNpYmtfY29uZmlnX2NhcGFiaWxpdHlfaW5pdCh2b2lkKTsKIGlu dCB4ZW5fcGNpYmtfY29uZmlnX2hlYWRlcl9hZGRfZmllbGRzKHN0cnVjdCBwY2lfZGV2ICpkZXYp OwogaW50IHhlbl9wY2lia19jb25maWdfY2FwYWJpbGl0eV9hZGRfZmllbGRzKHN0cnVjdCBwY2lf ZGV2ICpkZXYpOwogCitpbnQgeGVuX3BjaWJrX2dldF9pbnRlcnJ1cHRfdHlwZShzdHJ1Y3QgcGNp X2RldiAqZGV2KTsKKwogI2VuZGlmCQkJCS8qIF9fWEVOX1BDSUJBQ0tfQ09ORl9TUEFDRV9IX18g Ki8KZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL3hlbi1wY2liYWNrL2NvbmZfc3BhY2VfY2FwYWJp bGl0eS5jIGIvZHJpdmVycy94ZW4veGVuLXBjaWJhY2svY29uZl9zcGFjZV9jYXBhYmlsaXR5LmMK aW5kZXggZTU2OTQxMzNlYmU1Li5kM2E4NDYxMTk5NzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVu L3hlbi1wY2liYWNrL2NvbmZfc3BhY2VfY2FwYWJpbGl0eS5jCisrKyBiL2RyaXZlcnMveGVuL3hl bi1wY2liYWNrL2NvbmZfc3BhY2VfY2FwYWJpbGl0eS5jCkBAIC0xODksNiArMTg5LDg0IEBAIHN0 YXRpYyBjb25zdCBzdHJ1Y3QgY29uZmlnX2ZpZWxkIGNhcGxpc3RfcG1bXSA9IHsKIAl7fQogfTsK IAorc3RhdGljIHN0cnVjdCBtc2lfbXNpeF9maWVsZF9jb25maWcgeworCXUxNiBlbmFibGVfYml0 OyAvKiBiaXQgZm9yIGVuYWJsaW5nIE1TSS9NU0ktWCAqLworCWludCBpbnRfdHlwZTsgLyogaW50 ZXJydXB0IHR5cGUgZm9yIGV4Y2x1c2l2ZW5lc3MgY2hlY2sgKi8KK30gbXNpX2ZpZWxkX2NvbmZp ZyA9IHsKKwkuZW5hYmxlX2JpdCA9IFBDSV9NU0lfRkxBR1NfRU5BQkxFLAorCS5pbnRfdHlwZSA9 IElOVEVSUlVQVF9UWVBFX01TSSwKK30sIG1zaXhfZmllbGRfY29uZmlnID0geworCS5lbmFibGVf Yml0ID0gUENJX01TSVhfRkxBR1NfRU5BQkxFLAorCS5pbnRfdHlwZSA9IElOVEVSUlVQVF9UWVBF X01TSVgsCit9OworCitzdGF0aWMgdm9pZCAqbXNpX2ZpZWxkX2luaXQoc3RydWN0IHBjaV9kZXYg KmRldiwgaW50IG9mZnNldCkKK3sKKwlyZXR1cm4gJm1zaV9maWVsZF9jb25maWc7Cit9CisKK3N0 YXRpYyB2b2lkICptc2l4X2ZpZWxkX2luaXQoc3RydWN0IHBjaV9kZXYgKmRldiwgaW50IG9mZnNl dCkKK3sKKwlyZXR1cm4gJm1zaXhfZmllbGRfY29uZmlnOworfQorCitzdGF0aWMgaW50IG1zaV9t c2l4X2ZsYWdzX3dyaXRlKHN0cnVjdCBwY2lfZGV2ICpkZXYsIGludCBvZmZzZXQsIHUxNiBuZXdf dmFsdWUsCisJCQkJdm9pZCAqZGF0YSkKK3sKKwlpbnQgZXJyOworCXUxNiBvbGRfdmFsdWU7CisJ Y29uc3Qgc3RydWN0IG1zaV9tc2l4X2ZpZWxkX2NvbmZpZyAqZmllbGRfY29uZmlnID0gZGF0YTsK Kwljb25zdCBzdHJ1Y3QgeGVuX3BjaWJrX2Rldl9kYXRhICpkZXZfZGF0YSA9IHBjaV9nZXRfZHJ2 ZGF0YShkZXYpOworCisJaWYgKHhlbl9wY2lia19wZXJtaXNzaXZlIHx8IGRldl9kYXRhLT5wZXJt aXNzaXZlKQorCQlnb3RvIHdyaXRlOworCisJZXJyID0gcGNpX3JlYWRfY29uZmlnX3dvcmQoZGV2 LCBvZmZzZXQsICZvbGRfdmFsdWUpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwlpZiAo bmV3X3ZhbHVlID09IG9sZF92YWx1ZSkKKwkJcmV0dXJuIDA7CisKKwlpZiAoIWRldl9kYXRhLT5h bGxvd19pbnRlcnJ1cHRfY29udHJvbCB8fAorCSAgICAobmV3X3ZhbHVlIF4gb2xkX3ZhbHVlKSAm IH5maWVsZF9jb25maWctPmVuYWJsZV9iaXQpCisJCXJldHVybiBQQ0lCSU9TX1NFVF9GQUlMRUQ7 CisKKwlpZiAobmV3X3ZhbHVlICYgZmllbGRfY29uZmlnLT5lbmFibGVfYml0KSB7CisJCS8qIGRv bid0IGFsbG93IGVuYWJsaW5nIHRvZ2V0aGVyIHdpdGggb3RoZXIgaW50ZXJydXB0IHR5cGVzICov CisJCWludCBpbnRfdHlwZSA9IHhlbl9wY2lia19nZXRfaW50ZXJydXB0X3R5cGUoZGV2KTsKKwkJ aWYgKGludF90eXBlID09IElOVEVSUlVQVF9UWVBFX05PTkUgfHwKKwkJICAgIGludF90eXBlID09 IGZpZWxkX2NvbmZpZy0+aW50X3R5cGUpCisJCQlnb3RvIHdyaXRlOworCQlyZXR1cm4gUENJQklP U19TRVRfRkFJTEVEOworCX0KKword3JpdGU6CisJcmV0dXJuIHBjaV93cml0ZV9jb25maWdfd29y ZChkZXYsIG9mZnNldCwgbmV3X3ZhbHVlKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBjb25m aWdfZmllbGQgY2FwbGlzdF9tc2l4W10gPSB7CisJeworCQkub2Zmc2V0ICAgID0gUENJX01TSVhf RkxBR1MsCisJCS5zaXplICAgICAgPSAyLAorCQkuaW5pdCAgICAgID0gbXNpeF9maWVsZF9pbml0 LAorCQkudS53LnJlYWQgID0geGVuX3BjaWJrX3JlYWRfY29uZmlnX3dvcmQsCisJCS51Lncud3Jp dGUgPSBtc2lfbXNpeF9mbGFnc193cml0ZSwKKwl9LAorCXt9Cit9OworCitzdGF0aWMgY29uc3Qg c3RydWN0IGNvbmZpZ19maWVsZCBjYXBsaXN0X21zaVtdID0geworCXsKKwkJLm9mZnNldCAgICA9 IFBDSV9NU0lfRkxBR1MsCisJCS5zaXplICAgICAgPSAyLAorCQkuaW5pdCAgICAgID0gbXNpX2Zp ZWxkX2luaXQsCisJCS51LncucmVhZCAgPSB4ZW5fcGNpYmtfcmVhZF9jb25maWdfd29yZCwKKwkJ LnUudy53cml0ZSA9IG1zaV9tc2l4X2ZsYWdzX3dyaXRlLAorCX0sCisJe30KK307CisKIHN0YXRp YyBzdHJ1Y3QgeGVuX3BjaWJrX2NvbmZpZ19jYXBhYmlsaXR5IHhlbl9wY2lia19jb25maWdfY2Fw YWJpbGl0eV9wbSA9IHsKIAkuY2FwYWJpbGl0eSA9IFBDSV9DQVBfSURfUE0sCiAJLmZpZWxkcyA9 IGNhcGxpc3RfcG0sCkBAIC0xOTcsMTEgKzI3NSwyMSBAQCBzdGF0aWMgc3RydWN0IHhlbl9wY2li a19jb25maWdfY2FwYWJpbGl0eSB4ZW5fcGNpYmtfY29uZmlnX2NhcGFiaWxpdHlfdnBkID0gewog CS5jYXBhYmlsaXR5ID0gUENJX0NBUF9JRF9WUEQsCiAJLmZpZWxkcyA9IGNhcGxpc3RfdnBkLAog fTsKK3N0YXRpYyBzdHJ1Y3QgeGVuX3BjaWJrX2NvbmZpZ19jYXBhYmlsaXR5IHhlbl9wY2lia19j b25maWdfY2FwYWJpbGl0eV9tc2kgPSB7CisJLmNhcGFiaWxpdHkgPSBQQ0lfQ0FQX0lEX01TSSwK KwkuZmllbGRzID0gY2FwbGlzdF9tc2ksCit9Oworc3RhdGljIHN0cnVjdCB4ZW5fcGNpYmtfY29u ZmlnX2NhcGFiaWxpdHkgeGVuX3BjaWJrX2NvbmZpZ19jYXBhYmlsaXR5X21zaXggPSB7CisJLmNh cGFiaWxpdHkgPSBQQ0lfQ0FQX0lEX01TSVgsCisJLmZpZWxkcyA9IGNhcGxpc3RfbXNpeCwKK307 CiAKIGludCB4ZW5fcGNpYmtfY29uZmlnX2NhcGFiaWxpdHlfaW5pdCh2b2lkKQogewogCXJlZ2lz dGVyX2NhcGFiaWxpdHkoJnhlbl9wY2lia19jb25maWdfY2FwYWJpbGl0eV92cGQpOwogCXJlZ2lz dGVyX2NhcGFiaWxpdHkoJnhlbl9wY2lia19jb25maWdfY2FwYWJpbGl0eV9wbSk7CisJcmVnaXN0 ZXJfY2FwYWJpbGl0eSgmeGVuX3BjaWJrX2NvbmZpZ19jYXBhYmlsaXR5X21zaSk7CisJcmVnaXN0 ZXJfY2FwYWJpbGl0eSgmeGVuX3BjaWJrX2NvbmZpZ19jYXBhYmlsaXR5X21zaXgpOwogCiAJcmV0 dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9jb25mX3NwYWNl X2hlYWRlci5jIGIvZHJpdmVycy94ZW4veGVuLXBjaWJhY2svY29uZl9zcGFjZV9oZWFkZXIuYwpp bmRleCAxMGFlMjRiNWE3NmUuLmFiNjAzNjFkNWE4YSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4v eGVuLXBjaWJhY2svY29uZl9zcGFjZV9oZWFkZXIuYworKysgYi9kcml2ZXJzL3hlbi94ZW4tcGNp YmFjay9jb25mX3NwYWNlX2hlYWRlci5jCkBAIC0xMTcsNiArMTE3LDI0IEBAIHN0YXRpYyBpbnQg Y29tbWFuZF93cml0ZShzdHJ1Y3QgcGNpX2RldiAqZGV2LCBpbnQgb2Zmc2V0LCB1MTYgdmFsdWUs IHZvaWQgKmRhdGEpCiAJCXBjaV9jbGVhcl9td2koZGV2KTsKIAl9CiAKKwlpZiAoZGV2X2RhdGEg JiYgZGV2X2RhdGEtPmFsbG93X2ludGVycnVwdF9jb250cm9sKSB7CisJCWlmICgoY21kLT52YWwg XiB2YWwpICYgUENJX0NPTU1BTkRfSU5UWF9ESVNBQkxFKSB7CisJCQlpZiAodmFsdWUgJiBQQ0lf Q09NTUFORF9JTlRYX0RJU0FCTEUpIHsKKwkJCQlwY2lfaW50eChkZXYsIDApOworCQkJfSBlbHNl IHsKKwkJCQkvKiBEbyBub3QgYWxsb3cgZW5hYmxpbmcgSU5UeCB0b2dldGhlciB3aXRoIE1TSSBv ciBNU0ktWC4gKi8KKwkJCQlzd2l0Y2ggKHhlbl9wY2lia19nZXRfaW50ZXJydXB0X3R5cGUoZGV2 KSkgeworCQkJCWNhc2UgSU5URVJSVVBUX1RZUEVfTk9ORToKKwkJCQljYXNlIElOVEVSUlVQVF9U WVBFX0lOVFg6CisJCQkJCXBjaV9pbnR4KGRldiwgMSk7CisJCQkJCWJyZWFrOworCQkJCWRlZmF1 bHQ6CisJCQkJCXJldHVybiBQQ0lCSU9TX1NFVF9GQUlMRUQ7CisJCQkJfQorCQkJfQorCQl9CisJ fQorCiAJY21kLT52YWwgPSB2YWx1ZTsKIAogCWlmICgheGVuX3BjaWJrX3Blcm1pc3NpdmUgJiYg KCFkZXZfZGF0YSB8fCAhZGV2X2RhdGEtPnBlcm1pc3NpdmUpKQpkaWZmIC0tZ2l0IGEvZHJpdmVy cy94ZW4veGVuLXBjaWJhY2svcGNpX3N0dWIuYyBiL2RyaXZlcnMveGVuL3hlbi1wY2liYWNrL3Bj aV9zdHViLmMKaW5kZXggMDk3NDEwYTdjZGI3Li43YWY5M2Q2NWVkNTEgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMveGVuL3hlbi1wY2liYWNrL3BjaV9zdHViLmMKKysrIGIvZHJpdmVycy94ZW4veGVuLXBj aWJhY2svcGNpX3N0dWIuYwpAQCAtMzA0LDYgKzMwNCw4IEBAIHZvaWQgcGNpc3R1Yl9wdXRfcGNp X2RldihzdHJ1Y3QgcGNpX2RldiAqZGV2KQogCXhlbl9wY2lia19jb25maWdfcmVzZXRfZGV2KGRl dik7CiAJeGVuX3BjaWJrX2NvbmZpZ19mcmVlX2R5bl9maWVsZHMoZGV2KTsKIAorCWRldl9kYXRh LT5hbGxvd19pbnRlcnJ1cHRfY29udHJvbCA9IDA7CisKIAl4ZW5fdW5yZWdpc3Rlcl9kZXZpY2Vf ZG9tYWluX293bmVyKGRldik7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmZm91bmRfcHNkZXYtPmxv Y2ssIGZsYWdzKTsKQEAgLTE0MzEsNiArMTQzMyw2NSBAQCBzdGF0aWMgc3NpemVfdCBwZXJtaXNz aXZlX3Nob3coc3RydWN0IGRldmljZV9kcml2ZXIgKmRydiwgY2hhciAqYnVmKQogfQogc3RhdGlj IERSSVZFUl9BVFRSX1JXKHBlcm1pc3NpdmUpOwogCitzdGF0aWMgc3NpemVfdCBhbGxvd19pbnRl cnJ1cHRfY29udHJvbF9zdG9yZShzdHJ1Y3QgZGV2aWNlX2RyaXZlciAqZHJ2LAorCQkJCQkgICAg IGNvbnN0IGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50KQoreworCWludCBkb21haW4sIGJ1cywgc2xv dCwgZnVuYzsKKwlpbnQgZXJyOworCXN0cnVjdCBwY2lzdHViX2RldmljZSAqcHNkZXY7CisJc3Ry dWN0IHhlbl9wY2lia19kZXZfZGF0YSAqZGV2X2RhdGE7CisKKwllcnIgPSBzdHJfdG9fc2xvdChi dWYsICZkb21haW4sICZidXMsICZzbG90LCAmZnVuYyk7CisJaWYgKGVycikKKwkJZ290byBvdXQ7 CisKKwlwc2RldiA9IHBjaXN0dWJfZGV2aWNlX2ZpbmQoZG9tYWluLCBidXMsIHNsb3QsIGZ1bmMp OworCWlmICghcHNkZXYpIHsKKwkJZXJyID0gLUVOT0RFVjsKKwkJZ290byBvdXQ7CisJfQorCisJ ZGV2X2RhdGEgPSBwY2lfZ2V0X2RydmRhdGEocHNkZXYtPmRldik7CisJLyogdGhlIGRyaXZlciBk YXRhIGZvciBhIGRldmljZSBzaG91bGQgbmV2ZXIgYmUgbnVsbCBhdCB0aGlzIHBvaW50ICovCisJ aWYgKCFkZXZfZGF0YSkgeworCQllcnIgPSAtRU5YSU87CisJCWdvdG8gcmVsZWFzZTsKKwl9CisJ ZGV2X2RhdGEtPmFsbG93X2ludGVycnVwdF9jb250cm9sID0gMTsKK3JlbGVhc2U6CisJcGNpc3R1 Yl9kZXZpY2VfcHV0KHBzZGV2KTsKK291dDoKKwlpZiAoIWVycikKKwkJZXJyID0gY291bnQ7CisJ cmV0dXJuIGVycjsKK30KKworc3RhdGljIHNzaXplX3QgYWxsb3dfaW50ZXJydXB0X2NvbnRyb2xf c2hvdyhzdHJ1Y3QgZGV2aWNlX2RyaXZlciAqZHJ2LAorCQkJCQkgICAgY2hhciAqYnVmKQorewor CXN0cnVjdCBwY2lzdHViX2RldmljZSAqcHNkZXY7CisJc3RydWN0IHhlbl9wY2lia19kZXZfZGF0 YSAqZGV2X2RhdGE7CisJc2l6ZV90IGNvdW50ID0gMDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwor CisJc3Bpbl9sb2NrX2lycXNhdmUoJnBjaXN0dWJfZGV2aWNlc19sb2NrLCBmbGFncyk7CisJbGlz dF9mb3JfZWFjaF9lbnRyeShwc2RldiwgJnBjaXN0dWJfZGV2aWNlcywgZGV2X2xpc3QpIHsKKwkJ aWYgKGNvdW50ID49IFBBR0VfU0laRSkKKwkJCWJyZWFrOworCQlpZiAoIXBzZGV2LT5kZXYpCisJ CQljb250aW51ZTsKKwkJZGV2X2RhdGEgPSBwY2lfZ2V0X2RydmRhdGEocHNkZXYtPmRldik7CisJ CWlmICghZGV2X2RhdGEgfHwgIWRldl9kYXRhLT5hbGxvd19pbnRlcnJ1cHRfY29udHJvbCkKKwkJ CWNvbnRpbnVlOworCQljb3VudCArPQorCQkgICAgc2NucHJpbnRmKGJ1ZiArIGNvdW50LCBQQUdF X1NJWkUgLSBjb3VudCwgIiVzXG4iLAorCQkJICAgICAgcGNpX25hbWUocHNkZXYtPmRldikpOwor CX0KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwY2lzdHViX2RldmljZXNfbG9jaywgZmxhZ3Mp OworCXJldHVybiBjb3VudDsKK30KK3N0YXRpYyBEUklWRVJfQVRUUl9SVyhhbGxvd19pbnRlcnJ1 cHRfY29udHJvbCk7CisKIHN0YXRpYyB2b2lkIHBjaXN0dWJfZXhpdCh2b2lkKQogewogCWRyaXZl cl9yZW1vdmVfZmlsZSgmeGVuX3BjaWJrX3BjaV9kcml2ZXIuZHJpdmVyLCAmZHJpdmVyX2F0dHJf bmV3X3Nsb3QpOwpAQCAtMTQ0MCw2ICsxNTAxLDggQEAgc3RhdGljIHZvaWQgcGNpc3R1Yl9leGl0 KHZvaWQpCiAJZHJpdmVyX3JlbW92ZV9maWxlKCZ4ZW5fcGNpYmtfcGNpX2RyaXZlci5kcml2ZXIs ICZkcml2ZXJfYXR0cl9xdWlya3MpOwogCWRyaXZlcl9yZW1vdmVfZmlsZSgmeGVuX3BjaWJrX3Bj aV9kcml2ZXIuZHJpdmVyLAogCQkJICAgJmRyaXZlcl9hdHRyX3Blcm1pc3NpdmUpOworCWRyaXZl cl9yZW1vdmVfZmlsZSgmeGVuX3BjaWJrX3BjaV9kcml2ZXIuZHJpdmVyLAorCQkJICAgJmRyaXZl cl9hdHRyX2FsbG93X2ludGVycnVwdF9jb250cm9sKTsKIAlkcml2ZXJfcmVtb3ZlX2ZpbGUoJnhl bl9wY2lia19wY2lfZHJpdmVyLmRyaXZlciwKIAkJCSAgICZkcml2ZXJfYXR0cl9pcnFfaGFuZGxl cnMpOwogCWRyaXZlcl9yZW1vdmVfZmlsZSgmeGVuX3BjaWJrX3BjaV9kcml2ZXIuZHJpdmVyLApA QCAtMTUzMCw2ICsxNTkzLDkgQEAgc3RhdGljIGludCBfX2luaXQgcGNpc3R1Yl9pbml0KHZvaWQp CiAJaWYgKCFlcnIpCiAJCWVyciA9IGRyaXZlcl9jcmVhdGVfZmlsZSgmeGVuX3BjaWJrX3BjaV9k cml2ZXIuZHJpdmVyLAogCQkJCQkgJmRyaXZlcl9hdHRyX3Blcm1pc3NpdmUpOworCWlmICghZXJy KQorCQllcnIgPSBkcml2ZXJfY3JlYXRlX2ZpbGUoJnhlbl9wY2lia19wY2lfZHJpdmVyLmRyaXZl ciwKKwkJCQkJICZkcml2ZXJfYXR0cl9hbGxvd19pbnRlcnJ1cHRfY29udHJvbCk7CiAKIAlpZiAo IWVycikKIAkJZXJyID0gZHJpdmVyX2NyZWF0ZV9maWxlKCZ4ZW5fcGNpYmtfcGNpX2RyaXZlci5k cml2ZXIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9wY2liYWNrLmggYi9k cml2ZXJzL3hlbi94ZW4tcGNpYmFjay9wY2liYWNrLmgKaW5kZXggMjYzYzA1OWJmZjkwLi5jZTEw NzdlMzI0NjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL3hlbi1wY2liYWNrL3BjaWJhY2suaAor KysgYi9kcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9wY2liYWNrLmgKQEAgLTQ1LDYgKzQ1LDcgQEAg c3RydWN0IHhlbl9wY2lia19kZXZfZGF0YSB7CiAJc3RydWN0IGxpc3RfaGVhZCBjb25maWdfZmll bGRzOwogCXN0cnVjdCBwY2lfc2F2ZWRfc3RhdGUgKnBjaV9zYXZlZF9zdGF0ZTsKIAl1bnNpZ25l ZCBpbnQgcGVybWlzc2l2ZToxOworCXVuc2lnbmVkIGludCBhbGxvd19pbnRlcnJ1cHRfY29udHJv bDoxOwogCXVuc2lnbmVkIGludCB3YXJuZWRfb25fd3JpdGU6MTsKIAl1bnNpZ25lZCBpbnQgZW5h YmxlX2ludHg6MTsKIAl1bnNpZ25lZCBpbnQgaXNyX29uOjE7IC8qIFdoZXRoZXIgdGhlIElSUSBo YW5kbGVyIGlzIGluc3RhbGxlZC4gKi8KLS0gCjIuMjEuMAoKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRl dmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJvamVjdC5vcmcvbWFp bG1hbi9saXN0aW5mby94ZW4tZGV2ZWw=