From mboxrd@z Thu Jan 1 00:00:00 1970 From: "=?UTF-8?q?Christian=20K=C3=B6nig?=" Subject: [PATCH 03/12] dma-buf: lock the reservation object during (un)map_dma_buf v3 Date: Tue, 16 Apr 2019 20:38:32 +0200 Message-ID: <20190416183841.1577-4-christian.koenig@amd.com> References: <20190416183841.1577-1-christian.koenig@amd.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190416183841.1577-1-christian.koenig@amd.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: sumit.semwal@linaro.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org, amd-gfx@lists.freedesktop.org List-Id: amd-gfx.lists.freedesktop.org TWFrZSBpdCBtYW5kYXRvcnkgZm9yIGR5bmFtaWMgZG1hLWJ1ZiBjYWxsYmFja3MgdG8gYmUgY2Fs bGVkIHdpdGggdGhlCnJlc2VydmF0aW9uIGxvY2sgaGVsZC4KCkZvciBzdGF0aWMgZG1hLWJ1ZiBl eHBvcnRlcnMgd2Ugc3RpbGwgaGF2ZSB0aGUgZmFsbGJhY2sgb2YgdXNpbmcgY2FjaGVkIHNndC4K CnYyOiByZW9yZGVyZWQKdjM6IHJlYmFzZWQgb24gc2d0IGNhY2hpbmcKdjQ6IHVzZSB0aGUgY2Fj aGVkIHNndCB3aGVuIHBvc3NpYmxlCgpTaWduZWQtb2ZmLWJ5OiBDaHJpc3RpYW4gS8O2bmlnIDxj aHJpc3RpYW4ua29lbmlnQGFtZC5jb20+Ci0tLQogZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYyAg ICAgICAgICAgICAgICAgICAgIHwgMjQgKysrKysrKysrKy0tLS0tLS0tLQogZHJpdmVycy9ncHUv ZHJtL2FybWFkYS9hcm1hZGFfZ2VtLmMgICAgICAgICAgIHwgIDYgKysrKy0KIGRyaXZlcnMvZ3B1 L2RybS9kcm1fcHJpbWUuYyAgICAgICAgICAgICAgICAgICB8ICA2ICsrKystCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYyAgICAgICAgfCAgNiArKysrLQogZHJpdmVycy9n cHUvZHJtL3RlZ3JhL2dlbS5jICAgICAgICAgICAgICAgICAgIHwgIDYgKysrKy0KIGRyaXZlcnMv Z3B1L2RybS91ZGwvdWRsX2RtYWJ1Zi5jICAgICAgICAgICAgICB8ICA2ICsrKystCiAuLi4vY29t bW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRpZy5jICAgfCAgNiArKysrLQogLi4uL21l ZGlhL2NvbW1vbi92aWRlb2J1ZjIvdmlkZW9idWYyLWRtYS1zZy5jIHwgIDYgKysrKy0KIGRyaXZl cnMvc3RhZ2luZy9tZWRpYS90ZWdyYS12ZGUvdGVncmEtdmRlLmMgICB8ICA2ICsrKystCiBpbmNs dWRlL2xpbnV4L2RtYS1idWYuaCAgICAgICAgICAgICAgICAgICAgICAgfCAyMyArKysrKysrKysr KysrKysrLS0KIDEwIGZpbGVzIGNoYW5nZWQsIDc0IGluc2VydGlvbnMoKyksIDIxIGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVmLmMgYi9kcml2ZXJzL2Rt YS1idWYvZG1hLWJ1Zi5jCmluZGV4IGVmNDgwZTVmYjIzOS4uODNjOTJiZmQ5NjRjIDEwMDY0NAot LS0gYS9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jCisrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEt YnVmLmMKQEAgLTUzMiw4ICs1MzIsOSBAQCBFWFBPUlRfU1lNQk9MX0dQTChkbWFfYnVmX3B1dCk7 CiAvKioKICAqIGRtYV9idWZfYXR0YWNoIC0gQWRkIHRoZSBkZXZpY2UgdG8gZG1hX2J1ZidzIGF0 dGFjaG1lbnRzIGxpc3Q7IG9wdGlvbmFsbHksCiAgKiBjYWxscyBhdHRhY2goKSBvZiBkbWFfYnVm X29wcyB0byBhbGxvdyBkZXZpY2Utc3BlY2lmaWMgYXR0YWNoIGZ1bmN0aW9uYWxpdHkKLSAqIEBk bWFidWY6CVtpbl0JYnVmZmVyIHRvIGF0dGFjaCBkZXZpY2UgdG8uCi0gKiBAZGV2OglbaW5dCWRl dmljZSB0byBiZSBhdHRhY2hlZC4KKyAqIEBpbmZvOglbaW5dCWhvbGRzIGFsbCB0aGUgYXR0YWNo IHJlbGF0ZWQgaW5mb3JtYXRpb24gcHJvdmlkZWQKKyAqCQkJYnkgdGhlIGltcG9ydGVyLiBzZWUg JnN0cnVjdCBkbWFfYnVmX2F0dGFjaF9pbmZvCisgKgkJCWZvciBmdXJ0aGVyIGRldGFpbHMuCiAg KgogICogUmV0dXJucyBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50IHBvaW50ZXIgZm9yIHRoaXMg YXR0YWNobWVudC4gQXR0YWNobWVudHMKICAqIG11c3QgYmUgY2xlYW5lZCB1cCBieSBjYWxsaW5n IGRtYV9idWZfZGV0YWNoKCkuCkBAIC01NDcsMjAgKzU0OCwyMCBAQCBFWFBPUlRfU1lNQk9MX0dQ TChkbWFfYnVmX3B1dCk7CiAgKiBhY2Nlc3NpYmxlIHRvIEBkZXYsIGFuZCBjYW5ub3QgYmUgbW92 ZWQgdG8gYSBtb3JlIHN1aXRhYmxlIHBsYWNlLiBUaGlzIGlzCiAgKiBpbmRpY2F0ZWQgd2l0aCB0 aGUgZXJyb3IgY29kZSAtRUJVU1kuCiAgKi8KLXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmRt YV9idWZfYXR0YWNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCi0JCQkJCSAgc3RydWN0IGRldmlj ZSAqZGV2KQorc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqZG1hX2J1Zl9hdHRhY2goY29uc3Qg c3RydWN0IGRtYV9idWZfYXR0YWNoX2luZm8gKmluZm8pCiB7CisJc3RydWN0IGRtYV9idWYgKmRt YWJ1ZiA9IGluZm8tPmRtYWJ1ZjsKIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2g7 CiAJaW50IHJldDsKIAotCWlmIChXQVJOX09OKCFkbWFidWYgfHwgIWRldikpCisJaWYgKFdBUk5f T04oIWRtYWJ1ZiB8fCAhaW5mby0+ZGV2KSkKIAkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CiAK IAlhdHRhY2ggPSBremFsbG9jKHNpemVvZigqYXR0YWNoKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFh dHRhY2gpCiAJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwogCi0JYXR0YWNoLT5kZXYgPSBkZXY7 CisJYXR0YWNoLT5kZXYgPSBpbmZvLT5kZXY7CiAJYXR0YWNoLT5kbWFidWYgPSBkbWFidWY7CiAK IAltdXRleF9sb2NrKCZkbWFidWYtPmxvY2spOwpAQCAtNjg4LDkgKzY4OSw5IEBAIHN0cnVjdCBz Z190YWJsZSAqZG1hX2J1Zl9tYXBfYXR0YWNobWVudChzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50 ICphdHRhY2gsCiAJaWYgKGF0dGFjaC0+c2d0KQogCQlyZXR1cm4gYXR0YWNoLT5zZ3Q7CiAKLQlz Z190YWJsZSA9IGF0dGFjaC0+ZG1hYnVmLT5vcHMtPm1hcF9kbWFfYnVmKGF0dGFjaCwgZGlyZWN0 aW9uKTsKLQlpZiAoIXNnX3RhYmxlKQotCQlzZ190YWJsZSA9IEVSUl9QVFIoLUVOT01FTSk7CisJ cmVzZXJ2YXRpb25fb2JqZWN0X2xvY2soYXR0YWNoLT5kbWFidWYtPnJlc3YsIE5VTEwpOworCXNn X3RhYmxlID0gZG1hX2J1Zl9tYXBfYXR0YWNobWVudF9sb2NrZWQoYXR0YWNoLCBkaXJlY3Rpb24p OworCXJlc2VydmF0aW9uX29iamVjdF91bmxvY2soYXR0YWNoLT5kbWFidWYtPnJlc3YpOwogCiAJ cmV0dXJuIHNnX3RhYmxlOwogfQpAQCAtNzQ0LDggKzc0NSw5IEBAIHZvaWQgZG1hX2J1Zl91bm1h cF9hdHRhY2htZW50KHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCwKIAlpZiAoYXR0 YWNoLT5zZ3QgPT0gc2dfdGFibGUpCiAJCXJldHVybjsKIAotCWF0dGFjaC0+ZG1hYnVmLT5vcHMt PnVubWFwX2RtYV9idWYoYXR0YWNoLCBzZ190YWJsZSwKLQkJCQkJCWRpcmVjdGlvbik7CisJcmVz ZXJ2YXRpb25fb2JqZWN0X2xvY2soYXR0YWNoLT5kbWFidWYtPnJlc3YsIE5VTEwpOworCWRtYV9i dWZfdW5tYXBfYXR0YWNobWVudF9sb2NrZWQoYXR0YWNoLCBzZ190YWJsZSwgZGlyZWN0aW9uKTsK KwlyZXNlcnZhdGlvbl9vYmplY3RfdW5sb2NrKGF0dGFjaC0+ZG1hYnVmLT5yZXN2KTsKIH0KIEVY UE9SVF9TWU1CT0xfR1BMKGRtYV9idWZfdW5tYXBfYXR0YWNobWVudCk7CiAKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJtYWRhX2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL2Fy bWFkYS9hcm1hZGFfZ2VtLmMKaW5kZXggNjQyZDBlNzBkMGY4Li4xOWM0NzgyMTAzMmYgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hcm1hZGEvYXJtYWRhX2dlbS5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9hcm1hZGEvYXJtYWRhX2dlbS5jCkBAIC01MDEsNiArNTAxLDEwIEBAIGFybWFkYV9n ZW1fcHJpbWVfZXhwb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fZ2VtX29i amVjdCAqb2JqLAogc3RydWN0IGRybV9nZW1fb2JqZWN0ICoKIGFybWFkYV9nZW1fcHJpbWVfaW1w b3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkbWFfYnVmICpidWYpCiB7CisJc3Ry dWN0IGRtYV9idWZfYXR0YWNoX2luZm8gYXR0YWNoX2luZm8gPSB7CisJCS5kZXYgPSBkZXYtPmRl diwKKwkJLmRtYWJ1ZiA9IGJ1ZgorCX07CiAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0 YWNoOwogCXN0cnVjdCBhcm1hZGFfZ2VtX29iamVjdCAqZG9iajsKIApAQCAtNTE2LDcgKzUyMCw3 IEBAIGFybWFkYV9nZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVj dCBkbWFfYnVmICpidWYpCiAJCX0KIAl9CiAKLQlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChidWYs IGRldi0+ZGV2KTsKKwlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaCgmYXR0YWNoX2luZm8pOwogCWlm IChJU19FUlIoYXR0YWNoKSkKIAkJcmV0dXJuIEVSUl9DQVNUKGF0dGFjaCk7CiAKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJp bWUuYwppbmRleCAyMzFlM2Y2ZDVmNDEuLjFmYWRmNWQ1ZWQzMyAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2RybV9wcmltZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fcHJpbWUuYwpA QCAtNzA5LDYgKzcwOSwxMCBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmRybV9nZW1fcHJpbWVf aW1wb3J0X2RldihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCQkJCQkgICAgc3RydWN0IGRtYV9i dWYgKmRtYV9idWYsCiAJCQkJCSAgICBzdHJ1Y3QgZGV2aWNlICphdHRhY2hfZGV2KQogeworCXN0 cnVjdCBkbWFfYnVmX2F0dGFjaF9pbmZvIGF0dGFjaF9pbmZvID0geworCQkuZGV2ID0gYXR0YWNo X2RldiwKKwkJLmRtYWJ1ZiA9IGRtYV9idWYKKwl9OwogCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1l bnQgKmF0dGFjaDsKIAlzdHJ1Y3Qgc2dfdGFibGUgKnNndDsKIAlzdHJ1Y3QgZHJtX2dlbV9vYmpl Y3QgKm9iajsKQEAgLTcyOSw3ICs3MzMsNyBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmRybV9n ZW1fcHJpbWVfaW1wb3J0X2RldihzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCWlmICghZGV2LT5k cml2ZXItPmdlbV9wcmltZV9pbXBvcnRfc2dfdGFibGUpCiAJCXJldHVybiBFUlJfUFRSKC1FSU5W QUwpOwogCi0JYXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goZG1hX2J1ZiwgYXR0YWNoX2Rldik7CisJ YXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goJmF0dGFjaF9pbmZvKTsKIAlpZiAoSVNfRVJSKGF0dGFj aCkpCiAJCXJldHVybiBFUlJfQ0FTVChhdHRhY2gpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVf Z2VtX2RtYWJ1Zi5jCmluZGV4IDgyZTJjYTE3YTQ0MS4uYWE3ZjY4NWJkNmNhIDEwMDY0NAotLS0g YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYworKysgYi9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pOTE1X2dlbV9kbWFidWYuYwpAQCAtMjc3LDYgKzI3NywxMCBAQCBzdGF0aWMg Y29uc3Qgc3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3Rfb3BzIGk5MTVfZ2VtX29iamVjdF9kbWFi dWZfb3BzID0gewogc3RydWN0IGRybV9nZW1fb2JqZWN0ICppOTE1X2dlbV9wcmltZV9pbXBvcnQo c3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAkJCQkJICAgICBzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1 ZikKIHsKKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyBhdHRhY2hfaW5mbyA9IHsKKwkJLmRl diA9IGRldi0+ZGV2LAorCQkuZG1hYnVmID0gZG1hX2J1ZgorCX07CiAJc3RydWN0IGRtYV9idWZf YXR0YWNobWVudCAqYXR0YWNoOwogCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmo7CiAJ aW50IHJldDsKQEAgLTI5NSw3ICsyOTksNyBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmk5MTVf Z2VtX3ByaW1lX2ltcG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCX0KIAogCS8qIG5lZWQg dG8gYXR0YWNoICovCi0JYXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goZG1hX2J1ZiwgZGV2LT5kZXYp OworCWF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7CiAJaWYgKElTX0VSUihh dHRhY2gpKQogCQlyZXR1cm4gRVJSX0NBU1QoYXR0YWNoKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL3RlZ3JhL2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2dlbS5jCmluZGV4 IDRmODAxMDBmZjVmMy4uOGU2YjZjODc5YWRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v dGVncmEvZ2VtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2dlbS5jCkBAIC0zMzIsNiAr MzMyLDEwIEBAIHN0cnVjdCB0ZWdyYV9ibyAqdGVncmFfYm9fY3JlYXRlX3dpdGhfaGFuZGxlKHN0 cnVjdCBkcm1fZmlsZSAqZmlsZSwKIHN0YXRpYyBzdHJ1Y3QgdGVncmFfYm8gKnRlZ3JhX2JvX2lt cG9ydChzdHJ1Y3QgZHJtX2RldmljZSAqZHJtLAogCQkJCQlzdHJ1Y3QgZG1hX2J1ZiAqYnVmKQog eworCXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9pbmZvIGF0dGFjaF9pbmZvID0geworCQkuZGV2ID0g ZHJtLT5kZXYsCisJCS5kbWFidWYgPSBidWYKKwl9OwogCXN0cnVjdCB0ZWdyYV9kcm0gKnRlZ3Jh ID0gZHJtLT5kZXZfcHJpdmF0ZTsKIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2g7 CiAJc3RydWN0IHRlZ3JhX2JvICpibzsKQEAgLTM0MSw3ICszNDUsNyBAQCBzdGF0aWMgc3RydWN0 IHRlZ3JhX2JvICp0ZWdyYV9ib19pbXBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRybSwKIAlpZiAo SVNfRVJSKGJvKSkKIAkJcmV0dXJuIGJvOwogCi0JYXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goYnVm LCBkcm0tPmRldik7CisJYXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goJmF0dGFjaF9pbmZvKTsKIAlp ZiAoSVNfRVJSKGF0dGFjaCkpIHsKIAkJZXJyID0gUFRSX0VSUihhdHRhY2gpOwogCQlnb3RvIGZy ZWU7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kbWFidWYuYyBiL2RyaXZl cnMvZ3B1L2RybS91ZGwvdWRsX2RtYWJ1Zi5jCmluZGV4IDU1NmY2MjY2MmFhOS4uODZiOTI4Zjk3 NDJmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kbWFidWYuYworKysgYi9k cml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kbWFidWYuYwpAQCAtMjI2LDYgKzIyNiwxMCBAQCBzdGF0 aWMgaW50IHVkbF9wcmltZV9jcmVhdGUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIHN0cnVjdCBk cm1fZ2VtX29iamVjdCAqdWRsX2dlbV9wcmltZV9pbXBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRl diwKIAkJCQlzdHJ1Y3QgZG1hX2J1ZiAqZG1hX2J1ZikKIHsKKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRh Y2hfaW5mbyBhdHRhY2hfaW5mbyA9IHsKKwkJLmRldiA9IGRldi0+ZGV2LAorCQkuZG1hYnVmID0g ZG1hX2J1ZgorCX07CiAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOwogCXN0cnVj dCBzZ190YWJsZSAqc2c7CiAJc3RydWN0IHVkbF9nZW1fb2JqZWN0ICp1b2JqOwpAQCAtMjMzLDcg KzIzNyw3IEBAIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqdWRsX2dlbV9wcmltZV9pbXBvcnQoc3Ry dWN0IGRybV9kZXZpY2UgKmRldiwKIAogCS8qIG5lZWQgdG8gYXR0YWNoICovCiAJZ2V0X2Rldmlj ZShkZXYtPmRldik7Ci0JYXR0YWNoID0gZG1hX2J1Zl9hdHRhY2goZG1hX2J1ZiwgZGV2LT5kZXYp OworCWF0dGFjaCA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7CiAJaWYgKElTX0VSUihh dHRhY2gpKSB7CiAJCXB1dF9kZXZpY2UoZGV2LT5kZXYpOwogCQlyZXR1cm4gRVJSX0NBU1QoYXR0 YWNoKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1 ZjItZG1hLWNvbnRpZy5jIGIvZHJpdmVycy9tZWRpYS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVm Mi1kbWEtY29udGlnLmMKaW5kZXggYWZmMGFiN2JmODNkLi4xZjI2ODdiNWViMGUgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvbWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRpZy5j CisrKyBiL2RyaXZlcnMvbWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLWNvbnRp Zy5jCkBAIC02NzYsNiArNjc2LDEwIEBAIHN0YXRpYyB2b2lkIHZiMl9kY19kZXRhY2hfZG1hYnVm KHZvaWQgKm1lbV9wcml2KQogc3RhdGljIHZvaWQgKnZiMl9kY19hdHRhY2hfZG1hYnVmKHN0cnVj dCBkZXZpY2UgKmRldiwgc3RydWN0IGRtYV9idWYgKmRidWYsCiAJdW5zaWduZWQgbG9uZyBzaXpl LCBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkbWFfZGlyKQogeworCXN0cnVjdCBkbWFfYnVmX2F0 dGFjaF9pbmZvIGF0dGFjaF9pbmZvID0geworCQkuZGV2ID0gZGV2LAorCQkuZG1hYnVmID0gZGJ1 ZgorCX07CiAJc3RydWN0IHZiMl9kY19idWYgKmJ1ZjsKIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2ht ZW50ICpkYmE7CiAKQEAgLTY5MSw3ICs2OTUsNyBAQCBzdGF0aWMgdm9pZCAqdmIyX2RjX2F0dGFj aF9kbWFidWYoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZG1hX2J1ZiAqZGJ1ZiwKIAogCWJ1 Zi0+ZGV2ID0gZGV2OwogCS8qIGNyZWF0ZSBhdHRhY2htZW50IGZvciB0aGUgZG1hYnVmIHdpdGgg dGhlIHVzZXIgZGV2aWNlICovCi0JZGJhID0gZG1hX2J1Zl9hdHRhY2goZGJ1ZiwgYnVmLT5kZXYp OworCWRiYSA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hfaW5mbyk7CiAJaWYgKElTX0VSUihkYmEp KSB7CiAJCXByX2VycigiZmFpbGVkIHRvIGF0dGFjaCBkbWFidWZcbiIpOwogCQlrZnJlZShidWYp OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1k bWEtc2cuYyBiL2RyaXZlcnMvbWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLXNn LmMKaW5kZXggMDE1ZTczNzA5NWNkLi5jYmQ2MjZkMjM5M2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv bWVkaWEvY29tbW9uL3ZpZGVvYnVmMi92aWRlb2J1ZjItZG1hLXNnLmMKKysrIGIvZHJpdmVycy9t ZWRpYS9jb21tb24vdmlkZW9idWYyL3ZpZGVvYnVmMi1kbWEtc2cuYwpAQCAtNjA4LDYgKzYwOCwx MCBAQCBzdGF0aWMgdm9pZCB2YjJfZG1hX3NnX2RldGFjaF9kbWFidWYodm9pZCAqbWVtX3ByaXYp CiBzdGF0aWMgdm9pZCAqdmIyX2RtYV9zZ19hdHRhY2hfZG1hYnVmKHN0cnVjdCBkZXZpY2UgKmRl diwgc3RydWN0IGRtYV9idWYgKmRidWYsCiAJdW5zaWduZWQgbG9uZyBzaXplLCBlbnVtIGRtYV9k YXRhX2RpcmVjdGlvbiBkbWFfZGlyKQogeworCXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9pbmZvIGF0 dGFjaF9pbmZvID0geworCQkuZGV2ID0gZGV2LAorCQkuZG1hYnVmID0gZGJ1ZgorCX07CiAJc3Ry dWN0IHZiMl9kbWFfc2dfYnVmICpidWY7CiAJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqZGJh OwogCkBAIC02MjMsNyArNjI3LDcgQEAgc3RhdGljIHZvaWQgKnZiMl9kbWFfc2dfYXR0YWNoX2Rt YWJ1ZihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkbWFfYnVmICpkYnVmLAogCiAJYnVmLT5k ZXYgPSBkZXY7CiAJLyogY3JlYXRlIGF0dGFjaG1lbnQgZm9yIHRoZSBkbWFidWYgd2l0aCB0aGUg dXNlciBkZXZpY2UgKi8KLQlkYmEgPSBkbWFfYnVmX2F0dGFjaChkYnVmLCBidWYtPmRldik7CisJ ZGJhID0gZG1hX2J1Zl9hdHRhY2goJmF0dGFjaF9pbmZvKTsKIAlpZiAoSVNfRVJSKGRiYSkpIHsK IAkJcHJfZXJyKCJmYWlsZWQgdG8gYXR0YWNoIGRtYWJ1ZlxuIik7CiAJCWtmcmVlKGJ1Zik7CmRp ZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvbWVkaWEvdGVncmEtdmRlL3RlZ3JhLXZkZS5jIGIv ZHJpdmVycy9zdGFnaW5nL21lZGlhL3RlZ3JhLXZkZS90ZWdyYS12ZGUuYwppbmRleCBhYTZjNmJi YTk2MWUuLjVhMTBjMWZhY2MyNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL21lZGlhL3Rl Z3JhLXZkZS90ZWdyYS12ZGUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvbWVkaWEvdGVncmEtdmRl L3RlZ3JhLXZkZS5jCkBAIC01NjgsNiArNTY4LDEwIEBAIHN0YXRpYyBpbnQgdGVncmFfdmRlX2F0 dGFjaF9kbWFidWYoc3RydWN0IGRldmljZSAqZGV2LAogCQkJCSAgIHNpemVfdCAqc2l6ZSwKIAkJ CQkgICBlbnVtIGRtYV9kYXRhX2RpcmVjdGlvbiBkbWFfZGlyKQogeworCXN0cnVjdCBkbWFfYnVm X2F0dGFjaF9pbmZvIGF0dGFjaF9pbmZvID0geworCQkuZGV2ID0gZGV2LAorCQkuZG1hYnVmID0g ZG1hYnVmCisJfTsKIAlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2htZW50OwogCXN0 cnVjdCBkbWFfYnVmICpkbWFidWY7CiAJc3RydWN0IHNnX3RhYmxlICpzZ3Q7CkBAIC01OTEsNyAr NTk1LDcgQEAgc3RhdGljIGludCB0ZWdyYV92ZGVfYXR0YWNoX2RtYWJ1ZihzdHJ1Y3QgZGV2aWNl ICpkZXYsCiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCWF0dGFjaG1lbnQgPSBkbWFfYnVmX2F0 dGFjaChkbWFidWYsIGRldik7CisJYXR0YWNobWVudCA9IGRtYV9idWZfYXR0YWNoKCZhdHRhY2hf aW5mbyk7CiAJaWYgKElTX0VSUihhdHRhY2htZW50KSkgewogCQlkZXZfZXJyKGRldiwgIkZhaWxl ZCB0byBhdHRhY2ggZG1hYnVmXG4iKTsKIAkJZXJyID0gUFRSX0VSUihhdHRhY2htZW50KTsKZGlm ZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oIGIvaW5jbHVkZS9saW51eC9kbWEtYnVm LmgKaW5kZXggMThhNzhiZTUzNTQxLi43ZTIzNzU4ZGIzYTQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUv bGludXgvZG1hLWJ1Zi5oCisrKyBiL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oCkBAIC0xMjgsNiAr MTI4LDkgQEAgc3RydWN0IGRtYV9idWZfb3BzIHsKIAkgKiBhbnkgb3RoZXIga2luZCBvZiBzaGFy aW5nIHRoYXQgdGhlIGV4cG9ydGVyIG1pZ2h0IHdpc2ggdG8gbWFrZQogCSAqIGF2YWlsYWJsZSB0 byBidWZmZXItdXNlcnMuCiAJICoKKwkgKiBUaGlzIGlzIGFsd2F5cyBjYWxsZWQgd2l0aCB0aGUg ZG1hYnVmLT5yZXN2IG9iamVjdCBsb2NrZWQgd2hlbgorCSAqIG5vX3NndF9jYWNoZSBpcyB0cnVl LgorCSAqCiAJICogUmV0dXJuczoKIAkgKgogCSAqIEEgJnNnX3RhYmxlIHNjYXR0ZXIgbGlzdCBv ZiBvciB0aGUgYmFja2luZyBzdG9yYWdlIG9mIHRoZSBETUEgYnVmZmVyLApAQCAtMTQ4LDYgKzE1 MSw5IEBAIHN0cnVjdCBkbWFfYnVmX29wcyB7CiAJICogSXQgc2hvdWxkIGFsc28gdW5waW4gdGhl IGJhY2tpbmcgc3RvcmFnZSBpZiB0aGlzIGlzIHRoZSBsYXN0IG1hcHBpbmcKIAkgKiBvZiB0aGUg RE1BIGJ1ZmZlciwgaXQgdGhlIGV4cG9ydGVyIHN1cHBvcnRzIGJhY2tpbmcgc3RvcmFnZQogCSAq IG1pZ3JhdGlvbi4KKwkgKgorCSAqIFRoaXMgaXMgYWx3YXlzIGNhbGxlZCB3aXRoIHRoZSBkbWFi dWYtPnJlc3Ygb2JqZWN0IGxvY2tlZCB3aGVuCisJICogbm9fc2d0X2NhY2hlIGlzIHRydWUuCiAJ ICovCiAJdm9pZCAoKnVubWFwX2RtYV9idWYpKHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKiwK IAkJCSAgICAgIHN0cnVjdCBzZ190YWJsZSAqLApAQCAtMzcwLDYgKzM3NiwxOSBAQCBzdHJ1Y3Qg ZG1hX2J1Zl9leHBvcnRfaW5mbyB7CiAJc3RydWN0IGRtYV9idWZfZXhwb3J0X2luZm8gbmFtZSA9 IHsgLmV4cF9uYW1lID0gS0JVSUxEX01PRE5BTUUsIFwKIAkJCQkJIC5vd25lciA9IFRISVNfTU9E VUxFIH0KIAorLyoqCisgKiBzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfaW5mbyAtIGhvbGRzIGluZm9y bWF0aW9uIG5lZWRlZCB0byBhdHRhY2ggdG8gYSBkbWFfYnVmCisgKiBAZG1hYnVmOgl0aGUgZXhw b3J0ZWQgZG1hX2J1ZgorICogQGRldjoJdGhlIGRldmljZSB3aGljaCB3YW50cyB0byBpbXBvcnQg dGhlIGF0dGFjaG1lbnQKKyAqCisgKiBUaGlzIHN0cnVjdHVyZSBob2xkcyB0aGUgaW5mb3JtYXRp b24gcmVxdWlyZWQgdG8gYXR0YWNoIHRvIGEgYnVmZmVyLiBVc2VkCisgKiB3aXRoIGRtYV9idWZf YXR0YWNoKCkgb25seS4KKyAqLworc3RydWN0IGRtYV9idWZfYXR0YWNoX2luZm8geworCXN0cnVj dCBkbWFfYnVmICpkbWFidWY7CisJc3RydWN0IGRldmljZSAqZGV2OworfTsKKwogLyoqCiAgKiBn ZXRfZG1hX2J1ZiAtIGNvbnZlbmllbmNlIHdyYXBwZXIgZm9yIGdldF9maWxlLgogICogQGRtYWJ1 ZjoJW2luXQlwb2ludGVyIHRvIGRtYV9idWYKQEAgLTM4NCw4ICs0MDMsOCBAQCBzdGF0aWMgaW5s aW5lIHZvaWQgZ2V0X2RtYV9idWYoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKIAlnZXRfZmlsZShk bWFidWYtPmZpbGUpOwogfQogCi1zdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICpkbWFfYnVmX2F0 dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAotCQkJCQkJCXN0cnVjdCBkZXZpY2UgKmRldik7 CitzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICoKK2RtYV9idWZfYXR0YWNoKGNvbnN0IHN0cnVj dCBkbWFfYnVmX2F0dGFjaF9pbmZvICppbmZvKTsKIHZvaWQgZG1hX2J1Zl9kZXRhY2goc3RydWN0 IGRtYV9idWYgKmRtYWJ1ZiwKIAkJCQlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICpkbWFidWZf YXR0YWNoKTsKIAotLSAKMi4xNy4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVl ZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5m by9kcmktZGV2ZWw= 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=-8.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,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 917EBC10F14 for ; Tue, 16 Apr 2019 18:39:57 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 4CA752064A for ; Tue, 16 Apr 2019 18:39:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="tqCLyoUX" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729251AbfDPSjv (ORCPT ); Tue, 16 Apr 2019 14:39:51 -0400 Received: from mail-wr1-f66.google.com ([209.85.221.66]:45480 "EHLO mail-wr1-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730318AbfDPSiw (ORCPT ); Tue, 16 Apr 2019 14:38:52 -0400 Received: by mail-wr1-f66.google.com with SMTP id s15so28448489wra.12; Tue, 16 Apr 2019 11:38:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=YHP56/x8Y0vj9UsUHargeze959GmvGO+zgN4AFX2eV8=; b=tqCLyoUXlj5bU4CWRw2h01Gk2EfBDnhv1d6JQoxTTHBm7somvhMaJmk+llXBmlJEAz BD0M3IHJjaxUpQlgHVzP1053DSJpR0NjMwLGumjNyCL1GY7tuY6MOWQ9KIqRTSwIHFqY RpCmPSqY7k3tNrSTRU92QwbtYO5OqJZHcZmLJ+AXA1FTCNEbJ3Bi0xNyQ+Q9GC+7lTLU iDhUlg5r6syXdmeBVIU9NwAv07/cVOJZG43I038K0Z//Bs2nfwePS2dpgFolhx3ov2nn BZzF0nh6mQYOZGx6wO/fHNzptHYMHgVBwRgJf7VW1ZU1QpPLWj93EHtuA4JlAdW5Tzf6 eepw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=YHP56/x8Y0vj9UsUHargeze959GmvGO+zgN4AFX2eV8=; b=TVP+wqlsW2J9m5D4f7qem9GBJ2E/Us35bwm6JcVAugWt/2tshykC6/jED78H/+20YE ZfhwrtcKHAJKDdPBiz/CVjo6CZ2LjMKN2RhVxer0Ft+7Vs2sd8q9fmfEMEY7yJpb2foN 6pfSwKMvMhyw8UpW/p3BS45KW28WtDzPyR9Mc4UyduqcV4tt9l6qcebWuNpSyxm+gPBu dwRuBixBCUeHkxkku7uJmRoOUbMFuRxVYD//X/ajzU9+voIdRXUITXw64BIDBiDRocJs M6RtoAcDiqi+Vn9bA0qAakq8nT43s5tEnwmukyd0obKBYrzxDhts/XtKumFT/NrqT+5d 64wQ== X-Gm-Message-State: APjAAAUieY7qkbAJ5i/Ya9gQxWwXr4OXENu+3n+zcO1sbH8lkfhfGn74 gEQIwhQJcT/IrTIvFSYXyPEQaJM0 X-Google-Smtp-Source: APXvYqzBqW1/u8EB5MTMX+pFMF1VzudtLXi5fspXg48y8SjZWJZPXHjzMX6D6YkikiZVgQbcr5drdA== X-Received: by 2002:adf:dd8c:: with SMTP id x12mr22752424wrl.262.1555439929291; Tue, 16 Apr 2019 11:38:49 -0700 (PDT) Received: from abel.fritz.box ([2a02:908:1252:fb60:fcfa:e34f:82c0:3f66]) by smtp.gmail.com with ESMTPSA id m13sm128823wmg.42.2019.04.16.11.38.48 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 16 Apr 2019 11:38:48 -0700 (PDT) From: "=?UTF-8?q?Christian=20K=C3=B6nig?=" X-Google-Original-From: =?UTF-8?q?Christian=20K=C3=B6nig?= To: sumit.semwal@linaro.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org, amd-gfx@lists.freedesktop.org Subject: [PATCH 03/12] dma-buf: lock the reservation object during (un)map_dma_buf v3 Date: Tue, 16 Apr 2019 20:38:32 +0200 Message-Id: <20190416183841.1577-4-christian.koenig@amd.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190416183841.1577-1-christian.koenig@amd.com> References: <20190416183841.1577-1-christian.koenig@amd.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org Make it mandatory for dynamic dma-buf callbacks to be called with the reservation lock held. For static dma-buf exporters we still have the fallback of using cached sgt. v2: reordered v3: rebased on sgt caching v4: use the cached sgt when possible Signed-off-by: Christian König --- drivers/dma-buf/dma-buf.c | 24 ++++++++++--------- drivers/gpu/drm/armada/armada_gem.c | 6 ++++- drivers/gpu/drm/drm_prime.c | 6 ++++- drivers/gpu/drm/i915/i915_gem_dmabuf.c | 6 ++++- drivers/gpu/drm/tegra/gem.c | 6 ++++- drivers/gpu/drm/udl/udl_dmabuf.c | 6 ++++- .../common/videobuf2/videobuf2-dma-contig.c | 6 ++++- .../media/common/videobuf2/videobuf2-dma-sg.c | 6 ++++- drivers/staging/media/tegra-vde/tegra-vde.c | 6 ++++- include/linux/dma-buf.h | 23 ++++++++++++++++-- 10 files changed, 74 insertions(+), 21 deletions(-) diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c index ef480e5fb239..83c92bfd964c 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -532,8 +532,9 @@ EXPORT_SYMBOL_GPL(dma_buf_put); /** * dma_buf_attach - Add the device to dma_buf's attachments list; optionally, * calls attach() of dma_buf_ops to allow device-specific attach functionality - * @dmabuf: [in] buffer to attach device to. - * @dev: [in] device to be attached. + * @info: [in] holds all the attach related information provided + * by the importer. see &struct dma_buf_attach_info + * for further details. * * Returns struct dma_buf_attachment pointer for this attachment. Attachments * must be cleaned up by calling dma_buf_detach(). @@ -547,20 +548,20 @@ EXPORT_SYMBOL_GPL(dma_buf_put); * accessible to @dev, and cannot be moved to a more suitable place. This is * indicated with the error code -EBUSY. */ -struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, - struct device *dev) +struct dma_buf_attachment *dma_buf_attach(const struct dma_buf_attach_info *info) { + struct dma_buf *dmabuf = info->dmabuf; struct dma_buf_attachment *attach; int ret; - if (WARN_ON(!dmabuf || !dev)) + if (WARN_ON(!dmabuf || !info->dev)) return ERR_PTR(-EINVAL); attach = kzalloc(sizeof(*attach), GFP_KERNEL); if (!attach) return ERR_PTR(-ENOMEM); - attach->dev = dev; + attach->dev = info->dev; attach->dmabuf = dmabuf; mutex_lock(&dmabuf->lock); @@ -688,9 +689,9 @@ struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach, if (attach->sgt) return attach->sgt; - sg_table = attach->dmabuf->ops->map_dma_buf(attach, direction); - if (!sg_table) - sg_table = ERR_PTR(-ENOMEM); + reservation_object_lock(attach->dmabuf->resv, NULL); + sg_table = dma_buf_map_attachment_locked(attach, direction); + reservation_object_unlock(attach->dmabuf->resv); return sg_table; } @@ -744,8 +745,9 @@ void dma_buf_unmap_attachment(struct dma_buf_attachment *attach, if (attach->sgt == sg_table) return; - attach->dmabuf->ops->unmap_dma_buf(attach, sg_table, - direction); + reservation_object_lock(attach->dmabuf->resv, NULL); + dma_buf_unmap_attachment_locked(attach, sg_table, direction); + reservation_object_unlock(attach->dmabuf->resv); } EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment); diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c index 642d0e70d0f8..19c47821032f 100644 --- a/drivers/gpu/drm/armada/armada_gem.c +++ b/drivers/gpu/drm/armada/armada_gem.c @@ -501,6 +501,10 @@ armada_gem_prime_export(struct drm_device *dev, struct drm_gem_object *obj, struct drm_gem_object * armada_gem_prime_import(struct drm_device *dev, struct dma_buf *buf) { + struct dma_buf_attach_info attach_info = { + .dev = dev->dev, + .dmabuf = buf + }; struct dma_buf_attachment *attach; struct armada_gem_object *dobj; @@ -516,7 +520,7 @@ armada_gem_prime_import(struct drm_device *dev, struct dma_buf *buf) } } - attach = dma_buf_attach(buf, dev->dev); + attach = dma_buf_attach(&attach_info); if (IS_ERR(attach)) return ERR_CAST(attach); diff --git a/drivers/gpu/drm/drm_prime.c b/drivers/gpu/drm/drm_prime.c index 231e3f6d5f41..1fadf5d5ed33 100644 --- a/drivers/gpu/drm/drm_prime.c +++ b/drivers/gpu/drm/drm_prime.c @@ -709,6 +709,10 @@ struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev, struct dma_buf *dma_buf, struct device *attach_dev) { + struct dma_buf_attach_info attach_info = { + .dev = attach_dev, + .dmabuf = dma_buf + }; struct dma_buf_attachment *attach; struct sg_table *sgt; struct drm_gem_object *obj; @@ -729,7 +733,7 @@ struct drm_gem_object *drm_gem_prime_import_dev(struct drm_device *dev, if (!dev->driver->gem_prime_import_sg_table) return ERR_PTR(-EINVAL); - attach = dma_buf_attach(dma_buf, attach_dev); + attach = dma_buf_attach(&attach_info); if (IS_ERR(attach)) return ERR_CAST(attach); diff --git a/drivers/gpu/drm/i915/i915_gem_dmabuf.c b/drivers/gpu/drm/i915/i915_gem_dmabuf.c index 82e2ca17a441..aa7f685bd6ca 100644 --- a/drivers/gpu/drm/i915/i915_gem_dmabuf.c +++ b/drivers/gpu/drm/i915/i915_gem_dmabuf.c @@ -277,6 +277,10 @@ static const struct drm_i915_gem_object_ops i915_gem_object_dmabuf_ops = { struct drm_gem_object *i915_gem_prime_import(struct drm_device *dev, struct dma_buf *dma_buf) { + struct dma_buf_attach_info attach_info = { + .dev = dev->dev, + .dmabuf = dma_buf + }; struct dma_buf_attachment *attach; struct drm_i915_gem_object *obj; int ret; @@ -295,7 +299,7 @@ struct drm_gem_object *i915_gem_prime_import(struct drm_device *dev, } /* need to attach */ - attach = dma_buf_attach(dma_buf, dev->dev); + attach = dma_buf_attach(&attach_info); if (IS_ERR(attach)) return ERR_CAST(attach); diff --git a/drivers/gpu/drm/tegra/gem.c b/drivers/gpu/drm/tegra/gem.c index 4f80100ff5f3..8e6b6c879add 100644 --- a/drivers/gpu/drm/tegra/gem.c +++ b/drivers/gpu/drm/tegra/gem.c @@ -332,6 +332,10 @@ struct tegra_bo *tegra_bo_create_with_handle(struct drm_file *file, static struct tegra_bo *tegra_bo_import(struct drm_device *drm, struct dma_buf *buf) { + struct dma_buf_attach_info attach_info = { + .dev = drm->dev, + .dmabuf = buf + }; struct tegra_drm *tegra = drm->dev_private; struct dma_buf_attachment *attach; struct tegra_bo *bo; @@ -341,7 +345,7 @@ static struct tegra_bo *tegra_bo_import(struct drm_device *drm, if (IS_ERR(bo)) return bo; - attach = dma_buf_attach(buf, drm->dev); + attach = dma_buf_attach(&attach_info); if (IS_ERR(attach)) { err = PTR_ERR(attach); goto free; diff --git a/drivers/gpu/drm/udl/udl_dmabuf.c b/drivers/gpu/drm/udl/udl_dmabuf.c index 556f62662aa9..86b928f9742f 100644 --- a/drivers/gpu/drm/udl/udl_dmabuf.c +++ b/drivers/gpu/drm/udl/udl_dmabuf.c @@ -226,6 +226,10 @@ static int udl_prime_create(struct drm_device *dev, struct drm_gem_object *udl_gem_prime_import(struct drm_device *dev, struct dma_buf *dma_buf) { + struct dma_buf_attach_info attach_info = { + .dev = dev->dev, + .dmabuf = dma_buf + }; struct dma_buf_attachment *attach; struct sg_table *sg; struct udl_gem_object *uobj; @@ -233,7 +237,7 @@ struct drm_gem_object *udl_gem_prime_import(struct drm_device *dev, /* need to attach */ get_device(dev->dev); - attach = dma_buf_attach(dma_buf, dev->dev); + attach = dma_buf_attach(&attach_info); if (IS_ERR(attach)) { put_device(dev->dev); return ERR_CAST(attach); diff --git a/drivers/media/common/videobuf2/videobuf2-dma-contig.c b/drivers/media/common/videobuf2/videobuf2-dma-contig.c index aff0ab7bf83d..1f2687b5eb0e 100644 --- a/drivers/media/common/videobuf2/videobuf2-dma-contig.c +++ b/drivers/media/common/videobuf2/videobuf2-dma-contig.c @@ -676,6 +676,10 @@ static void vb2_dc_detach_dmabuf(void *mem_priv) static void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, unsigned long size, enum dma_data_direction dma_dir) { + struct dma_buf_attach_info attach_info = { + .dev = dev, + .dmabuf = dbuf + }; struct vb2_dc_buf *buf; struct dma_buf_attachment *dba; @@ -691,7 +695,7 @@ static void *vb2_dc_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, buf->dev = dev; /* create attachment for the dmabuf with the user device */ - dba = dma_buf_attach(dbuf, buf->dev); + dba = dma_buf_attach(&attach_info); if (IS_ERR(dba)) { pr_err("failed to attach dmabuf\n"); kfree(buf); diff --git a/drivers/media/common/videobuf2/videobuf2-dma-sg.c b/drivers/media/common/videobuf2/videobuf2-dma-sg.c index 015e737095cd..cbd626d2393a 100644 --- a/drivers/media/common/videobuf2/videobuf2-dma-sg.c +++ b/drivers/media/common/videobuf2/videobuf2-dma-sg.c @@ -608,6 +608,10 @@ static void vb2_dma_sg_detach_dmabuf(void *mem_priv) static void *vb2_dma_sg_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, unsigned long size, enum dma_data_direction dma_dir) { + struct dma_buf_attach_info attach_info = { + .dev = dev, + .dmabuf = dbuf + }; struct vb2_dma_sg_buf *buf; struct dma_buf_attachment *dba; @@ -623,7 +627,7 @@ static void *vb2_dma_sg_attach_dmabuf(struct device *dev, struct dma_buf *dbuf, buf->dev = dev; /* create attachment for the dmabuf with the user device */ - dba = dma_buf_attach(dbuf, buf->dev); + dba = dma_buf_attach(&attach_info); if (IS_ERR(dba)) { pr_err("failed to attach dmabuf\n"); kfree(buf); diff --git a/drivers/staging/media/tegra-vde/tegra-vde.c b/drivers/staging/media/tegra-vde/tegra-vde.c index aa6c6bba961e..5a10c1facc27 100644 --- a/drivers/staging/media/tegra-vde/tegra-vde.c +++ b/drivers/staging/media/tegra-vde/tegra-vde.c @@ -568,6 +568,10 @@ static int tegra_vde_attach_dmabuf(struct device *dev, size_t *size, enum dma_data_direction dma_dir) { + struct dma_buf_attach_info attach_info = { + .dev = dev, + .dmabuf = dmabuf + }; struct dma_buf_attachment *attachment; struct dma_buf *dmabuf; struct sg_table *sgt; @@ -591,7 +595,7 @@ static int tegra_vde_attach_dmabuf(struct device *dev, return -EINVAL; } - attachment = dma_buf_attach(dmabuf, dev); + attachment = dma_buf_attach(&attach_info); if (IS_ERR(attachment)) { dev_err(dev, "Failed to attach dmabuf\n"); err = PTR_ERR(attachment); diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index 18a78be53541..7e23758db3a4 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -128,6 +128,9 @@ struct dma_buf_ops { * any other kind of sharing that the exporter might wish to make * available to buffer-users. * + * This is always called with the dmabuf->resv object locked when + * no_sgt_cache is true. + * * Returns: * * A &sg_table scatter list of or the backing storage of the DMA buffer, @@ -148,6 +151,9 @@ struct dma_buf_ops { * It should also unpin the backing storage if this is the last mapping * of the DMA buffer, it the exporter supports backing storage * migration. + * + * This is always called with the dmabuf->resv object locked when + * no_sgt_cache is true. */ void (*unmap_dma_buf)(struct dma_buf_attachment *, struct sg_table *, @@ -370,6 +376,19 @@ struct dma_buf_export_info { struct dma_buf_export_info name = { .exp_name = KBUILD_MODNAME, \ .owner = THIS_MODULE } +/** + * struct dma_buf_attach_info - holds information needed to attach to a dma_buf + * @dmabuf: the exported dma_buf + * @dev: the device which wants to import the attachment + * + * This structure holds the information required to attach to a buffer. Used + * with dma_buf_attach() only. + */ +struct dma_buf_attach_info { + struct dma_buf *dmabuf; + struct device *dev; +}; + /** * get_dma_buf - convenience wrapper for get_file. * @dmabuf: [in] pointer to dma_buf @@ -384,8 +403,8 @@ static inline void get_dma_buf(struct dma_buf *dmabuf) get_file(dmabuf->file); } -struct dma_buf_attachment *dma_buf_attach(struct dma_buf *dmabuf, - struct device *dev); +struct dma_buf_attachment * +dma_buf_attach(const struct dma_buf_attach_info *info); void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *dmabuf_attach); -- 2.17.1