From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lu Baolu Subject: [PATCH v2 01/12] iommu/vt-d: Enumerate the scalable mode capability Date: Thu, 30 Aug 2018 09:35:13 +0800 Message-ID: <20180830013524.28743-2-baolu.lu@linux.intel.com> References: <20180830013524.28743-1-baolu.lu@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20180830013524.28743-1-baolu.lu-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: iommu-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org Errors-To: iommu-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org To: Joerg Roedel , David Woodhouse Cc: kevin.tian-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org, ashok.raj-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org, Jean-Philippe Brucker , sanjay.k.kumar-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org, iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, yi.y.sun-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org, jacob.jun.pan-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org List-Id: iommu@lists.linux-foundation.org VGhlIEludGVsIHZ0LWQgc3BlYyByZXYzLjAgaW50cm9kdWNlcyBhIG5ldyB0cmFuc2xhdGlvbgpt b2RlIGNhbGxlZCBzY2FsYWJsZSBtb2RlLCB3aGljaCBlbmFibGVzIFBBU0lELWdyYW51bGFyCnRy YW5zbGF0aW9ucyBmb3IgZmlyc3QgbGV2ZWwsIHNlY29uZCBsZXZlbCwgbmVzdGVkIGFuZApwYXNz LXRocm91Z2ggbW9kZXMuIEF0IHRoZSBzYW1lIHRpbWUsIHRoZSBwcmV2aW91cwpFeHRlbmRlZCBD b250ZXh0IChFQ1MpIG1vZGUgaXMgZGVwcmVjYXRlZCAobm8gcHJvZHVjdGlvbgpldmVyIGltcGxl bWVudHMgRUNTKS4KClRoaXMgcGF0Y2ggYWRkcyBlbnVtZXJhdGlvbiBmb3IgU2NhbGFibGUgTW9k ZSBhbmQgcmVtb3Zlcwp0aGUgZGVwcmVjYXRlZCBFQ1MgZW51bWVyYXRpb24uIEl0IHByb3ZpZGVz IGEgYm9vdCB0aW1lCm9wdGlvbiB0byBkaXNhYmxlIHNjYWxhYmxlIG1vZGUgZXZlbiBoYXJkd2Fy ZSBjbGFpbXMgdG8Kc3VwcG9ydCBpdC4KCkNjOiBBc2hvayBSYWogPGFzaG9rLnJhakBpbnRlbC5j b20+CkNjOiBKYWNvYiBQYW4gPGphY29iLmp1bi5wYW5AbGludXguaW50ZWwuY29tPgpDYzogS2V2 aW4gVGlhbiA8a2V2aW4udGlhbkBpbnRlbC5jb20+CkNjOiBMaXUgWWkgTCA8eWkubC5saXVAaW50 ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBTYW5qYXkgS3VtYXIgPHNhbmpheS5rLmt1bWFyQGludGVs LmNvbT4KU2lnbmVkLW9mZi1ieTogTHUgQmFvbHUgPGJhb2x1Lmx1QGxpbnV4LmludGVsLmNvbT4K UmV2aWV3ZWQtYnk6IEFzaG9rIFJhaiA8YXNob2sucmFqQGludGVsLmNvbT4KLS0tCiAuLi4vYWRt aW4tZ3VpZGUva2VybmVsLXBhcmFtZXRlcnMudHh0ICAgICAgICAgfCAxMiArKy0tCiBkcml2ZXJz L2lvbW11L2ludGVsLWlvbW11LmMgICAgICAgICAgICAgICAgICAgfCA2NCArKysrKy0tLS0tLS0t LS0tLS0tCiBpbmNsdWRlL2xpbnV4L2ludGVsLWlvbW11LmggICAgICAgICAgICAgICAgICAgfCAg MSArCiAzIGZpbGVzIGNoYW5nZWQsIDI0IGluc2VydGlvbnMoKyksIDUzIGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vYWRtaW4tZ3VpZGUva2VybmVsLXBhcmFtZXRlcnMu dHh0IGIvRG9jdW1lbnRhdGlvbi9hZG1pbi1ndWlkZS9rZXJuZWwtcGFyYW1ldGVycy50eHQKaW5k ZXggOTg3MWU2NDlmZmVmLi41Yjk3MTMwNmExMTQgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24v YWRtaW4tZ3VpZGUva2VybmVsLXBhcmFtZXRlcnMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vYWRt aW4tZ3VpZGUva2VybmVsLXBhcmFtZXRlcnMudHh0CkBAIC0xNjY4LDEyICsxNjY4LDEyIEBACiAJ CQlCeSBkZWZhdWx0LCBzdXBlciBwYWdlIHdpbGwgYmUgc3VwcG9ydGVkIGlmIEludGVsIElPTU1V CiAJCQloYXMgdGhlIGNhcGFiaWxpdHkuIFdpdGggdGhpcyBvcHRpb24sIHN1cGVyIHBhZ2Ugd2ls bAogCQkJbm90IGJlIHN1cHBvcnRlZC4KLQkJZWNzX29mZiBbRGVmYXVsdCBPZmZdCi0JCQlCeSBk ZWZhdWx0LCBleHRlbmRlZCBjb250ZXh0IHRhYmxlcyB3aWxsIGJlIHN1cHBvcnRlZCBpZgotCQkJ dGhlIGhhcmR3YXJlIGFkdmVydGlzZXMgdGhhdCBpdCBoYXMgc3VwcG9ydCBib3RoIGZvciB0aGUK LQkJCWV4dGVuZGVkIHRhYmxlcyB0aGVtc2VsdmVzLCBhbmQgYWxzbyBQQVNJRCBzdXBwb3J0LiBX aXRoCi0JCQl0aGlzIG9wdGlvbiBzZXQsIGV4dGVuZGVkIHRhYmxlcyB3aWxsIG5vdCBiZSB1c2Vk IGV2ZW4KLQkJCW9uIGhhcmR3YXJlIHdoaWNoIGNsYWltcyB0byBzdXBwb3J0IHRoZW0uCisJCXNt X29mZiBbRGVmYXVsdCBPZmZdCisJCQlCeSBkZWZhdWx0LCBzY2FsYWJsZSBtb2RlIHdpbGwgYmUg c3VwcG9ydGVkIGlmIHRoZQorCQkJaGFyZHdhcmUgYWR2ZXJ0aXNlcyB0aGF0IGl0IGhhcyBzdXBw b3J0IGZvciB0aGUgc2NhbGFibGUKKwkJCW1vZGUgdHJhbnNsYXRpb24uIFdpdGggdGhpcyBvcHRp b24gc2V0LCBzY2FsYWJsZSBtb2RlCisJCQl3aWxsIG5vdCBiZSB1c2VkIGV2ZW4gb24gaGFyZHdh cmUgd2hpY2ggY2xhaW1zIHRvIHN1cHBvcnQKKwkJCWl0LgogCQl0Ym9vdF9ub2ZvcmNlIFtEZWZh dWx0IE9mZl0KIAkJCURvIG5vdCBmb3JjZSB0aGUgSW50ZWwgSU9NTVUgZW5hYmxlZCB1bmRlciB0 Ym9vdC4KIAkJCUJ5IGRlZmF1bHQsIHRib290IHdpbGwgZm9yY2UgSW50ZWwgSU9NTVUgb24sIHdo aWNoCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lvbW11L2ludGVsLWlvbW11LmMgYi9kcml2ZXJzL2lv bW11L2ludGVsLWlvbW11LmMKaW5kZXggNWYzZjEwY2Y5ZDlkLi41ODQ1ZWRmNGRjZjkgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvaW9tbXUvaW50ZWwtaW9tbXUuYworKysgYi9kcml2ZXJzL2lvbW11L2lu dGVsLWlvbW11LmMKQEAgLTQzMCwzOCArNDMwLDE2IEBAIHN0YXRpYyBpbnQgZG1hcl9tYXBfZ2Z4 ID0gMTsKIHN0YXRpYyBpbnQgZG1hcl9mb3JjZWRhYzsKIHN0YXRpYyBpbnQgaW50ZWxfaW9tbXVf c3RyaWN0Owogc3RhdGljIGludCBpbnRlbF9pb21tdV9zdXBlcnBhZ2UgPSAxOwotc3RhdGljIGlu dCBpbnRlbF9pb21tdV9lY3MgPSAxOwotc3RhdGljIGludCBpbnRlbF9pb21tdV9wYXNpZDI4Owor c3RhdGljIGludCBpbnRlbF9pb21tdV9zbSA9IDE7CiBzdGF0aWMgaW50IGlvbW11X2lkZW50aXR5 X21hcHBpbmc7CiAKICNkZWZpbmUgSURFTlRNQVBfQUxMCQkxCiAjZGVmaW5lIElERU5UTUFQX0dG WAkJMgogI2RlZmluZSBJREVOVE1BUF9BWkFMSUEJCTQKIAotLyogQnJvYWR3ZWxsIGFuZCBTa3ls YWtlIGhhdmUgYnJva2VuIEVDUyBzdXBwb3J0IOKAlCBub3JtYWwgc28tY2FsbGVkICJzZWNvbmQK LSAqIGxldmVsIiB0cmFuc2xhdGlvbiBvZiBETUEgcmVxdWVzdHMtd2l0aG91dC1QQVNJRCBkb2Vz bid0IGFjdHVhbGx5IGhhcHBlbgotICogdW5sZXNzIHlvdSBhbHNvIHNldCB0aGUgTkVTVEUgYml0 IGluIGFuIGV4dGVuZGVkIGNvbnRleHQtZW50cnkuIFdoaWNoIG9mCi0gKiBjb3Vyc2UgbWVhbnMg dGhhdCBTVk0gZG9lc24ndCB3b3JrIGJlY2F1c2UgaXQncyB0cnlpbmcgdG8gZG8gbmVzdGVkCi0g KiB0cmFuc2xhdGlvbiBvZiB0aGUgcGh5c2ljYWwgYWRkcmVzc2VzIGl0IGZpbmRzIGluIHRoZSBw cm9jZXNzIHBhZ2UgdGFibGVzLAotICogdGhyb3VnaCB0aGUgSU9WQS0+cGh5cyBtYXBwaW5nIGZv dW5kIGluIHRoZSAic2Vjb25kIGxldmVsIiBwYWdlIHRhYmxlcy4KLSAqCi0gKiBUaGUgVlQtZCBz cGVjaWZpY2F0aW9uIHdhcyByZXRyb2FjdGl2ZWx5IGNoYW5nZWQgdG8gY2hhbmdlIHRoZSBkZWZp bml0aW9uCi0gKiBvZiB0aGUgY2FwYWJpbGl0eSBiaXRzIGFuZCBwcmV0ZW5kIHRoYXQgQnJvYWR3 ZWxsL1NreWxha2UgbmV2ZXIgaGFwcGVuZWQuLi4KLSAqIGJ1dCB1bmZvcnR1bmF0ZWx5IHRoZSB3 cm9uZyBiaXQgd2FzIGNoYW5nZWQuIEl0J3MgRUNTIHdoaWNoIGlzIGJyb2tlbiwgYnV0Ci0gKiBm b3Igc29tZSByZWFzb24gaXQgd2FzIHRoZSBQQVNJRCBjYXBhYmlsaXR5IGJpdCB3aGljaCB3YXMg cmVkZWZpbmVkIChmcm9tCi0gKiBiaXQgMjggb24gQkRXL1NLTCB0byBiaXQgNDAgaW4gZnV0dXJl KS4KLSAqCi0gKiBTbyBvdXIgdGVzdCBmb3IgRUNTIG5lZWRzIHRvIGVzY2hldyB0aG9zZSBpbXBs ZW1lbnRhdGlvbnMgd2hpY2ggc2V0IHRoZSBvbGQKLSAqIFBBU0lEIGNhcGFiaWl0eSBiaXQgMjgs IHNpbmNlIHRob3NlIGFyZSB0aGUgb25lcyBvbiB3aGljaCBFQ1MgaXMgYnJva2VuLgotICogVW5s ZXNzIHdlIGFyZSB3b3JraW5nIGFyb3VuZCB0aGUgJ3Bhc2lkMjgnIGxpbWl0YXRpb25zLCB0aGF0 IGlzLCBieSBwdXR0aW5nCi0gKiB0aGUgZGV2aWNlIGludG8gcGFzc3Rocm91Z2ggbW9kZSBmb3Ig bm9ybWFsIERNQSBhbmQgdGh1cyBtYXNraW5nIHRoZSBidWcuCi0gKi8KLSNkZWZpbmUgZWNzX2Vu YWJsZWQoaW9tbXUpIChpbnRlbF9pb21tdV9lY3MgJiYgZWNhcF9lY3MoaW9tbXUtPmVjYXApICYm IFwKLQkJCSAgICAoaW50ZWxfaW9tbXVfcGFzaWQyOCB8fCAhZWNhcF9icm9rZW5fcGFzaWQoaW9t bXUtPmVjYXApKSkKLS8qIFBBU0lEIHN1cHBvcnQgaXMgdGh1cyBlbmFibGVkIGlmIEVDUyBpcyBl bmFibGVkIGFuZCAqZWl0aGVyKiBvZiB0aGUgb2xkCi0gKiBvciBuZXcgY2FwYWJpbGl0eSBiaXRz IGFyZSBzZXQuICovCi0jZGVmaW5lIHBhc2lkX2VuYWJsZWQoaW9tbXUpIChlY3NfZW5hYmxlZChp b21tdSkgJiYJCQlcCi0JCQkgICAgICAoZWNhcF9wYXNpZChpb21tdS0+ZWNhcCkgfHwgZWNhcF9i cm9rZW5fcGFzaWQoaW9tbXUtPmVjYXApKSkKKyNkZWZpbmUgc21fc3VwcG9ydGVkKGlvbW11KQko aW50ZWxfaW9tbXVfc20gJiYgZWNhcF9zbXRzKChpb21tdSktPmVjYXApKQorI2RlZmluZSBwYXNp ZF9zdXBwb3J0ZWQoaW9tbXUpCShzbV9zdXBwb3J0ZWQoaW9tbXUpICYmCQkJXAorCQkJCSBlY2Fw X3Bhc2lkKChpb21tdSktPmVjYXApKQogCiBpbnQgaW50ZWxfaW9tbXVfZ2Z4X21hcHBlZDsKIEVY UE9SVF9TWU1CT0xfR1BMKGludGVsX2lvbW11X2dmeF9tYXBwZWQpOwpAQCAtNTQxLDE1ICs1MTks OSBAQCBzdGF0aWMgaW50IF9faW5pdCBpbnRlbF9pb21tdV9zZXR1cChjaGFyICpzdHIpCiAJCX0g ZWxzZSBpZiAoIXN0cm5jbXAoc3RyLCAic3Bfb2ZmIiwgNikpIHsKIAkJCXByX2luZm8oIkRpc2Fi bGUgc3VwcG9ydGVkIHN1cGVyIHBhZ2VcbiIpOwogCQkJaW50ZWxfaW9tbXVfc3VwZXJwYWdlID0g MDsKLQkJfSBlbHNlIGlmICghc3RybmNtcChzdHIsICJlY3Nfb2ZmIiwgNykpIHsKLQkJCXByaW50 ayhLRVJOX0lORk8KLQkJCQkiSW50ZWwtSU9NTVU6IGRpc2FibGUgZXh0ZW5kZWQgY29udGV4dCB0 YWJsZSBzdXBwb3J0XG4iKTsKLQkJCWludGVsX2lvbW11X2VjcyA9IDA7Ci0JCX0gZWxzZSBpZiAo IXN0cm5jbXAoc3RyLCAicGFzaWQyOCIsIDcpKSB7Ci0JCQlwcmludGsoS0VSTl9JTkZPCi0JCQkJ IkludGVsLUlPTU1VOiBlbmFibGUgcHJlLXByb2R1Y3Rpb24gUEFTSUQgc3VwcG9ydFxuIik7Ci0J CQlpbnRlbF9pb21tdV9wYXNpZDI4ID0gMTsKLQkJCWlvbW11X2lkZW50aXR5X21hcHBpbmcgfD0g SURFTlRNQVBfR0ZYOworCQl9IGVsc2UgaWYgKCFzdHJuY21wKHN0ciwgInNtX29mZiIsIDYpKSB7 CisJCQlwcl9pbmZvKCJJbnRlbC1JT01NVTogZGlzYWJsZSBzY2FsYWJsZSBtb2RlIHN1cHBvcnRc biIpOworCQkJaW50ZWxfaW9tbXVfc20gPSAwOwogCQl9IGVsc2UgaWYgKCFzdHJuY21wKHN0ciwg InRib290X25vZm9yY2UiLCAxMykpIHsKIAkJCXByaW50ayhLRVJOX0lORk8KIAkJCQkiSW50ZWwt SU9NTVU6IG5vdCBmb3JjaW5nIG9uIGFmdGVyIHRib290LiBUaGlzIGNvdWxkIGV4cG9zZSBzZWN1 cml0eSByaXNrIGZvciB0Ym9vdFxuIik7CkBAIC03OTYsNyArNzY4LDcgQEAgc3RhdGljIGlubGlu ZSBzdHJ1Y3QgY29udGV4dF9lbnRyeSAqaW9tbXVfY29udGV4dF9hZGRyKHN0cnVjdCBpbnRlbF9p b21tdSAqaW9tbXUKIAl1NjQgKmVudHJ5OwogCiAJZW50cnkgPSAmcm9vdC0+bG87Ci0JaWYgKGVj c19lbmFibGVkKGlvbW11KSkgeworCWlmIChzbV9zdXBwb3J0ZWQoaW9tbXUpKSB7CiAJCWlmIChk ZXZmbiA+PSAweDgwKSB7CiAJCQlkZXZmbiAtPSAweDgwOwogCQkJZW50cnkgPSAmcm9vdC0+aGk7 CkBAIC05MzgsNyArOTEwLDcgQEAgc3RhdGljIHZvaWQgZnJlZV9jb250ZXh0X3RhYmxlKHN0cnVj dCBpbnRlbF9pb21tdSAqaW9tbXUpCiAJCWlmIChjb250ZXh0KQogCQkJZnJlZV9wZ3RhYmxlX3Bh Z2UoY29udGV4dCk7CiAKLQkJaWYgKCFlY3NfZW5hYmxlZChpb21tdSkpCisJCWlmICghc21fc3Vw cG9ydGVkKGlvbW11KSkKIAkJCWNvbnRpbnVlOwogCiAJCWNvbnRleHQgPSBpb21tdV9jb250ZXh0 X2FkZHIoaW9tbXUsIGksIDB4ODAsIDApOwpAQCAtMTI5MCw4ICsxMjYyLDYgQEAgc3RhdGljIHZv aWQgaW9tbXVfc2V0X3Jvb3RfZW50cnkoc3RydWN0IGludGVsX2lvbW11ICppb21tdSkKIAl1bnNp Z25lZCBsb25nIGZsYWc7CiAKIAlhZGRyID0gdmlydF90b19waHlzKGlvbW11LT5yb290X2VudHJ5 KTsKLQlpZiAoZWNzX2VuYWJsZWQoaW9tbXUpKQotCQlhZGRyIHw9IERNQV9SVEFERFJfUlRUOwog CiAJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZpb21tdS0+cmVnaXN0ZXJfbG9jaywgZmxhZyk7CiAJ ZG1hcl93cml0ZXEoaW9tbXUtPnJlZyArIERNQVJfUlRBRERSX1JFRywgYWRkcik7CkBAIC0xNzgw LDcgKzE3NTAsNyBAQCBzdGF0aWMgdm9pZCBmcmVlX2RtYXJfaW9tbXUoc3RydWN0IGludGVsX2lv bW11ICppb21tdSkKIAlmcmVlX2NvbnRleHRfdGFibGUoaW9tbXUpOwogCiAjaWZkZWYgQ09ORklH X0lOVEVMX0lPTU1VX1NWTQotCWlmIChwYXNpZF9lbmFibGVkKGlvbW11KSkgeworCWlmIChwYXNp ZF9zdXBwb3J0ZWQoaW9tbXUpKSB7CiAJCWlmIChlY2FwX3Bycyhpb21tdS0+ZWNhcCkpCiAJCQlp bnRlbF9zdm1fZmluaXNoX3BycShpb21tdSk7CiAJCWludGVsX3N2bV9leGl0KGlvbW11KTsKQEAg LTI0ODksOCArMjQ1OSw4IEBAIHN0YXRpYyBzdHJ1Y3QgZG1hcl9kb21haW4gKmRtYXJfaW5zZXJ0 X29uZV9kZXZfaW5mbyhzdHJ1Y3QgaW50ZWxfaW9tbXUgKmlvbW11LAogCQkgICAgZG1hcl9maW5k X21hdGNoZWRfYXRzcl91bml0KHBkZXYpKQogCQkJaW5mby0+YXRzX3N1cHBvcnRlZCA9IDE7CiAK LQkJaWYgKGVjc19lbmFibGVkKGlvbW11KSkgewotCQkJaWYgKHBhc2lkX2VuYWJsZWQoaW9tbXUp KSB7CisJCWlmIChzbV9zdXBwb3J0ZWQoaW9tbXUpKSB7CisJCQlpZiAocGFzaWRfc3VwcG9ydGVk KGlvbW11KSkgewogCQkJCWludCBmZWF0dXJlcyA9IHBjaV9wYXNpZF9mZWF0dXJlcyhwZGV2KTsK IAkJCQlpZiAoZmVhdHVyZXMgPj0gMCkKIAkJCQkJaW5mby0+cGFzaWRfc3VwcG9ydGVkID0gZmVh dHVyZXMgfCAxOwpAQCAtMzMwMiw3ICszMjcyLDcgQEAgc3RhdGljIGludCBfX2luaXQgaW5pdF9k bWFycyh2b2lkKQogCQkgKiBXZSBuZWVkIHRvIGVuc3VyZSB0aGUgc3lzdGVtIHBhc2lkIHRhYmxl IGlzIG5vIGJpZ2dlcgogCQkgKiB0aGFuIHRoZSBzbWFsbGVzdCBzdXBwb3J0ZWQuCiAJCSAqLwot CQlpZiAocGFzaWRfZW5hYmxlZChpb21tdSkpIHsKKwkJaWYgKHBhc2lkX3N1cHBvcnRlZChpb21t dSkpIHsKIAkJCXUzMiB0ZW1wID0gMiA8PCBlY2FwX3Bzcyhpb21tdS0+ZWNhcCk7CiAKIAkJCWlu dGVsX3Bhc2lkX21heF9pZCA9IG1pbl90KHUzMiwgdGVtcCwKQEAgLTMzNjMsNyArMzMzMyw3IEBA IHN0YXRpYyBpbnQgX19pbml0IGluaXRfZG1hcnModm9pZCkKIAkJaWYgKCFlY2FwX3Bhc3NfdGhy b3VnaChpb21tdS0+ZWNhcCkpCiAJCQlod19wYXNzX3Rocm91Z2ggPSAwOwogI2lmZGVmIENPTkZJ R19JTlRFTF9JT01NVV9TVk0KLQkJaWYgKHBhc2lkX2VuYWJsZWQoaW9tbXUpKQorCQlpZiAocGFz aWRfc3VwcG9ydGVkKGlvbW11KSkKIAkJCWludGVsX3N2bV9pbml0KGlvbW11KTsKICNlbmRpZgog CX0KQEAgLTM0NjcsNyArMzQzNyw3IEBAIHN0YXRpYyBpbnQgX19pbml0IGluaXRfZG1hcnModm9p ZCkKIAkJaW9tbXVfZmx1c2hfd3JpdGVfYnVmZmVyKGlvbW11KTsKIAogI2lmZGVmIENPTkZJR19J TlRFTF9JT01NVV9TVk0KLQkJaWYgKHBhc2lkX2VuYWJsZWQoaW9tbXUpICYmIGVjYXBfcHJzKGlv bW11LT5lY2FwKSkgeworCQlpZiAocGFzaWRfc3VwcG9ydGVkKGlvbW11KSAmJiBlY2FwX3Bycyhp b21tdS0+ZWNhcCkpIHsKIAkJCXJldCA9IGludGVsX3N2bV9lbmFibGVfcHJxKGlvbW11KTsKIAkJ CWlmIChyZXQpCiAJCQkJZ290byBmcmVlX2lvbW11OwpAQCAtNDM1OCw3ICs0MzI4LDcgQEAgc3Rh dGljIGludCBpbnRlbF9pb21tdV9hZGQoc3RydWN0IGRtYXJfZHJoZF91bml0ICpkbWFydSkKIAkJ Z290byBvdXQ7CiAKICNpZmRlZiBDT05GSUdfSU5URUxfSU9NTVVfU1ZNCi0JaWYgKHBhc2lkX2Vu YWJsZWQoaW9tbXUpKQorCWlmIChwYXNpZF9zdXBwb3J0ZWQoaW9tbXUpKQogCQlpbnRlbF9zdm1f aW5pdChpb21tdSk7CiAjZW5kaWYKIApAQCAtNDM3NSw3ICs0MzQ1LDcgQEAgc3RhdGljIGludCBp bnRlbF9pb21tdV9hZGQoc3RydWN0IGRtYXJfZHJoZF91bml0ICpkbWFydSkKIAlpb21tdV9mbHVz aF93cml0ZV9idWZmZXIoaW9tbXUpOwogCiAjaWZkZWYgQ09ORklHX0lOVEVMX0lPTU1VX1NWTQot CWlmIChwYXNpZF9lbmFibGVkKGlvbW11KSAmJiBlY2FwX3Bycyhpb21tdS0+ZWNhcCkpIHsKKwlp ZiAocGFzaWRfc3VwcG9ydGVkKGlvbW11KSAmJiBlY2FwX3Bycyhpb21tdS0+ZWNhcCkpIHsKIAkJ cmV0ID0gaW50ZWxfc3ZtX2VuYWJsZV9wcnEoaW9tbXUpOwogCQlpZiAocmV0KQogCQkJZ290byBk aXNhYmxlX2lvbW11OwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9pbnRlbC1pb21tdS5oIGIv aW5jbHVkZS9saW51eC9pbnRlbC1pb21tdS5oCmluZGV4IDI4MDA0ZDc0YWUwNC4uMjE3M2FlMzVm MWRjIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2ludGVsLWlvbW11LmgKKysrIGIvaW5jbHVk ZS9saW51eC9pbnRlbC1pb21tdS5oCkBAIC0xMTUsNiArMTE1LDcgQEAKICAqIEV4dGVuZGVkIENh cGFiaWxpdHkgUmVnaXN0ZXIKICAqLwogCisjZGVmaW5lIGVjYXBfc210cyhlKQkJKCgoZSkgPj4g NDMpICYgMHgxKQogI2RlZmluZSBlY2FwX2RpdChlKQkJKChlID4+IDQxKSAmIDB4MSkKICNkZWZp bmUgZWNhcF9wYXNpZChlKQkJKChlID4+IDQwKSAmIDB4MSkKICNkZWZpbmUgZWNhcF9wc3MoZSkJ CSgoZSA+PiAzNSkgJiAweDFmKQotLSAKMi4xNy4xCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwppb21tdSBtYWlsaW5nIGxpc3QKaW9tbXVAbGlzdHMubGlu dXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5kYXRpb24ub3JnL21haWxt YW4vbGlzdGluZm8vaW9tbXU= 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=-2.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, MAILING_LIST_MULTI,SPF_PASS,URIBL_BLOCKED,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 D68A4C433F4 for ; Thu, 30 Aug 2018 01:36:49 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 90EA520647 for ; Thu, 30 Aug 2018 01:36:49 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 90EA520647 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727252AbeH3FgP (ORCPT ); Thu, 30 Aug 2018 01:36:15 -0400 Received: from mga12.intel.com ([192.55.52.136]:5367 "EHLO mga12.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726457AbeH3FgO (ORCPT ); Thu, 30 Aug 2018 01:36:14 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga003.jf.intel.com ([10.7.209.27]) by fmsmga106.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 29 Aug 2018 18:36:37 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.53,305,1531810800"; d="scan'208";a="79442223" Received: from allen-box.sh.intel.com ([10.239.161.122]) by orsmga003.jf.intel.com with ESMTP; 29 Aug 2018 18:36:34 -0700 From: Lu Baolu To: Joerg Roedel , David Woodhouse Cc: ashok.raj@intel.com, sanjay.k.kumar@intel.com, jacob.jun.pan@intel.com, kevin.tian@intel.com, yi.l.liu@intel.com, yi.y.sun@intel.com, peterx@redhat.com, Jean-Philippe Brucker , iommu@lists.linux-foundation.org, linux-kernel@vger.kernel.org, Lu Baolu , Jacob Pan Subject: [PATCH v2 01/12] iommu/vt-d: Enumerate the scalable mode capability Date: Thu, 30 Aug 2018 09:35:13 +0800 Message-Id: <20180830013524.28743-2-baolu.lu@linux.intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20180830013524.28743-1-baolu.lu@linux.intel.com> References: <20180830013524.28743-1-baolu.lu@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The Intel vt-d spec rev3.0 introduces a new translation mode called scalable mode, which enables PASID-granular translations for first level, second level, nested and pass-through modes. At the same time, the previous Extended Context (ECS) mode is deprecated (no production ever implements ECS). This patch adds enumeration for Scalable Mode and removes the deprecated ECS enumeration. It provides a boot time option to disable scalable mode even hardware claims to support it. Cc: Ashok Raj Cc: Jacob Pan Cc: Kevin Tian Cc: Liu Yi L Signed-off-by: Sanjay Kumar Signed-off-by: Lu Baolu Reviewed-by: Ashok Raj --- .../admin-guide/kernel-parameters.txt | 12 ++-- drivers/iommu/intel-iommu.c | 64 +++++-------------- include/linux/intel-iommu.h | 1 + 3 files changed, 24 insertions(+), 53 deletions(-) diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt index 9871e649ffef..5b971306a114 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -1668,12 +1668,12 @@ By default, super page will be supported if Intel IOMMU has the capability. With this option, super page will not be supported. - ecs_off [Default Off] - By default, extended context tables will be supported if - the hardware advertises that it has support both for the - extended tables themselves, and also PASID support. With - this option set, extended tables will not be used even - on hardware which claims to support them. + sm_off [Default Off] + By default, scalable mode will be supported if the + hardware advertises that it has support for the scalable + mode translation. With this option set, scalable mode + will not be used even on hardware which claims to support + it. tboot_noforce [Default Off] Do not force the Intel IOMMU enabled under tboot. By default, tboot will force Intel IOMMU on, which diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c index 5f3f10cf9d9d..5845edf4dcf9 100644 --- a/drivers/iommu/intel-iommu.c +++ b/drivers/iommu/intel-iommu.c @@ -430,38 +430,16 @@ static int dmar_map_gfx = 1; static int dmar_forcedac; static int intel_iommu_strict; static int intel_iommu_superpage = 1; -static int intel_iommu_ecs = 1; -static int intel_iommu_pasid28; +static int intel_iommu_sm = 1; static int iommu_identity_mapping; #define IDENTMAP_ALL 1 #define IDENTMAP_GFX 2 #define IDENTMAP_AZALIA 4 -/* Broadwell and Skylake have broken ECS support — normal so-called "second - * level" translation of DMA requests-without-PASID doesn't actually happen - * unless you also set the NESTE bit in an extended context-entry. Which of - * course means that SVM doesn't work because it's trying to do nested - * translation of the physical addresses it finds in the process page tables, - * through the IOVA->phys mapping found in the "second level" page tables. - * - * The VT-d specification was retroactively changed to change the definition - * of the capability bits and pretend that Broadwell/Skylake never happened... - * but unfortunately the wrong bit was changed. It's ECS which is broken, but - * for some reason it was the PASID capability bit which was redefined (from - * bit 28 on BDW/SKL to bit 40 in future). - * - * So our test for ECS needs to eschew those implementations which set the old - * PASID capabiity bit 28, since those are the ones on which ECS is broken. - * Unless we are working around the 'pasid28' limitations, that is, by putting - * the device into passthrough mode for normal DMA and thus masking the bug. - */ -#define ecs_enabled(iommu) (intel_iommu_ecs && ecap_ecs(iommu->ecap) && \ - (intel_iommu_pasid28 || !ecap_broken_pasid(iommu->ecap))) -/* PASID support is thus enabled if ECS is enabled and *either* of the old - * or new capability bits are set. */ -#define pasid_enabled(iommu) (ecs_enabled(iommu) && \ - (ecap_pasid(iommu->ecap) || ecap_broken_pasid(iommu->ecap))) +#define sm_supported(iommu) (intel_iommu_sm && ecap_smts((iommu)->ecap)) +#define pasid_supported(iommu) (sm_supported(iommu) && \ + ecap_pasid((iommu)->ecap)) int intel_iommu_gfx_mapped; EXPORT_SYMBOL_GPL(intel_iommu_gfx_mapped); @@ -541,15 +519,9 @@ static int __init intel_iommu_setup(char *str) } else if (!strncmp(str, "sp_off", 6)) { pr_info("Disable supported super page\n"); intel_iommu_superpage = 0; - } else if (!strncmp(str, "ecs_off", 7)) { - printk(KERN_INFO - "Intel-IOMMU: disable extended context table support\n"); - intel_iommu_ecs = 0; - } else if (!strncmp(str, "pasid28", 7)) { - printk(KERN_INFO - "Intel-IOMMU: enable pre-production PASID support\n"); - intel_iommu_pasid28 = 1; - iommu_identity_mapping |= IDENTMAP_GFX; + } else if (!strncmp(str, "sm_off", 6)) { + pr_info("Intel-IOMMU: disable scalable mode support\n"); + intel_iommu_sm = 0; } else if (!strncmp(str, "tboot_noforce", 13)) { printk(KERN_INFO "Intel-IOMMU: not forcing on after tboot. This could expose security risk for tboot\n"); @@ -796,7 +768,7 @@ static inline struct context_entry *iommu_context_addr(struct intel_iommu *iommu u64 *entry; entry = &root->lo; - if (ecs_enabled(iommu)) { + if (sm_supported(iommu)) { if (devfn >= 0x80) { devfn -= 0x80; entry = &root->hi; @@ -938,7 +910,7 @@ static void free_context_table(struct intel_iommu *iommu) if (context) free_pgtable_page(context); - if (!ecs_enabled(iommu)) + if (!sm_supported(iommu)) continue; context = iommu_context_addr(iommu, i, 0x80, 0); @@ -1290,8 +1262,6 @@ static void iommu_set_root_entry(struct intel_iommu *iommu) unsigned long flag; addr = virt_to_phys(iommu->root_entry); - if (ecs_enabled(iommu)) - addr |= DMA_RTADDR_RTT; raw_spin_lock_irqsave(&iommu->register_lock, flag); dmar_writeq(iommu->reg + DMAR_RTADDR_REG, addr); @@ -1780,7 +1750,7 @@ static void free_dmar_iommu(struct intel_iommu *iommu) free_context_table(iommu); #ifdef CONFIG_INTEL_IOMMU_SVM - if (pasid_enabled(iommu)) { + if (pasid_supported(iommu)) { if (ecap_prs(iommu->ecap)) intel_svm_finish_prq(iommu); intel_svm_exit(iommu); @@ -2489,8 +2459,8 @@ static struct dmar_domain *dmar_insert_one_dev_info(struct intel_iommu *iommu, dmar_find_matched_atsr_unit(pdev)) info->ats_supported = 1; - if (ecs_enabled(iommu)) { - if (pasid_enabled(iommu)) { + if (sm_supported(iommu)) { + if (pasid_supported(iommu)) { int features = pci_pasid_features(pdev); if (features >= 0) info->pasid_supported = features | 1; @@ -3302,7 +3272,7 @@ static int __init init_dmars(void) * We need to ensure the system pasid table is no bigger * than the smallest supported. */ - if (pasid_enabled(iommu)) { + if (pasid_supported(iommu)) { u32 temp = 2 << ecap_pss(iommu->ecap); intel_pasid_max_id = min_t(u32, temp, @@ -3363,7 +3333,7 @@ static int __init init_dmars(void) if (!ecap_pass_through(iommu->ecap)) hw_pass_through = 0; #ifdef CONFIG_INTEL_IOMMU_SVM - if (pasid_enabled(iommu)) + if (pasid_supported(iommu)) intel_svm_init(iommu); #endif } @@ -3467,7 +3437,7 @@ static int __init init_dmars(void) iommu_flush_write_buffer(iommu); #ifdef CONFIG_INTEL_IOMMU_SVM - if (pasid_enabled(iommu) && ecap_prs(iommu->ecap)) { + if (pasid_supported(iommu) && ecap_prs(iommu->ecap)) { ret = intel_svm_enable_prq(iommu); if (ret) goto free_iommu; @@ -4358,7 +4328,7 @@ static int intel_iommu_add(struct dmar_drhd_unit *dmaru) goto out; #ifdef CONFIG_INTEL_IOMMU_SVM - if (pasid_enabled(iommu)) + if (pasid_supported(iommu)) intel_svm_init(iommu); #endif @@ -4375,7 +4345,7 @@ static int intel_iommu_add(struct dmar_drhd_unit *dmaru) iommu_flush_write_buffer(iommu); #ifdef CONFIG_INTEL_IOMMU_SVM - if (pasid_enabled(iommu) && ecap_prs(iommu->ecap)) { + if (pasid_supported(iommu) && ecap_prs(iommu->ecap)) { ret = intel_svm_enable_prq(iommu); if (ret) goto disable_iommu; diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h index 28004d74ae04..2173ae35f1dc 100644 --- a/include/linux/intel-iommu.h +++ b/include/linux/intel-iommu.h @@ -115,6 +115,7 @@ * Extended Capability Register */ +#define ecap_smts(e) (((e) >> 43) & 0x1) #define ecap_dit(e) ((e >> 41) & 0x1) #define ecap_pasid(e) ((e >> 40) & 0x1) #define ecap_pss(e) ((e >> 35) & 0x1f) -- 2.17.1