|
From: Ross M. <ros...@ie...> - 2020-04-27 18:05:01
|
Hi Philippe,
This is pro bono work on my end. Possibly yours also? Use the patch or
lose the patch, as you wish.
I'll keep your preference in mind for the future.
Ross
On Mon, Apr 27, 2020, 9:03 AM Philippe Waroquiers <
phi...@sk...> wrote:
> Hello Ross,
>
> Thanks for the patch.
> Patches have somewhat a trend to be lost when (only) sent to a mailing
> list.
> The best is to file a bug in the valgrind bugzilla and attach the patch.
>
> Thanks
>
> Philippe
>
> On Sun, 2020-04-26 at 14:03 -0700, Ross Martin wrote:
> > I use valgrind quite a bit; unfortunately it didn’t support some of the
> ioctl’s I’m using for my current project. Here’s the patch.
> >
> >
> > diff -ruw valgrind-3.15.0-orig/config.h valgrind-3.15.0/config.h
> > --- valgrind-3.15.0-orig/config.h 2019-04-13 03:57:38.000000000 -0700
> > +++ valgrind-3.15.0/config.h 2020-04-24 19:05:10.315888225 -0700
> > @@ -60,7 +60,7 @@
> > #define HAVE_ASM_UNISTD_H 1
> >
> > /* Define to 1 if as supports fxsave64/fxrstor64. */
> > -#define HAVE_AS_AMD64_FXSAVE64 1
> > +/* #undef HAVE_AS_AMD64_FXSAVE64 */
> >
> > /* Define to 1 if as supports floating point phased out category. */
> > /* #undef HAVE_AS_PPC_FPPO */
> > @@ -216,7 +216,7 @@
> > #define HAVE_PTHREAD_YIELD 1
> >
> > /* Define to 1 if you have the `PTRACE_GETREGS' ptrace request. */
> > -#define HAVE_PTRACE_GETREGS 1
> > +/* #undef HAVE_PTRACE_GETREGS */
> >
> > /* Define to 1 if you have the `readlinkat' function. */
> > #define HAVE_READLINKAT 1
> > diff -ruw valgrind-3.15.0-orig/coregrind/m_syswrap/syswrap-linux.c
> valgrind-3.15.0/coregrind/m_syswrap/syswrap-linux.c
> > --- valgrind-3.15.0-orig/coregrind/m_syswrap/syswrap-linux.c 2019-04-13
> 03:56:21.000000000 -0700
> > +++ valgrind-3.15.0/coregrind/m_syswrap/syswrap-linux.c 2020-04-26
> 13:36:42.197565742 -0700
> > @@ -8036,6 +8036,165 @@
> > PRE_MEM_WRITE("ioctl(DRM_GEM_OPEN).size", (Addr)&data->size,
> sizeof(data->size));
> > }
> > break;
> > + case VKI_DRM_IOCTL_SET_MASTER:
> > + PRINT("ioctl(DRM_MODE_SET_MASTER)\n");
> > + break;
> > + case VKI_DRM_IOCTL_DROP_MASTER:
> > + PRINT("ioctl(DRM_MODE_DROP_MASTER)\n");
> > + break;
> > + case VKI_DRM_IOCTL_MODE_PAGE_FLIP:
> > + if (ARG3) {
> > + struct vki_drm_mode_crtc_page_flip* data = (struct
> vki_drm_mode_crtc_page_flip*)(Addr)ARG3;
> > + PRINT("ioctl(DRM_MODE_PAGE_FLIP)\n");
> > + PRE_MEM_READ("ioctl(DRM_MODE_PAGE_FLIP).crtc_id",
> (Addr)&data->crtc_id, sizeof(data->crtc_id));
> > + PRE_MEM_READ("ioctl(DRM_MODE_PAGE_FLIP).fb_id",
> (Addr)&data->fb_id, sizeof(data->fb_id));
> > + PRE_MEM_READ("ioctl(DRM_MODE_PAGE_FLIP).flags",
> (Addr)&data->flags, sizeof(data->flags));
> > + PRE_MEM_READ("ioctl(DRM_MODE_PAGE_FLIP).reserved",
> (Addr)&data->reserved, sizeof(data->reserved));
> > + PRE_MEM_READ("ioctl(DRM_MODE_PAGE_FLIP).user_data",
> (Addr)&data->user_data, sizeof(data->user_data));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_ADDFB:
> > + if (ARG3) {
> > + struct vki_drm_mode_fb_cmd* data = (struct
> vki_drm_mode_fb_cmd*)(Addr)ARG3;
> > + PRINT("ioctl(DRM_MODE_ADDFB)\n");
> > + PRE_MEM_READ("ioctl(DRM_MODE_ADDFB).width", (Addr)&data->width,
> sizeof(data->width));
> > + PRE_MEM_READ("ioctl(DRM_MODE_ADDFB).height", (Addr)&data->height,
> sizeof(data->width));
> > + PRE_MEM_READ("ioctl(DRM_MODE_ADDFB).pitch", (Addr)&data->pitch,
> sizeof(data->width));
> > + PRE_MEM_READ("ioctl(DRM_MODE_ADDFB).bpp", (Addr)&data->bpp,
> sizeof(data->width));
> > + PRE_MEM_READ("ioctl(DRM_MODE_ADDFB).depth", (Addr)&data->depth,
> sizeof(data->width));
> > + PRE_MEM_READ("ioctl(DRM_MODE_ADDFB).handle", (Addr)&data->handle,
> sizeof(data->width));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_ADDFB).fb_id", (Addr)&data->fb_id,
> sizeof(data->fb_id));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_GETENCODER:
> > + if (ARG3) {
> > + struct vki_drm_mode_get_encoder* data = (struct
> vki_drm_mode_get_encoder*)(Addr)ARG3;
> > + PRINT("ioctl(DRM_MODE_GETENCODER)\n");
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETENCODER).encoder_id",
> (Addr)&data->encoder_id, sizeof(data->encoder_id));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETENCODER).encoder_type",
> (Addr)&data->encoder_type, sizeof(data->encoder_type));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETENCODER).crtc_id",
> (Addr)&data->crtc_id, sizeof(data->crtc_id));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETENCODER).possible_crtcs",
> (Addr)&data->possible_crtcs, sizeof(data->possible_crtcs));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETENCODER).possible_clones",
> (Addr)&data->possible_clones, sizeof(data->possible_clones));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_GETCRTC:
> > + if (ARG3) {
> > + struct vki_drm_mode_crtc* data = (struct
> vki_drm_mode_crtc*)(Addr)ARG3;
> > + PRINT("ioctl(DRM_MODE_GETCRTC)\n");
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCRTC).crtc_id",
> (Addr)&data->crtc_id, sizeof(data->crtc_id));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCRTC).set_connectors_ptr",
> (Addr)&data->set_connectors_ptr, sizeof(data->set_connectors_ptr));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCRTC).count_connectors",
> (Addr)&data->count_connectors, sizeof(data->count_connectors));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCRTC).fb_id",
> (Addr)&data->fb_id, sizeof(data->fb_id));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCRTC).x",
> (Addr)&data->x, sizeof(data->x));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCRTC).y",
> (Addr)&data->y, sizeof(data->y));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCRTC).gamma_size",
> (Addr)&data->gamma_size, sizeof(data->gamma_size));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCRTC).mode_valid",
> (Addr)&data->mode_valid, sizeof(data->mode_valid));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCRTC).mode",
> (Addr)&data->mode, sizeof(data->mode));
> > + if(data->set_connectors_ptr && data->count_connectors)
> > + {
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCRTC).set_connectors_ptr[]",
> (Addr)data->set_connectors_ptr, data->count_connectors*sizeof(__vki_u32));
> > + }
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_GETRESOURCES:
> > + if (ARG3) {
> > + struct vki_drm_mode_card_res* data = (struct
> vki_drm_mode_card_res*)(Addr)ARG3;
> > + PRINT("ioctl(DRM_MODE_GETRESOURCES)\n");
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETRESOURCES).fb_id_ptr",
> (Addr)&data->fb_id_ptr, sizeof(data->fb_id_ptr));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETRESOURCES).crtc_id_ptr",
> (Addr)&data->crtc_id_ptr, sizeof(data->crtc_id_ptr));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETRESOURCES).connector_id_ptr",
> (Addr)&data->connector_id_ptr, sizeof(data->connector_id_ptr));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETRESOURCES).encoder_id_ptr",
> (Addr)&data->encoder_id_ptr, sizeof(data->encoder_id_ptr));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETRESOURCES).count_fbs",
> (Addr)&data->count_fbs, sizeof(data->count_fbs));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETRESOURCES).count_crtcs",
> (Addr)&data->count_crtcs, sizeof(data->count_crtcs));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETRESOURCES).count_connectors",
> (Addr)&data->count_connectors, sizeof(data->count_connectors));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETRESOURCES).count_encoders",
> (Addr)&data->count_encoders, sizeof(data->count_encoders));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).count_fbs",
> (Addr)&data->count_fbs, sizeof(data->count_fbs));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).count_crtcs",
> (Addr)&data->count_crtcs, sizeof(data->count_crtcs));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).count_connectors",
> (Addr)&data->count_connectors, sizeof(data->count_connectors));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).count_encoders",
> (Addr)&data->count_encoders, sizeof(data->count_encoders));
> > + if(data->fb_id_ptr && data->count_fbs)
> > + {
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).fb_id_ptr[]",
> (Addr)data->fb_id_ptr, data->count_fbs*sizeof(__vki_u32));
> > + }
> > + if(data->crtc_id_ptr && data->count_crtcs)
> > + {
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).crtc_id_ptr[]",
> (Addr)data->crtc_id_ptr, data->count_crtcs*sizeof(__vki_u32));
> > + }
> > + if(data->connector_id_ptr && data->count_connectors)
> > + {
> > +
> PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).connector_id_ptr[]",
> (Addr)data->connector_id_ptr, data->count_connectors*sizeof(__vki_u32));
> > + }
> > + if(data->encoder_id_ptr && data->count_encoders)
> > + {
> > +
> PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).encoder_id_ptr[]",
> (Addr)data->encoder_id_ptr, data->count_encoders*sizeof(__vki_u32));
> > + }
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).min_width",
> (Addr)&data->min_width, sizeof(data->min_width));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).max_width",
> (Addr)&data->max_width, sizeof(data->max_width));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).min_height",
> (Addr)&data->min_height, sizeof(data->min_height));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETRESOURCES).max_height",
> (Addr)&data->max_height, sizeof(data->max_height));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_GETCONNECTOR:
> > + if (ARG3) {
> > + struct vki_drm_mode_get_connector* data = (struct
> vki_drm_mode_get_connector*)(Addr)ARG3;
> > + PRINT("ioctl(DRM_MODE_GETCONNECTOR) for id %ld\n",
> (long)data->connector_id);
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCONNECTOR).connector_id",
> (Addr)&data->connector_id, sizeof(data->connector_id));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCONNECTOR).encoders_ptr",
> (Addr)&data->encoders_ptr, sizeof(data->encoders_ptr));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCONNECTOR).modes_ptr",
> (Addr)&data->modes_ptr, sizeof(data->modes_ptr));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCONNECTOR).props_ptr",
> (Addr)&data->props_ptr, sizeof(data->props_ptr));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCONNECTOR).prop_values_ptr",
> (Addr)&data->prop_values_ptr, sizeof(data->prop_values_ptr));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCONNECTOR).count_encoders",
> (Addr)&data->count_encoders, sizeof(data->count_encoders));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCONNECTOR).count_modes",
> (Addr)&data->count_modes, sizeof(data->count_modes));
> > + PRE_MEM_READ("ioctl(DRM_MODE_GETCONNECTOR).count_props",
> (Addr)&data->count_props, sizeof(data->count_props));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).count_encoders",
> (Addr)&data->count_encoders, sizeof(data->count_encoders));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).count_modes",
> (Addr)&data->count_modes, sizeof(data->count_modes));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).count_props",
> (Addr)&data->count_props, sizeof(data->count_props));
> > + if(data->encoders_ptr && data->count_modes)
> > + {
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).encoders_ptr[]",
> (Addr)data->encoders_ptr, data->count_encoders*sizeof(__vki_u32));
> > + }
> > + if(data->modes_ptr && data->count_modes)
> > + {
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).modes_ptr[]",
> (Addr)data->modes_ptr, data->count_modes*sizeof(struct
> vki_drm_mode_modeinfo));
> > + }
> > + if(data->props_ptr && data->count_props)
> > + {
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).props_ptr[]",
> (Addr)data->props_ptr, data->count_props*sizeof(__vki_u32));
> > + }
> > + if(data->prop_values_ptr && data->count_props)
> > + {
> > +
> PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).prop_values_ptr[]",
> (Addr)data->prop_values_ptr, data->count_props*sizeof(__vki_u64));
> > + }
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).encoder_id",
> (Addr)&data->encoder_id, sizeof(data->encoder_id));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).connector_type",
> (Addr)&data->connector_type, sizeof(data->connector_type));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).connector_type_id",
> (Addr)&data->connector_type_id, sizeof(data->connector_type_id));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).connection",
> (Addr)&data->connection, sizeof(data->connection));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).mm_width",
> (Addr)&data->mm_width, sizeof(data->mm_width));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).mm_height",
> (Addr)&data->mm_height, sizeof(data->mm_height));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_GETCONNECTOR).subpixel",
> (Addr)&data->subpixel, sizeof(data->subpixel));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_CREATE_DUMB:
> > + if (ARG3) {
> > + struct vki_drm_mode_create_dumb* data = (struct
> vki_drm_mode_create_dumb*)(Addr)ARG3;
> > + PRINT("ioctl(DRM_MODE_CREATE_DUMB) size (%ldx%ld), %ld bits per
> pixel\n", (long)data->width, (long)data->height, (long)data->bpp);
> > + PRE_MEM_READ("ioctl(DRM_MODE_CREATE_DUMB).width",
> (Addr)&data->width, sizeof(data->width));
> > + PRE_MEM_READ("ioctl(DRM_MODE_CREATE_DUMB).height",
> (Addr)&data->height, sizeof(data->height));
> > + PRE_MEM_READ("ioctl(DRM_MODE_CREATE_DUMB).bpp",
> (Addr)&data->bpp, sizeof(data->bpp));
> > + PRE_MEM_READ("ioctl(DRM_MODE_CREATE_DUMB).flags",
> (Addr)&data->flags, sizeof(data->flags));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_CREATE_DUMB).pitch",
> (Addr)&data->pitch, sizeof(data->pitch));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_CREATE_DUMB).handle",
> (Addr)&data->handle, sizeof(data->handle));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_CREATE_DUMB).size",
> (Addr)&data->size, sizeof(data->size));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_MAP_DUMB:
> > + if (ARG3) {
> > + struct vki_drm_mode_map_dumb* data = (struct
> vki_drm_mode_map_dumb*)(Addr)ARG3;
> > + PRINT("ioctl(DRM_MODE_MAP_DUMB)");
> > + PRE_MEM_READ("ioctl(DRM_MODE_MAP_DUMB).handle",
> (Addr)&data->handle, sizeof(data->handle));
> > + PRE_MEM_WRITE("ioctl(DRM_MODE_MAP_DUMB).offset",
> (Addr)&data->offset, sizeof(data->offset));
> > + }
> > + break;
> > case VKI_DRM_IOCTL_I915_GETPARAM:
> > if (ARG3) {
> > vki_drm_i915_getparam_t *data = (vki_drm_i915_getparam_t
> *)(Addr)ARG3;
> > @@ -9316,6 +9475,9 @@
> > PRE_MEM_WRITE("ioctl(VKI_PERF_EVENT_IOC_ID)", (Addr)ARG3,
> sizeof(__vki_u64));
> > break;
> >
> > + case VKI_EVIOCGRAB:
> > + break;
> > +
> > default:
> > /* EVIOC* are variable length and return size written on success
> */
> > switch (ARG2 & ~(_VKI_IOC_SIZEMASK << _VKI_IOC_SIZESHIFT)) {
> > @@ -10606,6 +10768,119 @@
> > POST_MEM_WRITE((Addr)&data->size, sizeof(data->size));
> > }
> > break;
> > + case VKI_DRM_IOCTL_SET_MASTER:
> > + break;
> > + case VKI_DRM_IOCTL_DROP_MASTER:
> > + break;
> > + case VKI_DRM_IOCTL_MODE_PAGE_FLIP:
> > + break;
> > + case VKI_DRM_IOCTL_MODE_ADDFB:
> > + if (ARG3) {
> > + struct vki_drm_mode_fb_cmd* data = (struct
> vki_drm_mode_fb_cmd*)(Addr)ARG3;
> > + POST_MEM_WRITE((Addr)&data->fb_id, sizeof(data->fb_id));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_GETENCODER:
> > + if (ARG3) {
> > + struct vki_drm_mode_get_encoder* data = (struct
> vki_drm_mode_get_encoder*)(Addr)ARG3;
> > + POST_MEM_WRITE((Addr)&data->encoder_type,
> sizeof(data->encoder_type));
> > + POST_MEM_WRITE((Addr)&data->crtc_id,
> sizeof(data->crtc_id));
> > + POST_MEM_WRITE((Addr)&data->possible_crtcs,
> sizeof(data->possible_crtcs));
> > + POST_MEM_WRITE((Addr)&data->possible_clones,
> sizeof(data->possible_clones));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_GETCRTC:
> > + if (ARG3) {
> > + struct vki_drm_mode_crtc* data = (struct
> vki_drm_mode_crtc*)(Addr)ARG3;
> > + POST_MEM_WRITE((Addr)&data->fb_id,
> sizeof(data->fb_id));
> > + POST_MEM_WRITE((Addr)&data->x,
> sizeof(data->x));
> > + POST_MEM_WRITE((Addr)&data->y,
> sizeof(data->y));
> > + POST_MEM_WRITE((Addr)&data->gamma_size,
> sizeof(data->gamma_size));
> > + POST_MEM_WRITE((Addr)&data->mode_valid,
> sizeof(data->mode_valid));
> > + if(data->mode_valid)
> > + {
> > + POST_MEM_WRITE((Addr)&data->mode,
> sizeof(data->mode));
> > + }
> > + if(data->set_connectors_ptr && data->count_connectors)
> > + {
> > + POST_MEM_WRITE((Addr)data->set_connectors_ptr,
> data->count_connectors*sizeof(__vki_u32));
> > + }
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_GETRESOURCES:
> > + if (ARG3) {
> > + struct vki_drm_mode_card_res* data = (struct
> vki_drm_mode_card_res*)(Addr)ARG3;
> > + POST_MEM_WRITE((Addr)&data->count_fbs,
> sizeof(data->count_fbs));
> > + POST_MEM_WRITE((Addr)&data->count_crtcs,
> sizeof(data->count_crtcs));
> > + POST_MEM_WRITE((Addr)&data->count_connectors,
> sizeof(data->count_connectors));
> > + POST_MEM_WRITE((Addr)&data->count_encoders,
> sizeof(data->count_encoders));
> > + if(data->fb_id_ptr && data->count_fbs)
> > + {
> > + POST_MEM_WRITE((Addr)data->fb_id_ptr,
> data->count_fbs*sizeof(__vki_u32));
> > + }
> > + if(data->crtc_id_ptr && data->count_crtcs)
> > + {
> > + POST_MEM_WRITE((Addr)data->crtc_id_ptr,
> data->count_crtcs*sizeof(__vki_u32));
> > + }
> > + if(data->connector_id_ptr && data->count_connectors)
> > + {
> > + POST_MEM_WRITE((Addr)data->connector_id_ptr,
> data->count_connectors*sizeof(__vki_u32));
> > + }
> > + if(data->encoder_id_ptr && data->count_encoders)
> > + {
> > + POST_MEM_WRITE((Addr)data->encoder_id_ptr,
> data->count_encoders*sizeof(__vki_u32));
> > + }
> > + POST_MEM_WRITE((Addr)&data->min_width, sizeof(data->min_width));
> > + POST_MEM_WRITE((Addr)&data->max_width, sizeof(data->max_width));
> > + POST_MEM_WRITE((Addr)&data->min_height, sizeof(data->min_height));
> > + POST_MEM_WRITE((Addr)&data->max_height, sizeof(data->max_height));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_GETCONNECTOR:
> > + if (ARG3) {
> > + struct vki_drm_mode_get_connector* data = (struct
> vki_drm_mode_get_connector*)(Addr)ARG3;
> > + POST_MEM_WRITE((Addr)&data->count_encoders,
> sizeof(data->count_encoders));
> > + POST_MEM_WRITE((Addr)&data->count_modes,
> sizeof(data->count_modes));
> > + POST_MEM_WRITE((Addr)&data->count_props,
> sizeof(data->count_props));
> > + if(data->encoders_ptr && data->count_modes)
> > + {
> > + POST_MEM_WRITE((Addr)data->encoders_ptr,
> data->count_encoders*sizeof(__vki_u32));
> > + }
> > + if(data->modes_ptr && data->count_modes)
> > + {
> > + POST_MEM_WRITE((Addr)data->modes_ptr,
> data->count_modes*sizeof(struct vki_drm_mode_modeinfo));
> > + }
> > + if(data->props_ptr && data->count_props)
> > + {
> > + POST_MEM_WRITE((Addr)data->props_ptr,
> data->count_props*sizeof(__vki_u32));
> > + }
> > + if(data->prop_values_ptr && data->count_props)
> > + {
> > + POST_MEM_WRITE((Addr)data->prop_values_ptr,
> data->count_props*sizeof(__vki_u64));
> > + }
> > + POST_MEM_WRITE((Addr)&data->encoder_id,
> sizeof(data->encoder_id));
> > + POST_MEM_WRITE((Addr)&data->connector_type,
> sizeof(data->connector_type));
> > + POST_MEM_WRITE((Addr)&data->connector_type_id,
> sizeof(data->connector_type_id));
> > + POST_MEM_WRITE((Addr)&data->connection,
> sizeof(data->connection));
> > + POST_MEM_WRITE((Addr)&data->mm_width,
> sizeof(data->mm_width));
> > + POST_MEM_WRITE((Addr)&data->mm_height,
> sizeof(data->mm_height));
> > + POST_MEM_WRITE((Addr)&data->subpixel,
> sizeof(data->subpixel));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_CREATE_DUMB:
> > + if (ARG3) {
> > + struct vki_drm_mode_create_dumb* data = (struct
> vki_drm_mode_create_dumb*)(Addr)ARG3;
> > + POST_MEM_WRITE((Addr)&data->pitch, sizeof(data->pitch));
> > + POST_MEM_WRITE((Addr)&data->handle, sizeof(data->handle));
> > + POST_MEM_WRITE((Addr)&data->size, sizeof(data->size));
> > + }
> > + break;
> > + case VKI_DRM_IOCTL_MODE_MAP_DUMB:
> > + if (ARG3) {
> > + struct vki_drm_mode_map_dumb* data = (struct
> vki_drm_mode_map_dumb*)(Addr)ARG3;
> > + POST_MEM_WRITE((Addr)&data->offset, sizeof(data->offset));
> > + }
> > + break;
> > case VKI_DRM_IOCTL_I915_GETPARAM:
> > if (ARG3) {
> > vki_drm_i915_getparam_t *data = (vki_drm_i915_getparam_t
> *)(Addr)ARG3;
> > @@ -11313,6 +11588,9 @@
> > POST_MEM_WRITE((Addr)ARG3, sizeof(__vki_u64));
> > break;
> >
> > + case VKI_EVIOCGRAB:
> > + break;
> > +
> > default:
> > /* EVIOC* are variable length and return size written on success
> */
> > switch (ARG2 & ~(_VKI_IOC_SIZEMASK << _VKI_IOC_SIZESHIFT)) {
> > diff -ruw valgrind-3.15.0-orig/include/vki/vki-linux-drm.h
> valgrind-3.15.0/include/vki/vki-linux-drm.h
> > --- valgrind-3.15.0-orig/include/vki/vki-linux-drm.h 2019-04-13
> 03:56:21.000000000 -0700
> > +++ valgrind-3.15.0/include/vki/vki-linux-drm.h 2020-04-26
> 11:09:08.471160985 -0700
> > @@ -440,6 +440,64 @@
> > __vki_u64 green;
> > __vki_u64 blue;
> > };
> > +struct vki_drm_mode_crtc_page_flip {
> > + __vki_u32 crtc_id;
> > + __vki_u32 fb_id;
> > + __vki_u32 flags;
> > + __vki_u32 reserved;
> > + __vki_u64 user_data;
> > +};
> > +struct vki_drm_mode_get_connector {
> > +
> > + __vki_u64 encoders_ptr;
> > + __vki_u64 modes_ptr;
> > + __vki_u64 props_ptr;
> > + __vki_u64 prop_values_ptr;
> > +
> > + __vki_u32 count_modes;
> > + __vki_u32 count_props;
> > + __vki_u32 count_encoders;
> > +
> > + __vki_u32 encoder_id; /**< Current Encoder */
> > + __vki_u32 connector_id; /**< Id */
> > + __vki_u32 connector_type;
> > + __vki_u32 connector_type_id;
> > +
> > + __vki_u32 connection;
> > + __vki_u32 mm_width; /**< width in millimeters */
> > + __vki_u32 mm_height; /**< height in millimeters */
> > + __vki_u32 subpixel;
> > +
> > + __vki_u32 pad;
> > +};
> > +/* create a dumb scanout buffer */
> > +struct vki_drm_mode_create_dumb {
> > + __vki_u32 height;
> > + __vki_u32 width;
> > + __vki_u32 bpp;
> > + __vki_u32 flags;
> > + /* handle, pitch, size will be returned */
> > + __vki_u32 handle;
> > + __vki_u32 pitch;
> > + __vki_u64 size;
> > +};
> > +
> > +/* set up for mmap of a dumb scanout buffer */
> > +struct vki_drm_mode_map_dumb {
> > + /** Handle for the object being mapped. */
> > + __vki_u32 handle;
> > + __vki_u32 pad;
> > + /**
>
> > + * Fake offset to use for subsequent mmap call
>
> > + *
>
> > + * This is a fixed-size type for 32/64 compatibility.
>
> > + */
> > + __vki_u64 offset;
> > +};
> > +
> > +struct vki_drm_mode_destroy_dumb {
> > + __vki_u32 handle;
> > +};
> >
> > //----------------------------------------------------------------------
> > // From include/drm/drm.h
> > @@ -533,6 +591,13 @@
> > #define VKI_DRM_IOCTL_MODE_GETFB VKI_DRM_IOWR(0xAD, struct
> vki_drm_mode_fb_cmd)
> > #define VKI_DRM_IOCTL_MODE_ADDFB VKI_DRM_IOWR(0xAE, struct
> vki_drm_mode_fb_cmd)
> > #define VKI_DRM_IOCTL_MODE_RMFB VKI_DRM_IOWR(0xAF,
> unsigned int)
> > +#define VKI_DRM_IOCTL_MODE_PAGE_FLIP VKI_DRM_IOWR(0xB0, struct
> vki_drm_mode_crtc_page_flip)
> > +
> > +
> > +#define VKI_DRM_IOCTL_MODE_CREATE_DUMB VKI_DRM_IOWR(0xB2, struct
> vki_drm_mode_create_dumb)
> > +#define VKI_DRM_IOCTL_MODE_MAP_DUMB VKI_DRM_IOWR(0xB3, struct
> vki_drm_mode_map_dumb)
> > +#define VKI_DRM_IOCTL_MODE_DESTROY_DUMB VKI_DRM_IOWR(0xB4, struct
> vki_drm_mode_destroy_dumb)
> > +
> >
> > #define VKI_DRM_COMMAND_BASE 0x40
> > #define VKI_DRM_COMMAND_END 0xA0
> > diff -ruw valgrind-3.15.0-orig/include/vki/vki-linux.h
> valgrind-3.15.0/include/vki/vki-linux.h
> > --- valgrind-3.15.0-orig/include/vki/vki-linux.h 2019-04-13
> 03:56:21.000000000 -0700
> > +++ valgrind-3.15.0/include/vki/vki-linux.h 2020-04-26
> 13:34:12.921637068 -0700
> > @@ -3058,6 +3058,8 @@
> >
> > #define VKI_EVIOCGBIT(ev,len) _VKI_IOC(_VKI_IOC_READ, 'E', 0x20
> + ev, len) /* get event bits */
> >
> > +#define VKI_EVIOCGRAB _VKI_IOW('E', 0x90, int)
> /* Grab/Release device */
> > +
> > /*
> > * Event types
> > */
> >
> >
> >
> > _______________________________________________
> > Valgrind-developers mailing list
> > Val...@li...
> > https://lists.sourceforge.net/lists/listinfo/valgrind-developers
>
>
|