Merge with /home/shaggy/git/linus-clean/

1 files changed, 268 insertions, 230 deletions

diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index 26300fccb4fc..5dd0207ffd46 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -10,11 +10,11 @@
  * ioctls.
  */
 
-#ifdef INCLUDES
 #include <linux/config.h>
 #include <linux/types.h>
 #include <linux/compat.h>
 #include <linux/kernel.h>
+#include <linux/capability.h>
 #include <linux/compiler.h>
 #include <linux/sched.h>
 #include <linux/smp.h>
@@ -49,6 +49,8 @@
 #include <linux/vt_kern.h>
 #include <linux/fb.h>
 #include <linux/ext2_fs.h>
+#include <linux/ext3_jbd.h>
+#include <linux/ext3_fs.h>
 #include <linux/videodev.h>
 #include <linux/netdevice.h>
 #include <linux/raw.h>
@@ -79,13 +81,9 @@
 #include <linux/capi.h>
 
 #include <scsi/scsi.h>
-/* Ugly hack. */
-#undef __KERNEL__
 #include <scsi/scsi_ioctl.h>
-#define __KERNEL__
 #include <scsi/sg.h>
 
-#include <asm/types.h>
 #include <asm/uaccess.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
@@ -93,7 +91,6 @@
 #include <linux/watchdog.h>
 #include <linux/dm-ioctl.h>
 
-#include <asm/module.h>
 #include <linux/soundcard.h>
 #include <linux/lp.h>
 #include <linux/ppdev.h>
@@ -121,17 +118,33 @@
 
 #include <linux/hiddev.h>
 
-#undef INCLUDES
-#endif
-
-#ifdef CODE
+#include <linux/dvb/audio.h>
+#include <linux/dvb/dmx.h>
+#include <linux/dvb/frontend.h>
+#include <linux/dvb/video.h>
+#include <linux/lp.h>
 
 /* Aiee. Someone does not find a difference between int and long */
 #define EXT2_IOC32_GETFLAGS               _IOR('f', 1, int)
 #define EXT2_IOC32_SETFLAGS               _IOW('f', 2, int)
+#define EXT3_IOC32_GETVERSION             _IOR('f', 3, int)
+#define EXT3_IOC32_SETVERSION             _IOW('f', 4, int)
+#define EXT3_IOC32_GETRSVSZ               _IOR('f', 5, int)
+#define EXT3_IOC32_SETRSVSZ               _IOW('f', 6, int)
+#define EXT3_IOC32_GROUP_EXTEND           _IOW('f', 7, unsigned int)
+#ifdef CONFIG_JBD_DEBUG
+#define EXT3_IOC32_WAIT_FOR_READONLY      _IOR('f', 99, int)
+#endif
+
 #define EXT2_IOC32_GETVERSION             _IOR('v', 1, int)
 #define EXT2_IOC32_SETVERSION             _IOW('v', 2, int)
 
+static int do_ioctl32_pointer(unsigned int fd, unsigned int cmd,
+                              unsigned long arg, struct file *f)
+{
+        return sys_ioctl(fd, cmd, (unsigned long)compat_ptr(arg));
+}
+
 static int w_long(unsigned int fd, unsigned int cmd, unsigned long arg)
 {
         mm_segment_t old_fs = get_fs();
@@ -175,241 +188,141 @@ static int do_ext2_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
         return sys_ioctl(fd, cmd, (unsigned long)compat_ptr(arg));
 }
 
-struct video_tuner32 {
-        compat_int_t tuner;
-        char name[32];
-        compat_ulong_t rangelow, rangehigh;
-        u32 flags;      /* It is really u32 in videodev.h */
-        u16 mode, signal;
-};
-
-static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
-{
-        int i;
-
-        if(get_user(kp->tuner, &up->tuner))
-                return -EFAULT;
-        for(i = 0; i < 32; i++)
-                __get_user(kp->name[i], &up->name[i]);
-        __get_user(kp->rangelow, &up->rangelow);
-        __get_user(kp->rangehigh, &up->rangehigh);
-        __get_user(kp->flags, &up->flags);
-        __get_user(kp->mode, &up->mode);
-        __get_user(kp->signal, &up->signal);
-        return 0;
-}
-
-static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
+static int do_ext3_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
 {
-        int i;
-
-        if(put_user(kp->tuner, &up->tuner))
-                return -EFAULT;
-        for(i = 0; i < 32; i++)
-                __put_user(kp->name[i], &up->name[i]);
-        __put_user(kp->rangelow, &up->rangelow);
-        __put_user(kp->rangehigh, &up->rangehigh);
-        __put_user(kp->flags, &up->flags);
-        __put_user(kp->mode, &up->mode);
-        __put_user(kp->signal, &up->signal);
-        return 0;
+        /* These are just misnamed, they actually get/put from/to user an int */
+        switch (cmd) {
+        case EXT3_IOC32_GETVERSION: cmd = EXT3_IOC_GETVERSION; break;
+        case EXT3_IOC32_SETVERSION: cmd = EXT3_IOC_SETVERSION; break;
+        case EXT3_IOC32_GETRSVSZ: cmd = EXT3_IOC_GETRSVSZ; break;
+        case EXT3_IOC32_SETRSVSZ: cmd = EXT3_IOC_SETRSVSZ; break;
+        case EXT3_IOC32_GROUP_EXTEND: cmd = EXT3_IOC_GROUP_EXTEND; break;
+#ifdef CONFIG_JBD_DEBUG
+        case EXT3_IOC32_WAIT_FOR_READONLY: cmd = EXT3_IOC_WAIT_FOR_READONLY; break;
+#endif
+        }
+        return sys_ioctl(fd, cmd, (unsigned long)compat_ptr(arg));
 }
 
-struct video_buffer32 {
-        compat_caddr_t base;
-        compat_int_t height, width, depth, bytesperline;
+struct compat_dmx_event {
+        dmx_event_t     event;
+        compat_time_t   timeStamp;
+        union
+        {
+                dmx_scrambling_status_t scrambling;
+        } u;
 };
 
-static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
+static int do_dmx_get_event(unsigned int fd, unsigned int cmd, unsigned long arg)
 {
-        u32 tmp;
-
-        if (get_user(tmp, &up->base))
-                return -EFAULT;
+        struct dmx_event kevent;
+        mm_segment_t old_fs = get_fs();
+        int err;
 
-        /* This is actually a physical address stored
-         * as a void pointer.
-         */
-        kp->base = (void *)(unsigned long) tmp;
+        set_fs(KERNEL_DS);
+        err = sys_ioctl(fd, cmd, (unsigned long) &kevent);
+        set_fs(old_fs);
 
-        __get_user(kp->height, &up->height);
-        __get_user(kp->width, &up->width);
-        __get_user(kp->depth, &up->depth);
-        __get_user(kp->bytesperline, &up->bytesperline);
-        return 0;
-}
+        if (!err) {
+                struct compat_dmx_event __user *up = compat_ptr(arg);
 
-static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
-{
-        u32 tmp = (u32)((unsigned long)kp->base);
+                err  = put_user(kevent.event, &up->event);
+                err |= put_user(kevent.timeStamp, &up->timeStamp);
+                err |= put_user(kevent.u.scrambling, &up->u.scrambling);
+                if (err)
+                        err = -EFAULT;
+        }
 
-        if(put_user(tmp, &up->base))
-                return -EFAULT;
-        __put_user(kp->height, &up->height);
-        __put_user(kp->width, &up->width);
-        __put_user(kp->depth, &up->depth);
-        __put_user(kp->bytesperline, &up->bytesperline);
-        return 0;
+        return err;
 }
 
-struct video_clip32 {
-        s32 x, y, width, height;        /* Its really s32 in videodev.h */
-        compat_caddr_t next;
-};
-
-struct video_window32 {
-        u32 x, y, width, height, chromakey, flags;
-        compat_caddr_t clips;
-        compat_int_t clipcount;
+struct compat_video_event {
+        int32_t         type;
+        compat_time_t   timestamp;
+        union {
+                video_size_t size;
+                unsigned int frame_rate;
+        } u;
 };
 
-/* You get back everything except the clips... */
-static int put_video_window32(struct video_window *kp, struct video_window32 __user *up)
+static int do_video_get_event(unsigned int fd, unsigned int cmd, unsigned long arg)
 {
-        if(put_user(kp->x, &up->x))
-                return -EFAULT;
-        __put_user(kp->y, &up->y);
-        __put_user(kp->width, &up->width);
-        __put_user(kp->height, &up->height);
-        __put_user(kp->chromakey, &up->chromakey);
-        __put_user(kp->flags, &up->flags);
-        __put_user(kp->clipcount, &up->clipcount);
-        return 0;
-}
+        struct video_event kevent;
+        mm_segment_t old_fs = get_fs();
+        int err;
 
-#define VIDIOCGTUNER32          _IOWR('v',4, struct video_tuner32)
-#define VIDIOCSTUNER32          _IOW('v',5, struct video_tuner32)
-#define VIDIOCGWIN32            _IOR('v',9, struct video_window32)
-#define VIDIOCSWIN32            _IOW('v',10, struct video_window32)
-#define VIDIOCGFBUF32           _IOR('v',11, struct video_buffer32)
-#define VIDIOCSFBUF32           _IOW('v',12, struct video_buffer32)
-#define VIDIOCGFREQ32           _IOR('v',14, u32)
-#define VIDIOCSFREQ32           _IOW('v',15, u32)
+        set_fs(KERNEL_DS);
+        err = sys_ioctl(fd, cmd, (unsigned long) &kevent);
+        set_fs(old_fs);
 
-enum {
-        MaxClips = (~0U-sizeof(struct video_window))/sizeof(struct video_clip)
+        if (!err) {
+                struct compat_video_event __user *up = compat_ptr(arg);
+
+                err  = put_user(kevent.type, &up->type);
+                err |= put_user(kevent.timestamp, &up->timestamp);
+                err |= put_user(kevent.u.size.w, &up->u.size.w);
+                err |= put_user(kevent.u.size.h, &up->u.size.h);
+                err |= put_user(kevent.u.size.aspect_ratio,
+                                &up->u.size.aspect_ratio);
+                if (err)
+                        err = -EFAULT;
+        }
+
+        return err;
+}
+
+struct compat_video_still_picture {
+        compat_uptr_t iFrame;
+        int32_t size;
 };
 
-static int do_set_window(unsigned int fd, unsigned int cmd, unsigned long arg)
+static int do_video_stillpicture(unsigned int fd, unsigned int cmd, unsigned long arg)
 {
-        struct video_window32 __user *up = compat_ptr(arg);
-        struct video_window __user *vw;
-        struct video_clip __user *p;
-        int nclips;
-        u32 n;
+        struct compat_video_still_picture __user *up;
+        struct video_still_picture __user *up_native;
+        compat_uptr_t fp;
+        int32_t size;
+        int err;
 
-        if (get_user(nclips, &up->clipcount))
+        up = (struct compat_video_still_picture __user *) arg;
+        err  = get_user(fp, &up->iFrame);
+        err |= get_user(size, &up->size);
+        if (err)
                 return -EFAULT;
 
-        /* Peculiar interface... */
-        if (nclips < 0)
-                nclips = VIDEO_CLIPMAP_SIZE;
-
-        if (nclips > MaxClips)
-                return -ENOMEM;
+        up_native =
+                compat_alloc_user_space(sizeof(struct video_still_picture));
 
-        vw = compat_alloc_user_space(sizeof(struct video_window) +
-                                    nclips * sizeof(struct video_clip));
+        put_user(compat_ptr(fp), &up_native->iFrame);
+        put_user(size, &up_native->size);
 
-        p = nclips ? (struct video_clip __user *)(vw + 1) : NULL;
+        err = sys_ioctl(fd, cmd, (unsigned long) up_native);
 
-        if (get_user(n, &up->x) || put_user(n, &vw->x) ||
-            get_user(n, &up->y) || put_user(n, &vw->y) ||
-            get_user(n, &up->width) || put_user(n, &vw->width) ||
-            get_user(n, &up->height) || put_user(n, &vw->height) ||
-            get_user(n, &up->chromakey) || put_user(n, &vw->chromakey) ||
-            get_user(n, &up->flags) || put_user(n, &vw->flags) ||
-            get_user(n, &up->clipcount) || put_user(n, &vw->clipcount) ||
-            get_user(n, &up->clips) || put_user(p, &vw->clips))
-                return -EFAULT;
-
-        if (nclips) {
-                struct video_clip32 __user *u = compat_ptr(n);
-                int i;
-                if (!u)
-                        return -EINVAL;
-                for (i = 0; i < nclips; i++, u++, p++) {
-                        s32 v;
-                        if (get_user(v, &u->x) ||
-                            put_user(v, &p->x) ||
-                            get_user(v, &u->y) ||
-                            put_user(v, &p->y) ||
-                            get_user(v, &u->width) ||
-                            put_user(v, &p->width) ||
-                            get_user(v, &u->height) ||
-                            put_user(v, &p->height) ||
-                            put_user(NULL, &p->next))
-                                return -EFAULT;
-                }
-        }
-
-        return sys_ioctl(fd, VIDIOCSWIN, (unsigned long)p);
+        return err;
 }
 
-static int do_video_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
-{
-        union {
-                struct video_tuner vt;
-                struct video_buffer vb;
-                struct video_window vw;
-                unsigned long vx;
-        } karg;
-        mm_segment_t old_fs = get_fs();
-        void __user *up = compat_ptr(arg);
-        int err = 0;
-
-        /* First, convert the command. */
-        switch(cmd) {
-        case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
-        case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
-        case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
-        case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
-        case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
-        case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
-        case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
-        };
-
-        switch(cmd) {
-        case VIDIOCSTUNER:
-        case VIDIOCGTUNER:
-                err = get_video_tuner32(&karg.vt, up);
-                break;
-
-        case VIDIOCSFBUF:
-                err = get_video_buffer32(&karg.vb, up);
-                break;
-
-        case VIDIOCSFREQ:
-                err = get_user(karg.vx, (u32 __user *)up);
-                break;
-        };
-        if(err)
-                goto out;
+struct compat_video_spu_palette {
+        int length;
+        compat_uptr_t palette;
+};
 
-        set_fs(KERNEL_DS);
-        err = sys_ioctl(fd, cmd, (unsigned long)&karg);
-        set_fs(old_fs);
+static int do_video_set_spu_palette(unsigned int fd, unsigned int cmd, unsigned long arg)
+{
+        struct compat_video_spu_palette __user *up;
+        struct video_spu_palette __user *up_native;
+        compat_uptr_t palp;
+        int length, err;
 
-        if(err == 0) {
-                switch(cmd) {
-                case VIDIOCGTUNER:
-                        err = put_video_tuner32(&karg.vt, up);
-                        break;
+        up = (struct compat_video_spu_palette __user *) arg;
+        err  = get_user(palp, &up->palette);
+        err |= get_user(length, &up->length);
 
-                case VIDIOCGWIN:
-                        err = put_video_window32(&karg.vw, up);
-                        break;
+        up_native = compat_alloc_user_space(sizeof(struct video_spu_palette));
+        put_user(compat_ptr(palp), &up_native->palette);
+        put_user(length, &up_native->length);
 
-                case VIDIOCGFBUF:
-                        err = put_video_buffer32(&karg.vb, up);
-                        break;
+        err = sys_ioctl(fd, cmd, (unsigned long) up_native);
 
-                case VIDIOCGFREQ:
-                        err = put_user(((u32)karg.vx), (u32 __user *)up);
-                        break;
-                };
-        }
-out:
         return err;
 }
 
@@ -532,7 +445,8 @@ static int dev_ifconf(unsigned int fd, unsigned int cmd, unsigned long arg)
 
         ifr = ifc.ifc_req;
         ifr32 = compat_ptr(ifc32.ifcbuf);
-        for (i = 0, j = 0; i < ifc32.ifc_len && j < ifc.ifc_len;
+        for (i = 0, j = 0;
+             i + sizeof (struct ifreq32) < ifc32.ifc_len && j < ifc.ifc_len;
              i += sizeof (struct ifreq32), j += sizeof (struct ifreq)) {
                 if (copy_in_user(ifr32, ifr, sizeof (struct ifreq32)))
                         return -EFAULT;
@@ -548,10 +462,7 @@ static int dev_ifconf(unsigned int fd, unsigned int cmd, unsigned long arg)
                 i = ((i / sizeof(struct ifreq)) * sizeof(struct ifreq32));
                 ifc32.ifc_len = i;
         } else {
-                if (i <= ifc32.ifc_len)
-                        ifc32.ifc_len = i;
-                else
-                        ifc32.ifc_len = i - sizeof (struct ifreq32);
+                ifc32.ifc_len = i;
         }
         if (copy_to_user(compat_ptr(arg), &ifc32, sizeof(struct ifconf32)))
                 return -EFAULT;
@@ -1006,6 +917,40 @@ static int sg_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
         return err;
 }
 
+struct compat_sg_req_info { /* used by SG_GET_REQUEST_TABLE ioctl() */
+        char req_state;
+        char orphan;
+        char sg_io_owned;
+        char problem;
+        int pack_id;
+        compat_uptr_t usr_ptr;
+        unsigned int duration;
+        int unused;
+};
+
+static int sg_grt_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
+{
+        int err, i;
+        sg_req_info_t *r;
+        struct compat_sg_req_info *o = (struct compat_sg_req_info *)arg;
+        r = compat_alloc_user_space(sizeof(sg_req_info_t)*SG_MAX_QUEUE);
+        err = sys_ioctl(fd,cmd,(unsigned long)r);
+        if (err < 0)
+                return err;
+        for (i = 0; i < SG_MAX_QUEUE; i++) {
+                void __user *ptr;
+                int d;
+
+                if (copy_in_user(o + i, r + i, offsetof(sg_req_info_t, usr_ptr)) ||
+                    get_user(ptr, &r[i].usr_ptr) ||
+                    get_user(d, &r[i].duration) ||
+                    put_user((u32)(unsigned long)(ptr), &o[i].usr_ptr) ||
+                    put_user(d, &o[i].duration))
+                        return -EFAULT;
+        }
+        return err;
+}
+
 struct sock_fprog32 {
         unsigned short  len;
         compat_caddr_t  filter;
@@ -2561,6 +2506,49 @@ static int old_bridge_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg
         return -EINVAL;
 }
 
+#define RTC_IRQP_READ32         _IOR('p', 0x0b, compat_ulong_t)
+#define RTC_IRQP_SET32          _IOW('p', 0x0c, compat_ulong_t)
+#define RTC_EPOCH_READ32        _IOR('p', 0x0d, compat_ulong_t)
+#define RTC_EPOCH_SET32         _IOW('p', 0x0e, compat_ulong_t)
+
+static int rtc_ioctl(unsigned fd, unsigned cmd, unsigned long arg)
+{
+        mm_segment_t oldfs = get_fs();
+        compat_ulong_t val32;
+        unsigned long kval;
+        int ret;
+
+        switch (cmd) {
+        case RTC_IRQP_READ32:
+        case RTC_EPOCH_READ32:
+                set_fs(KERNEL_DS);
+                ret = sys_ioctl(fd, (cmd == RTC_IRQP_READ32) ?
+                                        RTC_IRQP_READ : RTC_EPOCH_READ,
+                                        (unsigned long)&kval);
+                set_fs(oldfs);
+                if (ret)
+                        return ret;
+                val32 = kval;
+                return put_user(val32, (unsigned int __user *)arg);
+        case RTC_IRQP_SET32:
+        case RTC_EPOCH_SET32:
+                ret = get_user(val32, (unsigned int __user *)arg);
+                if (ret)
+                        return ret;
+                kval = val32;
+
+                set_fs(KERNEL_DS);
+                ret = sys_ioctl(fd, (cmd == RTC_IRQP_SET32) ?
+                                RTC_IRQP_SET : RTC_EPOCH_SET,
+                                (unsigned long)&kval);
+                set_fs(oldfs);
+                return ret;
+        default:
+                /* unreached */
+                return -ENOIOCTLCMD;
+        }
+}
+
 #if defined(CONFIG_NCP_FS) || defined(CONFIG_NCP_FS_MODULE)
 struct ncp_ioctl_request_32 {
         u32 function;
@@ -2748,10 +2736,34 @@ static int do_ncp_setprivatedata(unsigned int fd, unsigned int cmd, unsigned lon
 }
 #endif
 
-#undef CODE
-#endif
+static int
+lp_timeout_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
+{
+        struct compat_timeval *tc = (struct compat_timeval *)arg;
+        struct timeval *tn = compat_alloc_user_space(sizeof(struct timeval));
+        struct timeval ts;
+        if (get_user(ts.tv_sec, &tc->tv_sec) ||
+            get_user(ts.tv_usec, &tc->tv_usec) ||
+            put_user(ts.tv_sec, &tn->tv_sec) ||
+            put_user(ts.tv_usec, &tn->tv_usec))
+                return -EFAULT;
+        return sys_ioctl(fd, cmd, (unsigned long)tn);
+}
 
-#ifdef DECLARES
+#define HANDLE_IOCTL(cmd,handler) \
+        { (cmd), (ioctl_trans_handler_t)(handler) },
+
+/* pointer to compatible structure or no argument */
+#define COMPATIBLE_IOCTL(cmd) \
+        { (cmd), do_ioctl32_pointer },
+
+/* argument is an unsigned long integer, not a pointer */
+#define ULONG_IOCTL(cmd) \
+        { (cmd), (ioctl_trans_handler_t)sys_ioctl },
+
+
+struct ioctl_trans ioctl_start[] = {
+#include <linux/compat_ioctl.h>
 HANDLE_IOCTL(MEMREADOOB32, mtd_rw_oob)
 HANDLE_IOCTL(MEMWRITEOOB32, mtd_rw_oob)
 #ifdef CONFIG_NET
@@ -2831,6 +2843,7 @@ HANDLE_IOCTL(FDPOLLDRVSTAT32, fd_ioctl_trans)
 HANDLE_IOCTL(FDGETFDCSTAT32, fd_ioctl_trans)
 HANDLE_IOCTL(FDWERRORGET32, fd_ioctl_trans)
 HANDLE_IOCTL(SG_IO,sg_ioctl_trans)
+HANDLE_IOCTL(SG_GET_REQUEST_TABLE, sg_grt_trans)
 HANDLE_IOCTL(PPPIOCGIDLE32, ppp_ioctl_trans)
 HANDLE_IOCTL(PPPIOCSCOMPRESS32, ppp_ioctl_trans)
 HANDLE_IOCTL(PPPIOCSPASS32, ppp_sock_fprog_ioctl_trans)
@@ -2854,14 +2867,15 @@ HANDLE_IOCTL(EXT2_IOC32_GETFLAGS, do_ext2_ioctl)
 HANDLE_IOCTL(EXT2_IOC32_SETFLAGS, do_ext2_ioctl)
 HANDLE_IOCTL(EXT2_IOC32_GETVERSION, do_ext2_ioctl)
 HANDLE_IOCTL(EXT2_IOC32_SETVERSION, do_ext2_ioctl)
-HANDLE_IOCTL(VIDIOCGTUNER32, do_video_ioctl)
-HANDLE_IOCTL(VIDIOCSTUNER32, do_video_ioctl)
-HANDLE_IOCTL(VIDIOCGWIN32, do_video_ioctl)
-HANDLE_IOCTL(VIDIOCSWIN32, do_set_window)
-HANDLE_IOCTL(VIDIOCGFBUF32, do_video_ioctl)
-HANDLE_IOCTL(VIDIOCSFBUF32, do_video_ioctl)
-HANDLE_IOCTL(VIDIOCGFREQ32, do_video_ioctl)
-HANDLE_IOCTL(VIDIOCSFREQ32, do_video_ioctl)
+HANDLE_IOCTL(EXT3_IOC32_GETVERSION, do_ext3_ioctl)
+HANDLE_IOCTL(EXT3_IOC32_SETVERSION, do_ext3_ioctl)
+HANDLE_IOCTL(EXT3_IOC32_GETRSVSZ, do_ext3_ioctl)
+HANDLE_IOCTL(EXT3_IOC32_SETRSVSZ, do_ext3_ioctl)
+HANDLE_IOCTL(EXT3_IOC32_GROUP_EXTEND, do_ext3_ioctl)
+COMPATIBLE_IOCTL(EXT3_IOC_GROUP_ADD)
+#ifdef CONFIG_JBD_DEBUG
+HANDLE_IOCTL(EXT3_IOC32_WAIT_FOR_READONLY, do_ext3_ioctl)
+#endif
 /* One SMB ioctl needs translations. */
 #define SMB_IOC_GETMOUNTUID_32 _IOR('u', 1, compat_uid_t)
 HANDLE_IOCTL(SMB_IOC_GETMOUNTUID_32, do_smb_getmountuid)
@@ -2943,6 +2957,10 @@ HANDLE_IOCTL(SIOCSIWENCODE, do_wireless_ioctl)
 HANDLE_IOCTL(SIOCGIWENCODE, do_wireless_ioctl)
 HANDLE_IOCTL(SIOCSIFBR, old_bridge_ioctl)
 HANDLE_IOCTL(SIOCGIFBR, old_bridge_ioctl)
+HANDLE_IOCTL(RTC_IRQP_READ32, rtc_ioctl)
+HANDLE_IOCTL(RTC_IRQP_SET32, rtc_ioctl)
+HANDLE_IOCTL(RTC_EPOCH_READ32, rtc_ioctl)
+HANDLE_IOCTL(RTC_EPOCH_SET32, rtc_ioctl)
 
 #if defined(CONFIG_NCP_FS) || defined(CONFIG_NCP_FS_MODULE)
 HANDLE_IOCTL(NCP_IOC_NCPREQUEST_32, do_ncp_ncprequest)
@@ -2954,5 +2972,25 @@ HANDLE_IOCTL(NCP_IOC_GETPRIVATEDATA_32, do_ncp_getprivatedata)
 HANDLE_IOCTL(NCP_IOC_SETPRIVATEDATA_32, do_ncp_setprivatedata)
 #endif
 
-#undef DECLARES
-#endif
+/* dvb */
+HANDLE_IOCTL(DMX_GET_EVENT, do_dmx_get_event)
+HANDLE_IOCTL(VIDEO_GET_EVENT, do_video_get_event)
+HANDLE_IOCTL(VIDEO_STILLPICTURE, do_video_stillpicture)
+HANDLE_IOCTL(VIDEO_SET_SPU_PALETTE, do_video_set_spu_palette)
+
+/* parport */
+COMPATIBLE_IOCTL(LPTIME)
+COMPATIBLE_IOCTL(LPCHAR)
+COMPATIBLE_IOCTL(LPABORTOPEN)
+COMPATIBLE_IOCTL(LPCAREFUL)
+COMPATIBLE_IOCTL(LPWAIT)
+COMPATIBLE_IOCTL(LPSETIRQ)
+COMPATIBLE_IOCTL(LPGETSTATUS)
+COMPATIBLE_IOCTL(LPGETSTATUS)
+COMPATIBLE_IOCTL(LPRESET)
+/*LPGETSTATS not implemented, but no kernels seem to compile it in anyways*/
+COMPATIBLE_IOCTL(LPGETFLAGS)
+HANDLE_IOCTL(LPSETTIMEOUT, lp_timeout_trans)
+};
+
+int ioctl_table_size = ARRAY_SIZE(ioctl_start);