src/misc/ioctl.c

   1 #include <sys/ioctl.h>
   2 #include <stdarg.h>
   3 #include <errno.h>
   4 #include <time.h>
   5 #include <sys/time.h>
   6 #include <stddef.h>
   7 #include <stdint.h>
   8 #include <string.h>
   9 #include <endian.h>
  10 #include "syscall.h"
  11
  12 #define alignof(t) offsetof(struct { char c; t x; }, x)
  13
  14 #define W 1
  15 #define R 2
  16 #define WR 3
  17
  18 struct ioctl_compat_map {
  19         int new_req, old_req;
  20         unsigned char old_size, dir, force_align, noffs;
  21         unsigned char offsets[8];
  22 };
  23
  24 #define NINTH(a,b,c,d,e,f,g,h,i,...) i
  25 #define COUNT(...) NINTH(__VA_ARGS__,8,7,6,5,4,3,2,1,0)
  26 #define OFFS(...) COUNT(__VA_ARGS__), { __VA_ARGS__ }
  27
  28 /* yields a type for a struct with original size n, with a misaligned
  29  * timeval/timespec expanded from 32- to 64-bit. for use with ioctl
  30  * number producing macros; only size of result is meaningful. */
  31 #define new_misaligned(n) struct { int i; time_t t; char c[(n)-4]; }
  32
  33 struct v4l2_event {
  34         uint32_t a;
  35         uint64_t b[8];
  36         uint32_t c[2], ts[2], d[9];
  37 };
  38
  39 static const struct ioctl_compat_map compat_map[] = {
  40         { SIOCGSTAMP, SIOCGSTAMP_OLD, 8, R, 0, OFFS(0, 4) },
  41         { SIOCGSTAMPNS, SIOCGSTAMPNS_OLD, 8, R, 0, OFFS(0, 4) },
  42
  43         /* SNDRV_TIMER_IOCTL_STATUS */
  44         { _IOR('T', 0x14, char[96]), _IOR('T', 0x14, 88), 88, R, 0, OFFS(0,4) },
  45
  46         /* SNDRV_PCM_IOCTL_STATUS[_EXT] */
  47         { _IOR('A', 0x20, char[128]), _IOR('A', 0x20, char[108]), 108, R, 1, OFFS(4,8,12,16,52,56,60,64) },
  48         { _IOWR('A', 0x24, char[128]), _IOWR('A', 0x24, char[108]), 108, WR, 1, OFFS(4,8,12,16,52,56,60,64) },
  49
  50         /* SNDRV_RAWMIDI_IOCTL_STATUS */
  51         { _IOWR('W', 0x20, char[48]), _IOWR('W', 0x20, char[36]), 36, WR, 1, OFFS(4,8) },
  52
  53         /* SNDRV_PCM_IOCTL_SYNC_PTR - with 3 subtables */
  54         { _IOWR('A', 0x23, char[136]), _IOWR('A', 0x23, char[132]), 0, WR, 1, 0 },
  55         { 0, 0, 4, WR, 1, 0 }, /* snd_pcm_sync_ptr (flags only) */
  56         { 0, 0, 32, WR, 1, OFFS(8,12,16,24,28) }, /* snd_pcm_mmap_status */
  57         { 0, 0, 4, WR, 1, 0 }, /* snd_pcm_mmap_control (each member) */
  58
  59         /* VIDIOC_QUERYBUF, VIDIOC_QBUF, VIDIOC_DQBUF, VIDIOC_PREPARE_BUF */
  60         { _IOWR('V',  9, new_misaligned(68)), _IOWR('V',  9, char[68]), 68, WR, 1, OFFS(20, 24) },
  61         { _IOWR('V', 15, new_misaligned(68)), _IOWR('V', 15, char[68]), 68, WR, 1, OFFS(20, 24) },
  62         { _IOWR('V', 17, new_misaligned(68)), _IOWR('V', 17, char[68]), 68, WR, 1, OFFS(20, 24) },
  63         { _IOWR('V', 93, new_misaligned(68)), _IOWR('V', 93, char[68]), 68, WR, 1, OFFS(20, 24) },
  64
  65         /* VIDIOC_DQEVENT */
  66         { _IOR('V', 89, new_misaligned(120)), _IOR('V', 89, struct v4l2_event), sizeof(struct v4l2_event),
  67           R, 0, OFFS(offsetof(struct v4l2_event, ts[0]), offsetof(struct v4l2_event, ts[1])) },
  68
  69         /* VIDIOC_OMAP3ISP_STAT_REQ */
  70         { _IOWR('V', 192+6, char[32]), _IOWR('V', 192+6, char[24]), 22, WR, 0, OFFS(0,4) },
  71
  72         /* PPPIOCGIDLE */
  73         { _IOR('t', 63, char[16]), _IOR('t', 63, char[8]), 8, R, 0, OFFS(0,4) },
  74
  75         /* PPGETTIME, PPSETTIME */
  76         { _IOR('p', 0x95, char[16]), _IOR('p', 0x95, char[8]), 8, R, 0, OFFS(0,4) },
  77         { _IOW('p', 0x96, char[16]), _IOW('p', 0x96, char[8]), 8, W, 0, OFFS(0,4) },
  78
  79         /* LPSETTIMEOUT */
  80         { _IOW(0x6, 0xf, char[16]), 0x060f, 8, W, 0, OFFS(0,4) },
  81 };
  82
  83 static void convert_ioctl_struct(const struct ioctl_compat_map *map, char *old, char *new, int dir)
  84 {
  85         int new_offset = 0;
  86         int old_offset = 0;
  87         int old_size = map->old_size;
  88         if (!(dir & map->dir)) return;
  89         if (!map->old_size) {
  90                 /* offsets hard-coded for SNDRV_PCM_IOCTL_SYNC_PTR;
  91                  * if another exception appears this needs changing. */
  92                 convert_ioctl_struct(map+1, old, new, dir);
  93                 convert_ioctl_struct(map+2, old+4, new+8, dir);
  94                 /* snd_pcm_mmap_control, special-cased due to kernel
  95                  * type definition having been botched. */
  96                 int adj = BYTE_ORDER==BIG_ENDIAN ? 4 : 0;
  97                 convert_ioctl_struct(map+3, old+68, new+72+adj, dir);
  98                 convert_ioctl_struct(map+3, old+72, new+76+3*adj, dir);
  99                 return;
 100         }
 101         for (int i=0; i < map->noffs; i++) {
 102                 int ts_offset = map->offsets[i];
 103                 int len = ts_offset-old_offset;
 104                 if (dir==W) memcpy(old+old_offset, new+new_offset, len);
 105                 else memcpy(new+new_offset, old+old_offset, len);
 106                 new_offset += len;
 107                 old_offset += len;
 108                 long long new_ts;
 109                 long old_ts;
 110                 int align = map->force_align ? sizeof(time_t) : alignof(time_t);
 111                 new_offset += (align-1) & -new_offset;
 112                 if (dir==W) {
 113                         memcpy(&new_ts, new+new_offset, sizeof new_ts);
 114                         old_ts = new_ts;
 115                         memcpy(old+old_offset, &old_ts, sizeof old_ts);
 116                 } else {
 117                         memcpy(&old_ts, old+old_offset, sizeof old_ts);
 118                         new_ts = old_ts;
 119                         memcpy(new+new_offset, &new_ts, sizeof new_ts);
 120                 }
 121                 new_offset += sizeof new_ts;
 122                 old_offset += sizeof old_ts;
 123         }
 124         if (dir==W) memcpy(old+old_offset, new+new_offset, old_size-old_offset);
 125         else memcpy(new+new_offset, old+old_offset, old_size-old_offset);
 126 }
 127
 128 int ioctl(int fd, int req, ...)
 129 {
 130         void *arg;
 131         va_list ap;
 132         va_start(ap, req);
 133         arg = va_arg(ap, void *);
 134         va_end(ap);
 135         int r = __syscall(SYS_ioctl, fd, req, arg);
 136         if (SIOCGSTAMP != SIOCGSTAMP_OLD && req && r==-ENOTTY) {
 137                 for (int i=0; i<sizeof compat_map/sizeof *compat_map; i++) {
 138                         if (compat_map[i].new_req != req) continue;
 139                         union {
 140                                 long long align;
 141                                 char buf[256];
 142                         } u;
 143                         convert_ioctl_struct(&compat_map[i], u.buf, arg, W);
 144                         r = __syscall(SYS_ioctl, fd, compat_map[i].old_req, u.buf);
 145                         if (r<0) break;
 146                         convert_ioctl_struct(&compat_map[i], u.buf, arg, R);
 147                         break;
 148                 }
 149         }
 150         return __syscall_ret(r);
 151 }