From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 7/8] xen/gntdev: Implement dma-buf import functionality Date: Fri, 25 May 2018 18:33:30 +0300 Message-ID: <20180525153331.31188-8-andr2000@gmail.com> References: <20180525153331.31188-1-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x241.google.com (mail-wm0-x241.google.com [IPv6:2a00:1450:400c:c09::241]) by gabe.freedesktop.org (Postfix) with ESMTPS id 324F66E963 for ; Fri, 25 May 2018 15:33:56 +0000 (UTC) Received: by mail-wm0-x241.google.com with SMTP id f6-v6so15509222wmc.4 for ; Fri, 25 May 2018 08:33:56 -0700 (PDT) In-Reply-To: <20180525153331.31188-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 aGNoZW5rb0BlcGFtLmNvbT4KLS0tCiBkcml2ZXJzL3hlbi9nbnRkZXYuYyB8IDIzNyArKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiAxIGZpbGUgY2hhbmdlZCwgMjM0 IGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4v Z250ZGV2LmMgYi9kcml2ZXJzL3hlbi9nbnRkZXYuYwppbmRleCA1MmFiYzZjZDU4NDYuLmQ4YjYx NjhmMmNkOSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vZ250ZGV2LmMKKysrIGIvZHJpdmVycy94 ZW4vZ250ZGV2LmMKQEAgLTcxLDYgKzcxLDE3IEBAIHN0YXRpYyBhdG9taWNfdCBwYWdlc19tYXBw ZWQgPSBBVE9NSUNfSU5JVCgwKTsKIHN0YXRpYyBpbnQgdXNlX3B0ZW1vZDsKICNkZWZpbmUgcG9w dWxhdGVfZnJlZWFibGVfbWFwcyB1c2VfcHRlbW9kCiAKKyNpZmRlZiBDT05GSUdfWEVOX0dOVERF Vl9ETUFCVUYKKyNpZm5kZWYgR1JBTlRfSU5WQUxJRF9SRUYKKy8qCisgKiBOb3RlIG9uIHVzYWdl IG9mIGdyYW50IHJlZmVyZW5jZSAwIGFzIGludmFsaWQgZ3JhbnQgcmVmZXJlbmNlOgorICogZ3Jh bnQgcmVmZXJlbmNlIDAgaXMgdmFsaWQsIGJ1dCBuZXZlciBleHBvc2VkIHRvIGEgZHJpdmVyLAor ICogYmVjYXVzZSBvZiB0aGUgZmFjdCBpdCBpcyBhbHJlYWR5IGluIHVzZS9yZXNlcnZlZCBieSB0 aGUgUFYgY29uc29sZS4KKyAqLworI2RlZmluZSBHUkFOVF9JTlZBTElEX1JFRgkwCisjZW5kaWYK KyNlbmRpZgorCiBzdHJ1Y3QgZ250ZGV2X3ByaXYgewogCS8qIG1hcHMgd2l0aCB2aXNpYmxlIG9m ZnNldHMgaW4gdGhlIGZpbGUgZGVzY3JpcHRvciAqLwogCXN0cnVjdCBsaXN0X2hlYWQgbWFwczsK QEAgLTk0LDYgKzEwNSw4IEBAIHN0cnVjdCBnbnRkZXZfcHJpdiB7CiAJc3RydWN0IGxpc3RfaGVh ZCBkbWFidWZfZXhwX2xpc3Q7CiAJLyogTGlzdCBvZiB3YWl0IG9iamVjdHMuICovCiAJc3RydWN0 IGxpc3RfaGVhZCBkbWFidWZfZXhwX3dhaXRfbGlzdDsKKwkvKiBMaXN0IG9mIGltcG9ydGVkIERN QSBidWZmZXJzLiAqLworCXN0cnVjdCBsaXN0X2hlYWQgZG1hYnVmX2ltcF9saXN0OwogCS8qIFRo aXMgaXMgdGhlIGxvY2sgd2hpY2ggcHJvdGVjdHMgZG1hX2J1Zl94eHggbGlzdHMuICovCiAJc3Ry dWN0IG11dGV4IGRtYWJ1Zl9sb2NrOwogI2VuZGlmCkBAIC0xNTUsNiArMTY4LDEwIEBAIHN0cnVj dCB4ZW5fZG1hYnVmIHsKIAkJc3RydWN0IHsKIAkJCS8qIEdyYW50ZWQgcmVmZXJlbmNlcyBvZiB0 aGUgaW1wb3J0ZWQgYnVmZmVyLiAqLwogCQkJZ3JhbnRfcmVmX3QgKnJlZnM7CisJCQkvKiBTY2F0 dGVyLWdhdGhlciB0YWJsZSBvZiB0aGUgaW1wb3J0ZWQgYnVmZmVyLiAqLworCQkJc3RydWN0IHNn X3RhYmxlICpzZ3Q7CisJCQkvKiBkbWEtYnVmIGF0dGFjaG1lbnQgb2YgdGhlIGltcG9ydGVkIGJ1 ZmZlci4gKi8KKwkJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaDsKIAkJfSBpbXA7 CiAJfSB1OwogCkBAIC02ODQsNiArNzAxLDcgQEAgc3RhdGljIGludCBnbnRkZXZfb3BlbihzdHJ1 Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmxpcCkKIAltdXRleF9pbml0KCZwcml2LT5k bWFidWZfbG9jayk7CiAJSU5JVF9MSVNUX0hFQUQoJnByaXYtPmRtYWJ1Zl9leHBfbGlzdCk7CiAJ SU5JVF9MSVNUX0hFQUQoJnByaXYtPmRtYWJ1Zl9leHBfd2FpdF9saXN0KTsKKwlJTklUX0xJU1Rf SEVBRCgmcHJpdi0+ZG1hYnVmX2ltcF9saXN0KTsKICNlbmRpZgogCiAJaWYgKHVzZV9wdGVtb2Qp IHsKQEAgLTE1NDQsMTUgKzE1NjIsMjI4IEBAIHN0YXRpYyBpbnQgZG1hYnVmX2V4cF9mcm9tX3Jl ZnMoc3RydWN0IGdudGRldl9wcml2ICpwcml2LCBpbnQgZmxhZ3MsCiAvKiBETUEgYnVmZmVyIGlt cG9ydCBzdXBwb3J0LiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8K IC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLSAqLwogCi1zdGF0aWMgaW50IGRtYWJ1Zl9pbXBfcmVsZWFzZShzdHJ1Y3Qg Z250ZGV2X3ByaXYgKnByaXYsIHUzMiBmZCkKK3N0YXRpYyBpbnQKK2RtYWJ1Zl9pbXBfZ3JhbnRf Zm9yZWlnbl9hY2Nlc3Moc3RydWN0IHBhZ2UgKipwYWdlcywgdTMyICpyZWZzLAorCQkJCWludCBj b3VudCwgaW50IGRvbWlkKQogewotCXJldHVybiAwOworCWdyYW50X3JlZl90IHByaXZfZ3JlZl9o ZWFkOworCWludCBpLCByZXQ7CisKKwlyZXQgPSBnbnR0YWJfYWxsb2NfZ3JhbnRfcmVmZXJlbmNl cyhjb3VudCwgJnByaXZfZ3JlZl9oZWFkKTsKKwlpZiAocmV0IDwgMCkgeworCQlwcl9lcnIoIkNh bm5vdCBhbGxvY2F0ZSBncmFudCByZWZlcmVuY2VzLCByZXQgJWRcbiIsIHJldCk7CisJCXJldHVy biByZXQ7CisJfQorCisJZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKKwkJaW50IGN1cl9y ZWY7CisKKwkJY3VyX3JlZiA9IGdudHRhYl9jbGFpbV9ncmFudF9yZWZlcmVuY2UoJnByaXZfZ3Jl Zl9oZWFkKTsKKwkJaWYgKGN1cl9yZWYgPCAwKSB7CisJCQlyZXQgPSBjdXJfcmVmOworCQkJcHJf ZXJyKCJDYW5ub3QgY2xhaW0gZ3JhbnQgcmVmZXJlbmNlLCByZXQgJWRcbiIsIHJldCk7CisJCQln b3RvIG91dDsKKwkJfQorCisJCWdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzc19yZWYoY3VyX3Jl ZiwgZG9taWQsCisJCQkJCQl4ZW5fcGFnZV90b19nZm4ocGFnZXNbaV0pLCAwKTsKKwkJcmVmc1tp XSA9IGN1cl9yZWY7CisJfQorCisJcmV0ID0gMDsKKworb3V0OgorCWdudHRhYl9mcmVlX2dyYW50 X3JlZmVyZW5jZXMocHJpdl9ncmVmX2hlYWQpOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2 b2lkIGRtYWJ1Zl9pbXBfZW5kX2ZvcmVpZ25fYWNjZXNzKHUzMiAqcmVmcywgaW50IGNvdW50KQor eworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspCisJCWlmIChyZWZzW2ld ICE9IEdSQU5UX0lOVkFMSURfUkVGKQorCQkJZ250dGFiX2VuZF9mb3JlaWduX2FjY2VzcyhyZWZz W2ldLCAwLCAwVUwpOworfQorCitzdGF0aWMgdm9pZCBkbWFidWZfaW1wX2ZyZWVfc3RvcmFnZShz dHJ1Y3QgeGVuX2RtYWJ1ZiAqeGVuX2RtYWJ1ZikKK3sKKwlrZnJlZSh4ZW5fZG1hYnVmLT5wYWdl cyk7CisJa2ZyZWUoeGVuX2RtYWJ1Zi0+dS5pbXAucmVmcyk7CisJa2ZyZWUoeGVuX2RtYWJ1Zik7 Cit9CisKK3N0YXRpYyBzdHJ1Y3QgeGVuX2RtYWJ1ZiAqZG1hYnVmX2ltcF9hbGxvY19zdG9yYWdl KGludCBjb3VudCkKK3sKKwlzdHJ1Y3QgeGVuX2RtYWJ1ZiAqeGVuX2RtYWJ1ZjsKKwlpbnQgaTsK KworCXhlbl9kbWFidWYgPSBremFsbG9jKHNpemVvZigqeGVuX2RtYWJ1ZiksIEdGUF9LRVJORUwp OworCWlmICgheGVuX2RtYWJ1ZikKKwkJZ290byBmYWlsOworCisJeGVuX2RtYWJ1Zi0+dS5pbXAu cmVmcyA9IGtjYWxsb2MoY291bnQsCisJCQkJCSBzaXplb2YoeGVuX2RtYWJ1Zi0+dS5pbXAucmVm c1swXSksCisJCQkJCSBHRlBfS0VSTkVMKTsKKwlpZiAoIXhlbl9kbWFidWYtPnUuaW1wLnJlZnMp CisJCWdvdG8gZmFpbDsKKworCXhlbl9kbWFidWYtPnBhZ2VzID0ga2NhbGxvYyhjb3VudCwKKwkJ CQkgICAgc2l6ZW9mKHhlbl9kbWFidWYtPnBhZ2VzWzBdKSwKKwkJCQkgICAgR0ZQX0tFUk5FTCk7 CisJaWYgKCF4ZW5fZG1hYnVmLT5wYWdlcykKKwkJZ290byBmYWlsOworCisJeGVuX2RtYWJ1Zi0+ bnJfcGFnZXMgPSBjb3VudDsKKworCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKQorCQl4ZW5f ZG1hYnVmLT51LmltcC5yZWZzW2ldID0gR1JBTlRfSU5WQUxJRF9SRUY7CisKKwlyZXR1cm4geGVu X2RtYWJ1ZjsKKworZmFpbDoKKwlkbWFidWZfaW1wX2ZyZWVfc3RvcmFnZSh4ZW5fZG1hYnVmKTsK KwlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKIH0KIAogc3RhdGljIHN0cnVjdCB4ZW5fZG1hYnVm ICoKIGRtYWJ1Zl9pbXBfdG9fcmVmcyhzdHJ1Y3QgZ250ZGV2X3ByaXYgKnByaXYsIGludCBmZCwg aW50IGNvdW50LCBpbnQgZG9taWQpCiB7Ci0JcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisJc3Ry dWN0IHhlbl9kbWFidWYgKnhlbl9kbWFidWYsICpyZXQ7CisJc3RydWN0IGRtYV9idWYgKmRtYV9i dWY7CisJc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoOworCXN0cnVjdCBzZ190YWJs ZSAqc2d0OworCXN0cnVjdCBzZ19wYWdlX2l0ZXIgc2dfaXRlcjsKKwlpbnQgaTsKKworCWRtYV9i dWYgPSBkbWFfYnVmX2dldChmZCk7CisJaWYgKElTX0VSUihkbWFfYnVmKSkKKwkJcmV0dXJuIEVS Ul9DQVNUKGRtYV9idWYpOworCisJeGVuX2RtYWJ1ZiA9IGRtYWJ1Zl9pbXBfYWxsb2Nfc3RvcmFn ZShjb3VudCk7CisJaWYgKElTX0VSUih4ZW5fZG1hYnVmKSkgeworCQlyZXQgPSB4ZW5fZG1hYnVm OworCQlnb3RvIGZhaWxfcHV0OworCX0KKworCXhlbl9kbWFidWYtPnByaXYgPSBwcml2OworCXhl bl9kbWFidWYtPmZkID0gZmQ7CisKKwlhdHRhY2ggPSBkbWFfYnVmX2F0dGFjaChkbWFfYnVmLCBw cml2LT5kbWFfZGV2KTsKKwlpZiAoSVNfRVJSKGF0dGFjaCkpIHsKKwkJcmV0ID0gRVJSX0NBU1Qo YXR0YWNoKTsKKwkJZ290byBmYWlsX2ZyZWVfb2JqOworCX0KKworCXhlbl9kbWFidWYtPnUuaW1w LmF0dGFjaCA9IGF0dGFjaDsKKworCXNndCA9IGRtYV9idWZfbWFwX2F0dGFjaG1lbnQoYXR0YWNo LCBETUFfQklESVJFQ1RJT05BTCk7CisJaWYgKElTX0VSUihzZ3QpKSB7CisJCXJldCA9IEVSUl9D QVNUKHNndCk7CisJCWdvdG8gZmFpbF9kZXRhY2g7CisJfQorCisJLyogQ2hlY2sgbnVtYmVyIG9m IHBhZ2VzIHRoYXQgaW1wb3J0ZWQgYnVmZmVyIGhhcy4gKi8KKwlpZiAoYXR0YWNoLT5kbWFidWYt PnNpemUgIT0geGVuX2RtYWJ1Zi0+bnJfcGFnZXMgPDwgUEFHRV9TSElGVCkgeworCQlyZXQgPSBF UlJfUFRSKC1FSU5WQUwpOworCQlwcl9lcnIoIkRNQSBidWZmZXIgaGFzICV6dSBwYWdlcywgdXNl ci1zcGFjZSBleHBlY3RzICVkXG4iLAorCQkgICAgICAgYXR0YWNoLT5kbWFidWYtPnNpemUsIHhl bl9kbWFidWYtPm5yX3BhZ2VzKTsKKwkJZ290byBmYWlsX3VubWFwOworCX0KKworCXhlbl9kbWFi dWYtPnUuaW1wLnNndCA9IHNndDsKKworCS8qIE5vdyBjb252ZXJ0IHNndCB0byBhcnJheSBvZiBw YWdlcyBhbmQgY2hlY2sgZm9yIHBhZ2UgdmFsaWRpdHkuICovCisJaSA9IDA7CisJZm9yX2VhY2hf c2dfcGFnZShzZ3QtPnNnbCwgJnNnX2l0ZXIsIHNndC0+bmVudHMsIDApIHsKKwkJc3RydWN0IHBh Z2UgKnBhZ2UgPSBzZ19wYWdlX2l0ZXJfcGFnZSgmc2dfaXRlcik7CisJCS8qCisJCSAqIENoZWNr IGlmIHBhZ2UgaXMgdmFsaWQ6IHRoaXMgY2FuIGhhcHBlbiBpZiB3ZSBhcmUgZ2l2ZW4KKwkJICog YSBwYWdlIGZyb20gVlJBTSBvciBvdGhlciByZXNvdXJjZXMgd2hpY2ggYXJlIG5vdCBiYWNrZWQK KwkJICogYnkgYSBzdHJ1Y3QgcGFnZS4KKwkJICovCisJCWlmICghcGZuX3ZhbGlkKHBhZ2VfdG9f cGZuKHBhZ2UpKSkgeworCQkJcmV0ID0gRVJSX1BUUigtRUlOVkFMKTsKKwkJCWdvdG8gZmFpbF91 bm1hcDsKKwkJfQorCisJCXhlbl9kbWFidWYtPnBhZ2VzW2krK10gPSBwYWdlOworCX0KKworCXJl dCA9IEVSUl9QVFIoZG1hYnVmX2ltcF9ncmFudF9mb3JlaWduX2FjY2Vzcyh4ZW5fZG1hYnVmLT5w YWdlcywKKwkJCQkJCSAgICAgIHhlbl9kbWFidWYtPnUuaW1wLnJlZnMsCisJCQkJCQkgICAgICBj b3VudCwgZG9taWQpKTsKKwlpZiAoSVNfRVJSKHJldCkpCisJCWdvdG8gZmFpbF9lbmRfYWNjZXNz OworCisJcHJfZGVidWcoIkltcG9ydGVkIERNQSBidWZmZXIgd2l0aCBmZCAlZFxuIiwgZmQpOwor CisJbXV0ZXhfbG9jaygmcHJpdi0+ZG1hYnVmX2xvY2spOworCWxpc3RfYWRkKCZ4ZW5fZG1hYnVm LT5uZXh0LCAmcHJpdi0+ZG1hYnVmX2ltcF9saXN0KTsKKwltdXRleF91bmxvY2soJnByaXYtPmRt YWJ1Zl9sb2NrKTsKKworCXJldHVybiB4ZW5fZG1hYnVmOworCitmYWlsX2VuZF9hY2Nlc3M6CisJ ZG1hYnVmX2ltcF9lbmRfZm9yZWlnbl9hY2Nlc3MoeGVuX2RtYWJ1Zi0+dS5pbXAucmVmcywgY291 bnQpOworZmFpbF91bm1hcDoKKwlkbWFfYnVmX3VubWFwX2F0dGFjaG1lbnQoYXR0YWNoLCBzZ3Qs IERNQV9CSURJUkVDVElPTkFMKTsKK2ZhaWxfZGV0YWNoOgorCWRtYV9idWZfZGV0YWNoKGRtYV9i dWYsIGF0dGFjaCk7CitmYWlsX2ZyZWVfb2JqOgorCWRtYWJ1Zl9pbXBfZnJlZV9zdG9yYWdlKHhl bl9kbWFidWYpOworZmFpbF9wdXQ6CisJZG1hX2J1Zl9wdXQoZG1hX2J1Zik7CisJcmV0dXJuIHJl dDsKK30KKworLyoKKyAqIEZpbmQgdGhlIGh5cGVyIGRtYS1idWYgYnkgaXRzIGZpbGUgZGVzY3Jp cHRvciBhbmQgcmVtb3ZlCisgKiBpdCBmcm9tIHRoZSBidWZmZXIncyBsaXN0LgorICovCitzdGF0 aWMgc3RydWN0IHhlbl9kbWFidWYgKgorZG1hYnVmX2ltcF9maW5kX3VubGluayhzdHJ1Y3QgZ250 ZGV2X3ByaXYgKnByaXYsIGludCBmZCkKK3sKKwlzdHJ1Y3QgeGVuX2RtYWJ1ZiAqcSwgKnhlbl9k bWFidWYsICpyZXQgPSBFUlJfUFRSKC1FTk9FTlQpOworCisJbXV0ZXhfbG9jaygmcHJpdi0+ZG1h YnVmX2xvY2spOworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh4ZW5fZG1hYnVmLCBxLCAmcHJp di0+ZG1hYnVmX2ltcF9saXN0LCBuZXh0KSB7CisJCWlmICh4ZW5fZG1hYnVmLT5mZCA9PSBmZCkg eworCQkJcHJfZGVidWcoIkZvdW5kIHhlbl9kbWFidWYgaW4gdGhlIGltcG9ydCBsaXN0XG4iKTsK KwkJCXJldCA9IHhlbl9kbWFidWY7CisJCQlsaXN0X2RlbCgmeGVuX2RtYWJ1Zi0+bmV4dCk7CisJ CQlicmVhazsKKwkJfQorCX0KKwltdXRleF91bmxvY2soJnByaXYtPmRtYWJ1Zl9sb2NrKTsKKwly ZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGRtYWJ1Zl9pbXBfcmVsZWFzZShzdHJ1Y3QgZ250 ZGV2X3ByaXYgKnByaXYsIHUzMiBmZCkKK3sKKwlzdHJ1Y3QgeGVuX2RtYWJ1ZiAqeGVuX2RtYWJ1 ZjsKKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2g7CisJc3RydWN0IGRtYV9idWYg KmRtYV9idWY7CisKKwl4ZW5fZG1hYnVmID0gZG1hYnVmX2ltcF9maW5kX3VubGluayhwcml2LCBm ZCk7CisJaWYgKElTX0VSUih4ZW5fZG1hYnVmKSkKKwkJcmV0dXJuIFBUUl9FUlIoeGVuX2RtYWJ1 Zik7CisKKwlwcl9kZWJ1ZygiUmVsZWFzaW5nIERNQSBidWZmZXIgd2l0aCBmZCAlZFxuIiwgZmQp OworCisJYXR0YWNoID0geGVuX2RtYWJ1Zi0+dS5pbXAuYXR0YWNoOworCisJaWYgKHhlbl9kbWFi dWYtPnUuaW1wLnNndCkKKwkJZG1hX2J1Zl91bm1hcF9hdHRhY2htZW50KGF0dGFjaCwgeGVuX2Rt YWJ1Zi0+dS5pbXAuc2d0LAorCQkJCQkgRE1BX0JJRElSRUNUSU9OQUwpOworCWRtYV9idWYgPSBh dHRhY2gtPmRtYWJ1ZjsKKwlkbWFfYnVmX2RldGFjaChhdHRhY2gtPmRtYWJ1ZiwgYXR0YWNoKTsK KwlkbWFfYnVmX3B1dChkbWFfYnVmKTsKKworCWRtYWJ1Zl9pbXBfZW5kX2ZvcmVpZ25fYWNjZXNz KHhlbl9kbWFidWYtPnUuaW1wLnJlZnMsCisJCQkJICAgICAgeGVuX2RtYWJ1Zi0+bnJfcGFnZXMp OworCWRtYWJ1Zl9pbXBfZnJlZV9zdG9yYWdlKHhlbl9kbWFidWYpOworCXJldHVybiAwOwogfQog CiAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0gKi8KLS0gCjIuMTcuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4v bGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-wm0-f68.google.com ([74.125.82.68]:40707 "EHLO mail-wm0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S966698AbeEYPd4 (ORCPT ); Fri, 25 May 2018 11:33:56 -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 7/8] xen/gntdev: Implement dma-buf import functionality Date: Fri, 25 May 2018 18:33:30 +0300 Message-Id: <20180525153331.31188-8-andr2000@gmail.com> In-Reply-To: <20180525153331.31188-1-andr2000@gmail.com> References: <20180525153331.31188-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.c | 237 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 234 insertions(+), 3 deletions(-) diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c index 52abc6cd5846..d8b6168f2cd9 100644 --- a/drivers/xen/gntdev.c +++ b/drivers/xen/gntdev.c @@ -71,6 +71,17 @@ static atomic_t pages_mapped = ATOMIC_INIT(0); static int use_ptemod; #define populate_freeable_maps use_ptemod +#ifdef CONFIG_XEN_GNTDEV_DMABUF +#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 +#endif + struct gntdev_priv { /* maps with visible offsets in the file descriptor */ struct list_head maps; @@ -94,6 +105,8 @@ struct gntdev_priv { struct list_head dmabuf_exp_list; /* List of wait objects. */ struct list_head dmabuf_exp_wait_list; + /* List of imported DMA buffers. */ + struct list_head dmabuf_imp_list; /* This is the lock which protects dma_buf_xxx lists. */ struct mutex dmabuf_lock; #endif @@ -155,6 +168,10 @@ struct xen_dmabuf { 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; @@ -684,6 +701,7 @@ static int gntdev_open(struct inode *inode, struct file *flip) mutex_init(&priv->dmabuf_lock); INIT_LIST_HEAD(&priv->dmabuf_exp_list); INIT_LIST_HEAD(&priv->dmabuf_exp_wait_list); + INIT_LIST_HEAD(&priv->dmabuf_imp_list); #endif if (use_ptemod) { @@ -1544,15 +1562,228 @@ static int dmabuf_exp_from_refs(struct gntdev_priv *priv, int flags, /* DMA buffer import support. */ /* ------------------------------------------------------------------ */ -static int dmabuf_imp_release(struct gntdev_priv *priv, u32 fd) +static int +dmabuf_imp_grant_foreign_access(struct page **pages, u32 *refs, + int count, int domid) { - return 0; + 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 xen_dmabuf *xen_dmabuf) +{ + kfree(xen_dmabuf->pages); + kfree(xen_dmabuf->u.imp.refs); + kfree(xen_dmabuf); +} + +static struct xen_dmabuf *dmabuf_imp_alloc_storage(int count) +{ + struct xen_dmabuf *xen_dmabuf; + int i; + + xen_dmabuf = kzalloc(sizeof(*xen_dmabuf), GFP_KERNEL); + if (!xen_dmabuf) + goto fail; + + xen_dmabuf->u.imp.refs = kcalloc(count, + sizeof(xen_dmabuf->u.imp.refs[0]), + GFP_KERNEL); + if (!xen_dmabuf->u.imp.refs) + goto fail; + + xen_dmabuf->pages = kcalloc(count, + sizeof(xen_dmabuf->pages[0]), + GFP_KERNEL); + if (!xen_dmabuf->pages) + goto fail; + + xen_dmabuf->nr_pages = count; + + for (i = 0; i < count; i++) + xen_dmabuf->u.imp.refs[i] = GRANT_INVALID_REF; + + return xen_dmabuf; + +fail: + dmabuf_imp_free_storage(xen_dmabuf); + return ERR_PTR(-ENOMEM); } static struct xen_dmabuf * dmabuf_imp_to_refs(struct gntdev_priv *priv, int fd, int count, int domid) { - return ERR_PTR(-ENOMEM); + struct xen_dmabuf *xen_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); + + xen_dmabuf = dmabuf_imp_alloc_storage(count); + if (IS_ERR(xen_dmabuf)) { + ret = xen_dmabuf; + goto fail_put; + } + + xen_dmabuf->priv = priv; + xen_dmabuf->fd = fd; + + attach = dma_buf_attach(dma_buf, priv->dma_dev); + if (IS_ERR(attach)) { + ret = ERR_CAST(attach); + goto fail_free_obj; + } + + xen_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 != xen_dmabuf->nr_pages << PAGE_SHIFT) { + ret = ERR_PTR(-EINVAL); + pr_err("DMA buffer has %zu pages, user-space expects %d\n", + attach->dmabuf->size, xen_dmabuf->nr_pages); + goto fail_unmap; + } + + xen_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; + } + + xen_dmabuf->pages[i++] = page; + } + + ret = ERR_PTR(dmabuf_imp_grant_foreign_access(xen_dmabuf->pages, + xen_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->dmabuf_lock); + list_add(&xen_dmabuf->next, &priv->dmabuf_imp_list); + mutex_unlock(&priv->dmabuf_lock); + + return xen_dmabuf; + +fail_end_access: + dmabuf_imp_end_foreign_access(xen_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(xen_dmabuf); +fail_put: + dma_buf_put(dma_buf); + return ret; +} + +/* + * Find the hyper dma-buf by its file descriptor and remove + * it from the buffer's list. + */ +static struct xen_dmabuf * +dmabuf_imp_find_unlink(struct gntdev_priv *priv, int fd) +{ + struct xen_dmabuf *q, *xen_dmabuf, *ret = ERR_PTR(-ENOENT); + + mutex_lock(&priv->dmabuf_lock); + list_for_each_entry_safe(xen_dmabuf, q, &priv->dmabuf_imp_list, next) { + if (xen_dmabuf->fd == fd) { + pr_debug("Found xen_dmabuf in the import list\n"); + ret = xen_dmabuf; + list_del(&xen_dmabuf->next); + break; + } + } + mutex_unlock(&priv->dmabuf_lock); + return ret; +} + +static int dmabuf_imp_release(struct gntdev_priv *priv, u32 fd) +{ + struct xen_dmabuf *xen_dmabuf; + struct dma_buf_attachment *attach; + struct dma_buf *dma_buf; + + xen_dmabuf = dmabuf_imp_find_unlink(priv, fd); + if (IS_ERR(xen_dmabuf)) + return PTR_ERR(xen_dmabuf); + + pr_debug("Releasing DMA buffer with fd %d\n", fd); + + attach = xen_dmabuf->u.imp.attach; + + if (xen_dmabuf->u.imp.sgt) + dma_buf_unmap_attachment(attach, xen_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(xen_dmabuf->u.imp.refs, + xen_dmabuf->nr_pages); + dmabuf_imp_free_storage(xen_dmabuf); + return 0; } /* ------------------------------------------------------------------ */ -- 2.17.0