2014-03-12 00:11:39 +01:00
|
|
|
/*
|
|
|
|
* Copyright © 2014 Intel Corporation
|
|
|
|
* Copyright © 2012 Collabora, Ltd.
|
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, distribute, and sell this software
|
|
|
|
* and its documentation for any purpose is hereby granted without
|
|
|
|
* fee, provided that the above copyright notice appear in all copies
|
|
|
|
* and that both that copyright notice and this permission notice
|
|
|
|
* appear in supporting documentation, and that the name of the
|
|
|
|
* copyright holders not be used in advertising or publicity
|
|
|
|
* pertaining to distribution of the software without specific,
|
|
|
|
* written prior permission. The copyright holders make no
|
|
|
|
* representations about the suitability of this software for any
|
|
|
|
* purpose. It is provided "as is" without express or implied
|
|
|
|
* warranty.
|
|
|
|
*
|
|
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
|
|
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
|
|
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
|
|
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
|
|
|
|
* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
|
|
|
* SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2019-12-16 17:07:02 +01:00
|
|
|
#include <xwayland-config.h>
|
2014-03-12 00:11:39 +01:00
|
|
|
|
2019-12-17 17:07:58 +01:00
|
|
|
#include "os.h"
|
|
|
|
|
2014-03-12 00:11:39 +01:00
|
|
|
#include <sys/mman.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
2019-12-16 17:07:02 +01:00
|
|
|
#include "fb.h"
|
|
|
|
#include "os.h"
|
|
|
|
#include "pixmapstr.h"
|
|
|
|
|
2019-12-17 17:07:58 +01:00
|
|
|
#include "xwayland-pixmap.h"
|
2019-12-18 10:03:43 +01:00
|
|
|
#include "xwayland-screen.h"
|
2019-12-16 17:07:02 +01:00
|
|
|
#include "xwayland-shm.h"
|
|
|
|
|
2014-03-12 00:11:39 +01:00
|
|
|
struct xwl_pixmap {
|
|
|
|
struct wl_buffer *buffer;
|
|
|
|
void *data;
|
|
|
|
size_t size;
|
|
|
|
};
|
|
|
|
|
|
|
|
#ifndef HAVE_MKOSTEMP
|
|
|
|
static int
|
|
|
|
set_cloexec_or_close(int fd)
|
|
|
|
{
|
|
|
|
long flags;
|
|
|
|
|
|
|
|
if (fd == -1)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
flags = fcntl(fd, F_GETFD);
|
|
|
|
if (flags == -1)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
return fd;
|
|
|
|
|
|
|
|
err:
|
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static int
|
|
|
|
create_tmpfile_cloexec(char *tmpname)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
#ifdef HAVE_MKOSTEMP
|
|
|
|
fd = mkostemp(tmpname, O_CLOEXEC);
|
|
|
|
if (fd >= 0)
|
|
|
|
unlink(tmpname);
|
|
|
|
#else
|
|
|
|
fd = mkstemp(tmpname);
|
|
|
|
if (fd >= 0) {
|
|
|
|
fd = set_cloexec_or_close(fd);
|
|
|
|
unlink(tmpname);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-06-23 15:05:31 +02:00
|
|
|
return os_move_fd(fd);
|
2014-03-12 00:11:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a new, unique, anonymous file of the given size, and
|
|
|
|
* return the file descriptor for it. The file descriptor is set
|
|
|
|
* CLOEXEC. The file is immediately suitable for mmap()'ing
|
|
|
|
* the given size at offset zero.
|
|
|
|
*
|
|
|
|
* The file should not have a permanent backing store like a disk,
|
|
|
|
* but may have if XDG_RUNTIME_DIR is not properly implemented in OS.
|
|
|
|
*
|
|
|
|
* The file name is deleted from the file system.
|
|
|
|
*
|
|
|
|
* The file is suitable for buffer sharing between processes by
|
|
|
|
* transmitting the file descriptor over Unix sockets using the
|
|
|
|
* SCM_RIGHTS methods.
|
|
|
|
*
|
|
|
|
* If the C library implements posix_fallocate(), it is used to
|
|
|
|
* guarantee that disk space is available for the file at the
|
2020-07-05 22:07:33 +02:00
|
|
|
* given size. If disk space is insufficient, errno is set to ENOSPC.
|
2014-03-12 00:11:39 +01:00
|
|
|
* If posix_fallocate() is not supported, program may receive
|
|
|
|
* SIGBUS on accessing mmap()'ed file contents instead.
|
2020-07-11 19:34:59 +02:00
|
|
|
*
|
|
|
|
* If the C library implements memfd_create(), it is used to create the
|
|
|
|
* file purely in memory, without any backing file name on the file
|
|
|
|
* system, and then sealing off the possibility of shrinking it. This
|
|
|
|
* can then be checked before accessing mmap()'ed file contents, to
|
|
|
|
* make sure SIGBUS can't happen. It also avoids requiring
|
|
|
|
* XDG_RUNTIME_DIR.
|
2014-03-12 00:11:39 +01:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
os_create_anonymous_file(off_t size)
|
|
|
|
{
|
2016-02-19 08:08:12 +01:00
|
|
|
static const char template[] = "/xwayland-shared-XXXXXX";
|
2014-03-12 00:11:39 +01:00
|
|
|
const char *path;
|
|
|
|
char *name;
|
|
|
|
int fd;
|
|
|
|
int ret;
|
|
|
|
|
2020-07-11 19:34:59 +02:00
|
|
|
#ifdef HAVE_MEMFD_CREATE
|
|
|
|
fd = memfd_create("xwayland-shared", MFD_CLOEXEC | MFD_ALLOW_SEALING);
|
|
|
|
if (fd >= 0) {
|
|
|
|
/* We can add this seal before calling posix_fallocate(), as
|
|
|
|
* the file is currently zero-sized anyway.
|
|
|
|
*
|
|
|
|
* There is also no need to check for the return value, we
|
|
|
|
* couldn't do anything with it anyway.
|
|
|
|
*/
|
|
|
|
fcntl(fd, F_ADD_SEALS, F_SEAL_SHRINK);
|
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
path = getenv("XDG_RUNTIME_DIR");
|
|
|
|
if (!path) {
|
|
|
|
errno = ENOENT;
|
|
|
|
return -1;
|
|
|
|
}
|
2014-03-12 00:11:39 +01:00
|
|
|
|
2020-07-11 19:34:59 +02:00
|
|
|
name = malloc(strlen(path) + sizeof(template));
|
|
|
|
if (!name)
|
|
|
|
return -1;
|
2014-03-12 00:11:39 +01:00
|
|
|
|
2020-07-11 19:34:59 +02:00
|
|
|
strcpy(name, path);
|
|
|
|
strcat(name, template);
|
2014-03-12 00:11:39 +01:00
|
|
|
|
2020-07-11 19:34:59 +02:00
|
|
|
fd = create_tmpfile_cloexec(name);
|
2014-03-12 00:11:39 +01:00
|
|
|
|
2020-07-11 19:34:59 +02:00
|
|
|
free(name);
|
2014-03-12 00:11:39 +01:00
|
|
|
|
2020-07-11 19:34:59 +02:00
|
|
|
if (fd < 0)
|
|
|
|
return -1;
|
|
|
|
}
|
2014-03-12 00:11:39 +01:00
|
|
|
|
|
|
|
#ifdef HAVE_POSIX_FALLOCATE
|
2016-05-25 09:41:53 +02:00
|
|
|
/*
|
|
|
|
* posix_fallocate does an explicit rollback if it gets EINTR.
|
|
|
|
* Temporarily block signals to allow the call to succeed on
|
|
|
|
* slow systems where the smart scheduler's SIGALRM prevents
|
|
|
|
* large allocation attempts from ever succeeding.
|
|
|
|
*/
|
|
|
|
OsBlockSignals();
|
2016-04-25 11:33:00 +02:00
|
|
|
do {
|
|
|
|
ret = posix_fallocate(fd, 0, size);
|
|
|
|
} while (ret == EINTR);
|
2016-05-25 09:41:53 +02:00
|
|
|
OsReleaseSignals();
|
2016-04-25 11:33:00 +02:00
|
|
|
|
2014-03-12 00:11:39 +01:00
|
|
|
if (ret != 0) {
|
|
|
|
close(fd);
|
|
|
|
errno = ret;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#else
|
2016-04-25 11:33:00 +02:00
|
|
|
do {
|
|
|
|
ret = ftruncate(fd, size);
|
|
|
|
} while (ret == -1 && errno == EINTR);
|
|
|
|
|
2014-03-12 00:11:39 +01:00
|
|
|
if (ret < 0) {
|
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t
|
|
|
|
shm_format_for_depth(int depth)
|
|
|
|
{
|
|
|
|
switch (depth) {
|
|
|
|
case 32:
|
|
|
|
return WL_SHM_FORMAT_ARGB8888;
|
|
|
|
case 24:
|
|
|
|
default:
|
|
|
|
return WL_SHM_FORMAT_XRGB8888;
|
|
|
|
#ifdef WL_SHM_FORMAT_RGB565
|
|
|
|
case 16:
|
|
|
|
/* XXX: Check run-time protocol version too */
|
|
|
|
return WL_SHM_FORMAT_RGB565;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-30 13:17:34 +01:00
|
|
|
static const struct wl_buffer_listener xwl_shm_buffer_listener = {
|
|
|
|
xwl_pixmap_buffer_release_cb,
|
|
|
|
};
|
|
|
|
|
2014-03-12 00:11:39 +01:00
|
|
|
PixmapPtr
|
|
|
|
xwl_shm_create_pixmap(ScreenPtr screen,
|
|
|
|
int width, int height, int depth, unsigned int hint)
|
|
|
|
{
|
2016-02-05 14:44:29 +01:00
|
|
|
struct xwl_screen *xwl_screen = xwl_screen_get(screen);
|
2014-03-12 00:11:39 +01:00
|
|
|
struct xwl_pixmap *xwl_pixmap;
|
2016-02-05 14:44:29 +01:00
|
|
|
struct wl_shm_pool *pool;
|
|
|
|
PixmapPtr pixmap;
|
2014-03-12 00:11:39 +01:00
|
|
|
size_t size, stride;
|
2016-02-05 14:44:29 +01:00
|
|
|
uint32_t format;
|
|
|
|
int fd;
|
2014-03-12 00:11:39 +01:00
|
|
|
|
|
|
|
if (hint == CREATE_PIXMAP_USAGE_GLYPH_PICTURE ||
|
2019-07-09 11:08:27 +02:00
|
|
|
(!xwl_screen->rootless && hint != CREATE_PIXMAP_USAGE_BACKING_PIXMAP) ||
|
2014-03-12 00:11:39 +01:00
|
|
|
(width == 0 && height == 0) || depth < 15)
|
|
|
|
return fbCreatePixmap(screen, width, height, depth, hint);
|
|
|
|
|
|
|
|
pixmap = fbCreatePixmap(screen, 0, 0, depth, hint);
|
|
|
|
if (!pixmap)
|
|
|
|
return NULL;
|
|
|
|
|
2019-10-30 13:11:28 +01:00
|
|
|
xwl_pixmap = calloc(1, sizeof(*xwl_pixmap));
|
2014-03-12 00:11:39 +01:00
|
|
|
if (xwl_pixmap == NULL)
|
|
|
|
goto err_destroy_pixmap;
|
|
|
|
|
|
|
|
stride = PixmapBytePad(width, depth);
|
|
|
|
size = stride * height;
|
|
|
|
xwl_pixmap->buffer = NULL;
|
|
|
|
xwl_pixmap->size = size;
|
2016-02-05 14:44:29 +01:00
|
|
|
fd = os_create_anonymous_file(size);
|
|
|
|
if (fd < 0)
|
2014-03-12 00:11:39 +01:00
|
|
|
goto err_free_xwl_pixmap;
|
|
|
|
|
|
|
|
xwl_pixmap->data = mmap(NULL, size, PROT_READ | PROT_WRITE,
|
2016-02-05 14:44:29 +01:00
|
|
|
MAP_SHARED, fd, 0);
|
2014-03-12 00:11:39 +01:00
|
|
|
if (xwl_pixmap->data == MAP_FAILED)
|
|
|
|
goto err_close_fd;
|
|
|
|
|
|
|
|
if (!(*screen->ModifyPixmapHeader) (pixmap, width, height, depth,
|
|
|
|
BitsPerPixel(depth),
|
|
|
|
stride, xwl_pixmap->data))
|
|
|
|
goto err_munmap;
|
|
|
|
|
2016-02-05 14:44:29 +01:00
|
|
|
format = shm_format_for_depth(pixmap->drawable.depth);
|
|
|
|
pool = wl_shm_create_pool(xwl_screen->shm, fd, xwl_pixmap->size);
|
|
|
|
xwl_pixmap->buffer = wl_shm_pool_create_buffer(pool, 0,
|
|
|
|
pixmap->drawable.width,
|
|
|
|
pixmap->drawable.height,
|
|
|
|
pixmap->devKind, format);
|
|
|
|
wl_shm_pool_destroy(pool);
|
|
|
|
close(fd);
|
|
|
|
|
2019-10-30 13:17:34 +01:00
|
|
|
wl_buffer_add_listener(xwl_pixmap->buffer,
|
|
|
|
&xwl_shm_buffer_listener, pixmap);
|
|
|
|
|
2014-03-12 00:11:39 +01:00
|
|
|
xwl_pixmap_set_private(pixmap, xwl_pixmap);
|
|
|
|
|
|
|
|
return pixmap;
|
|
|
|
|
|
|
|
err_munmap:
|
|
|
|
munmap(xwl_pixmap->data, size);
|
|
|
|
err_close_fd:
|
2016-02-05 14:44:29 +01:00
|
|
|
close(fd);
|
2014-03-12 00:11:39 +01:00
|
|
|
err_free_xwl_pixmap:
|
|
|
|
free(xwl_pixmap);
|
|
|
|
err_destroy_pixmap:
|
|
|
|
fbDestroyPixmap(pixmap);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
Bool
|
|
|
|
xwl_shm_destroy_pixmap(PixmapPtr pixmap)
|
|
|
|
{
|
|
|
|
struct xwl_pixmap *xwl_pixmap = xwl_pixmap_get(pixmap);
|
|
|
|
|
|
|
|
if (xwl_pixmap && pixmap->refcnt == 1) {
|
2019-10-30 13:17:34 +01:00
|
|
|
xwl_pixmap_del_buffer_release_cb(pixmap);
|
2014-03-12 00:11:39 +01:00
|
|
|
if (xwl_pixmap->buffer)
|
|
|
|
wl_buffer_destroy(xwl_pixmap->buffer);
|
|
|
|
munmap(xwl_pixmap->data, xwl_pixmap->size);
|
|
|
|
free(xwl_pixmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
return fbDestroyPixmap(pixmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct wl_buffer *
|
|
|
|
xwl_shm_pixmap_get_wl_buffer(PixmapPtr pixmap)
|
|
|
|
{
|
2016-02-05 14:44:29 +01:00
|
|
|
return xwl_pixmap_get(pixmap)->buffer;
|
2014-03-12 00:11:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
Bool
|
|
|
|
xwl_shm_create_screen_resources(ScreenPtr screen)
|
|
|
|
{
|
|
|
|
struct xwl_screen *xwl_screen = xwl_screen_get(screen);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
screen->CreateScreenResources = xwl_screen->CreateScreenResources;
|
|
|
|
ret = (*screen->CreateScreenResources) (screen);
|
|
|
|
xwl_screen->CreateScreenResources = screen->CreateScreenResources;
|
|
|
|
screen->CreateScreenResources = xwl_shm_create_screen_resources;
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
return ret;
|
|
|
|
|
dix: Add hybrid full-size/empty-clip mode to SetRootClip
216bdbc735 removed the SetRootClip call in the XWayland output-hotplug
handler when running rootless (e.g. as a part of Weston/Mutter), since
the root window has no storage, so generating exposures will result in
writes to invalid memory.
Unfortunately, preventing the segfault also breaks sprite confinement.
SetRootClip updates winSize and borderSize for the root window, which
when combined with RRScreenSizeChanged calling ScreenRestructured,
generates a new sprite-confinment area to update it to the whole screen.
Removing this call results in the window geometry being reported
correctly, but winSize/borderSize never changing from their values at
startup, i.e. out of sync with the root window geometry / screen
information in the connection info / XRandR.
This patch introduces a hybrid mode, where we update winSize and
borderSize for the root window, enabling sprite confinement to work
correctly, but keep the clip emptied so exposures are never generated.
Signed-off-by: Daniel Stone <daniels@collabora.com>
Tested-by: Olivier Fourdan <ofourdan@redhat.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2016-02-12 17:36:59 +01:00
|
|
|
if (xwl_screen->rootless)
|
2014-03-12 00:11:39 +01:00
|
|
|
screen->devPrivate =
|
|
|
|
fbCreatePixmap(screen, 0, 0, screen->rootDepth, 0);
|
|
|
|
else
|
|
|
|
screen->devPrivate =
|
|
|
|
xwl_shm_create_pixmap(screen, screen->width, screen->height,
|
|
|
|
screen->rootDepth,
|
|
|
|
CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
|
|
|
|
|
dix: Add hybrid full-size/empty-clip mode to SetRootClip
216bdbc735 removed the SetRootClip call in the XWayland output-hotplug
handler when running rootless (e.g. as a part of Weston/Mutter), since
the root window has no storage, so generating exposures will result in
writes to invalid memory.
Unfortunately, preventing the segfault also breaks sprite confinement.
SetRootClip updates winSize and borderSize for the root window, which
when combined with RRScreenSizeChanged calling ScreenRestructured,
generates a new sprite-confinment area to update it to the whole screen.
Removing this call results in the window geometry being reported
correctly, but winSize/borderSize never changing from their values at
startup, i.e. out of sync with the root window geometry / screen
information in the connection info / XRandR.
This patch introduces a hybrid mode, where we update winSize and
borderSize for the root window, enabling sprite confinement to work
correctly, but keep the clip emptied so exposures are never generated.
Signed-off-by: Daniel Stone <daniels@collabora.com>
Tested-by: Olivier Fourdan <ofourdan@redhat.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>
2016-02-12 17:36:59 +01:00
|
|
|
SetRootClip(screen, xwl_screen->root_clip_mode);
|
|
|
|
|
2014-03-12 00:11:39 +01:00
|
|
|
return screen->devPrivate != NULL;
|
|
|
|
}
|