From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v2 8/9] xen/gntdev: Implement dma-buf import functionality Date: Fri, 1 Jun 2018 14:41:31 +0300 Message-ID: <20180601114132.22596-9-andr2000@gmail.com> References: <20180601114132.22596-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x241.google.com (mail-lf0-x241.google.com [IPv6:2a00:1450:4010:c07::241]) by gabe.freedesktop.org (Postfix) with ESMTPS id D95A86E687 for ; Fri, 1 Jun 2018 11:41:53 +0000 (UTC) Received: by mail-lf0-x241.google.com with SMTP id n18-v6so14357333lfh.10 for ; Fri, 01 Jun 2018 04:41:53 -0700 (PDT) In-Reply-To: <20180601114132.22596-1-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, daniel.vetter@intel.com, dongwon.kim@intel.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKMS4gSW1wb3J0IGEgZG1hLWJ1ZiB3aXRoIHRoZSBmaWxlIGRlc2NyaXB0b3IgcHJv dmlkZWQgYW5kIGV4cG9ydAogICBncmFudGVkIHJlZmVyZW5jZXMgdG8gdGhlIHBhZ2VzIG9mIHRo YXQgZG1hLWJ1ZiBpbnRvIHRoZSBhcnJheQogICBvZiBncmFudCByZWZlcmVuY2VzLgoKMi4gQWRk IEFQSSB0byBjbG9zZSBhbGwgcmVmZXJlbmNlcyB0byBhbiBpbXBvcnRlZCBidWZmZXIsIHNvIGl0 IGNhbiBiZQogICByZWxlYXNlZCBieSB0aGUgb3duZXIuIFRoaXMgaXMgb25seSB2YWxpZCBmb3Ig YnVmZmVycyBjcmVhdGVkIHdpdGgKICAgSU9DVExfR05UREVWX0RNQUJVRl9JTVBfVE9fUkVGUy4K ClNpZ25lZC1vZmYtYnk6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVz aGNoZW5rb0BlcGFtLmNvbT4KLS0tCiBkcml2ZXJzL3hlbi9nbnRkZXYtZG1hYnVmLmMgfCAyNDMg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiAxIGZpbGUgY2hhbmdlZCwgMjQx IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4v Z250ZGV2LWRtYWJ1Zi5jIGIvZHJpdmVycy94ZW4vZ250ZGV2LWRtYWJ1Zi5jCmluZGV4IGY2MTI0 Njg4NzliNC4uYjU1NjlhMjIwZjAzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9nbnRkZXYtZG1h YnVmLmMKKysrIGIvZHJpdmVycy94ZW4vZ250ZGV2LWRtYWJ1Zi5jCkBAIC0xMSw4ICsxMSwyMCBA QAogI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAK KyNpbmNsdWRlIDx4ZW4veGVuLmg+CisjaW5jbHVkZSA8eGVuL2dyYW50X3RhYmxlLmg+CisKICNp bmNsdWRlICJnbnRkZXYtZG1hYnVmLmgiCiAKKyNpZm5kZWYgR1JBTlRfSU5WQUxJRF9SRUYKKy8q CisgKiBOb3RlIG9uIHVzYWdlIG9mIGdyYW50IHJlZmVyZW5jZSAwIGFzIGludmFsaWQgZ3JhbnQg cmVmZXJlbmNlOgorICogZ3JhbnQgcmVmZXJlbmNlIDAgaXMgdmFsaWQsIGJ1dCBuZXZlciBleHBv c2VkIHRvIGEgZHJpdmVyLAorICogYmVjYXVzZSBvZiB0aGUgZmFjdCBpdCBpcyBhbHJlYWR5IGlu IHVzZS9yZXNlcnZlZCBieSB0aGUgUFYgY29uc29sZS4KKyAqLworI2RlZmluZSBHUkFOVF9JTlZB TElEX1JFRgkwCisjZW5kaWYKKwogc3RydWN0IGdudGRldl9kbWFidWYgewogCXN0cnVjdCBnbnRk ZXZfZG1hYnVmX3ByaXYgKnByaXY7CiAJc3RydWN0IGRtYV9idWYgKmRtYWJ1ZjsKQEAgLTI5LDYg KzQxLDE0IEBAIHN0cnVjdCBnbnRkZXZfZG1hYnVmIHsKIAkJCXZvaWQgKCpyZWxlYXNlKShzdHJ1 Y3QgZ250ZGV2X3ByaXYgKnByaXYsCiAJCQkJCXN0cnVjdCBncmFudF9tYXAgKm1hcCk7CiAJCX0g ZXhwOworCQlzdHJ1Y3QgeworCQkJLyogR3JhbnRlZCByZWZlcmVuY2VzIG9mIHRoZSBpbXBvcnRl ZCBidWZmZXIuICovCisJCQlncmFudF9yZWZfdCAqcmVmczsKKwkJCS8qIFNjYXR0ZXItZ2F0aGVy IHRhYmxlIG9mIHRoZSBpbXBvcnRlZCBidWZmZXIuICovCisJCQlzdHJ1Y3Qgc2dfdGFibGUgKnNn dDsKKwkJCS8qIGRtYS1idWYgYXR0YWNobWVudCBvZiB0aGUgaW1wb3J0ZWQgYnVmZmVyLiAqLwor CQkJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOworCQl9IGltcDsKIAl9IHU7CiAK IAkvKiBOdW1iZXIgb2YgcGFnZXMgdGhpcyBidWZmZXIgaGFzLiAqLwpAQCAtNTMsNiArNzMsOCBA QCBzdHJ1Y3QgZ250ZGV2X2RtYWJ1Zl9wcml2IHsKIAlzdHJ1Y3QgbGlzdF9oZWFkIGV4cF9saXN0 OwogCS8qIExpc3Qgb2Ygd2FpdCBvYmplY3RzLiAqLwogCXN0cnVjdCBsaXN0X2hlYWQgZXhwX3dh aXRfbGlzdDsKKwkvKiBMaXN0IG9mIGltcG9ydGVkIERNQSBidWZmZXJzLiAqLworCXN0cnVjdCBs aXN0X2hlYWQgaW1wX2xpc3Q7CiAJLyogVGhpcyBpcyB0aGUgbG9jayB3aGljaCBwcm90ZWN0cyBk bWFfYnVmX3h4eCBsaXN0cy4gKi8KIAlzdHJ1Y3QgbXV0ZXggbG9jazsKIH07CkBAIC00MjQsMjEg KzQ0NiwyMzcgQEAgaW50IGdudGRldl9kbWFidWZfZXhwX2Zyb21fcGFnZXMoc3RydWN0IGdudGRl dl9kbWFidWZfZXhwb3J0X2FyZ3MgKmFyZ3MpCiAvKiBETUEgYnVmZmVyIGltcG9ydCBzdXBwb3J0 LiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KIC8qIC0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LSAqLwogCitzdGF0aWMgaW50CitkbWFidWZfaW1wX2dyYW50X2ZvcmVpZ25fYWNjZXNzKHN0cnVj dCBwYWdlICoqcGFnZXMsIHUzMiAqcmVmcywKKwkJCQlpbnQgY291bnQsIGludCBkb21pZCkKK3sK KwlncmFudF9yZWZfdCBwcml2X2dyZWZfaGVhZDsKKwlpbnQgaSwgcmV0OworCisJcmV0ID0gZ250 dGFiX2FsbG9jX2dyYW50X3JlZmVyZW5jZXMoY291bnQsICZwcml2X2dyZWZfaGVhZCk7CisJaWYg KHJldCA8IDApIHsKKwkJcHJfZXJyKCJDYW5ub3QgYWxsb2NhdGUgZ3JhbnQgcmVmZXJlbmNlcywg cmV0ICVkXG4iLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKworCWZvciAoaSA9IDA7IGkgPCBj b3VudDsgaSsrKSB7CisJCWludCBjdXJfcmVmOworCisJCWN1cl9yZWYgPSBnbnR0YWJfY2xhaW1f Z3JhbnRfcmVmZXJlbmNlKCZwcml2X2dyZWZfaGVhZCk7CisJCWlmIChjdXJfcmVmIDwgMCkgewor CQkJcmV0ID0gY3VyX3JlZjsKKwkJCXByX2VycigiQ2Fubm90IGNsYWltIGdyYW50IHJlZmVyZW5j ZSwgcmV0ICVkXG4iLCByZXQpOworCQkJZ290byBvdXQ7CisJCX0KKworCQlnbnR0YWJfZ3JhbnRf Zm9yZWlnbl9hY2Nlc3NfcmVmKGN1cl9yZWYsIGRvbWlkLAorCQkJCQkJeGVuX3BhZ2VfdG9fZ2Zu KHBhZ2VzW2ldKSwgMCk7CisJCXJlZnNbaV0gPSBjdXJfcmVmOworCX0KKworCXJldCA9IDA7CisK K291dDoKKwlnbnR0YWJfZnJlZV9ncmFudF9yZWZlcmVuY2VzKHByaXZfZ3JlZl9oZWFkKTsKKwly ZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBkbWFidWZfaW1wX2VuZF9mb3JlaWduX2FjY2Vz cyh1MzIgKnJlZnMsIGludCBjb3VudCkKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCBj b3VudDsgaSsrKQorCQlpZiAocmVmc1tpXSAhPSBHUkFOVF9JTlZBTElEX1JFRikKKwkJCWdudHRh Yl9lbmRfZm9yZWlnbl9hY2Nlc3MocmVmc1tpXSwgMCwgMFVMKTsKK30KKworc3RhdGljIHZvaWQg ZG1hYnVmX2ltcF9mcmVlX3N0b3JhZ2Uoc3RydWN0IGdudGRldl9kbWFidWYgKmdudGRldl9kbWFi dWYpCit7CisJa2ZyZWUoZ250ZGV2X2RtYWJ1Zi0+cGFnZXMpOworCWtmcmVlKGdudGRldl9kbWFi dWYtPnUuaW1wLnJlZnMpOworCWtmcmVlKGdudGRldl9kbWFidWYpOworfQorCitzdGF0aWMgc3Ry dWN0IGdudGRldl9kbWFidWYgKmRtYWJ1Zl9pbXBfYWxsb2Nfc3RvcmFnZShpbnQgY291bnQpCit7 CisJc3RydWN0IGdudGRldl9kbWFidWYgKmdudGRldl9kbWFidWY7CisJaW50IGk7CisKKwlnbnRk ZXZfZG1hYnVmID0ga3phbGxvYyhzaXplb2YoKmdudGRldl9kbWFidWYpLCBHRlBfS0VSTkVMKTsK KwlpZiAoIWdudGRldl9kbWFidWYpCisJCWdvdG8gZmFpbDsKKworCWdudGRldl9kbWFidWYtPnUu aW1wLnJlZnMgPSBrY2FsbG9jKGNvdW50LAorCQkJCQkgICAgc2l6ZW9mKGdudGRldl9kbWFidWYt PnUuaW1wLnJlZnNbMF0pLAorCQkJCQkgICAgR0ZQX0tFUk5FTCk7CisJaWYgKCFnbnRkZXZfZG1h YnVmLT51LmltcC5yZWZzKQorCQlnb3RvIGZhaWw7CisKKwlnbnRkZXZfZG1hYnVmLT5wYWdlcyA9 IGtjYWxsb2MoY291bnQsCisJCQkJICAgICAgIHNpemVvZihnbnRkZXZfZG1hYnVmLT5wYWdlc1sw XSksCisJCQkJICAgICAgIEdGUF9LRVJORUwpOworCWlmICghZ250ZGV2X2RtYWJ1Zi0+cGFnZXMp CisJCWdvdG8gZmFpbDsKKworCWdudGRldl9kbWFidWYtPm5yX3BhZ2VzID0gY291bnQ7CisKKwlm b3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykKKwkJZ250ZGV2X2RtYWJ1Zi0+dS5pbXAucmVmc1tp XSA9IEdSQU5UX0lOVkFMSURfUkVGOworCisJcmV0dXJuIGdudGRldl9kbWFidWY7CisKK2ZhaWw6 CisJZG1hYnVmX2ltcF9mcmVlX3N0b3JhZ2UoZ250ZGV2X2RtYWJ1Zik7CisJcmV0dXJuIEVSUl9Q VFIoLUVOT01FTSk7Cit9CisKIHN0cnVjdCBnbnRkZXZfZG1hYnVmICoKIGdudGRldl9kbWFidWZf aW1wX3RvX3JlZnMoc3RydWN0IGdudGRldl9kbWFidWZfcHJpdiAqcHJpdiwgc3RydWN0IGRldmlj ZSAqZGV2LAogCQkJICBpbnQgZmQsIGludCBjb3VudCwgaW50IGRvbWlkKQogewotCXJldHVybiBF UlJfUFRSKC1FTk9NRU0pOworCXN0cnVjdCBnbnRkZXZfZG1hYnVmICpnbnRkZXZfZG1hYnVmLCAq cmV0OworCXN0cnVjdCBkbWFfYnVmICpkbWFfYnVmOworCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1l bnQgKmF0dGFjaDsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnNndDsKKwlzdHJ1Y3Qgc2dfcGFnZV9pdGVy IHNnX2l0ZXI7CisJaW50IGk7CisKKwlkbWFfYnVmID0gZG1hX2J1Zl9nZXQoZmQpOworCWlmIChJ U19FUlIoZG1hX2J1ZikpCisJCXJldHVybiBFUlJfQ0FTVChkbWFfYnVmKTsKKworCWdudGRldl9k bWFidWYgPSBkbWFidWZfaW1wX2FsbG9jX3N0b3JhZ2UoY291bnQpOworCWlmIChJU19FUlIoZ250 ZGV2X2RtYWJ1ZikpIHsKKwkJcmV0ID0gZ250ZGV2X2RtYWJ1ZjsKKwkJZ290byBmYWlsX3B1dDsK K30KKworCWdudGRldl9kbWFidWYtPnByaXYgPSBwcml2OworCWdudGRldl9kbWFidWYtPmZkID0g ZmQ7CisKKwlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChkbWFfYnVmLCBkZXYpOworCWlmIChJU19F UlIoYXR0YWNoKSkgeworCQlyZXQgPSBFUlJfQ0FTVChhdHRhY2gpOworCQlnb3RvIGZhaWxfZnJl ZV9vYmo7CisJfQorCisJZ250ZGV2X2RtYWJ1Zi0+dS5pbXAuYXR0YWNoID0gYXR0YWNoOworCisJ c2d0ID0gZG1hX2J1Zl9tYXBfYXR0YWNobWVudChhdHRhY2gsIERNQV9CSURJUkVDVElPTkFMKTsK KwlpZiAoSVNfRVJSKHNndCkpIHsKKwkJcmV0ID0gRVJSX0NBU1Qoc2d0KTsKKwkJZ290byBmYWls X2RldGFjaDsKKwl9CisKKwkvKiBDaGVjayBudW1iZXIgb2YgcGFnZXMgdGhhdCBpbXBvcnRlZCBi dWZmZXIgaGFzLiAqLworCWlmIChhdHRhY2gtPmRtYWJ1Zi0+c2l6ZSAhPSBnbnRkZXZfZG1hYnVm LT5ucl9wYWdlcyA8PCBQQUdFX1NISUZUKSB7CisJCXJldCA9IEVSUl9QVFIoLUVJTlZBTCk7CisJ CXByX2VycigiRE1BIGJ1ZmZlciBoYXMgJXp1IHBhZ2VzLCB1c2VyLXNwYWNlIGV4cGVjdHMgJWRc biIsCisJCSAgICAgICBhdHRhY2gtPmRtYWJ1Zi0+c2l6ZSwgZ250ZGV2X2RtYWJ1Zi0+bnJfcGFn ZXMpOworCQlnb3RvIGZhaWxfdW5tYXA7CisJfQorCisJZ250ZGV2X2RtYWJ1Zi0+dS5pbXAuc2d0 ID0gc2d0OworCisJLyogTm93IGNvbnZlcnQgc2d0IHRvIGFycmF5IG9mIHBhZ2VzIGFuZCBjaGVj ayBmb3IgcGFnZSB2YWxpZGl0eS4gKi8KKwlpID0gMDsKKwlmb3JfZWFjaF9zZ19wYWdlKHNndC0+ c2dsLCAmc2dfaXRlciwgc2d0LT5uZW50cywgMCkgeworCQlzdHJ1Y3QgcGFnZSAqcGFnZSA9IHNn X3BhZ2VfaXRlcl9wYWdlKCZzZ19pdGVyKTsKKwkJLyoKKwkJICogQ2hlY2sgaWYgcGFnZSBpcyB2 YWxpZDogdGhpcyBjYW4gaGFwcGVuIGlmIHdlIGFyZSBnaXZlbgorCQkgKiBhIHBhZ2UgZnJvbSBW UkFNIG9yIG90aGVyIHJlc291cmNlcyB3aGljaCBhcmUgbm90IGJhY2tlZAorCQkgKiBieSBhIHN0 cnVjdCBwYWdlLgorCQkgKi8KKwkJaWYgKCFwZm5fdmFsaWQocGFnZV90b19wZm4ocGFnZSkpKSB7 CisJCQlyZXQgPSBFUlJfUFRSKC1FSU5WQUwpOworCQkJZ290byBmYWlsX3VubWFwOworCQl9CisK KwkJZ250ZGV2X2RtYWJ1Zi0+cGFnZXNbaSsrXSA9IHBhZ2U7CisJfQorCisJcmV0ID0gRVJSX1BU UihkbWFidWZfaW1wX2dyYW50X2ZvcmVpZ25fYWNjZXNzKGdudGRldl9kbWFidWYtPnBhZ2VzLAor CQkJCQkJICAgICAgZ250ZGV2X2RtYWJ1Zi0+dS5pbXAucmVmcywKKwkJCQkJCSAgICAgIGNvdW50 LCBkb21pZCkpOworCWlmIChJU19FUlIocmV0KSkKKwkJZ290byBmYWlsX2VuZF9hY2Nlc3M7CisK Kwlwcl9kZWJ1ZygiSW1wb3J0ZWQgRE1BIGJ1ZmZlciB3aXRoIGZkICVkXG4iLCBmZCk7CisKKwlt dXRleF9sb2NrKCZwcml2LT5sb2NrKTsKKwlsaXN0X2FkZCgmZ250ZGV2X2RtYWJ1Zi0+bmV4dCwg JnByaXYtPmltcF9saXN0KTsKKwltdXRleF91bmxvY2soJnByaXYtPmxvY2spOworCisJcmV0dXJu IGdudGRldl9kbWFidWY7CisKK2ZhaWxfZW5kX2FjY2VzczoKKwlkbWFidWZfaW1wX2VuZF9mb3Jl aWduX2FjY2VzcyhnbnRkZXZfZG1hYnVmLT51LmltcC5yZWZzLCBjb3VudCk7CitmYWlsX3VubWFw OgorCWRtYV9idWZfdW5tYXBfYXR0YWNobWVudChhdHRhY2gsIHNndCwgRE1BX0JJRElSRUNUSU9O QUwpOworZmFpbF9kZXRhY2g6CisJZG1hX2J1Zl9kZXRhY2goZG1hX2J1ZiwgYXR0YWNoKTsKK2Zh aWxfZnJlZV9vYmo6CisJZG1hYnVmX2ltcF9mcmVlX3N0b3JhZ2UoZ250ZGV2X2RtYWJ1Zik7Citm YWlsX3B1dDoKKwlkbWFfYnVmX3B1dChkbWFfYnVmKTsKKwlyZXR1cm4gcmV0OwogfQogCiB1MzIg KmdudGRldl9kbWFidWZfaW1wX2dldF9yZWZzKHN0cnVjdCBnbnRkZXZfZG1hYnVmICpnbnRkZXZf ZG1hYnVmKQogeworCWlmIChnbnRkZXZfZG1hYnVmKQorCQlyZXR1cm4gZ250ZGV2X2RtYWJ1Zi0+ dS5pbXAucmVmczsKKwogCXJldHVybiBOVUxMOwogfQogCisvKgorICogRmluZCB0aGUgaHlwZXIg ZG1hLWJ1ZiBieSBpdHMgZmlsZSBkZXNjcmlwdG9yIGFuZCByZW1vdmUKKyAqIGl0IGZyb20gdGhl IGJ1ZmZlcidzIGxpc3QuCisgKi8KK3N0YXRpYyBzdHJ1Y3QgZ250ZGV2X2RtYWJ1ZiAqCitkbWFi dWZfaW1wX2ZpbmRfdW5saW5rKHN0cnVjdCBnbnRkZXZfZG1hYnVmX3ByaXYgKnByaXYsIGludCBm ZCkKK3sKKwlzdHJ1Y3QgZ250ZGV2X2RtYWJ1ZiAqcSwgKmdudGRldl9kbWFidWYsICpyZXQgPSBF UlJfUFRSKC1FTk9FTlQpOworCisJbXV0ZXhfbG9jaygmcHJpdi0+bG9jayk7CisJbGlzdF9mb3Jf ZWFjaF9lbnRyeV9zYWZlKGdudGRldl9kbWFidWYsIHEsICZwcml2LT5pbXBfbGlzdCwgbmV4dCkg eworCQlpZiAoZ250ZGV2X2RtYWJ1Zi0+ZmQgPT0gZmQpIHsKKwkJCXByX2RlYnVnKCJGb3VuZCBn bnRkZXZfZG1hYnVmIGluIHRoZSBpbXBvcnQgbGlzdFxuIik7CisJCQlyZXQgPSBnbnRkZXZfZG1h YnVmOworCQkJbGlzdF9kZWwoJmdudGRldl9kbWFidWYtPm5leHQpOworCQkJYnJlYWs7CisJCX0K Kwl9CisJbXV0ZXhfdW5sb2NrKCZwcml2LT5sb2NrKTsKKwlyZXR1cm4gcmV0OworfQorCiBpbnQg Z250ZGV2X2RtYWJ1Zl9pbXBfcmVsZWFzZShzdHJ1Y3QgZ250ZGV2X2RtYWJ1Zl9wcml2ICpwcml2 LCB1MzIgZmQpCiB7Ci0JcmV0dXJuIC1FSU5WQUw7CisJc3RydWN0IGdudGRldl9kbWFidWYgKmdu dGRldl9kbWFidWY7CisJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOworCXN0cnVj dCBkbWFfYnVmICpkbWFfYnVmOworCisJZ250ZGV2X2RtYWJ1ZiA9IGRtYWJ1Zl9pbXBfZmluZF91 bmxpbmsocHJpdiwgZmQpOworCWlmIChJU19FUlIoZ250ZGV2X2RtYWJ1ZikpCisJCXJldHVybiBQ VFJfRVJSKGdudGRldl9kbWFidWYpOworCisJcHJfZGVidWcoIlJlbGVhc2luZyBETUEgYnVmZmVy IHdpdGggZmQgJWRcbiIsIGZkKTsKKworCWF0dGFjaCA9IGdudGRldl9kbWFidWYtPnUuaW1wLmF0 dGFjaDsKKworCWlmIChnbnRkZXZfZG1hYnVmLT51LmltcC5zZ3QpCisJCWRtYV9idWZfdW5tYXBf YXR0YWNobWVudChhdHRhY2gsIGdudGRldl9kbWFidWYtPnUuaW1wLnNndCwKKwkJCQkJIERNQV9C SURJUkVDVElPTkFMKTsKKwlkbWFfYnVmID0gYXR0YWNoLT5kbWFidWY7CisJZG1hX2J1Zl9kZXRh Y2goYXR0YWNoLT5kbWFidWYsIGF0dGFjaCk7CisJZG1hX2J1Zl9wdXQoZG1hX2J1Zik7CisKKwlk bWFidWZfaW1wX2VuZF9mb3JlaWduX2FjY2VzcyhnbnRkZXZfZG1hYnVmLT51LmltcC5yZWZzLAor CQkJCSAgICAgIGdudGRldl9kbWFidWYtPm5yX3BhZ2VzKTsKKwlkbWFidWZfaW1wX2ZyZWVfc3Rv cmFnZShnbnRkZXZfZG1hYnVmKTsKKwlyZXR1cm4gMDsKIH0KIAogc3RydWN0IGdudGRldl9kbWFi dWZfcHJpdiAqZ250ZGV2X2RtYWJ1Zl9pbml0KHZvaWQpCkBAIC00NTIsNiArNjkwLDcgQEAgc3Ry dWN0IGdudGRldl9kbWFidWZfcHJpdiAqZ250ZGV2X2RtYWJ1Zl9pbml0KHZvaWQpCiAJbXV0ZXhf aW5pdCgmcHJpdi0+bG9jayk7CiAJSU5JVF9MSVNUX0hFQUQoJnByaXYtPmV4cF9saXN0KTsKIAlJ TklUX0xJU1RfSEVBRCgmcHJpdi0+ZXhwX3dhaXRfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJnBy aXYtPmltcF9saXN0KTsKIAogCXJldHVybiBwcml2OwogfQotLSAKMi4xNy4wCgpfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBs aXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVz a3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f66.google.com ([209.85.215.66]:35172 "EHLO mail-lf0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751937AbeFALlx (ORCPT ); Fri, 1 Jun 2018 07:41:53 -0400 From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: daniel.vetter@intel.com, andr2000@gmail.com, dongwon.kim@intel.com, matthew.d.roper@intel.com, Oleksandr Andrushchenko Subject: [PATCH v2 8/9] xen/gntdev: Implement dma-buf import functionality Date: Fri, 1 Jun 2018 14:41:31 +0300 Message-Id: <20180601114132.22596-9-andr2000@gmail.com> In-Reply-To: <20180601114132.22596-1-andr2000@gmail.com> References: <20180601114132.22596-1-andr2000@gmail.com> Sender: linux-media-owner@vger.kernel.org List-ID: From: Oleksandr Andrushchenko 1. Import a dma-buf with the file descriptor provided and export granted references to the pages of that dma-buf into the array of grant references. 2. Add API to close all references to an imported buffer, so it can be released by the owner. This is only valid for buffers created with IOCTL_GNTDEV_DMABUF_IMP_TO_REFS. Signed-off-by: Oleksandr Andrushchenko --- drivers/xen/gntdev-dmabuf.c | 243 +++++++++++++++++++++++++++++++++++- 1 file changed, 241 insertions(+), 2 deletions(-) diff --git a/drivers/xen/gntdev-dmabuf.c b/drivers/xen/gntdev-dmabuf.c index f612468879b4..b5569a220f03 100644 --- a/drivers/xen/gntdev-dmabuf.c +++ b/drivers/xen/gntdev-dmabuf.c @@ -11,8 +11,20 @@ #include #include +#include +#include + #include "gntdev-dmabuf.h" +#ifndef GRANT_INVALID_REF +/* + * Note on usage of grant reference 0 as invalid grant reference: + * grant reference 0 is valid, but never exposed to a driver, + * because of the fact it is already in use/reserved by the PV console. + */ +#define GRANT_INVALID_REF 0 +#endif + struct gntdev_dmabuf { struct gntdev_dmabuf_priv *priv; struct dma_buf *dmabuf; @@ -29,6 +41,14 @@ struct gntdev_dmabuf { void (*release)(struct gntdev_priv *priv, struct grant_map *map); } exp; + struct { + /* Granted references of the imported buffer. */ + grant_ref_t *refs; + /* Scatter-gather table of the imported buffer. */ + struct sg_table *sgt; + /* dma-buf attachment of the imported buffer. */ + struct dma_buf_attachment *attach; + } imp; } u; /* Number of pages this buffer has. */ @@ -53,6 +73,8 @@ struct gntdev_dmabuf_priv { struct list_head exp_list; /* List of wait objects. */ struct list_head exp_wait_list; + /* List of imported DMA buffers. */ + struct list_head imp_list; /* This is the lock which protects dma_buf_xxx lists. */ struct mutex lock; }; @@ -424,21 +446,237 @@ int gntdev_dmabuf_exp_from_pages(struct gntdev_dmabuf_export_args *args) /* DMA buffer import support. */ /* ------------------------------------------------------------------ */ +static int +dmabuf_imp_grant_foreign_access(struct page **pages, u32 *refs, + int count, int domid) +{ + grant_ref_t priv_gref_head; + int i, ret; + + ret = gnttab_alloc_grant_references(count, &priv_gref_head); + if (ret < 0) { + pr_err("Cannot allocate grant references, ret %d\n", ret); + return ret; + } + + for (i = 0; i < count; i++) { + int cur_ref; + + cur_ref = gnttab_claim_grant_reference(&priv_gref_head); + if (cur_ref < 0) { + ret = cur_ref; + pr_err("Cannot claim grant reference, ret %d\n", ret); + goto out; + } + + gnttab_grant_foreign_access_ref(cur_ref, domid, + xen_page_to_gfn(pages[i]), 0); + refs[i] = cur_ref; + } + + ret = 0; + +out: + gnttab_free_grant_references(priv_gref_head); + return ret; +} + +static void dmabuf_imp_end_foreign_access(u32 *refs, int count) +{ + int i; + + for (i = 0; i < count; i++) + if (refs[i] != GRANT_INVALID_REF) + gnttab_end_foreign_access(refs[i], 0, 0UL); +} + +static void dmabuf_imp_free_storage(struct gntdev_dmabuf *gntdev_dmabuf) +{ + kfree(gntdev_dmabuf->pages); + kfree(gntdev_dmabuf->u.imp.refs); + kfree(gntdev_dmabuf); +} + +static struct gntdev_dmabuf *dmabuf_imp_alloc_storage(int count) +{ + struct gntdev_dmabuf *gntdev_dmabuf; + int i; + + gntdev_dmabuf = kzalloc(sizeof(*gntdev_dmabuf), GFP_KERNEL); + if (!gntdev_dmabuf) + goto fail; + + gntdev_dmabuf->u.imp.refs = kcalloc(count, + sizeof(gntdev_dmabuf->u.imp.refs[0]), + GFP_KERNEL); + if (!gntdev_dmabuf->u.imp.refs) + goto fail; + + gntdev_dmabuf->pages = kcalloc(count, + sizeof(gntdev_dmabuf->pages[0]), + GFP_KERNEL); + if (!gntdev_dmabuf->pages) + goto fail; + + gntdev_dmabuf->nr_pages = count; + + for (i = 0; i < count; i++) + gntdev_dmabuf->u.imp.refs[i] = GRANT_INVALID_REF; + + return gntdev_dmabuf; + +fail: + dmabuf_imp_free_storage(gntdev_dmabuf); + return ERR_PTR(-ENOMEM); +} + struct gntdev_dmabuf * gntdev_dmabuf_imp_to_refs(struct gntdev_dmabuf_priv *priv, struct device *dev, int fd, int count, int domid) { - return ERR_PTR(-ENOMEM); + struct gntdev_dmabuf *gntdev_dmabuf, *ret; + struct dma_buf *dma_buf; + struct dma_buf_attachment *attach; + struct sg_table *sgt; + struct sg_page_iter sg_iter; + int i; + + dma_buf = dma_buf_get(fd); + if (IS_ERR(dma_buf)) + return ERR_CAST(dma_buf); + + gntdev_dmabuf = dmabuf_imp_alloc_storage(count); + if (IS_ERR(gntdev_dmabuf)) { + ret = gntdev_dmabuf; + goto fail_put; +} + + gntdev_dmabuf->priv = priv; + gntdev_dmabuf->fd = fd; + + attach = dma_buf_attach(dma_buf, dev); + if (IS_ERR(attach)) { + ret = ERR_CAST(attach); + goto fail_free_obj; + } + + gntdev_dmabuf->u.imp.attach = attach; + + sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL); + if (IS_ERR(sgt)) { + ret = ERR_CAST(sgt); + goto fail_detach; + } + + /* Check number of pages that imported buffer has. */ + if (attach->dmabuf->size != gntdev_dmabuf->nr_pages << PAGE_SHIFT) { + ret = ERR_PTR(-EINVAL); + pr_err("DMA buffer has %zu pages, user-space expects %d\n", + attach->dmabuf->size, gntdev_dmabuf->nr_pages); + goto fail_unmap; + } + + gntdev_dmabuf->u.imp.sgt = sgt; + + /* Now convert sgt to array of pages and check for page validity. */ + i = 0; + for_each_sg_page(sgt->sgl, &sg_iter, sgt->nents, 0) { + struct page *page = sg_page_iter_page(&sg_iter); + /* + * Check if page is valid: this can happen if we are given + * a page from VRAM or other resources which are not backed + * by a struct page. + */ + if (!pfn_valid(page_to_pfn(page))) { + ret = ERR_PTR(-EINVAL); + goto fail_unmap; + } + + gntdev_dmabuf->pages[i++] = page; + } + + ret = ERR_PTR(dmabuf_imp_grant_foreign_access(gntdev_dmabuf->pages, + gntdev_dmabuf->u.imp.refs, + count, domid)); + if (IS_ERR(ret)) + goto fail_end_access; + + pr_debug("Imported DMA buffer with fd %d\n", fd); + + mutex_lock(&priv->lock); + list_add(&gntdev_dmabuf->next, &priv->imp_list); + mutex_unlock(&priv->lock); + + return gntdev_dmabuf; + +fail_end_access: + dmabuf_imp_end_foreign_access(gntdev_dmabuf->u.imp.refs, count); +fail_unmap: + dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL); +fail_detach: + dma_buf_detach(dma_buf, attach); +fail_free_obj: + dmabuf_imp_free_storage(gntdev_dmabuf); +fail_put: + dma_buf_put(dma_buf); + return ret; } u32 *gntdev_dmabuf_imp_get_refs(struct gntdev_dmabuf *gntdev_dmabuf) { + if (gntdev_dmabuf) + return gntdev_dmabuf->u.imp.refs; + return NULL; } +/* + * Find the hyper dma-buf by its file descriptor and remove + * it from the buffer's list. + */ +static struct gntdev_dmabuf * +dmabuf_imp_find_unlink(struct gntdev_dmabuf_priv *priv, int fd) +{ + struct gntdev_dmabuf *q, *gntdev_dmabuf, *ret = ERR_PTR(-ENOENT); + + mutex_lock(&priv->lock); + list_for_each_entry_safe(gntdev_dmabuf, q, &priv->imp_list, next) { + if (gntdev_dmabuf->fd == fd) { + pr_debug("Found gntdev_dmabuf in the import list\n"); + ret = gntdev_dmabuf; + list_del(&gntdev_dmabuf->next); + break; + } + } + mutex_unlock(&priv->lock); + return ret; +} + int gntdev_dmabuf_imp_release(struct gntdev_dmabuf_priv *priv, u32 fd) { - return -EINVAL; + struct gntdev_dmabuf *gntdev_dmabuf; + struct dma_buf_attachment *attach; + struct dma_buf *dma_buf; + + gntdev_dmabuf = dmabuf_imp_find_unlink(priv, fd); + if (IS_ERR(gntdev_dmabuf)) + return PTR_ERR(gntdev_dmabuf); + + pr_debug("Releasing DMA buffer with fd %d\n", fd); + + attach = gntdev_dmabuf->u.imp.attach; + + if (gntdev_dmabuf->u.imp.sgt) + dma_buf_unmap_attachment(attach, gntdev_dmabuf->u.imp.sgt, + DMA_BIDIRECTIONAL); + dma_buf = attach->dmabuf; + dma_buf_detach(attach->dmabuf, attach); + dma_buf_put(dma_buf); + + dmabuf_imp_end_foreign_access(gntdev_dmabuf->u.imp.refs, + gntdev_dmabuf->nr_pages); + dmabuf_imp_free_storage(gntdev_dmabuf); + return 0; } struct gntdev_dmabuf_priv *gntdev_dmabuf_init(void) @@ -452,6 +690,7 @@ struct gntdev_dmabuf_priv *gntdev_dmabuf_init(void) mutex_init(&priv->lock); INIT_LIST_HEAD(&priv->exp_list); INIT_LIST_HEAD(&priv->exp_wait_list); + INIT_LIST_HEAD(&priv->imp_list); return priv; } -- 2.17.0