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 2829BC432C0 for ; Tue, 3 Dec 2019 05:44:06 +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 DF1D2206DF for ; Tue, 3 Dec 2019 05:44:05 +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="KPpbG0aW" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org DF1D2206DF 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 1ic0y9-0005kn-SN; Tue, 03 Dec 2019 05:43:29 +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 1ic0y8-0005ki-Mo for xen-devel@lists.xenproject.org; Tue, 03 Dec 2019 05:43:28 +0000 X-Inumbo-ID: d38f3392-158f-11ea-81cc-12813bfff9fa Received: from wout1-smtp.messagingengine.com (unknown [64.147.123.24]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id d38f3392-158f-11ea-81cc-12813bfff9fa; Tue, 03 Dec 2019 05:43:26 +0000 (UTC) Received: from compute7.internal (compute7.nyi.internal [10.202.2.47]) by mailout.west.internal (Postfix) with ESMTP id 2D2E1C8F; Tue, 3 Dec 2019 00:43:25 -0500 (EST) Received: from mailfrontend1 ([10.202.2.162]) by compute7.internal (MEProxy); Tue, 03 Dec 2019 00:43:25 -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=Au0sk+ xl/cZ8hI+5WvyE3tKwAjfm2QQqUf4iEBuIseM=; b=KPpbG0aWTbWbuuFica4AC1 ePvz1sgqjSuHxawCY/9vnuPNC+mOYXnUOAnTFQCNZXGH+54yZZauDnNjS6NMtbsR LVYj1Z+2FSKNLia1h+ezU1dJ+DpM3v9RANFCse6kUJh5o9Q9sUFwFsa4qycljS9I fecL8TydfmrA4aOYPp8MJf0WYLFm2ebvIet8lKsepO14Hflqslpr1a8bGwhD1qov bZwIhtAFjnNcrpRrVp+3UxssohYFlMU2om6yiGmCZq8Axh3LMiE6s7pd6q8bGvRy RIDJk89Owh6DeR6zug1c2DE4uGrFZup1zv2AXzQZWJdatholiFHBFuGIKDlm10xA == X-ME-Sender: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedufedrudejiedgkeegucetufdoteggodetrfdotf 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 B07B980059; Tue, 3 Dec 2019 00:43:22 -0500 (EST) From: =?UTF-8?q?Marek=20Marczykowski-G=C3=B3recki?= To: xen-devel@lists.xenproject.org Date: Tue, 3 Dec 2019 06:41:56 +0100 Message-Id: <20191203054222.7966-1-marmarek@invisiblethingslab.com> X-Mailer: git-send-email 2.21.0 MIME-Version: 1.0 Organization: Invisible Things Lab Subject: [Xen-devel] [PATCH v1] 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 , Ross Lagerwall , 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 aS1Hw7NyZWNraSA8bWFybWFyZWtAaW52aXNpYmxldGhpbmdzbGFiLmNvbT4KLS0tCkknbSBub3Qg dmVyeSBoYXBweSBhYm91dCBjb2RlIGR1cGxpY2F0aW9uIHJlZ2FyZGluZyBNU0kvTVNJLVgvSU5U eApleGNsdXNpdml0eSB0ZXN0LCBidXQgSSBkb24ndCBoYXZlIGJldHRlciBpZGVhcyBob3cgdG8g c3RydWN0dXJlIGl0LiBBbnkKc3VnZ2VzdGlvbnM/Ci0tLQogLi4uL3hlbi94ZW4tcGNpYmFjay9j b25mX3NwYWNlX2NhcGFiaWxpdHkuYyAgIHwgMTEzICsrKysrKysrKysrKysrKysrKwogZHJpdmVy cy94ZW4veGVuLXBjaWJhY2svY29uZl9zcGFjZV9oZWFkZXIuYyAgIHwgIDMwICsrKysrCiBkcml2 ZXJzL3hlbi94ZW4tcGNpYmFjay9wY2lfc3R1Yi5jICAgICAgICAgICAgfCAgNjYgKysrKysrKysr KwogZHJpdmVycy94ZW4veGVuLXBjaWJhY2svcGNpYmFjay5oICAgICAgICAgICAgIHwgICAxICsK IDQgZmlsZXMgY2hhbmdlZCwgMjEwIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJz L3hlbi94ZW4tcGNpYmFjay9jb25mX3NwYWNlX2NhcGFiaWxpdHkuYyBiL2RyaXZlcnMveGVuL3hl bi1wY2liYWNrL2NvbmZfc3BhY2VfY2FwYWJpbGl0eS5jCmluZGV4IGU1Njk0MTMzZWJlNS4uYzVh N2M1OGZmM2UzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9jb25mX3NwYWNl X2NhcGFiaWxpdHkuYworKysgYi9kcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9jb25mX3NwYWNlX2Nh cGFiaWxpdHkuYwpAQCAtMTg5LDYgKzE4OSwxMDkgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBjb25m aWdfZmllbGQgY2FwbGlzdF9wbVtdID0gewogCXt9CiB9OwogCitzdGF0aWMgc3RydWN0IG1zaV9t c2l4X2ZpZWxkX2NvbmZpZyB7CisJdTE2IGVuYWJsZV9iaXQ7ICAvKiBiaXQgZm9yIGVuYWJsaW5n IE1TSS9NU0ktWCAqLworCWludCBvdGhlcl9jYXA7ICAvKiB0aGUgb3RoZXIgY2FwYWJpbGl0eSBm b3IgZXhjbHVzaXZlbmVzcyBjaGVjayAqLworfSBtc2lfZmllbGRfY29uZmlnID0geworCS5lbmFi bGVfYml0ID0gUENJX01TSV9GTEFHU19FTkFCTEUsCisJLm90aGVyX2NhcCA9IFBDSV9DQVBfSURf TVNJWCwKK30sIG1zaXhfZmllbGRfY29uZmlnID0geworCS5lbmFibGVfYml0ID0gUENJX01TSVhf RkxBR1NfRU5BQkxFLAorCS5vdGhlcl9jYXAgPSBQQ0lfQ0FQX0lEX01TSSwKK307CisKK3N0YXRp YyB2b2lkICptc2lfZmllbGRfaW5pdChzdHJ1Y3QgcGNpX2RldiAqZGV2LCBpbnQgb2Zmc2V0KQor eworCXJldHVybiAmbXNpX2ZpZWxkX2NvbmZpZzsKK30KKworc3RhdGljIHZvaWQgKm1zaXhfZmll bGRfaW5pdChzdHJ1Y3QgcGNpX2RldiAqZGV2LCBpbnQgb2Zmc2V0KQoreworCXJldHVybiAmbXNp eF9maWVsZF9jb25maWc7Cit9CisKK3N0YXRpYyBpbnQgbXNpX21zaXhfZmxhZ3Nfd3JpdGUoc3Ry dWN0IHBjaV9kZXYgKmRldiwgaW50IG9mZnNldCwgdTE2IG5ld192YWx1ZSwKKwkJCSB2b2lkICpk YXRhKQoreworCWludCBlcnI7CisJdTE2IG9sZF92YWx1ZTsKKwlzdHJ1Y3QgbXNpX21zaXhfZmll bGRfY29uZmlnICpmaWVsZF9jb25maWcgPSBkYXRhOworCXN0cnVjdCB4ZW5fcGNpYmtfZGV2X2Rh dGEgKmRldl9kYXRhID0gcGNpX2dldF9kcnZkYXRhKGRldik7CisJaW50IG90aGVyX2NhcF9vZmZz ZXQ7CisJdTE2IG90aGVyX2NhcF9lbmFibGVfYml0OworCXUxNiBvdGhlcl9jYXBfdmFsdWU7CisK KwlpZiAoeGVuX3BjaWJrX3Blcm1pc3NpdmUgfHwgZGV2X2RhdGEtPnBlcm1pc3NpdmUpCisJCWdv dG8gd3JpdGU7CisKKwllcnIgPSBwY2lfcmVhZF9jb25maWdfd29yZChkZXYsIG9mZnNldCwgJm9s ZF92YWx1ZSk7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKKworCWlmIChuZXdfdmFsdWUgPT0g b2xkX3ZhbHVlKQorCQlyZXR1cm4gMDsKKworCWlmICghZGV2X2RhdGEtPmFsbG93X2ludGVycnVw dF9jb250cm9sIHx8CisJICAgIChuZXdfdmFsdWUgXiBvbGRfdmFsdWUpICYgfmZpZWxkX2NvbmZp Zy0+ZW5hYmxlX2JpdCkKKwkJcmV0dXJuIFBDSUJJT1NfU0VUX0ZBSUxFRDsKKworCWlmIChuZXdf dmFsdWUgJiBmaWVsZF9jb25maWctPmVuYWJsZV9iaXQpIHsKKwkJLyogZG9uJ3QgYWxsb3cgZW5h YmxpbmcgdG9nZXRoZXIgd2l0aCBJTlR4ICovCisJCWVyciA9IHBjaV9yZWFkX2NvbmZpZ193b3Jk KGRldiwgUENJX0NPTU1BTkQsICZvdGhlcl9jYXBfdmFsdWUpOworCQlpZiAoZXJyKQorCQkJcmV0 dXJuIGVycjsKKwkJaWYgKCEob3RoZXJfY2FwX3ZhbHVlICYgUENJX0NPTU1BTkRfSU5UWF9ESVNB QkxFKSkKKwkJCXJldHVybiBQQ0lCSU9TX1NFVF9GQUlMRUQ7CisKKwkJLyogYW5kIHRoZSBvdGhl ciBNU0koLVgpICovCisJCXN3aXRjaCAoZmllbGRfY29uZmlnLT5vdGhlcl9jYXApIHsKKwkJY2Fz ZSBQQ0lfQ0FQX0lEX01TSToKKwkJCW90aGVyX2NhcF9vZmZzZXQgPSBkZXYtPm1zaV9jYXAgKyBQ Q0lfTVNJX0ZMQUdTOworCQkJb3RoZXJfY2FwX2VuYWJsZV9iaXQgPSBQQ0lfTVNJX0ZMQUdTX0VO QUJMRTsKKwkJCWJyZWFrOworCQljYXNlIFBDSV9DQVBfSURfTVNJWDoKKwkJCW90aGVyX2NhcF9v ZmZzZXQgPSBkZXYtPm1zaXhfY2FwICsgUENJX01TSVhfRkxBR1M7CisJCQlvdGhlcl9jYXBfZW5h YmxlX2JpdCA9IFBDSV9NU0lYX0ZMQUdTX0VOQUJMRTsKKwkJCWJyZWFrOworCQlkZWZhdWx0Ogor CQkJQlVHX09OKDEpOworCQl9CisJCWVyciA9IHBjaV9yZWFkX2NvbmZpZ193b3JkKGRldiwKKwkJ CQkJICAgb3RoZXJfY2FwX29mZnNldCwKKwkJCQkJICAgJm90aGVyX2NhcF92YWx1ZSk7CisJCWlm IChlcnIpCisJCQlyZXR1cm4gZXJyOworCisJCWlmIChvdGhlcl9jYXBfdmFsdWUgJiBvdGhlcl9j YXBfZW5hYmxlX2JpdCkKKwkJCXJldHVybiBQQ0lCSU9TX1NFVF9GQUlMRUQ7CisJfQorCit3cml0 ZToKKwlyZXR1cm4gcGNpX3dyaXRlX2NvbmZpZ193b3JkKGRldiwgb2Zmc2V0LCBuZXdfdmFsdWUp OworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGNvbmZpZ19maWVsZCBjYXBsaXN0X21zaXhbXSA9 IHsKKwl7CisJCS5vZmZzZXQgICAgPSBQQ0lfTVNJWF9GTEFHUywKKwkJLnNpemUgICAgICA9IDIs CisJCS5pbml0ICAgICAgPSBtc2l4X2ZpZWxkX2luaXQsCisJCS51LncucmVhZCAgPSB4ZW5fcGNp YmtfcmVhZF9jb25maWdfd29yZCwKKwkJLnUudy53cml0ZSA9IG1zaV9tc2l4X2ZsYWdzX3dyaXRl LAorCX0sCisJe30KK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgY29uZmlnX2ZpZWxkIGNhcGxp c3RfbXNpW10gPSB7CisJeworCQkub2Zmc2V0ICAgID0gUENJX01TSV9GTEFHUywKKwkJLnNpemUg ICAgICA9IDIsCisJCS5pbml0ICAgICAgPSBtc2lfZmllbGRfaW5pdCwKKwkJLnUudy5yZWFkICA9 IHhlbl9wY2lia19yZWFkX2NvbmZpZ193b3JkLAorCQkudS53LndyaXRlID0gbXNpX21zaXhfZmxh Z3Nfd3JpdGUsCisJfSwKKwl7fQorfTsKKwogc3RhdGljIHN0cnVjdCB4ZW5fcGNpYmtfY29uZmln X2NhcGFiaWxpdHkgeGVuX3BjaWJrX2NvbmZpZ19jYXBhYmlsaXR5X3BtID0gewogCS5jYXBhYmls aXR5ID0gUENJX0NBUF9JRF9QTSwKIAkuZmllbGRzID0gY2FwbGlzdF9wbSwKQEAgLTE5NywxMSAr MzAwLDIxIEBAIHN0YXRpYyBzdHJ1Y3QgeGVuX3BjaWJrX2NvbmZpZ19jYXBhYmlsaXR5IHhlbl9w Y2lia19jb25maWdfY2FwYWJpbGl0eV92cGQgPSB7CiAJLmNhcGFiaWxpdHkgPSBQQ0lfQ0FQX0lE X1ZQRCwKIAkuZmllbGRzID0gY2FwbGlzdF92cGQsCiB9Oworc3RhdGljIHN0cnVjdCB4ZW5fcGNp YmtfY29uZmlnX2NhcGFiaWxpdHkgeGVuX3BjaWJrX2NvbmZpZ19jYXBhYmlsaXR5X21zaSA9IHsK KwkuY2FwYWJpbGl0eSA9IFBDSV9DQVBfSURfTVNJLAorCS5maWVsZHMgPSBjYXBsaXN0X21zaSwK K307CitzdGF0aWMgc3RydWN0IHhlbl9wY2lia19jb25maWdfY2FwYWJpbGl0eSB4ZW5fcGNpYmtf Y29uZmlnX2NhcGFiaWxpdHlfbXNpeCA9IHsKKwkuY2FwYWJpbGl0eSA9IFBDSV9DQVBfSURfTVNJ WCwKKwkuZmllbGRzID0gY2FwbGlzdF9tc2l4LAorfTsKIAogaW50IHhlbl9wY2lia19jb25maWdf Y2FwYWJpbGl0eV9pbml0KHZvaWQpCiB7CiAJcmVnaXN0ZXJfY2FwYWJpbGl0eSgmeGVuX3BjaWJr X2NvbmZpZ19jYXBhYmlsaXR5X3ZwZCk7CiAJcmVnaXN0ZXJfY2FwYWJpbGl0eSgmeGVuX3BjaWJr X2NvbmZpZ19jYXBhYmlsaXR5X3BtKTsKKwlyZWdpc3Rlcl9jYXBhYmlsaXR5KCZ4ZW5fcGNpYmtf Y29uZmlnX2NhcGFiaWxpdHlfbXNpKTsKKwlyZWdpc3Rlcl9jYXBhYmlsaXR5KCZ4ZW5fcGNpYmtf Y29uZmlnX2NhcGFiaWxpdHlfbXNpeCk7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2Ry aXZlcnMveGVuL3hlbi1wY2liYWNrL2NvbmZfc3BhY2VfaGVhZGVyLmMgYi9kcml2ZXJzL3hlbi94 ZW4tcGNpYmFjay9jb25mX3NwYWNlX2hlYWRlci5jCmluZGV4IDEwYWUyNGI1YTc2ZS4uMWUwZmZm MDJlMjFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9jb25mX3NwYWNlX2hl YWRlci5jCisrKyBiL2RyaXZlcnMveGVuL3hlbi1wY2liYWNrL2NvbmZfc3BhY2VfaGVhZGVyLmMK QEAgLTY0LDYgKzY0LDcgQEAgc3RhdGljIGludCBjb21tYW5kX3dyaXRlKHN0cnVjdCBwY2lfZGV2 ICpkZXYsIGludCBvZmZzZXQsIHUxNiB2YWx1ZSwgdm9pZCAqZGF0YSkKIAlpbnQgZXJyOwogCXUx NiB2YWw7CiAJc3RydWN0IHBjaV9jbWRfaW5mbyAqY21kID0gZGF0YTsKKwl1MTYgY2FwX3ZhbHVl OwogCiAJZGV2X2RhdGEgPSBwY2lfZ2V0X2RydmRhdGEoZGV2KTsKIAlpZiAoIXBjaV9pc19lbmFi bGVkKGRldikgJiYgaXNfZW5hYmxlX2NtZCh2YWx1ZSkpIHsKQEAgLTExNyw2ICsxMTgsMzUgQEAg c3RhdGljIGludCBjb21tYW5kX3dyaXRlKHN0cnVjdCBwY2lfZGV2ICpkZXYsIGludCBvZmZzZXQs IHUxNiB2YWx1ZSwgdm9pZCAqZGF0YSkKIAkJcGNpX2NsZWFyX213aShkZXYpOwogCX0KIAorCWlm IChkZXZfZGF0YSAmJiBkZXZfZGF0YS0+YWxsb3dfaW50ZXJydXB0X2NvbnRyb2wpIHsKKwkJaWYg KCEoY21kLT52YWwgJiBQQ0lfQ09NTUFORF9JTlRYX0RJU0FCTEUpICYmCisJCSAgICAodmFsdWUg JiBQQ0lfQ09NTUFORF9JTlRYX0RJU0FCTEUpKSB7CisJCQlwY2lfaW50eChkZXYsIDApOworCQl9 IGVsc2UgaWYgKChjbWQtPnZhbCAmIFBDSV9DT01NQU5EX0lOVFhfRElTQUJMRSkgJiYKKwkJICAg ICEodmFsdWUgJiBQQ0lfQ09NTUFORF9JTlRYX0RJU0FCTEUpKSB7CisJCQkvKiBEbyBub3QgYWxs b3cgZW5hYmxpbmcgSU5UeCB0b2dldGhlciB3aXRoIE1TSSBvciBNU0ktWC4gKi8KKwkJCS8qIERv IG5vdCB0cnVzdCBkZXYtPm1zaSh4KV9lbmFibGVkIGhlcmUsIGFzIGVuYWJsaW5nIGNvdWxkIGJl IGRvbmUKKwkJCSAqIGJ5cGFzc2luZyB0aGUgcGNpXyptc2kqIGZ1bmN0aW9ucywgYnkgdGhlIHFl bXUuCisJCQkgKi8KKwkJCWVyciA9IHBjaV9yZWFkX2NvbmZpZ193b3JkKGRldiwKKwkJCQkJCSAg IGRldi0+bXNpX2NhcCArIFBDSV9NU0lfRkxBR1MsCisJCQkJCQkgICAmY2FwX3ZhbHVlKTsKKwkJ CWlmICghZXJyICYmIChjYXBfdmFsdWUgJiBQQ0lfTVNJX0ZMQUdTX0VOQUJMRSkpCisJCQkJZXJy ID0gLUVCVVNZOworCQkJaWYgKCFlcnIpCisJCQkJZXJyID0gcGNpX3JlYWRfY29uZmlnX3dvcmQo ZGV2LAorCQkJCQkJCSAgIGRldi0+bXNpeF9jYXAgKyBQQ0lfTVNJWF9GTEFHUywKKwkJCQkJCQkg ICAmY2FwX3ZhbHVlKTsKKwkJCWlmICghZXJyICYmIChjYXBfdmFsdWUgJiBQQ0lfTVNJWF9GTEFH U19FTkFCTEUpKQorCQkJCWVyciA9IC1FQlVTWTsKKwkJCWlmIChlcnIpCisJCQkJcHJfd2Fybigi JXM6IGNhbm5vdCBlbmFibGUgSU5UeCAoJWQpXG4iLAorCQkJCQlwY2lfbmFtZShkZXYpLCBlcnIp OworCQkJZWxzZQorCQkJCXBjaV9pbnR4KGRldiwgMSk7CisJCX0KKwl9CisKIAljbWQtPnZhbCA9 IHZhbHVlOwogCiAJaWYgKCF4ZW5fcGNpYmtfcGVybWlzc2l2ZSAmJiAoIWRldl9kYXRhIHx8ICFk ZXZfZGF0YS0+cGVybWlzc2l2ZSkpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi94ZW4tcGNpYmFj ay9wY2lfc3R1Yi5jIGIvZHJpdmVycy94ZW4veGVuLXBjaWJhY2svcGNpX3N0dWIuYwppbmRleCAw OTc0MTBhN2NkYjcuLjdhZjkzZDY1ZWQ1MSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4veGVuLXBj aWJhY2svcGNpX3N0dWIuYworKysgYi9kcml2ZXJzL3hlbi94ZW4tcGNpYmFjay9wY2lfc3R1Yi5j CkBAIC0zMDQsNiArMzA0LDggQEAgdm9pZCBwY2lzdHViX3B1dF9wY2lfZGV2KHN0cnVjdCBwY2lf ZGV2ICpkZXYpCiAJeGVuX3BjaWJrX2NvbmZpZ19yZXNldF9kZXYoZGV2KTsKIAl4ZW5fcGNpYmtf Y29uZmlnX2ZyZWVfZHluX2ZpZWxkcyhkZXYpOwogCisJZGV2X2RhdGEtPmFsbG93X2ludGVycnVw dF9jb250cm9sID0gMDsKKwogCXhlbl91bnJlZ2lzdGVyX2RldmljZV9kb21haW5fb3duZXIoZGV2 KTsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZmb3VuZF9wc2Rldi0+bG9jaywgZmxhZ3MpOwpAQCAt MTQzMSw2ICsxNDMzLDY1IEBAIHN0YXRpYyBzc2l6ZV90IHBlcm1pc3NpdmVfc2hvdyhzdHJ1Y3Qg ZGV2aWNlX2RyaXZlciAqZHJ2LCBjaGFyICpidWYpCiB9CiBzdGF0aWMgRFJJVkVSX0FUVFJfUlco cGVybWlzc2l2ZSk7CiAKK3N0YXRpYyBzc2l6ZV90IGFsbG93X2ludGVycnVwdF9jb250cm9sX3N0 b3JlKHN0cnVjdCBkZXZpY2VfZHJpdmVyICpkcnYsCisJCQkJCSAgICAgY29uc3QgY2hhciAqYnVm LCBzaXplX3QgY291bnQpCit7CisJaW50IGRvbWFpbiwgYnVzLCBzbG90LCBmdW5jOworCWludCBl cnI7CisJc3RydWN0IHBjaXN0dWJfZGV2aWNlICpwc2RldjsKKwlzdHJ1Y3QgeGVuX3BjaWJrX2Rl dl9kYXRhICpkZXZfZGF0YTsKKworCWVyciA9IHN0cl90b19zbG90KGJ1ZiwgJmRvbWFpbiwgJmJ1 cywgJnNsb3QsICZmdW5jKTsKKwlpZiAoZXJyKQorCQlnb3RvIG91dDsKKworCXBzZGV2ID0gcGNp c3R1Yl9kZXZpY2VfZmluZChkb21haW4sIGJ1cywgc2xvdCwgZnVuYyk7CisJaWYgKCFwc2Rldikg eworCQllcnIgPSAtRU5PREVWOworCQlnb3RvIG91dDsKKwl9CisKKwlkZXZfZGF0YSA9IHBjaV9n ZXRfZHJ2ZGF0YShwc2Rldi0+ZGV2KTsKKwkvKiB0aGUgZHJpdmVyIGRhdGEgZm9yIGEgZGV2aWNl IHNob3VsZCBuZXZlciBiZSBudWxsIGF0IHRoaXMgcG9pbnQgKi8KKwlpZiAoIWRldl9kYXRhKSB7 CisJCWVyciA9IC1FTlhJTzsKKwkJZ290byByZWxlYXNlOworCX0KKwlkZXZfZGF0YS0+YWxsb3df aW50ZXJydXB0X2NvbnRyb2wgPSAxOworcmVsZWFzZToKKwlwY2lzdHViX2RldmljZV9wdXQocHNk ZXYpOworb3V0OgorCWlmICghZXJyKQorCQllcnIgPSBjb3VudDsKKwlyZXR1cm4gZXJyOworfQor CitzdGF0aWMgc3NpemVfdCBhbGxvd19pbnRlcnJ1cHRfY29udHJvbF9zaG93KHN0cnVjdCBkZXZp Y2VfZHJpdmVyICpkcnYsCisJCQkJCSAgICBjaGFyICpidWYpCit7CisJc3RydWN0IHBjaXN0dWJf ZGV2aWNlICpwc2RldjsKKwlzdHJ1Y3QgeGVuX3BjaWJrX2Rldl9kYXRhICpkZXZfZGF0YTsKKwlz aXplX3QgY291bnQgPSAwOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJx c2F2ZSgmcGNpc3R1Yl9kZXZpY2VzX2xvY2ssIGZsYWdzKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5 KHBzZGV2LCAmcGNpc3R1Yl9kZXZpY2VzLCBkZXZfbGlzdCkgeworCQlpZiAoY291bnQgPj0gUEFH RV9TSVpFKQorCQkJYnJlYWs7CisJCWlmICghcHNkZXYtPmRldikKKwkJCWNvbnRpbnVlOworCQlk ZXZfZGF0YSA9IHBjaV9nZXRfZHJ2ZGF0YShwc2Rldi0+ZGV2KTsKKwkJaWYgKCFkZXZfZGF0YSB8 fCAhZGV2X2RhdGEtPmFsbG93X2ludGVycnVwdF9jb250cm9sKQorCQkJY29udGludWU7CisJCWNv dW50ICs9CisJCSAgICBzY25wcmludGYoYnVmICsgY291bnQsIFBBR0VfU0laRSAtIGNvdW50LCAi JXNcbiIsCisJCQkgICAgICBwY2lfbmFtZShwc2Rldi0+ZGV2KSk7CisJfQorCXNwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJnBjaXN0dWJfZGV2aWNlc19sb2NrLCBmbGFncyk7CisJcmV0dXJuIGNvdW50 OworfQorc3RhdGljIERSSVZFUl9BVFRSX1JXKGFsbG93X2ludGVycnVwdF9jb250cm9sKTsKKwog c3RhdGljIHZvaWQgcGNpc3R1Yl9leGl0KHZvaWQpCiB7CiAJZHJpdmVyX3JlbW92ZV9maWxlKCZ4 ZW5fcGNpYmtfcGNpX2RyaXZlci5kcml2ZXIsICZkcml2ZXJfYXR0cl9uZXdfc2xvdCk7CkBAIC0x NDQwLDYgKzE1MDEsOCBAQCBzdGF0aWMgdm9pZCBwY2lzdHViX2V4aXQodm9pZCkKIAlkcml2ZXJf cmVtb3ZlX2ZpbGUoJnhlbl9wY2lia19wY2lfZHJpdmVyLmRyaXZlciwgJmRyaXZlcl9hdHRyX3F1 aXJrcyk7CiAJZHJpdmVyX3JlbW92ZV9maWxlKCZ4ZW5fcGNpYmtfcGNpX2RyaXZlci5kcml2ZXIs CiAJCQkgICAmZHJpdmVyX2F0dHJfcGVybWlzc2l2ZSk7CisJZHJpdmVyX3JlbW92ZV9maWxlKCZ4 ZW5fcGNpYmtfcGNpX2RyaXZlci5kcml2ZXIsCisJCQkgICAmZHJpdmVyX2F0dHJfYWxsb3dfaW50 ZXJydXB0X2NvbnRyb2wpOwogCWRyaXZlcl9yZW1vdmVfZmlsZSgmeGVuX3BjaWJrX3BjaV9kcml2 ZXIuZHJpdmVyLAogCQkJICAgJmRyaXZlcl9hdHRyX2lycV9oYW5kbGVycyk7CiAJZHJpdmVyX3Jl bW92ZV9maWxlKCZ4ZW5fcGNpYmtfcGNpX2RyaXZlci5kcml2ZXIsCkBAIC0xNTMwLDYgKzE1OTMs OSBAQCBzdGF0aWMgaW50IF9faW5pdCBwY2lzdHViX2luaXQodm9pZCkKIAlpZiAoIWVycikKIAkJ ZXJyID0gZHJpdmVyX2NyZWF0ZV9maWxlKCZ4ZW5fcGNpYmtfcGNpX2RyaXZlci5kcml2ZXIsCiAJ CQkJCSAmZHJpdmVyX2F0dHJfcGVybWlzc2l2ZSk7CisJaWYgKCFlcnIpCisJCWVyciA9IGRyaXZl cl9jcmVhdGVfZmlsZSgmeGVuX3BjaWJrX3BjaV9kcml2ZXIuZHJpdmVyLAorCQkJCQkgJmRyaXZl cl9hdHRyX2FsbG93X2ludGVycnVwdF9jb250cm9sKTsKIAogCWlmICghZXJyKQogCQllcnIgPSBk cml2ZXJfY3JlYXRlX2ZpbGUoJnhlbl9wY2lia19wY2lfZHJpdmVyLmRyaXZlciwKZGlmZiAtLWdp dCBhL2RyaXZlcnMveGVuL3hlbi1wY2liYWNrL3BjaWJhY2suaCBiL2RyaXZlcnMveGVuL3hlbi1w Y2liYWNrL3BjaWJhY2suaAppbmRleCAyNjNjMDU5YmZmOTAuLmNlMTA3N2UzMjQ2NiAxMDA2NDQK LS0tIGEvZHJpdmVycy94ZW4veGVuLXBjaWJhY2svcGNpYmFjay5oCisrKyBiL2RyaXZlcnMveGVu L3hlbi1wY2liYWNrL3BjaWJhY2suaApAQCAtNDUsNiArNDUsNyBAQCBzdHJ1Y3QgeGVuX3BjaWJr X2Rldl9kYXRhIHsKIAlzdHJ1Y3QgbGlzdF9oZWFkIGNvbmZpZ19maWVsZHM7CiAJc3RydWN0IHBj aV9zYXZlZF9zdGF0ZSAqcGNpX3NhdmVkX3N0YXRlOwogCXVuc2lnbmVkIGludCBwZXJtaXNzaXZl OjE7CisJdW5zaWduZWQgaW50IGFsbG93X2ludGVycnVwdF9jb250cm9sOjE7CiAJdW5zaWduZWQg aW50IHdhcm5lZF9vbl93cml0ZToxOwogCXVuc2lnbmVkIGludCBlbmFibGVfaW50eDoxOwogCXVu c2lnbmVkIGludCBpc3Jfb246MTsgLyogV2hldGhlciB0aGUgSVJRIGhhbmRsZXIgaXMgaW5zdGFs bGVkLiAqLwotLSAKMi4yMS4wCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KWGVuLWRldmVsIG1haWxpbmcgbGlzdApYZW4tZGV2ZWxAbGlzdHMueGVucHJv amVjdC5vcmcKaHR0cHM6Ly9saXN0cy54ZW5wcm9qZWN0Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL3hl bi1kZXZlbA== 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 9FB2EC432C0 for ; Tue, 3 Dec 2019 05:43:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 60F76206DF for ; Tue, 3 Dec 2019 05:43:28 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=messagingengine.com header.i=@messagingengine.com header.b="KPpbG0aW" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727060AbfLCFn1 (ORCPT ); Tue, 3 Dec 2019 00:43:27 -0500 Received: from wout1-smtp.messagingengine.com ([64.147.123.24]:38547 "EHLO wout1-smtp.messagingengine.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726805AbfLCFn1 (ORCPT ); Tue, 3 Dec 2019 00:43:27 -0500 Received: from compute7.internal (compute7.nyi.internal [10.202.2.47]) by mailout.west.internal (Postfix) with ESMTP id 2D2E1C8F; Tue, 3 Dec 2019 00:43:25 -0500 (EST) Received: from mailfrontend1 ([10.202.2.162]) by compute7.internal (MEProxy); Tue, 03 Dec 2019 00:43:25 -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=Au0sk+ xl/cZ8hI+5WvyE3tKwAjfm2QQqUf4iEBuIseM=; b=KPpbG0aWTbWbuuFica4AC1 ePvz1sgqjSuHxawCY/9vnuPNC+mOYXnUOAnTFQCNZXGH+54yZZauDnNjS6NMtbsR LVYj1Z+2FSKNLia1h+ezU1dJ+DpM3v9RANFCse6kUJh5o9Q9sUFwFsa4qycljS9I fecL8TydfmrA4aOYPp8MJf0WYLFm2ebvIet8lKsepO14Hflqslpr1a8bGwhD1qov bZwIhtAFjnNcrpRrVp+3UxssohYFlMU2om6yiGmCZq8Axh3LMiE6s7pd6q8bGvRy RIDJk89Owh6DeR6zug1c2DE4uGrFZup1zv2AXzQZWJdatholiFHBFuGIKDlm10xA == X-ME-Sender: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedufedrudejiedgkeegucetufdoteggodetrfdotf 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 B07B980059; Tue, 3 Dec 2019 00:43:22 -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?= , Simon Gaiser , Boris Ostrovsky , Juergen Gross , Stefano Stabellini , YueHaibing , Ross Lagerwall , linux-kernel@vger.kernel.org (open list) Subject: [PATCH v1] xen-pciback: optionally allow interrupt enable flag writes Date: Tue, 3 Dec 2019 06:41:56 +0100 Message-Id: <20191203054222.7966-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 --- I'm not very happy about code duplication regarding MSI/MSI-X/INTx exclusivity test, but I don't have better ideas how to structure it. Any suggestions? --- .../xen/xen-pciback/conf_space_capability.c | 113 ++++++++++++++++++ drivers/xen/xen-pciback/conf_space_header.c | 30 +++++ drivers/xen/xen-pciback/pci_stub.c | 66 ++++++++++ drivers/xen/xen-pciback/pciback.h | 1 + 4 files changed, 210 insertions(+) diff --git a/drivers/xen/xen-pciback/conf_space_capability.c b/drivers/xen/xen-pciback/conf_space_capability.c index e5694133ebe5..c5a7c58ff3e3 100644 --- a/drivers/xen/xen-pciback/conf_space_capability.c +++ b/drivers/xen/xen-pciback/conf_space_capability.c @@ -189,6 +189,109 @@ static const struct config_field caplist_pm[] = { {} }; +static struct msi_msix_field_config { + u16 enable_bit; /* bit for enabling MSI/MSI-X */ + int other_cap; /* the other capability for exclusiveness check */ +} msi_field_config = { + .enable_bit = PCI_MSI_FLAGS_ENABLE, + .other_cap = PCI_CAP_ID_MSIX, +}, msix_field_config = { + .enable_bit = PCI_MSIX_FLAGS_ENABLE, + .other_cap = PCI_CAP_ID_MSI, +}; + +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; + struct msi_msix_field_config *field_config = data; + struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev); + int other_cap_offset; + u16 other_cap_enable_bit; + u16 other_cap_value; + + 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 INTx */ + err = pci_read_config_word(dev, PCI_COMMAND, &other_cap_value); + if (err) + return err; + if (!(other_cap_value & PCI_COMMAND_INTX_DISABLE)) + return PCIBIOS_SET_FAILED; + + /* and the other MSI(-X) */ + switch (field_config->other_cap) { + case PCI_CAP_ID_MSI: + other_cap_offset = dev->msi_cap + PCI_MSI_FLAGS; + other_cap_enable_bit = PCI_MSI_FLAGS_ENABLE; + break; + case PCI_CAP_ID_MSIX: + other_cap_offset = dev->msix_cap + PCI_MSIX_FLAGS; + other_cap_enable_bit = PCI_MSIX_FLAGS_ENABLE; + break; + default: + BUG_ON(1); + } + err = pci_read_config_word(dev, + other_cap_offset, + &other_cap_value); + if (err) + return err; + + if (other_cap_value & other_cap_enable_bit) + 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 +300,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..1e0fff02e21b 100644 --- a/drivers/xen/xen-pciback/conf_space_header.c +++ b/drivers/xen/xen-pciback/conf_space_header.c @@ -64,6 +64,7 @@ static int command_write(struct pci_dev *dev, int offset, u16 value, void *data) int err; u16 val; struct pci_cmd_info *cmd = data; + u16 cap_value; dev_data = pci_get_drvdata(dev); if (!pci_is_enabled(dev) && is_enable_cmd(value)) { @@ -117,6 +118,35 @@ 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 & PCI_COMMAND_INTX_DISABLE) && + (value & PCI_COMMAND_INTX_DISABLE)) { + pci_intx(dev, 0); + } else if ((cmd->val & PCI_COMMAND_INTX_DISABLE) && + !(value & PCI_COMMAND_INTX_DISABLE)) { + /* Do not allow enabling INTx together with MSI or MSI-X. */ + /* Do not trust dev->msi(x)_enabled here, as enabling could be done + * bypassing the pci_*msi* functions, by the qemu. + */ + err = pci_read_config_word(dev, + dev->msi_cap + PCI_MSI_FLAGS, + &cap_value); + if (!err && (cap_value & PCI_MSI_FLAGS_ENABLE)) + err = -EBUSY; + if (!err) + err = pci_read_config_word(dev, + dev->msix_cap + PCI_MSIX_FLAGS, + &cap_value); + if (!err && (cap_value & PCI_MSIX_FLAGS_ENABLE)) + err = -EBUSY; + if (err) + pr_warn("%s: cannot enable INTx (%d)\n", + pci_name(dev), err); + else + pci_intx(dev, 1); + } + } + 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