From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v4 9/9] xen/gntdev: Implement dma-buf import functionality Date: Fri, 15 Jun 2018 09:27:53 +0300 Message-ID: <20180615062753.9229-10-andr2000@gmail.com> References: <20180615062753.9229-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-x244.google.com (mail-lf0-x244.google.com [IPv6:2a00:1450:4010:c07::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id 427F96E98A for ; Fri, 15 Jun 2018 06:28:18 +0000 (UTC) Received: by mail-lf0-x244.google.com with SMTP id d24-v6so12984119lfa.8 for ; Thu, 14 Jun 2018 23:28:18 -0700 (PDT) In-Reply-To: <20180615062753.9229-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 aGNoZW5rb0BlcGFtLmNvbT4KLS0tCiBkcml2ZXJzL3hlbi9nbnRkZXYtZG1hYnVmLmMgfCAyMzkg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiAxIGZpbGUgY2hhbmdlZCwgMjM0 IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4v Z250ZGV2LWRtYWJ1Zi5jIGIvZHJpdmVycy94ZW4vZ250ZGV2LWRtYWJ1Zi5jCmluZGV4IDA3YTk4 YWE1MmNhYi4uZGUxZjMyMDI2MjAzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3hlbi9nbnRkZXYtZG1h YnVmLmMKKysrIGIvZHJpdmVycy94ZW4vZ250ZGV2LWRtYWJ1Zi5jCkBAIC0yMSw2ICsyMSwxNSBA QAogI2luY2x1ZGUgImdudGRldi1jb21tb24uaCIKICNpbmNsdWRlICJnbnRkZXYtZG1hYnVmLmgi CiAKKyNpZm5kZWYgR1JBTlRfSU5WQUxJRF9SRUYKKy8qCisgKiBOb3RlIG9uIHVzYWdlIG9mIGdy YW50IHJlZmVyZW5jZSAwIGFzIGludmFsaWQgZ3JhbnQgcmVmZXJlbmNlOgorICogZ3JhbnQgcmVm ZXJlbmNlIDAgaXMgdmFsaWQsIGJ1dCBuZXZlciBleHBvc2VkIHRvIGEgZHJpdmVyLAorICogYmVj YXVzZSBvZiB0aGUgZmFjdCBpdCBpcyBhbHJlYWR5IGluIHVzZS9yZXNlcnZlZCBieSB0aGUgUFYg Y29uc29sZS4KKyAqLworI2RlZmluZSBHUkFOVF9JTlZBTElEX1JFRgkwCisjZW5kaWYKKwogc3Ry dWN0IGdudGRldl9kbWFidWYgewogCXN0cnVjdCBnbnRkZXZfZG1hYnVmX3ByaXYgKnByaXY7CiAJ c3RydWN0IGRtYV9idWYgKmRtYWJ1ZjsKQEAgLTM1LDYgKzQ0LDE0IEBAIHN0cnVjdCBnbnRkZXZf ZG1hYnVmIHsKIAkJCXN0cnVjdCBnbnRkZXZfcHJpdiAqcHJpdjsKIAkJCXN0cnVjdCBnbnRkZXZf Z3JhbnRfbWFwICptYXA7CiAJCX0gZXhwOworCQlzdHJ1Y3QgeworCQkJLyogR3JhbnRlZCByZWZl cmVuY2VzIG9mIHRoZSBpbXBvcnRlZCBidWZmZXIuICovCisJCQlncmFudF9yZWZfdCAqcmVmczsK KwkJCS8qIFNjYXR0ZXItZ2F0aGVyIHRhYmxlIG9mIHRoZSBpbXBvcnRlZCBidWZmZXIuICovCisJ CQlzdHJ1Y3Qgc2dfdGFibGUgKnNndDsKKwkJCS8qIGRtYS1idWYgYXR0YWNobWVudCBvZiB0aGUg aW1wb3J0ZWQgYnVmZmVyLiAqLworCQkJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNo OworCQl9IGltcDsKIAl9IHU7CiAKIAkvKiBOdW1iZXIgb2YgcGFnZXMgdGhpcyBidWZmZXIgaGFz LiAqLwpAQCAtNTksNiArNzYsOCBAQCBzdHJ1Y3QgZ250ZGV2X2RtYWJ1Zl9wcml2IHsKIAlzdHJ1 Y3QgbGlzdF9oZWFkIGV4cF9saXN0OwogCS8qIExpc3Qgb2Ygd2FpdCBvYmplY3RzLiAqLwogCXN0 cnVjdCBsaXN0X2hlYWQgZXhwX3dhaXRfbGlzdDsKKwkvKiBMaXN0IG9mIGltcG9ydGVkIERNQSBi dWZmZXJzLiAqLworCXN0cnVjdCBsaXN0X2hlYWQgaW1wX2xpc3Q7CiAJLyogVGhpcyBpcyB0aGUg bG9jayB3aGljaCBwcm90ZWN0cyBkbWFfYnVmX3h4eCBsaXN0cy4gKi8KIAlzdHJ1Y3QgbXV0ZXgg bG9jazsKIH07CkBAIC01MDYsMjEgKzUyNSwyMzAgQEAgc3RhdGljIGludCBkbWFidWZfZXhwX2Zy b21fcmVmcyhzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYsIGludCBmbGFncywKIAogLyogRE1BIGJ1 ZmZlciBpbXBvcnQgc3VwcG9ydC4gKi8KIAorc3RhdGljIGludAorZG1hYnVmX2ltcF9ncmFudF9m b3JlaWduX2FjY2VzcyhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCB1MzIgKnJlZnMsCisJCQkJaW50IGNv dW50LCBpbnQgZG9taWQpCit7CisJZ3JhbnRfcmVmX3QgcHJpdl9ncmVmX2hlYWQ7CisJaW50IGks IHJldDsKKworCXJldCA9IGdudHRhYl9hbGxvY19ncmFudF9yZWZlcmVuY2VzKGNvdW50LCAmcHJp dl9ncmVmX2hlYWQpOworCWlmIChyZXQgPCAwKSB7CisJCXByX2RlYnVnKCJDYW5ub3QgYWxsb2Nh dGUgZ3JhbnQgcmVmZXJlbmNlcywgcmV0ICVkXG4iLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0K KworCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7CisJCWludCBjdXJfcmVmOworCisJCWN1 cl9yZWYgPSBnbnR0YWJfY2xhaW1fZ3JhbnRfcmVmZXJlbmNlKCZwcml2X2dyZWZfaGVhZCk7CisJ CWlmIChjdXJfcmVmIDwgMCkgeworCQkJcmV0ID0gY3VyX3JlZjsKKwkJCXByX2RlYnVnKCJDYW5u b3QgY2xhaW0gZ3JhbnQgcmVmZXJlbmNlLCByZXQgJWRcbiIsIHJldCk7CisJCQlnb3RvIG91dDsK KwkJfQorCisJCWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzc19yZWYoY3VyX3JlZiwgZG9taWQs CisJCQkJCQl4ZW5fcGFnZV90b19nZm4ocGFnZXNbaV0pLCAwKTsKKwkJcmVmc1tpXSA9IGN1cl9y ZWY7CisJfQorCisJcmV0dXJuIDA7CisKK291dDoKKwlnbnR0YWJfZnJlZV9ncmFudF9yZWZlcmVu Y2VzKHByaXZfZ3JlZl9oZWFkKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBkbWFi dWZfaW1wX2VuZF9mb3JlaWduX2FjY2Vzcyh1MzIgKnJlZnMsIGludCBjb3VudCkKK3sKKwlpbnQg aTsKKworCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKQorCQlpZiAocmVmc1tpXSAhPSBHUkFO VF9JTlZBTElEX1JFRikKKwkJCWdudHRhYl9lbmRfZm9yZWlnbl9hY2Nlc3MocmVmc1tpXSwgMCwg MFVMKTsKK30KKworc3RhdGljIHZvaWQgZG1hYnVmX2ltcF9mcmVlX3N0b3JhZ2Uoc3RydWN0IGdu dGRldl9kbWFidWYgKmdudGRldl9kbWFidWYpCit7CisJa2ZyZWUoZ250ZGV2X2RtYWJ1Zi0+cGFn ZXMpOworCWtmcmVlKGdudGRldl9kbWFidWYtPnUuaW1wLnJlZnMpOworCWtmcmVlKGdudGRldl9k bWFidWYpOworfQorCitzdGF0aWMgc3RydWN0IGdudGRldl9kbWFidWYgKmRtYWJ1Zl9pbXBfYWxs b2Nfc3RvcmFnZShpbnQgY291bnQpCit7CisJc3RydWN0IGdudGRldl9kbWFidWYgKmdudGRldl9k bWFidWY7CisJaW50IGk7CisKKwlnbnRkZXZfZG1hYnVmID0ga3phbGxvYyhzaXplb2YoKmdudGRl dl9kbWFidWYpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWdudGRldl9kbWFidWYpCisJCWdvdG8gZmFp bDsKKworCWdudGRldl9kbWFidWYtPnUuaW1wLnJlZnMgPSBrY2FsbG9jKGNvdW50LAorCQkJCQkg ICAgc2l6ZW9mKGdudGRldl9kbWFidWYtPnUuaW1wLnJlZnNbMF0pLAorCQkJCQkgICAgR0ZQX0tF Uk5FTCk7CisJaWYgKCFnbnRkZXZfZG1hYnVmLT51LmltcC5yZWZzKQorCQlnb3RvIGZhaWw7CisK KwlnbnRkZXZfZG1hYnVmLT5wYWdlcyA9IGtjYWxsb2MoY291bnQsCisJCQkJICAgICAgIHNpemVv ZihnbnRkZXZfZG1hYnVmLT5wYWdlc1swXSksCisJCQkJICAgICAgIEdGUF9LRVJORUwpOworCWlm ICghZ250ZGV2X2RtYWJ1Zi0+cGFnZXMpCisJCWdvdG8gZmFpbDsKKworCWdudGRldl9kbWFidWYt Pm5yX3BhZ2VzID0gY291bnQ7CisKKwlmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykKKwkJZ250 ZGV2X2RtYWJ1Zi0+dS5pbXAucmVmc1tpXSA9IEdSQU5UX0lOVkFMSURfUkVGOworCisJcmV0dXJu IGdudGRldl9kbWFidWY7CisKK2ZhaWw6CisJZG1hYnVmX2ltcF9mcmVlX3N0b3JhZ2UoZ250ZGV2 X2RtYWJ1Zik7CisJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Cit9CisKIHN0YXRpYyBzdHJ1Y3Qg Z250ZGV2X2RtYWJ1ZiAqCiBkbWFidWZfaW1wX3RvX3JlZnMoc3RydWN0IGdudGRldl9kbWFidWZf cHJpdiAqcHJpdiwgc3RydWN0IGRldmljZSAqZGV2LAogCQkgICBpbnQgZmQsIGludCBjb3VudCwg aW50IGRvbWlkKQogewotCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCXN0cnVjdCBnbnRkZXZf ZG1hYnVmICpnbnRkZXZfZG1hYnVmLCAqcmV0OworCXN0cnVjdCBkbWFfYnVmICpkbWFfYnVmOwor CXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaDsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnNn dDsKKwlzdHJ1Y3Qgc2dfcGFnZV9pdGVyIHNnX2l0ZXI7CisJaW50IGk7CisKKwlkbWFfYnVmID0g ZG1hX2J1Zl9nZXQoZmQpOworCWlmIChJU19FUlIoZG1hX2J1ZikpCisJCXJldHVybiBFUlJfQ0FT VChkbWFfYnVmKTsKKworCWdudGRldl9kbWFidWYgPSBkbWFidWZfaW1wX2FsbG9jX3N0b3JhZ2Uo Y291bnQpOworCWlmIChJU19FUlIoZ250ZGV2X2RtYWJ1ZikpIHsKKwkJcmV0ID0gZ250ZGV2X2Rt YWJ1ZjsKKwkJZ290byBmYWlsX3B1dDsKKwl9CisKKwlnbnRkZXZfZG1hYnVmLT5wcml2ID0gcHJp djsKKwlnbnRkZXZfZG1hYnVmLT5mZCA9IGZkOworCisJYXR0YWNoID0gZG1hX2J1Zl9hdHRhY2go ZG1hX2J1ZiwgZGV2KTsKKwlpZiAoSVNfRVJSKGF0dGFjaCkpIHsKKwkJcmV0ID0gRVJSX0NBU1Qo YXR0YWNoKTsKKwkJZ290byBmYWlsX2ZyZWVfb2JqOworCX0KKworCWdudGRldl9kbWFidWYtPnUu aW1wLmF0dGFjaCA9IGF0dGFjaDsKKworCXNndCA9IGRtYV9idWZfbWFwX2F0dGFjaG1lbnQoYXR0 YWNoLCBETUFfQklESVJFQ1RJT05BTCk7CisJaWYgKElTX0VSUihzZ3QpKSB7CisJCXJldCA9IEVS Ul9DQVNUKHNndCk7CisJCWdvdG8gZmFpbF9kZXRhY2g7CisJfQorCisJLyogQ2hlY2sgbnVtYmVy IG9mIHBhZ2VzIHRoYXQgaW1wb3J0ZWQgYnVmZmVyIGhhcy4gKi8KKwlpZiAoYXR0YWNoLT5kbWFi dWYtPnNpemUgIT0gZ250ZGV2X2RtYWJ1Zi0+bnJfcGFnZXMgPDwgUEFHRV9TSElGVCkgeworCQly ZXQgPSBFUlJfUFRSKC1FSU5WQUwpOworCQlwcl9kZWJ1ZygiRE1BIGJ1ZmZlciBoYXMgJXp1IHBh Z2VzLCB1c2VyLXNwYWNlIGV4cGVjdHMgJWRcbiIsCisJCQkgYXR0YWNoLT5kbWFidWYtPnNpemUs IGdudGRldl9kbWFidWYtPm5yX3BhZ2VzKTsKKwkJZ290byBmYWlsX3VubWFwOworCX0KKworCWdu dGRldl9kbWFidWYtPnUuaW1wLnNndCA9IHNndDsKKworCS8qIE5vdyBjb252ZXJ0IHNndCB0byBh cnJheSBvZiBwYWdlcyBhbmQgY2hlY2sgZm9yIHBhZ2UgdmFsaWRpdHkuICovCisJaSA9IDA7CisJ Zm9yX2VhY2hfc2dfcGFnZShzZ3QtPnNnbCwgJnNnX2l0ZXIsIHNndC0+bmVudHMsIDApIHsKKwkJ c3RydWN0IHBhZ2UgKnBhZ2UgPSBzZ19wYWdlX2l0ZXJfcGFnZSgmc2dfaXRlcik7CisJCS8qCisJ CSAqIENoZWNrIGlmIHBhZ2UgaXMgdmFsaWQ6IHRoaXMgY2FuIGhhcHBlbiBpZiB3ZSBhcmUgZ2l2 ZW4KKwkJICogYSBwYWdlIGZyb20gVlJBTSBvciBvdGhlciByZXNvdXJjZXMgd2hpY2ggYXJlIG5v dCBiYWNrZWQKKwkJICogYnkgYSBzdHJ1Y3QgcGFnZS4KKwkJICovCisJCWlmICghcGZuX3ZhbGlk KHBhZ2VfdG9fcGZuKHBhZ2UpKSkgeworCQkJcmV0ID0gRVJSX1BUUigtRUlOVkFMKTsKKwkJCWdv dG8gZmFpbF91bm1hcDsKKwkJfQorCisJCWdudGRldl9kbWFidWYtPnBhZ2VzW2krK10gPSBwYWdl OworCX0KKworCXJldCA9IEVSUl9QVFIoZG1hYnVmX2ltcF9ncmFudF9mb3JlaWduX2FjY2Vzcyhn bnRkZXZfZG1hYnVmLT5wYWdlcywKKwkJCQkJCSAgICAgIGdudGRldl9kbWFidWYtPnUuaW1wLnJl ZnMsCisJCQkJCQkgICAgICBjb3VudCwgZG9taWQpKTsKKwlpZiAoSVNfRVJSKHJldCkpCisJCWdv dG8gZmFpbF9lbmRfYWNjZXNzOworCisJcHJfZGVidWcoIkltcG9ydGVkIERNQSBidWZmZXIgd2l0 aCBmZCAlZFxuIiwgZmQpOworCisJbXV0ZXhfbG9jaygmcHJpdi0+bG9jayk7CisJbGlzdF9hZGQo JmdudGRldl9kbWFidWYtPm5leHQsICZwcml2LT5pbXBfbGlzdCk7CisJbXV0ZXhfdW5sb2NrKCZw cml2LT5sb2NrKTsKKworCXJldHVybiBnbnRkZXZfZG1hYnVmOworCitmYWlsX2VuZF9hY2Nlc3M6 CisJZG1hYnVmX2ltcF9lbmRfZm9yZWlnbl9hY2Nlc3MoZ250ZGV2X2RtYWJ1Zi0+dS5pbXAucmVm cywgY291bnQpOworZmFpbF91bm1hcDoKKwlkbWFfYnVmX3VubWFwX2F0dGFjaG1lbnQoYXR0YWNo LCBzZ3QsIERNQV9CSURJUkVDVElPTkFMKTsKK2ZhaWxfZGV0YWNoOgorCWRtYV9idWZfZGV0YWNo KGRtYV9idWYsIGF0dGFjaCk7CitmYWlsX2ZyZWVfb2JqOgorCWRtYWJ1Zl9pbXBfZnJlZV9zdG9y YWdlKGdudGRldl9kbWFidWYpOworZmFpbF9wdXQ6CisJZG1hX2J1Zl9wdXQoZG1hX2J1Zik7CisJ cmV0dXJuIHJldDsKIH0KIAotc3RhdGljIHUzMiAqZG1hYnVmX2ltcF9nZXRfcmVmcyhzdHJ1Y3Qg Z250ZGV2X2RtYWJ1ZiAqZ250ZGV2X2RtYWJ1ZikKKy8qCisgKiBGaW5kIHRoZSBoeXBlciBkbWEt YnVmIGJ5IGl0cyBmaWxlIGRlc2NyaXB0b3IgYW5kIHJlbW92ZQorICogaXQgZnJvbSB0aGUgYnVm ZmVyJ3MgbGlzdC4KKyAqLworc3RhdGljIHN0cnVjdCBnbnRkZXZfZG1hYnVmICoKK2RtYWJ1Zl9p bXBfZmluZF91bmxpbmsoc3RydWN0IGdudGRldl9kbWFidWZfcHJpdiAqcHJpdiwgaW50IGZkKQog ewotCXJldHVybiBOVUxMOworCXN0cnVjdCBnbnRkZXZfZG1hYnVmICpxLCAqZ250ZGV2X2RtYWJ1 ZiwgKnJldCA9IEVSUl9QVFIoLUVOT0VOVCk7CisKKwltdXRleF9sb2NrKCZwcml2LT5sb2NrKTsK KwlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoZ250ZGV2X2RtYWJ1ZiwgcSwgJnByaXYtPmltcF9s aXN0LCBuZXh0KSB7CisJCWlmIChnbnRkZXZfZG1hYnVmLT5mZCA9PSBmZCkgeworCQkJcHJfZGVi dWcoIkZvdW5kIGdudGRldl9kbWFidWYgaW4gdGhlIGltcG9ydCBsaXN0XG4iKTsKKwkJCXJldCA9 IGdudGRldl9kbWFidWY7CisJCQlsaXN0X2RlbCgmZ250ZGV2X2RtYWJ1Zi0+bmV4dCk7CisJCQli cmVhazsKKwkJfQorCX0KKwltdXRleF91bmxvY2soJnByaXYtPmxvY2spOworCXJldHVybiByZXQ7 CiB9CiAKIHN0YXRpYyBpbnQgZG1hYnVmX2ltcF9yZWxlYXNlKHN0cnVjdCBnbnRkZXZfZG1hYnVm X3ByaXYgKnByaXYsIHUzMiBmZCkKIHsKLQlyZXR1cm4gLUVJTlZBTDsKKwlzdHJ1Y3QgZ250ZGV2 X2RtYWJ1ZiAqZ250ZGV2X2RtYWJ1ZjsKKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRh Y2g7CisJc3RydWN0IGRtYV9idWYgKmRtYV9idWY7CisKKwlnbnRkZXZfZG1hYnVmID0gZG1hYnVm X2ltcF9maW5kX3VubGluayhwcml2LCBmZCk7CisJaWYgKElTX0VSUihnbnRkZXZfZG1hYnVmKSkK KwkJcmV0dXJuIFBUUl9FUlIoZ250ZGV2X2RtYWJ1Zik7CisKKwlwcl9kZWJ1ZygiUmVsZWFzaW5n IERNQSBidWZmZXIgd2l0aCBmZCAlZFxuIiwgZmQpOworCisJZG1hYnVmX2ltcF9lbmRfZm9yZWln bl9hY2Nlc3MoZ250ZGV2X2RtYWJ1Zi0+dS5pbXAucmVmcywKKwkJCQkgICAgICBnbnRkZXZfZG1h YnVmLT5ucl9wYWdlcyk7CisKKwlhdHRhY2ggPSBnbnRkZXZfZG1hYnVmLT51LmltcC5hdHRhY2g7 CisKKwlpZiAoZ250ZGV2X2RtYWJ1Zi0+dS5pbXAuc2d0KQorCQlkbWFfYnVmX3VubWFwX2F0dGFj aG1lbnQoYXR0YWNoLCBnbnRkZXZfZG1hYnVmLT51LmltcC5zZ3QsCisJCQkJCSBETUFfQklESVJF Q1RJT05BTCk7CisJZG1hX2J1ZiA9IGF0dGFjaC0+ZG1hYnVmOworCWRtYV9idWZfZGV0YWNoKGF0 dGFjaC0+ZG1hYnVmLCBhdHRhY2gpOworCWRtYV9idWZfcHV0KGRtYV9idWYpOworCisJZG1hYnVm X2ltcF9mcmVlX3N0b3JhZ2UoZ250ZGV2X2RtYWJ1Zik7CisJcmV0dXJuIDA7CiB9CiAKIC8qIERN QSBidWZmZXIgSU9DVEwgc3VwcG9ydC4gKi8KQEAgLTU5Nyw3ICs4MjUsNyBAQCBsb25nIGdudGRl dl9pb2N0bF9kbWFidWZfaW1wX3RvX3JlZnMoc3RydWN0IGdudGRldl9wcml2ICpwcml2LAogCWlm IChJU19FUlIoZ250ZGV2X2RtYWJ1ZikpCiAJCXJldHVybiBQVFJfRVJSKGdudGRldl9kbWFidWYp OwogCi0JaWYgKGNvcHlfdG9fdXNlcih1LT5yZWZzLCBkbWFidWZfaW1wX2dldF9yZWZzKGdudGRl dl9kbWFidWYpLAorCWlmIChjb3B5X3RvX3VzZXIodS0+cmVmcywgZ250ZGV2X2RtYWJ1Zi0+dS5p bXAucmVmcywKIAkJCSBzaXplb2YoKnUtPnJlZnMpICogb3AuY291bnQpICE9IDApIHsKIAkJcmV0 ID0gLUVGQVVMVDsKIAkJZ290byBvdXRfcmVsZWFzZTsKQEAgLTYzMSw2ICs4NTksNyBAQCBzdHJ1 Y3QgZ250ZGV2X2RtYWJ1Zl9wcml2ICpnbnRkZXZfZG1hYnVmX2luaXQodm9pZCkKIAltdXRleF9p bml0KCZwcml2LT5sb2NrKTsKIAlJTklUX0xJU1RfSEVBRCgmcHJpdi0+ZXhwX2xpc3QpOwogCUlO SVRfTElTVF9IRUFEKCZwcml2LT5leHBfd2FpdF9saXN0KTsKKwlJTklUX0xJU1RfSEVBRCgmcHJp di0+aW1wX2xpc3QpOwogCiAJcmV0dXJuIHByaXY7CiB9Ci0tIAoyLjE3LjEKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxp c3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNr dG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f68.google.com ([209.85.215.68]:33126 "EHLO mail-lf0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755856AbeFOG2S (ORCPT ); Fri, 15 Jun 2018 02:28:18 -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 v4 9/9] xen/gntdev: Implement dma-buf import functionality Date: Fri, 15 Jun 2018 09:27:53 +0300 Message-Id: <20180615062753.9229-10-andr2000@gmail.com> In-Reply-To: <20180615062753.9229-1-andr2000@gmail.com> References: <20180615062753.9229-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 | 239 +++++++++++++++++++++++++++++++++++- 1 file changed, 234 insertions(+), 5 deletions(-) diff --git a/drivers/xen/gntdev-dmabuf.c b/drivers/xen/gntdev-dmabuf.c index 07a98aa52cab..de1f32026203 100644 --- a/drivers/xen/gntdev-dmabuf.c +++ b/drivers/xen/gntdev-dmabuf.c @@ -21,6 +21,15 @@ #include "gntdev-common.h" #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; @@ -35,6 +44,14 @@ struct gntdev_dmabuf { struct gntdev_priv *priv; struct gntdev_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. */ @@ -59,6 +76,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; }; @@ -506,21 +525,230 @@ static int dmabuf_exp_from_refs(struct gntdev_priv *priv, int flags, /* 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_debug("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_debug("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; + } + + return 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); +} + static struct gntdev_dmabuf * 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_debug("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; } -static u32 *dmabuf_imp_get_refs(struct gntdev_dmabuf *gntdev_dmabuf) +/* + * 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) { - return NULL; + 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; } static int 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); + + dmabuf_imp_end_foreign_access(gntdev_dmabuf->u.imp.refs, + gntdev_dmabuf->nr_pages); + + 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_free_storage(gntdev_dmabuf); + return 0; } /* DMA buffer IOCTL support. */ @@ -597,7 +825,7 @@ long gntdev_ioctl_dmabuf_imp_to_refs(struct gntdev_priv *priv, if (IS_ERR(gntdev_dmabuf)) return PTR_ERR(gntdev_dmabuf); - if (copy_to_user(u->refs, dmabuf_imp_get_refs(gntdev_dmabuf), + if (copy_to_user(u->refs, gntdev_dmabuf->u.imp.refs, sizeof(*u->refs) * op.count) != 0) { ret = -EFAULT; goto out_release; @@ -631,6 +859,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.1