From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tom Murphy via iommu Subject: [PATCH v3 1/4] iommu: Add gfp parameter to iommu_ops::map Date: Mon, 6 May 2019 19:52:03 +0100 Message-ID: <20190506185207.31069-2-tmurphy@arista.com> References: <20190506185207.31069-1-tmurphy@arista.com> Reply-To: Tom Murphy Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190506185207.31069-1-tmurphy-nzgTgzXrdUbQT0dZR+AlfA@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: iommu-cunTk1MwBs9QetFLy7KEm3xJsTq8ys+cHZ5vskTnxNA@public.gmane.org Cc: Heiko Stuebner , Will Deacon , David Brown , Thierry Reding , linux-s390-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-samsung-soc-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Krzysztof Kozlowski , Jonathan Hunter , linux-rockchip-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, Kukjin Kim , Gerald Schaefer , Andy Gross , linux-tegra-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-mediatek-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, Matthias Brugger , linux-arm-kernel-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, Tom Murphy , Robin Murphy , linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, murphyt7-/Zw1syy4LHg@public.gmane.org, David Woodhouse List-Id: linux-arm-msm@vger.kernel.org QWRkIGEgZ2ZwX3QgcGFyYW1ldGVyIHRvIHRoZSBpb21tdV9vcHM6Om1hcCBmdW5jdGlvbi4KUmVt b3ZlIHRoZSBuZWVkbGVzcyBsb2NraW5nIGluIHRoZSBBTUQgaW9tbXUgZHJpdmVyLgoKVGhlIGlv bW11X29wczo6bWFwIGZ1bmN0aW9uIChvciB0aGUgaW9tbXVfbWFwIGZ1bmN0aW9uIHdoaWNoIGNh bGxzIGl0KQp3YXMgYWx3YXlzIHN1cHBvc2VkIHRvIGJlIHNsZWVwYWJsZSAoYWNjb3JkaW5nIHRv IEpvZXJnJ3MgY29tbWVudCBpbgp0aGlzIHRocmVhZDogaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcv cGF0Y2h3b3JrL3BhdGNoLzk3NzUyMC8gKSBhbmQgc28Kc2hvdWxkIHByb2JhYmx5IGhhdmUgaGFk IGEgIm1pZ2h0X3NsZWVwKCkiIHNpbmNlIGl0IHdhcyB3cml0dGVuLiBIb3dldmVyCmN1cnJlbnRs eSB0aGUgZG1hLWlvbW11IGFwaSBjYW4gY2FsbCBpb21tdV9tYXAgaW4gYW4gYXRvbWljIGNvbnRl eHQsCndoaWNoIGl0IHNob3VsZG4ndCBkby4gVGhpcyBkb2Vzbid0IGNhdXNlIGFueSBwcm9ibGVt cyBiZWNhdXNlIGFueSBpb21tdQpkcml2ZXIgd2hpY2ggdXNlcyB0aGUgZG1hLWlvbW11IGFwaSB1 c2VzIGdmcF9hdG9taWMgaW4gaXQncwppb21tdV9vcHM6Om1hcCBmdW5jdGlvbi4gQnV0IGRvaW5n IHRoaXMgd2FzdGVzIHRoZSBtZW1vcnkgYWxsb2NhdG9ycwphdG9taWMgcG9vbHMuCgpXZSBjYW4g cmVtb3ZlIHRoZSBtdXRleCBsb2NrIGZyb20gYW1kX2lvbW11X21hcCBhbmQgYW1kX2lvbW11X3Vu bWFwLgppb21tdV9tYXAgZG9lc27igJl0IGxvY2sgd2hpbGUgbWFwcGluZyBhbmQgc28gbm8gdHdv IGNhbGxzIHNob3VsZCB0b3VjaAp0aGUgc2FtZSBpb3ZhIHJhbmdlLiBUaGUgQU1EIGRyaXZlciBh bHJlYWR5IGhhbmRsZXMgdGhlIHBhZ2UgdGFibGUgcGFnZQphbGxvY2F0aW9ucyB3aXRob3V0IGxv Y2tzIHNvIHdlIGNhbiBzYWZlbHkgcmVtb3ZlIHRoZSBsb2Nrcy4KClNpZ25lZC1vZmYtYnk6IFRv bSBNdXJwaHkgPHRtdXJwaHlAYXJpc3RhLmNvbT4KLS0tCiBkcml2ZXJzL2lvbW11L2FtZF9pb21t dS5jICAgICAgfCAxNCArKysrLS0tLS0tLQogZHJpdmVycy9pb21tdS9hcm0tc21tdS12My5jICAg IHwgIDIgKy0KIGRyaXZlcnMvaW9tbXUvYXJtLXNtbXUuYyAgICAgICB8ICAyICstCiBkcml2ZXJz L2lvbW11L2RtYS1pb21tdS5jICAgICAgfCAgNiArKy0tLQogZHJpdmVycy9pb21tdS9leHlub3Mt aW9tbXUuYyAgIHwgIDIgKy0KIGRyaXZlcnMvaW9tbXUvaW50ZWwtaW9tbXUuYyAgICB8ICAyICst CiBkcml2ZXJzL2lvbW11L2lvbW11LmMgICAgICAgICAgfCA0MyArKysrKysrKysrKysrKysrKysr KysrKysrKysrKy0tLS0tCiBkcml2ZXJzL2lvbW11L2lwbW11LXZtc2EuYyAgICAgfCAgMiArLQog ZHJpdmVycy9pb21tdS9tc21faW9tbXUuYyAgICAgIHwgIDIgKy0KIGRyaXZlcnMvaW9tbXUvbXRr X2lvbW11LmMgICAgICB8ICAyICstCiBkcml2ZXJzL2lvbW11L210a19pb21tdV92MS5jICAgfCAg MiArLQogZHJpdmVycy9pb21tdS9vbWFwLWlvbW11LmMgICAgIHwgIDIgKy0KIGRyaXZlcnMvaW9t bXUvcWNvbV9pb21tdS5jICAgICB8ICAyICstCiBkcml2ZXJzL2lvbW11L3JvY2tjaGlwLWlvbW11 LmMgfCAgMiArLQogZHJpdmVycy9pb21tdS9zMzkwLWlvbW11LmMgICAgIHwgIDIgKy0KIGRyaXZl cnMvaW9tbXUvdGVncmEtZ2FydC5jICAgICB8ICAyICstCiBkcml2ZXJzL2lvbW11L3RlZ3JhLXNt bXUuYyAgICAgfCAgMiArLQogaW5jbHVkZS9saW51eC9pb21tdS5oICAgICAgICAgIHwgMjEgKysr KysrKysrKysrKysrKy0KIDE4IGZpbGVzIGNoYW5nZWQsIDc4IGluc2VydGlvbnMoKyksIDM0IGRl bGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUvYW1kX2lvbW11LmMgYi9kcml2 ZXJzL2lvbW11L2FtZF9pb21tdS5jCmluZGV4IGViZDA2MjUyMmNmNS4uZWEzYTVkYzYxYmIwIDEw MDY0NAotLS0gYS9kcml2ZXJzL2lvbW11L2FtZF9pb21tdS5jCisrKyBiL2RyaXZlcnMvaW9tbXUv YW1kX2lvbW11LmMKQEAgLTMwOTIsNyArMzA5Miw4IEBAIHN0YXRpYyBpbnQgYW1kX2lvbW11X2F0 dGFjaF9kZXZpY2Uoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tLAogfQogCiBzdGF0aWMgaW50IGFt ZF9pb21tdV9tYXAoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tLCB1bnNpZ25lZCBsb25nIGlvdmEs Ci0JCQkgcGh5c19hZGRyX3QgcGFkZHIsIHNpemVfdCBwYWdlX3NpemUsIGludCBpb21tdV9wcm90 KQorCQkJIHBoeXNfYWRkcl90IHBhZGRyLCBzaXplX3QgcGFnZV9zaXplLCBpbnQgaW9tbXVfcHJv dCwKKwkJCSBnZnBfdCBnZnApCiB7CiAJc3RydWN0IHByb3RlY3Rpb25fZG9tYWluICpkb21haW4g PSB0b19wZG9tYWluKGRvbSk7CiAJaW50IHByb3QgPSAwOwpAQCAtMzEwNiw5ICszMTA3LDcgQEAg c3RhdGljIGludCBhbWRfaW9tbXVfbWFwKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbSwgdW5zaWdu ZWQgbG9uZyBpb3ZhLAogCWlmIChpb21tdV9wcm90ICYgSU9NTVVfV1JJVEUpCiAJCXByb3QgfD0g SU9NTVVfUFJPVF9JVzsKIAotCW11dGV4X2xvY2soJmRvbWFpbi0+YXBpX2xvY2spOwotCXJldCA9 IGlvbW11X21hcF9wYWdlKGRvbWFpbiwgaW92YSwgcGFkZHIsIHBhZ2Vfc2l6ZSwgcHJvdCwgR0ZQ X0tFUk5FTCk7Ci0JbXV0ZXhfdW5sb2NrKCZkb21haW4tPmFwaV9sb2NrKTsKKwlyZXQgPSBpb21t dV9tYXBfcGFnZShkb21haW4sIGlvdmEsIHBhZGRyLCBwYWdlX3NpemUsIHByb3QsIGdmcCk7CiAK IAlkb21haW5fZmx1c2hfbnBfY2FjaGUoZG9tYWluLCBpb3ZhLCBwYWdlX3NpemUpOwogCkBAIC0z MTE5LDE2ICszMTE4LDExIEBAIHN0YXRpYyBzaXplX3QgYW1kX2lvbW11X3VubWFwKHN0cnVjdCBp b21tdV9kb21haW4gKmRvbSwgdW5zaWduZWQgbG9uZyBpb3ZhLAogCQkJICAgc2l6ZV90IHBhZ2Vf c2l6ZSkKIHsKIAlzdHJ1Y3QgcHJvdGVjdGlvbl9kb21haW4gKmRvbWFpbiA9IHRvX3Bkb21haW4o ZG9tKTsKLQlzaXplX3QgdW5tYXBfc2l6ZTsKIAogCWlmIChkb21haW4tPm1vZGUgPT0gUEFHRV9N T0RFX05PTkUpCiAJCXJldHVybiAwOwogCi0JbXV0ZXhfbG9jaygmZG9tYWluLT5hcGlfbG9jayk7 Ci0JdW5tYXBfc2l6ZSA9IGlvbW11X3VubWFwX3BhZ2UoZG9tYWluLCBpb3ZhLCBwYWdlX3NpemUp OwotCW11dGV4X3VubG9jaygmZG9tYWluLT5hcGlfbG9jayk7Ci0KLQlyZXR1cm4gdW5tYXBfc2l6 ZTsKKwlyZXR1cm4gaW9tbXVfdW5tYXBfcGFnZShkb21haW4sIGlvdmEsIHBhZ2Vfc2l6ZSk7CiB9 CiAKIHN0YXRpYyBwaHlzX2FkZHJfdCBhbWRfaW9tbXVfaW92YV90b19waHlzKHN0cnVjdCBpb21t dV9kb21haW4gKmRvbSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUvYXJtLXNtbXUtdjMuYyBi L2RyaXZlcnMvaW9tbXUvYXJtLXNtbXUtdjMuYwppbmRleCBkMzg4MDAxMGM2Y2YuLmU1YzQ4MDg5 YjQ5ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pb21tdS9hcm0tc21tdS12My5jCisrKyBiL2RyaXZl cnMvaW9tbXUvYXJtLXNtbXUtdjMuYwpAQCAtMTc3Nyw3ICsxNzc3LDcgQEAgc3RhdGljIGludCBh cm1fc21tdV9hdHRhY2hfZGV2KHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwgc3RydWN0IGRl dmljZSAqZGV2KQogfQogCiBzdGF0aWMgaW50IGFybV9zbW11X21hcChzdHJ1Y3QgaW9tbXVfZG9t YWluICpkb21haW4sIHVuc2lnbmVkIGxvbmcgaW92YSwKLQkJCXBoeXNfYWRkcl90IHBhZGRyLCBz aXplX3Qgc2l6ZSwgaW50IHByb3QpCisJCQlwaHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90IHNpemUs IGludCBwcm90LCBnZnBfdCBnZnApCiB7CiAJc3RydWN0IGlvX3BndGFibGVfb3BzICpvcHMgPSB0 b19zbW11X2RvbWFpbihkb21haW4pLT5wZ3RibF9vcHM7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMv aW9tbXUvYXJtLXNtbXUuYyBiL2RyaXZlcnMvaW9tbXUvYXJtLXNtbXUuYwppbmRleCAwNDVkOTM4 ODQxNjQuLjJkNTBkYjU1Yjc4OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pb21tdS9hcm0tc21tdS5j CisrKyBiL2RyaXZlcnMvaW9tbXUvYXJtLXNtbXUuYwpAQCAtMTI4Niw3ICsxMjg2LDcgQEAgc3Rh dGljIGludCBhcm1fc21tdV9hdHRhY2hfZGV2KHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwg c3RydWN0IGRldmljZSAqZGV2KQogfQogCiBzdGF0aWMgaW50IGFybV9zbW11X21hcChzdHJ1Y3Qg aW9tbXVfZG9tYWluICpkb21haW4sIHVuc2lnbmVkIGxvbmcgaW92YSwKLQkJCXBoeXNfYWRkcl90 IHBhZGRyLCBzaXplX3Qgc2l6ZSwgaW50IHByb3QpCisJCQlwaHlzX2FkZHJfdCBwYWRkciwgc2l6 ZV90IHNpemUsIGludCBwcm90LCBnZnBfdCBnZnApCiB7CiAJc3RydWN0IGlvX3BndGFibGVfb3Bz ICpvcHMgPSB0b19zbW11X2RvbWFpbihkb21haW4pLT5wZ3RibF9vcHM7CiAJc3RydWN0IGFybV9z bW11X2RldmljZSAqc21tdSA9IHRvX3NtbXVfZG9tYWluKGRvbWFpbiktPnNtbXU7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL2lvbW11L2RtYS1pb21tdS5jIGIvZHJpdmVycy9pb21tdS9kbWEtaW9tbXUu YwppbmRleCBmYTU3MTNhNGY2ZjguLjdhOTZjMmM4ZjU2YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9p b21tdS9kbWEtaW9tbXUuYworKysgYi9kcml2ZXJzL2lvbW11L2RtYS1pb21tdS5jCkBAIC00NDAs NyArNDQwLDcgQEAgc3RhdGljIGRtYV9hZGRyX3QgX19pb21tdV9kbWFfbWFwKHN0cnVjdCBkZXZp Y2UgKmRldiwgcGh5c19hZGRyX3QgcGh5cywKIAlpZiAoIWlvdmEpCiAJCXJldHVybiBETUFfTUFQ UElOR19FUlJPUjsKIAotCWlmIChpb21tdV9tYXAoZG9tYWluLCBpb3ZhLCBwaHlzIC0gaW92YV9v ZmYsIHNpemUsIHByb3QpKSB7CisJaWYgKGlvbW11X21hcF9hdG9taWMoZG9tYWluLCBpb3ZhLCBw aHlzIC0gaW92YV9vZmYsIHNpemUsIHByb3QpKSB7CiAJCWlvbW11X2RtYV9mcmVlX2lvdmEoY29v a2llLCBpb3ZhLCBzaXplKTsKIAkJcmV0dXJuIERNQV9NQVBQSU5HX0VSUk9SOwogCX0KQEAgLTY0 MSw3ICs2NDEsNyBAQCBzdGF0aWMgdm9pZCAqaW9tbXVfZG1hX2FsbG9jX3JlbWFwKHN0cnVjdCBk ZXZpY2UgKmRldiwgc2l6ZV90IHNpemUsCiAJCQlhcmNoX2RtYV9wcmVwX2NvaGVyZW50KHNnX3Bh Z2Uoc2cpLCBzZy0+bGVuZ3RoKTsKIAl9CiAKLQlpZiAoaW9tbXVfbWFwX3NnKGRvbWFpbiwgaW92 YSwgc2d0LnNnbCwgc2d0Lm9yaWdfbmVudHMsIGlvcHJvdCkKKwlpZiAoaW9tbXVfbWFwX3NnX2F0 b21pYyhkb21haW4sIGlvdmEsIHNndC5zZ2wsIHNndC5vcmlnX25lbnRzLCBpb3Byb3QpCiAJCQk8 IHNpemUpCiAJCWdvdG8gb3V0X2ZyZWVfc2c7CiAKQEAgLTEwMDMsNyArMTAwMyw3IEBAIHN0YXRp YyBpbnQgaW9tbXVfZG1hX21hcF9zZyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBzY2F0dGVy bGlzdCAqc2csCiAJICogV2UnbGwgbGVhdmUgYW55IHBoeXNpY2FsIGNvbmNhdGVuYXRpb24gdG8g dGhlIElPTU1VIGRyaXZlcidzCiAJICogaW1wbGVtZW50YXRpb24gLSBpdCBrbm93cyBiZXR0ZXIg dGhhbiB3ZSBkby4KIAkgKi8KLQlpZiAoaW9tbXVfbWFwX3NnKGRvbWFpbiwgaW92YSwgc2csIG5l bnRzLCBwcm90KSA8IGlvdmFfbGVuKQorCWlmIChpb21tdV9tYXBfc2dfYXRvbWljKGRvbWFpbiwg aW92YSwgc2csIG5lbnRzLCBwcm90KSA8IGlvdmFfbGVuKQogCQlnb3RvIG91dF9mcmVlX2lvdmE7 CiAKIAlyZXR1cm4gX19maW5hbGlzZV9zZyhkZXYsIHNnLCBuZW50cywgaW92YSk7CmRpZmYgLS1n aXQgYS9kcml2ZXJzL2lvbW11L2V4eW5vcy1pb21tdS5jIGIvZHJpdmVycy9pb21tdS9leHlub3Mt aW9tbXUuYwppbmRleCAwNWM2YmMwOTlkNjIuLjQ2NDE0MjM0YzE3OSAxMDA2NDQKLS0tIGEvZHJp dmVycy9pb21tdS9leHlub3MtaW9tbXUuYworKysgYi9kcml2ZXJzL2lvbW11L2V4eW5vcy1pb21t dS5jCkBAIC0xMDc4LDcgKzEwNzgsNyBAQCBzdGF0aWMgaW50IGx2MnNldF9wYWdlKHN5c21tdV9w dGVfdCAqcGVudCwgcGh5c19hZGRyX3QgcGFkZHIsIHNpemVfdCBzaXplLAogICovCiBzdGF0aWMg aW50IGV4eW5vc19pb21tdV9tYXAoc3RydWN0IGlvbW11X2RvbWFpbiAqaW9tbXVfZG9tYWluLAog CQkJICAgIHVuc2lnbmVkIGxvbmcgbF9pb3ZhLCBwaHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90IHNp emUsCi0JCQkgICAgaW50IHByb3QpCisJCQkgICAgaW50IHByb3QsIGdmcF90IGdmcCkKIHsKIAlz dHJ1Y3QgZXh5bm9zX2lvbW11X2RvbWFpbiAqZG9tYWluID0gdG9fZXh5bm9zX2RvbWFpbihpb21t dV9kb21haW4pOwogCXN5c21tdV9wdGVfdCAqZW50cnk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lv bW11L2ludGVsLWlvbW11LmMgYi9kcml2ZXJzL2lvbW11L2ludGVsLWlvbW11LmMKaW5kZXggMjhj YjcxM2Q3MjhjLi40ZjBmZjI4ZjdjYjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW9tbXUvaW50ZWwt aW9tbXUuYworKysgYi9kcml2ZXJzL2lvbW11L2ludGVsLWlvbW11LmMKQEAgLTUxMzcsNyArNTEz Nyw3IEBAIHN0YXRpYyB2b2lkIGludGVsX2lvbW11X2RldGFjaF9kZXZpY2Uoc3RydWN0IGlvbW11 X2RvbWFpbiAqZG9tYWluLAogCiBzdGF0aWMgaW50IGludGVsX2lvbW11X21hcChzdHJ1Y3QgaW9t bXVfZG9tYWluICpkb21haW4sCiAJCQkgICB1bnNpZ25lZCBsb25nIGlvdmEsIHBoeXNfYWRkcl90 IGhwYSwKLQkJCSAgIHNpemVfdCBzaXplLCBpbnQgaW9tbXVfcHJvdCkKKwkJCSAgIHNpemVfdCBz aXplLCBpbnQgaW9tbXVfcHJvdCwgZ2ZwX3QgZ2ZwKQogewogCXN0cnVjdCBkbWFyX2RvbWFpbiAq ZG1hcl9kb21haW4gPSB0b19kbWFyX2RvbWFpbihkb21haW4pOwogCXU2NCBtYXhfYWRkcjsKZGlm ZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUvaW9tbXUuYyBiL2RyaXZlcnMvaW9tbXUvaW9tbXUuYwpp bmRleCAxMDlkZTY3ZDVkNzIuLjFiNDk4NDFjMTc3ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pb21t dS9pb21tdS5jCisrKyBiL2RyaXZlcnMvaW9tbXUvaW9tbXUuYwpAQCAtMTU4NCw4ICsxNTg0LDgg QEAgc3RhdGljIHNpemVfdCBpb21tdV9wZ3NpemUoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWlu LAogCXJldHVybiBwZ3NpemU7CiB9CiAKLWludCBpb21tdV9tYXAoc3RydWN0IGlvbW11X2RvbWFp biAqZG9tYWluLCB1bnNpZ25lZCBsb25nIGlvdmEsCi0JICAgICAgcGh5c19hZGRyX3QgcGFkZHIs IHNpemVfdCBzaXplLCBpbnQgcHJvdCkKK2ludCBfX2lvbW11X21hcChzdHJ1Y3QgaW9tbXVfZG9t YWluICpkb21haW4sIHVuc2lnbmVkIGxvbmcgaW92YSwKKwkgICAgICBwaHlzX2FkZHJfdCBwYWRk ciwgc2l6ZV90IHNpemUsIGludCBwcm90LCBnZnBfdCBnZnApCiB7CiAJY29uc3Qgc3RydWN0IGlv bW11X29wcyAqb3BzID0gZG9tYWluLT5vcHM7CiAJdW5zaWduZWQgbG9uZyBvcmlnX2lvdmEgPSBp b3ZhOwpAQCAtMTYyMiw4ICsxNjIyLDggQEAgaW50IGlvbW11X21hcChzdHJ1Y3QgaW9tbXVfZG9t YWluICpkb21haW4sIHVuc2lnbmVkIGxvbmcgaW92YSwKIAogCQlwcl9kZWJ1ZygibWFwcGluZzog aW92YSAweCVseCBwYSAlcGEgcGdzaXplIDB4JXp4XG4iLAogCQkJIGlvdmEsICZwYWRkciwgcGdz aXplKTsKKwkJcmV0ID0gb3BzLT5tYXAoZG9tYWluLCBpb3ZhLCBwYWRkciwgcGdzaXplLCBwcm90 LCBnZnApOwogCi0JCXJldCA9IG9wcy0+bWFwKGRvbWFpbiwgaW92YSwgcGFkZHIsIHBnc2l6ZSwg cHJvdCk7CiAJCWlmIChyZXQpCiAJCQlicmVhazsKIApAQCAtMTY0Myw4ICsxNjQzLDIyIEBAIGlu dCBpb21tdV9tYXAoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCB1bnNpZ25lZCBsb25nIGlv dmEsCiAKIAlyZXR1cm4gcmV0OwogfQorCitpbnQgaW9tbXVfbWFwKHN0cnVjdCBpb21tdV9kb21h aW4gKmRvbWFpbiwgdW5zaWduZWQgbG9uZyBpb3ZhLAorCSAgICAgIHBoeXNfYWRkcl90IHBhZGRy LCBzaXplX3Qgc2l6ZSwgaW50IHByb3QpCit7CisJbWlnaHRfc2xlZXAoKTsKKwlyZXR1cm4gX19p b21tdV9tYXAoZG9tYWluLCBpb3ZhLCBwYWRkciwgc2l6ZSwgcHJvdCwgR0ZQX0tFUk5FTCk7Cit9 CiBFWFBPUlRfU1lNQk9MX0dQTChpb21tdV9tYXApOwogCitpbnQgaW9tbXVfbWFwX2F0b21pYyhz dHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4sIHVuc2lnbmVkIGxvbmcgaW92YSwKKwkgICAgICBw aHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90IHNpemUsIGludCBwcm90KQoreworCXJldHVybiBfX2lv bW11X21hcChkb21haW4sIGlvdmEsIHBhZGRyLCBzaXplLCBwcm90LCBHRlBfQVRPTUlDKTsKK30K K0VYUE9SVF9TWU1CT0xfR1BMKGlvbW11X21hcF9hdG9taWMpOworCiBzdGF0aWMgc2l6ZV90IF9f aW9tbXVfdW5tYXAoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLAogCQkJICAgIHVuc2lnbmVk IGxvbmcgaW92YSwgc2l6ZV90IHNpemUsCiAJCQkgICAgYm9vbCBzeW5jKQpAQCAtMTcxOSw4ICsx NzMzLDkgQEAgc2l6ZV90IGlvbW11X3VubWFwX2Zhc3Qoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9t YWluLAogfQogRVhQT1JUX1NZTUJPTF9HUEwoaW9tbXVfdW5tYXBfZmFzdCk7CiAKLXNpemVfdCBp b21tdV9tYXBfc2coc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCB1bnNpZ25lZCBsb25nIGlv dmEsCi0JCSAgICBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLCB1bnNpZ25lZCBpbnQgbmVudHMsIGlu dCBwcm90KQorc2l6ZV90IF9faW9tbXVfbWFwX3NnKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFp biwgdW5zaWduZWQgbG9uZyBpb3ZhLAorCQkgICAgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZywgdW5z aWduZWQgaW50IG5lbnRzLCBpbnQgcHJvdCwKKwkJICAgIGdmcF90IGdmcCkKIHsKIAlzaXplX3Qg bGVuID0gMCwgbWFwcGVkID0gMDsKIAlwaHlzX2FkZHJfdCBzdGFydDsKQEAgLTE3MzEsNyArMTc0 Niw5IEBAIHNpemVfdCBpb21tdV9tYXBfc2coc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCB1 bnNpZ25lZCBsb25nIGlvdmEsCiAJCXBoeXNfYWRkcl90IHNfcGh5cyA9IHNnX3BoeXMoc2cpOwog CiAJCWlmIChsZW4gJiYgc19waHlzICE9IHN0YXJ0ICsgbGVuKSB7Ci0JCQlyZXQgPSBpb21tdV9t YXAoZG9tYWluLCBpb3ZhICsgbWFwcGVkLCBzdGFydCwgbGVuLCBwcm90KTsKKwkJCXJldCA9IF9f aW9tbXVfbWFwKGRvbWFpbiwgaW92YSArIG1hcHBlZCwgc3RhcnQsCisJCQkJCWxlbiwgcHJvdCwg Z2ZwKTsKKwogCQkJaWYgKHJldCkKIAkJCQlnb3RvIG91dF9lcnI7CiAKQEAgLTE3NTksOCArMTc3 NiwyMiBAQCBzaXplX3QgaW9tbXVfbWFwX3NnKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwg dW5zaWduZWQgbG9uZyBpb3ZhLAogCXJldHVybiAwOwogCiB9CisKK3NpemVfdCBpb21tdV9tYXBf c2coc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCB1bnNpZ25lZCBsb25nIGlvdmEsCisJCSAg ICBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLCB1bnNpZ25lZCBpbnQgbmVudHMsIGludCBwcm90KQor eworCW1pZ2h0X3NsZWVwKCk7CisJcmV0dXJuIF9faW9tbXVfbWFwX3NnKGRvbWFpbiwgaW92YSwg c2csIG5lbnRzLCBwcm90LCBHRlBfS0VSTkVMKTsKK30KIEVYUE9SVF9TWU1CT0xfR1BMKGlvbW11 X21hcF9zZyk7CiAKK3NpemVfdCBpb21tdV9tYXBfc2dfYXRvbWljKHN0cnVjdCBpb21tdV9kb21h aW4gKmRvbWFpbiwgdW5zaWduZWQgbG9uZyBpb3ZhLAorCQkgICAgc3RydWN0IHNjYXR0ZXJsaXN0 ICpzZywgdW5zaWduZWQgaW50IG5lbnRzLCBpbnQgcHJvdCkKK3sKKwlyZXR1cm4gX19pb21tdV9t YXBfc2coZG9tYWluLCBpb3ZhLCBzZywgbmVudHMsIHByb3QsIEdGUF9BVE9NSUMpOworfQorRVhQ T1JUX1NZTUJPTF9HUEwoaW9tbXVfbWFwX3NnX2F0b21pYyk7CisKIGludCBpb21tdV9kb21haW5f d2luZG93X2VuYWJsZShzdHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4sIHUzMiB3bmRfbnIsCiAJ CQkgICAgICAgcGh5c19hZGRyX3QgcGFkZHIsIHU2NCBzaXplLCBpbnQgcHJvdCkKIHsKZGlmZiAt LWdpdCBhL2RyaXZlcnMvaW9tbXUvaXBtbXUtdm1zYS5jIGIvZHJpdmVycy9pb21tdS9pcG1tdS12 bXNhLmMKaW5kZXggOWEzODBjMTA2NTVlLi5lMDA1YzgzZDQ5ZDggMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvaW9tbXUvaXBtbXUtdm1zYS5jCisrKyBiL2RyaXZlcnMvaW9tbXUvaXBtbXUtdm1zYS5jCkBA IC03MDcsNyArNzA3LDcgQEAgc3RhdGljIHZvaWQgaXBtbXVfZGV0YWNoX2RldmljZShzdHJ1Y3Qg aW9tbXVfZG9tYWluICppb19kb21haW4sCiB9CiAKIHN0YXRpYyBpbnQgaXBtbXVfbWFwKHN0cnVj dCBpb21tdV9kb21haW4gKmlvX2RvbWFpbiwgdW5zaWduZWQgbG9uZyBpb3ZhLAotCQkgICAgIHBo eXNfYWRkcl90IHBhZGRyLCBzaXplX3Qgc2l6ZSwgaW50IHByb3QpCisJCSAgICAgcGh5c19hZGRy X3QgcGFkZHIsIHNpemVfdCBzaXplLCBpbnQgcHJvdCwgZ2ZwX3QgZ2ZwKQogewogCXN0cnVjdCBp cG1tdV92bXNhX2RvbWFpbiAqZG9tYWluID0gdG9fdm1zYV9kb21haW4oaW9fZG9tYWluKTsKIApk aWZmIC0tZ2l0IGEvZHJpdmVycy9pb21tdS9tc21faW9tbXUuYyBiL2RyaXZlcnMvaW9tbXUvbXNt X2lvbW11LmMKaW5kZXggOWZiMGViN2E0ZDAyLi4zZjZiZjM2NTNhYTIgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvaW9tbXUvbXNtX2lvbW11LmMKKysrIGIvZHJpdmVycy9pb21tdS9tc21faW9tbXUuYwpA QCAtNTA4LDcgKzUwOCw3IEBAIHN0YXRpYyB2b2lkIG1zbV9pb21tdV9kZXRhY2hfZGV2KHN0cnVj dCBpb21tdV9kb21haW4gKmRvbWFpbiwKIH0KIAogc3RhdGljIGludCBtc21faW9tbXVfbWFwKHN0 cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwgdW5zaWduZWQgbG9uZyBpb3ZhLAotCQkJIHBoeXNf YWRkcl90IHBhLCBzaXplX3QgbGVuLCBpbnQgcHJvdCkKKwkJCSBwaHlzX2FkZHJfdCBwYSwgc2l6 ZV90IGxlbiwgaW50IHByb3QsIGdmcF90IGdmcCkKIHsKIAlzdHJ1Y3QgbXNtX3ByaXYgKnByaXYg PSB0b19tc21fcHJpdihkb21haW4pOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CmRpZmYgLS1naXQg YS9kcml2ZXJzL2lvbW11L210a19pb21tdS5jIGIvZHJpdmVycy9pb21tdS9tdGtfaW9tbXUuYwpp bmRleCBkZTNlMDIyNzdiNzAuLjMxNzZiOWI1NGQ0ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pb21t dS9tdGtfaW9tbXUuYworKysgYi9kcml2ZXJzL2lvbW11L210a19pb21tdS5jCkBAIC0zNjQsNyAr MzY0LDcgQEAgc3RhdGljIHZvaWQgbXRrX2lvbW11X2RldGFjaF9kZXZpY2Uoc3RydWN0IGlvbW11 X2RvbWFpbiAqZG9tYWluLAogfQogCiBzdGF0aWMgaW50IG10a19pb21tdV9tYXAoc3RydWN0IGlv bW11X2RvbWFpbiAqZG9tYWluLCB1bnNpZ25lZCBsb25nIGlvdmEsCi0JCQkgcGh5c19hZGRyX3Qg cGFkZHIsIHNpemVfdCBzaXplLCBpbnQgcHJvdCkKKwkJCSBwaHlzX2FkZHJfdCBwYWRkciwgc2l6 ZV90IHNpemUsIGludCBwcm90LCBnZnBfdCBnZnApCiB7CiAJc3RydWN0IG10a19pb21tdV9kb21h aW4gKmRvbSA9IHRvX210a19kb21haW4oZG9tYWluKTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9pb21tdS9tdGtfaW9tbXVfdjEuYyBiL2RyaXZlcnMvaW9tbXUv bXRrX2lvbW11X3YxLmMKaW5kZXggNTJiMDFlM2E0OWRmLi5lN2IxOTA3ZmFlYzEgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvaW9tbXUvbXRrX2lvbW11X3YxLmMKKysrIGIvZHJpdmVycy9pb21tdS9tdGtf aW9tbXVfdjEuYwpAQCAtMzAzLDcgKzMwMyw3IEBAIHN0YXRpYyB2b2lkIG10a19pb21tdV9kZXRh Y2hfZGV2aWNlKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwKIH0KIAogc3RhdGljIGludCBt dGtfaW9tbXVfbWFwKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwgdW5zaWduZWQgbG9uZyBp b3ZhLAotCQkJIHBoeXNfYWRkcl90IHBhZGRyLCBzaXplX3Qgc2l6ZSwgaW50IHByb3QpCisJCQkg cGh5c19hZGRyX3QgcGFkZHIsIHNpemVfdCBzaXplLCBpbnQgcHJvdCwgZ2ZwX3QgZ2ZwKQogewog CXN0cnVjdCBtdGtfaW9tbXVfZG9tYWluICpkb20gPSB0b19tdGtfZG9tYWluKGRvbWFpbik7CiAJ dW5zaWduZWQgaW50IHBhZ2VfbnVtID0gc2l6ZSA+PiBNVDI3MDFfSU9NTVVfUEFHRV9TSElGVDsK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUvb21hcC1pb21tdS5jIGIvZHJpdmVycy9pb21tdS9v bWFwLWlvbW11LmMKaW5kZXggZDJmYjM0N2FhNGZmLi5jMWQ1YTcxMjg1ZGMgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvaW9tbXUvb21hcC1pb21tdS5jCisrKyBiL2RyaXZlcnMvaW9tbXUvb21hcC1pb21t dS5jCkBAIC0xMTA5LDcgKzExMDksNyBAQCBzdGF0aWMgdTMyIGlvdGxiX2luaXRfZW50cnkoc3Ry dWN0IGlvdGxiX2VudHJ5ICplLCB1MzIgZGEsIHUzMiBwYSwgaW50IHBnc3opCiB9CiAKIHN0YXRp YyBpbnQgb21hcF9pb21tdV9tYXAoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCB1bnNpZ25l ZCBsb25nIGRhLAotCQkJICBwaHlzX2FkZHJfdCBwYSwgc2l6ZV90IGJ5dGVzLCBpbnQgcHJvdCkK KwkJCSAgcGh5c19hZGRyX3QgcGEsIHNpemVfdCBieXRlcywgaW50IHByb3QsIGdmcF90IGdmcCkK IHsKIAlzdHJ1Y3Qgb21hcF9pb21tdV9kb21haW4gKm9tYXBfZG9tYWluID0gdG9fb21hcF9kb21h aW4oZG9tYWluKTsKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSBvbWFwX2RvbWFpbi0+ZGV2OwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9pb21tdS9xY29tX2lvbW11LmMgYi9kcml2ZXJzL2lvbW11L3Fjb21f aW9tbXUuYwppbmRleCA4Y2RkM2YwNTk1MTMuLmEwMWUwN2E0ZTc2ZiAxMDA2NDQKLS0tIGEvZHJp dmVycy9pb21tdS9xY29tX2lvbW11LmMKKysrIGIvZHJpdmVycy9pb21tdS9xY29tX2lvbW11LmMK QEAgLTQxMSw3ICs0MTEsNyBAQCBzdGF0aWMgdm9pZCBxY29tX2lvbW11X2RldGFjaF9kZXYoc3Ry dWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCBzdHJ1Y3QgZGV2aWNlICpkZQogfQogCiBzdGF0aWMg aW50IHFjb21faW9tbXVfbWFwKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwgdW5zaWduZWQg bG9uZyBpb3ZhLAotCQkJICBwaHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90IHNpemUsIGludCBwcm90 KQorCQkJICBwaHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90IHNpemUsIGludCBwcm90LCBnZnBfdCBn ZnApCiB7CiAJaW50IHJldDsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwpkaWZmIC0tZ2l0IGEvZHJp dmVycy9pb21tdS9yb2NrY2hpcC1pb21tdS5jIGIvZHJpdmVycy9pb21tdS9yb2NrY2hpcC1pb21t dS5jCmluZGV4IDc3ZDRiZDkzZmU0Yi4uYWEzNTA3ZjM1MTA3IDEwMDY0NAotLS0gYS9kcml2ZXJz L2lvbW11L3JvY2tjaGlwLWlvbW11LmMKKysrIGIvZHJpdmVycy9pb21tdS9yb2NrY2hpcC1pb21t dS5jCkBAIC03NjAsNyArNzYwLDcgQEAgc3RhdGljIGludCBya19pb21tdV9tYXBfaW92YShzdHJ1 Y3QgcmtfaW9tbXVfZG9tYWluICpya19kb21haW4sIHUzMiAqcHRlX2FkZHIsCiB9CiAKIHN0YXRp YyBpbnQgcmtfaW9tbXVfbWFwKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwgdW5zaWduZWQg bG9uZyBfaW92YSwKLQkJCXBoeXNfYWRkcl90IHBhZGRyLCBzaXplX3Qgc2l6ZSwgaW50IHByb3Qp CisJCQlwaHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90IHNpemUsIGludCBwcm90LCBnZnBfdCBnZnAp CiB7CiAJc3RydWN0IHJrX2lvbW11X2RvbWFpbiAqcmtfZG9tYWluID0gdG9fcmtfZG9tYWluKGRv bWFpbik7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUv czM5MC1pb21tdS5jIGIvZHJpdmVycy9pb21tdS9zMzkwLWlvbW11LmMKaW5kZXggMjJkNGRiMzAy YzFjLi5lZmE2YWE2ODUyMWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW9tbXUvczM5MC1pb21tdS5j CisrKyBiL2RyaXZlcnMvaW9tbXUvczM5MC1pb21tdS5jCkBAIC0yNjUsNyArMjY1LDcgQEAgc3Rh dGljIGludCBzMzkwX2lvbW11X3VwZGF0ZV90cmFucyhzdHJ1Y3QgczM5MF9kb21haW4gKnMzOTBf ZG9tYWluLAogfQogCiBzdGF0aWMgaW50IHMzOTBfaW9tbXVfbWFwKHN0cnVjdCBpb21tdV9kb21h aW4gKmRvbWFpbiwgdW5zaWduZWQgbG9uZyBpb3ZhLAotCQkJICBwaHlzX2FkZHJfdCBwYWRkciwg c2l6ZV90IHNpemUsIGludCBwcm90KQorCQkJICBwaHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90IHNp emUsIGludCBwcm90LCBnZnBfdCBnZnApCiB7CiAJc3RydWN0IHMzOTBfZG9tYWluICpzMzkwX2Rv bWFpbiA9IHRvX3MzOTBfZG9tYWluKGRvbWFpbik7CiAJaW50IGZsYWdzID0gWlBDSV9QVEVfVkFM SUQsIHJjID0gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUvdGVncmEtZ2FydC5jIGIvZHJp dmVycy9pb21tdS90ZWdyYS1nYXJ0LmMKaW5kZXggNGQ4MDU3OTE2NTUyLi5mMzAwMDk5ODUyYjEg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW9tbXUvdGVncmEtZ2FydC5jCisrKyBiL2RyaXZlcnMvaW9t bXUvdGVncmEtZ2FydC5jCkBAIC0xOTAsNyArMTkwLDcgQEAgc3RhdGljIGlubGluZSBpbnQgX19n YXJ0X2lvbW11X21hcChzdHJ1Y3QgZ2FydF9kZXZpY2UgKmdhcnQsIHVuc2lnbmVkIGxvbmcgaW92 YSwKIH0KIAogc3RhdGljIGludCBnYXJ0X2lvbW11X21hcChzdHJ1Y3QgaW9tbXVfZG9tYWluICpk b21haW4sIHVuc2lnbmVkIGxvbmcgaW92YSwKLQkJCSAgcGh5c19hZGRyX3QgcGEsIHNpemVfdCBi eXRlcywgaW50IHByb3QpCisJCQkgIHBoeXNfYWRkcl90IHBhLCBzaXplX3QgYnl0ZXMsIGludCBw cm90LCBnZnBfdCBnZnApCiB7CiAJc3RydWN0IGdhcnRfZGV2aWNlICpnYXJ0ID0gZ2FydF9oYW5k bGU7CiAJaW50IHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW9tbXUvdGVncmEtc21tdS5jIGIv ZHJpdmVycy9pb21tdS90ZWdyYS1zbW11LmMKaW5kZXggNTE4MmM3ZDYxNzFlLi5lMWJmODY3ZTA2 MDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW9tbXUvdGVncmEtc21tdS5jCisrKyBiL2RyaXZlcnMv aW9tbXUvdGVncmEtc21tdS5jCkBAIC02NDEsNyArNjQxLDcgQEAgc3RhdGljIHZvaWQgdGVncmFf c21tdV9zZXRfcHRlKHN0cnVjdCB0ZWdyYV9zbW11X2FzICphcywgdW5zaWduZWQgbG9uZyBpb3Zh LAogfQogCiBzdGF0aWMgaW50IHRlZ3JhX3NtbXVfbWFwKHN0cnVjdCBpb21tdV9kb21haW4gKmRv bWFpbiwgdW5zaWduZWQgbG9uZyBpb3ZhLAotCQkJICBwaHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90 IHNpemUsIGludCBwcm90KQorCQkJICBwaHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90IHNpemUsIGlu dCBwcm90LCBnZnBfdCBnZnApCiB7CiAJc3RydWN0IHRlZ3JhX3NtbXVfYXMgKmFzID0gdG9fc21t dV9hcyhkb21haW4pOwogCWRtYV9hZGRyX3QgcHRlX2RtYTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUv bGludXgvaW9tbXUuaCBiL2luY2x1ZGUvbGludXgvaW9tbXUuaAppbmRleCBmZmJiYzdlMzljZWUu Ljc2YjhlN2ZlM2VkMCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9pb21tdS5oCisrKyBiL2lu Y2x1ZGUvbGludXgvaW9tbXUuaApAQCAtMTk4LDcgKzE5OCw3IEBAIHN0cnVjdCBpb21tdV9vcHMg ewogCWludCAoKmF0dGFjaF9kZXYpKHN0cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwgc3RydWN0 IGRldmljZSAqZGV2KTsKIAl2b2lkICgqZGV0YWNoX2Rldikoc3RydWN0IGlvbW11X2RvbWFpbiAq ZG9tYWluLCBzdHJ1Y3QgZGV2aWNlICpkZXYpOwogCWludCAoKm1hcCkoc3RydWN0IGlvbW11X2Rv bWFpbiAqZG9tYWluLCB1bnNpZ25lZCBsb25nIGlvdmEsCi0JCSAgIHBoeXNfYWRkcl90IHBhZGRy LCBzaXplX3Qgc2l6ZSwgaW50IHByb3QpOworCQkgICBwaHlzX2FkZHJfdCBwYWRkciwgc2l6ZV90 IHNpemUsIGludCBwcm90LCBnZnBfdCBnZnApOwogCXNpemVfdCAoKnVubWFwKShzdHJ1Y3QgaW9t bXVfZG9tYWluICpkb21haW4sIHVuc2lnbmVkIGxvbmcgaW92YSwKIAkJICAgICBzaXplX3Qgc2l6 ZSk7CiAJdm9pZCAoKmZsdXNoX2lvdGxiX2FsbCkoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWlu KTsKQEAgLTI5NSwxMiArMjk1LDE3IEBAIGV4dGVybiBzdHJ1Y3QgaW9tbXVfZG9tYWluICppb21t dV9nZXRfZG9tYWluX2Zvcl9kZXYoc3RydWN0IGRldmljZSAqZGV2KTsKIGV4dGVybiBzdHJ1Y3Qg aW9tbXVfZG9tYWluICppb21tdV9nZXRfZG1hX2RvbWFpbihzdHJ1Y3QgZGV2aWNlICpkZXYpOwog ZXh0ZXJuIGludCBpb21tdV9tYXAoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCB1bnNpZ25l ZCBsb25nIGlvdmEsCiAJCSAgICAgcGh5c19hZGRyX3QgcGFkZHIsIHNpemVfdCBzaXplLCBpbnQg cHJvdCk7CitleHRlcm4gaW50IGlvbW11X21hcF9hdG9taWMoc3RydWN0IGlvbW11X2RvbWFpbiAq ZG9tYWluLCB1bnNpZ25lZCBsb25nIGlvdmEsCisJCSAgICAgcGh5c19hZGRyX3QgcGFkZHIsIHNp emVfdCBzaXplLCBpbnQgcHJvdCk7CiBleHRlcm4gc2l6ZV90IGlvbW11X3VubWFwKHN0cnVjdCBp b21tdV9kb21haW4gKmRvbWFpbiwgdW5zaWduZWQgbG9uZyBpb3ZhLAogCQkJICBzaXplX3Qgc2l6 ZSk7CiBleHRlcm4gc2l6ZV90IGlvbW11X3VubWFwX2Zhc3Qoc3RydWN0IGlvbW11X2RvbWFpbiAq ZG9tYWluLAogCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgaW92YSwgc2l6ZV90IHNpemUpOwogZXh0 ZXJuIHNpemVfdCBpb21tdV9tYXBfc2coc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCB1bnNp Z25lZCBsb25nIGlvdmEsCiAJCQkgICBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLHVuc2lnbmVkIGlu dCBuZW50cywgaW50IHByb3QpOworZXh0ZXJuIHNpemVfdCBpb21tdV9tYXBfc2dfYXRvbWljKHN0 cnVjdCBpb21tdV9kb21haW4gKmRvbWFpbiwKKwkJCQkgIHVuc2lnbmVkIGxvbmcgaW92YSwgc3Ry dWN0IHNjYXR0ZXJsaXN0ICpzZywKKwkJCQkgIHVuc2lnbmVkIGludCBuZW50cywgaW50IHByb3Qp OwogZXh0ZXJuIHBoeXNfYWRkcl90IGlvbW11X2lvdmFfdG9fcGh5cyhzdHJ1Y3QgaW9tbXVfZG9t YWluICpkb21haW4sIGRtYV9hZGRyX3QgaW92YSk7CiBleHRlcm4gdm9pZCBpb21tdV9zZXRfZmF1 bHRfaGFuZGxlcihzdHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4sCiAJCQlpb21tdV9mYXVsdF9o YW5kbGVyX3QgaGFuZGxlciwgdm9pZCAqdG9rZW4pOwpAQCAtNDY5LDYgKzQ3NCwxMyBAQCBzdGF0 aWMgaW5saW5lIGludCBpb21tdV9tYXAoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLCB1bnNp Z25lZCBsb25nIGlvdmEsCiAJcmV0dXJuIC1FTk9ERVY7CiB9CiAKK3N0YXRpYyBpbmxpbmUgaW50 IGlvbW11X21hcF9hdG9taWMoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLAorCQkJCSAgIHVu c2lnbmVkIGxvbmcgaW92YSwgcGh5c19hZGRyX3QgcGFkZHIsCisJCQkJICAgc2l6ZV90IHNpemUs IGludCBwcm90KQoreworCXJldHVybiAtRU5PREVWOworfQorCiBzdGF0aWMgaW5saW5lIHNpemVf dCBpb21tdV91bm1hcChzdHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4sCiAJCQkJIHVuc2lnbmVk IGxvbmcgaW92YSwgc2l6ZV90IHNpemUpCiB7CkBAIC00ODgsNiArNTAwLDEzIEBAIHN0YXRpYyBp bmxpbmUgc2l6ZV90IGlvbW11X21hcF9zZyhzdHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4sCiAJ cmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBpbmxpbmUgc2l6ZV90IGlvbW11X21hcF9zZ19hdG9taWMo c3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluLAorCQkJCSAgdW5zaWduZWQgbG9uZyBpb3ZhLCBz dHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAorCQkJCSAgdW5zaWduZWQgaW50IG5lbnRzLCBpbnQgcHJv dCkKK3sKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIGlubGluZSB2b2lkIGlvbW11X2ZsdXNoX3Rs Yl9hbGwoc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluKQogewogfQotLSAKMi4xNy4xCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwppb21tdSBtYWlsaW5n IGxpc3QKaW9tbXVAbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51 eGZvdW5kYXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vaW9tbXU= 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.0 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,T_DKIMWL_WL_HIGH,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable 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 36E46C04AAB for ; Mon, 6 May 2019 18:53:27 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id E7C122087F for ; Mon, 6 May 2019 18:53:26 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=arista.com header.i=@arista.com header.b="ZCYFX8CM" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726554AbfEFSx0 (ORCPT ); Mon, 6 May 2019 14:53:26 -0400 Received: from mail-ed1-f66.google.com ([209.85.208.66]:34925 "EHLO mail-ed1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726723AbfEFSxC (ORCPT ); Mon, 6 May 2019 14:53:02 -0400 Received: by mail-ed1-f66.google.com with SMTP id p26so16340749edr.2 for ; Mon, 06 May 2019 11:52:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=arista.com; s=googlenew; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=s41GnUu90JCiEgrnABXG+bHWTAI6F4JjxNl1CN9ewHg=; b=ZCYFX8CMopu0SIhXQwEzYq94vbC0tugBW0Jq1jr2mB0mxyAOfM9CcDjnE/u/x0VbdQ yvzc/naFQP6CDngayfphMDk6XKWyXGVn9Qn/ZXmOWRj+7eEoL5gnKfYAGWXGYcpIdSLW L1sKseQD8+U6lFqPFKi3Fj4hyKHBc/HxYc22LCg1zPeQknewxnvZz1e+pywT+SawweII ig/0w4DQ5awP8ZutWDwJQ+1LOrbK1AUqBfY9MTjK9vQBHAT3zAXk7Lzotea+ntUW9QT6 i4yL4e/pdwVvqnV6okuHbZsGhRIClT75TQRKwGiex1gyjEry/SLsD0RS5vSGP4DgKcUp jIoQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=s41GnUu90JCiEgrnABXG+bHWTAI6F4JjxNl1CN9ewHg=; b=oTbHuhyNxqA6oIp/54XQzF2FKdymFWtRth08tdD31AGue0mdZAELr3sN/ubf4PFDO3 QGfS58JDcQic5tUFs48YJCEzHJSjrJaVZqi+2wuAANRiYFlyOWuaijqEUUA2kw7oCvp7 vE/wlnXw8ao4gex9rWDIJX81/Cog1LCw1VmGu8xGWgjoh7k8CF4GEjP+3sv6/Jelpsge Ln+muoQ0dg/Qu8pwaaskNLlXEALvFh3Nn9MWCgBsPmijLUsBwwfrB/hnshUzXPHCNpMC jo67GzqN9ntIwDys2CyUcil8aCi+NmzxsR2e2HxWg41ebTK3/nmDYWGS3PmaY2Lr7myX a5Mg== X-Gm-Message-State: APjAAAVl2lX+xqPlruE1+KALkz+dlP/CqVJ5c4ARTKO2lEije+wZL/7x SipJ4HzeyZ2h+nHlW46KmWRAlA== X-Google-Smtp-Source: APXvYqysGVOPiQ4VqcDPnY6E6NgzBjdzwU/bm/BJFhE4ocR0L7XSzehahLL9jlee5M6UcZb13zQ3tQ== X-Received: by 2002:a50:eb0b:: with SMTP id y11mr27753818edp.254.1557168778431; Mon, 06 May 2019 11:52:58 -0700 (PDT) Received: from localhost.localdomain ([2a02:8084:a0:bc00:d9d9:922a:828d:a50e]) by smtp.gmail.com with ESMTPSA id e35sm3361412eda.2.2019.05.06.11.52.56 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 06 May 2019 11:52:57 -0700 (PDT) From: Tom Murphy To: iommu@lists.linux-foundation.org Cc: murphyt7@tcd.ie, Tom Murphy , Joerg Roedel , Will Deacon , Robin Murphy , Marek Szyprowski , Kukjin Kim , Krzysztof Kozlowski , David Woodhouse , Andy Gross , David Brown , Matthias Brugger , Rob Clark , Heiko Stuebner , Gerald Schaefer , Thierry Reding , Jonathan Hunter , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-samsung-soc@vger.kernel.org, linux-arm-msm@vger.kernel.org, linux-mediatek@lists.infradead.org, linux-rockchip@lists.infradead.org, linux-s390@vger.kernel.org, linux-tegra@vger.kernel.org Subject: [PATCH v3 1/4] iommu: Add gfp parameter to iommu_ops::map Date: Mon, 6 May 2019 19:52:03 +0100 Message-Id: <20190506185207.31069-2-tmurphy@arista.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190506185207.31069-1-tmurphy@arista.com> References: <20190506185207.31069-1-tmurphy@arista.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit Sender: linux-arm-msm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org Message-ID: <20190506185203.7kiD0wHLUo-tObuBAYhll8fEOWiK1ynvUg5UmR06fdM@z> Add a gfp_t parameter to the iommu_ops::map function. Remove the needless locking in the AMD iommu driver. The iommu_ops::map function (or the iommu_map function which calls it) was always supposed to be sleepable (according to Joerg's comment in this thread: https://lore.kernel.org/patchwork/patch/977520/ ) and so should probably have had a "might_sleep()" since it was written. However currently the dma-iommu api can call iommu_map in an atomic context, which it shouldn't do. This doesn't cause any problems because any iommu driver which uses the dma-iommu api uses gfp_atomic in it's iommu_ops::map function. But doing this wastes the memory allocators atomic pools. We can remove the mutex lock from amd_iommu_map and amd_iommu_unmap. iommu_map doesn’t lock while mapping and so no two calls should touch the same iova range. The AMD driver already handles the page table page allocations without locks so we can safely remove the locks. Signed-off-by: Tom Murphy --- drivers/iommu/amd_iommu.c | 14 ++++------- drivers/iommu/arm-smmu-v3.c | 2 +- drivers/iommu/arm-smmu.c | 2 +- drivers/iommu/dma-iommu.c | 6 ++--- drivers/iommu/exynos-iommu.c | 2 +- drivers/iommu/intel-iommu.c | 2 +- drivers/iommu/iommu.c | 43 +++++++++++++++++++++++++++++----- drivers/iommu/ipmmu-vmsa.c | 2 +- drivers/iommu/msm_iommu.c | 2 +- drivers/iommu/mtk_iommu.c | 2 +- drivers/iommu/mtk_iommu_v1.c | 2 +- drivers/iommu/omap-iommu.c | 2 +- drivers/iommu/qcom_iommu.c | 2 +- drivers/iommu/rockchip-iommu.c | 2 +- drivers/iommu/s390-iommu.c | 2 +- drivers/iommu/tegra-gart.c | 2 +- drivers/iommu/tegra-smmu.c | 2 +- include/linux/iommu.h | 21 ++++++++++++++++- 18 files changed, 78 insertions(+), 34 deletions(-) diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c index ebd062522cf5..ea3a5dc61bb0 100644 --- a/drivers/iommu/amd_iommu.c +++ b/drivers/iommu/amd_iommu.c @@ -3092,7 +3092,8 @@ static int amd_iommu_attach_device(struct iommu_domain *dom, } static int amd_iommu_map(struct iommu_domain *dom, unsigned long iova, - phys_addr_t paddr, size_t page_size, int iommu_prot) + phys_addr_t paddr, size_t page_size, int iommu_prot, + gfp_t gfp) { struct protection_domain *domain = to_pdomain(dom); int prot = 0; @@ -3106,9 +3107,7 @@ static int amd_iommu_map(struct iommu_domain *dom, unsigned long iova, if (iommu_prot & IOMMU_WRITE) prot |= IOMMU_PROT_IW; - mutex_lock(&domain->api_lock); - ret = iommu_map_page(domain, iova, paddr, page_size, prot, GFP_KERNEL); - mutex_unlock(&domain->api_lock); + ret = iommu_map_page(domain, iova, paddr, page_size, prot, gfp); domain_flush_np_cache(domain, iova, page_size); @@ -3119,16 +3118,11 @@ static size_t amd_iommu_unmap(struct iommu_domain *dom, unsigned long iova, size_t page_size) { struct protection_domain *domain = to_pdomain(dom); - size_t unmap_size; if (domain->mode == PAGE_MODE_NONE) return 0; - mutex_lock(&domain->api_lock); - unmap_size = iommu_unmap_page(domain, iova, page_size); - mutex_unlock(&domain->api_lock); - - return unmap_size; + return iommu_unmap_page(domain, iova, page_size); } static phys_addr_t amd_iommu_iova_to_phys(struct iommu_domain *dom, diff --git a/drivers/iommu/arm-smmu-v3.c b/drivers/iommu/arm-smmu-v3.c index d3880010c6cf..e5c48089b49f 100644 --- a/drivers/iommu/arm-smmu-v3.c +++ b/drivers/iommu/arm-smmu-v3.c @@ -1777,7 +1777,7 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) } static int arm_smmu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot) + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c index 045d93884164..2d50db55b788 100644 --- a/drivers/iommu/arm-smmu.c +++ b/drivers/iommu/arm-smmu.c @@ -1286,7 +1286,7 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) } static int arm_smmu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot) + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; struct arm_smmu_device *smmu = to_smmu_domain(domain)->smmu; diff --git a/drivers/iommu/dma-iommu.c b/drivers/iommu/dma-iommu.c index fa5713a4f6f8..7a96c2c8f56b 100644 --- a/drivers/iommu/dma-iommu.c +++ b/drivers/iommu/dma-iommu.c @@ -440,7 +440,7 @@ static dma_addr_t __iommu_dma_map(struct device *dev, phys_addr_t phys, if (!iova) return DMA_MAPPING_ERROR; - if (iommu_map(domain, iova, phys - iova_off, size, prot)) { + if (iommu_map_atomic(domain, iova, phys - iova_off, size, prot)) { iommu_dma_free_iova(cookie, iova, size); return DMA_MAPPING_ERROR; } @@ -641,7 +641,7 @@ static void *iommu_dma_alloc_remap(struct device *dev, size_t size, arch_dma_prep_coherent(sg_page(sg), sg->length); } - if (iommu_map_sg(domain, iova, sgt.sgl, sgt.orig_nents, ioprot) + if (iommu_map_sg_atomic(domain, iova, sgt.sgl, sgt.orig_nents, ioprot) < size) goto out_free_sg; @@ -1003,7 +1003,7 @@ static int iommu_dma_map_sg(struct device *dev, struct scatterlist *sg, * We'll leave any physical concatenation to the IOMMU driver's * implementation - it knows better than we do. */ - if (iommu_map_sg(domain, iova, sg, nents, prot) < iova_len) + if (iommu_map_sg_atomic(domain, iova, sg, nents, prot) < iova_len) goto out_free_iova; return __finalise_sg(dev, sg, nents, iova); diff --git a/drivers/iommu/exynos-iommu.c b/drivers/iommu/exynos-iommu.c index 05c6bc099d62..46414234c179 100644 --- a/drivers/iommu/exynos-iommu.c +++ b/drivers/iommu/exynos-iommu.c @@ -1078,7 +1078,7 @@ static int lv2set_page(sysmmu_pte_t *pent, phys_addr_t paddr, size_t size, */ static int exynos_iommu_map(struct iommu_domain *iommu_domain, unsigned long l_iova, phys_addr_t paddr, size_t size, - int prot) + int prot, gfp_t gfp) { struct exynos_iommu_domain *domain = to_exynos_domain(iommu_domain); sysmmu_pte_t *entry; diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c index 28cb713d728c..4f0ff28f7cb9 100644 --- a/drivers/iommu/intel-iommu.c +++ b/drivers/iommu/intel-iommu.c @@ -5137,7 +5137,7 @@ static void intel_iommu_detach_device(struct iommu_domain *domain, static int intel_iommu_map(struct iommu_domain *domain, unsigned long iova, phys_addr_t hpa, - size_t size, int iommu_prot) + size_t size, int iommu_prot, gfp_t gfp) { struct dmar_domain *dmar_domain = to_dmar_domain(domain); u64 max_addr; diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c index 109de67d5d72..1b49841c177e 100644 --- a/drivers/iommu/iommu.c +++ b/drivers/iommu/iommu.c @@ -1584,8 +1584,8 @@ static size_t iommu_pgsize(struct iommu_domain *domain, return pgsize; } -int iommu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot) +int __iommu_map(struct iommu_domain *domain, unsigned long iova, + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { const struct iommu_ops *ops = domain->ops; unsigned long orig_iova = iova; @@ -1622,8 +1622,8 @@ int iommu_map(struct iommu_domain *domain, unsigned long iova, pr_debug("mapping: iova 0x%lx pa %pa pgsize 0x%zx\n", iova, &paddr, pgsize); + ret = ops->map(domain, iova, paddr, pgsize, prot, gfp); - ret = ops->map(domain, iova, paddr, pgsize, prot); if (ret) break; @@ -1643,8 +1643,22 @@ int iommu_map(struct iommu_domain *domain, unsigned long iova, return ret; } + +int iommu_map(struct iommu_domain *domain, unsigned long iova, + phys_addr_t paddr, size_t size, int prot) +{ + might_sleep(); + return __iommu_map(domain, iova, paddr, size, prot, GFP_KERNEL); +} EXPORT_SYMBOL_GPL(iommu_map); +int iommu_map_atomic(struct iommu_domain *domain, unsigned long iova, + phys_addr_t paddr, size_t size, int prot) +{ + return __iommu_map(domain, iova, paddr, size, prot, GFP_ATOMIC); +} +EXPORT_SYMBOL_GPL(iommu_map_atomic); + static size_t __iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size, bool sync) @@ -1719,8 +1733,9 @@ size_t iommu_unmap_fast(struct iommu_domain *domain, } EXPORT_SYMBOL_GPL(iommu_unmap_fast); -size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova, - struct scatterlist *sg, unsigned int nents, int prot) +size_t __iommu_map_sg(struct iommu_domain *domain, unsigned long iova, + struct scatterlist *sg, unsigned int nents, int prot, + gfp_t gfp) { size_t len = 0, mapped = 0; phys_addr_t start; @@ -1731,7 +1746,9 @@ size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova, phys_addr_t s_phys = sg_phys(sg); if (len && s_phys != start + len) { - ret = iommu_map(domain, iova + mapped, start, len, prot); + ret = __iommu_map(domain, iova + mapped, start, + len, prot, gfp); + if (ret) goto out_err; @@ -1759,8 +1776,22 @@ size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova, return 0; } + +size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova, + struct scatterlist *sg, unsigned int nents, int prot) +{ + might_sleep(); + return __iommu_map_sg(domain, iova, sg, nents, prot, GFP_KERNEL); +} EXPORT_SYMBOL_GPL(iommu_map_sg); +size_t iommu_map_sg_atomic(struct iommu_domain *domain, unsigned long iova, + struct scatterlist *sg, unsigned int nents, int prot) +{ + return __iommu_map_sg(domain, iova, sg, nents, prot, GFP_ATOMIC); +} +EXPORT_SYMBOL_GPL(iommu_map_sg_atomic); + int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr, phys_addr_t paddr, u64 size, int prot) { diff --git a/drivers/iommu/ipmmu-vmsa.c b/drivers/iommu/ipmmu-vmsa.c index 9a380c10655e..e005c83d49d8 100644 --- a/drivers/iommu/ipmmu-vmsa.c +++ b/drivers/iommu/ipmmu-vmsa.c @@ -707,7 +707,7 @@ static void ipmmu_detach_device(struct iommu_domain *io_domain, } static int ipmmu_map(struct iommu_domain *io_domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot) + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { struct ipmmu_vmsa_domain *domain = to_vmsa_domain(io_domain); diff --git a/drivers/iommu/msm_iommu.c b/drivers/iommu/msm_iommu.c index 9fb0eb7a4d02..3f6bf3653aa2 100644 --- a/drivers/iommu/msm_iommu.c +++ b/drivers/iommu/msm_iommu.c @@ -508,7 +508,7 @@ static void msm_iommu_detach_dev(struct iommu_domain *domain, } static int msm_iommu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t pa, size_t len, int prot) + phys_addr_t pa, size_t len, int prot, gfp_t gfp) { struct msm_priv *priv = to_msm_priv(domain); unsigned long flags; diff --git a/drivers/iommu/mtk_iommu.c b/drivers/iommu/mtk_iommu.c index de3e02277b70..3176b9b54d4d 100644 --- a/drivers/iommu/mtk_iommu.c +++ b/drivers/iommu/mtk_iommu.c @@ -364,7 +364,7 @@ static void mtk_iommu_detach_device(struct iommu_domain *domain, } static int mtk_iommu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot) + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { struct mtk_iommu_domain *dom = to_mtk_domain(domain); unsigned long flags; diff --git a/drivers/iommu/mtk_iommu_v1.c b/drivers/iommu/mtk_iommu_v1.c index 52b01e3a49df..e7b1907faec1 100644 --- a/drivers/iommu/mtk_iommu_v1.c +++ b/drivers/iommu/mtk_iommu_v1.c @@ -303,7 +303,7 @@ static void mtk_iommu_detach_device(struct iommu_domain *domain, } static int mtk_iommu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot) + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { struct mtk_iommu_domain *dom = to_mtk_domain(domain); unsigned int page_num = size >> MT2701_IOMMU_PAGE_SHIFT; diff --git a/drivers/iommu/omap-iommu.c b/drivers/iommu/omap-iommu.c index d2fb347aa4ff..c1d5a71285dc 100644 --- a/drivers/iommu/omap-iommu.c +++ b/drivers/iommu/omap-iommu.c @@ -1109,7 +1109,7 @@ static u32 iotlb_init_entry(struct iotlb_entry *e, u32 da, u32 pa, int pgsz) } static int omap_iommu_map(struct iommu_domain *domain, unsigned long da, - phys_addr_t pa, size_t bytes, int prot) + phys_addr_t pa, size_t bytes, int prot, gfp_t gfp) { struct omap_iommu_domain *omap_domain = to_omap_domain(domain); struct device *dev = omap_domain->dev; diff --git a/drivers/iommu/qcom_iommu.c b/drivers/iommu/qcom_iommu.c index 8cdd3f059513..a01e07a4e76f 100644 --- a/drivers/iommu/qcom_iommu.c +++ b/drivers/iommu/qcom_iommu.c @@ -411,7 +411,7 @@ static void qcom_iommu_detach_dev(struct iommu_domain *domain, struct device *de } static int qcom_iommu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot) + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { int ret; unsigned long flags; diff --git a/drivers/iommu/rockchip-iommu.c b/drivers/iommu/rockchip-iommu.c index 77d4bd93fe4b..aa3507f35107 100644 --- a/drivers/iommu/rockchip-iommu.c +++ b/drivers/iommu/rockchip-iommu.c @@ -760,7 +760,7 @@ static int rk_iommu_map_iova(struct rk_iommu_domain *rk_domain, u32 *pte_addr, } static int rk_iommu_map(struct iommu_domain *domain, unsigned long _iova, - phys_addr_t paddr, size_t size, int prot) + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { struct rk_iommu_domain *rk_domain = to_rk_domain(domain); unsigned long flags; diff --git a/drivers/iommu/s390-iommu.c b/drivers/iommu/s390-iommu.c index 22d4db302c1c..efa6aa68521d 100644 --- a/drivers/iommu/s390-iommu.c +++ b/drivers/iommu/s390-iommu.c @@ -265,7 +265,7 @@ static int s390_iommu_update_trans(struct s390_domain *s390_domain, } static int s390_iommu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot) + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { struct s390_domain *s390_domain = to_s390_domain(domain); int flags = ZPCI_PTE_VALID, rc = 0; diff --git a/drivers/iommu/tegra-gart.c b/drivers/iommu/tegra-gart.c index 4d8057916552..f300099852b1 100644 --- a/drivers/iommu/tegra-gart.c +++ b/drivers/iommu/tegra-gart.c @@ -190,7 +190,7 @@ static inline int __gart_iommu_map(struct gart_device *gart, unsigned long iova, } static int gart_iommu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t pa, size_t bytes, int prot) + phys_addr_t pa, size_t bytes, int prot, gfp_t gfp) { struct gart_device *gart = gart_handle; int ret; diff --git a/drivers/iommu/tegra-smmu.c b/drivers/iommu/tegra-smmu.c index 5182c7d6171e..e1bf867e0607 100644 --- a/drivers/iommu/tegra-smmu.c +++ b/drivers/iommu/tegra-smmu.c @@ -641,7 +641,7 @@ static void tegra_smmu_set_pte(struct tegra_smmu_as *as, unsigned long iova, } static int tegra_smmu_map(struct iommu_domain *domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot) + phys_addr_t paddr, size_t size, int prot, gfp_t gfp) { struct tegra_smmu_as *as = to_smmu_as(domain); dma_addr_t pte_dma; diff --git a/include/linux/iommu.h b/include/linux/iommu.h index ffbbc7e39cee..76b8e7fe3ed0 100644 --- a/include/linux/iommu.h +++ b/include/linux/iommu.h @@ -198,7 +198,7 @@ struct iommu_ops { int (*attach_dev)(struct iommu_domain *domain, struct device *dev); void (*detach_dev)(struct iommu_domain *domain, struct device *dev); int (*map)(struct iommu_domain *domain, unsigned long iova, - phys_addr_t paddr, size_t size, int prot); + phys_addr_t paddr, size_t size, int prot, gfp_t gfp); size_t (*unmap)(struct iommu_domain *domain, unsigned long iova, size_t size); void (*flush_iotlb_all)(struct iommu_domain *domain); @@ -295,12 +295,17 @@ extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev); extern struct iommu_domain *iommu_get_dma_domain(struct device *dev); extern int iommu_map(struct iommu_domain *domain, unsigned long iova, phys_addr_t paddr, size_t size, int prot); +extern int iommu_map_atomic(struct iommu_domain *domain, unsigned long iova, + phys_addr_t paddr, size_t size, int prot); extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size); extern size_t iommu_unmap_fast(struct iommu_domain *domain, unsigned long iova, size_t size); extern size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova, struct scatterlist *sg,unsigned int nents, int prot); +extern size_t iommu_map_sg_atomic(struct iommu_domain *domain, + unsigned long iova, struct scatterlist *sg, + unsigned int nents, int prot); extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova); extern void iommu_set_fault_handler(struct iommu_domain *domain, iommu_fault_handler_t handler, void *token); @@ -469,6 +474,13 @@ static inline int iommu_map(struct iommu_domain *domain, unsigned long iova, return -ENODEV; } +static inline int iommu_map_atomic(struct iommu_domain *domain, + unsigned long iova, phys_addr_t paddr, + size_t size, int prot) +{ + return -ENODEV; +} + static inline size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size) { @@ -488,6 +500,13 @@ static inline size_t iommu_map_sg(struct iommu_domain *domain, return 0; } +static inline size_t iommu_map_sg_atomic(struct iommu_domain *domain, + unsigned long iova, struct scatterlist *sg, + unsigned int nents, int prot) +{ + return 0; +} + static inline void iommu_flush_tlb_all(struct iommu_domain *domain) { } -- 2.17.1