From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jacob Pan Subject: [PATCH V4 10/18] iommu/ioasid: Support mm token type ioasid_set notifications Date: Sat, 27 Feb 2021 14:01:18 -0800 Message-ID: <1614463286-97618-11-git-send-email-jacob.jun.pan@linux.intel.com> References: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> Mime-Version: 1.0 Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1614463286-97618-1-git-send-email-jacob.jun.pan-VuQAYsv1563Yd54FQh9/CA@public.gmane.org> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: iommu-bounces-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org Sender: "iommu" Content-Type: text/plain; charset="windows-1252" To: LKML , Joerg Roedel , Lu Baolu , David Woodhouse , iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org, cgroups-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Tejun Heo , Li Zefan , Johannes Weiner , Jean-Philippe Brucker Cc: "Tian, Kevin" , Dave Jiang , Raj Ashok , Jonathan Corbet , Alex Williamson , Jason Gunthorpe , Wu Hao QXMgYSBzeXN0ZW0td2lkZSByZXNvdXJjZSwgSU9BU0lEIGlzIG9mdGVuIHNoYXJlZCBieSBtdWx0 aXBsZSBrZXJuZWwKc3Vic3lzdGVtcyB0aGF0IGFyZSBpbmRlcGVuZGVudCBvZiBlYWNoIG90aGVy LiBIb3dldmVyLCBhdCB0aGUKaW9hc2lkX3NldCBsZXZlbCwgdGhlc2Uga2VybmVsIHN1YnN5c3Rl bXMgbXVzdCBjb21tdW5pY2F0ZSB3aXRoIGVhY2gKb3RoZXIgZm9yIG93bmVyc2hpcCBjaGVja2lu ZywgZXZlbnQgbm90aWZpY2F0aW9ucywgZXRjLiBGb3IgZXhhbXBsZSwgb24KSW50ZWwgU2NhbGFi bGUgSU8gVmlydHVhbGl6YXRpb24gKFNJT1YpIGVuYWJsZWQgcGxhdGZvcm1zLCBLVk0gYW5kIFZG SU8KaW5zdGFuY2VzIHVuZGVyIHRoZSBzYW1lIHByb2Nlc3MvZ3Vlc3QgbXVzdCBiZSBhd2FyZSBv ZiBhIHNoYXJlZCBJT0FTSUQKc2V0LgpJT0FTSURfU0VUX1RZUEVfTU0gdG9rZW4gdHlwZSB3YXMg aW50cm9kdWNlZCB0byBleHBsaWNpdGx5IG1hcmsgYW4KSU9BU0lEIHNldCB0aGF0IGJlbG9uZ3Mg dG8gYSBwcm9jZXNzLCB0aHVzIHVzZSB0aGUgc2FtZSBtbV9zdHJ1Y3QKcG9pbnRlciBhcyBhIHRv a2VuLiBVc2VycyBvZiB0aGUgc2FtZSBwcm9jZXNzIGNhbiB0aGVuIGlkZW50aWZ5IHdpdGgKZWFj aCBvdGhlciBiYXNlZCBvbiB0aGlzIHRva2VuLgoKVGhpcyBwYXRjaCBpbnRyb2R1Y2VzIE1NIHRv a2VuIHNwZWNpZmljIGV2ZW50IHJlZ2lzdHJhdGlvbiBBUElzLiBFdmVudApzdWJzY3JpYmVycyBz dWNoIGFzIEtWTSBpbnN0YW5jZXMgY2FuIHJlZ2lzdGVyIElPQVNJRCBldmVudCBoYW5kbGVyCndp dGhvdXQgdGhlIGtub3dsZWRnZSBvZiBpdHMgaW9hc2lkX3NldC4gRXZlbnQgaGFuZGxlcnMgYXJl IHJlZ2lzdGVyZWQKYmFzZWQgb24gaXRzIG1tX3N0cnVjdCBwb2ludGVyIGFzIGEgdG9rZW4uIElu IGNhc2Ugd2hlbiBzdWJzY3JpYmVycwpyZWdpc3RlciBoYW5kbGVyICpwcmlvciogdG8gdGhlIGNy ZWF0aW9uIG9mIHRoZSBpb2FzaWRfc2V0LCB0aGUKaGFuZGxlcuKAmXMgbm90aWZpY2F0aW9uIGJs b2NrIGlzIHN0b3JlZCBpbiBhIHBlbmRpbmcgbGlzdCB3aXRoaW4gSU9BU0lECmNvcmUuIE9uY2Ug dGhlIGlvYXNpZF9zZXQgb2YgdGhlIE1NIHRva2VuIGlzIGNyZWF0ZWQsIHRoZSBub3RpZmljYXRp b24KYmxvY2sgd2lsbCBiZSByZWdpc3RlcmVkIGJ5IHRoZSBJT0FTSUQgY29yZS4KClNpZ25lZC1v ZmYtYnk6IExpdSBZaSBMIDx5aS5sLmxpdUBpbnRlbC5jb20+ClNpZ25lZC1vZmYtYnk6IFd1IEhh byA8aGFvLnd1QGludGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogSmFjb2IgUGFuIDxqYWNvYi5qdW4u cGFuQGxpbnV4LmludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2lvbW11L2lvYXNpZC5jIHwgMTQyICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL2xpbnV4L2lv YXNpZC5oIHwgIDE4ICsrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCAxNjAgaW5zZXJ0aW9ucygrKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUvaW9hc2lkLmMgYi9kcml2ZXJzL2lvbW11L2lvYXNp ZC5jCmluZGV4IDU2NTc3ZTc0NWM0Yi4uOTZlOTQxZGZhZGE3IDEwMDY0NAotLS0gYS9kcml2ZXJz L2lvbW11L2lvYXNpZC5jCisrKyBiL2RyaXZlcnMvaW9tbXUvaW9hc2lkLmMKQEAgLTIxLDYgKzIx LDggQEAKICAqIGtlZXAgbG9jYWwgc3RhdGVzIGluIHN5bmMuCiAgKi8KIHN0YXRpYyBBVE9NSUNf Tk9USUZJRVJfSEVBRChpb2FzaWRfbm90aWZpZXIpOworLyogTGlzdCB0byBob2xkIHBlbmRpbmcg bm90aWZpY2F0aW9uIGJsb2NrIHJlZ2lzdHJhdGlvbnMgKi8KK3N0YXRpYyBMSVNUX0hFQUQoaW9h c2lkX25iX3BlbmRpbmdfbGlzdCk7CiBzdGF0aWMgREVGSU5FX1NQSU5MT0NLKGlvYXNpZF9uYl9s b2NrKTsKIAogLyogRGVmYXVsdCB0byBQQ0llIHN0YW5kYXJkIDIwIGJpdCBQQVNJRCAqLwpAQCAt NTc0LDYgKzU3NiwyNyBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaW9hc2lkX3NldF9pc192YWxpZChz dHJ1Y3QgaW9hc2lkX3NldCAqc2V0KQogCXJldHVybiB4YV9sb2FkKCZpb2FzaWRfc2V0cywgc2V0 LT5pZCkgPT0gc2V0OwogfQogCitzdGF0aWMgdm9pZCBpb2FzaWRfYWRkX3BlbmRpbmdfbmIoc3Ry dWN0IGlvYXNpZF9zZXQgKnNldCkKK3sKKwlzdHJ1Y3QgaW9hc2lkX3NldF9uYiAqY3VycjsKKwor CWlmIChzZXQtPnR5cGUgIT0gSU9BU0lEX1NFVF9UWVBFX01NKQorCQlyZXR1cm47CisJLyoKKwkg KiBDaGVjayBpZiB0aGVyZSBhcmUgYW55IHBlbmRpbmcgbmIgcmVxdWVzdHMgZm9yIHRoZSBnaXZl biB0b2tlbiwgaWYgc28KKwkgKiBhZGQgdGhlbSB0byB0aGUgbm90aWZpZXIgY2hhaW4uCisJICov CisJc3Bpbl9sb2NrKCZpb2FzaWRfbmJfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShjdXJy LCAmaW9hc2lkX25iX3BlbmRpbmdfbGlzdCwgbGlzdCkgeworCQlpZiAoY3Vyci0+dG9rZW4gPT0g c2V0LT50b2tlbiAmJiAhY3Vyci0+YWN0aXZlKSB7CisJCQlhdG9taWNfbm90aWZpZXJfY2hhaW5f cmVnaXN0ZXIoJnNldC0+bmgsIGN1cnItPm5iKTsKKwkJCWN1cnItPnNldCA9IHNldDsKKwkJCWN1 cnItPmFjdGl2ZSA9IHRydWU7CisJCX0KKwl9CisJc3Bpbl91bmxvY2soJmlvYXNpZF9uYl9sb2Nr KTsKK30KKwogLyoqCiAgKiBpb2FzaWRfc2V0X2FsbG9jIC0gQWxsb2NhdGUgYSBuZXcgSU9BU0lE IHNldCBmb3IgYSBnaXZlbiB0b2tlbgogICoKQEAgLTY1OCw2ICs2ODEsMTEgQEAgc3RydWN0IGlv YXNpZF9zZXQgKmlvYXNpZF9zZXRfYWxsb2Modm9pZCAqdG9rZW4sIGlvYXNpZF90IHF1b3RhLCBp bnQgdHlwZSkKIAlhdG9taWNfc2V0KCZzZXQtPm5yX2lvYXNpZHMsIDApOwogCUFUT01JQ19JTklU X05PVElGSUVSX0hFQUQoJnNldC0+bmgpOwogCisJLyoKKwkgKiBDaGVjayBpZiB0aGVyZSBhcmUg YW55IHBlbmRpbmcgbmIgcmVxdWVzdHMgZm9yIHRoZSBnaXZlbiB0b2tlbiwgaWYgc28KKwkgKiBh ZGQgdGhlbSB0byB0aGUgbm90aWZpZXIgY2hhaW4uCisJICovCisJaW9hc2lkX2FkZF9wZW5kaW5n X25iKHNldCk7CiAJLyoKIAkgKiBQZXIgc2V0IFhBIGlzIHVzZWQgdG8gc3RvcmUgcHJpdmF0ZSBJ RHMgd2l0aGluIHRoZSBzZXQsIGdldCByZWFkeQogCSAqIGZvciBpb2FzaWRfc2V0IHByaXZhdGUg SUQgYW5kIHN5c3RlbS13aWRlIElPQVNJRCBhbGxvY2F0aW9uCkBAIC02NzUsNiArNzAzLDcgQEAg RVhQT1JUX1NZTUJPTF9HUEwoaW9hc2lkX3NldF9hbGxvYyk7CiAKIHN0YXRpYyBpbnQgaW9hc2lk X3NldF9mcmVlX2xvY2tlZChzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0KQogeworCXN0cnVjdCBpb2Fz aWRfc2V0X25iICpjdXJyOwogCWludCByZXQgPSAwOwogCiAJaWYgKCFpb2FzaWRfc2V0X2lzX3Zh bGlkKHNldCkpIHsKQEAgLTY4OCw2ICs3MTcsMTYgQEAgc3RhdGljIGludCBpb2FzaWRfc2V0X2Zy ZWVfbG9ja2VkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQpCiAJfQogCiAJV0FSTl9PTigheGFfZW1w dHkoJnNldC0+eGEpKTsKKwkvKiBSZXN0b3JlIHBlbmRpbmcgc3RhdHVzIG9mIHRoZSBzZXQgTkJz ICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShjdXJyLCAmaW9hc2lkX25iX3BlbmRpbmdfbGlzdCwg bGlzdCkgeworCQlpZiAoY3Vyci0+dG9rZW4gPT0gc2V0LT50b2tlbikgeworCQkJaWYgKGN1cnIt PmFjdGl2ZSkKKwkJCQljdXJyLT5hY3RpdmUgPSBmYWxzZTsKKwkJCWVsc2UKKwkJCQlwcl93YXJu KCJTZXQgdG9rZW4gZXhpc3RzIGJ1dCBub3QgYWN0aXZlIVxuIik7CisJCX0KKwl9CisKIAkvKgog CSAqIFRva2VuIGdvdCByZWxlYXNlZCByaWdodCBhd2F5IGFmdGVyIHRoZSBpb2FzaWRfc2V0IGlz IGZyZWVkLgogCSAqIElmIGEgbmV3IHNldCBpcyBjcmVhdGVkIGltbWVkaWF0ZWx5IHdpdGggdGhl IG5ld2x5IHJlbGVhc2VkIHRva2VuLApAQCAtMTExNyw2ICsxMTU2LDIyIEBAIEVYUE9SVF9TWU1C T0xfR1BMKGlvYXNpZF9yZWdpc3Rlcl9ub3RpZmllcik7CiB2b2lkIGlvYXNpZF91bnJlZ2lzdGVy X25vdGlmaWVyKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsCiAJCQkJc3RydWN0IG5vdGlmaWVyX2Js b2NrICpuYikKIHsKKwlzdHJ1Y3QgaW9hc2lkX3NldF9uYiAqY3VycjsKKworCXNwaW5fbG9jaygm aW9hc2lkX25iX2xvY2spOworCS8qCisJICogUGVuZGluZyBsaXN0IGlzIHJlZ2lzdGVyZWQgd2l0 aCBhIHRva2VuIHdpdGhvdXQgYW4gaW9hc2lkX3NldCwKKwkgKiB0aGVyZWZvcmUgc2hvdWxkIG5v dCBiZSB1bnJlZ2lzdGVyZWQgZGlyZWN0bHkuCisJICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShj dXJyLCAmaW9hc2lkX25iX3BlbmRpbmdfbGlzdCwgbGlzdCkgeworCQlpZiAoY3Vyci0+bmIgPT0g bmIpIHsKKwkJCXByX3dhcm4oIkNhbm5vdCB1bnJlZ2lzdGVyIE5CIGZyb20gcGVuZGluZyBsaXN0 XG4iKTsKKwkJCXNwaW5fdW5sb2NrKCZpb2FzaWRfbmJfbG9jayk7CisJCQlyZXR1cm47CisJCX0K Kwl9CisJc3Bpbl91bmxvY2soJmlvYXNpZF9uYl9sb2NrKTsKKwogCWlmIChzZXQpCiAJCWF0b21p Y19ub3RpZmllcl9jaGFpbl91bnJlZ2lzdGVyKCZzZXQtPm5oLCBuYik7CiAJZWxzZQpAQCAtMTEy NCw2ICsxMTc5LDkzIEBAIHZvaWQgaW9hc2lkX3VucmVnaXN0ZXJfbm90aWZpZXIoc3RydWN0IGlv YXNpZF9zZXQgKnNldCwKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGlvYXNpZF91bnJlZ2lzdGVyX25v dGlmaWVyKTsKIAorLyoqCisgKiBpb2FzaWRfcmVnaXN0ZXJfbm90aWZpZXJfbW0gLSBSZWdpc3Rl ciBhIG5vdGlmaWVyIGJsb2NrIG9uIHRoZSBJT0FTSUQgc2V0CisgKiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBjcmVhdGVkIGJ5IHRoZSBtbV9zdHJ1Y3QgcG9pbnRlciBhcyB0aGUgdG9r ZW4KKyAqCisgKiBAbW06IHRoZSBtbV9zdHJ1Y3QgdG9rZW4gb2YgdGhlIGlvYXNpZF9zZXQKKyAq IEBuYjogbm90ZmllciBibG9jayB0byBiZSByZWdpc3RlcmVkIG9uIHRoZSBpb2FzaWRfc2V0Cisg KgorICogVGhpcyBhIHZhcmlhbnQgb2YgaW9hc2lkX3JlZ2lzdGVyX25vdGlmaWVyKCkgd2hlcmUg dGhlIGNhbGxlciBpbnRlbmRzIHRvCisgKiBsaXN0ZW4gdG8gSU9BU0lEIGV2ZW50cyBiZWxvbmcg dGhlIGlvYXNpZF9zZXQgY3JlYXRlZCB1bmRlciB0aGUgc2FtZQorICogcHJvY2Vzcy4gQ2FsbGVy IGlzIG5vdCBhd2FyZSBvZiB0aGUgaW9hc2lkX3NldCwgbm8gbmVlZCB0byBob2xkIHJlZmVyZW5j ZQorICogb2YgdGhlIGlvYXNpZF9zZXQuCisgKi8KK2ludCBpb2FzaWRfcmVnaXN0ZXJfbm90aWZp ZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIpCit7 CisJc3RydWN0IGlvYXNpZF9zZXRfbmIgKmN1cnI7CisJc3RydWN0IGlvYXNpZF9zZXQgKnNldDsK KwlpbnQgcmV0ID0gMDsKKworCXNwaW5fbG9jaygmaW9hc2lkX25iX2xvY2spOworCS8qIENoZWNr IGZvciBkdXBsaWNhdGVzLCBuYiBpcyB1bmlxdWUgcGVyIHNldCAqLworCWxpc3RfZm9yX2VhY2hf ZW50cnkoY3VyciwgJmlvYXNpZF9uYl9wZW5kaW5nX2xpc3QsIGxpc3QpIHsKKwkJaWYgKGN1cnIt PnRva2VuID09IG1tICYmIGN1cnItPm5iID09IG5iKSB7CisJCQlyZXQgPSAtRUJVU1k7CisJCQln b3RvIGV4aXRfdW5sb2NrOworCQl9CisJfQorCWN1cnIgPSBremFsbG9jKHNpemVvZigqY3Vyciks IEdGUF9BVE9NSUMpOworCWlmICghY3VycikgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGV4 aXRfdW5sb2NrOworCX0KKwkvKiBDaGVjayBpZiB0aGUgdG9rZW4gaGFzIGFuIGV4aXN0aW5nIHNl dCAqLworCXNldCA9IGlvYXNpZF9maW5kX21tX3NldChtbSk7CisJaWYgKCFzZXQpIHsKKwkJLyog QWRkIHRvIHRoZSByc3ZkIGxpc3QgYXMgaW5hY3RpdmUgKi8KKwkJY3Vyci0+YWN0aXZlID0gZmFs c2U7CisJfSBlbHNlIHsKKwkJLyogUkVWSVNJVDogT25seSByZWdpc3RlciBlbXB0eSBzZXQgZm9y IG5vdy4gQ2FuIGFkZCBhbiBvcHRpb24KKwkJICogaW4gdGhlIGZ1dHVyZSB0byBwbGF5YmFjayBl eGlzdGluZyBQQVNJRHMuCisJCSAqLworCQlpZiAoYXRvbWljX3JlYWQoJnNldC0+bnJfaW9hc2lk cykpIHsKKwkJCXByX3dhcm4oIklPQVNJRCBzZXQgJWQgbm90IGVtcHR5ICVkXG4iLCBzZXQtPmlk LAorCQkJCWF0b21pY19yZWFkKCZzZXQtPm5yX2lvYXNpZHMpKTsKKwkJCXJldCA9IC1FQlVTWTsK KwkJCWdvdG8gZXhpdF9mcmVlOworCQl9CisJCWN1cnItPnRva2VuID0gbW07CisJCWN1cnItPm5i ID0gbmI7CisJCWN1cnItPmFjdGl2ZSA9IHRydWU7CisJCWN1cnItPnNldCA9IHNldDsKKworCQkv KiBTZXQgYWxyZWFkeSBjcmVhdGVkLCBhZGQgdG8gdGhlIG5vdGlmaWVyIGNoYWluICovCisJCWF0 b21pY19ub3RpZmllcl9jaGFpbl9yZWdpc3Rlcigmc2V0LT5uaCwgbmIpOworCX0KKworCWxpc3Rf YWRkKCZjdXJyLT5saXN0LCAmaW9hc2lkX25iX3BlbmRpbmdfbGlzdCk7CisJZ290byBleGl0X3Vu bG9jazsKK2V4aXRfZnJlZToKKwlrZnJlZShjdXJyKTsKK2V4aXRfdW5sb2NrOgorCXNwaW5fdW5s b2NrKCZpb2FzaWRfbmJfbG9jayk7CisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0xfR1BM KGlvYXNpZF9yZWdpc3Rlcl9ub3RpZmllcl9tbSk7CisKK3ZvaWQgaW9hc2lkX3VucmVnaXN0ZXJf bm90aWZpZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCBub3RpZmllcl9ibG9jayAq bmIpCit7CisJc3RydWN0IGlvYXNpZF9zZXRfbmIgKmN1cnI7CisKKwlzcGluX2xvY2soJmlvYXNp ZF9uYl9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGN1cnIsICZpb2FzaWRfbmJfcGVuZGlu Z19saXN0LCBsaXN0KSB7CisJCWlmIChjdXJyLT50b2tlbiA9PSBtbSAmJiBjdXJyLT5uYiA9PSBu YikgeworCQkJbGlzdF9kZWwoJmN1cnItPmxpc3QpOworCQkJc3Bpbl91bmxvY2soJmlvYXNpZF9u Yl9sb2NrKTsKKwkJCWlmIChjdXJyLT5hY3RpdmUpIHsKKwkJCQlhdG9taWNfbm90aWZpZXJfY2hh aW5fdW5yZWdpc3RlcigmY3Vyci0+c2V0LT5uaCwKKwkJCQkJCQkJIG5iKTsKKwkJCX0KKwkJCWtm cmVlKGN1cnIpOworCQkJcmV0dXJuOworCQl9CisJfQorCXByX3dhcm4oIk5vIGlvYXNpZCBzZXQg Zm91bmQgZm9yIG1tIHRva2VuICVsbHhcbiIsICAodTY0KW1tKTsKKwlzcGluX3VubG9jaygmaW9h c2lkX25iX2xvY2spOworfQorRVhQT1JUX1NZTUJPTF9HUEwoaW9hc2lkX3VucmVnaXN0ZXJfbm90 aWZpZXJfbW0pOworCiBNT0RVTEVfQVVUSE9SKCJKZWFuLVBoaWxpcHBlIEJydWNrZXIgPGplYW4t cGhpbGlwcGUuYnJ1Y2tlckBhcm0uY29tPiIpOwogTU9EVUxFX0FVVEhPUigiSmFjb2IgUGFuIDxq YWNvYi5qdW4ucGFuQGxpbnV4LmludGVsLmNvbT4iKTsKIE1PRFVMRV9ERVNDUklQVElPTigiSU8g QWRkcmVzcyBTcGFjZSBJRCAoSU9BU0lEKSBhbGxvY2F0b3IiKTsKZGlmZiAtLWdpdCBhL2luY2x1 ZGUvbGludXgvaW9hc2lkLmggYi9pbmNsdWRlL2xpbnV4L2lvYXNpZC5oCmluZGV4IGQ4Yjg1YTA0 MjE0Zi4uYzk3ZTgwZmY2NWNjIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2lvYXNpZC5oCisr KyBiL2luY2x1ZGUvbGludXgvaW9hc2lkLmgKQEAgLTEzMiw2ICsxMzIsOCBAQCB2b2lkIGlvYXNp ZF91bnJlZ2lzdGVyX25vdGlmaWVyKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsCiB2b2lkIGlvYXNp ZF9zZXRfZm9yX2VhY2hfaW9hc2lkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZGF0YSwKIAkJCQl2b2lk ICgqZm4pKGlvYXNpZF90IGlkLCB2b2lkICpkYXRhKSwKIAkJCQl2b2lkICpkYXRhKTsKK2ludCBp b2FzaWRfcmVnaXN0ZXJfbm90aWZpZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCBu b3RpZmllcl9ibG9jayAqbmIpOwordm9pZCBpb2FzaWRfdW5yZWdpc3Rlcl9ub3RpZmllcl9tbShz dHJ1Y3QgbW1fc3RydWN0ICptbSwgc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYik7CiAjZWxzZSAv KiAhQ09ORklHX0lPQVNJRCAqLwogc3RhdGljIGlubGluZSB2b2lkIGlvYXNpZF9pbnN0YWxsX2Nh cGFjaXR5KGlvYXNpZF90IHRvdGFsKQogewpAQCAtMjUwLDUgKzI1MiwyMSBAQCBzdGF0aWMgaW5s aW5lIHZvaWQgaW9hc2lkX3NldF9mb3JfZWFjaF9pb2FzaWQoc3RydWN0IGlvYXNpZF9zZXQgKnNk YXRhLAogCQkJCQkgICAgICB2b2lkICpkYXRhKQogewogfQorCitzdGF0aWMgaW5saW5lIGludCBp b2FzaWRfcmVnaXN0ZXJfbm90aWZpZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJCSAg ICAgIHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIpCit7CisJcmV0dXJuIC1FTk9UU1VQUDsKK30K Kworc3RhdGljIGlubGluZSB2b2lkIGlvYXNpZF91bnJlZ2lzdGVyX25vdGlmaWVyX21tKHN0cnVj dCBtbV9zdHJ1Y3QgKm1tLAorCQkJCQkJIHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIpCit7Cit9 CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBpb2FzaWRfcXVldWVfd29yayhzdHJ1Y3Qgd29ya19zdHJ1 Y3QgKndvcmspCit7CisJcmV0dXJuIGZhbHNlOworfQogI2VuZGlmIC8qIENPTkZJR19JT0FTSUQg Ki8KICNlbmRpZiAvKiBfX0xJTlVYX0lPQVNJRF9IICovCi0tIAoyLjI1LjEKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmlvbW11IG1haWxpbmcgbGlzdApp b21tdUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRh dGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby9pb21tdQ== 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=-15.2 required=3.0 tests=BAYES_00,DATE_IN_PAST_06_12, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,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 7433CC433E6 for ; Sun, 28 Feb 2021 06:33:26 +0000 (UTC) Received: from smtp3.osuosl.org (smtp3.osuosl.org [140.211.166.136]) (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 399DA64E02 for ; Sun, 28 Feb 2021 06:33:26 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 399DA64E02 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=iommu-bounces@lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id E5F2A6F9E9; Sun, 28 Feb 2021 06:33:25 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id SxM827V1RdiL; Sun, 28 Feb 2021 06:33:23 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp3.osuosl.org (Postfix) with ESMTP id 9AABB6F9BB; Sun, 28 Feb 2021 06:33:22 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id BC56DC001A; Sun, 28 Feb 2021 06:33:21 +0000 (UTC) Received: from smtp3.osuosl.org (smtp3.osuosl.org [140.211.166.136]) by lists.linuxfoundation.org (Postfix) with ESMTP id 1B621C001A for ; Sun, 28 Feb 2021 06:33:15 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id E6BDD6F893 for ; Sun, 28 Feb 2021 06:33:12 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id ZsZIjg2ch6Ii for ; Sun, 28 Feb 2021 06:33:12 +0000 (UTC) X-Greylist: domain auto-whitelisted by SQLgrey-1.8.0 Received: from mga06.intel.com (mga06.intel.com [134.134.136.31]) by smtp3.osuosl.org (Postfix) with ESMTPS id ED22D6F82D for ; Sun, 28 Feb 2021 06:33:11 +0000 (UTC) IronPort-SDR: jLpvBIdFsmKFxDHXWfEiUJPZTvjmIT67hKA5q1ftBp6l6+erGrnpKsgRe2BKm8ZmuP5xGgPAaE aRca/HGodxnw== X-IronPort-AV: E=McAfee;i="6000,8403,9908"; a="247624810" X-IronPort-AV: E=Sophos;i="5.81,211,1610438400"; d="scan'208";a="247624810" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by orsmga104.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 Feb 2021 22:33:10 -0800 IronPort-SDR: qchTLFgyX916CIPRGYrZ6Gz/jgLi7dnTlsnEaeI9+8aGkJZxtP0fLvsmT6I9TZRolKwIsN+KcZ K/62nW9dIV4g== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.81,211,1610438400"; d="scan'208";a="517029725" Received: from otc-wp-03.jf.intel.com ([10.54.39.79]) by orsmga004.jf.intel.com with ESMTP; 27 Feb 2021 22:33:09 -0800 From: Jacob Pan To: LKML , Joerg Roedel , "Lu Baolu" , David Woodhouse , iommu@lists.linux-foundation.org, cgroups@vger.kernel.org, Tejun Heo , Li Zefan , Johannes Weiner , Jean-Philippe Brucker Subject: [PATCH V4 10/18] iommu/ioasid: Support mm token type ioasid_set notifications Date: Sat, 27 Feb 2021 14:01:18 -0800 Message-Id: <1614463286-97618-11-git-send-email-jacob.jun.pan@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> References: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> MIME-Version: 1.0 Cc: "Tian, Kevin" , Dave Jiang , Raj Ashok , Jonathan Corbet , Alex Williamson , Jason Gunthorpe , Wu Hao X-BeenThere: iommu@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Development issues for Linux IOMMU support List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: iommu-bounces@lists.linux-foundation.org Sender: "iommu" QXMgYSBzeXN0ZW0td2lkZSByZXNvdXJjZSwgSU9BU0lEIGlzIG9mdGVuIHNoYXJlZCBieSBtdWx0 aXBsZSBrZXJuZWwKc3Vic3lzdGVtcyB0aGF0IGFyZSBpbmRlcGVuZGVudCBvZiBlYWNoIG90aGVy LiBIb3dldmVyLCBhdCB0aGUKaW9hc2lkX3NldCBsZXZlbCwgdGhlc2Uga2VybmVsIHN1YnN5c3Rl bXMgbXVzdCBjb21tdW5pY2F0ZSB3aXRoIGVhY2gKb3RoZXIgZm9yIG93bmVyc2hpcCBjaGVja2lu ZywgZXZlbnQgbm90aWZpY2F0aW9ucywgZXRjLiBGb3IgZXhhbXBsZSwgb24KSW50ZWwgU2NhbGFi bGUgSU8gVmlydHVhbGl6YXRpb24gKFNJT1YpIGVuYWJsZWQgcGxhdGZvcm1zLCBLVk0gYW5kIFZG SU8KaW5zdGFuY2VzIHVuZGVyIHRoZSBzYW1lIHByb2Nlc3MvZ3Vlc3QgbXVzdCBiZSBhd2FyZSBv ZiBhIHNoYXJlZCBJT0FTSUQKc2V0LgpJT0FTSURfU0VUX1RZUEVfTU0gdG9rZW4gdHlwZSB3YXMg aW50cm9kdWNlZCB0byBleHBsaWNpdGx5IG1hcmsgYW4KSU9BU0lEIHNldCB0aGF0IGJlbG9uZ3Mg dG8gYSBwcm9jZXNzLCB0aHVzIHVzZSB0aGUgc2FtZSBtbV9zdHJ1Y3QKcG9pbnRlciBhcyBhIHRv a2VuLiBVc2VycyBvZiB0aGUgc2FtZSBwcm9jZXNzIGNhbiB0aGVuIGlkZW50aWZ5IHdpdGgKZWFj aCBvdGhlciBiYXNlZCBvbiB0aGlzIHRva2VuLgoKVGhpcyBwYXRjaCBpbnRyb2R1Y2VzIE1NIHRv a2VuIHNwZWNpZmljIGV2ZW50IHJlZ2lzdHJhdGlvbiBBUElzLiBFdmVudApzdWJzY3JpYmVycyBz dWNoIGFzIEtWTSBpbnN0YW5jZXMgY2FuIHJlZ2lzdGVyIElPQVNJRCBldmVudCBoYW5kbGVyCndp dGhvdXQgdGhlIGtub3dsZWRnZSBvZiBpdHMgaW9hc2lkX3NldC4gRXZlbnQgaGFuZGxlcnMgYXJl IHJlZ2lzdGVyZWQKYmFzZWQgb24gaXRzIG1tX3N0cnVjdCBwb2ludGVyIGFzIGEgdG9rZW4uIElu IGNhc2Ugd2hlbiBzdWJzY3JpYmVycwpyZWdpc3RlciBoYW5kbGVyICpwcmlvciogdG8gdGhlIGNy ZWF0aW9uIG9mIHRoZSBpb2FzaWRfc2V0LCB0aGUKaGFuZGxlcuKAmXMgbm90aWZpY2F0aW9uIGJs b2NrIGlzIHN0b3JlZCBpbiBhIHBlbmRpbmcgbGlzdCB3aXRoaW4gSU9BU0lECmNvcmUuIE9uY2Ug dGhlIGlvYXNpZF9zZXQgb2YgdGhlIE1NIHRva2VuIGlzIGNyZWF0ZWQsIHRoZSBub3RpZmljYXRp b24KYmxvY2sgd2lsbCBiZSByZWdpc3RlcmVkIGJ5IHRoZSBJT0FTSUQgY29yZS4KClNpZ25lZC1v ZmYtYnk6IExpdSBZaSBMIDx5aS5sLmxpdUBpbnRlbC5jb20+ClNpZ25lZC1vZmYtYnk6IFd1IEhh byA8aGFvLnd1QGludGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogSmFjb2IgUGFuIDxqYWNvYi5qdW4u cGFuQGxpbnV4LmludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2lvbW11L2lvYXNpZC5jIHwgMTQyICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL2xpbnV4L2lv YXNpZC5oIHwgIDE4ICsrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCAxNjAgaW5zZXJ0aW9ucygrKQoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUvaW9hc2lkLmMgYi9kcml2ZXJzL2lvbW11L2lvYXNp ZC5jCmluZGV4IDU2NTc3ZTc0NWM0Yi4uOTZlOTQxZGZhZGE3IDEwMDY0NAotLS0gYS9kcml2ZXJz L2lvbW11L2lvYXNpZC5jCisrKyBiL2RyaXZlcnMvaW9tbXUvaW9hc2lkLmMKQEAgLTIxLDYgKzIx LDggQEAKICAqIGtlZXAgbG9jYWwgc3RhdGVzIGluIHN5bmMuCiAgKi8KIHN0YXRpYyBBVE9NSUNf Tk9USUZJRVJfSEVBRChpb2FzaWRfbm90aWZpZXIpOworLyogTGlzdCB0byBob2xkIHBlbmRpbmcg bm90aWZpY2F0aW9uIGJsb2NrIHJlZ2lzdHJhdGlvbnMgKi8KK3N0YXRpYyBMSVNUX0hFQUQoaW9h c2lkX25iX3BlbmRpbmdfbGlzdCk7CiBzdGF0aWMgREVGSU5FX1NQSU5MT0NLKGlvYXNpZF9uYl9s b2NrKTsKIAogLyogRGVmYXVsdCB0byBQQ0llIHN0YW5kYXJkIDIwIGJpdCBQQVNJRCAqLwpAQCAt NTc0LDYgKzU3NiwyNyBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaW9hc2lkX3NldF9pc192YWxpZChz dHJ1Y3QgaW9hc2lkX3NldCAqc2V0KQogCXJldHVybiB4YV9sb2FkKCZpb2FzaWRfc2V0cywgc2V0 LT5pZCkgPT0gc2V0OwogfQogCitzdGF0aWMgdm9pZCBpb2FzaWRfYWRkX3BlbmRpbmdfbmIoc3Ry dWN0IGlvYXNpZF9zZXQgKnNldCkKK3sKKwlzdHJ1Y3QgaW9hc2lkX3NldF9uYiAqY3VycjsKKwor CWlmIChzZXQtPnR5cGUgIT0gSU9BU0lEX1NFVF9UWVBFX01NKQorCQlyZXR1cm47CisJLyoKKwkg KiBDaGVjayBpZiB0aGVyZSBhcmUgYW55IHBlbmRpbmcgbmIgcmVxdWVzdHMgZm9yIHRoZSBnaXZl biB0b2tlbiwgaWYgc28KKwkgKiBhZGQgdGhlbSB0byB0aGUgbm90aWZpZXIgY2hhaW4uCisJICov CisJc3Bpbl9sb2NrKCZpb2FzaWRfbmJfbG9jayk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShjdXJy LCAmaW9hc2lkX25iX3BlbmRpbmdfbGlzdCwgbGlzdCkgeworCQlpZiAoY3Vyci0+dG9rZW4gPT0g c2V0LT50b2tlbiAmJiAhY3Vyci0+YWN0aXZlKSB7CisJCQlhdG9taWNfbm90aWZpZXJfY2hhaW5f cmVnaXN0ZXIoJnNldC0+bmgsIGN1cnItPm5iKTsKKwkJCWN1cnItPnNldCA9IHNldDsKKwkJCWN1 cnItPmFjdGl2ZSA9IHRydWU7CisJCX0KKwl9CisJc3Bpbl91bmxvY2soJmlvYXNpZF9uYl9sb2Nr KTsKK30KKwogLyoqCiAgKiBpb2FzaWRfc2V0X2FsbG9jIC0gQWxsb2NhdGUgYSBuZXcgSU9BU0lE IHNldCBmb3IgYSBnaXZlbiB0b2tlbgogICoKQEAgLTY1OCw2ICs2ODEsMTEgQEAgc3RydWN0IGlv YXNpZF9zZXQgKmlvYXNpZF9zZXRfYWxsb2Modm9pZCAqdG9rZW4sIGlvYXNpZF90IHF1b3RhLCBp bnQgdHlwZSkKIAlhdG9taWNfc2V0KCZzZXQtPm5yX2lvYXNpZHMsIDApOwogCUFUT01JQ19JTklU X05PVElGSUVSX0hFQUQoJnNldC0+bmgpOwogCisJLyoKKwkgKiBDaGVjayBpZiB0aGVyZSBhcmUg YW55IHBlbmRpbmcgbmIgcmVxdWVzdHMgZm9yIHRoZSBnaXZlbiB0b2tlbiwgaWYgc28KKwkgKiBh ZGQgdGhlbSB0byB0aGUgbm90aWZpZXIgY2hhaW4uCisJICovCisJaW9hc2lkX2FkZF9wZW5kaW5n X25iKHNldCk7CiAJLyoKIAkgKiBQZXIgc2V0IFhBIGlzIHVzZWQgdG8gc3RvcmUgcHJpdmF0ZSBJ RHMgd2l0aGluIHRoZSBzZXQsIGdldCByZWFkeQogCSAqIGZvciBpb2FzaWRfc2V0IHByaXZhdGUg SUQgYW5kIHN5c3RlbS13aWRlIElPQVNJRCBhbGxvY2F0aW9uCkBAIC02NzUsNiArNzAzLDcgQEAg RVhQT1JUX1NZTUJPTF9HUEwoaW9hc2lkX3NldF9hbGxvYyk7CiAKIHN0YXRpYyBpbnQgaW9hc2lk X3NldF9mcmVlX2xvY2tlZChzdHJ1Y3QgaW9hc2lkX3NldCAqc2V0KQogeworCXN0cnVjdCBpb2Fz aWRfc2V0X25iICpjdXJyOwogCWludCByZXQgPSAwOwogCiAJaWYgKCFpb2FzaWRfc2V0X2lzX3Zh bGlkKHNldCkpIHsKQEAgLTY4OCw2ICs3MTcsMTYgQEAgc3RhdGljIGludCBpb2FzaWRfc2V0X2Zy ZWVfbG9ja2VkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQpCiAJfQogCiAJV0FSTl9PTigheGFfZW1w dHkoJnNldC0+eGEpKTsKKwkvKiBSZXN0b3JlIHBlbmRpbmcgc3RhdHVzIG9mIHRoZSBzZXQgTkJz ICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShjdXJyLCAmaW9hc2lkX25iX3BlbmRpbmdfbGlzdCwg bGlzdCkgeworCQlpZiAoY3Vyci0+dG9rZW4gPT0gc2V0LT50b2tlbikgeworCQkJaWYgKGN1cnIt PmFjdGl2ZSkKKwkJCQljdXJyLT5hY3RpdmUgPSBmYWxzZTsKKwkJCWVsc2UKKwkJCQlwcl93YXJu KCJTZXQgdG9rZW4gZXhpc3RzIGJ1dCBub3QgYWN0aXZlIVxuIik7CisJCX0KKwl9CisKIAkvKgog CSAqIFRva2VuIGdvdCByZWxlYXNlZCByaWdodCBhd2F5IGFmdGVyIHRoZSBpb2FzaWRfc2V0IGlz IGZyZWVkLgogCSAqIElmIGEgbmV3IHNldCBpcyBjcmVhdGVkIGltbWVkaWF0ZWx5IHdpdGggdGhl IG5ld2x5IHJlbGVhc2VkIHRva2VuLApAQCAtMTExNyw2ICsxMTU2LDIyIEBAIEVYUE9SVF9TWU1C T0xfR1BMKGlvYXNpZF9yZWdpc3Rlcl9ub3RpZmllcik7CiB2b2lkIGlvYXNpZF91bnJlZ2lzdGVy X25vdGlmaWVyKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsCiAJCQkJc3RydWN0IG5vdGlmaWVyX2Js b2NrICpuYikKIHsKKwlzdHJ1Y3QgaW9hc2lkX3NldF9uYiAqY3VycjsKKworCXNwaW5fbG9jaygm aW9hc2lkX25iX2xvY2spOworCS8qCisJICogUGVuZGluZyBsaXN0IGlzIHJlZ2lzdGVyZWQgd2l0 aCBhIHRva2VuIHdpdGhvdXQgYW4gaW9hc2lkX3NldCwKKwkgKiB0aGVyZWZvcmUgc2hvdWxkIG5v dCBiZSB1bnJlZ2lzdGVyZWQgZGlyZWN0bHkuCisJICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShj dXJyLCAmaW9hc2lkX25iX3BlbmRpbmdfbGlzdCwgbGlzdCkgeworCQlpZiAoY3Vyci0+bmIgPT0g bmIpIHsKKwkJCXByX3dhcm4oIkNhbm5vdCB1bnJlZ2lzdGVyIE5CIGZyb20gcGVuZGluZyBsaXN0 XG4iKTsKKwkJCXNwaW5fdW5sb2NrKCZpb2FzaWRfbmJfbG9jayk7CisJCQlyZXR1cm47CisJCX0K Kwl9CisJc3Bpbl91bmxvY2soJmlvYXNpZF9uYl9sb2NrKTsKKwogCWlmIChzZXQpCiAJCWF0b21p Y19ub3RpZmllcl9jaGFpbl91bnJlZ2lzdGVyKCZzZXQtPm5oLCBuYik7CiAJZWxzZQpAQCAtMTEy NCw2ICsxMTc5LDkzIEBAIHZvaWQgaW9hc2lkX3VucmVnaXN0ZXJfbm90aWZpZXIoc3RydWN0IGlv YXNpZF9zZXQgKnNldCwKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGlvYXNpZF91bnJlZ2lzdGVyX25v dGlmaWVyKTsKIAorLyoqCisgKiBpb2FzaWRfcmVnaXN0ZXJfbm90aWZpZXJfbW0gLSBSZWdpc3Rl ciBhIG5vdGlmaWVyIGJsb2NrIG9uIHRoZSBJT0FTSUQgc2V0CisgKiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBjcmVhdGVkIGJ5IHRoZSBtbV9zdHJ1Y3QgcG9pbnRlciBhcyB0aGUgdG9r ZW4KKyAqCisgKiBAbW06IHRoZSBtbV9zdHJ1Y3QgdG9rZW4gb2YgdGhlIGlvYXNpZF9zZXQKKyAq IEBuYjogbm90ZmllciBibG9jayB0byBiZSByZWdpc3RlcmVkIG9uIHRoZSBpb2FzaWRfc2V0Cisg KgorICogVGhpcyBhIHZhcmlhbnQgb2YgaW9hc2lkX3JlZ2lzdGVyX25vdGlmaWVyKCkgd2hlcmUg dGhlIGNhbGxlciBpbnRlbmRzIHRvCisgKiBsaXN0ZW4gdG8gSU9BU0lEIGV2ZW50cyBiZWxvbmcg dGhlIGlvYXNpZF9zZXQgY3JlYXRlZCB1bmRlciB0aGUgc2FtZQorICogcHJvY2Vzcy4gQ2FsbGVy IGlzIG5vdCBhd2FyZSBvZiB0aGUgaW9hc2lkX3NldCwgbm8gbmVlZCB0byBob2xkIHJlZmVyZW5j ZQorICogb2YgdGhlIGlvYXNpZF9zZXQuCisgKi8KK2ludCBpb2FzaWRfcmVnaXN0ZXJfbm90aWZp ZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIpCit7 CisJc3RydWN0IGlvYXNpZF9zZXRfbmIgKmN1cnI7CisJc3RydWN0IGlvYXNpZF9zZXQgKnNldDsK KwlpbnQgcmV0ID0gMDsKKworCXNwaW5fbG9jaygmaW9hc2lkX25iX2xvY2spOworCS8qIENoZWNr IGZvciBkdXBsaWNhdGVzLCBuYiBpcyB1bmlxdWUgcGVyIHNldCAqLworCWxpc3RfZm9yX2VhY2hf ZW50cnkoY3VyciwgJmlvYXNpZF9uYl9wZW5kaW5nX2xpc3QsIGxpc3QpIHsKKwkJaWYgKGN1cnIt PnRva2VuID09IG1tICYmIGN1cnItPm5iID09IG5iKSB7CisJCQlyZXQgPSAtRUJVU1k7CisJCQln b3RvIGV4aXRfdW5sb2NrOworCQl9CisJfQorCWN1cnIgPSBremFsbG9jKHNpemVvZigqY3Vyciks IEdGUF9BVE9NSUMpOworCWlmICghY3VycikgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGV4 aXRfdW5sb2NrOworCX0KKwkvKiBDaGVjayBpZiB0aGUgdG9rZW4gaGFzIGFuIGV4aXN0aW5nIHNl dCAqLworCXNldCA9IGlvYXNpZF9maW5kX21tX3NldChtbSk7CisJaWYgKCFzZXQpIHsKKwkJLyog QWRkIHRvIHRoZSByc3ZkIGxpc3QgYXMgaW5hY3RpdmUgKi8KKwkJY3Vyci0+YWN0aXZlID0gZmFs c2U7CisJfSBlbHNlIHsKKwkJLyogUkVWSVNJVDogT25seSByZWdpc3RlciBlbXB0eSBzZXQgZm9y IG5vdy4gQ2FuIGFkZCBhbiBvcHRpb24KKwkJICogaW4gdGhlIGZ1dHVyZSB0byBwbGF5YmFjayBl eGlzdGluZyBQQVNJRHMuCisJCSAqLworCQlpZiAoYXRvbWljX3JlYWQoJnNldC0+bnJfaW9hc2lk cykpIHsKKwkJCXByX3dhcm4oIklPQVNJRCBzZXQgJWQgbm90IGVtcHR5ICVkXG4iLCBzZXQtPmlk LAorCQkJCWF0b21pY19yZWFkKCZzZXQtPm5yX2lvYXNpZHMpKTsKKwkJCXJldCA9IC1FQlVTWTsK KwkJCWdvdG8gZXhpdF9mcmVlOworCQl9CisJCWN1cnItPnRva2VuID0gbW07CisJCWN1cnItPm5i ID0gbmI7CisJCWN1cnItPmFjdGl2ZSA9IHRydWU7CisJCWN1cnItPnNldCA9IHNldDsKKworCQkv KiBTZXQgYWxyZWFkeSBjcmVhdGVkLCBhZGQgdG8gdGhlIG5vdGlmaWVyIGNoYWluICovCisJCWF0 b21pY19ub3RpZmllcl9jaGFpbl9yZWdpc3Rlcigmc2V0LT5uaCwgbmIpOworCX0KKworCWxpc3Rf YWRkKCZjdXJyLT5saXN0LCAmaW9hc2lkX25iX3BlbmRpbmdfbGlzdCk7CisJZ290byBleGl0X3Vu bG9jazsKK2V4aXRfZnJlZToKKwlrZnJlZShjdXJyKTsKK2V4aXRfdW5sb2NrOgorCXNwaW5fdW5s b2NrKCZpb2FzaWRfbmJfbG9jayk7CisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0xfR1BM KGlvYXNpZF9yZWdpc3Rlcl9ub3RpZmllcl9tbSk7CisKK3ZvaWQgaW9hc2lkX3VucmVnaXN0ZXJf bm90aWZpZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCBub3RpZmllcl9ibG9jayAq bmIpCit7CisJc3RydWN0IGlvYXNpZF9zZXRfbmIgKmN1cnI7CisKKwlzcGluX2xvY2soJmlvYXNp ZF9uYl9sb2NrKTsKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGN1cnIsICZpb2FzaWRfbmJfcGVuZGlu Z19saXN0LCBsaXN0KSB7CisJCWlmIChjdXJyLT50b2tlbiA9PSBtbSAmJiBjdXJyLT5uYiA9PSBu YikgeworCQkJbGlzdF9kZWwoJmN1cnItPmxpc3QpOworCQkJc3Bpbl91bmxvY2soJmlvYXNpZF9u Yl9sb2NrKTsKKwkJCWlmIChjdXJyLT5hY3RpdmUpIHsKKwkJCQlhdG9taWNfbm90aWZpZXJfY2hh aW5fdW5yZWdpc3RlcigmY3Vyci0+c2V0LT5uaCwKKwkJCQkJCQkJIG5iKTsKKwkJCX0KKwkJCWtm cmVlKGN1cnIpOworCQkJcmV0dXJuOworCQl9CisJfQorCXByX3dhcm4oIk5vIGlvYXNpZCBzZXQg Zm91bmQgZm9yIG1tIHRva2VuICVsbHhcbiIsICAodTY0KW1tKTsKKwlzcGluX3VubG9jaygmaW9h c2lkX25iX2xvY2spOworfQorRVhQT1JUX1NZTUJPTF9HUEwoaW9hc2lkX3VucmVnaXN0ZXJfbm90 aWZpZXJfbW0pOworCiBNT0RVTEVfQVVUSE9SKCJKZWFuLVBoaWxpcHBlIEJydWNrZXIgPGplYW4t cGhpbGlwcGUuYnJ1Y2tlckBhcm0uY29tPiIpOwogTU9EVUxFX0FVVEhPUigiSmFjb2IgUGFuIDxq YWNvYi5qdW4ucGFuQGxpbnV4LmludGVsLmNvbT4iKTsKIE1PRFVMRV9ERVNDUklQVElPTigiSU8g QWRkcmVzcyBTcGFjZSBJRCAoSU9BU0lEKSBhbGxvY2F0b3IiKTsKZGlmZiAtLWdpdCBhL2luY2x1 ZGUvbGludXgvaW9hc2lkLmggYi9pbmNsdWRlL2xpbnV4L2lvYXNpZC5oCmluZGV4IGQ4Yjg1YTA0 MjE0Zi4uYzk3ZTgwZmY2NWNjIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2lvYXNpZC5oCisr KyBiL2luY2x1ZGUvbGludXgvaW9hc2lkLmgKQEAgLTEzMiw2ICsxMzIsOCBAQCB2b2lkIGlvYXNp ZF91bnJlZ2lzdGVyX25vdGlmaWVyKHN0cnVjdCBpb2FzaWRfc2V0ICpzZXQsCiB2b2lkIGlvYXNp ZF9zZXRfZm9yX2VhY2hfaW9hc2lkKHN0cnVjdCBpb2FzaWRfc2V0ICpzZGF0YSwKIAkJCQl2b2lk ICgqZm4pKGlvYXNpZF90IGlkLCB2b2lkICpkYXRhKSwKIAkJCQl2b2lkICpkYXRhKTsKK2ludCBp b2FzaWRfcmVnaXN0ZXJfbm90aWZpZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCBu b3RpZmllcl9ibG9jayAqbmIpOwordm9pZCBpb2FzaWRfdW5yZWdpc3Rlcl9ub3RpZmllcl9tbShz dHJ1Y3QgbW1fc3RydWN0ICptbSwgc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYik7CiAjZWxzZSAv KiAhQ09ORklHX0lPQVNJRCAqLwogc3RhdGljIGlubGluZSB2b2lkIGlvYXNpZF9pbnN0YWxsX2Nh cGFjaXR5KGlvYXNpZF90IHRvdGFsKQogewpAQCAtMjUwLDUgKzI1MiwyMSBAQCBzdGF0aWMgaW5s aW5lIHZvaWQgaW9hc2lkX3NldF9mb3JfZWFjaF9pb2FzaWQoc3RydWN0IGlvYXNpZF9zZXQgKnNk YXRhLAogCQkJCQkgICAgICB2b2lkICpkYXRhKQogewogfQorCitzdGF0aWMgaW5saW5lIGludCBp b2FzaWRfcmVnaXN0ZXJfbm90aWZpZXJfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJCSAg ICAgIHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIpCit7CisJcmV0dXJuIC1FTk9UU1VQUDsKK30K Kworc3RhdGljIGlubGluZSB2b2lkIGlvYXNpZF91bnJlZ2lzdGVyX25vdGlmaWVyX21tKHN0cnVj dCBtbV9zdHJ1Y3QgKm1tLAorCQkJCQkJIHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIpCit7Cit9 CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBpb2FzaWRfcXVldWVfd29yayhzdHJ1Y3Qgd29ya19zdHJ1 Y3QgKndvcmspCit7CisJcmV0dXJuIGZhbHNlOworfQogI2VuZGlmIC8qIENPTkZJR19JT0FTSUQg Ki8KICNlbmRpZiAvKiBfX0xJTlVYX0lPQVNJRF9IICovCi0tIAoyLjI1LjEKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmlvbW11IG1haWxpbmcgbGlzdApp b21tdUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4Zm91bmRh dGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby9pb21tdQ== 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=-15.2 required=3.0 tests=BAYES_00,DATE_IN_PAST_06_12, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,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 68D82C433DB for ; Sun, 28 Feb 2021 06:40:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 30EC564DF2 for ; Sun, 28 Feb 2021 06:40:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230511AbhB1GkA (ORCPT ); Sun, 28 Feb 2021 01:40:00 -0500 Received: from mga09.intel.com ([134.134.136.24]:22647 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230462AbhB1Gjw (ORCPT ); Sun, 28 Feb 2021 01:39:52 -0500 IronPort-SDR: 89cxGE+AL8eS7SpWoQmA2TTWPviOuX5RwqwEXy8FgMg/LovMXnCZffmGVa1Kpr7/d4RAmxQEng OtMYi2dTSzYw== X-IronPort-AV: E=McAfee;i="6000,8403,9908"; a="186323902" X-IronPort-AV: E=Sophos;i="5.81,211,1610438400"; d="scan'208";a="186323902" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by orsmga102.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 27 Feb 2021 22:33:09 -0800 IronPort-SDR: qchTLFgyX916CIPRGYrZ6Gz/jgLi7dnTlsnEaeI9+8aGkJZxtP0fLvsmT6I9TZRolKwIsN+KcZ K/62nW9dIV4g== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.81,211,1610438400"; d="scan'208";a="517029725" Received: from otc-wp-03.jf.intel.com ([10.54.39.79]) by orsmga004.jf.intel.com with ESMTP; 27 Feb 2021 22:33:09 -0800 From: Jacob Pan To: LKML , Joerg Roedel , "Lu Baolu" , David Woodhouse , iommu@lists.linux-foundation.org, cgroups@vger.kernel.org, Tejun Heo , Li Zefan , Johannes Weiner , Jean-Philippe Brucker Cc: Alex Williamson , Eric Auger , Jason Gunthorpe , Jonathan Corbet , Raj Ashok , "Tian, Kevin" , Yi Liu , Wu Hao , Dave Jiang , Jacob Pan Subject: [PATCH V4 10/18] iommu/ioasid: Support mm token type ioasid_set notifications Date: Sat, 27 Feb 2021 14:01:18 -0800 Message-Id: <1614463286-97618-11-git-send-email-jacob.jun.pan@linux.intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> References: <1614463286-97618-1-git-send-email-jacob.jun.pan@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org As a system-wide resource, IOASID is often shared by multiple kernel subsystems that are independent of each other. However, at the ioasid_set level, these kernel subsystems must communicate with each other for ownership checking, event notifications, etc. For example, on Intel Scalable IO Virtualization (SIOV) enabled platforms, KVM and VFIO instances under the same process/guest must be aware of a shared IOASID set. IOASID_SET_TYPE_MM token type was introduced to explicitly mark an IOASID set that belongs to a process, thus use the same mm_struct pointer as a token. Users of the same process can then identify with each other based on this token. This patch introduces MM token specific event registration APIs. Event subscribers such as KVM instances can register IOASID event handler without the knowledge of its ioasid_set. Event handlers are registered based on its mm_struct pointer as a token. In case when subscribers register handler *prior* to the creation of the ioasid_set, the handler’s notification block is stored in a pending list within IOASID core. Once the ioasid_set of the MM token is created, the notification block will be registered by the IOASID core. Signed-off-by: Liu Yi L Signed-off-by: Wu Hao Signed-off-by: Jacob Pan --- drivers/iommu/ioasid.c | 142 +++++++++++++++++++++++++++++++++++++++++ include/linux/ioasid.h | 18 ++++++ 2 files changed, 160 insertions(+) diff --git a/drivers/iommu/ioasid.c b/drivers/iommu/ioasid.c index 56577e745c4b..96e941dfada7 100644 --- a/drivers/iommu/ioasid.c +++ b/drivers/iommu/ioasid.c @@ -21,6 +21,8 @@ * keep local states in sync. */ static ATOMIC_NOTIFIER_HEAD(ioasid_notifier); +/* List to hold pending notification block registrations */ +static LIST_HEAD(ioasid_nb_pending_list); static DEFINE_SPINLOCK(ioasid_nb_lock); /* Default to PCIe standard 20 bit PASID */ @@ -574,6 +576,27 @@ static inline bool ioasid_set_is_valid(struct ioasid_set *set) return xa_load(&ioasid_sets, set->id) == set; } +static void ioasid_add_pending_nb(struct ioasid_set *set) +{ + struct ioasid_set_nb *curr; + + if (set->type != IOASID_SET_TYPE_MM) + return; + /* + * Check if there are any pending nb requests for the given token, if so + * add them to the notifier chain. + */ + spin_lock(&ioasid_nb_lock); + list_for_each_entry(curr, &ioasid_nb_pending_list, list) { + if (curr->token == set->token && !curr->active) { + atomic_notifier_chain_register(&set->nh, curr->nb); + curr->set = set; + curr->active = true; + } + } + spin_unlock(&ioasid_nb_lock); +} + /** * ioasid_set_alloc - Allocate a new IOASID set for a given token * @@ -658,6 +681,11 @@ struct ioasid_set *ioasid_set_alloc(void *token, ioasid_t quota, int type) atomic_set(&set->nr_ioasids, 0); ATOMIC_INIT_NOTIFIER_HEAD(&set->nh); + /* + * Check if there are any pending nb requests for the given token, if so + * add them to the notifier chain. + */ + ioasid_add_pending_nb(set); /* * Per set XA is used to store private IDs within the set, get ready * for ioasid_set private ID and system-wide IOASID allocation @@ -675,6 +703,7 @@ EXPORT_SYMBOL_GPL(ioasid_set_alloc); static int ioasid_set_free_locked(struct ioasid_set *set) { + struct ioasid_set_nb *curr; int ret = 0; if (!ioasid_set_is_valid(set)) { @@ -688,6 +717,16 @@ static int ioasid_set_free_locked(struct ioasid_set *set) } WARN_ON(!xa_empty(&set->xa)); + /* Restore pending status of the set NBs */ + list_for_each_entry(curr, &ioasid_nb_pending_list, list) { + if (curr->token == set->token) { + if (curr->active) + curr->active = false; + else + pr_warn("Set token exists but not active!\n"); + } + } + /* * Token got released right away after the ioasid_set is freed. * If a new set is created immediately with the newly released token, @@ -1117,6 +1156,22 @@ EXPORT_SYMBOL_GPL(ioasid_register_notifier); void ioasid_unregister_notifier(struct ioasid_set *set, struct notifier_block *nb) { + struct ioasid_set_nb *curr; + + spin_lock(&ioasid_nb_lock); + /* + * Pending list is registered with a token without an ioasid_set, + * therefore should not be unregistered directly. + */ + list_for_each_entry(curr, &ioasid_nb_pending_list, list) { + if (curr->nb == nb) { + pr_warn("Cannot unregister NB from pending list\n"); + spin_unlock(&ioasid_nb_lock); + return; + } + } + spin_unlock(&ioasid_nb_lock); + if (set) atomic_notifier_chain_unregister(&set->nh, nb); else @@ -1124,6 +1179,93 @@ void ioasid_unregister_notifier(struct ioasid_set *set, } EXPORT_SYMBOL_GPL(ioasid_unregister_notifier); +/** + * ioasid_register_notifier_mm - Register a notifier block on the IOASID set + * created by the mm_struct pointer as the token + * + * @mm: the mm_struct token of the ioasid_set + * @nb: notfier block to be registered on the ioasid_set + * + * This a variant of ioasid_register_notifier() where the caller intends to + * listen to IOASID events belong the ioasid_set created under the same + * process. Caller is not aware of the ioasid_set, no need to hold reference + * of the ioasid_set. + */ +int ioasid_register_notifier_mm(struct mm_struct *mm, struct notifier_block *nb) +{ + struct ioasid_set_nb *curr; + struct ioasid_set *set; + int ret = 0; + + spin_lock(&ioasid_nb_lock); + /* Check for duplicates, nb is unique per set */ + list_for_each_entry(curr, &ioasid_nb_pending_list, list) { + if (curr->token == mm && curr->nb == nb) { + ret = -EBUSY; + goto exit_unlock; + } + } + curr = kzalloc(sizeof(*curr), GFP_ATOMIC); + if (!curr) { + ret = -ENOMEM; + goto exit_unlock; + } + /* Check if the token has an existing set */ + set = ioasid_find_mm_set(mm); + if (!set) { + /* Add to the rsvd list as inactive */ + curr->active = false; + } else { + /* REVISIT: Only register empty set for now. Can add an option + * in the future to playback existing PASIDs. + */ + if (atomic_read(&set->nr_ioasids)) { + pr_warn("IOASID set %d not empty %d\n", set->id, + atomic_read(&set->nr_ioasids)); + ret = -EBUSY; + goto exit_free; + } + curr->token = mm; + curr->nb = nb; + curr->active = true; + curr->set = set; + + /* Set already created, add to the notifier chain */ + atomic_notifier_chain_register(&set->nh, nb); + } + + list_add(&curr->list, &ioasid_nb_pending_list); + goto exit_unlock; +exit_free: + kfree(curr); +exit_unlock: + spin_unlock(&ioasid_nb_lock); + return ret; +} +EXPORT_SYMBOL_GPL(ioasid_register_notifier_mm); + +void ioasid_unregister_notifier_mm(struct mm_struct *mm, struct notifier_block *nb) +{ + struct ioasid_set_nb *curr; + + spin_lock(&ioasid_nb_lock); + list_for_each_entry(curr, &ioasid_nb_pending_list, list) { + if (curr->token == mm && curr->nb == nb) { + list_del(&curr->list); + spin_unlock(&ioasid_nb_lock); + if (curr->active) { + atomic_notifier_chain_unregister(&curr->set->nh, + nb); + } + kfree(curr); + return; + } + } + pr_warn("No ioasid set found for mm token %llx\n", (u64)mm); + spin_unlock(&ioasid_nb_lock); +} +EXPORT_SYMBOL_GPL(ioasid_unregister_notifier_mm); + MODULE_AUTHOR("Jean-Philippe Brucker "); MODULE_AUTHOR("Jacob Pan "); MODULE_DESCRIPTION("IO Address Space ID (IOASID) allocator"); diff --git a/include/linux/ioasid.h b/include/linux/ioasid.h index d8b85a04214f..c97e80ff65cc 100644 --- a/include/linux/ioasid.h +++ b/include/linux/ioasid.h @@ -132,6 +132,8 @@ void ioasid_unregister_notifier(struct ioasid_set *set, void ioasid_set_for_each_ioasid(struct ioasid_set *sdata, void (*fn)(ioasid_t id, void *data), void *data); +int ioasid_register_notifier_mm(struct mm_struct *mm, struct notifier_block *nb); +void ioasid_unregister_notifier_mm(struct mm_struct *mm, struct notifier_block *nb); #else /* !CONFIG_IOASID */ static inline void ioasid_install_capacity(ioasid_t total) { @@ -250,5 +252,21 @@ static inline void ioasid_set_for_each_ioasid(struct ioasid_set *sdata, void *data) { } + +static inline int ioasid_register_notifier_mm(struct mm_struct *mm, + struct notifier_block *nb) +{ + return -ENOTSUPP; +} + +static inline void ioasid_unregister_notifier_mm(struct mm_struct *mm, + struct notifier_block *nb) +{ +} + +static inline bool ioasid_queue_work(struct work_struct *work) +{ + return false; +} #endif /* CONFIG_IOASID */ #endif /* __LINUX_IOASID_H */ -- 2.25.1