From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v2 4/9] xen/grant-table: Allow allocating buffers suitable for DMA Date: Fri, 1 Jun 2018 14:41:27 +0300 Message-ID: <20180601114132.22596-5-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-x244.google.com (mail-lf0-x244.google.com [IPv6:2a00:1450:4010:c07::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id 78F786E677 for ; Fri, 1 Jun 2018 11:41:47 +0000 (UTC) Received: by mail-lf0-x244.google.com with SMTP id j13-v6so9936265lfb.13 for ; Fri, 01 Jun 2018 04:41:47 -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 YW0uY29tPgoKRXh0ZW5kIGdyYW50IHRhYmxlIG1vZHVsZSBBUEkgdG8gYWxsb3cgYWxsb2NhdGlu ZyBidWZmZXJzIHRoYXQgY2FuCmJlIHVzZWQgZm9yIERNQSBvcGVyYXRpb25zIGFuZCBtYXBwaW5n IGZvcmVpZ24gZ3JhbnQgcmVmZXJlbmNlcwpvbiB0b3Agb2YgdGhvc2UuClRoZSByZXN1bHRpbmcg YnVmZmVyIGlzIHNpbWlsYXIgdG8gdGhlIG9uZSBhbGxvY2F0ZWQgYnkgdGhlIGJhbGxvb24KZHJp dmVyIGluIHRlcm1zIHRoYXQgcHJvcGVyIG1lbW9yeSByZXNlcnZhdGlvbiBpcyBtYWRlCih7aW5j cmVhc2V8ZGVjcmVhc2V9X3Jlc2VydmF0aW9uIGFuZCBWQSBtYXBwaW5ncyB1cGRhdGVkIGlmIG5l ZWRlZCkuClRoaXMgaXMgdXNlZnVsIGZvciBzaGFyaW5nIGZvcmVpZ24gYnVmZmVycyB3aXRoIEhX IGRyaXZlcnMgd2hpY2gKY2Fubm90IHdvcmsgd2l0aCBzY2F0dGVyZWQgYnVmZmVycyBwcm92aWRl ZCBieSB0aGUgYmFsbG9vbiBkcml2ZXIsCmJ1dCByZXF1aXJlIERNQWFibGUgbWVtb3J5IGluc3Rl YWQuCgpTaWduZWQtb2ZmLWJ5OiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2Fu ZHJ1c2hjaGVua29AZXBhbS5jb20+Ci0tLQogZHJpdmVycy94ZW4vS2NvbmZpZyAgICAgICB8ICAx MyArKysrKwogZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYyB8IDEwOSArKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS94ZW4vZ3JhbnRfdGFibGUuaCB8ICAxOCAr KysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDE0MCBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy94ZW4vS2NvbmZpZyBiL2RyaXZlcnMveGVuL0tjb25maWcKaW5kZXggZTVkMGMyODM3 MmVhLi4zOTUzNmRkZmJjZTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMveGVuL0tjb25maWcKKysrIGIv ZHJpdmVycy94ZW4vS2NvbmZpZwpAQCAtMTYxLDYgKzE2MSwxOSBAQCBjb25maWcgWEVOX0dSQU5U X0RFVl9BTExPQwogCSAgdG8gb3RoZXIgZG9tYWlucy4gVGhpcyBjYW4gYmUgdXNlZCB0byBpbXBs ZW1lbnQgZnJvbnRlbmQgZHJpdmVycwogCSAgb3IgYXMgcGFydCBvZiBhbiBpbnRlci1kb21haW4g c2hhcmVkIG1lbW9yeSBjaGFubmVsLgogCitjb25maWcgWEVOX0dSQU5UX0RNQV9BTExPQworCWJv b2wgIkFsbG93IGFsbG9jYXRpbmcgRE1BIGNhcGFibGUgYnVmZmVycyB3aXRoIGdyYW50IHJlZmVy ZW5jZSBtb2R1bGUiCisJZGVwZW5kcyBvbiBYRU4gJiYgSEFTX0RNQQorCWhlbHAKKwkgIEV4dGVu ZHMgZ3JhbnQgdGFibGUgbW9kdWxlIEFQSSB0byBhbGxvdyBhbGxvY2F0aW5nIERNQSBjYXBhYmxl CisJICBidWZmZXJzIGFuZCBtYXBwaW5nIGZvcmVpZ24gZ3JhbnQgcmVmZXJlbmNlcyBvbiB0b3Ag b2YgaXQuCisJICBUaGUgcmVzdWx0aW5nIGJ1ZmZlciBpcyBzaW1pbGFyIHRvIG9uZSBhbGxvY2F0 ZWQgYnkgdGhlIGJhbGxvb24KKwkgIGRyaXZlciBpbiB0ZXJtcyB0aGF0IHByb3BlciBtZW1vcnkg cmVzZXJ2YXRpb24gaXMgbWFkZQorCSAgKHtpbmNyZWFzZXxkZWNyZWFzZX1fcmVzZXJ2YXRpb24g YW5kIFZBIG1hcHBpbmdzIHVwZGF0ZWQgaWYgbmVlZGVkKS4KKwkgIFRoaXMgaXMgdXNlZnVsIGZv ciBzaGFyaW5nIGZvcmVpZ24gYnVmZmVycyB3aXRoIEhXIGRyaXZlcnMgd2hpY2gKKwkgIGNhbm5v dCB3b3JrIHdpdGggc2NhdHRlcmVkIGJ1ZmZlcnMgcHJvdmlkZWQgYnkgdGhlIGJhbGxvb24gZHJp dmVyLAorCSAgYnV0IHJlcXVpcmUgRE1BYWJsZSBtZW1vcnkgaW5zdGVhZC4KKwogY29uZmlnIFNX SU9UTEJfWEVOCiAJZGVmX2Jvb2wgeQogCXNlbGVjdCBTV0lPVExCCmRpZmYgLS1naXQgYS9kcml2 ZXJzL3hlbi9ncmFudC10YWJsZS5jIGIvZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYwppbmRleCBk YmI0OGE4OWU5ODcuLjU2NThlNThkOWNjNiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vZ3JhbnQt dGFibGUuYworKysgYi9kcml2ZXJzL3hlbi9ncmFudC10YWJsZS5jCkBAIC00NSw2ICs0NSw5IEBA CiAjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CiAjaW5jbHVkZSA8bGludXgvcmF0ZWxpbWl0 Lmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlcGFyYW0uaD4KKyNpZmRlZiBDT05GSUdfWEVOX0dS QU5UX0RNQV9BTExPQworI2luY2x1ZGUgPGxpbnV4L2RtYS1tYXBwaW5nLmg+CisjZW5kaWYKIAog I2luY2x1ZGUgPHhlbi94ZW4uaD4KICNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNlL3hlbi5oPgpAQCAt NTcsNiArNjAsNyBAQAogI2lmZGVmIENPTkZJR19YODYKICNpbmNsdWRlIDxhc20veGVuL2NwdWlk Lmg+CiAjZW5kaWYKKyNpbmNsdWRlIDx4ZW4vbWVtLXJlc2VydmF0aW9uLmg+CiAjaW5jbHVkZSA8 YXNtL3hlbi9oeXBlcmNhbGwuaD4KICNpbmNsdWRlIDxhc20veGVuL2ludGVyZmFjZS5oPgogCkBA IC04MTEsNiArODE1LDczIEBAIGludCBnbnR0YWJfYWxsb2NfcGFnZXMoaW50IG5yX3BhZ2VzLCBz dHJ1Y3QgcGFnZSAqKnBhZ2VzKQogfQogRVhQT1JUX1NZTUJPTF9HUEwoZ250dGFiX2FsbG9jX3Bh Z2VzKTsKIAorI2lmZGVmIENPTkZJR19YRU5fR1JBTlRfRE1BX0FMTE9DCisvKioKKyAqIGdudHRh Yl9kbWFfYWxsb2NfcGFnZXMgLSBhbGxvYyBETUFhYmxlIHBhZ2VzIHN1aXRhYmxlIGZvciBncmFu dCBtYXBwaW5nIGludG8KKyAqIEBhcmdzOiBhcmd1bWVudHMgdG8gdGhlIGZ1bmN0aW9uCisgKi8K K2ludCBnbnR0YWJfZG1hX2FsbG9jX3BhZ2VzKHN0cnVjdCBnbnR0YWJfZG1hX2FsbG9jX2FyZ3Mg KmFyZ3MpCit7CisJdW5zaWduZWQgbG9uZyBwZm4sIHN0YXJ0X3BmbjsKKwlzaXplX3Qgc2l6ZTsK KwlpbnQgaSwgcmV0OworCisJc2l6ZSA9IGFyZ3MtPm5yX3BhZ2VzIDw8IFBBR0VfU0hJRlQ7CisJ aWYgKGFyZ3MtPmNvaGVyZW50KQorCQlhcmdzLT52YWRkciA9IGRtYV9hbGxvY19jb2hlcmVudChh cmdzLT5kZXYsIHNpemUsCisJCQkJCQkgJmFyZ3MtPmRldl9idXNfYWRkciwKKwkJCQkJCSBHRlBf S0VSTkVMIHwgX19HRlBfTk9XQVJOKTsKKwllbHNlCisJCWFyZ3MtPnZhZGRyID0gZG1hX2FsbG9j X3djKGFyZ3MtPmRldiwgc2l6ZSwKKwkJCQkJICAgJmFyZ3MtPmRldl9idXNfYWRkciwKKwkJCQkJ ICAgR0ZQX0tFUk5FTCB8IF9fR0ZQX05PV0FSTik7CisJaWYgKCFhcmdzLT52YWRkcikgeworCQlw cl9lcnIoIkZhaWxlZCB0byBhbGxvY2F0ZSBETUEgYnVmZmVyIG9mIHNpemUgJXp1XG4iLCBzaXpl KTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJc3RhcnRfcGZuID0gX19waHlzX3RvX3Bmbihh cmdzLT5kZXZfYnVzX2FkZHIpOworCWZvciAocGZuID0gc3RhcnRfcGZuLCBpID0gMDsgcGZuIDwg c3RhcnRfcGZuICsgYXJncy0+bnJfcGFnZXM7CisJCQlwZm4rKywgaSsrKSB7CisJCXN0cnVjdCBw YWdlICpwYWdlID0gcGZuX3RvX3BhZ2UocGZuKTsKKworCQlhcmdzLT5wYWdlc1tpXSA9IHBhZ2U7 CisJCWFyZ3MtPmZyYW1lc1tpXSA9IHhlbl9wYWdlX3RvX2dmbihwYWdlKTsKKwkJeGVubWVtX3Jl c2VydmF0aW9uX3NjcnViX3BhZ2UocGFnZSk7CisJfQorCisJeGVubWVtX3Jlc2VydmF0aW9uX3Zh X21hcHBpbmdfcmVzZXQoYXJncy0+bnJfcGFnZXMsIGFyZ3MtPnBhZ2VzKTsKKworCXJldCA9IHhl bm1lbV9yZXNlcnZhdGlvbl9kZWNyZWFzZShhcmdzLT5ucl9wYWdlcywgYXJncy0+ZnJhbWVzKTsK KwlpZiAocmV0ICE9IGFyZ3MtPm5yX3BhZ2VzKSB7CisJCXByX2VycigiRmFpbGVkIHRvIGRlY3Jl YXNlIHJlc2VydmF0aW9uIGZvciBETUEgYnVmZmVyXG4iKTsKKwkJcmV0ID0gLUVGQVVMVDsKKwkJ Z290byBmYWlsX2ZyZWVfZG1hOworCX0KKworCXJldCA9IGdudHRhYl9wYWdlc19zZXRfcHJpdmF0 ZShhcmdzLT5ucl9wYWdlcywgYXJncy0+cGFnZXMpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIGZh aWxfY2xlYXJfcHJpdmF0ZTsKKworCXJldHVybiAwOworCitmYWlsX2NsZWFyX3ByaXZhdGU6CisJ Z250dGFiX3BhZ2VzX2NsZWFyX3ByaXZhdGUoYXJncy0+bnJfcGFnZXMsIGFyZ3MtPnBhZ2VzKTsK K2ZhaWxfZnJlZV9kbWE6CisJeGVubWVtX3Jlc2VydmF0aW9uX2luY3JlYXNlKGFyZ3MtPm5yX3Bh Z2VzLCBhcmdzLT5mcmFtZXMpOworCXhlbm1lbV9yZXNlcnZhdGlvbl92YV9tYXBwaW5nX3VwZGF0 ZShhcmdzLT5ucl9wYWdlcywgYXJncy0+cGFnZXMsCisJCQkJCSAgICAgYXJncy0+ZnJhbWVzKTsK KwlpZiAoYXJncy0+Y29oZXJlbnQpCisJCWRtYV9mcmVlX2NvaGVyZW50KGFyZ3MtPmRldiwgc2l6 ZSwKKwkJCQkgIGFyZ3MtPnZhZGRyLCBhcmdzLT5kZXZfYnVzX2FkZHIpOworCWVsc2UKKwkJZG1h X2ZyZWVfd2MoYXJncy0+ZGV2LCBzaXplLAorCQkJICAgIGFyZ3MtPnZhZGRyLCBhcmdzLT5kZXZf YnVzX2FkZHIpOworCXJldHVybiByZXQ7Cit9CitFWFBPUlRfU1lNQk9MX0dQTChnbnR0YWJfZG1h X2FsbG9jX3BhZ2VzKTsKKyNlbmRpZgorCiB2b2lkIGdudHRhYl9wYWdlc19jbGVhcl9wcml2YXRl KGludCBucl9wYWdlcywgc3RydWN0IHBhZ2UgKipwYWdlcykKIHsKIAlpbnQgaTsKQEAgLTgzOCw2 ICs5MDksNDQgQEAgdm9pZCBnbnR0YWJfZnJlZV9wYWdlcyhpbnQgbnJfcGFnZXMsIHN0cnVjdCBw YWdlICoqcGFnZXMpCiB9CiBFWFBPUlRfU1lNQk9MX0dQTChnbnR0YWJfZnJlZV9wYWdlcyk7CiAK KyNpZmRlZiBDT05GSUdfWEVOX0dSQU5UX0RNQV9BTExPQworLyoqCisgKiBnbnR0YWJfZG1hX2Zy ZWVfcGFnZXMgLSBmcmVlIERNQWFibGUgcGFnZXMKKyAqIEBhcmdzOiBhcmd1bWVudHMgdG8gdGhl IGZ1bmN0aW9uCisgKi8KK2ludCBnbnR0YWJfZG1hX2ZyZWVfcGFnZXMoc3RydWN0IGdudHRhYl9k bWFfYWxsb2NfYXJncyAqYXJncykKK3sKKwlzaXplX3Qgc2l6ZTsKKwlpbnQgaSwgcmV0OworCisJ Z250dGFiX3BhZ2VzX2NsZWFyX3ByaXZhdGUoYXJncy0+bnJfcGFnZXMsIGFyZ3MtPnBhZ2VzKTsK KworCWZvciAoaSA9IDA7IGkgPCBhcmdzLT5ucl9wYWdlczsgaSsrKQorCQlhcmdzLT5mcmFtZXNb aV0gPSBwYWdlX3RvX3hlbl9wZm4oYXJncy0+cGFnZXNbaV0pOworCisJcmV0ID0geGVubWVtX3Jl c2VydmF0aW9uX2luY3JlYXNlKGFyZ3MtPm5yX3BhZ2VzLCBhcmdzLT5mcmFtZXMpOworCWlmIChy ZXQgIT0gYXJncy0+bnJfcGFnZXMpIHsKKwkJcHJfZXJyKCJGYWlsZWQgdG8gZGVjcmVhc2UgcmVz ZXJ2YXRpb24gZm9yIERNQSBidWZmZXJcbiIpOworCQlyZXQgPSAtRUZBVUxUOworCX0gZWxzZSB7 CisJCXJldCA9IDA7CisJfQorCisJeGVubWVtX3Jlc2VydmF0aW9uX3ZhX21hcHBpbmdfdXBkYXRl KGFyZ3MtPm5yX3BhZ2VzLCBhcmdzLT5wYWdlcywKKwkJCQkJICAgICBhcmdzLT5mcmFtZXMpOwor CisJc2l6ZSA9IGFyZ3MtPm5yX3BhZ2VzIDw8IFBBR0VfU0hJRlQ7CisJaWYgKGFyZ3MtPmNvaGVy ZW50KQorCQlkbWFfZnJlZV9jb2hlcmVudChhcmdzLT5kZXYsIHNpemUsCisJCQkJICBhcmdzLT52 YWRkciwgYXJncy0+ZGV2X2J1c19hZGRyKTsKKwllbHNlCisJCWRtYV9mcmVlX3djKGFyZ3MtPmRl diwgc2l6ZSwKKwkJCSAgICBhcmdzLT52YWRkciwgYXJncy0+ZGV2X2J1c19hZGRyKTsKKwlyZXR1 cm4gcmV0OworfQorRVhQT1JUX1NZTUJPTF9HUEwoZ250dGFiX2RtYV9mcmVlX3BhZ2VzKTsKKyNl bmRpZgorCiAvKiBIYW5kbGluZyBvZiBwYWdlZCBvdXQgZ3JhbnQgdGFyZ2V0cyAoR05UU1RfZWFn YWluKSAqLwogI2RlZmluZSBNQVhfREVMQVkgMjU2CiBzdGF0aWMgaW5saW5lIHZvaWQKZGlmZiAt LWdpdCBhL2luY2x1ZGUveGVuL2dyYW50X3RhYmxlLmggYi9pbmNsdWRlL3hlbi9ncmFudF90YWJs ZS5oCmluZGV4IGRlMDNmMjU0MmJiNy4uOWJjNWJjMDdkNGQzIDEwMDY0NAotLS0gYS9pbmNsdWRl L3hlbi9ncmFudF90YWJsZS5oCisrKyBiL2luY2x1ZGUveGVuL2dyYW50X3RhYmxlLmgKQEAgLTE5 OCw2ICsxOTgsMjQgQEAgdm9pZCBnbnR0YWJfZnJlZV9hdXRvX3hsYXRfZnJhbWVzKHZvaWQpOwog aW50IGdudHRhYl9hbGxvY19wYWdlcyhpbnQgbnJfcGFnZXMsIHN0cnVjdCBwYWdlICoqcGFnZXMp Owogdm9pZCBnbnR0YWJfZnJlZV9wYWdlcyhpbnQgbnJfcGFnZXMsIHN0cnVjdCBwYWdlICoqcGFn ZXMpOwogCisjaWZkZWYgQ09ORklHX1hFTl9HUkFOVF9ETUFfQUxMT0MKK3N0cnVjdCBnbnR0YWJf ZG1hX2FsbG9jX2FyZ3MgeworCS8qIERldmljZSBmb3Igd2hpY2ggRE1BIG1lbW9yeSB3aWxsIGJl L3dhcyBhbGxvY2F0ZWQuICovCisJc3RydWN0IGRldmljZSAqZGV2OworCS8qIElmIHNldCB0aGVu IERNQSBidWZmZXIgaXMgY29oZXJlbnQgYW5kIHdyaXRlLWNvbWJpbmUgb3RoZXJ3aXNlLiAqLwor CWJvb2wgY29oZXJlbnQ7CisKKwlpbnQgbnJfcGFnZXM7CisJc3RydWN0IHBhZ2UgKipwYWdlczsK Kwl4ZW5fcGZuX3QgKmZyYW1lczsKKwl2b2lkICp2YWRkcjsKKwlkbWFfYWRkcl90IGRldl9idXNf YWRkcjsKK307CisKK2ludCBnbnR0YWJfZG1hX2FsbG9jX3BhZ2VzKHN0cnVjdCBnbnR0YWJfZG1h X2FsbG9jX2FyZ3MgKmFyZ3MpOworaW50IGdudHRhYl9kbWFfZnJlZV9wYWdlcyhzdHJ1Y3QgZ250 dGFiX2RtYV9hbGxvY19hcmdzICphcmdzKTsKKyNlbmRpZgorCiBpbnQgZ250dGFiX3BhZ2VzX3Nl dF9wcml2YXRlKGludCBucl9wYWdlcywgc3RydWN0IHBhZ2UgKipwYWdlcyk7CiB2b2lkIGdudHRh Yl9wYWdlc19jbGVhcl9wcml2YXRlKGludCBucl9wYWdlcywgc3RydWN0IHBhZ2UgKipwYWdlcyk7 CiAKLS0gCjIuMTcuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRl dmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f66.google.com ([209.85.215.66]:40159 "EHLO mail-lf0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751889AbeFALls (ORCPT ); Fri, 1 Jun 2018 07:41:48 -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 4/9] xen/grant-table: Allow allocating buffers suitable for DMA Date: Fri, 1 Jun 2018 14:41:27 +0300 Message-Id: <20180601114132.22596-5-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 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 | 109 ++++++++++++++++++++++++++++++++++++++ include/xen/grant_table.h | 18 +++++++ 3 files changed, 140 insertions(+) diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig index e5d0c28372ea..39536ddfbce4 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 && HAS_DMA + 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 dbb48a89e987..5658e58d9cc6 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,73 @@ int gnttab_alloc_pages(int nr_pages, struct page **pages) } EXPORT_SYMBOL_GPL(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; + size_t size; + int i, ret; + + 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); + return -ENOMEM; + } + + 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; + args->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, args->frames); + if (ret != args->nr_pages) { + pr_err("Failed to decrease reservation for DMA buffer\n"); + ret = -EFAULT; + goto fail_free_dma; + } + + ret = gnttab_pages_set_private(args->nr_pages, args->pages); + if (ret < 0) + goto fail_clear_private; + + return 0; + +fail_clear_private: + gnttab_pages_clear_private(args->nr_pages, args->pages); +fail_free_dma: + xenmem_reservation_increase(args->nr_pages, args->frames); + xenmem_reservation_va_mapping_update(args->nr_pages, args->pages, + args->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); + return ret; +} +EXPORT_SYMBOL_GPL(gnttab_dma_alloc_pages); +#endif + void gnttab_pages_clear_private(int nr_pages, struct page **pages) { int i; @@ -838,6 +909,44 @@ void gnttab_free_pages(int nr_pages, struct page **pages) } EXPORT_SYMBOL_GPL(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) +{ + size_t size; + int i, ret; + + gnttab_pages_clear_private(args->nr_pages, args->pages); + + for (i = 0; i < args->nr_pages; i++) + args->frames[i] = page_to_xen_pfn(args->pages[i]); + + ret = xenmem_reservation_increase(args->nr_pages, args->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, + args->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); + return ret; +} +EXPORT_SYMBOL_GPL(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..9bc5bc07d4d3 100644 --- a/include/xen/grant_table.h +++ b/include/xen/grant_table.h @@ -198,6 +198,24 @@ 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; + + int nr_pages; + struct page **pages; + xen_pfn_t *frames; + void *vaddr; + 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