add further ioctl time64 fallback conversions

this commit covers all remaining ioctls I'm aware of that use
time_t-derived types in their interfaces. it may still be incomplete,
and has undergone only minimal testing for a few commands used in
audio playback.

the SNDRV_PCM_IOCTL_SYNC_PTR command is special-cased because, rather
than the whole structure expanding, it has two substructures each
padded to 64 bytes that expand within their own 64-byte reserved zone.
as long as it's the only one of its type, it doesn't really make sense
to make a general framework for it, but the existing table framework
is still used for the substructures in the special-case. one of the
substructures, snd_pcm_mmap_status, has a snd_pcm_uframes_t member
which is not a timestamp but is expanded just like one, to match the
64-bit-arch version of the structure. this is handled just like a
timestamp at offset 8, and is the motivation for the conversions table
holding offsets of individual values to be expanded rather than
timespec/timeval type pairs.

for some of the types, the size to which they expand is dependent on
whether the arch's ABI aligns 8-byte types on 8-byte boundaries.
new_req entries in the table need to reflect this size to get the
right ioctl request number that will match what callers pass, but we
don't have access to the actual structure type definitions here and
duplicating them would be cumbersome. instead, the new_misaligned
macro introduced here constructs an artificial object whose size is
the result of expanding a misaligned timespec/timeval to 64-bit and
imposing the arch's alignment on the result, which can be passed to
the _IO{R,W,WR} macros.

diff --git a/src/misc/ioctl.c b/src/misc/ioctl.c
index 245876e213883c71b32b461c7fa9d328f5187eae..84a50d44f75b81fccf522f1bd0cde72e465a2e90 100644 (file)
--- a/src/misc/ioctl.c
+++ b/src/misc/ioctl.c
@@ -23,9 +23,49 @@ struct ioctl_compat_map {
 #define COUNT(...) NINTH(__VA_ARGS__,8,7,6,5,4,3,2,1,0)
 #define OFFS(...) COUNT(__VA_ARGS__), { __VA_ARGS__ }
 
+/* yields a type for a struct with original size n, with a misaligned
+ * timeval/timespec expanded from 32- to 64-bit. for use with ioctl
+ * number producing macros; only size of result is meaningful. */
+#define new_misaligned(n) struct { int i; time_t t; char c[(n)-4]; }
+
 static const struct ioctl_compat_map compat_map[] = {
        { SIOCGSTAMP, SIOCGSTAMP_OLD, 8, R, 0, OFFS(0, 4) },
        { SIOCGSTAMPNS, SIOCGSTAMPNS_OLD, 8, R, 0, OFFS(0, 4) },
+
+       /* SNDRV_TIMER_IOCTL_STATUS */
+       { _IOR('T', 0x14, char[96]), _IOR('T', 0x14, 88), 88, R, 0, OFFS(0,4) },
+
+       /* SNDRV_PCM_IOCTL_STATUS[_EXT] */
+       { _IOR('A', 0x20, char[128]), _IOR('A', 0x20, char[108]), 108, R, 1, OFFS(4,8,12,16,52,56,60,64) },
+       { _IOWR('A', 0x24, char[128]), _IOWR('A', 0x24, char[108]), 108, WR, 1, OFFS(4,8,12,16,52,56,60,64) },
+
+       /* SNDRV_RAWMIDI_IOCTL_STATUS */
+       { _IOWR('W', 0x20, char[48]), _IOWR('W', 0x20, char[36]), 36, WR, 1, OFFS(4,8) },
+
+       /* SNDRV_PCM_IOCTL_SYNC_PTR - with 3 subtables */
+       { _IOWR('A', 0x23, char[136]), _IOWR('A', 0x23, char[132]), 0, WR, 1, 0 },
+       { 0, 0, 4, WR, 1, 0 }, /* snd_pcm_sync_ptr (flags only) */
+       { 0, 0, 32, WR, 1, OFFS(8,12,16,24,28) }, /* snd_pcm_mmap_status */
+       { 0, 0, 8, WR, 1, OFFS(0,4) }, /* snd_pcm_mmap_control */
+
+       /* VIDIOC_QUERYBUF, VIDIOC_QBUF, VIDIOC_DQBUF, VIDIOC_PREPARE_BUF */
+       { _IOWR('V',  9, new_misaligned(72)), _IOWR('V',  9, char[72]), 72, WR, 0, OFFS(20) },
+       { _IOWR('V', 15, new_misaligned(72)), _IOWR('V', 15, char[72]), 72, WR, 0, OFFS(20) },
+       { _IOWR('V', 17, new_misaligned(72)), _IOWR('V', 17, char[72]), 72, WR, 0, OFFS(20) },
+       { _IOWR('V', 93, new_misaligned(72)), _IOWR('V', 93, char[72]), 72, WR, 0, OFFS(20) },
+
+       /* VIDIOC_DQEVENT */
+       { _IOR('V', 89, new_misaligned(96)), _IOR('V', 89, char[96]), 96, R, 0, OFFS(76,80) },
+
+       /* PPPIOCGIDLE */
+       { _IOR('t', 63, char[16]), _IOR('t', 63, char[8]), 8, R, 0, OFFS(0,4) },
+
+       /* PPGETTIME, PPSETTIME */
+       { _IOR('p', 0x95, char[16]), _IOR('p', 0x95, char[8]), 8, R, 0, OFFS(0,4) },
+       { _IOW('p', 0x96, char[16]), _IOW('p', 0x96, char[8]), 8, W, 0, OFFS(0,4) },
+
+       /* LPSETTIMEOUT */
+       { _IOW(0x6, 0xf, char[16]), 0x060f, 8, W, 0, OFFS(0,4) },
 };
 
 static void convert_ioctl_struct(const struct ioctl_compat_map *map, char *old, char *new, int dir)
@@ -34,6 +74,14 @@ static void convert_ioctl_struct(const struct ioctl_compat_map *map, char *old,
        int old_offset = 0;
        int old_size = map->old_size;
        if (!(dir & map->dir)) return;
+       if (!map->old_size) {
+               /* offsets hard-coded for SNDRV_PCM_IOCTL_SYNC_PTR;
+                * if another exception appears this needs changing. */
+               convert_ioctl_struct(map+1, old, new, dir);
+               convert_ioctl_struct(map+2, old+4, new+8, dir);
+               convert_ioctl_struct(map+3, old+68, new+72, dir);
+               return;
+       }
        for (int i=0; i < map->noffs; i++) {
                int ts_offset = map->offsets[i];
                int len = ts_offset-old_offset;
@@ -69,7 +117,7 @@ int ioctl(int fd, int req, ...)
        arg = va_arg(ap, void *);
        va_end(ap);
        int r = __syscall(SYS_ioctl, fd, req, arg);
-       if (r==-ENOTTY) {
+       if (req && r==-ENOTTY) {
                for (int i=0; i<sizeof compat_map/sizeof *compat_map; i++) {
                        if (compat_map[i].new_req != req) continue;
                        union {