Differential D10747 Diff 60360 src/server/linuxdmabuf_v1_interface.cpp

Changeset View

Standalone View

src/server/linuxdmabuf_v1_interface.cpp

This file was added.

1		/********************************************************************
2		Copyright © 2018 Fredrik Höglund <fredrik@kde.org>
3
4		Based on the libweston implementation,
5		Copyright © 2014, 2015 Collabora, Ltd.
6
7		This library is free software; you can redistribute it and/or
8		modify it under the terms of the GNU Lesser General Public
9		License as published by the Free Software Foundation; either
10		version 2.1 of the License, or (at your option) version 3, or any
11		later version accepted by the membership of KDE e.V. (or its
12		successor approved by the membership of KDE e.V.), which shall
13		act as a proxy defined in Section 6 of version 3 of the license.
14
15		This library is distributed in the hope that it will be useful,
16		but WITHOUT ANY WARRANTY; without even the implied warranty of
17		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18		Lesser General Public License for more details.
19
20		You should have received a copy of the GNU Lesser General Public
21		License along with this library. If not, see <http://www.gnu.org/licenses/>.
22		*********************************************************************/
23
24		#include <KWayland/Server/kwaylandserver_export.h>
25		#include "linuxdmabuf_v1_interface.h"
26		#include "wayland-linux-dmabuf-unstable-v1-server-protocol.h"
27		#include "wayland-server-protocol.h"
28		#include "global_p.h"
29
30		#include "drm_fourcc.h"
31
32		#include <QVector>
33
34		#include <unistd.h>
35		#include <assert.h>
36
37		#include <array>
38
39
40		namespace KWayland
41		{
42
43		namespace Server
44		{
45
46
47		class LinuxDmabufParams
48		{
49		public:
50		LinuxDmabufParams(LinuxDmabufUnstableV1Interface dmabufInterface, wl_client client, uint32_t version, uint32_t id);
51		~LinuxDmabufParams();
52
53		void postNoMemory() { wl_resource_post_no_memory(m_resource); }
54
55		wl_resource *resource() const { return m_resource; }
56
57		void add(int fd, uint32_t plane_idx, uint32_t offset, uint32_t stride, uint64_t modifier);
58		void create(wl_client *client, uint32_t bufferId, const QSize &size, uint32_t format, uint32_t flags);
59
60		static void destroy(wl_client client, wl_resource resource);
61		static void add(wl_client client, wl_resource resource, int fd, uint32_t plane_idx, uint32_t offset, uint32_t stride, uint32_t modifier_hi, uint32_t modifier_lo);
62		static void create(wl_client client, wl_resource resource, int width, int height, uint32_t format, uint32_t flags);
63		static void createImmed(wl_client client, wl_resource resource, uint32_t new_id, int width, int height, uint32_t format, uint32_t flags);
64
65		private:
66		static const struct zwp_linux_buffer_params_v1_interface s_interface;
67
68		wl_resource *m_resource;
69		LinuxDmabufUnstableV1Interface *m_dmabufInterface;
70		std::array<LinuxDmabuf::Plane, 4> m_planes;
71		size_t m_planeCount = 0;
72		bool m_bufferCreated = false;
73		};
74
75
76		#ifndef DOXYGEN_SHOULD_SKIP_THIS
77		const struct zwp_linux_buffer_params_v1_interface LinuxDmabufParams::s_interface = {
78		destroy,
79		add,
80		create,
81		createImmed
82		};
83		#endif
84
85
86		LinuxDmabufParams::LinuxDmabufParams(LinuxDmabufUnstableV1Interface dmabufInterface, wl_client client, uint32_t version, uint32_t id)
87		: m_dmabufInterface(dmabufInterface)
88		{
89		m_resource = wl_resource_create(client, &zwp_linux_buffer_params_v1_interface, version, id);
90		if (!m_resource) {
91		return;
92		}
93
94		wl_resource_set_implementation(m_resource, &s_interface, this,
95		[](wl_resource *resource) {
96		delete static_cast<LinuxDmabufParams *>(wl_resource_get_user_data(resource));
97		});
98
99		for (auto &plane : m_planes) {
100		plane.fd = -1;
101		plane.offset = 0;
102		plane.stride = 0;
103		plane.modifier = 0;
104		}
105		}
106
107
108		LinuxDmabufParams::~LinuxDmabufParams()
109		{
110		// Close the file descriptors
111		for (auto &plane : m_planes) {
112		if (plane.fd != -1) {
113		::close(plane.fd);
114		}
115		}
116		}
117
118
119		void LinuxDmabufParams::create(wl_client *client, uint32_t bufferId, const QSize &size, uint32_t format, uint32_t flags)
120		{
121		// Validate the parameters
122		// -----------------------
123		const uint32_t width = size.width();
124		const uint32_t height = size.height();
125
126		if (m_bufferCreated) {
127		wl_resource_post_error(m_resource,
128		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_ALREADY_USED,
129		"params was already used to create a wl_buffer");
130		return;
131		}
132
133		if (m_planeCount == 0) {
134		wl_resource_post_error(m_resource,
135		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INCOMPLETE,
136		"no dmabuf has been added to the params");
137		return;
138		}
139
140		// Check for holes in the dmabufs set (e.g. [0, 1, 3])
141		for (uint32_t i = 0; i < m_planeCount; i++) {
142		if (m_planes[i].fd != -1)
143		continue;
144
145		wl_resource_post_error(m_resource,
146		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INCOMPLETE,
147		"no dmabuf has been added for plane %i", i);
148		return;
149		}
150
151		if (width < 1 \|\| height < 1) {
152		wl_resource_post_error(m_resource,
153		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_DIMENSIONS,
154		"invalid width %d or height %d", width, height);
155		return;
156		}
157
158		for (uint32_t i = 0; i < m_planeCount; i++) {
159		auto &plane = m_planes[i];
160
161		if (uint64_t(plane.offset) + plane.stride > UINT32_MAX) {
162		wl_resource_post_error(m_resource,
163		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_OUT_OF_BOUNDS,
164		"size overflow for plane %i", i);
165		return;
166		}
167
168		if (i == 0 && uint64_t(plane.offset) + plane.stride * height > UINT32_MAX) {
169		wl_resource_post_error(m_resource,
170		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_OUT_OF_BOUNDS,
171		"size overflow for plane %i", i);
172		return;
173		}
174
175		// Don't report an error as it might be caused by the kernel not supporting seeking on dmabuf
176		off_t size = ::lseek(plane.fd, 0, SEEK_END);
177		if (size == -1)
178		continue;
179
180		if (plane.offset >= size) {
181		wl_resource_post_error(m_resource,
182		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_OUT_OF_BOUNDS,
183		"invalid offset %i for plane %i",
184		plane.offset, i);
185		return;
186		}
187
188		if (plane.offset + plane.stride > size) {
189		wl_resource_post_error(m_resource,
190		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_OUT_OF_BOUNDS,
191		"invalid stride %i for plane %i",
192		plane.stride, i);
193		return;
194		}
195
196		// Only valid for first plane as other planes might be
197		// sub-sampled according to fourcc format
198		if (i == 0 && plane.offset + plane.stride * height > size) {
199		wl_resource_post_error(m_resource,
200		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_OUT_OF_BOUNDS,
201		"invalid buffer stride or height for plane %i", i);
202		return;
203		}
204		}
205
206
207		// Import the buffer
208		// -----------------
209		QVector<LinuxDmabuf::Plane> planes;
210		planes.reserve(m_planeCount);
211		for (uint32_t i = 0; i < m_planeCount; i++)
212		planes << m_planes[i];
213
214		LinuxDmabuf::Buffer *buffer = m_dmabufInterface->bridge()->importBuffer(planes, format, size, (LinuxDmabuf::Flags) flags);
215		if (buffer) {
216		// The buffer has ownership of the file descriptors now
217		for (auto &plane : m_planes) {
218		plane.fd = -1;
219		}
220
221		wl_resource *resource = wl_resource_create(client, &wl_buffer_interface, 1, bufferId);
222		if (!resource ) {
223		postNoMemory();
224		delete buffer;
225		return;
226		}
227
228		wl_resource_set_implementation(resource, m_dmabufInterface->bufferImplementation(), buffer,
229		[](wl_resource *resource) { // Destructor
230		delete static_cast<LinuxDmabuf::Buffer *>(wl_resource_get_user_data(resource));
231		});
232
233		// XXX Do we need this?
234		//buffer->setResource(resource);
235
236		// Send a 'created' event when the request is not for an immediate import, i.e. bufferId is zero
237		if (bufferId == 0) {
238		zwp_linux_buffer_params_v1_send_created(m_resource, resource);
239		}
240
241		m_bufferCreated = true;
242		} else {
243		if (bufferId == 0) {
244		zwp_linux_buffer_params_v1_send_failed(m_resource);
245		} else {
246		// since the behavior is left implementation defined by the
247		// protocol in case of create_immed failure due to an unknown cause,
248		// we choose to treat it as a fatal error and immediately kill the
249		// client instead of creating an invalid handle and waiting for it
250		// to be used.
251		wl_resource_post_error(m_resource,
252		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_WL_BUFFER,
253		"importing the supplied dmabufs failed");
254		}
255		}
256		}
257
258
259		void LinuxDmabufParams::add(int fd, uint32_t plane_idx, uint32_t offset, uint32_t stride, uint64_t modifier)
260		{
261		if (m_bufferCreated) {
262		wl_resource_post_error(m_resource,
263		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_ALREADY_USED,
264		"params was already used to create a wl_buffer");
265		::close(fd);
266		return;
267		}
268
269		if (plane_idx >= m_planes.size()) {
270		wl_resource_post_error(m_resource,
271		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_IDX,
272		"plane index %u is too high", plane_idx);
273		::close(fd);
274		return;
275		}
276
277		auto &plane = m_planes[plane_idx];
278
279		if (plane.fd != -1) {
280		wl_resource_post_error(m_resource,
281		ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_SET,
282		"a dmabuf has already been added for plane %u",
283		plane_idx);
284		::close(fd);
285		return;
286		}
287
288		plane.fd = fd;
289		plane.offset = offset;
290		plane.stride = stride;
291		plane.modifier = modifier;
292
293		m_planeCount++;
294		}
295
296
297
298		// --------------------------------------------------------------------
299
300
301
302		void LinuxDmabufParams::destroy(wl_client client, wl_resource resource)
303		{
304		Q_UNUSED(client)
305		wl_resource_destroy(resource);
306		}
307
308
309		void LinuxDmabufParams::add(wl_client client, wl_resource resource,
310		int fd, uint32_t plane_idx,
311		uint32_t offset, uint32_t stride,
312		uint32_t modifier_hi, uint32_t modifier_lo)
313		{
314		Q_UNUSED(client)
315
316		LinuxDmabufParams params = static_cast<LinuxDmabufParams >(wl_resource_get_user_data(resource));
317		assert(params->m_resource == resource);
318		params->add(fd, plane_idx, offset, stride, (uint64_t(modifier_hi) << 32) \| modifier_lo);
319		}
320
321
322		void LinuxDmabufParams::create(wl_client client, wl_resource resource,
323		int width, int height, uint32_t format, uint32_t flags)
324		{
325		Q_UNUSED(client)
326
327		LinuxDmabufParams params = static_cast<LinuxDmabufParams >(wl_resource_get_user_data(resource));
328		assert(params->m_resource == resource);
329		params->create(client, 0, QSize(width, height), format, flags);
330		}
331
332
333		void LinuxDmabufParams::createImmed(wl_client client, wl_resource resource,
334		uint32_t new_id, int width, int height,
335		uint32_t format, uint32_t flags)
336		{
337		Q_UNUSED(client)
338
339		LinuxDmabufParams params = static_cast<LinuxDmabufParams >(wl_resource_get_user_data(resource));
340		assert(params->m_resource == resource);
341		params->create(client, new_id, QSize(width, height), format, flags);
342		}
343
344
345
346		// --------------------------------------------------------------------
347
348
349
350		class LinuxDmabufUnstableV1Interface::Private : public Global::Private
351		{
352		public:
353		Private(LinuxDmabufUnstableV1Interface q, Display display);
354		~Private();
355
356		static const struct wl_buffer_interface *bufferImplementation() { return &s_bufferImplementation; }
357		LinuxDmabufUnstableV1Interface::Bridge *bridge;
358		LinuxDmabufUnstableV1Interface * const q;
359		static const uint32_t s_version;
360
361		void bind(wl_client *client, uint32_t version, uint32_t id) override final;
362		void createParams(wl_client client, wl_resource resource, uint32_t id);
363
364		static void unbind(wl_client client, wl_resource resource);
365		static void createParamsCallback(wl_client client, wl_resource resource, uint32_t id);
	davidedmundsonUnsubmitted Not Done is this defined? I can't find it I'd expect it be used on line 408. davidedmundson: is this defined? I can't find it I'd expect it be used on line 408.
366
367		private:
368		static const struct zwp_linux_dmabuf_v1_interface s_implementation;
369		static const struct wl_buffer_interface s_bufferImplementation;
370		};
371
372
373		#ifndef DOXYGEN_SHOULD_SKIP_THIS
374		const struct zwp_linux_dmabuf_v1_interface LinuxDmabufUnstableV1Interface::Private::s_implementation = {
375		[](wl_client , wl_resource resource) { wl_resource_destroy(resource); }, // unbind
376		createParamsCallback
377		};
378
379
380		const struct wl_buffer_interface LinuxDmabufUnstableV1Interface::Private::s_bufferImplementation = {
381		[](wl_client , wl_resource resource) { wl_resource_destroy(resource); } // destroy
382		};
383
384		const uint32_t LinuxDmabufUnstableV1Interface::Private::s_version = 3;
385		#endif
386
387
388		LinuxDmabufUnstableV1Interface::Private::Private(LinuxDmabufUnstableV1Interface q, Display display)
389		: Global::Private(display, &zwp_linux_dmabuf_v1_interface, s_version),
390		q(q)
391		{
392		}
393
394
395		LinuxDmabufUnstableV1Interface::Private::~Private()
396		{
397		}
398
399
400		void LinuxDmabufUnstableV1Interface::Private::bind(wl_client *client, uint32_t version, uint32_t id)
401		{
402		wl_resource *resource = wl_resource_create(client, &zwp_linux_dmabuf_v1_interface, std::min(s_version, version), id);
403		if (!resource) {
404		wl_client_post_no_memory(client);
405		return;
406		}
407
408		wl_resource_set_implementation(resource, &s_implementation, this, nullptr);
409
410		// Send formats & modifiers
411		// ------------------------
412		const QVector<uint32_t> formats = bridge->supportedFormats();
413		for (uint32_t format : formats) {
414		QVector<uint64_t> modifiers = bridge->supportedModifiers(format);
415		if (modifiers.isEmpty()) {
416		modifiers << DRM_FORMAT_MOD_INVALID;
417		}
418
419		for (uint64_t modifier : qAsConst(modifiers)) {
420		if (version >= ZWP_LINUX_DMABUF_V1_MODIFIER_SINCE_VERSION) {
421		const uint32_t modifier_lo = modifier & 0xFFFFFFFF;
422		const uint32_t modifier_hi = modifier >> 32;
423		zwp_linux_dmabuf_v1_send_modifier(resource, format, modifier_hi, modifier_lo);
424		} else if (modifier == DRM_FORMAT_MOD_LINEAR \|\| modifier == DRM_FORMAT_MOD_INVALID) {
425		zwp_linux_dmabuf_v1_send_format(resource, format);
426		}
427		}
428		}
429		}
430
431
432		void LinuxDmabufUnstableV1Interface::Private::createParams(wl_client client, wl_resource resource, uint32_t id)
433		{
434		LinuxDmabufParams *params = new LinuxDmabufParams(q, client, wl_resource_get_version(resource), id);
435		if (!params->resource()) {
436		wl_resource_post_no_memory(resource);
437		delete params;
438		}
439		}
440
441
442		void LinuxDmabufUnstableV1Interface::Private::createParamsCallback(wl_client client, wl_resource resource, uint32_t id)
443		{
444		LinuxDmabufUnstableV1Interface::Private global = static_cast<LinuxDmabufUnstableV1Interface::Private >(wl_resource_get_user_data(resource));
445		global->createParams(client, resource, id);
446		}
447
448
449
450		// --------------------------------------------------------------------
451
452
453
454		LinuxDmabufUnstableV1Interface::LinuxDmabufUnstableV1Interface(Display display, QObject parent)
455		: Global(new Private(this, display), parent)
456		{
457		}
458
459
460		LinuxDmabufUnstableV1Interface::~LinuxDmabufUnstableV1Interface()
461		{
462		}
463
464
465		void LinuxDmabufUnstableV1Interface::setBridge(LinuxDmabufUnstableV1Interface::Bridge *bridge)
466		{
467		d_func()->bridge = bridge;
468		}
469
470
471		LinuxDmabufUnstableV1Interface::Bridge *LinuxDmabufUnstableV1Interface::bridge() const
472		{
473		return d_func()->bridge;
474		}
475
476
477		const struct wl_buffer_interface *LinuxDmabufUnstableV1Interface::bufferImplementation()
478		{
479		return LinuxDmabufUnstableV1Interface::Private::bufferImplementation();
480		}
481
482
483		LinuxDmabufUnstableV1Interface::Private *LinuxDmabufUnstableV1Interface::d_func() const
484		{
485		return reinterpret_cast<Private*>(d.data());
486		}
487
488
489		} // namespace Server
490		} // namespace Wayland