[IA64] regset: 32-bit support

This is the 32-bit regset implementation under IA64. Basically register
read/write, which is derived from current ptrace register read/write.
This version added TLS support.

Signed-off-by: Shaohua Li <shaohua.li@intel.com>
Signed-off-by: Tony Luck <tony.luck@intel.com>

2 files changed, 629 insertions, 25 deletions

diff --git a/arch/ia64/ia32/sys_ia32.c b/arch/ia64/ia32/sys_ia32.c
index b1bf51fe97b4..7e028ceb93ba 100644
--- a/arch/ia64/ia32/sys_ia32.c
+++ b/arch/ia64/ia32/sys_ia32.c
@@ -38,6 +38,7 @@
 #include <linux/eventpoll.h>
 #include <linux/personality.h>
 #include <linux/ptrace.h>
+#include <linux/regset.h>
 #include <linux/stat.h>
 #include <linux/ipc.h>
 #include <linux/capability.h>
@@ -2387,16 +2388,45 @@ get_free_idx (void)
         return -ESRCH;
 }
 
+static void set_tls_desc(struct task_struct *p, int idx,
+                const struct ia32_user_desc *info, int n)
+{
+        struct thread_struct *t = &p->thread;
+        struct desc_struct *desc = &t->tls_array[idx - GDT_ENTRY_TLS_MIN];
+        int cpu;
+
+        /*
+         * We must not get preempted while modifying the TLS.
+         */
+        cpu = get_cpu();
+
+        while (n-- > 0) {
+                if (LDT_empty(info)) {
+                        desc->a = 0;
+                        desc->b = 0;
+                } else {
+                        desc->a = LDT_entry_a(info);
+                        desc->b = LDT_entry_b(info);
+                }
+
+                ++info;
+                ++desc;
+        }
+
+        if (t == &current->thread)
+                load_TLS(t, cpu);
+
+        put_cpu();
+}
+
 /*
  * Set a given TLS descriptor:
  */
 asmlinkage int
 sys32_set_thread_area (struct ia32_user_desc __user *u_info)
 {
-        struct thread_struct *t = &current->thread;
         struct ia32_user_desc info;
-        struct desc_struct *desc;
-        int cpu, idx;
+        int idx;
 
         if (copy_from_user(&info, u_info, sizeof(info)))
                 return -EFAULT;
@@ -2416,18 +2446,7 @@ sys32_set_thread_area (struct ia32_user_desc __user *u_info)
         if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
                 return -EINVAL;
 
-        desc = t->tls_array + idx - GDT_ENTRY_TLS_MIN;
-
-        cpu = smp_processor_id();
-
-        if (LDT_empty(&info)) {
-                desc->a = 0;
-                desc->b = 0;
-        } else {
-                desc->a = LDT_entry_a(&info);
-                desc->b = LDT_entry_b(&info);
-        }
-        load_TLS(t, cpu);
+        set_tls_desc(current, idx, &info, 1);
         return 0;
 }
 
@@ -2451,6 +2470,20 @@ sys32_set_thread_area (struct ia32_user_desc __user *u_info)
 #define GET_PRESENT(desc)       (((desc)->b >> 15) & 1)
 #define GET_USEABLE(desc)       (((desc)->b >> 20) & 1)
 
+static void fill_user_desc(struct ia32_user_desc *info, int idx,
+                const struct desc_struct *desc)
+{
+        info->entry_number = idx;
+        info->base_addr = GET_BASE(desc);
+        info->limit = GET_LIMIT(desc);
+        info->seg_32bit = GET_32BIT(desc);
+        info->contents = GET_CONTENTS(desc);
+        info->read_exec_only = !GET_WRITABLE(desc);
+        info->limit_in_pages = GET_LIMIT_PAGES(desc);
+        info->seg_not_present = !GET_PRESENT(desc);
+        info->useable = GET_USEABLE(desc);
+}
+
 asmlinkage int
 sys32_get_thread_area (struct ia32_user_desc __user *u_info)
 {
@@ -2464,22 +2497,588 @@ sys32_get_thread_area (struct ia32_user_desc __user *u_info)
                 return -EINVAL;
 
         desc = current->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
-
-        info.entry_number = idx;
-        info.base_addr = GET_BASE(desc);
-        info.limit = GET_LIMIT(desc);
-        info.seg_32bit = GET_32BIT(desc);
-        info.contents = GET_CONTENTS(desc);
-        info.read_exec_only = !GET_WRITABLE(desc);
-        info.limit_in_pages = GET_LIMIT_PAGES(desc);
-        info.seg_not_present = !GET_PRESENT(desc);
-        info.useable = GET_USEABLE(desc);
+        fill_user_desc(&info, idx, desc);
 
         if (copy_to_user(u_info, &info, sizeof(info)))
                 return -EFAULT;
         return 0;
 }
 
+struct regset_get {
+        void *kbuf;
+        void __user *ubuf;
+};
+
+struct regset_set {
+        const void *kbuf;
+        const void __user *ubuf;
+};
+
+struct regset_getset {
+        struct task_struct *target;
+        const struct user_regset *regset;
+        union {
+                struct regset_get get;
+                struct regset_set set;
+        } u;
+        unsigned int pos;
+        unsigned int count;
+        int ret;
+};
+
+static void getfpreg(struct task_struct *task, int regno, int *val)
+{
+        switch (regno / sizeof(int)) {
+        case 0:
+                *val = task->thread.fcr & 0xffff;
+                break;
+        case 1:
+                *val = task->thread.fsr & 0xffff;
+                break;
+        case 2:
+                *val = (task->thread.fsr>>16) & 0xffff;
+                break;
+        case 3:
+                *val = task->thread.fir;
+                break;
+        case 4:
+                *val = (task->thread.fir>>32) & 0xffff;
+                break;
+        case 5:
+                *val = task->thread.fdr;
+                break;
+        case 6:
+                *val = (task->thread.fdr >> 32) & 0xffff;
+                break;
+        }
+}
+
+static void setfpreg(struct task_struct *task, int regno, int val)
+{
+        switch (regno / sizeof(int)) {
+        case 0:
+                task->thread.fcr = (task->thread.fcr & (~0x1f3f))
+                        | (val & 0x1f3f);
+                break;
+        case 1:
+                task->thread.fsr = (task->thread.fsr & (~0xffff)) | val;
+                break;
+        case 2:
+                task->thread.fsr = (task->thread.fsr & (~0xffff0000))
+                        | (val << 16);
+                break;
+        case 3:
+                task->thread.fir = (task->thread.fir & (~0xffffffff)) | val;
+                break;
+        case 5:
+                task->thread.fdr = (task->thread.fdr & (~0xffffffff)) | val;
+                break;
+        }
+}
+
+static void access_fpreg_ia32(int regno, void *reg,
+                struct pt_regs *pt, struct switch_stack *sw,
+                int tos, int write)
+{
+        void *f;
+
+        if ((regno += tos) >= 8)
+                regno -= 8;
+        if (regno < 4)
+                f = &pt->f8 + regno;
+        else if (regno <= 7)
+                f = &sw->f12 + (regno - 4);
+        else {
+                printk(KERN_ERR "regno must be less than 7 \n");
+                 return;
+        }
+
+        if (write)
+                memcpy(f, reg, sizeof(struct _fpreg_ia32));
+        else
+                memcpy(reg, f, sizeof(struct _fpreg_ia32));
+}
+
+static void do_fpregs_get(struct unw_frame_info *info, void *arg)
+{
+        struct regset_getset *dst = arg;
+        struct task_struct *task = dst->target;
+        struct pt_regs *pt;
+        int start, end, tos;
+        char buf[80];
+
+        if (dst->count == 0 || unw_unwind_to_user(info) < 0)
+                return;
+        if (dst->pos < 7 * sizeof(int)) {
+                end = min((dst->pos + dst->count),
+                        (unsigned int)(7 * sizeof(int)));
+                for (start = dst->pos; start < end; start += sizeof(int))
+                        getfpreg(task, start, (int *)(buf + start));
+                dst->ret = user_regset_copyout(&dst->pos, &dst->count,
+                                &dst->u.get.kbuf, &dst->u.get.ubuf, buf,
+                                0, 7 * sizeof(int));
+                if (dst->ret || dst->count == 0)
+                        return;
+        }
+        if (dst->pos < sizeof(struct ia32_user_i387_struct)) {
+                pt = task_pt_regs(task);
+                tos = (task->thread.fsr >> 11) & 7;
+                end = min(dst->pos + dst->count,
+                        (unsigned int)(sizeof(struct ia32_user_i387_struct)));
+                start = (dst->pos - 7 * sizeof(int)) /
+                        sizeof(struct _fpreg_ia32);
+                end = (end - 7 * sizeof(int)) / sizeof(struct _fpreg_ia32);
+                for (; start < end; start++)
+                        access_fpreg_ia32(start,
+                                (struct _fpreg_ia32 *)buf + start,
+                                pt, info->sw, tos, 0);
+                dst->ret = user_regset_copyout(&dst->pos, &dst->count,
+                                &dst->u.get.kbuf, &dst->u.get.ubuf,
+                                buf, 7 * sizeof(int),
+                                sizeof(struct ia32_user_i387_struct));
+                if (dst->ret || dst->count == 0)
+                        return;
+        }
+}
+
+static void do_fpregs_set(struct unw_frame_info *info, void *arg)
+{
+        struct regset_getset *dst = arg;
+        struct task_struct *task = dst->target;
+        struct pt_regs *pt;
+        char buf[80];
+        int end, start, tos;
+
+        if (dst->count == 0 || unw_unwind_to_user(info) < 0)
+                return;
+
+        if (dst->pos < 7 * sizeof(int)) {
+                start = dst->pos;
+                dst->ret = user_regset_copyin(&dst->pos, &dst->count,
+                                &dst->u.set.kbuf, &dst->u.set.ubuf, buf,
+                                0, 7 * sizeof(int));
+                if (dst->ret)
+                        return;
+                for (; start < dst->pos; start += sizeof(int))
+                        setfpreg(task, start, *((int *)(buf + start)));
+                if (dst->count == 0)
+                        return;
+        }
+        if (dst->pos < sizeof(struct ia32_user_i387_struct)) {
+                start = (dst->pos - 7 * sizeof(int)) /
+                        sizeof(struct _fpreg_ia32);
+                dst->ret = user_regset_copyin(&dst->pos, &dst->count,
+                                &dst->u.set.kbuf, &dst->u.set.ubuf,
+                                buf, 7 * sizeof(int),
+                                sizeof(struct ia32_user_i387_struct));
+                if (dst->ret)
+                        return;
+                pt = task_pt_regs(task);
+                tos = (task->thread.fsr >> 11) & 7;
+                end = (dst->pos - 7 * sizeof(int)) / sizeof(struct _fpreg_ia32);
+                for (; start < end; start++)
+                        access_fpreg_ia32(start,
+                                (struct _fpreg_ia32 *)buf + start,
+                                pt, info->sw, tos, 1);
+                if (dst->count == 0)
+                        return;
+        }
+}
+
+#define OFFSET(member) ((int)(offsetof(struct ia32_user_fxsr_struct, member)))
+static void getfpxreg(struct task_struct *task, int start, int end, char *buf)
+{
+        int min_val;
+
+        min_val = min(end, OFFSET(fop));
+        while (start < min_val) {
+                if (start == OFFSET(cwd))
+                        *((short *)buf) = task->thread.fcr & 0xffff;
+                else if (start == OFFSET(swd))
+                        *((short *)buf) = task->thread.fsr & 0xffff;
+                else if (start == OFFSET(twd))
+                        *((short *)buf) = (task->thread.fsr>>16) & 0xffff;
+                buf += 2;
+                start += 2;
+        }
+        /* skip fop element */
+        if (start == OFFSET(fop)) {
+                start += 2;
+                buf += 2;
+        }
+        while (start < end) {
+                if (start == OFFSET(fip))
+                        *((int *)buf) = task->thread.fir;
+                else if (start == OFFSET(fcs))
+                        *((int *)buf) = (task->thread.fir>>32) & 0xffff;
+                else if (start == OFFSET(foo))
+                        *((int *)buf) = task->thread.fdr;
+                else if (start == OFFSET(fos))
+                        *((int *)buf) = (task->thread.fdr>>32) & 0xffff;
+                else if (start == OFFSET(mxcsr))
+                        *((int *)buf) = ((task->thread.fcr>>32) & 0xff80)
+                                         | ((task->thread.fsr>>32) & 0x3f);
+                buf += 4;
+                start += 4;
+        }
+}
+
+static void setfpxreg(struct task_struct *task, int start, int end, char *buf)
+{
+        int min_val, num32;
+        short num;
+        unsigned long num64;
+
+        min_val = min(end, OFFSET(fop));
+        while (start < min_val) {
+                num = *((short *)buf);
+                if (start == OFFSET(cwd)) {
+                        task->thread.fcr = (task->thread.fcr & (~0x1f3f))
+                                                | (num & 0x1f3f);
+                } else if (start == OFFSET(swd)) {
+                        task->thread.fsr = (task->thread.fsr & (~0xffff)) | num;
+                } else if (start == OFFSET(twd)) {
+                        task->thread.fsr = (task->thread.fsr & (~0xffff0000))
+                                | (((int)num) << 16);
+                }
+                buf += 2;
+                start += 2;
+        }
+        /* skip fop element */
+        if (start == OFFSET(fop)) {
+                start += 2;
+                buf += 2;
+        }
+        while (start < end) {
+                num32 = *((int *)buf);
+                if (start == OFFSET(fip))
+                        task->thread.fir = (task->thread.fir & (~0xffffffff))
+                                                 | num32;
+                else if (start == OFFSET(foo))
+                        task->thread.fdr = (task->thread.fdr & (~0xffffffff))
+                                                 | num32;
+                else if (start == OFFSET(mxcsr)) {
+                        num64 = num32 & 0xff10;
+                        task->thread.fcr = (task->thread.fcr &
+                                (~0xff1000000000UL)) | (num64<<32);
+                        num64 = num32 & 0x3f;
+                        task->thread.fsr = (task->thread.fsr &
+                                (~0x3f00000000UL)) | (num64<<32);
+                }
+                buf += 4;
+                start += 4;
+        }
+}
+
+static void do_fpxregs_get(struct unw_frame_info *info, void *arg)
+{
+        struct regset_getset *dst = arg;
+        struct task_struct *task = dst->target;
+        struct pt_regs *pt;
+        char buf[128];
+        int start, end, tos;
+
+        if (dst->count == 0 || unw_unwind_to_user(info) < 0)
+                return;
+        if (dst->pos < OFFSET(st_space[0])) {
+                end = min(dst->pos + dst->count, (unsigned int)32);
+                getfpxreg(task, dst->pos, end, buf);
+                dst->ret = user_regset_copyout(&dst->pos, &dst->count,
+                                &dst->u.get.kbuf, &dst->u.get.ubuf, buf,
+                                0, OFFSET(st_space[0]));
+                if (dst->ret || dst->count == 0)
+                        return;
+        }
+        if (dst->pos < OFFSET(xmm_space[0])) {
+                pt = task_pt_regs(task);
+                tos = (task->thread.fsr >> 11) & 7;
+                end = min(dst->pos + dst->count,
+                                (unsigned int)OFFSET(xmm_space[0]));
+                start = (dst->pos - OFFSET(st_space[0])) / 16;
+                end = (end - OFFSET(st_space[0])) / 16;
+                for (; start < end; start++)
+                        access_fpreg_ia32(start, buf + 16 * start, pt,
+                                                info->sw, tos, 0);
+                dst->ret = user_regset_copyout(&dst->pos, &dst->count,
+                                &dst->u.get.kbuf, &dst->u.get.ubuf,
+                                buf, OFFSET(st_space[0]), OFFSET(xmm_space[0]));
+                if (dst->ret || dst->count == 0)
+                        return;
+        }
+        if (dst->pos < OFFSET(padding[0]))
+                dst->ret = user_regset_copyout(&dst->pos, &dst->count,
+                                &dst->u.get.kbuf, &dst->u.get.ubuf,
+                                &info->sw->f16, OFFSET(xmm_space[0]),
+                                OFFSET(padding[0]));
+}
+
+static void do_fpxregs_set(struct unw_frame_info *info, void *arg)
+{
+        struct regset_getset *dst = arg;
+        struct task_struct *task = dst->target;
+        char buf[128];
+        int start, end;
+
+        if (dst->count == 0 || unw_unwind_to_user(info) < 0)
+                return;
+
+        if (dst->pos < OFFSET(st_space[0])) {
+                start = dst->pos;
+                dst->ret = user_regset_copyin(&dst->pos, &dst->count,
+                                &dst->u.set.kbuf, &dst->u.set.ubuf,
+                                buf, 0, OFFSET(st_space[0]));
+                if (dst->ret)
+                        return;
+                setfpxreg(task, start, dst->pos, buf);
+                if (dst->count == 0)
+                        return;
+        }
+        if (dst->pos < OFFSET(xmm_space[0])) {
+                struct pt_regs *pt;
+                int tos;
+                pt = task_pt_regs(task);
+                tos = (task->thread.fsr >> 11) & 7;
+                start = (dst->pos - OFFSET(st_space[0])) / 16;
+                dst->ret = user_regset_copyin(&dst->pos, &dst->count,
+                                &dst->u.set.kbuf, &dst->u.set.ubuf,
+                                buf, OFFSET(st_space[0]), OFFSET(xmm_space[0]));
+                if (dst->ret)
+                        return;
+                end = (dst->pos - OFFSET(st_space[0])) / 16;
+                for (; start < end; start++)
+                        access_fpreg_ia32(start, buf + 16 * start, pt, info->sw,
+                                                 tos, 1);
+                if (dst->count == 0)
+                        return;
+        }
+        if (dst->pos < OFFSET(padding[0]))
+                dst->ret = user_regset_copyin(&dst->pos, &dst->count,
+                                &dst->u.set.kbuf, &dst->u.set.ubuf,
+                                &info->sw->f16, OFFSET(xmm_space[0]),
+                                 OFFSET(padding[0]));
+}
+#undef OFFSET
+
+static int do_regset_call(void (*call)(struct unw_frame_info *, void *),
+                struct task_struct *target,
+                const struct user_regset *regset,
+                unsigned int pos, unsigned int count,
+                const void *kbuf, const void __user *ubuf)
+{
+        struct regset_getset info = { .target = target, .regset = regset,
+                .pos = pos, .count = count,
+                .u.set = { .kbuf = kbuf, .ubuf = ubuf },
+                .ret = 0 };
+
+        if (target == current)
+                unw_init_running(call, &info);
+        else {
+                struct unw_frame_info ufi;
+                memset(&ufi, 0, sizeof(ufi));
+                unw_init_from_blocked_task(&ufi, target);
+                (*call)(&ufi, &info);
+        }
+
+        return info.ret;
+}
+
+static int ia32_fpregs_get(struct task_struct *target,
+                const struct user_regset *regset,
+                unsigned int pos, unsigned int count,
+                void *kbuf, void __user *ubuf)
+{
+        return do_regset_call(do_fpregs_get, target, regset, pos, count,
+                kbuf, ubuf);
+}
+
+static int ia32_fpregs_set(struct task_struct *target,
+                const struct user_regset *regset,
+                unsigned int pos, unsigned int count,
+                const void *kbuf, const void __user *ubuf)
+{
+        return do_regset_call(do_fpregs_set, target, regset, pos, count,
+                kbuf, ubuf);
+}
+
+static int ia32_fpxregs_get(struct task_struct *target,
+                const struct user_regset *regset,
+                unsigned int pos, unsigned int count,
+                void *kbuf, void __user *ubuf)
+{
+        return do_regset_call(do_fpxregs_get, target, regset, pos, count,
+                kbuf, ubuf);
+}
+
+static int ia32_fpxregs_set(struct task_struct *target,
+                const struct user_regset *regset,
+                unsigned int pos, unsigned int count,
+                const void *kbuf, const void __user *ubuf)
+{
+        return do_regset_call(do_fpxregs_set, target, regset, pos, count,
+                kbuf, ubuf);
+}
+
+static int ia32_genregs_get(struct task_struct *target,
+                const struct user_regset *regset,
+                unsigned int pos, unsigned int count,
+                void *kbuf, void __user *ubuf)
+{
+        if (kbuf) {
+                u32 *kp = kbuf;
+                while (count > 0) {
+                        *kp++ = getreg(target, pos);
+                        pos += 4;
+                        count -= 4;
+                }
+        } else {
+                u32 __user *up = ubuf;
+                while (count > 0) {
+                        if (__put_user(getreg(target, pos), up++))
+                                return -EFAULT;
+                        pos += 4;
+                        count -= 4;
+                }
+        }
+        return 0;
+}
+
+static int ia32_genregs_set(struct task_struct *target,
+                const struct user_regset *regset,
+                unsigned int pos, unsigned int count,
+                const void *kbuf, const void __user *ubuf)
+{
+        int ret = 0;
+
+        if (kbuf) {
+                const u32 *kp = kbuf;
+                while (!ret && count > 0) {
+                        putreg(target, pos, *kp++);
+                        pos += 4;
+                        count -= 4;
+                }
+        } else {
+                const u32 __user *up = ubuf;
+                u32 val;
+                while (!ret && count > 0) {
+                        ret = __get_user(val, up++);
+                        if (!ret)
+                                putreg(target, pos, val);
+                        pos += 4;
+                        count -= 4;
+                }
+        }
+        return ret;
+}
+
+static int ia32_tls_active(struct task_struct *target,
+                const struct user_regset *regset)
+{
+        struct thread_struct *t = &target->thread;
+        int n = GDT_ENTRY_TLS_ENTRIES;
+        while (n > 0 && desc_empty(&t->tls_array[n -1]))
+                --n;
+        return n;
+}
+
+static int ia32_tls_get(struct task_struct *target,
+                const struct user_regset *regset, unsigned int pos,
+                unsigned int count, void *kbuf, void __user *ubuf)
+{
+        const struct desc_struct *tls;
+
+        if (pos > GDT_ENTRY_TLS_ENTRIES * sizeof(struct ia32_user_desc) ||
+                        (pos % sizeof(struct ia32_user_desc)) != 0 ||
+                        (count % sizeof(struct ia32_user_desc)) != 0)
+                return -EINVAL;
+
+        pos /= sizeof(struct ia32_user_desc);
+        count /= sizeof(struct ia32_user_desc);
+
+        tls = &target->thread.tls_array[pos];
+
+        if (kbuf) {
+                struct ia32_user_desc *info = kbuf;
+                while (count-- > 0)
+                        fill_user_desc(info++, GDT_ENTRY_TLS_MIN + pos++,
+                                        tls++);
+        } else {
+                struct ia32_user_desc __user *u_info = ubuf;
+                while (count-- > 0) {
+                        struct ia32_user_desc info;
+                        fill_user_desc(&info, GDT_ENTRY_TLS_MIN + pos++, tls++);
+                        if (__copy_to_user(u_info++, &info, sizeof(info)))
+                                return -EFAULT;
+                }
+        }
+
+        return 0;
+}
+
+static int ia32_tls_set(struct task_struct *target,
+                const struct user_regset *regset, unsigned int pos,
+                unsigned int count, const void *kbuf, const void __user *ubuf)
+{
+        struct ia32_user_desc infobuf[GDT_ENTRY_TLS_ENTRIES];
+        const struct ia32_user_desc *info;
+
+        if (pos > GDT_ENTRY_TLS_ENTRIES * sizeof(struct ia32_user_desc) ||
+                        (pos % sizeof(struct ia32_user_desc)) != 0 ||
+                        (count % sizeof(struct ia32_user_desc)) != 0)
+                return -EINVAL;
+
+        if (kbuf)
+                info = kbuf;
+        else if (__copy_from_user(infobuf, ubuf, count))
+                return -EFAULT;
+        else
+                info = infobuf;
+
+        set_tls_desc(target,
+                GDT_ENTRY_TLS_MIN + (pos / sizeof(struct ia32_user_desc)),
+                info, count / sizeof(struct ia32_user_desc));
+
+        return 0;
+}
+
+/*
+ * This should match arch/i386/kernel/ptrace.c:native_regsets.
+ * XXX ioperm? vm86?
+ */
+static const struct user_regset ia32_regsets[] = {
+        {
+                .core_note_type = NT_PRSTATUS,
+                .n = sizeof(struct user_regs_struct32)/4,
+                .size = 4, .align = 4,
+                .get = ia32_genregs_get, .set = ia32_genregs_set
+        },
+        {
+                .core_note_type = NT_PRFPREG,
+                .n = sizeof(struct ia32_user_i387_struct) / 4,
+                .size = 4, .align = 4,
+                .get = ia32_fpregs_get, .set = ia32_fpregs_set
+        },
+        {
+                .core_note_type = NT_PRXFPREG,
+                .n = sizeof(struct ia32_user_fxsr_struct) / 4,
+                .size = 4, .align = 4,
+                .get = ia32_fpxregs_get, .set = ia32_fpxregs_set
+        },
+        {
+                .core_note_type = NT_386_TLS,
+                .n = GDT_ENTRY_TLS_ENTRIES,
+                .bias = GDT_ENTRY_TLS_MIN,
+                .size = sizeof(struct ia32_user_desc),
+                .align = sizeof(struct ia32_user_desc),
+                .active = ia32_tls_active,
+                .get = ia32_tls_get, .set = ia32_tls_set,
+        },
+};
+
+const struct user_regset_view user_ia32_view = {
+        .name = "i386", .e_machine = EM_386,
+        .regsets = ia32_regsets, .n = ARRAY_SIZE(ia32_regsets)
+};
+
 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high, 
                         __u32 len_low, __u32 len_high, int advice)
 { 
diff --git a/arch/ia64/kernel/ptrace.c b/arch/ia64/kernel/ptrace.c
index 7136c7811efc..4c104170ca4d 100644
--- a/arch/ia64/kernel/ptrace.c
+++ b/arch/ia64/kernel/ptrace.c
@@ -2314,5 +2314,10 @@ static const struct user_regset_view user_ia64_view = {
 
 const struct user_regset_view *task_user_regset_view(struct task_struct *tsk)
 {
+#ifdef CONFIG_IA32_SUPPORT
+        extern const struct user_regset_view user_ia32_view;
+        if (IS_IA32_PROCESS(task_pt_regs(tsk)))
+                return &user_ia32_view;
+#endif
         return &user_ia64_view;
 }