[RFC PATCH v4 1/1] drm: implement decoding of DRM ioctls
Zhibin Li
haoyouab at gmail.com
Tue Aug 27 05:37:28 UTC 2019
On Wed, Aug 14, 2019 at 10:59 PM Zhibin Li <haoyouab at gmail.com> wrote:
> Oh sorry, I just realized that those changes like
> print_uint16_array_member()
> or new macros should be sent in a separate patch. They are common changes
> instead of DRM specific ones.
>
Hi, just wonder whether there's any other issues I should pay attention to
in this patch
since it's been a while.
>
> On Tue, Aug 13, 2019 at 12:42 AM Zhibin Li <haoyouab at gmail.com> wrote:
>
>> * drm_mpers.c: New file.
>> * drm.c: Likewise.
>> * linux/drm/drm.h: Likewise.
>> * linux/drm/drm_mode.h: Likewise.
>> * defs.h (drm_decode_number,print_uint16_array_member,
>> drm_ioctl): New prototype.
>> (drm_ctx_flags, drm_mode_flags, drm_mode_type): New xlat prototype.
>> (umove_nor_syserror): New macro, a wrapper for umove and syserror.
>> * ioctl.c (ioctl_decode): Call drm_ioctl for ioctl type 'd'.
>> (ioctl_decode_command_number): Call drm_decode_number for ioctl type 'd'.
>> * Makefile.am (strace_SOURCES): Add drm.c and drm_mpers.c.
>> (EXTRA_DIST): Add linux/drm/drm.h and linux/drm/drm_mode.h.
>> * print_fields.h (PRINT_FIELD_DRM_CRTC_ID): New macro. A wrapper of
>> PRINT_FIELD_U for drm crtc_id fields.
>> * util.c (print_uint16_array_member): New function.
>> * xlat/drm_buf_desc_flags.in: New file.
>> * xlat/drm_capability.in: Likewise.
>> * xlat/drm_client_capability.in: Likewise.
>> * xlat/drm_control_func.in: Likewise.
>> * xlat/drm_crtc_sequence_flags.in: Likewise.
>> * xlat/drm_ctx_flags.in: Likewise.
>> * xlat/drm_lock_flags.in: Likewise.
>> * xlat/drm_map_flags.in: Likewise.
>> * xlat/drm_map_type.in: Likewise.
>> * xlat/drm_mode_atomic_flags.in: Likewise.
>> * xlat/drm_mode_create_lease_flags.in: Likewise.
>> * xlat/drm_mode_cursor_flags.in: Likewise.
>> * xlat/drm_mode_encoder_type.in: Likewise.
>> * xlat/drm_mode_fb_cmd2_flags.in: Likewise.
>> * xlat/drm_mode_fb_dirty_cmd_flags.in: Likewise.
>> * xlat/drm_mode_flags.in: Likewise.
>> * xlat/drm_mode_get_property_flags.: Likewise.in
>> * xlat/drm_mode_page_flip_flags.in: Likewise.
>> * xlat/drm_mode_set_plane_flags.in: Likewise.
>> * xlat/drm_mode_type.in: Likewise.
>> * xlat/drm_modeset_cmd.in: Likewise.
>> * xlat/drm_prime_handle_flags.in
>> * xlat/drm_syncobj_fd_to_handle_flags.in: Likewise.
>> * xlat/drm_syncobj_flags.in: Likewise.
>> * xlat/drm_syncobj_handle_to_fd_flags.in: Likewise.
>> * xlat/drm_syncobj_wait_flags.in: Likewise.
>> * xlat/drm_vblank_seq_type.in: Likewise.
>> * xlat/drm_vblank_seq_type_flags.in: Likewise.
>>
>> Co-authored-by: Patrik Jakobsson <patrik.r.jakobsson at gmail.com>
>> ---
>> Makefile.am | 4 +
>> defs.h | 13 +
>> drm.c | 1553 ++++++++++++++++++++++++
>> drm_mpers.c | 882 ++++++++++++++
>> ioctl.c | 4 +
>> linux/drm/drm.h | 1042 ++++++++++++++++
>> linux/drm/drm_mode.h | 914 ++++++++++++++
>> print_fields.h | 3 +
>> util.c | 9 +
>> xlat/drm_buf_desc_flags.in | 6 +
>> xlat/drm_capability.in | 15 +
>> xlat/drm_client_capability.in | 6 +
>> xlat/drm_control_func.in | 5 +
>> xlat/drm_crtc_sequence_flags.in | 3 +
>> xlat/drm_ctx_flags.in | 3 +
>> xlat/drm_lock_flags.in | 7 +
>> xlat/drm_map_flags.in | 9 +
>> xlat/drm_map_type.in | 7 +
>> xlat/drm_mode_atomic_flags.in | 6 +
>> xlat/drm_mode_create_lease_flags.in | 2 +
>> xlat/drm_mode_cursor_flags.in | 3 +
>> xlat/drm_mode_encoder_type.in | 10 +
>> xlat/drm_mode_fb_cmd2_flags.in | 3 +
>> xlat/drm_mode_fb_dirty_cmd_flags.in | 3 +
>> xlat/drm_mode_flags.in | 6 +
>> xlat/drm_mode_get_property_flags.in | 9 +
>> xlat/drm_mode_page_flip_flags.in | 5 +
>> xlat/drm_mode_set_plane_flags.in | 3 +
>> xlat/drm_mode_type.in | 8 +
>> xlat/drm_modeset_cmd.in | 3 +
>> xlat/drm_prime_handle_flags.in | 2 +
>> xlat/drm_syncobj_fd_to_handle_flags.in | 2 +
>> xlat/drm_syncobj_flags.in | 2 +
>> xlat/drm_syncobj_handle_to_fd_flags.in | 1 +
>> xlat/drm_syncobj_wait_flags.in | 4 +
>> xlat/drm_vblank_seq_type.in | 3 +
>> xlat/drm_vblank_seq_type_flags.in | 6 +
>> 37 files changed, 4566 insertions(+)
>> create mode 100644 drm.c
>> create mode 100644 drm_mpers.c
>> create mode 100644 linux/drm/drm.h
>> create mode 100644 linux/drm/drm_mode.h
>> create mode 100644 xlat/drm_buf_desc_flags.in
>> create mode 100644 xlat/drm_capability.in
>> create mode 100644 xlat/drm_client_capability.in
>> create mode 100644 xlat/drm_control_func.in
>> create mode 100644 xlat/drm_crtc_sequence_flags.in
>> create mode 100644 xlat/drm_ctx_flags.in
>> create mode 100644 xlat/drm_lock_flags.in
>> create mode 100644 xlat/drm_map_flags.in
>> create mode 100644 xlat/drm_map_type.in
>> create mode 100644 xlat/drm_mode_atomic_flags.in
>> create mode 100644 xlat/drm_mode_create_lease_flags.in
>> create mode 100644 xlat/drm_mode_cursor_flags.in
>> create mode 100644 xlat/drm_mode_encoder_type.in
>> create mode 100644 xlat/drm_mode_fb_cmd2_flags.in
>> create mode 100644 xlat/drm_mode_fb_dirty_cmd_flags.in
>> create mode 100644 xlat/drm_mode_flags.in
>> create mode 100644 xlat/drm_mode_get_property_flags.in
>> create mode 100644 xlat/drm_mode_page_flip_flags.in
>> create mode 100644 xlat/drm_mode_set_plane_flags.in
>> create mode 100644 xlat/drm_mode_type.in
>> create mode 100644 xlat/drm_modeset_cmd.in
>> create mode 100644 xlat/drm_prime_handle_flags.in
>> create mode 100644 xlat/drm_syncobj_fd_to_handle_flags.in
>> create mode 100644 xlat/drm_syncobj_flags.in
>> create mode 100644 xlat/drm_syncobj_handle_to_fd_flags.in
>> create mode 100644 xlat/drm_syncobj_wait_flags.in
>> create mode 100644 xlat/drm_vblank_seq_type.in
>> create mode 100644 xlat/drm_vblank_seq_type_flags.in
>>
>> diff --git a/Makefile.am b/Makefile.am
>> index 25a81f2c..388a7620 100644
>> --- a/Makefile.am
>> +++ b/Makefile.am
>> @@ -101,6 +101,8 @@ strace_SOURCES = \
>> dirent.c \
>> dirent64.c \
>> dm.c \
>> + drm.c \
>> + drm_mpers.c \
>> dyxlat.c \
>> empty.h \
>> epoll.c \
>> @@ -538,6 +540,8 @@ EXTRA_DIST = \
>> linux/csky/syscallent.h \
>> linux/bfin/userent.h \
>> linux/check_scno.c \
>> + linux/drm/drm.h \
>> + linux/drm/drm_mode.h \
>> linux/dummy.h \
>> linux/errnoent.h \
>> linux/getregs_old.h \
>> diff --git a/defs.h b/defs.h
>> index 003cc228..1eb699c5 100644
>> --- a/defs.h
>> +++ b/defs.h
>> @@ -313,6 +313,9 @@ extern const struct xlat arp_hardware_types[];
>> extern const struct xlat at_flags[];
>> extern const struct xlat clocknames[];
>> extern const struct xlat dirent_types[];
>> +extern const struct xlat drm_ctx_flags[];
>> +extern const struct xlat drm_mode_flags[];
>> +extern const struct xlat drm_mode_type[];
>> extern const struct xlat ethernet_protocols[];
>> extern const struct xlat inet_protocols[];
>> extern const struct xlat evdev_abs[];
>> @@ -508,6 +511,12 @@ umoven(struct tcb *, kernel_ulong_t addr, unsigned
>> int len, void *laddr);
>> # define umove(pid, addr, objp) \
>> umoven((pid), (addr), sizeof(*(objp)), (void *) (objp))
>>
>> +/**
>> + * @return true on success, false on error.
>> + */
>> +# define umove_nor_syserror(tcp, arg, objp) \
>> + (!syserror(tcp) && !umove(tcp, arg, objp))
>> +
>> /**
>> * @return true on success, false on error.
>> */
>> @@ -769,6 +778,8 @@ extern void print_kernel_version(unsigned long
>> version);
>> extern void print_abnormal_hi(kernel_ulong_t);
>> extern void print_ioprio(unsigned int ioprio);
>>
>> +extern bool print_uint16_array_member(struct tcb *, void *elem_buf,
>> + size_t elem_size, void *data);
>> extern bool print_int32_array_member(struct tcb *, void *elem_buf,
>> size_t elem_size, void *data);
>> extern bool print_uint32_array_member(struct tcb *, void *elem_buf,
>> @@ -924,6 +935,7 @@ name ## _ioctl(struct tcb *, unsigned int request,
>> kernel_ulong_t arg) \
>> /* End of DECL_IOCTL definition. */
>>
>> DECL_IOCTL(dm);
>> +DECL_IOCTL(drm);
>> DECL_IOCTL(evdev);
>> DECL_IOCTL(file);
>> DECL_IOCTL(fs_x);
>> @@ -941,6 +953,7 @@ DECL_IOCTL(uffdio);
>>
>> extern int decode_sg_io_v4(struct tcb *, const kernel_ulong_t arg);
>> extern void print_evdev_ff_type(const kernel_ulong_t val);
>> +extern int drm_decode_number(struct tcb *, const unsigned int code);
>>
>> struct nlmsghdr;
>>
>> diff --git a/drm.c b/drm.c
>> new file mode 100644
>> index 00000000..c754b16a
>> --- /dev/null
>> +++ b/drm.c
>> @@ -0,0 +1,1553 @@
>> +/*
>> + * Copyright (c) 2015 Intel Corporation
>> + * Copyright (c) 2019 Patrik Jakobsson <pjakobsson at suse.de>
>> + * Copyright (c) 2019 The strace developers.
>> + * All rights reserved.
>> + *
>> + * SPDX-License-Identifier: LGPL-2.1-or-later
>> + */
>> +
>> +#include "defs.h"
>> +#include "print_fields.h"
>> +#include <drm/drm.h>
>> +
>> +#include "xlat/drm_capability.h"
>> +#include "xlat/drm_client_capability.h"
>> +#include "xlat/drm_control_func.h"
>> +#include "xlat/drm_crtc_sequence_flags.h"
>> +#include "xlat/drm_ctx_flags.h"
>> +#include "xlat/drm_lock_flags.h"
>> +#include "xlat/drm_modeset_cmd.h"
>> +#include "xlat/drm_mode_atomic_flags.h"
>> +#include "xlat/drm_mode_create_lease_flags.h"
>> +#include "xlat/drm_mode_cursor_flags.h"
>> +#include "xlat/drm_mode_encoder_type.h"
>> +#include "xlat/drm_mode_fb_dirty_cmd_flags.h"
>> +#include "xlat/drm_mode_flags.h"
>> +#include "xlat/drm_mode_get_property_flags.h"
>> +#include "xlat/drm_mode_page_flip_flags.h"
>> +#include "xlat/drm_mode_set_plane_flags.h"
>> +#include "xlat/drm_mode_type.h"
>> +#include "xlat/drm_prime_handle_flags.h"
>> +#include "xlat/drm_syncobj_fd_to_handle_flags.h"
>> +#include "xlat/drm_syncobj_flags.h"
>> +#include "xlat/drm_syncobj_handle_to_fd_flags.h"
>> +#include "xlat/drm_syncobj_wait_flags.h"
>> +
>> +static void
>> +print_drm_iowr(const unsigned int nr, const unsigned int size,
>> + const char *str)
>> +{
>> + tprintf("DRM_IOWR(%#x, %#x) /* %s */", nr, size, str);
>> +}
>> +
>> +int
>> +drm_decode_number(struct tcb *const tcp, const unsigned int code)
>> +{
>> + const unsigned int nr = _IOC_NR(code);
>> + const unsigned int size = _IOC_SIZE(code);
>> +
>> + if (_IOC_DIR(code) == (_IOC_READ | _IOC_WRITE)) {
>> + switch (nr) {
>> + case _IOC_NR(DRM_IOCTL_MODE_GETCONNECTOR):
>> + /* In Linux commit v3.12-rc7~26^2~2 a u32 padding
>> was */
>> + /* added to struct drm_mode_get_connector so in
>> old */
>> + /* kernel headers the size of this structure is
>> 0x4c */
>> + /* instead of today's 0x50, which makes it
>> different */
>> + /* among personalities in case of older kernels
>> hence */
>> + /* we handle it later in drm_mpers.c instead of
>> here. */
>> + /* The newer 0x50-size is not affected even in
>> mpers. */
>> + print_drm_iowr(nr, size,
>> + "DRM_IOCTL_MODE_GETCONNECTOR");
>> + return IOCTL_NUMBER_STOP_LOOKUP;
>> +
>> + case _IOC_NR(DRM_IOCTL_MODE_ADDFB2):
>> + /* The struct size differs among versions of
>> kernels. */
>> + /* Specifically, in Linux commit
>> v4.1-rc1~69^2~35^2~57 */
>> + /* modifier field was added to the end of
>> structure. */
>> + print_drm_iowr(nr, size,
>> + "DRM_IOCTL_MODE_ADDFB2");
>> + return IOCTL_NUMBER_STOP_LOOKUP;
>> + }
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static int
>> +drm_get_magic(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_auth auth;
>> +
>> + if (entering(tcp))
>> + return 0;
>> +
>> + /* exiting-only code */
>> + if (umove_or_printaddr(tcp, arg, &auth))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", auth, magic);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_irq_busid(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_irq_busid busid;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &busid))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_D("{", busid, busnum);
>> + PRINT_FIELD_D(", ", busid, devnum);
>> + PRINT_FIELD_D(", ", busid, funcnum);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &busid)) {
>> + PRINT_FIELD_D(", ", busid, irq);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static void
>> +print_set_version(struct tcb *const tcp, const kernel_ulong_t arg,
>> + struct drm_set_version *ver)
>> +{
>> + PRINT_FIELD_D("{", *ver, drm_di_major);
>> + PRINT_FIELD_D(", ", *ver, drm_di_minor);
>> + PRINT_FIELD_D(", ", *ver, drm_dd_major);
>> + PRINT_FIELD_D(", ", *ver, drm_dd_minor);
>> + tprints("}");
>> +}
>> +
>> +static int
>> +drm_set_version(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_set_version ver;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &ver))
>> + return RVAL_IOCTL_DECODED;
>> + print_set_version(tcp, arg, &ver);
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &ver)) {
>> + tprints(" => ");
>> + print_set_version(tcp, arg, &ver);
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +
>> +static int
>> +drm_modeset_ctl(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_modeset_ctl ctl;
>> +
>> + if (umove_or_printaddr(tcp, arg, &ctl))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", ctl, crtc);
>> + PRINT_FIELD_XVAL(", ", ctl, cmd, drm_modeset_cmd, "_DRM_???");
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_gem_close(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_gem_close close;
>> +
>> + if (umove_or_printaddr(tcp, arg, &close))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", close, handle);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_gem_flink(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_gem_flink flink;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &flink))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", flink, handle);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &flink)) {
>> + PRINT_FIELD_U(", ", flink, name);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_gem_open(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_gem_open open;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &open))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", open, name);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &open)) {
>> + PRINT_FIELD_U(", ", open, handle);
>> + PRINT_FIELD_U(", ", open, size);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_get_cap(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_get_cap cap;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &cap))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_XVAL("{", cap, capability, drm_capability,
>> + "DRM_CAP_???");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &cap)) {
>> + PRINT_FIELD_U(", ", cap, value);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_set_client_cap(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_set_client_cap cap;
>> +
>> + if (umove_or_printaddr(tcp, arg, &cap))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_XVAL("{", cap, capability, drm_client_capability,
>> + "DRM_CLIENT_CAP_???");
>> + PRINT_FIELD_U(", ", cap, value);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_auth_magic(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_auth auth;
>> +
>> + if (umove_or_printaddr(tcp, arg, &auth))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", auth, magic);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_noop(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + /* No-op ioctl */
>> + printaddr(arg);
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_control(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_control control;
>> +
>> + if (umove_or_printaddr(tcp, arg, &control))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_XVAL("{", control, func, drm_control_func,
>> + "DRM_???");
>> + PRINT_FIELD_D(", ", control, irq);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_ctx(struct tcb *const tcp, const kernel_ulong_t arg, bool is_get)
>> +{
>> + /* GET_CTX ioctl does not touch handle */
>> + /* field according to the drvier code. */
>> + struct drm_ctx ctx;
>> +
>> + if (umove_or_printaddr(tcp, arg, &ctx))
>> + return RVAL_IOCTL_DECODED;
>> + if (is_get)
>> + PRINT_FIELD_FLAGS("{", ctx, flags, drm_ctx_flags,
>> + "_DRM_CONTEXT_???");
>> + else
>> + PRINT_FIELD_U("{", ctx, handle);
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_lock(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_lock lock;
>> +
>> + if (entering(tcp))
>> + return 0;
>> +
>> + /* exiting-only code */
>> + if (umove_or_printaddr(tcp, arg, &lock))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_D("{", lock, context);
>> + PRINT_FIELD_FLAGS(", ", lock, flags, drm_lock_flags,
>> "_DRM_LOCK_???");
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_prime_handle_to_fd(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_prime_handle handle;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &handle))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", handle, handle);
>> + PRINT_FIELD_FLAGS(", ", handle, flags,
>> drm_prime_handle_flags,
>> + "DRM_???");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &handle)) {
>> + PRINT_FIELD_FD(", ", handle, fd, tcp);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_prime_fd_to_handle(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_prime_handle handle;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &handle))
>> + return RVAL_IOCTL_DECODED;
>> + /* The printing oder here is different comparing to */
>> + /* the order of fields in the struture because in */
>> + /* this ioctl command we have to get handle via fd. */
>> + PRINT_FIELD_FD("{", handle, fd, tcp);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &handle)) {
>> + PRINT_FIELD_U(", ", handle, handle);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +
>> +}
>> +
>> +static int
>> +drm_crtc_get_sequence(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_crtc_get_sequence seq;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &seq))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_DRM_CRTC_ID("{", seq, crtc_id);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &seq)) {
>> + PRINT_FIELD_U(", ", seq, active);
>> + PRINT_FIELD_U(", ", seq, sequence);
>> + PRINT_FIELD_D(", ", seq, sequence_ns);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_crtc_queue_sequence(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_crtc_queue_sequence seq;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &seq))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_DRM_CRTC_ID("{", seq, crtc_id);
>> + PRINT_FIELD_FLAGS(", ", seq, flags,
>> drm_crtc_sequence_flags,
>> + "DRM_CRTC_SEQUENCE_???");
>> + PRINT_FIELD_X(", ", seq, user_data);
>> + PRINT_FIELD_U(", ", seq, sequence);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &seq)) {
>> + PRINT_FIELD_U(" => {", seq, sequence);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_get_resources(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_card_res res;
>> + uint32_t u32_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &res))
>> + return RVAL_IOCTL_DECODED;
>> + tprints("{fb_id_ptr=");
>> + print_array(tcp, res.fb_id_ptr, res.count_fbs,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", crtc_id_ptr=");
>> + print_array(tcp, res.crtc_id_ptr, res.count_crtcs,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", connector_id_ptr=");
>> + print_array(tcp, res.connector_id_ptr,
>> res.count_connectors,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", encoder_id_ptr=");
>> + print_array(tcp, res.encoder_id_ptr, res.count_encoders,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + PRINT_FIELD_U(", ", res, count_fbs);
>> + PRINT_FIELD_U(", ", res, count_crtcs);
>> + PRINT_FIELD_U(", ", res, count_connectors);
>> + PRINT_FIELD_U(", ", res, count_encoders);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &res)) {
>> + PRINT_FIELD_U(" => {", res, count_fbs);
>> + PRINT_FIELD_U(", ", res, count_crtcs);
>> + PRINT_FIELD_U(", ", res, count_connectors);
>> + PRINT_FIELD_U(", ", res, count_encoders);
>> + PRINT_FIELD_U(", ", res, min_width);
>> + PRINT_FIELD_U(", ", res, max_width);
>> + PRINT_FIELD_U(", ", res, min_height);
>> + PRINT_FIELD_U(", ", res, max_height);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static void
>> +print_drm_mode_modeinfo(struct drm_mode_modeinfo *info)
>> +{
>> + PRINT_FIELD_U("{", *info, clock);
>> + PRINT_FIELD_U(", ", *info, hdisplay);
>> + PRINT_FIELD_U(", ", *info, hsync_start);
>> + PRINT_FIELD_U(", ", *info, hsync_end);
>> + PRINT_FIELD_U(", ", *info, htotal);
>> + PRINT_FIELD_U(", ", *info, hskew);
>> + PRINT_FIELD_U(", ", *info, vdisplay);
>> + PRINT_FIELD_U(", ", *info, vsync_start);
>> + PRINT_FIELD_U(", ", *info, vsync_end);
>> + PRINT_FIELD_U(", ", *info, vtotal);
>> + PRINT_FIELD_U(", ", *info, vscan);
>> + PRINT_FIELD_U(", ", *info, vrefresh);
>> + PRINT_FIELD_FLAGS(", ", *info, flags, drm_mode_flags,
>> + "DRM_MODE_FLAG_PIC_???");
>> + PRINT_FIELD_XVAL(", ", *info, type, drm_mode_type,
>> + "DRM_MODE_TYPE_???");
>> + PRINT_FIELD_CSTRING(", ", *info, name);
>> + tprints("}");
>> +}
>> +
>> +static void
>> +print_drm_mode_crtc_tail(struct tcb *const tcp, struct drm_mode_crtc
>> *crtc,
>> + bool is_get)
>> +{
>> + uint32_t set_connectors_ptr;
>> +
>> + if (!is_get) {
>> + tprints(", set_connectors_ptr=");
>> + print_array(tcp, crtc->set_connectors_ptr,
>> + crtc->count_connectors,
>> + &set_connectors_ptr,
>> sizeof(set_connectors_ptr),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + PRINT_FIELD_U(", ", *crtc, count_connectors);
>> + }
>> + PRINT_FIELD_U(", ", *crtc, fb_id);
>> + PRINT_FIELD_U(", ", *crtc, x);
>> + PRINT_FIELD_U(", ", *crtc, y);
>> + PRINT_FIELD_U(", ", *crtc, gamma_size);
>> + PRINT_FIELD_U(", ", *crtc, mode_valid);
>> + tprints(", mode=");
>> + print_drm_mode_modeinfo(&crtc->mode);
>> +}
>> +
>> +static int
>> +drm_mode_crtc(struct tcb *const tcp, const kernel_ulong_t arg,
>> + bool is_get)
>> +{
>> + struct drm_mode_crtc crtc;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &crtc))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_DRM_CRTC_ID("{", crtc, crtc_id);
>> + if (is_get)
>> + return 0;
>> + print_drm_mode_crtc_tail(tcp, &crtc, is_get);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &crtc) && is_get) {
>> + print_drm_mode_crtc_tail(tcp, &crtc, is_get);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_cursor(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_cursor cursor;
>> +
>> + if (umove_or_printaddr(tcp, arg, &cursor))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_FLAGS("{", cursor, flags, drm_mode_cursor_flags,
>> + "DRM_MODE_CURSOR_???");
>> + PRINT_FIELD_DRM_CRTC_ID(", ", cursor, crtc_id);
>> + PRINT_FIELD_D(", ", cursor, x);
>> + PRINT_FIELD_D(", ", cursor, y);
>> + PRINT_FIELD_U(", ", cursor, width);
>> + PRINT_FIELD_U(", ", cursor, height);
>> + PRINT_FIELD_U(", ", cursor, handle);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_gamma(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_crtc_lut lut;
>> + int array_size;
>> + uint16_t u32_val;
>> +
>> + if (umove_or_printaddr(tcp, arg, &lut))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + array_size = lut.gamma_size * (sizeof(uint16_t));
>> + PRINT_FIELD_DRM_CRTC_ID("{", lut, crtc_id);
>> + PRINT_FIELD_U(", ", lut, gamma_size);
>> + tprints(", red=");
>> + print_array(tcp, lut.red, array_size,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint16_array_member, 0);
>> + tprints(", green=");
>> + print_array(tcp, lut.green, array_size,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint16_array_member, 0);
>> + tprints(", blue=");
>> + print_array(tcp, lut.blue, array_size,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint16_array_member, 0);
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_get_encoder(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_get_encoder enc;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &enc))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", enc, encoder_id);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &enc)) {
>> + PRINT_FIELD_U(" => {", enc, encoder_id);
>> + PRINT_FIELD_XVAL(", ", enc, encoder_type,
>> drm_mode_encoder_type,
>> + "DRM_MODE_ENCODER_???");
>> + PRINT_FIELD_DRM_CRTC_ID(", ", enc, crtc_id);
>> + PRINT_FIELD_X(", ", enc, possible_crtcs);
>> + PRINT_FIELD_X(", ", enc, possible_clones);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static bool
>> +print_drm_mode_property_enum(struct tcb *tcp, void *elem_buf,
>> + size_t elem_size, void *data)
>> +{
>> + const struct drm_mode_property_enum *p = elem_buf;
>> + PRINT_FIELD_U("{", *p, value);
>> + PRINT_FIELD_CSTRING(", ", *p, name);
>> + tprints("}");
>> + return true;
>> +}
>> +
>> +static int
>> +drm_mode_get_property(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_get_property prop;
>> + uint64_t values_val;
>> + struct drm_mode_property_enum enum_blob_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &prop))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", prop, prop_id);
>> + PRINT_FIELD_U(", ", prop, count_values);
>> + PRINT_FIELD_U(", ", prop, count_enum_blobs);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &prop)) {
>> + tprints(" => {values_ptr=");
>> + print_array(tcp, prop.values_ptr, prop.count_values,
>> + &values_val, sizeof(values_val),
>> + tfetch_mem, print_uint64_array_member, 0);
>> + tprints(", enum_blob_ptr=");
>> + print_array(tcp, prop.enum_blob_ptr,
>> prop.count_enum_blobs,
>> + &enum_blob_val, sizeof(enum_blob_val),
>> + tfetch_mem, print_drm_mode_property_enum, 0);
>> + PRINT_FIELD_FLAGS(", ", prop, flags,
>> drm_mode_get_property_flags,
>> + "DRM_MODE_PROP_???");
>> + PRINT_FIELD_CSTRING(", ", prop, name);
>> + PRINT_FIELD_U(", ", prop, count_values);
>> + PRINT_FIELD_U(", ", prop, count_enum_blobs);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_set_property(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_connector_set_property prop;
>> +
>> + if (umove_or_printaddr(tcp, arg, &prop))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", prop, value);
>> + PRINT_FIELD_U(", ", prop, prop_id);
>> + PRINT_FIELD_U(", ", prop, connector_id);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_get_prop_blob(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_get_blob blob;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &blob))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", blob, blob_id);
>> + PRINT_FIELD_U(", ", blob, length);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &blob)) {
>> + PRINT_FIELD_U(" => {", blob, length);
>> + PRINT_FIELD_ADDR64(", ", blob, data);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static void
>> +print_drm_mode_fb_cmd_part(struct drm_mode_fb_cmd *cmd)
>> +{
>> + /* The prefix might differ here */
>> + /* and it could be ", " or "{". */
>> + /* So we print it in the caller. */
>> + PRINT_FIELD_U("", *cmd, width);
>> + PRINT_FIELD_U(", ", *cmd, height);
>> + PRINT_FIELD_U(", ", *cmd, pitch);
>> + PRINT_FIELD_U(", ", *cmd, bpp);
>> + PRINT_FIELD_U(", ", *cmd, depth);
>> + PRINT_FIELD_U(", ", *cmd, handle);
>> +}
>> +
>> +static int
>> +drm_mode_get_fb(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_fb_cmd cmd;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &cmd))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", cmd, fb_id);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &cmd)) {
>> + tprints(", ");
>> + print_drm_mode_fb_cmd_part(&cmd);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_add_fb(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_fb_cmd cmd;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &cmd))
>> + return RVAL_IOCTL_DECODED;
>> + tprints("{");
>> + print_drm_mode_fb_cmd_part(&cmd);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &cmd)) {
>> + PRINT_FIELD_U(", ", cmd, fb_id);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_rm_fb(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + unsigned int fb_id;
>> +
>> + if (umove_or_printaddr(tcp, arg, &fb_id))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + tprintf("{fb_id=%u}", fb_id);
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_page_flip(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_crtc_page_flip flip;
>> +
>> + if (umove_or_printaddr(tcp, arg, &flip))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_DRM_CRTC_ID("{", flip, crtc_id);
>> + PRINT_FIELD_U(", ", flip, fb_id);
>> + PRINT_FIELD_FLAGS(", ", flip, flags, drm_mode_page_flip_flags,
>> + "DRM_MODE_PAGE_FLIP_???");
>> + PRINT_FIELD_X(", ", flip, user_data);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static bool
>> +print_drm_clip_rect(struct tcb *tcp, void *elem_buf,
>> + size_t elem_size, void *data)
>> +{
>> + const struct drm_clip_rect *p = elem_buf;
>> + PRINT_FIELD_U("{", *p, x1);
>> + PRINT_FIELD_D(", ", *p, y1);
>> + PRINT_FIELD_D(", ", *p, x2);
>> + PRINT_FIELD_D(", ", *p, y2);
>> + tprints("}");
>> + return true;
>> +}
>> +
>> +static int
>> +drm_mode_dirty_fb(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_fb_dirty_cmd cmd;
>> + struct drm_clip_rect clips_val;
>> +
>> + if (umove_or_printaddr(tcp, arg, &cmd))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", cmd, fb_id);
>> + PRINT_FIELD_FLAGS(", ", cmd, flags, drm_mode_fb_dirty_cmd_flags,
>> + "DRM_MODE_FB_DIRTY_ANNOTATE_???");
>> + PRINT_FIELD_X(", ", cmd, color);
>> + PRINT_FIELD_U(", ", cmd, num_clips);
>> + tprints(", clips_ptr=");
>> + print_array(tcp, cmd.clips_ptr, cmd. num_clips,
>> + &clips_val, sizeof(clips_val),
>> + tfetch_mem, print_drm_clip_rect, 0);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_create_dumb(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_create_dumb dumb;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &dumb))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", dumb, width);
>> + PRINT_FIELD_U(", ", dumb, height);
>> + PRINT_FIELD_U(", ", dumb, bpp);
>> + PRINT_FIELD_X(", ", dumb, flags);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &dumb)) {
>> + PRINT_FIELD_U(", ", dumb, handle);
>> + PRINT_FIELD_U(", ", dumb, pitch);
>> + PRINT_FIELD_U(", ", dumb, size);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_map_dumb(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_map_dumb dumb;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &dumb))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", dumb, handle);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &dumb)) {
>> + PRINT_FIELD_U(", ", dumb, offset);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_destroy_dumb(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_destroy_dumb dumb;
>> +
>> + if (umove_or_printaddr(tcp, arg, &dumb))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", dumb, handle);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_getplane(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_get_plane plane;
>> + uint32_t formant_type_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &plane))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", plane, plane_id);
>> + PRINT_FIELD_U(", ", plane, count_format_types);
>> + tprints(", format_type_ptr=");
>> + print_array(tcp, plane.format_type_ptr,
>> + plane.count_format_types,
>> + &formant_type_val, sizeof(formant_type_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> +
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &plane)) {
>> + PRINT_FIELD_U(" => {", plane, plane_id);
>> + PRINT_FIELD_DRM_CRTC_ID(", ", plane, crtc_id);
>> + PRINT_FIELD_U(", ", plane, fb_id);
>> + PRINT_FIELD_U(", ", plane, possible_crtcs);
>> + PRINT_FIELD_U(", ", plane, gamma_size);
>> + PRINT_FIELD_U(", ", plane, count_format_types);
>> +
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_setplane(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_set_plane plane;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &plane))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", plane, plane_id);
>> + PRINT_FIELD_DRM_CRTC_ID(", ", plane, crtc_id);
>> + PRINT_FIELD_U(", ", plane, fb_id);
>> + PRINT_FIELD_FLAGS(", ", plane, flags,
>> drm_mode_set_plane_flags,
>> + "DRM_MODE_PRESENT_???");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &plane)) {
>> + PRINT_FIELD_D(", ", plane, crtc_x);
>> + PRINT_FIELD_D(", ", plane, crtc_y);
>> + PRINT_FIELD_U(", ", plane, crtc_w);
>> + PRINT_FIELD_U(", ", plane, crtc_h);
>> + /* The printing format reference is from kernel driver. */
>> + PRINT_FIELD_U(", ", plane, src_x);
>> + tprintf_comment("%u.%06u", plane.src_x >> 16,
>> + ((plane.src_x & 0xffff) * 15625) >> 10);
>> + PRINT_FIELD_U(", ", plane, src_y);
>> + tprintf_comment("%u.%06u", plane.src_y >> 16,
>> + ((plane.src_y & 0xffff) * 15625) >> 10);
>> + PRINT_FIELD_U(", ", plane, src_h);
>> + tprintf_comment("%u.%06u", plane.src_h >> 16,
>> + ((plane.src_h & 0xffff) * 15625) >> 10);
>> + PRINT_FIELD_U(", ", plane, src_w);
>> + tprintf_comment("%u.%06u", plane.src_w >> 16,
>> + ((plane.src_w & 0xffff) * 15625) >> 10);
>> +
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_cursor2(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_cursor2 cursor;
>> +
>> + if (umove_or_printaddr(tcp, arg, &cursor))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_FLAGS("{", cursor, flags, drm_mode_cursor_flags,
>> + "DRM_MODE_CURSOR_???");
>> + PRINT_FIELD_DRM_CRTC_ID(", ", cursor, crtc_id);
>> + PRINT_FIELD_D(", ", cursor, x);
>> + PRINT_FIELD_D(", ", cursor, y);
>> + PRINT_FIELD_U(", ", cursor, width);
>> + PRINT_FIELD_U(", ", cursor, height);
>> + PRINT_FIELD_U(", ", cursor, handle);
>> + PRINT_FIELD_D(", ", cursor, hot_x);
>> + PRINT_FIELD_D(", ", cursor, hot_y);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_atomic(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_atomic atomic;
>> + uint32_t u32_val;
>> + uint64_t u64_val;
>> +
>> + if (umove_or_printaddr(tcp, arg, &atomic))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_FLAGS("{", atomic, flags, drm_mode_atomic_flags,
>> + "DRM_MODE_ATOMIC_???");
>> + PRINT_FIELD_U(", ", atomic, count_objs);
>> + tprints(", objs_ptr=");
>> + print_array(tcp, atomic.objs_ptr, atomic.count_objs,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", count_props_ptr=");
>> + print_array(tcp, atomic.count_props_ptr, atomic.count_objs,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", props_ptr=");
>> + print_array(tcp, atomic.props_ptr, atomic.count_objs,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", prop_values_ptr=");
>> + print_array(tcp, atomic.prop_values_ptr, atomic.count_objs,
>> + &u64_val, sizeof(u64_val),
>> + tfetch_mem, print_uint64_array_member, 0);
>> + if (atomic.reserved)
>> + PRINT_FIELD_U(", ", atomic, reserved);
>> + PRINT_FIELD_X(", ", atomic, user_data);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_createpropblob(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_create_blob blob;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &blob))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_ADDR64("{", blob, data);
>> + PRINT_FIELD_U(", ", blob, length);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &blob)) {
>> + PRINT_FIELD_U(", ", blob, blob_id);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_destroypropblob(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_destroy_blob blob;
>> +
>> + if (umove_or_printaddr(tcp, arg, &blob))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", blob, blob_id);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_syncobj_create(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_syncobj_create create;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &create))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_FLAGS("{", create, flags, drm_syncobj_flags,
>> + "DRM_SYNCOBJ_???");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &create)) {
>> + PRINT_FIELD_U(", ", create, handle);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_syncobj_destroy(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_syncobj_destroy destroy;
>> +
>> + if (umove_or_printaddr(tcp, arg, &destroy))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", destroy, handle);
>> + if (destroy.pad)
>> + PRINT_FIELD_U(", ", destroy, pad);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_syncobj_handle_fd(struct tcb *const tcp, const kernel_ulong_t arg,
>> + bool is_handle_to_fd)
>> +{
>> + struct drm_syncobj_handle handle;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &handle))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + if (is_handle_to_fd) {
>> + PRINT_FIELD_U("{", handle, handle);
>> + PRINT_FIELD_FLAGS(", ", handle, flags,
>> + drm_syncobj_handle_to_fd_flags,
>> + "DRM_SYNCOBJ_???");
>> + } else {
>> + PRINT_FIELD_FD("{", handle, fd, tcp);
>> + PRINT_FIELD_FLAGS(", ", handle, flags,
>> + drm_syncobj_fd_to_handle_flags,
>> + "DRM_SYNCOBJ_???");
>> + }
>> + if (handle.pad)
>> + PRINT_FIELD_U(", ", handle, pad);
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &handle)) {
>> + if (is_handle_to_fd)
>> + PRINT_FIELD_FD(", ", handle, fd, tcp);
>> + else
>> + PRINT_FIELD_U(", ", handle, handle);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_syncobj_wait(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_syncobj_wait wait;
>> + uint32_t handles_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &wait))
>> + return RVAL_IOCTL_DECODED;
>> + tprints("{handles=");
>> + print_array(tcp, wait.handles, wait.count_handles,
>> + &handles_val, sizeof(handles_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + PRINT_FIELD_D(", ", wait, timeout_nsec);
>> + PRINT_FIELD_U(", ", wait, count_handles);
>> + PRINT_FIELD_FLAGS(", ", wait, flags,
>> drm_syncobj_wait_flags,
>> + "DRM_SYNCOBJ_WAIT_FLAGS_???");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &wait)) {
>> + PRINT_FIELD_U(", ", wait, first_signaled);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_syncobj_reset_or_signal(struct tcb *const tcp, const kernel_ulong_t
>> arg)
>> +{
>> + struct drm_syncobj_array array;
>> + uint32_t handles_val;
>> +
>> + if (umove_or_printaddr(tcp, arg, &array))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + tprints("{handles=");
>> + print_array(tcp, array.handles, array.count_handles,
>> + &handles_val, sizeof(handles_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + PRINT_FIELD_U(", ", array, count_handles);
>> + if (array.pad)
>> + PRINT_FIELD_U(", ", array, pad);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_create_lease(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_create_lease lease;
>> + uint32_t object_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &lease))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + tprints("{object_ids=");
>> + print_array(tcp, lease.object_ids, lease.object_count,
>> + &object_val, sizeof(object_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + PRINT_FIELD_U(", ", lease, object_count);
>> + PRINT_FIELD_X(", ", lease, flags);
>> + PRINT_FIELD_FLAGS(", ", lease, flags,
>> + drm_mode_create_lease_flags,
>> + "O_???");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &lease)) {
>> + PRINT_FIELD_U(", ", lease, lessee_id);
>> + PRINT_FIELD_FD(", ", lease, fd, tcp);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_list_lessees(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_list_lessees lessees;
>> + uint32_t lessees_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &lessees))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", lessees, count_lessees);
>> + if (lessees.pad)
>> + PRINT_FIELD_U(", ", lessees, pad);
>> + tprints(", lessees_ptr=");
>> + print_array(tcp, lessees.lessees_ptr,
>> lessees.count_lessees,
>> + &lessees_val, sizeof(lessees_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> +
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &lessees)) {
>> + PRINT_FIELD_U(" => {", lessees, count_lessees);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_get_lease(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_get_lease lease;
>> + uint32_t objects_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &lease))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", lease, count_objects);
>> + if (lease.pad)
>> + PRINT_FIELD_U(", ", lease, pad);
>> + tprints(", objects_ptr=");
>> + print_array(tcp, lease.objects_ptr, lease.count_objects,
>> + &objects_val, sizeof(objects_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> +
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &lease)) {
>> + PRINT_FIELD_U(" => {", lease, count_objects);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +
>> +}
>> +
>> +static int
>> +drm_mode_revoke_lease(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_mode_revoke_lease lease;
>> +
>> + if (umove_or_printaddr(tcp, arg, &lease))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", lease, lessee_id);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_syncobj_timeline_wait(struct tcb *const tcp, const kernel_ulong_t
>> arg)
>> +{
>> + struct drm_syncobj_timeline_wait wait;
>> + uint32_t handles_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &wait))
>> + return RVAL_IOCTL_DECODED;
>> + tprints("{handles=");
>> + print_array(tcp, wait.handles, wait.count_handles,
>> + &handles_val, sizeof(handles_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + PRINT_FIELD_D(", ", wait, timeout_nsec);
>> + PRINT_FIELD_U(", ", wait, count_handles);
>> + PRINT_FIELD_FLAGS(", ", wait, flags,
>> drm_syncobj_wait_flags,
>> + "DRM_SYNCOBJ_WAIT_FLAGS_???");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umove(tcp, arg, &wait)) {
>> + PRINT_FIELD_U(", ", wait, first_signaled);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_syncobj_query_or_timeline_signal(struct tcb *const tcp,
>> + const kernel_ulong_t arg)
>> +{
>> + struct drm_syncobj_timeline_array array;
>> + uint32_t handles_val;
>> + uint64_t points_val;
>> +
>> + if (umove_or_printaddr(tcp, arg, &array))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + tprints("{handles=");
>> + print_array(tcp, array.handles, array.count_handles,
>> + &handles_val, sizeof(handles_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", points=");
>> + print_array(tcp, array.points, array.count_handles,
>> + &points_val, sizeof(points_val),
>> + tfetch_mem, print_uint64_array_member, 0);
>> +
>> + PRINT_FIELD_U(", ", array, count_handles);
>> + if (array.pad)
>> + PRINT_FIELD_U(", ", array, pad);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_syncobj_transfer(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct drm_syncobj_transfer transfer;
>> +
>> + if (umove_or_printaddr(tcp, arg, &transfer))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", transfer, src_handle);
>> + PRINT_FIELD_U(", ", transfer, dst_handle);
>> + PRINT_FIELD_U(", ", transfer, src_point);
>> + PRINT_FIELD_U(", ", transfer, dst_point);
>> + PRINT_FIELD_FLAGS(", ", transfer, flags, drm_syncobj_wait_flags,
>> + "DRM_SYNCOBJ_WAIT_FLAGS_???");
>> + if (transfer.pad)
>> + PRINT_FIELD_U(", ", transfer, pad);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +int
>> +drm_ioctl(struct tcb *const tcp, const unsigned int code,
>> + const kernel_ulong_t arg)
>> +{
>> + if (entering(tcp))
>> + tprints(", ");
>> +
>> + switch (code) {
>> + case DRM_IOCTL_GET_MAGIC: /* R */
>> + return drm_get_magic(tcp, arg);
>> + case DRM_IOCTL_IRQ_BUSID: /* RW */
>> + return drm_irq_busid(tcp, arg);
>> + case DRM_IOCTL_SET_VERSION: /* RW */
>> + return drm_set_version(tcp, arg);
>> + case DRM_IOCTL_MODESET_CTL: /* W */
>> + return drm_modeset_ctl(tcp, arg);
>> + case DRM_IOCTL_GEM_CLOSE: /* W */
>> + return drm_gem_close(tcp, arg);
>> + case DRM_IOCTL_GEM_FLINK: /* RW */
>> + return drm_gem_flink(tcp, arg);
>> + case DRM_IOCTL_GEM_OPEN: /* RW */
>> + return drm_gem_open(tcp, arg);
>> + case DRM_IOCTL_GET_CAP: /* RW */
>> + return drm_get_cap(tcp, arg);
>> + case DRM_IOCTL_SET_CLIENT_CAP: /* W */
>> + return drm_set_client_cap(tcp, arg);
>> + case DRM_IOCTL_AUTH_MAGIC: /* W */
>> + return drm_auth_magic(tcp, arg);
>> + case DRM_IOCTL_BLOCK: /* RW */
>> + case DRM_IOCTL_UNBLOCK: /* RW */
>> + case DRM_IOCTL_MOD_CTX: /* W */
>> + case DRM_IOCTL_ADD_DRAW: /* RW */
>> + case DRM_IOCTL_RM_DRAW: /* RW */
>> + case DRM_IOCTL_FINISH: /* W */
>> + case DRM_IOCTL_MODE_ATTACHMODE: /* RW */
>> + case DRM_IOCTL_MODE_DETACHMODE: /* RW */
>> + case DRM_IOCTL_GET_STATS: /* R */
>> + return drm_noop(tcp, arg);
>> + case DRM_IOCTL_CONTROL: /* W */
>> + return drm_control(tcp, arg);
>> + case DRM_IOCTL_ADD_CTX: /* RW */
>> + case DRM_IOCTL_SWITCH_CTX: /* W */
>> + case DRM_IOCTL_NEW_CTX: /* W */
>> + case DRM_IOCTL_GET_CTX: /* RW */
>> + if (entering(tcp))
>> + return 0;
>> + return drm_ctx(tcp, arg, code == DRM_IOCTL_GET_CTX);
>> + case DRM_IOCTL_RM_CTX: /* RW */
>> + return drm_ctx(tcp, arg, false);
>> + case DRM_IOCTL_LOCK: /* W */
>> + case DRM_IOCTL_UNLOCK: /* W */
>> + return drm_lock(tcp, arg);
>> + case DRM_IOCTL_PRIME_HANDLE_TO_FD: /* RW */
>> + return drm_prime_handle_to_fd(tcp, arg);
>> + case DRM_IOCTL_PRIME_FD_TO_HANDLE: /* RW */
>> + return drm_prime_fd_to_handle(tcp, arg);
>> + case DRM_IOCTL_CRTC_GET_SEQUENCE: /* RW */
>> + return drm_crtc_get_sequence(tcp, arg);
>> + case DRM_IOCTL_CRTC_QUEUE_SEQUENCE: /* RW */
>> + return drm_crtc_queue_sequence(tcp, arg);
>> + case DRM_IOCTL_MODE_GETRESOURCES: /* RW */
>> + return drm_mode_get_resources(tcp, arg);
>> + case DRM_IOCTL_MODE_GETCRTC: /* RW */
>> + case DRM_IOCTL_MODE_SETCRTC: /* RW */
>> + return drm_mode_crtc(tcp, arg, code ==
>> DRM_IOCTL_MODE_GETCRTC);
>> + case DRM_IOCTL_MODE_CURSOR: /* RW */
>> + return drm_mode_cursor(tcp, arg);
>> + case DRM_IOCTL_MODE_GETGAMMA: /* RW */
>> + case DRM_IOCTL_MODE_SETGAMMA: /* RW */
>> + return drm_mode_gamma(tcp, arg);
>> + case DRM_IOCTL_MODE_GETENCODER: /* RW */
>> + return drm_mode_get_encoder(tcp, arg);
>> + case DRM_IOCTL_MODE_GETPROPERTY: /* RW */
>> + return drm_mode_get_property(tcp, arg);
>> + case DRM_IOCTL_MODE_SETPROPERTY: /* RW */
>> + return drm_mode_set_property(tcp, arg);
>> + case DRM_IOCTL_MODE_GETPROPBLOB: /* RW */
>> + return drm_mode_get_prop_blob(tcp, arg);
>> + case DRM_IOCTL_MODE_GETFB: /* RW */
>> + return drm_mode_get_fb(tcp, arg);
>> + case DRM_IOCTL_MODE_ADDFB: /* RW */
>> + return drm_mode_add_fb(tcp, arg);
>> + case DRM_IOCTL_MODE_RMFB: /* RW */
>> + return drm_mode_rm_fb(tcp, arg);
>> + case DRM_IOCTL_MODE_PAGE_FLIP: /* RW */
>> + return drm_mode_page_flip(tcp, arg);
>> + case DRM_IOCTL_MODE_DIRTYFB: /* RW */
>> + return drm_mode_dirty_fb(tcp, arg);
>> + case DRM_IOCTL_MODE_CREATE_DUMB: /* RW */
>> + return drm_mode_create_dumb(tcp, arg);
>> + case DRM_IOCTL_MODE_MAP_DUMB: /* RW */
>> + return drm_mode_map_dumb(tcp, arg);
>> + case DRM_IOCTL_MODE_DESTROY_DUMB: /* RW */
>> + return drm_mode_destroy_dumb(tcp, arg);
>> + case DRM_IOCTL_MODE_GETPLANE: /* RW */
>> + return drm_mode_getplane(tcp, arg);
>> + case DRM_IOCTL_MODE_SETPLANE: /* RW */
>> + return drm_mode_setplane(tcp, arg);
>> + case DRM_IOCTL_MODE_CURSOR2: /* RW */
>> + return drm_mode_cursor2(tcp, arg);
>> + case DRM_IOCTL_MODE_ATOMIC: /* RW */
>> + return drm_mode_atomic(tcp, arg);//
>> + case DRM_IOCTL_MODE_CREATEPROPBLOB: /* RW */
>> + return drm_mode_createpropblob(tcp, arg);
>> + case DRM_IOCTL_MODE_DESTROYPROPBLOB: /* RW */
>> + return drm_mode_destroypropblob(tcp, arg);
>> + case DRM_IOCTL_SYNCOBJ_CREATE: /* RW */
>> + return drm_syncobj_create(tcp, arg);
>> + case DRM_IOCTL_SYNCOBJ_DESTROY: /* RW */
>> + return drm_syncobj_destroy(tcp, arg);
>> + case DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD: /* RW */
>> + case DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE: /* RW */
>> + return drm_syncobj_handle_fd(tcp, arg, code ==
>> DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD);
>> + case DRM_IOCTL_SYNCOBJ_WAIT: /* RW */
>> + return drm_syncobj_wait(tcp, arg);
>> + case DRM_IOCTL_SYNCOBJ_RESET: /* RW */
>> + case DRM_IOCTL_SYNCOBJ_SIGNAL: /* RW */
>> + return drm_syncobj_reset_or_signal(tcp, arg);
>> + case DRM_IOCTL_MODE_CREATE_LEASE: /* RW */
>> + return drm_mode_create_lease(tcp, arg);
>> + case DRM_IOCTL_MODE_LIST_LESSEES: /* RW */
>> + return drm_mode_list_lessees(tcp, arg);
>> + case DRM_IOCTL_MODE_GET_LEASE: /* RW */
>> + return drm_mode_get_lease(tcp, arg);
>> + case DRM_IOCTL_MODE_REVOKE_LEASE: /* RW */
>> + return drm_mode_revoke_lease(tcp, arg);
>> + case DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT: /* RW */
>> + return drm_syncobj_timeline_wait(tcp, arg);
>> + case DRM_IOCTL_SYNCOBJ_QUERY: /* RW */
>> + case DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL: /* RW */
>> + return drm_syncobj_query_or_timeline_signal(tcp, arg);
>> + case DRM_IOCTL_SYNCOBJ_TRANSFER: /* RW */
>> + return drm_syncobj_transfer(tcp, arg);
>> + default:
>> + return drm_ioctl_mpers(tcp, code, arg);
>> + }
>> +}
>> diff --git a/drm_mpers.c b/drm_mpers.c
>> new file mode 100644
>> index 00000000..b34744a8
>> --- /dev/null
>> +++ b/drm_mpers.c
>> @@ -0,0 +1,882 @@
>> +/*
>> + * Copyright (c) 2015 Intel Corporation
>> + * Copyright (c) 2019 Patrik Jakobsson <pjakobsson at suse.de>
>> + * Copyright (c) 2019 The strace developers.
>> + * All rights reserved.
>> + *
>> + * SPDX-License-Identifier: LGPL-2.1-or-later
>> + */
>> +
>> +#include "defs.h"
>> +#include <drm/drm.h>
>> +
>> +#include DEF_MPERS_TYPE(struct_drm_version)
>> +#include DEF_MPERS_TYPE(struct_drm_unique)
>> +#include DEF_MPERS_TYPE(struct_drm_map)
>> +#include DEF_MPERS_TYPE(struct_drm_client)
>> +#include DEF_MPERS_TYPE(struct_drm_stats)
>> +#include DEF_MPERS_TYPE(struct_drm_buf_desc)
>> +#include DEF_MPERS_TYPE(struct_drm_buf_info)
>> +#include DEF_MPERS_TYPE(struct_drm_buf_map)
>> +#include DEF_MPERS_TYPE(struct_drm_buf_pub)
>> +#include DEF_MPERS_TYPE(struct_drm_buf_free)
>> +#include DEF_MPERS_TYPE(struct_drm_ctx_priv_map)
>> +#include DEF_MPERS_TYPE(struct_drm_ctx_res)
>> +#include DEF_MPERS_TYPE(struct_drm_agp_mode)
>> +#include DEF_MPERS_TYPE(struct_drm_agp_info)
>> +#include DEF_MPERS_TYPE(struct_drm_agp_buffer)
>> +#include DEF_MPERS_TYPE(struct_drm_agp_binding)
>> +#include DEF_MPERS_TYPE(struct_drm_scatter_gather)
>> +#include DEF_MPERS_TYPE(union_drm_wait_vblank)
>> +#include DEF_MPERS_TYPE(struct_drm_mode_get_connector)
>> +#include DEF_MPERS_TYPE(struct_drm_mode_fb_cmd2)
>> +#include DEF_MPERS_TYPE(struct_drm_mode_get_plane_res)
>> +#include DEF_MPERS_TYPE(struct_drm_mode_obj_get_properties)
>> +#include DEF_MPERS_TYPE(struct_drm_mode_obj_set_property)
>> +
>> +typedef struct drm_version struct_drm_version;
>> +typedef struct drm_unique struct_drm_unique;
>> +typedef struct drm_map struct_drm_map;
>> +typedef struct drm_client struct_drm_client;
>> +typedef struct drm_stats struct_drm_stats;
>> +typedef struct drm_buf_desc struct_drm_buf_desc;
>> +typedef struct drm_buf_info struct_drm_buf_info;
>> +typedef struct drm_buf_map struct_drm_buf_map;
>> +typedef struct drm_buf_pub struct_drm_buf_pub;
>> +typedef struct drm_buf_free struct_drm_buf_free;
>> +typedef struct drm_ctx_priv_map struct_drm_ctx_priv_map;
>> +typedef struct drm_ctx_res struct_drm_ctx_res;
>> +typedef struct drm_agp_mode struct_drm_agp_mode;
>> +typedef struct drm_agp_info struct_drm_agp_info;
>> +typedef struct drm_agp_buffer struct_drm_agp_buffer;
>> +typedef struct drm_agp_binding struct_drm_agp_binding;
>> +typedef struct drm_scatter_gather struct_drm_scatter_gather;
>> +typedef union drm_wait_vblank union_drm_wait_vblank;
>> +typedef struct drm_mode_get_connector struct_drm_mode_get_connector;
>> +typedef struct drm_mode_fb_cmd2 struct_drm_mode_fb_cmd2;
>> +typedef struct drm_mode_get_plane_res struct_drm_mode_get_plane_res;
>> +typedef struct drm_mode_obj_get_properties
>> struct_drm_mode_obj_get_properties;
>> +typedef struct drm_mode_obj_set_property
>> struct_drm_mode_obj_set_property;
>> +
>> +#include MPERS_DEFS
>> +
>> +#include "print_fields.h"
>> +
>> +#include "xlat/drm_buf_desc_flags.h"
>> +#include "xlat/drm_map_flags.h"
>> +#include "xlat/drm_map_type.h"
>> +#include "xlat/drm_mode_fb_cmd2_flags.h"
>> +#include "xlat/drm_vblank_seq_type.h"
>> +#include "xlat/drm_vblank_seq_type_flags.h"
>> +
>> +static int
>> +drm_version(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_version ver;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &ver))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", ver, name_len);
>> + PRINT_FIELD_U(", ", ver, date_len);
>> + PRINT_FIELD_U(", ", ver, desc_len);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &ver)) {
>> + PRINT_FIELD_D(" => {", ver, version_major);
>> + PRINT_FIELD_D(", ", ver, version_minor);
>> + PRINT_FIELD_D(", ", ver, version_patchlevel);
>> + PRINT_FIELD_U(", ", ver, name_len);
>> + tprints(", name=");
>> + printstrn(tcp, ptr_to_kulong(ver.name), ver.name_len);
>> + PRINT_FIELD_U(", ", ver, date_len);
>> + tprints(", date=");
>> + printstrn(tcp, ptr_to_kulong(ver.date), ver.date_len);
>> + PRINT_FIELD_U(", ", ver, desc_len);
>> + tprints(", desc=");
>> + printstrn(tcp, ptr_to_kulong(ver.desc), ver.desc_len);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_unique(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_unique unique;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &unique))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", unique, unique_len);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &unique)) {
>> + PRINT_FIELD_U(" => {", unique, unique_len);
>> + tprints(", unique=");
>> + printstrn(tcp, ptr_to_kulong(unique.unique),
>> unique.unique_len);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_get_map(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_map map;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &map))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_X("{", map, offset);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &map)) {
>> + PRINT_FIELD_X(" => {", map, offset);
>> + PRINT_FIELD_U(", ", map, size);
>> + PRINT_FIELD_XVAL(", ", map, type, drm_map_type,
>> "_DRM_???");
>> + PRINT_FIELD_FLAGS(", ", map, flags, drm_map_flags,
>> "_DRM_???");
>> + PRINT_FIELD_PTR(", ", map, handle);
>> + PRINT_FIELD_D(", ", map, mtrr);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_get_client(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_client client;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &client))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_D("{", client, idx);
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &client)) {
>> + PRINT_FIELD_D(", ", client, auth);
>> + PRINT_FIELD_U(", ", client, pid);
>> + PRINT_FIELD_UID(", ", client, uid);
>> + PRINT_FIELD_U(", ", client, magic);
>> + PRINT_FIELD_U(", ", client, iocs);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_add_map(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_map map;
>> +
>> + if (umove_or_printaddr(tcp, arg, &map))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_X("{", map, offset);
>> + PRINT_FIELD_U(", ", map, size);
>> + PRINT_FIELD_XVAL(", ", map, type, drm_map_type, "_DRM_???");
>> + PRINT_FIELD_FLAGS(", ", map, flags, drm_map_flags, "_DRM_???");
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_add_bufs(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_buf_desc desc;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &desc))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_D("{", desc, count);
>> + PRINT_FIELD_D(", ", desc, size);
>> + PRINT_FIELD_FLAGS(", ", desc, flags, drm_buf_desc_flags,
>> + "_DRM_???");
>> + PRINT_FIELD_X(", ", desc, agp_start);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &desc)) {
>> + PRINT_FIELD_D(" => {", desc, count);
>> + PRINT_FIELD_D(", ", desc, size);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mark_bufs(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_buf_desc desc;
>> +
>> + if (umove_or_printaddr(tcp, arg, &desc))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_D("{", desc, size);
>> + PRINT_FIELD_D(", ", desc, low_mark);
>> + PRINT_FIELD_D(", ", desc, high_mark);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static bool
>> +print_drm_buf_desc(struct tcb *tcp, void *elem_buf,
>> + size_t elem_size, void *data)
>> +{
>> + const struct_drm_buf_desc *p = elem_buf;
>> + PRINT_FIELD_D("{", *p, count);
>> + PRINT_FIELD_D(", ", *p, size);
>> + PRINT_FIELD_D(", ", *p, low_mark);
>> + PRINT_FIELD_D(", ", *p, high_mark);
>> + PRINT_FIELD_FLAGS(", ", *p, flags, drm_buf_desc_flags,
>> + "_DRM_???");
>> + tprints("}");
>> + return true;
>> +}
>> +
>> +static int
>> +drm_info_bufs(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_buf_info info;
>> + struct_drm_buf_desc desc;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &info))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + tprints("{list=");
>> + print_array(tcp, ptr_to_kulong(info.list), info.count,
>> + &desc, sizeof(desc),
>> + tfetch_mem, print_drm_buf_desc, 0);
>> + PRINT_FIELD_D(", ", info, count);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &info)) {
>> + PRINT_FIELD_D(" => {", info, count);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static bool
>> +print_drm_buf_pub(struct tcb *tcp, void *elem_buf,
>> + size_t elem_size, void *data)
>> +
>> +{
>> + const struct_drm_buf_pub *p = elem_buf;
>> + PRINT_FIELD_D("{", *p, idx);
>> + PRINT_FIELD_D(", ", *p, total);
>> + PRINT_FIELD_D(", ", *p, used);
>> + PRINT_FIELD_PTR(", ", *p, address);
>> + tprints("}");
>> + return true;
>> +}
>> +
>> +static int
>> +drm_map_bufs(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_buf_map map;
>> + struct_drm_buf_pub pub;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &map))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_D("{", map, count);
>> + PRINT_FIELD_PTR(", ", map, virtual);
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &map)) {
>> + tprints(", list=");
>> + print_array(tcp, ptr_to_kulong(map.list), map.count,
>> + &pub, sizeof(pub),
>> + tfetch_mem, print_drm_buf_pub, 0);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_free_bufs(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_buf_free free;
>> + int list_val;
>> +
>> + if (umove_or_printaddr(tcp, arg, &free))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_D("{", free, count);
>> + tprints(", list=");
>> + print_array(tcp, ptr_to_kulong(free.list), free.count,
>> + &list_val, sizeof(list_val),
>> + tfetch_mem, print_int32_array_member, 0);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_rm_map(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_map map;
>> +
>> + if (umove_or_printaddr(tcp, arg, &map))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_PTR("{", map, handle);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_sarea_ctx(struct tcb *const tcp, const kernel_ulong_t arg,
>> + const bool is_get)
>> +{
>> + struct_drm_ctx_priv_map map;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &map))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", map, ctx_id);
>> + if (!is_get)
>> + PRINT_FIELD_PTR(", ", map, handle);
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &map) && is_get) {
>> + PRINT_FIELD_PTR(", ", map, handle);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static bool
>> +print_drm_ctx(struct tcb *tcp, void *elem_buf,
>> + size_t elem_size, void *data)
>> +{
>> + const struct drm_ctx *p = elem_buf;
>> + PRINT_FIELD_U("{", *p, handle);
>> + PRINT_FIELD_FLAGS("{", *p, flags, drm_ctx_flags,
>> "_DRM_CONTEXT_???");
>> + tprints("}");
>> + return true;
>> +}
>> +
>> +static int
>> +drm_res_ctx(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_ctx_res ctx;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &ctx))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_D("{", ctx, count);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &ctx)) {
>> + PRINT_FIELD_D(" => {", ctx, count);
>> + tprints(", contexts=");
>> + print_array(tcp, ptr_to_kulong(ctx.contexts), ctx.count,
>> + &ctx, sizeof(ctx),
>> + tfetch_mem, print_drm_ctx, 0);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +
>> +static int
>> +drm_agp_enable(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_agp_mode mode;
>> +
>> + if (umove_or_printaddr(tcp, arg, &mode))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", mode, mode);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_agp_info(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_agp_info info;
>> +
>> + if (entering(tcp))
>> +
>> + /* exiting-only code */
>> + if (umove_or_printaddr(tcp, arg, &info))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_D("{", info, agp_version_major);
>> + PRINT_FIELD_D(", ", info, agp_version_minor);
>> + PRINT_FIELD_U(", ", info, mode);
>> + PRINT_FIELD_X(", ", info, aperture_base);
>> + PRINT_FIELD_U(", ", info, aperture_size);
>> + PRINT_FIELD_U(", ", info, memory_allowed);
>> + PRINT_FIELD_U(", ", info, memory_used);
>> + PRINT_FIELD_X(", ", info, id_vendor);
>> + PRINT_FIELD_X(", ", info, id_device);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_agp_alloc(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_agp_buffer buffer;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &buffer))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", buffer, size);
>> + PRINT_FIELD_U(", ", buffer, type);
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &buffer)) {
>> + PRINT_FIELD_U(", ", buffer, handle);
>> + PRINT_FIELD_U(", ", buffer, physical);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_agp_free(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_agp_buffer buffer;
>> +
>> + if (umove_or_printaddr(tcp, arg, &buffer))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", buffer, handle);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_agp_bind(struct tcb *const tcp, const kernel_ulong_t arg, bool
>> is_bind)
>> +{
>> + struct_drm_agp_binding binding;
>> +
>> + if (umove_or_printaddr(tcp, arg, &binding))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", binding, handle);
>> + if (is_bind)
>> + PRINT_FIELD_X(", ", binding, offset);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_scatter_gather(struct tcb *const tcp, const kernel_ulong_t arg,
>> + bool is_alloc)
>> +{
>> + struct_drm_scatter_gather sg;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &sg))
>> + return RVAL_IOCTL_DECODED;
>> + if (is_alloc)
>> + PRINT_FIELD_U("{", sg, size);
>> + else
>> + PRINT_FIELD_U("{", sg, handle);
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &sg)) {
>> + if (is_alloc)
>> + PRINT_FIELD_U(", ", sg, handle);
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_wait_vblank(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + union_drm_wait_vblank vblank;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &vblank))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + /* TODO: constants with _DRM_VBLANK_HIGH_CRTC_MASK is not
>> added */
>> + tprints("{request={type=");
>> + printxval(drm_vblank_seq_type,
>> + vblank.request.type & _DRM_VBLANK_TYPES_MASK,
>> + "_DRM_VBLANK_???");
>> + tprints(", type.flags=");
>> + printflags(drm_vblank_seq_type_flags,
>> + vblank.request.type & _DRM_VBLANK_FLAGS_MASK,
>> + "_DRM_VBLANK_???");
>> + PRINT_FIELD_U(", ", vblank.request, sequence);
>> + PRINT_FIELD_U(", ", vblank.request, signal);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &vblank)) {
>> + tprints(", {reply={type=");
>> + printxval(drm_vblank_seq_type,
>> + vblank.reply.type & _DRM_VBLANK_TYPES_MASK,
>> + "_DRM_VBLANK_???");
>> + tprints(", type.flags=");
>> + printflags(drm_vblank_seq_type_flags,
>> + vblank.reply.type & _DRM_VBLANK_FLAGS_MASK,
>> + "_DRM_VBLANK_???");
>> +
>> + PRINT_FIELD_U(", ", vblank.reply, sequence);
>> + PRINT_FIELD_D(", ", vblank.reply, tval_sec);
>> + PRINT_FIELD_D(", ", vblank.reply, tval_usec);
>> + tprints("}");
>> + }
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static bool
>> +print_drm_mode_modeinfo(struct tcb *tcp, void *elem_buf,
>> + size_t elem_size, void *data)
>> +{
>> + const struct drm_mode_modeinfo *p = elem_buf;
>> + PRINT_FIELD_U("{", *p, clock);
>> + PRINT_FIELD_U(", ", *p, hdisplay);
>> + PRINT_FIELD_U(", ", *p, hsync_start);
>> + PRINT_FIELD_U(", ", *p, hsync_end);
>> + PRINT_FIELD_U(", ", *p, htotal);
>> + PRINT_FIELD_U(", ", *p, hskew);
>> + PRINT_FIELD_U(", ", *p, vdisplay);
>> + PRINT_FIELD_U(", ", *p, vsync_start);
>> + PRINT_FIELD_U(", ", *p, vsync_end);
>> + PRINT_FIELD_U(", ", *p, vtotal);
>> + PRINT_FIELD_U(", ", *p, vscan);
>> + PRINT_FIELD_U(", ", *p, vrefresh);
>> + PRINT_FIELD_FLAGS(", ", *p, flags, drm_mode_flags,
>> + "DRM_MODE_FLAG_PIC_???");
>> + PRINT_FIELD_XVAL(", ", *p, type, drm_mode_type,
>> + "DRM_MODE_TYPE_???");
>> + PRINT_FIELD_CSTRING(", ", *p, name);
>> + tprints("}");
>> + return true;
>> +}
>> +
>> +static void
>> +print_mode_get_connector_head(struct tcb *const tcp,
>> + const kernel_ulong_t arg,
>> + struct_drm_mode_get_connector *con,
>> + const char *suffix)
>> +{
>> + PRINT_FIELD_U("{", *con, connector_id);
>> + PRINT_FIELD_U(", ", *con, count_modes);
>> + PRINT_FIELD_U(", ", *con, count_props);
>> + PRINT_FIELD_U(", ", *con, count_encoders);
>> + tprints(suffix);
>> +}
>> +
>> +static int
>> +drm_mode_get_connector(struct tcb *const tcp, const kernel_ulong_t arg,
>> + uint32_t size)
>> +{
>> + struct_drm_mode_get_connector con;
>> + struct drm_mode_modeinfo modeinfo;
>> + uint32_t u32_val;
>> + uint64_t u64_val;
>> +
>> + if (entering(tcp)) {
>> + if (umoven_or_printaddr(tcp, arg, size, &con))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + print_mode_get_connector_head(tcp, arg, &con, "}");
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umoven(tcp, arg, size, &con)) {
>> + tprints(" => ");
>> + print_mode_get_connector_head(tcp, arg, &con, "");
>> + tprints(", encoders_ptr=");
>> + print_array(tcp, con.encoders_ptr, con.count_encoders,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", modes_ptr=");
>> + print_array(tcp, con.modes_ptr, con.count_modes,
>> + &modeinfo, sizeof(modeinfo),
>> + tfetch_mem, print_drm_mode_modeinfo, 0);
>> + tprints(", props_ptr=");
>> + print_array(tcp, con.props_ptr, con.count_props,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", prop_values_ptr=");
>> + print_array(tcp, con.prop_values_ptr, con.count_props,
>> + &u64_val, sizeof(u64_val),
>> + tfetch_mem, print_uint64_array_member, 0);
>> + PRINT_FIELD_U(", ", con, encoder_id);
>> + PRINT_FIELD_U(", ", con, connector_type);
>> + PRINT_FIELD_U(", ", con, connector_type_id);
>> + PRINT_FIELD_U(", ", con, connection);
>> + PRINT_FIELD_U(", ", con, mm_width);
>> + PRINT_FIELD_U(", ", con, mm_height);
>> + PRINT_FIELD_U(", ", con, subpixel);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_add_fb2(struct tcb *const tcp, const kernel_ulong_t arg,
>> + uint32_t size)
>> +{
>> + struct_drm_mode_fb_cmd2 cmd;
>> +
>> + if (entering(tcp)) {
>> + if (umoven_or_printaddr(tcp, arg, size, &cmd))
>> + return RVAL_IOCTL_DECODED;
>> + PRINT_FIELD_U("{", cmd, width);
>> + PRINT_FIELD_U(", ", cmd, height);
>> + PRINT_FIELD_X(", ", cmd, pixel_format);
>> + PRINT_FIELD_FLAGS(", ", cmd, flags,
>> drm_mode_fb_cmd2_flags,
>> + "DRM_MODE_FB_???");
>> + tprintf(", handles=[%u, %u, %u, %u]",
>> + cmd.handles[0], cmd.handles[1],
>> + cmd.handles[2], cmd.handles[3]);
>> + tprintf(", pitches=[%u, %u, %u, %u]",
>> + cmd.pitches[0], cmd.pitches[1],
>> + cmd.pitches[2], cmd.pitches[3]);
>> + tprintf(", offsets=[%u, %u, %u, %u]",
>> + cmd.offsets[0], cmd.offsets[1],
>> + cmd.offsets[2], cmd.offsets[3]);
>> + /* modifier field was added in Linux commit
>> v4.1-rc1~69^2~35^2~57. */
>> + if (size > offsetof(struct_drm_mode_fb_cmd2, modifier)) {
>> + tprintf(", modifiers=[%" PRIu64 ", %" PRIu64 ",
>> %" PRIu64 ", %" PRIu64 "]",
>> + (uint64_t) cmd.modifier[0], (uint64_t)
>> cmd.modifier[1],
>> + (uint64_t) cmd.modifier[2], (uint64_t)
>> cmd.modifier[3]);
>> + }
>> +
>> + return 0;
>> + }
>> +
>> + if (!syserror(tcp) && !umoven(tcp, arg, size, &cmd))
>> + PRINT_FIELD_U(", ", cmd, fb_id);
>> +
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_getplaneresources(struct tcb *const tcp, const kernel_ulong_t
>> arg)
>> +{
>> + struct_drm_mode_get_plane_res res;
>> + uint32_t plane_id_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &res))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + tprints("{plane_id_ptr=");
>> + print_array(tcp, res.plane_id_ptr, res.count_planes,
>> + &plane_id_val, sizeof(plane_id_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + PRINT_FIELD_U(", ", res, count_planes);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &res)) {
>> + PRINT_FIELD_U(" => {", res, count_planes);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_obj_getproperties(struct tcb *const tcp, const kernel_ulong_t
>> arg)
>> +{
>> + struct_drm_mode_obj_get_properties prop;
>> + uint32_t u32_val;
>> + uint64_t u64_val;
>> +
>> + if (entering(tcp)) {
>> + if (umove_or_printaddr(tcp, arg, &prop))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + tprints("{props_ptr=");
>> + print_array(tcp, prop.props_ptr, prop.count_props,
>> + &u32_val, sizeof(u32_val),
>> + tfetch_mem, print_uint32_array_member, 0);
>> + tprints(", prop_values_ptr=");
>> + print_array(tcp, prop.prop_values_ptr, prop.count_props,
>> + &u64_val, sizeof(u64_val),
>> + tfetch_mem, print_uint64_array_member, 0);
>> + PRINT_FIELD_U(", ", prop, count_props);
>> + PRINT_FIELD_U(", ", prop, obj_id);
>> + PRINT_FIELD_U(", ", prop, obj_type);
>> + tprints("}");
>> +
>> + return 0;
>> + }
>> +
>> + if (umove_nor_syserror(tcp, arg, &prop)) {
>> + PRINT_FIELD_U(" => {", prop, count_props);
>> + tprints("}");
>> + }
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +static int
>> +drm_mode_obj_setproperty(struct tcb *const tcp, const kernel_ulong_t arg)
>> +{
>> + struct_drm_mode_obj_set_property prop;
>> +
>> + if (umove_or_printaddr(tcp, arg, &prop))
>> + return RVAL_IOCTL_DECODED;
>> +
>> + PRINT_FIELD_U("{", prop, value);
>> + PRINT_FIELD_U(", ", prop, prop_id);
>> + PRINT_FIELD_U(", ", prop, obj_id);
>> + PRINT_FIELD_U(", ", prop, obj_type);
>> + tprints("}");
>> +
>> + return RVAL_IOCTL_DECODED;
>> +}
>> +
>> +MPERS_PRINTER_DECL(int, drm_ioctl_mpers, struct tcb *const tcp,
>> + const unsigned int code, const kernel_ulong_t arg)
>> +{
>> + switch (code) {
>> + case DRM_IOCTL_VERSION: /* RW */
>> + return drm_version(tcp, arg);
>> + case DRM_IOCTL_GET_UNIQUE: /* RW */
>> + return drm_unique(tcp, arg);
>> + case DRM_IOCTL_GET_MAP: /* RW */
>> + return drm_get_map(tcp, arg);
>> + case DRM_IOCTL_GET_CLIENT: /* RW */
>> + return drm_get_client(tcp, arg);
>> + case DRM_IOCTL_ADD_MAP: /* RW */
>> + return drm_add_map(tcp, arg);
>> + case DRM_IOCTL_ADD_BUFS: /* RW */
>> + return drm_add_bufs(tcp, arg);
>> + case DRM_IOCTL_MARK_BUFS: /* W */
>> + return drm_mark_bufs(tcp, arg);
>> + case DRM_IOCTL_INFO_BUFS: /* RW */
>> + return drm_info_bufs(tcp, arg);
>> + case DRM_IOCTL_MAP_BUFS: /* RW */
>> + return drm_map_bufs(tcp, arg);
>> + case DRM_IOCTL_FREE_BUFS: /* W */
>> + return drm_free_bufs(tcp, arg);
>> + case DRM_IOCTL_RM_MAP: /* W */
>> + return drm_rm_map(tcp, arg);
>> + case DRM_IOCTL_SET_SAREA_CTX:
>> + case DRM_IOCTL_GET_SAREA_CTX:
>> + return drm_sarea_ctx(tcp, arg, code ==
>> DRM_IOCTL_GET_SAREA_CTX);
>> + case DRM_IOCTL_RES_CTX: /* RW */
>> + return drm_res_ctx(tcp, arg);
>> + case DRM_IOCTL_AGP_ENABLE: /* W */
>> + return drm_agp_enable(tcp, arg);
>> + case DRM_IOCTL_AGP_INFO: /* R */
>> + return drm_agp_info(tcp, arg);
>> + case DRM_IOCTL_AGP_ALLOC: /* RW */
>> + return drm_agp_alloc(tcp, arg);
>> + case DRM_IOCTL_AGP_FREE: /* W */
>> + return drm_agp_free(tcp, arg);
>> + case DRM_IOCTL_AGP_BIND: /* W */
>> + case DRM_IOCTL_AGP_UNBIND: /* W */
>> + return drm_agp_bind(tcp, arg, code == DRM_IOCTL_AGP_BIND);
>> + case DRM_IOCTL_SG_ALLOC: /* RW */
>> + case DRM_IOCTL_SG_FREE: /* W */
>> + return drm_scatter_gather(tcp, arg, code ==
>> DRM_IOCTL_SG_ALLOC);
>> + case DRM_IOCTL_WAIT_VBLANK: /* RW */
>> + return drm_wait_vblank(tcp, arg);
>> + }
>> +
>> + /* The structure sizes of ioctl cmds below are different */
>> + /* among kernels and/or personalities so we can't just use */
>> + /* switch(code) to identify them but use _IOC_NR instead. */
>> +
>> + if (_IOC_NR(code) == _IOC_NR(DRM_IOCTL_MODE_GETCONNECTOR)) {
>> + return drm_mode_get_connector(tcp, arg, _IOC_SIZE(code));
>> + }
>> +
>> + if (_IOC_NR(code) == _IOC_NR(DRM_IOCTL_MODE_ADDFB2)) {
>> + return drm_mode_add_fb2(tcp, arg, _IOC_SIZE(code));
>> + }
>> +
>> + /* The structure sizes of ioctl cmds
>> DRM_IOCTL_MODE_GETPLANERESOURCES, */
>> + /* DRM_IOCTL_MODE_OBJ_GETPROPERTIES and
>> DRM_IOCTL_MODE_OBJ_SETPROPERTY */
>> + /* differs only among personalities, not versions of kernels,
>> this is */
>> + /* a little bit different from DRM_IOCTL_MODE_GETCONNECTOR which
>> may */
>> + /* differs among both kernels and personalities */
>> + if (_IOC_NR(code) == _IOC_NR(DRM_IOCTL_MODE_GETPLANERESOURCES)) {
>> + return drm_mode_getplaneresources(tcp, arg);
>> + }
>> +
>> + if (_IOC_NR(code) == _IOC_NR(DRM_IOCTL_MODE_OBJ_GETPROPERTIES)) {
>> + return drm_mode_obj_getproperties(tcp, arg);
>> + }
>> +
>> + if (_IOC_NR(code) == _IOC_NR(DRM_IOCTL_MODE_OBJ_SETPROPERTY)) {
>> + return drm_mode_obj_setproperty(tcp, arg);
>> + }
>> +
>> + return RVAL_DECODED;
>> +}
>> diff --git a/ioctl.c b/ioctl.c
>> index b80292cb..75bdc209 100644
>> --- a/ioctl.c
>> +++ b/ioctl.c
>> @@ -195,6 +195,8 @@ ioctl_decode_command_number(struct tcb *tcp)
>> return 1;
>> }
>> return 0;
>> + case 'd':
>> + return drm_decode_number(tcp, code);
>> default:
>> return 0;
>> }
>> @@ -264,6 +266,8 @@ ioctl_decode(struct tcb *tcp)
>> return fs_x_ioctl(tcp, code, arg);
>> case 0x22:
>> return scsi_ioctl(tcp, code, arg);
>> + case 'd':
>> + return drm_ioctl(tcp, code, arg);
>> case 'L':
>> return loop_ioctl(tcp, code, arg);
>> #ifdef HAVE_STRUCT_MTD_WRITE_REQ
>> diff --git a/linux/drm/drm.h b/linux/drm/drm.h
>> new file mode 100644
>> index 00000000..efcd16c3
>> --- /dev/null
>> +++ b/linux/drm/drm.h
>> @@ -0,0 +1,1042 @@
>> +/**
>> + * \file drm.h
>> + * Header for the Direct Rendering Manager
>> + *
>> + * \author Rickard E. (Rik) Faith <faith at valinux.com>
>> + *
>> + * \par Acknowledgments:
>> + * Dec 1999, Richard Henderson <rth at twiddle.net>, move to generic \c
>> cmpxchg.
>> + */
>> +
>> +/*
>> + * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
>> + * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
>> + * All rights reserved.
>> + *
>> + * Permission is hereby granted, free of charge, to any person obtaining
>> a
>> + * copy of this software and associated documentation files (the
>> "Software"),
>> + * to deal in the Software without restriction, including without
>> limitation
>> + * the rights to use, copy, modify, merge, publish, distribute,
>> sublicense,
>> + * and/or sell copies of the Software, and to permit persons to whom the
>> + * Software is furnished to do so, subject to the following conditions:
>> + *
>> + * The above copyright notice and this permission notice (including the
>> next
>> + * paragraph) shall be included in all copies or substantial portions of
>> the
>> + * Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
>> EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
>> MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
>> SHALL
>> + * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
>> DAMAGES OR
>> + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
>> + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
>> + * OTHER DEALINGS IN THE SOFTWARE.
>> + */
>> +
>> +#ifndef _DRM_H_
>> +#define _DRM_H_
>> +
>> +#if defined(__linux__)
>> +
>> +#include <linux/types.h>
>> +#include <linux/fcntl.h>
>> +#include <asm/ioctl.h>
>> +typedef unsigned int drm_handle_t;
>> +
>> +#else /* One of the BSDs */
>> +
>> +#include <stdint.h>
>> +#include <sys/ioccom.h>
>> +#include <sys/types.h>
>> +typedef int8_t __s8;
>> +typedef uint8_t __u8;
>> +typedef int16_t __s16;
>> +typedef uint16_t __u16;
>> +typedef int32_t __s32;
>> +typedef uint32_t __u32;
>> +typedef int64_t __s64;
>> +typedef uint64_t __u64;
>> +typedef unsigned long drm_handle_t;
>> +
>> +#endif
>> +
>> +#if defined(__cplusplus)
>> +extern "C" {
>> +#endif
>> +
>> +#define DRM_NAME "drm" /**< Name in kernel, /dev, and /proc */
>> +#define DRM_MIN_ORDER 5 /**< At least 2^5 bytes = 32 bytes */
>> +#define DRM_MAX_ORDER 22 /**< Up to 2^22 bytes = 4MB */
>> +#define DRM_RAM_PERCENT 10 /**< How much system ram can we lock? */
>> +
>> +#define _DRM_LOCK_HELD 0x80000000U /**< Hardware lock is held */
>> +#define _DRM_LOCK_CONT 0x40000000U /**< Hardware lock is contended */
>> +#define _DRM_LOCK_IS_HELD(lock) ((lock) & _DRM_LOCK_HELD)
>> +#define _DRM_LOCK_IS_CONT(lock) ((lock) & _DRM_LOCK_CONT)
>> +#define _DRM_LOCKING_CONTEXT(lock) ((lock) &
>> ~(_DRM_LOCK_HELD|_DRM_LOCK_CONT))
>> +
>> +typedef unsigned int drm_context_t;
>> +typedef unsigned int drm_drawable_t;
>> +typedef unsigned int drm_magic_t;
>> +
>> +/**
>> + * Cliprect.
>> + *
>> + * \warning: If you change this structure, make sure you change
>> + * XF86DRIClipRectRec in the server as well
>> + *
>> + * \note KW: Actually it's illegal to change either for
>> + * backwards-compatibility reasons.
>> + */
>> +struct drm_clip_rect {
>> + unsigned short x1;
>> + unsigned short y1;
>> + unsigned short x2;
>> + unsigned short y2;
>> +};
>> +
>> +/**
>> + * Drawable information.
>> + */
>> +struct drm_drawable_info {
>> + unsigned int num_rects;
>> + struct drm_clip_rect *rects;
>> +};
>> +
>> +/**
>> + * Texture region,
>> + */
>> +struct drm_tex_region {
>> + unsigned char next;
>> + unsigned char prev;
>> + unsigned char in_use;
>> + unsigned char padding;
>> + unsigned int age;
>> +};
>> +
>> +/**
>> + * Hardware lock.
>> + *
>> + * The lock structure is a simple cache-line aligned integer. To avoid
>> + * processor bus contention on a multiprocessor system, there should not
>> be any
>> + * other data stored in the same cache line.
>> + */
>> +struct drm_hw_lock {
>> + __volatile__ unsigned int lock; /**< lock variable */
>> + char padding[60]; /**< Pad to cache line */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_VERSION ioctl argument type.
>> + *
>> + * \sa drmGetVersion().
>> + */
>> +struct drm_version {
>> + int version_major; /**< Major version */
>> + int version_minor; /**< Minor version */
>> + int version_patchlevel; /**< Patch level */
>> + size_t name_len; /**< Length of name buffer */
>> + char *name; /**< Name of driver */
>> + size_t date_len; /**< Length of date buffer */
>> + char *date; /**< User-space buffer to hold date */
>> + size_t desc_len; /**< Length of desc buffer */
>> + char *desc; /**< User-space buffer to hold desc */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_GET_UNIQUE ioctl argument type.
>> + *
>> + * \sa drmGetBusid() and drmSetBusId().
>> + */
>> +struct drm_unique {
>> + size_t unique_len; /**< Length of unique */
>> + char *unique; /**< Unique name for driver instantiation */
>> +};
>> +
>> +struct drm_list {
>> + int count; /**< Length of user-space structures */
>> + struct drm_version *version;
>> +};
>> +
>> +struct drm_block {
>> + int unused;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_CONTROL ioctl argument type.
>> + *
>> + * \sa drmCtlInstHandler() and drmCtlUninstHandler().
>> + */
>> +struct drm_control {
>> + enum {
>> + DRM_ADD_COMMAND,
>> + DRM_RM_COMMAND,
>> + DRM_INST_HANDLER,
>> + DRM_UNINST_HANDLER
>> + } func;
>> + int irq;
>> +};
>> +
>> +/**
>> + * Type of memory to map.
>> + */
>> +enum drm_map_type {
>> + _DRM_FRAME_BUFFER = 0, /**< WC (no caching), no core dump */
>> + _DRM_REGISTERS = 1, /**< no caching, no core dump */
>> + _DRM_SHM = 2, /**< shared, cached */
>> + _DRM_AGP = 3, /**< AGP/GART */
>> + _DRM_SCATTER_GATHER = 4, /**< Scatter/gather memory for PCI DMA
>> */
>> + _DRM_CONSISTENT = 5 /**< Consistent memory for PCI DMA */
>> +};
>> +
>> +/**
>> + * Memory mapping flags.
>> + */
>> +enum drm_map_flags {
>> + _DRM_RESTRICTED = 0x01, /**< Cannot be mapped to
>> user-virtual */
>> + _DRM_READ_ONLY = 0x02,
>> + _DRM_LOCKED = 0x04, /**< shared, cached, locked */
>> + _DRM_KERNEL = 0x08, /**< kernel requires access */
>> + _DRM_WRITE_COMBINING = 0x10, /**< use write-combining if
>> available */
>> + _DRM_CONTAINS_LOCK = 0x20, /**< SHM page that contains lock */
>> + _DRM_REMOVABLE = 0x40, /**< Removable mapping */
>> + _DRM_DRIVER = 0x80 /**< Managed by driver */
>> +};
>> +
>> +struct drm_ctx_priv_map {
>> + unsigned int ctx_id; /**< Context requesting private mapping
>> */
>> + void *handle; /**< Handle of map */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_GET_MAP, DRM_IOCTL_ADD_MAP and DRM_IOCTL_RM_MAP ioctls
>> + * argument type.
>> + *
>> + * \sa drmAddMap().
>> + */
>> +struct drm_map {
>> + unsigned long offset; /**< Requested physical address (0 for
>> SAREA)*/
>> + unsigned long size; /**< Requested physical size (bytes) */
>> + enum drm_map_type type; /**< Type of memory to map */
>> + enum drm_map_flags flags; /**< Flags */
>> + void *handle; /**< User-space: "Handle" to pass to
>> mmap() */
>> + /**< Kernel-space: kernel-virtual
>> address */
>> + int mtrr; /**< MTRR slot used */
>> + /* Private data */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_GET_CLIENT ioctl argument type.
>> + */
>> +struct drm_client {
>> + int idx; /**< Which client desired? */
>> + int auth; /**< Is client authenticated? */
>> + unsigned long pid; /**< Process ID */
>> + unsigned long uid; /**< User ID */
>> + unsigned long magic; /**< Magic */
>> + unsigned long iocs; /**< Ioctl count */
>> +};
>> +
>> +enum drm_stat_type {
>> + _DRM_STAT_LOCK,
>> + _DRM_STAT_OPENS,
>> + _DRM_STAT_CLOSES,
>> + _DRM_STAT_IOCTLS,
>> + _DRM_STAT_LOCKS,
>> + _DRM_STAT_UNLOCKS,
>> + _DRM_STAT_VALUE, /**< Generic value */
>> + _DRM_STAT_BYTE, /**< Generic byte counter (1024bytes/K) */
>> + _DRM_STAT_COUNT, /**< Generic non-byte counter (1000/k) */
>> +
>> + _DRM_STAT_IRQ, /**< IRQ */
>> + _DRM_STAT_PRIMARY, /**< Primary DMA bytes */
>> + _DRM_STAT_SECONDARY, /**< Secondary DMA bytes */
>> + _DRM_STAT_DMA, /**< DMA */
>> + _DRM_STAT_SPECIAL, /**< Special DMA (e.g., priority or
>> polled) */
>> + _DRM_STAT_MISSED /**< Missed DMA opportunity */
>> + /* Add to the *END* of the list */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_GET_STATS ioctl argument type.
>> + */
>> +struct drm_stats {
>> + unsigned long count;
>> + struct {
>> + unsigned long value;
>> + enum drm_stat_type type;
>> + } data[15];
>> +};
>> +
>> +/**
>> + * Hardware locking flags.
>> + */
>> +enum drm_lock_flags {
>> + _DRM_LOCK_READY = 0x01, /**< Wait until hardware is ready
>> for DMA */
>> + _DRM_LOCK_QUIESCENT = 0x02, /**< Wait until hardware quiescent */
>> + _DRM_LOCK_FLUSH = 0x04, /**< Flush this context's DMA queue
>> first */
>> + _DRM_LOCK_FLUSH_ALL = 0x08, /**< Flush all DMA queues first */
>> + /* These *HALT* flags aren't supported yet
>> + -- they will be used to support the
>> + full-screen DGA-like mode. */
>> + _DRM_HALT_ALL_QUEUES = 0x10, /**< Halt all current and future
>> queues */
>> + _DRM_HALT_CUR_QUEUES = 0x20 /**< Halt all current queues */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_LOCK, DRM_IOCTL_UNLOCK and DRM_IOCTL_FINISH ioctl argument
>> type.
>> + *
>> + * \sa drmGetLock() and drmUnlock().
>> + */
>> +struct drm_lock {
>> + int context;
>> + enum drm_lock_flags flags;
>> +};
>> +
>> +/**
>> + * DMA flags
>> + *
>> + * \warning
>> + * These values \e must match xf86drm.h.
>> + *
>> + * \sa drm_dma.
>> + */
>> +enum drm_dma_flags {
>> + /* Flags for DMA buffer dispatch */
>> + _DRM_DMA_BLOCK = 0x01, /**<
>> + * Block until buffer dispatched.
>> + *
>> + * \note The buffer may not yet have
>> + * been processed by the hardware --
>> + * getting a hardware lock with the
>> + * hardware quiescent will ensure
>> + * that the buffer has been
>> + * processed.
>> + */
>> + _DRM_DMA_WHILE_LOCKED = 0x02, /**< Dispatch while lock held */
>> + _DRM_DMA_PRIORITY = 0x04, /**< High priority dispatch */
>> +
>> + /* Flags for DMA buffer request */
>> + _DRM_DMA_WAIT = 0x10, /**< Wait for free buffers */
>> + _DRM_DMA_SMALLER_OK = 0x20, /**< Smaller-than-requested buffers
>> OK */
>> + _DRM_DMA_LARGER_OK = 0x40 /**< Larger-than-requested buffers
>> OK */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_ADD_BUFS and DRM_IOCTL_MARK_BUFS ioctl argument type.
>> + *
>> + * \sa drmAddBufs().
>> + */
>> +struct drm_buf_desc {
>> + int count; /**< Number of buffers of this size */
>> + int size; /**< Size in bytes */
>> + int low_mark; /**< Low water mark */
>> + int high_mark; /**< High water mark */
>> + enum {
>> + _DRM_PAGE_ALIGN = 0x01, /**< Align on page boundaries for
>> DMA */
>> + _DRM_AGP_BUFFER = 0x02, /**< Buffer is in AGP space */
>> + _DRM_SG_BUFFER = 0x04, /**< Scatter/gather memory buffer
>> */
>> + _DRM_FB_BUFFER = 0x08, /**< Buffer is in frame buffer */
>> + _DRM_PCI_BUFFER_RO = 0x10 /**< Map PCI DMA buffer
>> read-only */
>> + } flags;
>> + unsigned long agp_start; /**<
>> + * Start address of where the AGP
>> buffers are
>> + * in the AGP aperture
>> + */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_INFO_BUFS ioctl argument type.
>> + */
>> +struct drm_buf_info {
>> + int count; /**< Entries in list */
>> + struct drm_buf_desc *list;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_FREE_BUFS ioctl argument type.
>> + */
>> +struct drm_buf_free {
>> + int count;
>> + int *list;
>> +};
>> +
>> +/**
>> + * Buffer information
>> + *
>> + * \sa drm_buf_map.
>> + */
>> +struct drm_buf_pub {
>> + int idx; /**< Index into the master buffer
>> list */
>> + int total; /**< Buffer size */
>> + int used; /**< Amount of buffer in use (for
>> DMA) */
>> + void *address; /**< Address of buffer */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_MAP_BUFS ioctl argument type.
>> + */
>> +struct drm_buf_map {
>> + int count; /**< Length of the buffer list */
>> +#ifdef __cplusplus
>> + void *virt;
>> +#else
>> + void *virtual; /**< Mmap'd area in user-virtual */
>> +#endif
>> + struct drm_buf_pub *list; /**< Buffer information */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_DMA ioctl argument type.
>> + *
>> + * Indices here refer to the offset into the buffer list in drm_buf_get.
>> + *
>> + * \sa drmDMA().
>> + */
>> +struct drm_dma {
>> + int context; /**< Context handle */
>> + int send_count; /**< Number of buffers to send
>> */
>> + int *send_indices; /**< List of handles to buffers */
>> + int *send_sizes; /**< Lengths of data to send */
>> + enum drm_dma_flags flags; /**< Flags */
>> + int request_count; /**< Number of buffers
>> requested */
>> + int request_size; /**< Desired size for buffers */
>> + int *request_indices; /**< Buffer information */
>> + int *request_sizes;
>> + int granted_count; /**< Number of buffers granted
>> */
>> +};
>> +
>> +enum drm_ctx_flags {
>> + _DRM_CONTEXT_PRESERVED = 0x01,
>> + _DRM_CONTEXT_2DONLY = 0x02
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_ADD_CTX ioctl argument type.
>> + *
>> + * \sa drmCreateContext() and drmDestroyContext().
>> + */
>> +struct drm_ctx {
>> + drm_context_t handle;
>> + enum drm_ctx_flags flags;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_RES_CTX ioctl argument type.
>> + */
>> +struct drm_ctx_res {
>> + int count;
>> + struct drm_ctx *contexts;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_ADD_DRAW and DRM_IOCTL_RM_DRAW ioctl argument type.
>> + */
>> +struct drm_draw {
>> + drm_drawable_t handle;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_UPDATE_DRAW ioctl argument type.
>> + */
>> +typedef enum {
>> + DRM_DRAWABLE_CLIPRECTS
>> +} drm_drawable_info_type_t;
>> +
>> +struct drm_update_draw {
>> + drm_drawable_t handle;
>> + unsigned int type;
>> + unsigned int num;
>> + unsigned long long data;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_GET_MAGIC and DRM_IOCTL_AUTH_MAGIC ioctl argument type.
>> + */
>> +struct drm_auth {
>> + drm_magic_t magic;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_IRQ_BUSID ioctl argument type.
>> + *
>> + * \sa drmGetInterruptFromBusID().
>> + */
>> +struct drm_irq_busid {
>> + int irq; /**< IRQ number */
>> + int busnum; /**< bus number */
>> + int devnum; /**< device number */
>> + int funcnum; /**< function number */
>> +};
>> +
>> +enum drm_vblank_seq_type {
>> + _DRM_VBLANK_ABSOLUTE = 0x0, /**< Wait for specific vblank
>> sequence number */
>> + _DRM_VBLANK_RELATIVE = 0x1, /**< Wait for given number of
>> vblanks */
>> + /* bits 1-6 are reserved for high crtcs */
>> + _DRM_VBLANK_HIGH_CRTC_MASK = 0x0000003e,
>> + _DRM_VBLANK_EVENT = 0x4000000, /**< Send event instead of
>> blocking */
>> + _DRM_VBLANK_FLIP = 0x8000000, /**< Scheduled buffer swap should
>> flip */
>> + _DRM_VBLANK_NEXTONMISS = 0x10000000, /**< If missed, wait for
>> next vblank */
>> + _DRM_VBLANK_SECONDARY = 0x20000000, /**< Secondary display
>> controller */
>> + _DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of
>> blocking, unsupported */
>> +};
>> +#define _DRM_VBLANK_HIGH_CRTC_SHIFT 1
>> +
>> +#define _DRM_VBLANK_TYPES_MASK (_DRM_VBLANK_ABSOLUTE |
>> _DRM_VBLANK_RELATIVE)
>> +#define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_EVENT | _DRM_VBLANK_SIGNAL |
>> \
>> + _DRM_VBLANK_SECONDARY |
>> _DRM_VBLANK_NEXTONMISS)
>> +
>> +struct drm_wait_vblank_request {
>> + enum drm_vblank_seq_type type;
>> + unsigned int sequence;
>> + unsigned long signal;
>> +};
>> +
>> +struct drm_wait_vblank_reply {
>> + enum drm_vblank_seq_type type;
>> + unsigned int sequence;
>> + long tval_sec;
>> + long tval_usec;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_WAIT_VBLANK ioctl argument type.
>> + *
>> + * \sa drmWaitVBlank().
>> + */
>> +union drm_wait_vblank {
>> + struct drm_wait_vblank_request request;
>> + struct drm_wait_vblank_reply reply;
>> +};
>> +
>> +#define _DRM_PRE_MODESET 1
>> +#define _DRM_POST_MODESET 2
>> +
>> +/**
>> + * DRM_IOCTL_MODESET_CTL ioctl argument type
>> + *
>> + * \sa drmModesetCtl().
>> + */
>> +struct drm_modeset_ctl {
>> + __u32 crtc;
>> + __u32 cmd;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_AGP_ENABLE ioctl argument type.
>> + *
>> + * \sa drmAgpEnable().
>> + */
>> +struct drm_agp_mode {
>> + unsigned long mode; /**< AGP mode */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_AGP_ALLOC and DRM_IOCTL_AGP_FREE ioctls argument type.
>> + *
>> + * \sa drmAgpAlloc() and drmAgpFree().
>> + */
>> +struct drm_agp_buffer {
>> + unsigned long size; /**< In bytes -- will round to page
>> boundary */
>> + unsigned long handle; /**< Used for binding / unbinding */
>> + unsigned long type; /**< Type of memory to allocate */
>> + unsigned long physical; /**< Physical used by i810 */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_AGP_BIND and DRM_IOCTL_AGP_UNBIND ioctls argument type.
>> + *
>> + * \sa drmAgpBind() and drmAgpUnbind().
>> + */
>> +struct drm_agp_binding {
>> + unsigned long handle; /**< From drm_agp_buffer */
>> + unsigned long offset; /**< In bytes -- will round to page
>> boundary */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_AGP_INFO ioctl argument type.
>> + *
>> + * \sa drmAgpVersionMajor(), drmAgpVersionMinor(), drmAgpGetMode(),
>> + * drmAgpBase(), drmAgpSize(), drmAgpMemoryUsed(), drmAgpMemoryAvail(),
>> + * drmAgpVendorId() and drmAgpDeviceId().
>> + */
>> +struct drm_agp_info {
>> + int agp_version_major;
>> + int agp_version_minor;
>> + unsigned long mode;
>> + unsigned long aperture_base; /* physical address */
>> + unsigned long aperture_size; /* bytes */
>> + unsigned long memory_allowed; /* bytes */
>> + unsigned long memory_used;
>> +
>> + /* PCI information */
>> + unsigned short id_vendor;
>> + unsigned short id_device;
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_SG_ALLOC ioctl argument type.
>> + */
>> +struct drm_scatter_gather {
>> + unsigned long size; /**< In bytes -- will round to page
>> boundary */
>> + unsigned long handle; /**< Used for mapping / unmapping */
>> +};
>> +
>> +/**
>> + * DRM_IOCTL_SET_VERSION ioctl argument type.
>> + */
>> +struct drm_set_version {
>> + int drm_di_major;
>> + int drm_di_minor;
>> + int drm_dd_major;
>> + int drm_dd_minor;
>> +};
>> +
>> +/** DRM_IOCTL_GEM_CLOSE ioctl argument type */
>> +struct drm_gem_close {
>> + /** Handle of the object to be closed. */
>> + __u32 handle;
>> + __u32 pad;
>> +};
>> +
>> +/** DRM_IOCTL_GEM_FLINK ioctl argument type */
>> +struct drm_gem_flink {
>> + /** Handle for the object being named */
>> + __u32 handle;
>> +
>> + /** Returned global name */
>> + __u32 name;
>> +};
>> +
>> +/** DRM_IOCTL_GEM_OPEN ioctl argument type */
>> +struct drm_gem_open {
>> + /** Name of object being opened */
>> + __u32 name;
>> +
>> + /** Returned handle for the object */
>> + __u32 handle;
>> +
>> + /** Returned size of the object */
>> + __u64 size;
>> +};
>> +
>> +#define DRM_CAP_DUMB_BUFFER 0x1
>> +#define DRM_CAP_VBLANK_HIGH_CRTC 0x2
>> +#define DRM_CAP_DUMB_PREFERRED_DEPTH 0x3
>> +#define DRM_CAP_DUMB_PREFER_SHADOW 0x4
>> +#define DRM_CAP_PRIME 0x5
>> +#define DRM_PRIME_CAP_IMPORT 0x1
>> +#define DRM_PRIME_CAP_EXPORT 0x2
>> +#define DRM_CAP_TIMESTAMP_MONOTONIC 0x6
>> +#define DRM_CAP_ASYNC_PAGE_FLIP 0x7
>> +/*
>> + * The CURSOR_WIDTH and CURSOR_HEIGHT capabilities return a valid
>> widthxheight
>> + * combination for the hardware cursor. The intention is that a hardware
>> + * agnostic userspace can query a cursor plane size to use.
>> + *
>> + * Note that the cross-driver contract is to merely return a valid size;
>> + * drivers are free to attach another meaning on top, eg. i915 returns
>> the
>> + * maximum plane size.
>> + */
>> +#define DRM_CAP_CURSOR_WIDTH 0x8
>> +#define DRM_CAP_CURSOR_HEIGHT 0x9
>> +#define DRM_CAP_ADDFB2_MODIFIERS 0x10
>> +#define DRM_CAP_PAGE_FLIP_TARGET 0x11
>> +#define DRM_CAP_CRTC_IN_VBLANK_EVENT 0x12
>> +#define DRM_CAP_SYNCOBJ 0x13
>> +#define DRM_CAP_SYNCOBJ_TIMELINE 0x14
>> +
>> +/** DRM_IOCTL_GET_CAP ioctl argument type */
>> +struct drm_get_cap {
>> + __u64 capability;
>> + __u64 value;
>> +};
>> +
>> +/**
>> + * DRM_CLIENT_CAP_STEREO_3D
>> + *
>> + * if set to 1, the DRM core will expose the stereo 3D capabilities of
>> the
>> + * monitor by advertising the supported 3D layouts in the flags of struct
>> + * drm_mode_modeinfo.
>> + */
>> +#define DRM_CLIENT_CAP_STEREO_3D 1
>> +
>> +/**
>> + * DRM_CLIENT_CAP_UNIVERSAL_PLANES
>> + *
>> + * If set to 1, the DRM core will expose all planes (overlay, primary,
>> and
>> + * cursor) to userspace.
>> + */
>> +#define DRM_CLIENT_CAP_UNIVERSAL_PLANES 2
>> +
>> +/**
>> + * DRM_CLIENT_CAP_ATOMIC
>> + *
>> + * If set to 1, the DRM core will expose atomic properties to userspace
>> + */
>> +#define DRM_CLIENT_CAP_ATOMIC 3
>> +
>> +/**
>> + * DRM_CLIENT_CAP_ASPECT_RATIO
>> + *
>> + * If set to 1, the DRM core will provide aspect ratio information in
>> modes.
>> + */
>> +#define DRM_CLIENT_CAP_ASPECT_RATIO 4
>> +
>> +/**
>> + * DRM_CLIENT_CAP_WRITEBACK_CONNECTORS
>> + *
>> + * If set to 1, the DRM core will expose special connectors to be used
>> for
>> + * writing back to memory the scene setup in the commit. Depends on
>> client
>> + * also supporting DRM_CLIENT_CAP_ATOMIC
>> + */
>> +#define DRM_CLIENT_CAP_WRITEBACK_CONNECTORS 5
>> +
>> +/** DRM_IOCTL_SET_CLIENT_CAP ioctl argument type */
>> +struct drm_set_client_cap {
>> + __u64 capability;
>> + __u64 value;
>> +};
>> +
>> +#define DRM_RDWR O_RDWR
>> +#define DRM_CLOEXEC O_CLOEXEC
>> +struct drm_prime_handle {
>> + __u32 handle;
>> +
>> + /** Flags.. only applicable for handle->fd */
>> + __u32 flags;
>> +
>> + /** Returned dmabuf file descriptor */
>> + __s32 fd;
>> +};
>> +
>> +struct drm_syncobj_create {
>> + __u32 handle;
>> +#define DRM_SYNCOBJ_CREATE_SIGNALED (1 << 0)
>> + __u32 flags;
>> +};
>> +
>> +struct drm_syncobj_destroy {
>> + __u32 handle;
>> + __u32 pad;
>> +};
>> +
>> +#define DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE (1 << 0)
>> +#define DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE (1 << 0)
>> +struct drm_syncobj_handle {
>> + __u32 handle;
>> + __u32 flags;
>> +
>> + __s32 fd;
>> + __u32 pad;
>> +};
>> +
>> +struct drm_syncobj_transfer {
>> + __u32 src_handle;
>> + __u32 dst_handle;
>> + __u64 src_point;
>> + __u64 dst_point;
>> + __u32 flags;
>> + __u32 pad;
>> +};
>> +
>> +#define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL (1 << 0)
>> +#define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT (1 << 1)
>> +#define DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE (1 << 2) /* wait for time
>> point to become available */
>> +struct drm_syncobj_wait {
>> + __u64 handles;
>> + /* absolute timeout */
>> + __s64 timeout_nsec;
>> + __u32 count_handles;
>> + __u32 flags;
>> + __u32 first_signaled; /* only valid when not waiting all */
>> + __u32 pad;
>> +};
>> +
>> +struct drm_syncobj_timeline_wait {
>> + __u64 handles;
>> + /* wait on specific timeline point for every handles*/
>> + __u64 points;
>> + /* absolute timeout */
>> + __s64 timeout_nsec;
>> + __u32 count_handles;
>> + __u32 flags;
>> + __u32 first_signaled; /* only valid when not waiting all */
>> + __u32 pad;
>> +};
>> +
>> +
>> +struct drm_syncobj_array {
>> + __u64 handles;
>> + __u32 count_handles;
>> + __u32 pad;
>> +};
>> +
>> +struct drm_syncobj_timeline_array {
>> + __u64 handles;
>> + __u64 points;
>> + __u32 count_handles;
>> + __u32 pad;
>> +};
>> +
>> +
>> +/* Query current scanout sequence number */
>> +struct drm_crtc_get_sequence {
>> + __u32 crtc_id; /* requested crtc_id */
>> + __u32 active; /* return: crtc output is active */
>> + __u64 sequence; /* return: most recent vblank sequence */
>> + __s64 sequence_ns; /* return: most recent time of first
>> pixel out */
>> +};
>> +
>> +/* Queue event to be delivered at specified sequence. Time stamp marks
>> + * when the first pixel of the refresh cycle leaves the display engine
>> + * for the display
>> + */
>> +#define DRM_CRTC_SEQUENCE_RELATIVE 0x00000001 /*
>> sequence is relative to current */
>> +#define DRM_CRTC_SEQUENCE_NEXT_ON_MISS 0x00000002 /* Use
>> next sequence if we've missed */
>> +
>> +struct drm_crtc_queue_sequence {
>> + __u32 crtc_id;
>> + __u32 flags;
>> + __u64 sequence; /* on input, target sequence. on output,
>> actual sequence */
>> + __u64 user_data; /* user data passed to event */
>> +};
>> +
>> +#if defined(__cplusplus)
>> +}
>> +#endif
>> +
>> +#include "drm_mode.h"
>> +
>> +#if defined(__cplusplus)
>> +extern "C" {
>> +#endif
>> +
>> +#define DRM_IOCTL_BASE 'd'
>> +#define DRM_IO(nr) _IO(DRM_IOCTL_BASE,nr)
>> +#define DRM_IOR(nr,type) _IOR(DRM_IOCTL_BASE,nr,type)
>> +#define DRM_IOW(nr,type) _IOW(DRM_IOCTL_BASE,nr,type)
>> +#define DRM_IOWR(nr,type) _IOWR(DRM_IOCTL_BASE,nr,type)
>> +
>> +#define DRM_IOCTL_VERSION DRM_IOWR(0x00, struct drm_version)
>> +#define DRM_IOCTL_GET_UNIQUE DRM_IOWR(0x01, struct drm_unique)
>> +#define DRM_IOCTL_GET_MAGIC DRM_IOR( 0x02, struct drm_auth)
>> +#define DRM_IOCTL_IRQ_BUSID DRM_IOWR(0x03, struct
>> drm_irq_busid)
>> +#define DRM_IOCTL_GET_MAP DRM_IOWR(0x04, struct drm_map)
>> +#define DRM_IOCTL_GET_CLIENT DRM_IOWR(0x05, struct drm_client)
>> +#define DRM_IOCTL_GET_STATS DRM_IOR( 0x06, struct drm_stats)
>> +#define DRM_IOCTL_SET_VERSION DRM_IOWR(0x07, struct
>> drm_set_version)
>> +#define DRM_IOCTL_MODESET_CTL DRM_IOW(0x08, struct
>> drm_modeset_ctl)
>> +#define DRM_IOCTL_GEM_CLOSE DRM_IOW (0x09, struct
>> drm_gem_close)
>> +#define DRM_IOCTL_GEM_FLINK DRM_IOWR(0x0a, struct
>> drm_gem_flink)
>> +#define DRM_IOCTL_GEM_OPEN DRM_IOWR(0x0b, struct
>> drm_gem_open)
>> +#define DRM_IOCTL_GET_CAP DRM_IOWR(0x0c, struct drm_get_cap)
>> +#define DRM_IOCTL_SET_CLIENT_CAP DRM_IOW( 0x0d, struct
>> drm_set_client_cap)
>> +
>> +#define DRM_IOCTL_SET_UNIQUE DRM_IOW( 0x10, struct drm_unique)
>> +#define DRM_IOCTL_AUTH_MAGIC DRM_IOW( 0x11, struct drm_auth)
>> +#define DRM_IOCTL_BLOCK DRM_IOWR(0x12, struct
>> drm_block)
>> +#define DRM_IOCTL_UNBLOCK DRM_IOWR(0x13, struct drm_block)
>> +#define DRM_IOCTL_CONTROL DRM_IOW( 0x14, struct drm_control)
>> +#define DRM_IOCTL_ADD_MAP DRM_IOWR(0x15, struct drm_map)
>> +#define DRM_IOCTL_ADD_BUFS DRM_IOWR(0x16, struct
>> drm_buf_desc)
>> +#define DRM_IOCTL_MARK_BUFS DRM_IOW( 0x17, struct
>> drm_buf_desc)
>> +#define DRM_IOCTL_INFO_BUFS DRM_IOWR(0x18, struct
>> drm_buf_info)
>> +#define DRM_IOCTL_MAP_BUFS DRM_IOWR(0x19, struct drm_buf_map)
>> +#define DRM_IOCTL_FREE_BUFS DRM_IOW( 0x1a, struct
>> drm_buf_free)
>> +
>> +#define DRM_IOCTL_RM_MAP DRM_IOW( 0x1b, struct drm_map)
>> +
>> +#define DRM_IOCTL_SET_SAREA_CTX DRM_IOW( 0x1c, struct
>> drm_ctx_priv_map)
>> +#define DRM_IOCTL_GET_SAREA_CTX DRM_IOWR(0x1d, struct
>> drm_ctx_priv_map)
>> +
>> +#define DRM_IOCTL_SET_MASTER DRM_IO(0x1e)
>> +#define DRM_IOCTL_DROP_MASTER DRM_IO(0x1f)
>> +
>> +#define DRM_IOCTL_ADD_CTX DRM_IOWR(0x20, struct drm_ctx)
>> +#define DRM_IOCTL_RM_CTX DRM_IOWR(0x21, struct drm_ctx)
>> +#define DRM_IOCTL_MOD_CTX DRM_IOW( 0x22, struct drm_ctx)
>> +#define DRM_IOCTL_GET_CTX DRM_IOWR(0x23, struct drm_ctx)
>> +#define DRM_IOCTL_SWITCH_CTX DRM_IOW( 0x24, struct drm_ctx)
>> +#define DRM_IOCTL_NEW_CTX DRM_IOW( 0x25, struct drm_ctx)
>> +#define DRM_IOCTL_RES_CTX DRM_IOWR(0x26, struct drm_ctx_res)
>> +#define DRM_IOCTL_ADD_DRAW DRM_IOWR(0x27, struct drm_draw)
>> +#define DRM_IOCTL_RM_DRAW DRM_IOWR(0x28, struct drm_draw)
>> +#define DRM_IOCTL_DMA DRM_IOWR(0x29, struct drm_dma)
>> +#define DRM_IOCTL_LOCK DRM_IOW( 0x2a, struct drm_lock)
>> +#define DRM_IOCTL_UNLOCK DRM_IOW( 0x2b, struct drm_lock)
>> +#define DRM_IOCTL_FINISH DRM_IOW( 0x2c, struct drm_lock)
>> +
>> +#define DRM_IOCTL_PRIME_HANDLE_TO_FD DRM_IOWR(0x2d, struct
>> drm_prime_handle)
>> +#define DRM_IOCTL_PRIME_FD_TO_HANDLE DRM_IOWR(0x2e, struct
>> drm_prime_handle)
>> +
>> +#define DRM_IOCTL_AGP_ACQUIRE DRM_IO( 0x30)
>> +#define DRM_IOCTL_AGP_RELEASE DRM_IO( 0x31)
>> +#define DRM_IOCTL_AGP_ENABLE DRM_IOW( 0x32, struct
>> drm_agp_mode)
>> +#define DRM_IOCTL_AGP_INFO DRM_IOR( 0x33, struct
>> drm_agp_info)
>> +#define DRM_IOCTL_AGP_ALLOC DRM_IOWR(0x34, struct
>> drm_agp_buffer)
>> +#define DRM_IOCTL_AGP_FREE DRM_IOW( 0x35, struct
>> drm_agp_buffer)
>> +#define DRM_IOCTL_AGP_BIND DRM_IOW( 0x36, struct
>> drm_agp_binding)
>> +#define DRM_IOCTL_AGP_UNBIND DRM_IOW( 0x37, struct
>> drm_agp_binding)
>> +
>> +#define DRM_IOCTL_SG_ALLOC DRM_IOWR(0x38, struct
>> drm_scatter_gather)
>> +#define DRM_IOCTL_SG_FREE DRM_IOW( 0x39, struct
>> drm_scatter_gather)
>> +
>> +#define DRM_IOCTL_WAIT_VBLANK DRM_IOWR(0x3a, union
>> drm_wait_vblank)
>> +
>> +#define DRM_IOCTL_CRTC_GET_SEQUENCE DRM_IOWR(0x3b, struct
>> drm_crtc_get_sequence)
>> +#define DRM_IOCTL_CRTC_QUEUE_SEQUENCE DRM_IOWR(0x3c, struct
>> drm_crtc_queue_sequence)
>> +
>> +#define DRM_IOCTL_UPDATE_DRAW DRM_IOW(0x3f, struct
>> drm_update_draw)
>> +
>> +#define DRM_IOCTL_MODE_GETRESOURCES DRM_IOWR(0xA0, struct
>> drm_mode_card_res)
>> +#define DRM_IOCTL_MODE_GETCRTC DRM_IOWR(0xA1, struct
>> drm_mode_crtc)
>> +#define DRM_IOCTL_MODE_SETCRTC DRM_IOWR(0xA2, struct
>> drm_mode_crtc)
>> +#define DRM_IOCTL_MODE_CURSOR DRM_IOWR(0xA3, struct
>> drm_mode_cursor)
>> +#define DRM_IOCTL_MODE_GETGAMMA DRM_IOWR(0xA4, struct
>> drm_mode_crtc_lut)
>> +#define DRM_IOCTL_MODE_SETGAMMA DRM_IOWR(0xA5, struct
>> drm_mode_crtc_lut)
>> +#define DRM_IOCTL_MODE_GETENCODER DRM_IOWR(0xA6, struct
>> drm_mode_get_encoder)
>> +#define DRM_IOCTL_MODE_GETCONNECTOR DRM_IOWR(0xA7, struct
>> drm_mode_get_connector)
>> +#define DRM_IOCTL_MODE_ATTACHMODE DRM_IOWR(0xA8, struct
>> drm_mode_mode_cmd) /* deprecated (never worked) */
>> +#define DRM_IOCTL_MODE_DETACHMODE DRM_IOWR(0xA9, struct
>> drm_mode_mode_cmd) /* deprecated (never worked) */
>> +
>> +#define DRM_IOCTL_MODE_GETPROPERTY DRM_IOWR(0xAA, struct
>> drm_mode_get_property)
>> +#define DRM_IOCTL_MODE_SETPROPERTY DRM_IOWR(0xAB, struct
>> drm_mode_connector_set_property)
>> +#define DRM_IOCTL_MODE_GETPROPBLOB DRM_IOWR(0xAC, struct
>> drm_mode_get_blob)
>> +#define DRM_IOCTL_MODE_GETFB DRM_IOWR(0xAD, struct
>> drm_mode_fb_cmd)
>> +#define DRM_IOCTL_MODE_ADDFB DRM_IOWR(0xAE, struct
>> drm_mode_fb_cmd)
>> +#define DRM_IOCTL_MODE_RMFB DRM_IOWR(0xAF, unsigned int)
>> +#define DRM_IOCTL_MODE_PAGE_FLIP DRM_IOWR(0xB0, struct
>> drm_mode_crtc_page_flip)
>> +#define DRM_IOCTL_MODE_DIRTYFB DRM_IOWR(0xB1, struct
>> drm_mode_fb_dirty_cmd)
>> +
>> +#define DRM_IOCTL_MODE_CREATE_DUMB DRM_IOWR(0xB2, struct
>> drm_mode_create_dumb)
>> +#define DRM_IOCTL_MODE_MAP_DUMB DRM_IOWR(0xB3, struct
>> drm_mode_map_dumb)
>> +#define DRM_IOCTL_MODE_DESTROY_DUMB DRM_IOWR(0xB4, struct
>> drm_mode_destroy_dumb)
>> +#define DRM_IOCTL_MODE_GETPLANERESOURCES DRM_IOWR(0xB5, struct
>> drm_mode_get_plane_res)
>> +#define DRM_IOCTL_MODE_GETPLANE DRM_IOWR(0xB6, struct
>> drm_mode_get_plane)
>> +#define DRM_IOCTL_MODE_SETPLANE DRM_IOWR(0xB7, struct
>> drm_mode_set_plane)
>> +#define DRM_IOCTL_MODE_ADDFB2 DRM_IOWR(0xB8, struct
>> drm_mode_fb_cmd2)
>> +#define DRM_IOCTL_MODE_OBJ_GETPROPERTIES DRM_IOWR(0xB9, struct
>> drm_mode_obj_get_properties)
>> +#define DRM_IOCTL_MODE_OBJ_SETPROPERTY DRM_IOWR(0xBA, struct
>> drm_mode_obj_set_property)
>> +#define DRM_IOCTL_MODE_CURSOR2 DRM_IOWR(0xBB, struct
>> drm_mode_cursor2)
>> +#define DRM_IOCTL_MODE_ATOMIC DRM_IOWR(0xBC, struct
>> drm_mode_atomic)
>> +#define DRM_IOCTL_MODE_CREATEPROPBLOB DRM_IOWR(0xBD, struct
>> drm_mode_create_blob)
>> +#define DRM_IOCTL_MODE_DESTROYPROPBLOB DRM_IOWR(0xBE, struct
>> drm_mode_destroy_blob)
>> +
>> +#define DRM_IOCTL_SYNCOBJ_CREATE DRM_IOWR(0xBF, struct
>> drm_syncobj_create)
>> +#define DRM_IOCTL_SYNCOBJ_DESTROY DRM_IOWR(0xC0, struct
>> drm_syncobj_destroy)
>> +#define DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD DRM_IOWR(0xC1, struct
>> drm_syncobj_handle)
>> +#define DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE DRM_IOWR(0xC2, struct
>> drm_syncobj_handle)
>> +#define DRM_IOCTL_SYNCOBJ_WAIT DRM_IOWR(0xC3, struct
>> drm_syncobj_wait)
>> +#define DRM_IOCTL_SYNCOBJ_RESET DRM_IOWR(0xC4, struct
>> drm_syncobj_array)
>> +#define DRM_IOCTL_SYNCOBJ_SIGNAL DRM_IOWR(0xC5, struct
>> drm_syncobj_array)
>> +
>> +#define DRM_IOCTL_MODE_CREATE_LEASE DRM_IOWR(0xC6, struct
>> drm_mode_create_lease)
>> +#define DRM_IOCTL_MODE_LIST_LESSEES DRM_IOWR(0xC7, struct
>> drm_mode_list_lessees)
>> +#define DRM_IOCTL_MODE_GET_LEASE DRM_IOWR(0xC8, struct
>> drm_mode_get_lease)
>> +#define DRM_IOCTL_MODE_REVOKE_LEASE DRM_IOWR(0xC9, struct
>> drm_mode_revoke_lease)
>> +
>> +#define DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT DRM_IOWR(0xCA, struct
>> drm_syncobj_timeline_wait)
>> +#define DRM_IOCTL_SYNCOBJ_QUERY DRM_IOWR(0xCB, struct
>> drm_syncobj_timeline_array)
>> +#define DRM_IOCTL_SYNCOBJ_TRANSFER DRM_IOWR(0xCC, struct
>> drm_syncobj_transfer)
>> +#define DRM_IOCTL_SYNCOBJ_TIMELINE_SIGNAL DRM_IOWR(0xCD, struct
>> drm_syncobj_timeline_array)
>> +
>> +/**
>> + * Device specific ioctls should only be in their respective headers
>> + * The device specific ioctl range is from 0x40 to 0x9f.
>> + * Generic IOCTLS restart at 0xA0.
>> + *
>> + * \sa drmCommandNone(), drmCommandRead(), drmCommandWrite(), and
>> + * drmCommandReadWrite().
>> + */
>> +#define DRM_COMMAND_BASE 0x40
>> +#define DRM_COMMAND_END 0xA0
>> +
>> +/**
>> + * Header for events written back to userspace on the drm fd. The
>> + * type defines the type of event, the length specifies the total
>> + * length of the event (including the header), and user_data is
>> + * typically a 64 bit value passed with the ioctl that triggered the
>> + * event. A read on the drm fd will always only return complete
>> + * events, that is, if for example the read buffer is 100 bytes, and
>> + * there are two 64 byte events pending, only one will be returned.
>> + *
>> + * Event types 0 - 0x7fffffff are generic drm events, 0x80000000 and
>> + * up are chipset specific.
>> + */
>> +struct drm_event {
>> + __u32 type;
>> + __u32 length;
>> +};
>> +
>> +#define DRM_EVENT_VBLANK 0x01
>> +#define DRM_EVENT_FLIP_COMPLETE 0x02
>> +#define DRM_EVENT_CRTC_SEQUENCE 0x03
>> +
>> +struct drm_event_vblank {
>> + struct drm_event base;
>> + __u64 user_data;
>> + __u32 tv_sec;
>> + __u32 tv_usec;
>> + __u32 sequence;
>> + __u32 crtc_id; /* 0 on older kernels that do not support this */
>> +};
>> +
>> +/* Event delivered at sequence. Time stamp marks when the first pixel
>> + * of the refresh cycle leaves the display engine for the display
>> + */
>> +struct drm_event_crtc_sequence {
>> + struct drm_event base;
>> + __u64 user_data;
>> + __s64 time_ns;
>> + __u64 sequence;
>> +};
>> +
>> +/* typedef area */
>> +typedef struct drm_clip_rect drm_clip_rect_t;
>> +typedef struct drm_drawable_info drm_drawable_info_t;
>> +typedef struct drm_tex_region drm_tex_region_t;
>> +typedef struct drm_hw_lock drm_hw_lock_t;
>> +typedef struct drm_version drm_version_t;
>> +typedef struct drm_unique drm_unique_t;
>> +typedef struct drm_list drm_list_t;
>> +typedef struct drm_block drm_block_t;
>> +typedef struct drm_control drm_control_t;
>> +typedef enum drm_map_type drm_map_type_t;
>> +typedef enum drm_map_flags drm_map_flags_t;
>> +typedef struct drm_ctx_priv_map drm_ctx_priv_map_t;
>> +typedef struct drm_map drm_map_t;
>> +typedef struct drm_client drm_client_t;
>> +typedef enum drm_stat_type drm_stat_type_t;
>> +typedef struct drm_stats drm_stats_t;
>> +typedef enum drm_lock_flags drm_lock_flags_t;
>> +typedef struct drm_lock drm_lock_t;
>> +typedef enum drm_dma_flags drm_dma_flags_t;
>> +typedef struct drm_buf_desc drm_buf_desc_t;
>> +typedef struct drm_buf_info drm_buf_info_t;
>> +typedef struct drm_buf_free drm_buf_free_t;
>> +typedef struct drm_buf_pub drm_buf_pub_t;
>> +typedef struct drm_buf_map drm_buf_map_t;
>> +typedef struct drm_dma drm_dma_t;
>> +typedef union drm_wait_vblank drm_wait_vblank_t;
>> +typedef struct drm_agp_mode drm_agp_mode_t;
>> +typedef enum drm_ctx_flags drm_ctx_flags_t;
>> +typedef struct drm_ctx drm_ctx_t;
>> +typedef struct drm_ctx_res drm_ctx_res_t;
>> +typedef struct drm_draw drm_draw_t;
>> +typedef struct drm_update_draw drm_update_draw_t;
>> +typedef struct drm_auth drm_auth_t;
>> +typedef struct drm_irq_busid drm_irq_busid_t;
>> +typedef enum drm_vblank_seq_type drm_vblank_seq_type_t;
>> +
>> +typedef struct drm_agp_buffer drm_agp_buffer_t;
>> +typedef struct drm_agp_binding drm_agp_binding_t;
>> +typedef struct drm_agp_info drm_agp_info_t;
>> +typedef struct drm_scatter_gather drm_scatter_gather_t;
>> +typedef struct drm_set_version drm_set_version_t;
>> +
>> +#if defined(__cplusplus)
>> +}
>> +#endif
>> +
>> +#endif
>> diff --git a/linux/drm/drm_mode.h b/linux/drm/drm_mode.h
>> new file mode 100644
>> index 00000000..5fe6c649
>> --- /dev/null
>> +++ b/linux/drm/drm_mode.h
>> @@ -0,0 +1,914 @@
>> +/*
>> + * Copyright (c) 2007 Dave Airlie <airlied at linux.ie>
>> + * Copyright (c) 2007 Jakob Bornecrantz <wallbraker at gmail.com>
>> + * Copyright (c) 2008 Red Hat Inc.
>> + * Copyright (c) 2007-2008 Tungsten Graphics, Inc., Cedar Park, TX., USA
>> + * Copyright (c) 2007-2008 Intel Corporation
>> + *
>> + * Permission is hereby granted, free of charge, to any person obtaining
>> a
>> + * copy of this software and associated documentation files (the
>> "Software"),
>> + * to deal in the Software without restriction, including without
>> limitation
>> + * the rights to use, copy, modify, merge, publish, distribute,
>> sublicense,
>> + * and/or sell copies of the Software, and to permit persons to whom the
>> + * Software is furnished to do so, subject to the following conditions:
>> + *
>> + * The above copyright notice and this permission notice shall be
>> included in
>> + * all copies or substantial portions of the Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
>> EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
>> MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
>> SHALL THE
>> + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
>> ARISING
>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>> DEALINGS
>> + * IN THE SOFTWARE.
>> + */
>> +
>> +#ifndef _DRM_MODE_H
>> +#define _DRM_MODE_H
>> +
>> +#include "drm.h"
>> +
>> +#if defined(__cplusplus)
>> +extern "C" {
>> +#endif
>> +
>> +#define DRM_CONNECTOR_NAME_LEN 32
>> +#define DRM_DISPLAY_MODE_LEN 32
>> +#define DRM_PROP_NAME_LEN 32
>> +
>> +#define DRM_MODE_TYPE_BUILTIN (1<<0) /* deprecated */
>> +#define DRM_MODE_TYPE_CLOCK_C ((1<<1) | DRM_MODE_TYPE_BUILTIN) /*
>> deprecated */
>> +#define DRM_MODE_TYPE_CRTC_C ((1<<2) | DRM_MODE_TYPE_BUILTIN) /*
>> deprecated */
>> +#define DRM_MODE_TYPE_PREFERRED (1<<3)
>> +#define DRM_MODE_TYPE_DEFAULT (1<<4) /* deprecated */
>> +#define DRM_MODE_TYPE_USERDEF (1<<5)
>> +#define DRM_MODE_TYPE_DRIVER (1<<6)
>> +
>> +#define DRM_MODE_TYPE_ALL (DRM_MODE_TYPE_PREFERRED | \
>> + DRM_MODE_TYPE_USERDEF | \
>> + DRM_MODE_TYPE_DRIVER)
>> +
>> +/* Video mode flags */
>> +/* bit compatible with the xrandr RR_ definitions (bits 0-13)
>> + *
>> + * ABI warning: Existing userspace really expects
>> + * the mode flags to match the xrandr definitions. Any
>> + * changes that don't match the xrandr definitions will
>> + * likely need a new client cap or some other mechanism
>> + * to avoid breaking existing userspace. This includes
>> + * allocating new flags in the previously unused bits!
>> + */
>> +#define DRM_MODE_FLAG_PHSYNC (1<<0)
>> +#define DRM_MODE_FLAG_NHSYNC (1<<1)
>> +#define DRM_MODE_FLAG_PVSYNC (1<<2)
>> +#define DRM_MODE_FLAG_NVSYNC (1<<3)
>> +#define DRM_MODE_FLAG_INTERLACE (1<<4)
>> +#define DRM_MODE_FLAG_DBLSCAN (1<<5)
>> +#define DRM_MODE_FLAG_CSYNC (1<<6)
>> +#define DRM_MODE_FLAG_PCSYNC (1<<7)
>> +#define DRM_MODE_FLAG_NCSYNC (1<<8)
>> +#define DRM_MODE_FLAG_HSKEW (1<<9) /* hskew provided
>> */
>> +#define DRM_MODE_FLAG_BCAST (1<<10) /* deprecated */
>> +#define DRM_MODE_FLAG_PIXMUX (1<<11) /* deprecated */
>> +#define DRM_MODE_FLAG_DBLCLK (1<<12)
>> +#define DRM_MODE_FLAG_CLKDIV2 (1<<13)
>> + /*
>> + * When adding a new stereo mode don't forget to adjust
>> DRM_MODE_FLAGS_3D_MAX
>> + * (define not exposed to user space).
>> + */
>> +#define DRM_MODE_FLAG_3D_MASK (0x1f<<14)
>> +#define DRM_MODE_FLAG_3D_NONE (0<<14)
>> +#define DRM_MODE_FLAG_3D_FRAME_PACKING (1<<14)
>> +#define DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE (2<<14)
>> +#define DRM_MODE_FLAG_3D_LINE_ALTERNATIVE (3<<14)
>> +#define DRM_MODE_FLAG_3D_SIDE_BY_SIDE_FULL (4<<14)
>> +#define DRM_MODE_FLAG_3D_L_DEPTH (5<<14)
>> +#define DRM_MODE_FLAG_3D_L_DEPTH_GFX_GFX_DEPTH (6<<14)
>> +#define DRM_MODE_FLAG_3D_TOP_AND_BOTTOM (7<<14)
>> +#define DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF (8<<14)
>> +
>> +/* Picture aspect ratio options */
>> +#define DRM_MODE_PICTURE_ASPECT_NONE 0
>> +#define DRM_MODE_PICTURE_ASPECT_4_3 1
>> +#define DRM_MODE_PICTURE_ASPECT_16_9 2
>> +#define DRM_MODE_PICTURE_ASPECT_64_27 3
>> +#define DRM_MODE_PICTURE_ASPECT_256_135 4
>> +
>> +/* Content type options */
>> +#define DRM_MODE_CONTENT_TYPE_NO_DATA 0
>> +#define DRM_MODE_CONTENT_TYPE_GRAPHICS 1
>> +#define DRM_MODE_CONTENT_TYPE_PHOTO 2
>> +#define DRM_MODE_CONTENT_TYPE_CINEMA 3
>> +#define DRM_MODE_CONTENT_TYPE_GAME 4
>> +
>> +/* Aspect ratio flag bitmask (4 bits 22:19) */
>> +#define DRM_MODE_FLAG_PIC_AR_MASK (0x0F<<19)
>> +#define DRM_MODE_FLAG_PIC_AR_NONE \
>> + (DRM_MODE_PICTURE_ASPECT_NONE<<19)
>> +#define DRM_MODE_FLAG_PIC_AR_4_3 \
>> + (DRM_MODE_PICTURE_ASPECT_4_3<<19)
>> +#define DRM_MODE_FLAG_PIC_AR_16_9 \
>> + (DRM_MODE_PICTURE_ASPECT_16_9<<19)
>> +#define DRM_MODE_FLAG_PIC_AR_64_27 \
>> + (DRM_MODE_PICTURE_ASPECT_64_27<<19)
>> +#define DRM_MODE_FLAG_PIC_AR_256_135 \
>> + (DRM_MODE_PICTURE_ASPECT_256_135<<19)
>> +
>> +#define DRM_MODE_FLAG_ALL (DRM_MODE_FLAG_PHSYNC | \
>> + DRM_MODE_FLAG_NHSYNC | \
>> + DRM_MODE_FLAG_PVSYNC | \
>> + DRM_MODE_FLAG_NVSYNC | \
>> + DRM_MODE_FLAG_INTERLACE | \
>> + DRM_MODE_FLAG_DBLSCAN | \
>> + DRM_MODE_FLAG_CSYNC | \
>> + DRM_MODE_FLAG_PCSYNC | \
>> + DRM_MODE_FLAG_NCSYNC | \
>> + DRM_MODE_FLAG_HSKEW | \
>> + DRM_MODE_FLAG_DBLCLK | \
>> + DRM_MODE_FLAG_CLKDIV2 | \
>> + DRM_MODE_FLAG_3D_MASK)
>> +
>> +/* DPMS flags */
>> +/* bit compatible with the xorg definitions. */
>> +#define DRM_MODE_DPMS_ON 0
>> +#define DRM_MODE_DPMS_STANDBY 1
>> +#define DRM_MODE_DPMS_SUSPEND 2
>> +#define DRM_MODE_DPMS_OFF 3
>> +
>> +/* Scaling mode options */
>> +#define DRM_MODE_SCALE_NONE 0 /* Unmodified timing (display or
>> + software can still scale) */
>> +#define DRM_MODE_SCALE_FULLSCREEN 1 /* Full screen, ignore aspect */
>> +#define DRM_MODE_SCALE_CENTER 2 /* Centered, no scaling */
>> +#define DRM_MODE_SCALE_ASPECT 3 /* Full screen, preserve aspect
>> */
>> +
>> +/* Dithering mode options */
>> +#define DRM_MODE_DITHERING_OFF 0
>> +#define DRM_MODE_DITHERING_ON 1
>> +#define DRM_MODE_DITHERING_AUTO 2
>> +
>> +/* Dirty info options */
>> +#define DRM_MODE_DIRTY_OFF 0
>> +#define DRM_MODE_DIRTY_ON 1
>> +#define DRM_MODE_DIRTY_ANNOTATE 2
>> +
>> +/* Link Status options */
>> +#define DRM_MODE_LINK_STATUS_GOOD 0
>> +#define DRM_MODE_LINK_STATUS_BAD 1
>> +
>> +/*
>> + * DRM_MODE_ROTATE_<degrees>
>> + *
>> + * Signals that a drm plane is been rotated <degrees> degrees in counter
>> + * clockwise direction.
>> + *
>> + * This define is provided as a convenience, looking up the property id
>> + * using the name->prop id lookup is the preferred method.
>> + */
>> +#define DRM_MODE_ROTATE_0 (1<<0)
>> +#define DRM_MODE_ROTATE_90 (1<<1)
>> +#define DRM_MODE_ROTATE_180 (1<<2)
>> +#define DRM_MODE_ROTATE_270 (1<<3)
>> +
>> +/*
>> + * DRM_MODE_ROTATE_MASK
>> + *
>> + * Bitmask used to look for drm plane rotations.
>> + */
>> +#define DRM_MODE_ROTATE_MASK (\
>> + DRM_MODE_ROTATE_0 | \
>> + DRM_MODE_ROTATE_90 | \
>> + DRM_MODE_ROTATE_180 | \
>> + DRM_MODE_ROTATE_270)
>> +
>> +/*
>> + * DRM_MODE_REFLECT_<axis>
>> + *
>> + * Signals that the contents of a drm plane is reflected along the
>> <axis> axis,
>> + * in the same way as mirroring.
>> + * See kerneldoc chapter "Plane Composition Properties" for more details.
>> + *
>> + * This define is provided as a convenience, looking up the property id
>> + * using the name->prop id lookup is the preferred method.
>> + */
>> +#define DRM_MODE_REFLECT_X (1<<4)
>> +#define DRM_MODE_REFLECT_Y (1<<5)
>> +
>> +/*
>> + * DRM_MODE_REFLECT_MASK
>> + *
>> + * Bitmask used to look for drm plane reflections.
>> + */
>> +#define DRM_MODE_REFLECT_MASK (\
>> + DRM_MODE_REFLECT_X | \
>> + DRM_MODE_REFLECT_Y)
>> +
>> +/* Content Protection Flags */
>> +#define DRM_MODE_CONTENT_PROTECTION_UNDESIRED 0
>> +#define DRM_MODE_CONTENT_PROTECTION_DESIRED 1
>> +#define DRM_MODE_CONTENT_PROTECTION_ENABLED 2
>> +
>> +struct drm_mode_modeinfo {
>> + __u32 clock;
>> + __u16 hdisplay;
>> + __u16 hsync_start;
>> + __u16 hsync_end;
>> + __u16 htotal;
>> + __u16 hskew;
>> + __u16 vdisplay;
>> + __u16 vsync_start;
>> + __u16 vsync_end;
>> + __u16 vtotal;
>> + __u16 vscan;
>> +
>> + __u32 vrefresh;
>> +
>> + __u32 flags;
>> + __u32 type;
>> + char name[DRM_DISPLAY_MODE_LEN];
>> +};
>> +
>> +struct drm_mode_card_res {
>> + __u64 fb_id_ptr;
>> + __u64 crtc_id_ptr;
>> + __u64 connector_id_ptr;
>> + __u64 encoder_id_ptr;
>> + __u32 count_fbs;
>> + __u32 count_crtcs;
>> + __u32 count_connectors;
>> + __u32 count_encoders;
>> + __u32 min_width;
>> + __u32 max_width;
>> + __u32 min_height;
>> + __u32 max_height;
>> +};
>> +
>> +struct drm_mode_crtc {
>> + __u64 set_connectors_ptr;
>> + __u32 count_connectors;
>> +
>> + __u32 crtc_id; /**< Id */
>> + __u32 fb_id; /**< Id of framebuffer */
>> +
>> + __u32 x; /**< x Position on the framebuffer */
>> + __u32 y; /**< y Position on the framebuffer */
>> +
>> + __u32 gamma_size;
>> + __u32 mode_valid;
>> + struct drm_mode_modeinfo mode;
>> +};
>> +
>> +#define DRM_MODE_PRESENT_TOP_FIELD (1<<0)
>> +#define DRM_MODE_PRESENT_BOTTOM_FIELD (1<<1)
>> +
>> +/* Planes blend with or override other bits on the CRTC */
>> +struct drm_mode_set_plane {
>> + __u32 plane_id;
>> + __u32 crtc_id;
>> + __u32 fb_id; /* fb object contains surface format type */
>> + __u32 flags; /* see above flags */
>> +
>> + /* Signed dest location allows it to be partially off screen */
>> + __s32 crtc_x;
>> + __s32 crtc_y;
>> + __u32 crtc_w;
>> + __u32 crtc_h;
>> +
>> + /* Source values are 16.16 fixed point */
>> + __u32 src_x;
>> + __u32 src_y;
>> + __u32 src_h;
>> + __u32 src_w;
>> +};
>> +
>> +struct drm_mode_get_plane {
>> + __u32 plane_id;
>> +
>> + __u32 crtc_id;
>> + __u32 fb_id;
>> +
>> + __u32 possible_crtcs;
>> + __u32 gamma_size;
>> +
>> + __u32 count_format_types;
>> + __u64 format_type_ptr;
>> +};
>> +
>> +struct drm_mode_get_plane_res {
>> + __u64 plane_id_ptr;
>> + __u32 count_planes;
>> +};
>> +
>> +#define DRM_MODE_ENCODER_NONE 0
>> +#define DRM_MODE_ENCODER_DAC 1
>> +#define DRM_MODE_ENCODER_TMDS 2
>> +#define DRM_MODE_ENCODER_LVDS 3
>> +#define DRM_MODE_ENCODER_TVDAC 4
>> +#define DRM_MODE_ENCODER_VIRTUAL 5
>> +#define DRM_MODE_ENCODER_DSI 6
>> +#define DRM_MODE_ENCODER_DPMST 7
>> +#define DRM_MODE_ENCODER_DPI 8
>> +
>> +struct drm_mode_get_encoder {
>> + __u32 encoder_id;
>> + __u32 encoder_type;
>> +
>> + __u32 crtc_id; /**< Id of crtc */
>> +
>> + __u32 possible_crtcs;
>> + __u32 possible_clones;
>> +};
>> +
>> +/* This is for connectors with multiple signal types. */
>> +/* Try to match DRM_MODE_CONNECTOR_X as closely as possible. */
>> +enum drm_mode_subconnector {
>> + DRM_MODE_SUBCONNECTOR_Automatic = 0,
>> + DRM_MODE_SUBCONNECTOR_Unknown = 0,
>> + DRM_MODE_SUBCONNECTOR_DVID = 3,
>> + DRM_MODE_SUBCONNECTOR_DVIA = 4,
>> + DRM_MODE_SUBCONNECTOR_Composite = 5,
>> + DRM_MODE_SUBCONNECTOR_SVIDEO = 6,
>> + DRM_MODE_SUBCONNECTOR_Component = 8,
>> + DRM_MODE_SUBCONNECTOR_SCART = 9,
>> +};
>> +
>> +#define DRM_MODE_CONNECTOR_Unknown 0
>> +#define DRM_MODE_CONNECTOR_VGA 1
>> +#define DRM_MODE_CONNECTOR_DVII 2
>> +#define DRM_MODE_CONNECTOR_DVID 3
>> +#define DRM_MODE_CONNECTOR_DVIA 4
>> +#define DRM_MODE_CONNECTOR_Composite 5
>> +#define DRM_MODE_CONNECTOR_SVIDEO 6
>> +#define DRM_MODE_CONNECTOR_LVDS 7
>> +#define DRM_MODE_CONNECTOR_Component 8
>> +#define DRM_MODE_CONNECTOR_9PinDIN 9
>> +#define DRM_MODE_CONNECTOR_DisplayPort 10
>> +#define DRM_MODE_CONNECTOR_HDMIA 11
>> +#define DRM_MODE_CONNECTOR_HDMIB 12
>> +#define DRM_MODE_CONNECTOR_TV 13
>> +#define DRM_MODE_CONNECTOR_eDP 14
>> +#define DRM_MODE_CONNECTOR_VIRTUAL 15
>> +#define DRM_MODE_CONNECTOR_DSI 16
>> +#define DRM_MODE_CONNECTOR_DPI 17
>> +#define DRM_MODE_CONNECTOR_WRITEBACK 18
>> +
>> +struct drm_mode_get_connector {
>> +
>> + __u64 encoders_ptr;
>> + __u64 modes_ptr;
>> + __u64 props_ptr;
>> + __u64 prop_values_ptr;
>> +
>> + __u32 count_modes;
>> + __u32 count_props;
>> + __u32 count_encoders;
>> +
>> + __u32 encoder_id; /**< Current Encoder */
>> + __u32 connector_id; /**< Id */
>> + __u32 connector_type;
>> + __u32 connector_type_id;
>> +
>> + __u32 connection;
>> + __u32 mm_width; /**< width in millimeters */
>> + __u32 mm_height; /**< height in millimeters */
>> + __u32 subpixel;
>> +
>> + __u32 pad;
>> +};
>> +
>> +#define DRM_MODE_PROP_PENDING (1<<0) /* deprecated, do not use */
>> +#define DRM_MODE_PROP_RANGE (1<<1)
>> +#define DRM_MODE_PROP_IMMUTABLE (1<<2)
>> +#define DRM_MODE_PROP_ENUM (1<<3) /* enumerated type with text
>> strings */
>> +#define DRM_MODE_PROP_BLOB (1<<4)
>> +#define DRM_MODE_PROP_BITMASK (1<<5) /* bitmask of enumerated types */
>> +
>> +/* non-extended types: legacy bitmask, one bit per type: */
>> +#define DRM_MODE_PROP_LEGACY_TYPE ( \
>> + DRM_MODE_PROP_RANGE | \
>> + DRM_MODE_PROP_ENUM | \
>> + DRM_MODE_PROP_BLOB | \
>> + DRM_MODE_PROP_BITMASK)
>> +
>> +/* extended-types: rather than continue to consume a bit per type,
>> + * grab a chunk of the bits to use as integer type id.
>> + */
>> +#define DRM_MODE_PROP_EXTENDED_TYPE 0x0000ffc0
>> +#define DRM_MODE_PROP_TYPE(n) ((n) << 6)
>> +#define DRM_MODE_PROP_OBJECT DRM_MODE_PROP_TYPE(1)
>> +#define DRM_MODE_PROP_SIGNED_RANGE DRM_MODE_PROP_TYPE(2)
>> +
>> +/* the PROP_ATOMIC flag is used to hide properties from userspace that
>> + * is not aware of atomic properties. This is mostly to work around
>> + * older userspace (DDX drivers) that read/write each prop they find,
>> + * without being aware that this could be triggering a lengthy modeset.
>> + */
>> +#define DRM_MODE_PROP_ATOMIC 0x80000000
>> +
>> +struct drm_mode_property_enum {
>> + __u64 value;
>> + char name[DRM_PROP_NAME_LEN];
>> +};
>> +
>> +struct drm_mode_get_property {
>> + __u64 values_ptr; /* values and blob lengths */
>> + __u64 enum_blob_ptr; /* enum and blob id ptrs */
>> +
>> + __u32 prop_id;
>> + __u32 flags;
>> + char name[DRM_PROP_NAME_LEN];
>> +
>> + __u32 count_values;
>> + /* This is only used to count enum values, not blobs. The _blobs
>> is
>> + * simply because of a historical reason, i.e. backwards compat.
>> */
>> + __u32 count_enum_blobs;
>> +};
>> +
>> +struct drm_mode_connector_set_property {
>> + __u64 value;
>> + __u32 prop_id;
>> + __u32 connector_id;
>> +};
>> +
>> +#define DRM_MODE_OBJECT_CRTC 0xcccccccc
>> +#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
>> +#define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
>> +#define DRM_MODE_OBJECT_MODE 0xdededede
>> +#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
>> +#define DRM_MODE_OBJECT_FB 0xfbfbfbfb
>> +#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
>> +#define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
>> +#define DRM_MODE_OBJECT_ANY 0
>> +
>> +struct drm_mode_obj_get_properties {
>> + __u64 props_ptr;
>> + __u64 prop_values_ptr;
>> + __u32 count_props;
>> + __u32 obj_id;
>> + __u32 obj_type;
>> +};
>> +
>> +struct drm_mode_obj_set_property {
>> + __u64 value;
>> + __u32 prop_id;
>> + __u32 obj_id;
>> + __u32 obj_type;
>> +};
>> +
>> +struct drm_mode_get_blob {
>> + __u32 blob_id;
>> + __u32 length;
>> + __u64 data;
>> +};
>> +
>> +struct drm_mode_fb_cmd {
>> + __u32 fb_id;
>> + __u32 width;
>> + __u32 height;
>> + __u32 pitch;
>> + __u32 bpp;
>> + __u32 depth;
>> + /* driver specific handle */
>> + __u32 handle;
>> +};
>> +
>> +#define DRM_MODE_FB_INTERLACED (1<<0) /* for interlaced framebuffers */
>> +#define DRM_MODE_FB_MODIFIERS (1<<1) /* enables ->modifer[] */
>> +
>> +struct drm_mode_fb_cmd2 {
>> + __u32 fb_id;
>> + __u32 width;
>> + __u32 height;
>> + __u32 pixel_format; /* fourcc code from drm_fourcc.h */
>> + __u32 flags; /* see above flags */
>> +
>> + /*
>> + * In case of planar formats, this ioctl allows up to 4
>> + * buffer objects with offsets and pitches per plane.
>> + * The pitch and offset order is dictated by the fourcc,
>> + * e.g. NV12 (http://fourcc.org/yuv.php#NV12) is described as:
>> + *
>> + * YUV 4:2:0 image with a plane of 8 bit Y samples
>> + * followed by an interleaved U/V plane containing
>> + * 8 bit 2x2 subsampled colour difference samples.
>> + *
>> + * So it would consist of Y as offsets[0] and UV as
>> + * offsets[1]. Note that offsets[0] will generally
>> + * be 0 (but this is not required).
>> + *
>> + * To accommodate tiled, compressed, etc formats, a
>> + * modifier can be specified. The default value of zero
>> + * indicates "native" format as specified by the fourcc.
>> + * Vendor specific modifier token. Note that even though
>> + * it looks like we have a modifier per-plane, we in fact
>> + * do not. The modifier for each plane must be identical.
>> + * Thus all combinations of different data layouts for
>> + * multi plane formats must be enumerated as separate
>> + * modifiers.
>> + */
>> + __u32 handles[4];
>> + __u32 pitches[4]; /* pitch for each plane */
>> + __u32 offsets[4]; /* offset of each plane */
>> + __u64 modifier[4]; /* ie, tiling, compress */
>> +};
>> +
>> +#define DRM_MODE_FB_DIRTY_ANNOTATE_COPY 0x01
>> +#define DRM_MODE_FB_DIRTY_ANNOTATE_FILL 0x02
>> +#define DRM_MODE_FB_DIRTY_FLAGS 0x03
>> +
>> +#define DRM_MODE_FB_DIRTY_MAX_CLIPS 256
>> +
>> +/*
>> + * Mark a region of a framebuffer as dirty.
>> + *
>> + * Some hardware does not automatically update display contents
>> + * as a hardware or software draw to a framebuffer. This ioctl
>> + * allows userspace to tell the kernel and the hardware what
>> + * regions of the framebuffer have changed.
>> + *
>> + * The kernel or hardware is free to update more then just the
>> + * region specified by the clip rects. The kernel or hardware
>> + * may also delay and/or coalesce several calls to dirty into a
>> + * single update.
>> + *
>> + * Userspace may annotate the updates, the annotates are a
>> + * promise made by the caller that the change is either a copy
>> + * of pixels or a fill of a single color in the region specified.
>> + *
>> + * If the DRM_MODE_FB_DIRTY_ANNOTATE_COPY flag is given then
>> + * the number of updated regions are half of num_clips given,
>> + * where the clip rects are paired in src and dst. The width and
>> + * height of each one of the pairs must match.
>> + *
>> + * If the DRM_MODE_FB_DIRTY_ANNOTATE_FILL flag is given the caller
>> + * promises that the region specified of the clip rects is filled
>> + * completely with a single color as given in the color argument.
>> + */
>> +
>> +struct drm_mode_fb_dirty_cmd {
>> + __u32 fb_id;
>> + __u32 flags;
>> + __u32 color;
>> + __u32 num_clips;
>> + __u64 clips_ptr;
>> +};
>> +
>> +struct drm_mode_mode_cmd {
>> + __u32 connector_id;
>> + struct drm_mode_modeinfo mode;
>> +};
>> +
>> +#define DRM_MODE_CURSOR_BO 0x01
>> +#define DRM_MODE_CURSOR_MOVE 0x02
>> +#define DRM_MODE_CURSOR_FLAGS 0x03
>> +
>> +/*
>> + * depending on the value in flags different members are used.
>> + *
>> + * CURSOR_BO uses
>> + * crtc_id
>> + * width
>> + * height
>> + * handle - if 0 turns the cursor off
>> + *
>> + * CURSOR_MOVE uses
>> + * crtc_id
>> + * x
>> + * y
>> + */
>> +struct drm_mode_cursor {
>> + __u32 flags;
>> + __u32 crtc_id;
>> + __s32 x;
>> + __s32 y;
>> + __u32 width;
>> + __u32 height;
>> + /* driver specific handle */
>> + __u32 handle;
>> +};
>> +
>> +struct drm_mode_cursor2 {
>> + __u32 flags;
>> + __u32 crtc_id;
>> + __s32 x;
>> + __s32 y;
>> + __u32 width;
>> + __u32 height;
>> + /* driver specific handle */
>> + __u32 handle;
>> + __s32 hot_x;
>> + __s32 hot_y;
>> +};
>> +
>> +struct drm_mode_crtc_lut {
>> + __u32 crtc_id;
>> + __u32 gamma_size;
>> +
>> + /* pointers to arrays */
>> + __u64 red;
>> + __u64 green;
>> + __u64 blue;
>> +};
>> +
>> +struct drm_color_ctm {
>> + /*
>> + * Conversion matrix in S31.32 sign-magnitude
>> + * (not two's complement!) format.
>> + */
>> + __u64 matrix[9];
>> +};
>> +
>> +struct drm_color_lut {
>> + /*
>> + * Values are mapped linearly to 0.0 - 1.0 range, with 0x0 == 0.0
>> and
>> + * 0xffff == 1.0.
>> + */
>> + __u16 red;
>> + __u16 green;
>> + __u16 blue;
>> + __u16 reserved;
>> +};
>> +
>> +#define DRM_MODE_PAGE_FLIP_EVENT 0x01
>> +#define DRM_MODE_PAGE_FLIP_ASYNC 0x02
>> +#define DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE 0x4
>> +#define DRM_MODE_PAGE_FLIP_TARGET_RELATIVE 0x8
>> +#define DRM_MODE_PAGE_FLIP_TARGET (DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE | \
>> + DRM_MODE_PAGE_FLIP_TARGET_RELATIVE)
>> +#define DRM_MODE_PAGE_FLIP_FLAGS (DRM_MODE_PAGE_FLIP_EVENT | \
>> + DRM_MODE_PAGE_FLIP_ASYNC | \
>> + DRM_MODE_PAGE_FLIP_TARGET)
>> +
>> +/*
>> + * Request a page flip on the specified crtc.
>> + *
>> + * This ioctl will ask KMS to schedule a page flip for the specified
>> + * crtc. Once any pending rendering targeting the specified fb (as of
>> + * ioctl time) has completed, the crtc will be reprogrammed to display
>> + * that fb after the next vertical refresh. The ioctl returns
>> + * immediately, but subsequent rendering to the current fb will block
>> + * in the execbuffer ioctl until the page flip happens. If a page
>> + * flip is already pending as the ioctl is called, EBUSY will be
>> + * returned.
>> + *
>> + * Flag DRM_MODE_PAGE_FLIP_EVENT requests that drm sends back a vblank
>> + * event (see drm.h: struct drm_event_vblank) when the page flip is
>> + * done. The user_data field passed in with this ioctl will be
>> + * returned as the user_data field in the vblank event struct.
>> + *
>> + * Flag DRM_MODE_PAGE_FLIP_ASYNC requests that the flip happen
>> + * 'as soon as possible', meaning that it not delay waiting for vblank.
>> + * This may cause tearing on the screen.
>> + *
>> + * The reserved field must be zero.
>> + */
>> +
>> +struct drm_mode_crtc_page_flip {
>> + __u32 crtc_id;
>> + __u32 fb_id;
>> + __u32 flags;
>> + __u32 reserved;
>> + __u64 user_data;
>> +};
>> +
>> +/*
>> + * Request a page flip on the specified crtc.
>> + *
>> + * Same as struct drm_mode_crtc_page_flip, but supports new flags and
>> + * re-purposes the reserved field:
>> + *
>> + * The sequence field must be zero unless either of the
>> + * DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE/RELATIVE flags is specified. When
>> + * the ABSOLUTE flag is specified, the sequence field denotes the
>> absolute
>> + * vblank sequence when the flip should take effect. When the RELATIVE
>> + * flag is specified, the sequence field denotes the relative (to the
>> + * current one when the ioctl is called) vblank sequence when the flip
>> + * should take effect. NOTE: DRM_IOCTL_WAIT_VBLANK must still be used to
>> + * make sure the vblank sequence before the target one has passed before
>> + * calling this ioctl. The purpose of the
>> + * DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE/RELATIVE flags is merely to clarify
>> + * the target for when code dealing with a page flip runs during a
>> + * vertical blank period.
>> + */
>> +
>> +struct drm_mode_crtc_page_flip_target {
>> + __u32 crtc_id;
>> + __u32 fb_id;
>> + __u32 flags;
>> + __u32 sequence;
>> + __u64 user_data;
>> +};
>> +
>> +/* create a dumb scanout buffer */
>> +struct drm_mode_create_dumb {
>> + __u32 height;
>> + __u32 width;
>> + __u32 bpp;
>> + __u32 flags;
>> + /* handle, pitch, size will be returned */
>> + __u32 handle;
>> + __u32 pitch;
>> + __u64 size;
>> +};
>> +
>> +/* set up for mmap of a dumb scanout buffer */
>> +struct drm_mode_map_dumb {
>> + /** Handle for the object being mapped. */
>> + __u32 handle;
>> + __u32 pad;
>> + /**
>> + * Fake offset to use for subsequent mmap call
>> + *
>> + * This is a fixed-size type for 32/64 compatibility.
>> + */
>> + __u64 offset;
>> +};
>> +
>> +struct drm_mode_destroy_dumb {
>> + __u32 handle;
>> +};
>> +
>> +/* page-flip flags are valid, plus: */
>> +#define DRM_MODE_ATOMIC_TEST_ONLY 0x0100
>> +#define DRM_MODE_ATOMIC_NONBLOCK 0x0200
>> +#define DRM_MODE_ATOMIC_ALLOW_MODESET 0x0400
>> +
>> +#define DRM_MODE_ATOMIC_FLAGS (\
>> + DRM_MODE_PAGE_FLIP_EVENT |\
>> + DRM_MODE_PAGE_FLIP_ASYNC |\
>> + DRM_MODE_ATOMIC_TEST_ONLY |\
>> + DRM_MODE_ATOMIC_NONBLOCK |\
>> + DRM_MODE_ATOMIC_ALLOW_MODESET)
>> +
>> +struct drm_mode_atomic {
>> + __u32 flags;
>> + __u32 count_objs;
>> + __u64 objs_ptr;
>> + __u64 count_props_ptr;
>> + __u64 props_ptr;
>> + __u64 prop_values_ptr;
>> + __u64 reserved;
>> + __u64 user_data;
>> +};
>> +
>> +struct drm_format_modifier_blob {
>> +#define FORMAT_BLOB_CURRENT 1
>> + /* Version of this blob format */
>> + __u32 version;
>> +
>> + /* Flags */
>> + __u32 flags;
>> +
>> + /* Number of fourcc formats supported */
>> + __u32 count_formats;
>> +
>> + /* Where in this blob the formats exist (in bytes) */
>> + __u32 formats_offset;
>> +
>> + /* Number of drm_format_modifiers */
>> + __u32 count_modifiers;
>> +
>> + /* Where in this blob the modifiers exist (in bytes) */
>> + __u32 modifiers_offset;
>> +
>> + /* __u32 formats[] */
>> + /* struct drm_format_modifier modifiers[] */
>> +};
>> +
>> +struct drm_format_modifier {
>> + /* Bitmask of formats in get_plane format list this info applies
>> to. The
>> + * offset allows a sliding window of which 64 formats (bits).
>> + *
>> + * Some examples:
>> + * In today's world with < 65 formats, and formats 0, and 2 are
>> + * supported
>> + * 0x0000000000000005
>> + * ^-offset = 0, formats = 5
>> + *
>> + * If the number formats grew to 128, and formats 98-102 are
>> + * supported with the modifier:
>> + *
>> + * 0x0000007c00000000 0000000000000000
>> + * ^
>> + * |__offset = 64, formats = 0x7c00000000
>> + *
>> + */
>> + __u64 formats;
>> + __u32 offset;
>> + __u32 pad;
>> +
>> + /* The modifier that applies to the >get_plane format list
>> bitmask. */
>> + __u64 modifier;
>> +};
>> +
>> +/**
>> + * Create a new 'blob' data property, copying length bytes from data
>> pointer,
>> + * and returning new blob ID.
>> + */
>> +struct drm_mode_create_blob {
>> + /** Pointer to data to copy. */
>> + __u64 data;
>> + /** Length of data to copy. */
>> + __u32 length;
>> + /** Return: new property ID. */
>> + __u32 blob_id;
>> +};
>> +
>> +/**
>> + * Destroy a user-created blob property.
>> + */
>> +struct drm_mode_destroy_blob {
>> + __u32 blob_id;
>> +};
>> +
>> +/**
>> + * Lease mode resources, creating another drm_master.
>> + */
>> +struct drm_mode_create_lease {
>> + /** Pointer to array of object ids (__u32) */
>> + __u64 object_ids;
>> + /** Number of object ids */
>> + __u32 object_count;
>> + /** flags for new FD (O_CLOEXEC, etc) */
>> + __u32 flags;
>> +
>> + /** Return: unique identifier for lessee. */
>> + __u32 lessee_id;
>> + /** Return: file descriptor to new drm_master file */
>> + __u32 fd;
>> +};
>> +
>> +/**
>> + * List lesses from a drm_master
>> + */
>> +struct drm_mode_list_lessees {
>> + /** Number of lessees.
>> + * On input, provides length of the array.
>> + * On output, provides total number. No
>> + * more than the input number will be written
>> + * back, so two calls can be used to get
>> + * the size and then the data.
>> + */
>> + __u32 count_lessees;
>> + __u32 pad;
>> +
>> + /** Pointer to lessees.
>> + * pointer to __u64 array of lessee ids
>> + */
>> + __u64 lessees_ptr;
>> +};
>> +
>> +/**
>> + * Get leased objects
>> + */
>> +struct drm_mode_get_lease {
>> + /** Number of leased objects.
>> + * On input, provides length of the array.
>> + * On output, provides total number. No
>> + * more than the input number will be written
>> + * back, so two calls can be used to get
>> + * the size and then the data.
>> + */
>> + __u32 count_objects;
>> + __u32 pad;
>> +
>> + /** Pointer to objects.
>> + * pointer to __u32 array of object ids
>> + */
>> + __u64 objects_ptr;
>> +};
>> +
>> +/**
>> + * Revoke lease
>> + */
>> +struct drm_mode_revoke_lease {
>> + /** Unique ID of lessee
>> + */
>> + __u32 lessee_id;
>> +};
>> +
>> +/**
>> + * struct drm_mode_rect - Two dimensional rectangle.
>> + * @x1: Horizontal starting coordinate (inclusive).
>> + * @y1: Vertical starting coordinate (inclusive).
>> + * @x2: Horizontal ending coordinate (exclusive).
>> + * @y2: Vertical ending coordinate (exclusive).
>> + *
>> + * With drm subsystem using struct drm_rect to manage rectangular area
>> this
>> + * export it to user-space.
>> + *
>> + * Currently used by drm_mode_atomic blob property FB_DAMAGE_CLIPS.
>> + */
>> +struct drm_mode_rect {
>> + __s32 x1;
>> + __s32 y1;
>> + __s32 x2;
>> + __s32 y2;
>> +};
>> +
>> +#if defined(__cplusplus)
>> +}
>> +#endif
>> +
>> +#endif
>> diff --git a/print_fields.h b/print_fields.h
>> index 677b5f6c..12c32a72 100644
>> --- a/print_fields.h
>> +++ b/print_fields.h
>> @@ -25,6 +25,9 @@
>> STRACE_PRINTF("%s%s=%llu", (prefix_), #field_, \
>> zero_extend_signed_to_ull((where_).field_))
>>
>> +# define PRINT_FIELD_DRM_CRTC_ID(prefix_, where_, field_) \
>> + PRINT_FIELD_U(prefix_, where_, field_)
>> +
>> # define PRINT_FIELD_U_CAST(prefix_, where_, field_, type_) \
>> STRACE_PRINTF("%s%s=%llu", (prefix_), #field_, \
>> zero_extend_signed_to_ull((type_) (where_).field_))
>> diff --git a/util.c b/util.c
>> index ec86cdb9..2b85fafa 100644
>> --- a/util.c
>> +++ b/util.c
>> @@ -1248,6 +1248,15 @@ umoven_or_printaddr64_ignore_syserror(struct tcb
>> *const tcp,
>> return -1;
>> }
>>
>> +bool
>> +print_uint16_array_member(struct tcb *tcp, void *elem_buf, size_t
>> elem_size,
>> + void *data)
>> +{
>> + tprintf("%" PRIu16, *(uint16_t*) elem_buf);
>> +
>> + return true;
>> +}
>> +
>> bool
>> print_int32_array_member(struct tcb *tcp, void *elem_buf, size_t
>> elem_size,
>> void *data)
>> diff --git a/xlat/drm_buf_desc_flags.in b/xlat/drm_buf_desc_flags.in
>> new file mode 100644
>> index 00000000..79667094
>> --- /dev/null
>> +++ b/xlat/drm_buf_desc_flags.in
>> @@ -0,0 +1,6 @@
>> +#sorted
>> +_DRM_PAGE_ALIGN 0x01
>> +_DRM_AGP_BUFFER 0x02
>> +_DRM_SG_BUFFER 0x04
>> +_DRM_FB_BUFFER 0x08
>> +_DRM_PCI_BUFFER_RO 0x10
>> diff --git a/xlat/drm_capability.in b/xlat/drm_capability.in
>> new file mode 100644
>> index 00000000..383b2535
>> --- /dev/null
>> +++ b/xlat/drm_capability.in
>> @@ -0,0 +1,15 @@
>> +#value_indexed
>> +DRM_CAP_DUMB_BUFFER 0x1
>> +DRM_CAP_VBLANK_HIGH_CRTC 0x2
>> +DRM_CAP_DUMB_PREFERRED_DEPTH 0x3
>> +DRM_CAP_DUMB_PREFER_SHADOW 0x4
>> +DRM_CAP_PRIME 0x5
>> +DRM_CAP_TIMESTAMP_MONOTONIC 0x6
>> +DRM_CAP_ASYNC_PAGE_FLIP 0x7
>> +DRM_CAP_CURSOR_WIDTH 0x8
>> +DRM_CAP_CURSOR_HEIGHT 0x9
>> +DRM_CAP_ADDFB2_MODIFIERS 0x10
>> +DRM_CAP_PAGE_FLIP_TARGET 0x11
>> +DRM_CAP_CRTC_IN_VBLANK_EVENT 0x12
>> +DRM_CAP_SYNCOBJ 0x13
>> +DRM_CAP_SYNCOBJ_TIMELINE 0x14
>> diff --git a/xlat/drm_client_capability.in b/xlat/
>> drm_client_capability.in
>> new file mode 100644
>> index 00000000..efbf1283
>> --- /dev/null
>> +++ b/xlat/drm_client_capability.in
>> @@ -0,0 +1,6 @@
>> +#value_indexed
>> +DRM_CLIENT_CAP_STEREO_3D 1
>> +DRM_CLIENT_CAP_UNIVERSAL_PLANES 2
>> +DRM_CLIENT_CAP_ATOMIC 3
>> +DRM_CLIENT_CAP_ASPECT_RATIO 4
>> +DRM_CLIENT_CAP_WRITEBACK_CONNECTORS 5
>> diff --git a/xlat/drm_control_func.in b/xlat/drm_control_func.in
>> new file mode 100644
>> index 00000000..1942c92d
>> --- /dev/null
>> +++ b/xlat/drm_control_func.in
>> @@ -0,0 +1,5 @@
>> +#value_indexed
>> +DRM_ADD_COMMAND 0
>> +DRM_RM_COMMAND 1
>> +DRM_INST_HANDLER 2
>> +DRM_UNINST_HANDLER 3
>> diff --git a/xlat/drm_crtc_sequence_flags.in b/xlat/
>> drm_crtc_sequence_flags.in
>> new file mode 100644
>> index 00000000..e444bca2
>> --- /dev/null
>> +++ b/xlat/drm_crtc_sequence_flags.in
>> @@ -0,0 +1,3 @@
>> +#sorted
>> +DRM_CRTC_SEQUENCE_RELATIVE 0x00000001
>> +DRM_CRTC_SEQUENCE_NEXT_ON_MISS 0x00000002
>> diff --git a/xlat/drm_ctx_flags.in b/xlat/drm_ctx_flags.in
>> new file mode 100644
>> index 00000000..c07a2524
>> --- /dev/null
>> +++ b/xlat/drm_ctx_flags.in
>> @@ -0,0 +1,3 @@
>> +#sorted
>> +_DRM_CONTEXT_PRESERVED 0x01
>> +_DRM_CONTEXT_2DONLY 0x02
>> diff --git a/xlat/drm_lock_flags.in b/xlat/drm_lock_flags.in
>> new file mode 100644
>> index 00000000..4ae983fa
>> --- /dev/null
>> +++ b/xlat/drm_lock_flags.in
>> @@ -0,0 +1,7 @@
>> +#sorted
>> +_DRM_LOCK_READY 0x01
>> +_DRM_LOCK_QUIESCENT 0x02
>> +_DRM_LOCK_FLUSH 0x04
>> +_DRM_LOCK_FLUSH_ALL 0x08
>> +_DRM_HALT_ALL_QUEUES 0x10
>> +_DRM_HALT_CUR_QUEUES 0x20
>> diff --git a/xlat/drm_map_flags.in b/xlat/drm_map_flags.in
>> new file mode 100644
>> index 00000000..4fed3ca1
>> --- /dev/null
>> +++ b/xlat/drm_map_flags.in
>> @@ -0,0 +1,9 @@
>> +#sorted
>> +_DRM_RESTRICTED 0x01
>> +_DRM_READ_ONLY 0x02
>> +_DRM_LOCKED 0x04
>> +_DRM_KERNEL 0x08
>> +_DRM_WRITE_COMBINING 0x10
>> +_DRM_CONTAINS_LOCK 0x20
>> +_DRM_REMOVABLE 0x40
>> +_DRM_DRIVER 0x80
>> diff --git a/xlat/drm_map_type.in b/xlat/drm_map_type.in
>> new file mode 100644
>> index 00000000..cc84306e
>> --- /dev/null
>> +++ b/xlat/drm_map_type.in
>> @@ -0,0 +1,7 @@
>> +#value_indexed
>> +_DRM_FRAME_BUFFER 0
>> +_DRM_REGISTERS 1
>> +_DRM_SHM 2
>> +_DRM_AGP 3
>> +_DRM_SCATTER_GATHER 4
>> +_DRM_CONSISTENT 5
>> diff --git a/xlat/drm_mode_atomic_flags.in b/xlat/
>> drm_mode_atomic_flags.in
>> new file mode 100644
>> index 00000000..665eed42
>> --- /dev/null
>> +++ b/xlat/drm_mode_atomic_flags.in
>> @@ -0,0 +1,6 @@
>> +#sorted
>> +DRM_MODE_PAGE_FLIP_EVENT 0x1
>> +DRM_MODE_PAGE_FLIP_ASYNC 0x2
>> +DRM_MODE_ATOMIC_TEST_ONLY 0x100
>> +DRM_MODE_ATOMIC_NONBLOCK 0x200
>> +DRM_MODE_ATOMIC_ALLOW_MODESET 0x400
>> diff --git a/xlat/drm_mode_create_lease_flags.in b/xlat/
>> drm_mode_create_lease_flags.in
>> new file mode 100644
>> index 00000000..231c4a72
>> --- /dev/null
>> +++ b/xlat/drm_mode_create_lease_flags.in
>> @@ -0,0 +1,2 @@
>> +O_CLOEXEC
>> +O_NONBLOCK
>> diff --git a/xlat/drm_mode_cursor_flags.in b/xlat/
>> drm_mode_cursor_flags.in
>> new file mode 100644
>> index 00000000..a703d383
>> --- /dev/null
>> +++ b/xlat/drm_mode_cursor_flags.in
>> @@ -0,0 +1,3 @@
>> +#sorted
>> +DRM_MODE_CURSOR_BO 0x01
>> +DRM_MODE_CURSOR_MOVE 0x02
>> diff --git a/xlat/drm_mode_encoder_type.in b/xlat/
>> drm_mode_encoder_type.in
>> new file mode 100644
>> index 00000000..58435446
>> --- /dev/null
>> +++ b/xlat/drm_mode_encoder_type.in
>> @@ -0,0 +1,10 @@
>> +#value_indexed
>> +DRM_MODE_ENCODER_NONE 0
>> +DRM_MODE_ENCODER_DAC 1
>> +DRM_MODE_ENCODER_TMDS 2
>> +DRM_MODE_ENCODER_LVDS 3
>> +DRM_MODE_ENCODER_TVDAC 4
>> +DRM_MODE_ENCODER_VIRTUAL 5
>> +DRM_MODE_ENCODER_DSI 6
>> +DRM_MODE_ENCODER_DPMST 7
>> +DRM_MODE_ENCODER_DPI 8
>> diff --git a/xlat/drm_mode_fb_cmd2_flags.in b/xlat/
>> drm_mode_fb_cmd2_flags.in
>> new file mode 100644
>> index 00000000..d0f30f59
>> --- /dev/null
>> +++ b/xlat/drm_mode_fb_cmd2_flags.in
>> @@ -0,0 +1,3 @@
>> +#sorted
>> +DRM_MODE_FB_INTERLACED (1<<0)
>> +DRM_MODE_FB_MODIFIERS (1<<1)
>> diff --git a/xlat/drm_mode_fb_dirty_cmd_flags.in b/xlat/
>> drm_mode_fb_dirty_cmd_flags.in
>> new file mode 100644
>> index 00000000..7b1585f3
>> --- /dev/null
>> +++ b/xlat/drm_mode_fb_dirty_cmd_flags.in
>> @@ -0,0 +1,3 @@
>> +#sorted
>> +DRM_MODE_FB_DIRTY_ANNOTATE_COPY 0x01
>> +DRM_MODE_FB_DIRTY_ANNOTATE_FILL 0x02
>> diff --git a/xlat/drm_mode_flags.in b/xlat/drm_mode_flags.in
>> new file mode 100644
>> index 00000000..c4c55749
>> --- /dev/null
>> +++ b/xlat/drm_mode_flags.in
>> @@ -0,0 +1,6 @@
>> +#sorted
>> +DRM_MODE_FLAG_PIC_AR_NONE (0 << 19)
>> +DRM_MODE_FLAG_PIC_AR_4_3 (1 << 19)
>> +DRM_MODE_FLAG_PIC_AR_16_9 (2 << 19)
>> +DRM_MODE_FLAG_PIC_AR_64_27 (3 << 19)
>> +DRM_MODE_FLAG_PIC_AR_256_135 (4 << 19)
>> diff --git a/xlat/drm_mode_get_property_flags.in b/xlat/
>> drm_mode_get_property_flags.in
>> new file mode 100644
>> index 00000000..f9e13889
>> --- /dev/null
>> +++ b/xlat/drm_mode_get_property_flags.in
>> @@ -0,0 +1,9 @@
>> +#sorted
>> +DRM_MODE_PROP_PENDING (1<<0)
>> +DRM_MODE_PROP_RANGE (1<<1)
>> +DRM_MODE_PROP_IMMUTABLE (1<<2)
>> +DRM_MODE_PROP_ENUM (1<<3)
>> +DRM_MODE_PROP_BLOB (1<<4)
>> +DRM_MODE_PROP_BITMASK (1<<5)
>> +DRM_MODE_PROP_EXTENDED_TYPE 0x0000ffc0
>> +DRM_MODE_PROP_ATOMIC 0x80000000
>> diff --git a/xlat/drm_mode_page_flip_flags.in b/xlat/
>> drm_mode_page_flip_flags.in
>> new file mode 100644
>> index 00000000..da3fec1c
>> --- /dev/null
>> +++ b/xlat/drm_mode_page_flip_flags.in
>> @@ -0,0 +1,5 @@
>> +DRM_MODE_PAGE_FLIP_EVENT 0x01
>> +DRM_MODE_PAGE_FLIP_ASYNC 0x02
>> +DRM_MODE_PAGE_FLIP_TARGET
>> (DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE | DRM_MODE_PAGE_FLIP_TARGET_RELATIVE)
>> +DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE 0x04
>> +DRM_MODE_PAGE_FLIP_TARGET_RELATIVE 0x08
>> diff --git a/xlat/drm_mode_set_plane_flags.in b/xlat/
>> drm_mode_set_plane_flags.in
>> new file mode 100644
>> index 00000000..d5128547
>> --- /dev/null
>> +++ b/xlat/drm_mode_set_plane_flags.in
>> @@ -0,0 +1,3 @@
>> +#sorted
>> +DRM_MODE_PRESENT_TOP_FIELD (1<<0)
>> +DRM_MODE_PRESENT_BOTTOM_FIELD (1<<1)
>> diff --git a/xlat/drm_mode_type.in b/xlat/drm_mode_type.in
>> new file mode 100644
>> index 00000000..74a29678
>> --- /dev/null
>> +++ b/xlat/drm_mode_type.in
>> @@ -0,0 +1,8 @@
>> +#sorted
>> +DRM_MODE_TYPE_BUILTIN (1 << 0)
>> +DRM_MODE_TYPE_CLOCK_C (1 << 1 | DRM_MODE_TYPE_BUILTIN)
>> +DRM_MODE_TYPE_CRTC_C (1 << 2 | DRM_MODE_TYPE_BUILTIN)
>> +DRM_MODE_TYPE_PREFERRED (1 << 3)
>> +DRM_MODE_TYPE_DEFAULT (1 << 4)
>> +DRM_MODE_TYPE_USERDEF (1 << 5)
>> +DRM_MODE_TYPE_DRIVER (1 << 6)
>> diff --git a/xlat/drm_modeset_cmd.in b/xlat/drm_modeset_cmd.in
>> new file mode 100644
>> index 00000000..2152f3da
>> --- /dev/null
>> +++ b/xlat/drm_modeset_cmd.in
>> @@ -0,0 +1,3 @@
>> +#value_indexed
>> +_DRM_PRE_MODESET 1
>> +_DRM_POST_MODESET 2
>> diff --git a/xlat/drm_prime_handle_flags.in b/xlat/
>> drm_prime_handle_flags.in
>> new file mode 100644
>> index 00000000..5ace5a54
>> --- /dev/null
>> +++ b/xlat/drm_prime_handle_flags.in
>> @@ -0,0 +1,2 @@
>> +DRM_RDWR
>> +DRM_CLOEXEC
>> diff --git a/xlat/drm_syncobj_fd_to_handle_flags.in b/xlat/
>> drm_syncobj_fd_to_handle_flags.in
>> new file mode 100644
>> index 00000000..838e6d81
>> --- /dev/null
>> +++ b/xlat/drm_syncobj_fd_to_handle_flags.in
>> @@ -0,0 +1,2 @@
>> +#sorted
>> +DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE
>> diff --git a/xlat/drm_syncobj_flags.in b/xlat/drm_syncobj_flags.in
>> new file mode 100644
>> index 00000000..8817528b
>> --- /dev/null
>> +++ b/xlat/drm_syncobj_flags.in
>> @@ -0,0 +1,2 @@
>> +#sorted
>> +DRM_SYNCOBJ_CREATE_SIGNALED (1 << 0)
>> diff --git a/xlat/drm_syncobj_handle_to_fd_flags.in b/xlat/
>> drm_syncobj_handle_to_fd_flags.in
>> new file mode 100644
>> index 00000000..5968102a
>> --- /dev/null
>> +++ b/xlat/drm_syncobj_handle_to_fd_flags.in
>> @@ -0,0 +1 @@
>> +DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE
>> diff --git a/xlat/drm_syncobj_wait_flags.in b/xlat/
>> drm_syncobj_wait_flags.in
>> new file mode 100644
>> index 00000000..d576b51f
>> --- /dev/null
>> +++ b/xlat/drm_syncobj_wait_flags.in
>> @@ -0,0 +1,4 @@
>> +#sorted
>> +DRM_SYNCOBJ_WAIT_FLAGS_WAIT_ALL (1 << 0)
>> +DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT (1 << 1)
>> +DRM_SYNCOBJ_WAIT_FLAGS_WAIT_AVAILABLE (1 << 2)
>> diff --git a/xlat/drm_vblank_seq_type.in b/xlat/drm_vblank_seq_type.in
>> new file mode 100644
>> index 00000000..97e3043a
>> --- /dev/null
>> +++ b/xlat/drm_vblank_seq_type.in
>> @@ -0,0 +1,3 @@
>> +#sorted
>> +_DRM_VBLANK_ABSOLUTE 0x0
>> +_DRM_VBLANK_RELATIVE 0x1
>> diff --git a/xlat/drm_vblank_seq_type_flags.in b/xlat/
>> drm_vblank_seq_type_flags.in
>> new file mode 100644
>> index 00000000..be9e2e4f
>> --- /dev/null
>> +++ b/xlat/drm_vblank_seq_type_flags.in
>> @@ -0,0 +1,6 @@
>> +#sorted
>> +_DRM_VBLANK_EVENT 0x4000000
>> +_DRM_VBLANK_FLIP 0x8000000
>> +_DRM_VBLANK_NEXTONMISS 0x10000000
>> +_DRM_VBLANK_SECONDARY 0x20000000
>> +_DRM_VBLANK_SIGNAL 0x40000000
>> --
>> 2.20.1
>>
>>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.strace.io/pipermail/strace-devel/attachments/20190827/72bd4ce8/attachment.html>
More information about the Strace-devel
mailing list