From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH v2 0/9] xen: dma-buf support for grant device Date: Fri, 1 Jun 2018 14:41:23 +0300 Message-ID: <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-x242.google.com (mail-lf0-x242.google.com [IPv6:2a00:1450:4010:c07::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id 66F966E64F for ; Fri, 1 Jun 2018 11:41:41 +0000 (UTC) Received: by mail-lf0-x242.google.com with SMTP id d24-v6so14381550lfa.8 for ; Fri, 01 Jun 2018 04:41:41 -0700 (PDT) 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 YW0uY29tPgoKVGhpcyB3b3JrIGlzIGluIHJlc3BvbnNlIHRvIG15IHByZXZpb3VzIGF0dGVtcHQg dG8gaW50cm9kdWNlIFhlbi9EUk0KemVyby1jb3B5IGRyaXZlciBbMV0gdG8gZW5hYmxlIExpbnV4 IGRtYS1idWYgQVBJIFsyXSBmb3IgWGVuIGJhc2VkCmZyb250ZW5kcy9iYWNrZW5kcy4gVGhlcmUg aXMgYWxzbyBhbiBleGlzdGluZyBoeXBlcl9kbWFidWYgYXBwcm9hY2gKYXZhaWxhYmxlIFszXSB3 aGljaCwgaWYgcmV3b3JrZWQgdG8gdXRpbGl6ZSB0aGUgcHJvcG9zZWQgc29sdXRpb24sCmNhbiBn cmVhdGx5IGJlbmVmaXQgYXMgd2VsbC4KClJGQyBmb3IgdGhpcyBzZXJpZXMgd2FzIHB1Ymxpc2hl ZCBhbmQgZGlzY3Vzc2VkIFs5XSwgY29tbWVudHMgYWRkcmVzc2VkLgoKVGhlIG9yaWdpbmFsIHJh dGlvbmFsZSBiZWhpbmQgdGhpcyB3b3JrIHdhcyB0byBlbmFibGUgemVyby1jb3B5aW5nCnVzZS1j YXNlcyB3aGlsZSB3b3JraW5nIHdpdGggWGVuIHBhcmEtdmlydHVhbCBkaXNwbGF5IGRyaXZlciBb NF06CndoZW4gdXNpbmcgWGVuIFBWIERSTSBmcm9udGVuZCBkcml2ZXIgdGhlbiBvbiBiYWNrZW5k IHNpZGUgb25lIHdpbGwKbmVlZCB0byBkbyBjb3B5aW5nIG9mIGRpc3BsYXkgYnVmZmVycycgY29u dGVudHMgKGZpbGxlZCBieSB0aGUKZnJvbnRlbmQncyB1c2VyLXNwYWNlKSBpbnRvIGJ1ZmZlcnMg YWxsb2NhdGVkIGF0IHRoZSBiYWNrZW5kIHNpZGUuClRha2luZyBpbnRvIGFjY291bnQgdGhlIHNp emUgb2YgZGlzcGxheSBidWZmZXJzIGFuZCBmcmFtZXMgcGVyCnNlY29uZCBpdCBtYXkgcmVzdWx0 IGluIHVubmVlZGVkIGh1Z2UgZGF0YSBidXMgb2NjdXBhdGlvbiBhbmQKcGVyZm9ybWFuY2UgbG9z cy4KClRoZSBoZWxwZXIgZHJpdmVyIFs0XSBhbGxvd3MgaW1wbGVtZW50aW5nIHplcm8tY29weWlu ZyB1c2UtY2FzZXMKd2hlbiB1c2luZyBYZW4gcGFyYS12aXJ0dWFsaXplZCBmcm9udGVuZCBkaXNw bGF5IGRyaXZlciBieSBpbXBsZW1lbnRpbmcKYSBEUk0vS01TIGhlbHBlciBkcml2ZXIgcnVubmlu ZyBvbiBiYWNrZW5kJ3Mgc2lkZS4KSXQgdXRpbGl6ZXMgUFJJTUUgYnVmZmVycyBBUEkgKGltcGxl bWVudGVkIG9uIHRvcCBvZiBMaW51eCBkbWEtYnVmKQp0byBzaGFyZSBmcm9udGVuZCdzIGJ1ZmZl cnMgd2l0aCBwaHlzaWNhbCBkZXZpY2UgZHJpdmVycyBvbgpiYWNrZW5kJ3Mgc2lkZToKCiAtIGEg ZHVtYiBidWZmZXIgY3JlYXRlZCBvbiBiYWNrZW5kJ3Mgc2lkZSBjYW4gYmUgc2hhcmVkCiAgIHdp dGggdGhlIFhlbiBQViBmcm9udGVuZCBkcml2ZXIsIHNvIGl0IGRpcmVjdGx5IHdyaXRlcwogICBp bnRvIGJhY2tlbmQncyBkb21haW4gbWVtb3J5IChpbnRvIHRoZSBidWZmZXIgZXhwb3J0ZWQgZnJv bQogICBEUk0vS01TIGRyaXZlciBvZiBhIHBoeXNpY2FsIGRpc3BsYXkgZGV2aWNlKQogLSBhIGR1 bWIgYnVmZmVyIGFsbG9jYXRlZCBieSB0aGUgZnJvbnRlbmQgY2FuIGJlIGltcG9ydGVkCiAgIGlu dG8gcGh5c2ljYWwgZGV2aWNlIERSTS9LTVMgZHJpdmVyLCB0aHVzIGFsbG93aW5nIHRvCiAgIGFj aGlldmUgbm8gY29weWluZyBhcyB3ZWxsCgpGaW5hbGx5LCBpdCB3YXMgZGlzY3Vzc2VkIGFuZCBk ZWNpZGVkIChbMV0sIFs1XSkgdGhhdCBpdCBpcyB3b3J0aAppbXBsZW1lbnRpbmcgc3VjaCB1c2Ut Y2FzZXMgdmlhIGV4dGVuc2lvbiBvZiB0aGUgZXhpc3RpbmcgWGVuIGdudGRldgpkcml2ZXIgaW5z dGVhZCBvZiBpbnRyb2R1Y2luZyBuZXcgRFJNIHNwZWNpZmljIGRyaXZlci4KUGxlYXNlIG5vdGUs IHRoYXQgdGhlIHN1cHBvcnQgb2YgZG1hLWJ1ZiBpcyBMaW51eCBvbmx5LAphcyBkbWEtYnVmIGlz IGEgTGludXggb25seSB0aGluZy4KCk5vdyB0byB0aGUgcHJvcG9zZWQgc29sdXRpb24uIFRoZSBj aGFuZ2VzICB0byB0aGUgZXhpc3RpbmcgWGVuIGRyaXZlcnMKaW4gdGhlIExpbnV4IGtlcm5lbCBm YWxsIGludG8gMiBjYXRlZ29yaWVzOgoxLiBETUEtYWJsZSBtZW1vcnkgYnVmZmVyIGFsbG9jYXRp b24gYW5kIGluY3JlYXNpbmcvZGVjcmVhc2luZyBtZW1vcnkKICAgcmVzZXJ2YXRpb24gb2YgdGhl IHBhZ2VzIG9mIHN1Y2ggYSBidWZmZXIuCiAgIFRoaXMgaXMgcmVxdWlyZWQgaWYgd2UgYXJlIGFi b3V0IHRvIHNoYXJlIGRtYS1idWYgd2l0aCB0aGUgaGFyZHdhcmUKICAgdGhhdCBkb2VzIHJlcXVp cmUgdGhvc2UgdG8gYmUgYWxsb2NhdGVkIHdpdGggZG1hX2FsbG9jX3h4eCBBUEkuCiAgIChJdCBp cyBzdGlsbCBwb3NzaWJsZSB0byBhbGxvY2F0ZSBhIGRtYS1idWYgZnJvbSBhbnkgc3lzdGVtIG1l bW9yeSwKICAgZS5nLiBzeXN0ZW0gcGFnZXMpLgoyLiBFeHRlbnNpb24gb2YgdGhlIGdudGRldiBk cml2ZXIgdG8gZW5hYmxlIGl0IHRvIGltcG9ydC9leHBvcnQgZG1hLWJ1ZuKAmXMuCgpUaGUgZmly c3QgZml2ZSBwYXRjaGVzIGFyZSBpbiBwcmVwYXJhdGlvbiBmb3IgWGVuIGRtYS1idWYgc3VwcG9y dCwKYnV0IEkgY29uc2lkZXIgdGhvc2UgdXNhYmxlIHJlZ2FyZGxlc3Mgb2YgdGhlIGRtYS1idWYg dXNlLWNhc2UsCmUuZy4gb3RoZXIgZnJvbnRlbmQvYmFja2VuZCBrZXJuZWwgbW9kdWxlcyBtYXkg YWxzbyBiZW5lZml0IGZyb20gdGhlc2UKZm9yIGJldHRlciBjb2RlIHJldXNlOgogICAgMDAwMS14 ZW4tZ3JhbnQtdGFibGUtRXhwb3J0LWdudHRhYl8tYWxsb2MtZnJlZS1fcGFnZXMtYXMtLnBhdGNo CiAgICAwMDAyLXhlbi1ncmFudC10YWJsZS1NYWtlLXNldC1jbGVhci1wYWdlLXByaXZhdGUtY29k ZS1zaGEucGF0Y2gKICAgIDAwMDMteGVuLWJhbGxvb24tU2hhcmUtY29tbW9uLW1lbW9yeS1yZXNl cnZhdGlvbi1yb3V0aW5lcy5wYXRjaAogICAgMDAwNC14ZW4tZ3JhbnQtdGFibGUtQWxsb3ctYWxs b2NhdGluZy1idWZmZXJzLXN1aXRhYmxlLWZvLnBhdGNoCiAgICAwMDA1LXhlbi1nbnRkZXYtQWxs b3ctbWFwcGluZ3MtZm9yLURNQS1idWZmZXJzLnBhdGNoCgpUaGUgbmV4dCB0aHJlZSBwYXRjaGVz IGFyZSBYZW4gaW1wbGVtZW50YXRpb24gb2YgZG1hLWJ1ZiBhcyBwYXJ0IG9mCnRoZSBncmFudCBk ZXZpY2U6CiAgICAwMDA2LXhlbi1nbnRkZXYtQWRkLWluaXRpYWwtc3VwcG9ydC1mb3ItZG1hLWJ1 Zi1VQVBJLnBhdGNoCiAgICAwMDA3LXhlbi1nbnRkZXYtSW1wbGVtZW50LWRtYS1idWYtZXhwb3J0 LWZ1bmN0aW9uYWxpdHkucGF0Y2gKICAgIDAwMDgteGVuLWdudGRldi1JbXBsZW1lbnQtZG1hLWJ1 Zi1pbXBvcnQtZnVuY3Rpb25hbGl0eS5wYXRjaAoKVGhlIGxhc3QgcGF0Y2ggbWFrZXMgaXQgcG9z c2libGUgZm9yIGluLWtlcm5lbCB1c2Ugb2YgWGVuIGRtYS1idWYgQVBJOgogICAgMDAwOS14ZW4t Z250ZGV2LUV4cG9zZS1nbnRkZXYtcy1kbWEtYnVmLUFQSS1mb3ItaW4ta2VybmVsLnBhdGNoCgpU aGUgY29ycmVzcG9uZGluZyBsaWJ4ZW5nbnR0YWIgY2hhbmdlcyBhcmUgYXZhaWxhYmxlIGF0IFs2 XS4KCkFsbCB0aGUgYWJvdmUgd2FzIHRlc3RlZCB3aXRoIGRpc3BsYXkgYmFja2VuZCBbN10gYW5k IGl0cyBhY2NvbXBhbnlpbmcKaGVscGVyIGxpYnJhcnkgWzhdIG9uIFJlbmVzYXMgQVJNNjQgYmFz ZWQgYm9hcmQuCkJhc2ljIGJhbGxvb24gdGVzdHMgb24geDg2LgoKKlRvIGFsbCB0aGUgY29tbXVu aXRpZXMqOiBJIHdvdWxkIGxpa2UgdG8gYXNrIHlvdSB0byByZXZpZXcgdGhlIHByb3Bvc2VkCnNv bHV0aW9uIGFuZCBnaXZlIGZlZWRiYWNrIG9uIGl0LCBzbyBJIGNhbiBpbXByb3ZlIGFuZCBzZW5k IGZpbmFsCnBhdGNoZXMgZm9yIHJldmlldyAodGhpcyBpcyBzdGlsbCB3b3JrIGluIHByb2dyZXNz LCBidXQgZW5vdWdoIHRvIHN0YXJ0CmRpc2N1c3NpbmcgdGhlIGltcGxlbWVudGF0aW9uKS4KClRo YW5rIHlvdSBpbiBhZHZhbmNlLApPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbwoKWzFdIGh0dHBzOi8v bGlzdHMuZnJlZWRlc2t0b3Aub3JnL2FyY2hpdmVzL2RyaS1kZXZlbC8yMDE4LUFwcmlsLzE3MzE2 My5odG1sClsyXSBodHRwczovL2VsaXhpci5ib290bGluLmNvbS9saW51eC92NC4xNy1yYzUvc291 cmNlL0RvY3VtZW50YXRpb24vZHJpdmVyLWFwaS9kbWEtYnVmLnJzdApbM10gaHR0cHM6Ly9saXN0 cy54ZW5wcm9qZWN0Lm9yZy9hcmNoaXZlcy9odG1sL3hlbi1kZXZlbC8yMDE4LTAyL21zZzAxMjAy Lmh0bWwKWzRdIGh0dHBzOi8vY2dpdC5mcmVlZGVza3RvcC5vcmcvZHJtL2RybS1taXNjL3RyZWUv ZHJpdmVycy9ncHUvZHJtL3hlbgpbNV0gaHR0cHM6Ly9wYXRjaHdvcmsua2VybmVsLm9yZy9wYXRj aC8xMDI3OTY4MS8KWzZdIGh0dHBzOi8vZ2l0aHViLmNvbS9hbmRyMjAwMC94ZW4vdHJlZS94ZW5f ZG1hX2J1Zl92MQpbN10gaHR0cHM6Ly9naXRodWIuY29tL2FuZHIyMDAwL2Rpc3BsX2JlL3RyZWUv eGVuX2RtYV9idWZfdjEKWzhdIGh0dHBzOi8vZ2l0aHViLmNvbS9hbmRyMjAwMC9saWJ4ZW5iZS90 cmVlL3hlbl9kbWFfYnVmX3YxCls5XSBodHRwczovL2xrbWwub3JnL2xrbWwvMjAxOC81LzE3LzIx NQoKQ2hhbmdlcyBzaW5jZSB2MToKKioqKioqKioqKioqKioqKioKLSBEZWZpbmUgR05UREVWX0RN QV9GTEFHX1hYWCBzdGFydGluZyBmcm9tIGJpdCAwCi0gUmVuYW1lIG1lbV9yZXNlcnZhdGlvbi5o IHRvIG1lbS1yZXNlcnZhdGlvbi5oCi0gUmVtb3ZlIHVzbGVzcyBjb21tZW50cwotIENoYW5nZSBs aWNlbnNlcyBmcm9tIEdQTHYyIE9SIE1JVCB0byBHUEx2MiBvbmx5Ci0gTWFrZSB4ZW5tZW1fcmVz ZXJ2YXRpb25fdmFfbWFwcGluZ197dXBkYXRlfGNsZWFyfSBpbmxpbmUKLSBDaGFuZ2UgRVhQT1JU X1NZTUJPTCB0byBFWFBPUlRfU1lNQk9MX0dQTCBmb3IgbmV3IGZ1bmN0aW9ucwotIE1ha2UgZ250 dGFiX2RtYV97YWxsb2N8ZnJlZX1fcGFnZXMgdG8gcmVxdWVzdCBmcmFtZXMgYXJyYXkKICBiZSBh bGxvY2F0ZWQgb3V0c2lkZQotIEZpeGUgZ250dGFiX2RtYV9hbGxvY19wYWdlcyBmYWlsIHBhdGgg KGFkZGVkIHhlbm1lbV9yZXNlcnZhdGlvbl9pbmNyZWFzZSkKLSBNb3ZlIG1vc3Qgb2YgZG1hLWJ1 ZiBmcm9tIGdudGRldi5jIHRvIGdudGRldi1kbWFidWYuYwotIEFkZCByZXF1aXJlZCBkZXBlbmRl bmNpZXMgdG8gS2NvbmZpZwotIFJld29yayAiI2lmZGVmIENPTkZJR19YRU5fWFhYIiBmb3IgaWYv ZWxzZQotIEV4cG9ydCBnbnR0YWJfe2FsbG9jfGZyZWV9X3BhZ2VzIGFzIEdQTCBzeW1ib2xzIChw YXRjaCAxKQoKT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gKDkpOgogIHhlbi9ncmFudC10YWJsZTog RXhwb3J0IGdudHRhYl97YWxsb2N8ZnJlZX1fcGFnZXMgYXMgR1BMCiAgeGVuL2dyYW50LXRhYmxl OiBNYWtlIHNldC9jbGVhciBwYWdlIHByaXZhdGUgY29kZSBzaGFyZWQKICB4ZW4vYmFsbG9vbjog U2hhcmUgY29tbW9uIG1lbW9yeSByZXNlcnZhdGlvbiByb3V0aW5lcwogIHhlbi9ncmFudC10YWJs ZTogQWxsb3cgYWxsb2NhdGluZyBidWZmZXJzIHN1aXRhYmxlIGZvciBETUEKICB4ZW4vZ250ZGV2 OiBBbGxvdyBtYXBwaW5ncyBmb3IgRE1BIGJ1ZmZlcnMKICB4ZW4vZ250ZGV2OiBBZGQgaW5pdGlh bCBzdXBwb3J0IGZvciBkbWEtYnVmIFVBUEkKICB4ZW4vZ250ZGV2OiBJbXBsZW1lbnQgZG1hLWJ1 ZiBleHBvcnQgZnVuY3Rpb25hbGl0eQogIHhlbi9nbnRkZXY6IEltcGxlbWVudCBkbWEtYnVmIGlt cG9ydCBmdW5jdGlvbmFsaXR5CiAgeGVuL2dudGRldjogRXhwb3NlIGdudGRldidzIGRtYS1idWYg QVBJIGZvciBpbi1rZXJuZWwgdXNlCgogZHJpdmVycy94ZW4vS2NvbmZpZyAgICAgICAgICAgfCAg MjMgKysKIGRyaXZlcnMveGVuL01ha2VmaWxlICAgICAgICAgIHwgICAyICsKIGRyaXZlcnMveGVu L2JhbGxvb24uYyAgICAgICAgIHwgIDcxICstLS0KIGRyaXZlcnMveGVuL2dudGRldi1kbWFidWYu YyAgIHwgNzA3ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMveGVu L2dudGRldi1kbWFidWYuaCAgIHwgIDQ4ICsrKwogZHJpdmVycy94ZW4vZ250ZGV2LmMgICAgICAg ICAgfCAzODcgKysrKysrKysrKysrKysrKysrLQogZHJpdmVycy94ZW4vZ3JhbnQtdGFibGUuYyAg ICAgfCAxNjUgKysrKysrKy0KIGRyaXZlcnMveGVuL21lbS1yZXNlcnZhdGlvbi5jIHwgMTIwICsr KysrKwogaW5jbHVkZS91YXBpL3hlbi9nbnRkZXYuaCAgICAgfCAxMDYgKysrKysKIGluY2x1ZGUv eGVuL2dyYW50X2Rldi5oICAgICAgIHwgIDM3ICsrCiBpbmNsdWRlL3hlbi9ncmFudF90YWJsZS5o ICAgICB8ICAyMSArCiBpbmNsdWRlL3hlbi9tZW0tcmVzZXJ2YXRpb24uaCB8ICA2NSArKysrCiAx MiBmaWxlcyBjaGFuZ2VkLCAxNjQ3IGluc2VydGlvbnMoKyksIDEwNSBkZWxldGlvbnMoLSkKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3hlbi9nbnRkZXYtZG1hYnVmLmMKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBkcml2ZXJzL3hlbi9nbnRkZXYtZG1hYnVmLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBk cml2ZXJzL3hlbi9tZW0tcmVzZXJ2YXRpb24uYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUv eGVuL2dyYW50X2Rldi5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS94ZW4vbWVtLXJlc2Vy dmF0aW9uLmgKCi0tIAoyLjE3LjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVk ZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail-lf0-f68.google.com ([209.85.215.68]:35141 "EHLO mail-lf0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751092AbeFALll (ORCPT ); Fri, 1 Jun 2018 07:41:41 -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 0/9] xen: dma-buf support for grant device Date: Fri, 1 Jun 2018 14:41:23 +0300 Message-Id: <20180601114132.22596-1-andr2000@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-media-owner@vger.kernel.org List-ID: From: Oleksandr Andrushchenko This work is in response to my previous attempt to introduce Xen/DRM zero-copy driver [1] to enable Linux dma-buf API [2] for Xen based frontends/backends. There is also an existing hyper_dmabuf approach available [3] which, if reworked to utilize the proposed solution, can greatly benefit as well. RFC for this series was published and discussed [9], comments addressed. The original rationale behind this work was to enable zero-copying use-cases while working with Xen para-virtual display driver [4]: when using Xen PV DRM frontend driver then on backend side one will need to do copying of display buffers' contents (filled by the frontend's user-space) into buffers allocated at the backend side. Taking into account the size of display buffers and frames per second it may result in unneeded huge data bus occupation and performance loss. The helper driver [4] allows implementing zero-copying use-cases when using Xen para-virtualized frontend display driver by implementing a DRM/KMS helper driver running on backend's side. It utilizes PRIME buffers API (implemented on top of Linux dma-buf) to share frontend's buffers with physical device drivers on backend's side: - a dumb buffer created on backend's side can be shared with the Xen PV frontend driver, so it directly writes into backend's domain memory (into the buffer exported from DRM/KMS driver of a physical display device) - a dumb buffer allocated by the frontend can be imported into physical device DRM/KMS driver, thus allowing to achieve no copying as well Finally, it was discussed and decided ([1], [5]) that it is worth implementing such use-cases via extension of the existing Xen gntdev driver instead of introducing new DRM specific driver. Please note, that the support of dma-buf is Linux only, as dma-buf is a Linux only thing. Now to the proposed solution. The changes to the existing Xen drivers in the Linux kernel fall into 2 categories: 1. DMA-able memory buffer allocation and increasing/decreasing memory reservation of the pages of such a buffer. This is required if we are about to share dma-buf with the hardware that does require those to be allocated with dma_alloc_xxx API. (It is still possible to allocate a dma-buf from any system memory, e.g. system pages). 2. Extension of the gntdev driver to enable it to import/export dma-buf’s. The first five patches are in preparation for Xen dma-buf support, but I consider those usable regardless of the dma-buf use-case, e.g. other frontend/backend kernel modules may also benefit from these for better code reuse: 0001-xen-grant-table-Export-gnttab_-alloc-free-_pages-as-.patch 0002-xen-grant-table-Make-set-clear-page-private-code-sha.patch 0003-xen-balloon-Share-common-memory-reservation-routines.patch 0004-xen-grant-table-Allow-allocating-buffers-suitable-fo.patch 0005-xen-gntdev-Allow-mappings-for-DMA-buffers.patch The next three patches are Xen implementation of dma-buf as part of the grant device: 0006-xen-gntdev-Add-initial-support-for-dma-buf-UAPI.patch 0007-xen-gntdev-Implement-dma-buf-export-functionality.patch 0008-xen-gntdev-Implement-dma-buf-import-functionality.patch The last patch makes it possible for in-kernel use of Xen dma-buf API: 0009-xen-gntdev-Expose-gntdev-s-dma-buf-API-for-in-kernel.patch The corresponding libxengnttab changes are available at [6]. All the above was tested with display backend [7] and its accompanying helper library [8] on Renesas ARM64 based board. Basic balloon tests on x86. *To all the communities*: I would like to ask you to review the proposed solution and give feedback on it, so I can improve and send final patches for review (this is still work in progress, but enough to start discussing the implementation). Thank you in advance, Oleksandr Andrushchenko [1] https://lists.freedesktop.org/archives/dri-devel/2018-April/173163.html [2] https://elixir.bootlin.com/linux/v4.17-rc5/source/Documentation/driver-api/dma-buf.rst [3] https://lists.xenproject.org/archives/html/xen-devel/2018-02/msg01202.html [4] https://cgit.freedesktop.org/drm/drm-misc/tree/drivers/gpu/drm/xen [5] https://patchwork.kernel.org/patch/10279681/ [6] https://github.com/andr2000/xen/tree/xen_dma_buf_v1 [7] https://github.com/andr2000/displ_be/tree/xen_dma_buf_v1 [8] https://github.com/andr2000/libxenbe/tree/xen_dma_buf_v1 [9] https://lkml.org/lkml/2018/5/17/215 Changes since v1: ***************** - Define GNTDEV_DMA_FLAG_XXX starting from bit 0 - Rename mem_reservation.h to mem-reservation.h - Remove usless comments - Change licenses from GPLv2 OR MIT to GPLv2 only - Make xenmem_reservation_va_mapping_{update|clear} inline - Change EXPORT_SYMBOL to EXPORT_SYMBOL_GPL for new functions - Make gnttab_dma_{alloc|free}_pages to request frames array be allocated outside - Fixe gnttab_dma_alloc_pages fail path (added xenmem_reservation_increase) - Move most of dma-buf from gntdev.c to gntdev-dmabuf.c - Add required dependencies to Kconfig - Rework "#ifdef CONFIG_XEN_XXX" for if/else - Export gnttab_{alloc|free}_pages as GPL symbols (patch 1) Oleksandr Andrushchenko (9): xen/grant-table: Export gnttab_{alloc|free}_pages as GPL xen/grant-table: Make set/clear page private code shared xen/balloon: Share common memory reservation routines xen/grant-table: Allow allocating buffers suitable for DMA xen/gntdev: Allow mappings for DMA buffers xen/gntdev: Add initial support for dma-buf UAPI xen/gntdev: Implement dma-buf export functionality xen/gntdev: Implement dma-buf import functionality xen/gntdev: Expose gntdev's dma-buf API for in-kernel use drivers/xen/Kconfig | 23 ++ drivers/xen/Makefile | 2 + drivers/xen/balloon.c | 71 +--- drivers/xen/gntdev-dmabuf.c | 707 ++++++++++++++++++++++++++++++++++ drivers/xen/gntdev-dmabuf.h | 48 +++ drivers/xen/gntdev.c | 387 ++++++++++++++++++- drivers/xen/grant-table.c | 165 +++++++- drivers/xen/mem-reservation.c | 120 ++++++ include/uapi/xen/gntdev.h | 106 +++++ include/xen/grant_dev.h | 37 ++ include/xen/grant_table.h | 21 + include/xen/mem-reservation.h | 65 ++++ 12 files changed, 1647 insertions(+), 105 deletions(-) create mode 100644 drivers/xen/gntdev-dmabuf.c create mode 100644 drivers/xen/gntdev-dmabuf.h create mode 100644 drivers/xen/mem-reservation.c create mode 100644 include/xen/grant_dev.h create mode 100644 include/xen/mem-reservation.h -- 2.17.0