From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 3/8] xen/grant-table: Allow allocating buffers suitable for DMA Date: Fri, 25 May 2018 18:33:26 +0300 Message-ID: <20180525153331.31188-4-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-wr0-x244.google.com (mail-wr0-x244.google.com [IPv6:2a00:1450:400c:c0c::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1FF1B6E954 for ; Fri, 25 May 2018 15:33:49 +0000 (UTC) Received: by mail-wr0-x244.google.com with SMTP id i12-v6so9963475wrc.4 for ; Fri, 25 May 2018 08:33:49 -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 YW0uY29tPgoKRXh0ZW5kIGdyYW50IHRhYmxlIG1vZHVsZSBBUEkgdG8gYWxsb3cgYWxsb2NhdGlu ZyBidWZmZXJzIHRoYXQgY2FuCmJlIHVzZWQgZm9yIERNQSBvcGVyYXRpb25zIGFuZCBtYXBwaW5n IGZvcmVpZ24gZ3JhbnQgcmVmZXJlbmNlcwpvbiB0b3Agb2YgdGhvc2UuClRoZSByZXN1bHRpbmcg YnVmZmVyIGlzIHNpbWlsYXIgdG8gdGhlIG9uZSBhbGxvY2F0ZWQgYnkgdGhlIGJhbGxvb24KZHJp dmVyIGluIHRlcm1zIHRoYXQgcHJvcGVyIG1lbW9yeSByZXNlcnZhdGlvbiBpcyBtYWRlCih7aW5j cmVhc2V8ZGVjcmVhc2V9X3Jlc2VydmF0aW9uIGFuZCBWQSBtYXBwaW5ncyB1cGRhdGVkIGlmIG5l ZWRlZCkuClRoaXMgaXMgdXNlZnVsIGZvciBzaGFyaW5nIGZvcmVpZ24gYnVmZmVycyB3aXRoIEhX IGRyaXZlcnMgd2hpY2gKY2Fubm90IHdvcmsgd2l0aCBzY2F0dGVyZWQgYnVmZmVycyBwcm92aWRl ZCBieSB0aGUgYmFsbG9vbiBkcml2ZXIsCmJ1dCByZXF1aXJlIERNQWFibGUgbWVtb3J5IGluc3Rl YWQuCgpTaWduZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2Fu ZHJ1c2hjaGVua29AZXBhbS5jb20+Ci0tLQogZHJpdmVycy94ZW4vS2NvbmZpZyAgICAgICB8ICAx MyArKysrCiBkcml2ZXJzL3hlbi9ncmFudC10YWJsZS5jIHwgMTI0ICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrCiBpbmNsdWRlL3hlbi9ncmFudF90YWJsZS5oIHwgIDI1ICsr KysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDE2MiBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy94ZW4vS2NvbmZpZyBiL2RyaXZlcnMveGVuL0tjb25maWcKaW5kZXggZTVkMGMyODM3 MmVhLi4zNDMxZmUyMTA2MjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL0tjb25maWcKKysrIGIv ZHJpdmVycy94ZW4vS2NvbmZpZwpAQCAtMTYxLDYgKzE2MSwxOSBAQCBjb25maWcgWEVOX0dSQU5U X0RFVl9BTExPQwogCSAgdG8gb3RoZXIgZG9tYWlucy4gVGhpcyBjYW4gYmUgdXNlZCB0byBpbXBs ZW1lbnQgZnJvbnRlbmQgZHJpdmVycwogCSAgb3IgYXMgcGFydCBvZiBhbiBpbnRlci1kb21haW4g c2hhcmVkIG1lbW9yeSBjaGFubmVsLgogCitjb25maWcgWEVOX0dSQU5UX0RNQV9BTExPQworCWJv b2wgIkFsbG93IGFsbG9jYXRpbmcgRE1BIGNhcGFibGUgYnVmZmVycyB3aXRoIGdyYW50IHJlZmVy ZW5jZSBtb2R1bGUiCisJZGVwZW5kcyBvbiBYRU4KKwloZWxwCisJICBFeHRlbmRzIGdyYW50IHRh YmxlIG1vZHVsZSBBUEkgdG8gYWxsb3cgYWxsb2NhdGluZyBETUEgY2FwYWJsZQorCSAgYnVmZmVy cyBhbmQgbWFwcGluZyBmb3JlaWduIGdyYW50IHJlZmVyZW5jZXMgb24gdG9wIG9mIGl0LgorCSAg VGhlIHJlc3VsdGluZyBidWZmZXIgaXMgc2ltaWxhciB0byBvbmUgYWxsb2NhdGVkIGJ5IHRoZSBi YWxsb29uCisJICBkcml2ZXIgaW4gdGVybXMgdGhhdCBwcm9wZXIgbWVtb3J5IHJlc2VydmF0aW9u IGlzIG1hZGUKKwkgICh7aW5jcmVhc2V8ZGVjcmVhc2V9X3Jlc2VydmF0aW9uIGFuZCBWQSBtYXBw aW5ncyB1cGRhdGVkIGlmIG5lZWRlZCkuCisJICBUaGlzIGlzIHVzZWZ1bCBmb3Igc2hhcmluZyBm b3JlaWduIGJ1ZmZlcnMgd2l0aCBIVyBkcml2ZXJzIHdoaWNoCisJICBjYW5ub3Qgd29yayB3aXRo IHNjYXR0ZXJlZCBidWZmZXJzIHByb3ZpZGVkIGJ5IHRoZSBiYWxsb29uIGRyaXZlciwKKwkgIGJ1 dCByZXF1aXJlIERNQWFibGUgbWVtb3J5IGluc3RlYWQuCisKIGNvbmZpZyBTV0lPVExCX1hFTgog CWRlZl9ib29sIHkKIAlzZWxlY3QgU1dJT1RMQgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vZ3Jh bnQtdGFibGUuYyBiL2RyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMKaW5kZXggZDc0ODgyMjZlMWYy Li4wNmZlNmU3ZjYzOWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL2dyYW50LXRhYmxlLmMKKysr IGIvZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYwpAQCAtNDUsNiArNDUsOSBAQAogI2luY2x1ZGUg PGxpbnV4L3dvcmtxdWV1ZS5oPgogI2luY2x1ZGUgPGxpbnV4L3JhdGVsaW1pdC5oPgogI2luY2x1 ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+CisjaWZkZWYgQ09ORklHX1hFTl9HUkFOVF9ETUFfQUxM T0MKKyNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgorI2VuZGlmCiAKICNpbmNsdWRlIDx4 ZW4veGVuLmg+CiAjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS94ZW4uaD4KQEAgLTU3LDYgKzYwLDcg QEAKICNpZmRlZiBDT05GSUdfWDg2CiAjaW5jbHVkZSA8YXNtL3hlbi9jcHVpZC5oPgogI2VuZGlm CisjaW5jbHVkZSA8eGVuL21lbV9yZXNlcnZhdGlvbi5oPgogI2luY2x1ZGUgPGFzbS94ZW4vaHlw ZXJjYWxsLmg+CiAjaW5jbHVkZSA8YXNtL3hlbi9pbnRlcmZhY2UuaD4KIApAQCAtODExLDYgKzgx NSw4MiBAQCBpbnQgZ250dGFiX2FsbG9jX3BhZ2VzKGludCBucl9wYWdlcywgc3RydWN0IHBhZ2Ug KipwYWdlcykKIH0KIEVYUE9SVF9TWU1CT0woZ250dGFiX2FsbG9jX3BhZ2VzKTsKIAorI2lmZGVm IENPTkZJR19YRU5fR1JBTlRfRE1BX0FMTE9DCisvKioKKyAqIGdudHRhYl9kbWFfYWxsb2NfcGFn ZXMgLSBhbGxvYyBETUFhYmxlIHBhZ2VzIHN1aXRhYmxlIGZvciBncmFudCBtYXBwaW5nIGludG8K KyAqIEBhcmdzOiBhcmd1bWVudHMgdG8gdGhlIGZ1bmN0aW9uCisgKi8KK2ludCBnbnR0YWJfZG1h X2FsbG9jX3BhZ2VzKHN0cnVjdCBnbnR0YWJfZG1hX2FsbG9jX2FyZ3MgKmFyZ3MpCit7CisJdW5z aWduZWQgbG9uZyBwZm4sIHN0YXJ0X3BmbjsKKwl4ZW5fcGZuX3QgKmZyYW1lczsKKwlzaXplX3Qg c2l6ZTsKKwlpbnQgaSwgcmV0OworCisJZnJhbWVzID0ga2NhbGxvYyhhcmdzLT5ucl9wYWdlcywg c2l6ZW9mKCpmcmFtZXMpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWZyYW1lcykKKwkJcmV0dXJuIC1F Tk9NRU07CisKKwlzaXplID0gYXJncy0+bnJfcGFnZXMgPDwgUEFHRV9TSElGVDsKKwlpZiAoYXJn cy0+Y29oZXJlbnQpCisJCWFyZ3MtPnZhZGRyID0gZG1hX2FsbG9jX2NvaGVyZW50KGFyZ3MtPmRl diwgc2l6ZSwKKwkJCQkJCSAmYXJncy0+ZGV2X2J1c19hZGRyLAorCQkJCQkJIEdGUF9LRVJORUwg fCBfX0dGUF9OT1dBUk4pOworCWVsc2UKKwkJYXJncy0+dmFkZHIgPSBkbWFfYWxsb2Nfd2MoYXJn cy0+ZGV2LCBzaXplLAorCQkJCQkgICAmYXJncy0+ZGV2X2J1c19hZGRyLAorCQkJCQkgICBHRlBf S0VSTkVMIHwgX19HRlBfTk9XQVJOKTsKKwlpZiAoIWFyZ3MtPnZhZGRyKSB7CisJCXByX2Vycigi RmFpbGVkIHRvIGFsbG9jYXRlIERNQSBidWZmZXIgb2Ygc2l6ZSAlenVcbiIsIHNpemUpOworCQly ZXQgPSAtRU5PTUVNOworCQlnb3RvIGZhaWxfZnJlZV9mcmFtZXM7CisJfQorCisJc3RhcnRfcGZu ID0gX19waHlzX3RvX3BmbihhcmdzLT5kZXZfYnVzX2FkZHIpOworCWZvciAocGZuID0gc3RhcnRf cGZuLCBpID0gMDsgcGZuIDwgc3RhcnRfcGZuICsgYXJncy0+bnJfcGFnZXM7CisJCQlwZm4rKywg aSsrKSB7CisJCXN0cnVjdCBwYWdlICpwYWdlID0gcGZuX3RvX3BhZ2UocGZuKTsKKworCQlhcmdz LT5wYWdlc1tpXSA9IHBhZ2U7CisJCWZyYW1lc1tpXSA9IHhlbl9wYWdlX3RvX2dmbihwYWdlKTsK KwkJeGVubWVtX3Jlc2VydmF0aW9uX3NjcnViX3BhZ2UocGFnZSk7CisJfQorCisJeGVubWVtX3Jl c2VydmF0aW9uX3ZhX21hcHBpbmdfcmVzZXQoYXJncy0+bnJfcGFnZXMsIGFyZ3MtPnBhZ2VzKTsK KworCXJldCA9IHhlbm1lbV9yZXNlcnZhdGlvbl9kZWNyZWFzZShhcmdzLT5ucl9wYWdlcywgZnJh bWVzKTsKKwlpZiAocmV0ICE9IGFyZ3MtPm5yX3BhZ2VzKSB7CisJCXByX2VycigiRmFpbGVkIHRv IGRlY3JlYXNlIHJlc2VydmF0aW9uIGZvciBETUEgYnVmZmVyXG4iKTsKKwkJeGVubWVtX3Jlc2Vy dmF0aW9uX2luY3JlYXNlKHJldCwgZnJhbWVzKTsKKwkJcmV0ID0gLUVGQVVMVDsKKwkJZ290byBm YWlsX2ZyZWVfZG1hOworCX0KKworCXJldCA9IGdudHRhYl9wYWdlc19zZXRfcHJpdmF0ZShhcmdz LT5ucl9wYWdlcywgYXJncy0+cGFnZXMpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZhaWxfY2xl YXJfcHJpdmF0ZTsKKworCWtmcmVlKGZyYW1lcyk7CisJcmV0dXJuIDA7CisKK2ZhaWxfY2xlYXJf cHJpdmF0ZToKKwlnbnR0YWJfcGFnZXNfY2xlYXJfcHJpdmF0ZShhcmdzLT5ucl9wYWdlcywgYXJn cy0+cGFnZXMpOworZmFpbF9mcmVlX2RtYToKKwl4ZW5tZW1fcmVzZXJ2YXRpb25fdmFfbWFwcGlu Z191cGRhdGUoYXJncy0+bnJfcGFnZXMsIGFyZ3MtPnBhZ2VzLAorCQkJCQkgICAgIGZyYW1lcyk7 CisJaWYgKGFyZ3MtPmNvaGVyZW50KQorCQlkbWFfZnJlZV9jb2hlcmVudChhcmdzLT5kZXYsIHNp emUsCisJCQkJICBhcmdzLT52YWRkciwgYXJncy0+ZGV2X2J1c19hZGRyKTsKKwllbHNlCisJCWRt YV9mcmVlX3djKGFyZ3MtPmRldiwgc2l6ZSwKKwkJCSAgICBhcmdzLT52YWRkciwgYXJncy0+ZGV2 X2J1c19hZGRyKTsKK2ZhaWxfZnJlZV9mcmFtZXM6CisJa2ZyZWUoZnJhbWVzKTsKKwlyZXR1cm4g cmV0OworfQorRVhQT1JUX1NZTUJPTChnbnR0YWJfZG1hX2FsbG9jX3BhZ2VzKTsKKyNlbmRpZgor CiB2b2lkIGdudHRhYl9wYWdlc19jbGVhcl9wcml2YXRlKGludCBucl9wYWdlcywgc3RydWN0IHBh Z2UgKipwYWdlcykKIHsKIAlpbnQgaTsKQEAgLTgzOCw2ICs5MTgsNTAgQEAgdm9pZCBnbnR0YWJf ZnJlZV9wYWdlcyhpbnQgbnJfcGFnZXMsIHN0cnVjdCBwYWdlICoqcGFnZXMpCiB9CiBFWFBPUlRf U1lNQk9MKGdudHRhYl9mcmVlX3BhZ2VzKTsKIAorI2lmZGVmIENPTkZJR19YRU5fR1JBTlRfRE1B X0FMTE9DCisvKioKKyAqIGdudHRhYl9kbWFfZnJlZV9wYWdlcyAtIGZyZWUgRE1BYWJsZSBwYWdl cworICogQGFyZ3M6IGFyZ3VtZW50cyB0byB0aGUgZnVuY3Rpb24KKyAqLworaW50IGdudHRhYl9k bWFfZnJlZV9wYWdlcyhzdHJ1Y3QgZ250dGFiX2RtYV9hbGxvY19hcmdzICphcmdzKQoreworCXhl bl9wZm5fdCAqZnJhbWVzOworCXNpemVfdCBzaXplOworCWludCBpLCByZXQ7CisKKwlnbnR0YWJf cGFnZXNfY2xlYXJfcHJpdmF0ZShhcmdzLT5ucl9wYWdlcywgYXJncy0+cGFnZXMpOworCisJZnJh bWVzID0ga2NhbGxvYyhhcmdzLT5ucl9wYWdlcywgc2l6ZW9mKCpmcmFtZXMpLCBHRlBfS0VSTkVM KTsKKwlpZiAoIWZyYW1lcykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlmb3IgKGkgPSAwOyBpIDwg YXJncy0+bnJfcGFnZXM7IGkrKykKKwkJZnJhbWVzW2ldID0gcGFnZV90b194ZW5fcGZuKGFyZ3Mt PnBhZ2VzW2ldKTsKKworCXJldCA9IHhlbm1lbV9yZXNlcnZhdGlvbl9pbmNyZWFzZShhcmdzLT5u cl9wYWdlcywgZnJhbWVzKTsKKwlpZiAocmV0ICE9IGFyZ3MtPm5yX3BhZ2VzKSB7CisJCXByX2Vy cigiRmFpbGVkIHRvIGRlY3JlYXNlIHJlc2VydmF0aW9uIGZvciBETUEgYnVmZmVyXG4iKTsKKwkJ cmV0ID0gLUVGQVVMVDsKKwl9IGVsc2UgeworCQlyZXQgPSAwOworCX0KKworCXhlbm1lbV9yZXNl cnZhdGlvbl92YV9tYXBwaW5nX3VwZGF0ZShhcmdzLT5ucl9wYWdlcywgYXJncy0+cGFnZXMsCisJ CQkJCSAgICAgZnJhbWVzKTsKKworCXNpemUgPSBhcmdzLT5ucl9wYWdlcyA8PCBQQUdFX1NISUZU OworCWlmIChhcmdzLT5jb2hlcmVudCkKKwkJZG1hX2ZyZWVfY29oZXJlbnQoYXJncy0+ZGV2LCBz aXplLAorCQkJCSAgYXJncy0+dmFkZHIsIGFyZ3MtPmRldl9idXNfYWRkcik7CisJZWxzZQorCQlk bWFfZnJlZV93YyhhcmdzLT5kZXYsIHNpemUsCisJCQkgICAgYXJncy0+dmFkZHIsIGFyZ3MtPmRl dl9idXNfYWRkcik7CisJa2ZyZWUoZnJhbWVzKTsKKwlyZXR1cm4gcmV0OworfQorRVhQT1JUX1NZ TUJPTChnbnR0YWJfZG1hX2ZyZWVfcGFnZXMpOworI2VuZGlmCisKIC8qIEhhbmRsaW5nIG9mIHBh Z2VkIG91dCBncmFudCB0YXJnZXRzIChHTlRTVF9lYWdhaW4pICovCiAjZGVmaW5lIE1BWF9ERUxB WSAyNTYKIHN0YXRpYyBpbmxpbmUgdm9pZApkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4vZ3JhbnRf dGFibGUuaCBiL2luY2x1ZGUveGVuL2dyYW50X3RhYmxlLmgKaW5kZXggZGUwM2YyNTQyYmI3Li45 ODJlMzQyNDJiOWMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUveGVuL2dyYW50X3RhYmxlLmgKKysrIGIv aW5jbHVkZS94ZW4vZ3JhbnRfdGFibGUuaApAQCAtMTk4LDYgKzE5OCwzMSBAQCB2b2lkIGdudHRh Yl9mcmVlX2F1dG9feGxhdF9mcmFtZXModm9pZCk7CiBpbnQgZ250dGFiX2FsbG9jX3BhZ2VzKGlu dCBucl9wYWdlcywgc3RydWN0IHBhZ2UgKipwYWdlcyk7CiB2b2lkIGdudHRhYl9mcmVlX3BhZ2Vz KGludCBucl9wYWdlcywgc3RydWN0IHBhZ2UgKipwYWdlcyk7CiAKKyNpZmRlZiBDT05GSUdfWEVO X0dSQU5UX0RNQV9BTExPQworc3RydWN0IGdudHRhYl9kbWFfYWxsb2NfYXJncyB7CisJLyogRGV2 aWNlIGZvciB3aGljaCBETUEgbWVtb3J5IHdpbGwgYmUvd2FzIGFsbG9jYXRlZC4gKi8KKwlzdHJ1 Y3QgZGV2aWNlICpkZXY7CisJLyoKKwkgKiBJZiBzZXQgdGhlbiBETUEgYnVmZmVyIGlzIGNvaGVy ZW50IGFuZCB3cml0ZS1jb21iaW5lIG90aGVyd2lzZS4KKwkgKi8KKwlib29sIGNvaGVyZW50Owor CS8qCisJICogTnVtYmVyIG9mIGVudHJpZXMgaW4gdGhlIEBwYWdlcyBhcnJheSwgZGVmaW5lcyB0 aGUgc2l6ZQorCSAqIG9mIHRoZSBETUEgYnVmZmVyLgorCSAqLworCWludCBucl9wYWdlczsKKwkv KiBBcnJheSBvZiBwYWdlcyBAcGFnZXMgZmlsbGVkIHdpdGggcGFnZXMgb2YgdGhlIERNQSBidWZm ZXIuICovCisJc3RydWN0IHBhZ2UgKipwYWdlczsKKwkvKiBWaXJ0dWFsL0NQVSBhZGRyZXNzIG9m IHRoZSBETUEgYnVmZmVyLiAqLworCXZvaWQgKnZhZGRyOworCS8qIEJ1cyBhZGRyZXNzIG9mIHRo ZSBETUEgYnVmZmVyLiAqLworCWRtYV9hZGRyX3QgZGV2X2J1c19hZGRyOworfTsKKworaW50IGdu dHRhYl9kbWFfYWxsb2NfcGFnZXMoc3RydWN0IGdudHRhYl9kbWFfYWxsb2NfYXJncyAqYXJncyk7 CitpbnQgZ250dGFiX2RtYV9mcmVlX3BhZ2VzKHN0cnVjdCBnbnR0YWJfZG1hX2FsbG9jX2FyZ3Mg KmFyZ3MpOworI2VuZGlmCisKIGludCBnbnR0YWJfcGFnZXNfc2V0X3ByaXZhdGUoaW50IG5yX3Bh Z2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKTsKIHZvaWQgZ250dGFiX3BhZ2VzX2NsZWFyX3ByaXZh dGUoaW50IG5yX3BhZ2VzLCBzdHJ1Y3QgcGFnZSAqKnBhZ2VzKTsKIAotLSAKMi4xNy4wCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFp bGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-wr0-f193.google.com ([209.85.128.193]:40093 "EHLO mail-wr0-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S966571AbeEYPdt (ORCPT ); Fri, 25 May 2018 11:33:49 -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 3/8] xen/grant-table: Allow allocating buffers suitable for DMA Date: Fri, 25 May 2018 18:33:26 +0300 Message-Id: <20180525153331.31188-4-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 Extend grant table module API to allow allocating buffers that can be used for DMA operations and mapping foreign grant references on top of those. The resulting buffer is similar to the one allocated by the balloon driver in terms that proper memory reservation is made ({increase|decrease}_reservation and VA mappings updated if needed). This is useful for sharing foreign buffers with HW drivers which cannot work with scattered buffers provided by the balloon driver, but require DMAable memory instead. Signed-off-by: Oleksandr Andrushchenko --- drivers/xen/Kconfig | 13 ++++ drivers/xen/grant-table.c | 124 ++++++++++++++++++++++++++++++++++++++ include/xen/grant_table.h | 25 ++++++++ 3 files changed, 162 insertions(+) diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig index e5d0c28372ea..3431fe210624 100644 --- a/drivers/xen/Kconfig +++ b/drivers/xen/Kconfig @@ -161,6 +161,19 @@ config XEN_GRANT_DEV_ALLOC to other domains. This can be used to implement frontend drivers or as part of an inter-domain shared memory channel. +config XEN_GRANT_DMA_ALLOC + bool "Allow allocating DMA capable buffers with grant reference module" + depends on XEN + help + Extends grant table module API to allow allocating DMA capable + buffers and mapping foreign grant references on top of it. + The resulting buffer is similar to one allocated by the balloon + driver in terms that proper memory reservation is made + ({increase|decrease}_reservation and VA mappings updated if needed). + This is useful for sharing foreign buffers with HW drivers which + cannot work with scattered buffers provided by the balloon driver, + but require DMAable memory instead. + config SWIOTLB_XEN def_bool y select SWIOTLB diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c index d7488226e1f2..06fe6e7f639c 100644 --- a/drivers/xen/grant-table.c +++ b/drivers/xen/grant-table.c @@ -45,6 +45,9 @@ #include #include #include +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC +#include +#endif #include #include @@ -57,6 +60,7 @@ #ifdef CONFIG_X86 #include #endif +#include #include #include @@ -811,6 +815,82 @@ int gnttab_alloc_pages(int nr_pages, struct page **pages) } EXPORT_SYMBOL(gnttab_alloc_pages); +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC +/** + * gnttab_dma_alloc_pages - alloc DMAable pages suitable for grant mapping into + * @args: arguments to the function + */ +int gnttab_dma_alloc_pages(struct gnttab_dma_alloc_args *args) +{ + unsigned long pfn, start_pfn; + xen_pfn_t *frames; + size_t size; + int i, ret; + + frames = kcalloc(args->nr_pages, sizeof(*frames), GFP_KERNEL); + if (!frames) + return -ENOMEM; + + size = args->nr_pages << PAGE_SHIFT; + if (args->coherent) + args->vaddr = dma_alloc_coherent(args->dev, size, + &args->dev_bus_addr, + GFP_KERNEL | __GFP_NOWARN); + else + args->vaddr = dma_alloc_wc(args->dev, size, + &args->dev_bus_addr, + GFP_KERNEL | __GFP_NOWARN); + if (!args->vaddr) { + pr_err("Failed to allocate DMA buffer of size %zu\n", size); + ret = -ENOMEM; + goto fail_free_frames; + } + + start_pfn = __phys_to_pfn(args->dev_bus_addr); + for (pfn = start_pfn, i = 0; pfn < start_pfn + args->nr_pages; + pfn++, i++) { + struct page *page = pfn_to_page(pfn); + + args->pages[i] = page; + frames[i] = xen_page_to_gfn(page); + xenmem_reservation_scrub_page(page); + } + + xenmem_reservation_va_mapping_reset(args->nr_pages, args->pages); + + ret = xenmem_reservation_decrease(args->nr_pages, frames); + if (ret != args->nr_pages) { + pr_err("Failed to decrease reservation for DMA buffer\n"); + xenmem_reservation_increase(ret, frames); + ret = -EFAULT; + goto fail_free_dma; + } + + ret = gnttab_pages_set_private(args->nr_pages, args->pages); + if (ret < 0) + goto fail_clear_private; + + kfree(frames); + return 0; + +fail_clear_private: + gnttab_pages_clear_private(args->nr_pages, args->pages); +fail_free_dma: + xenmem_reservation_va_mapping_update(args->nr_pages, args->pages, + frames); + if (args->coherent) + dma_free_coherent(args->dev, size, + args->vaddr, args->dev_bus_addr); + else + dma_free_wc(args->dev, size, + args->vaddr, args->dev_bus_addr); +fail_free_frames: + kfree(frames); + return ret; +} +EXPORT_SYMBOL(gnttab_dma_alloc_pages); +#endif + void gnttab_pages_clear_private(int nr_pages, struct page **pages) { int i; @@ -838,6 +918,50 @@ void gnttab_free_pages(int nr_pages, struct page **pages) } EXPORT_SYMBOL(gnttab_free_pages); +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC +/** + * gnttab_dma_free_pages - free DMAable pages + * @args: arguments to the function + */ +int gnttab_dma_free_pages(struct gnttab_dma_alloc_args *args) +{ + xen_pfn_t *frames; + size_t size; + int i, ret; + + gnttab_pages_clear_private(args->nr_pages, args->pages); + + frames = kcalloc(args->nr_pages, sizeof(*frames), GFP_KERNEL); + if (!frames) + return -ENOMEM; + + for (i = 0; i < args->nr_pages; i++) + frames[i] = page_to_xen_pfn(args->pages[i]); + + ret = xenmem_reservation_increase(args->nr_pages, frames); + if (ret != args->nr_pages) { + pr_err("Failed to decrease reservation for DMA buffer\n"); + ret = -EFAULT; + } else { + ret = 0; + } + + xenmem_reservation_va_mapping_update(args->nr_pages, args->pages, + frames); + + size = args->nr_pages << PAGE_SHIFT; + if (args->coherent) + dma_free_coherent(args->dev, size, + args->vaddr, args->dev_bus_addr); + else + dma_free_wc(args->dev, size, + args->vaddr, args->dev_bus_addr); + kfree(frames); + return ret; +} +EXPORT_SYMBOL(gnttab_dma_free_pages); +#endif + /* Handling of paged out grant targets (GNTST_eagain) */ #define MAX_DELAY 256 static inline void diff --git a/include/xen/grant_table.h b/include/xen/grant_table.h index de03f2542bb7..982e34242b9c 100644 --- a/include/xen/grant_table.h +++ b/include/xen/grant_table.h @@ -198,6 +198,31 @@ void gnttab_free_auto_xlat_frames(void); int gnttab_alloc_pages(int nr_pages, struct page **pages); void gnttab_free_pages(int nr_pages, struct page **pages); +#ifdef CONFIG_XEN_GRANT_DMA_ALLOC +struct gnttab_dma_alloc_args { + /* Device for which DMA memory will be/was allocated. */ + struct device *dev; + /* + * If set then DMA buffer is coherent and write-combine otherwise. + */ + bool coherent; + /* + * Number of entries in the @pages array, defines the size + * of the DMA buffer. + */ + int nr_pages; + /* Array of pages @pages filled with pages of the DMA buffer. */ + struct page **pages; + /* Virtual/CPU address of the DMA buffer. */ + void *vaddr; + /* Bus address of the DMA buffer. */ + dma_addr_t dev_bus_addr; +}; + +int gnttab_dma_alloc_pages(struct gnttab_dma_alloc_args *args); +int gnttab_dma_free_pages(struct gnttab_dma_alloc_args *args); +#endif + int gnttab_pages_set_private(int nr_pages, struct page **pages); void gnttab_pages_clear_private(int nr_pages, struct page **pages); -- 2.17.0