int bpt_nsaved;
        unsigned long bpt_addr[2];              /* breakpoint handling  */
        unsigned int bpt_insn[2];
-
-       struct restart_block    restart_block;
 };
 
 /*
        .exec_domain    = &default_exec_domain, \
        .addr_limit     = KERNEL_DS,            \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        struct switch_stack *sw = (struct switch_stack *)regs - 1;
        long i, err = __get_user(regs->pc, &sc->sc_pc);
 
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        sw->r26 = (unsigned long) ret_from_sys_call;
 
 
        struct exec_domain *exec_domain;/* execution domain */
        __u32 cpu;                      /* current CPU */
        unsigned long thr_ptr;          /* TLS ptr */
-       struct restart_block restart_block;
 };
 
 /*
        .cpu        = 0,                        \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit = KERNEL_DS,                \
-       .restart_block  = {                     \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info    (init_thread_union.thread_info)
 
        struct pt_regs *regs = current_pt_regs();
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /* Since we stacked the signal on a word boundary,
         * then 'sp' should be word aligned here.  If it's
 
 #ifdef CONFIG_ARM_THUMBEE
        unsigned long           thumbee_state;  /* ThumbEE Handler Base register */
 #endif
-       struct restart_block    restart_block;
 };
 
 #define INIT_THREAD_INFO(tsk)                                          \
        .cpu_domain     = domain_val(DOMAIN_USER, DOMAIN_MANAGER) |     \
                          domain_val(DOMAIN_KERNEL, DOMAIN_MANAGER) |   \
                          domain_val(DOMAIN_IO, DOMAIN_CLIENT),         \
-       .restart_block  = {                                             \
-               .fn     = do_no_restart_syscall,                        \
-       },                                                              \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        struct sigframe __user *frame;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Since we stacked the signal on a 64-bit boundary,
        struct rt_sigframe __user *frame;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Since we stacked the signal on a 64-bit boundary,
 
        mm_segment_t            addr_limit;     /* address limit */
        struct task_struct      *task;          /* main task structure */
        struct exec_domain      *exec_domain;   /* execution domain */
-       struct restart_block    restart_block;
        int                     preempt_count;  /* 0 => preemptable, <0 => bug */
        int                     cpu;            /* cpu */
 };
        .flags          = 0,                                            \
        .preempt_count  = INIT_PREEMPT_COUNT,                           \
        .addr_limit     = KERNEL_DS,                                    \
-       .restart_block  = {                                             \
-               .fn     = do_no_restart_syscall,                        \
-       },                                                              \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        struct rt_sigframe __user *frame;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Since we stacked the signal on a 128-bit boundary, then 'sp' should
 
        struct compat_sigframe __user *frame;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Since we stacked the signal on a 64-bit boundary,
        struct compat_rt_sigframe __user *frame;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Since we stacked the signal on a 64-bit boundary,
 
                                                   saved by debug handler
                                                   when setting up
                                                   trampoline */
-       struct restart_block    restart_block;
        __u8                    supervisor_stack[0];
 };
 
        .flags          = 0,                                            \
        .cpu            = 0,                                            \
        .preempt_count  = INIT_PREEMPT_COUNT,                           \
-       .restart_block  = {                                             \
-               .fn     = do_no_restart_syscall                         \
-       }                                                               \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        OFFSET(TI_preempt_count, thread_info, preempt_count);
        OFFSET(TI_rar_saved, thread_info, rar_saved);
        OFFSET(TI_rsr_saved, thread_info, rsr_saved);
-       OFFSET(TI_restart_block, thread_info, restart_block);
        BLANK();
        OFFSET(TSK_active_mm, task_struct, active_mm);
        BLANK();
 
        sigset_t set;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        frame = (struct rt_sigframe __user *)regs->sp;
        pr_debug("SIG return: frame = %p\n", frame);
 
        int cpu;                /* cpu we're on */
        int preempt_count;      /* 0 => preemptable, <0 => BUG */
        mm_segment_t addr_limit;        /* address limit */
-       struct restart_block restart_block;
 #ifndef CONFIG_SMP
        struct l1_scratch_task_info l1_task_info;
 #endif
        .flags          = 0,                    \
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
-       .restart_block  = {                     \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 #define init_thread_info       (init_thread_union.thread_info)
 #define init_stack             (init_thread_union.stack)
 
        int err = 0;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
 #define RESTORE(x) err |= __get_user(regs->x, &sc->sc_##x)
 
 
        int                     cpu;            /* cpu we're on */
        int                     preempt_count;  /* 0 = preemptable, <0 = BUG */
        mm_segment_t            addr_limit;     /* thread address space */
-       struct restart_block    restart_block;
 };
 
 /*
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block  = {                     \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        sigset_t set;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Since we stacked the signal on a dword boundary,
 
        unsigned long old_usp;
 
         /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /* restore the regs from &sc->regs (same as sc, since regs is first)
         * (sc is already checked for VERIFY_READ since the sigframe was
 
        unsigned long old_usp;
 
         /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Restore the registers from &sc->regs. sc is already checked
 
                                                   0-0xBFFFFFFF for user-thead
                                                   0-0xFFFFFFFF for kernel-thread
                                                */
-       struct restart_block    restart_block;
        __u8                    supervisor_stack[0];
 };
 
        .cpu            = 0,                            \
        .preempt_count  = INIT_PREEMPT_COUNT,           \
        .addr_limit     = KERNEL_DS,                    \
-       .restart_block = {                              \
-                      .fn = do_no_restart_syscall,     \
-       },                                              \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
                                                 * 0-0xBFFFFFFF for user-thead
                                                 * 0-0xFFFFFFFF for kernel-thread
                                                 */
-       struct restart_block    restart_block;
 
        __u8                    supervisor_stack[0];
 };
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        OFFSET(TI_CPU,                  thread_info, cpu);
        OFFSET(TI_PREEMPT_COUNT,        thread_info, preempt_count);
        OFFSET(TI_ADDR_LIMIT,           thread_info, addr_limit);
-       OFFSET(TI_RESTART_BLOCK,        thread_info, restart_block);
        BLANK();
 
        /* offsets into register file storage */
 
        unsigned long tbr, psr;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        tbr = user->i.tbr;
        psr = user->i.psr;
 
         * used for syscalls somehow;
         * seems to have a function pointer and four arguments
         */
-       struct restart_block    restart_block;
        /* Points to the current pt_regs frame  */
        struct pt_regs          *regs;
        /*
        .cpu            = 0,                    \
        .preempt_count  = 1,                    \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
        .sp = 0,                                \
        .regs = NULL,                   \
 }
 
        sigset_t blocked;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        frame = (struct rt_sigframe __user *)pt_psp(regs);
        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 
        __u32 status;                   /* Thread synchronous flags */
        mm_segment_t addr_limit;        /* user-level address space limit */
        int preempt_count;              /* 0=premptable, <0=BUG; will also serve as bh-counter */
-       struct restart_block restart_block;
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
        __u64 ac_stamp;
        __u64 ac_leave;
        .cpu            = 0,                    \
        .addr_limit     = KERNEL_DS,            \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #ifndef ASM_OFFSETS_C
 
        long err;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /* restore scratch that always needs gets updated during signal delivery: */
        err  = __get_user(flags, &sc->sc_flags);
 
                                                   0-0xBFFFFFFF for user-thread
                                                   0-0xFFFFFFFF for kernel-thread
                                                */
-       struct restart_block    restart_block;
 
        __u8                    supervisor_stack[0];
 };
 #define TI_CPU         0x00000010
 #define TI_PRE_COUNT   0x00000014
 #define TI_ADDR_LIMIT  0x00000018
-#define TI_RESTART_BLOCK 0x000001C
 
 #endif
 
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        unsigned int err = 0;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
 #define COPY(x)                err |= __get_user(regs->x, &sc->sc_##x)
        COPY(r4);
 
        int                     preempt_count;  /* 0 => preemptable, <0 => BUG */
        __u32                   cpu;            /* should always be 0 on m68k */
        unsigned long           tp_value;       /* thread pointer */
-       struct restart_block    restart_block;
 };
 #endif /* __ASSEMBLY__ */
 
        .exec_domain    = &default_exec_domain, \
        .addr_limit     = KERNEL_DS,            \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_stack             (init_thread_union.stack)
 
        int err = 0;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /* get previous context */
        if (copy_from_user(&context, usc, sizeof(context)))
        int err;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        err = __get_user(temp, &uc->uc_mcontext.version);
        if (temp != MCONTEXT_VERSION)
 
        int preempt_count;      /* 0 => preemptable, <0 => BUG */
 
        mm_segment_t addr_limit;        /* thread address space */
-       struct restart_block restart_block;
 
-       u8 supervisor_stack[0];
+       u8 supervisor_stack[0] __aligned(8);
 };
 
 #else /* !__ASSEMBLY__ */
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        int err;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        err = metag_gp_regs_copyin(regs, 0, sizeof(struct user_gp_regs), NULL,
                                   &sc->regs);
 
        __u32                   cpu; /* current CPU */
        __s32                   preempt_count; /* 0 => preemptable,< 0 => BUG*/
        mm_segment_t            addr_limit; /* thread address space */
-       struct restart_block    restart_block;
 
        struct cpu_context      cpu_context;
 };
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        int rval;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                goto badframe;
 
                                                 * 0x7fffffff for user-thead
                                                 * 0xffffffff for kernel-thread
                                                 */
-       struct restart_block    restart_block;
        struct pt_regs          *regs;
        long                    syscall;        /* syscall number */
 };
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block  = {                     \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        OFFSET(TI_CPU, thread_info, cpu);
        OFFSET(TI_PRE_COUNT, thread_info, preempt_count);
        OFFSET(TI_ADDR_LIMIT, thread_info, addr_limit);
-       OFFSET(TI_RESTART_BLOCK, thread_info, restart_block);
        OFFSET(TI_REGS, thread_info, regs);
        DEFINE(_THREAD_SIZE, THREAD_SIZE);
        DEFINE(_THREAD_MASK, THREAD_MASK);
 
        int i;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        err |= __get_user(regs->cp0_epc, &sc->sc_pc);
 
 
        int i;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        err |= __get_user(regs->cp0_epc, &sc->sc_pc);
        err |= __get_user(regs->hi, &sc->sc_mdhi);
 
                                                   0-0xBFFFFFFF for user-thead
                                                   0-0xFFFFFFFF for kernel-thread
                                                */
-       struct restart_block    restart_block;
 
        __u8                    supervisor_stack[0];
 };
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        OFFSET(TI_cpu,                  thread_info, cpu);
        OFFSET(TI_preempt_count,        thread_info, preempt_count);
        OFFSET(TI_addr_limit,           thread_info, addr_limit);
-       OFFSET(TI_restart_block,        thread_info, restart_block);
        BLANK();
 
        OFFSET(REG_D0,                  pt_regs, d0);
 
        unsigned int err = 0;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (is_using_fpu(current))
                fpu_kill_state(current);
 
                                               0-0x7FFFFFFF for user-thead
                                               0-0xFFFFFFFF for kernel-thread
                                             */
-       struct restart_block    restart_block;
        __u8                    supervisor_stack[0];
 
        /* saved context data */
        .cpu            = 0,                            \
        .preempt_count  = 1,                            \
        .addr_limit     = KERNEL_DS,                    \
-       .restart_block  = {                             \
-                         .fn = do_no_restart_syscall,  \
-       },                                              \
        .ksp            = 0,                            \
 }
 
 
        int err = 0;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Restore the regs from &sc->regs.
 
        mm_segment_t addr_limit;        /* user-level address space limit */
        __u32 cpu;                      /* current CPU */
        int preempt_count;              /* 0=premptable, <0=BUG; will also serve as bh-counter */
-       struct restart_block restart_block;
 };
 
 #define INIT_THREAD_INFO(tsk)                  \
        .cpu            = 0,                    \
        .addr_limit     = KERNEL_DS,            \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
-       .restart_block  = {                     \
-               .fn = do_no_restart_syscall     \
-       }                                       \
 }
 
 #define init_thread_info        (init_thread_union.thread_info)
 
                sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 #endif
 
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /* Unwind the user stack to get the rt_sigframe structure. */
        frame = (struct rt_sigframe __user *)
 
        int             cpu;                    /* cpu we're on */
        int             preempt_count;          /* 0 => preemptable,
                                                   <0 => BUG */
-       struct restart_block restart_block;
        unsigned long   local_flags;            /* private flags for thread */
 
        /* low level flags - has atomic operations done on it */
        .exec_domain =  &default_exec_domain,   \
        .cpu =          0,                      \
        .preempt_count = INIT_PREEMPT_COUNT,    \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
        .flags =        0,                      \
 }
 
 
        int tm_restore = 0;
 #endif
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        rt_sf = (struct rt_sigframe __user *)
                (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
 #endif
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
        sc = &sf->sctx;
 
 #endif
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (!access_ok(VERIFY_READ, uc, sizeof(*uc)))
                goto badframe;
 
        unsigned long           sys_call_table; /* System call table address */
        unsigned int            cpu;            /* current CPU */
        int                     preempt_count;  /* 0 => preemptable, <0 => BUG */
-       struct restart_block    restart_block;
        unsigned int            system_call;
        __u64                   user_timer;
        __u64                   system_timer;
        .flags          = 0,                    \
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
-       .restart_block  = {                     \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        int i;
 
        /* Alwys make any pending restarted system call return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
                return -EFAULT;
 
        _sigregs user_sregs;
 
        /* Alwys make any pending restarted system call return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs)))
                return -EFAULT;
 
         * 0-0xFFFFFFFF for kernel-thread
         */
        mm_segment_t            addr_limit;
-       struct restart_block    restart_block;
        struct pt_regs          *regs;
 };
 
        .cpu            = 0,                    \
        .preempt_count  = 1,                    \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block  = {                     \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        OFFSET(TI_CPU, thread_info, cpu);
        OFFSET(TI_PRE_COUNT, thread_info, preempt_count);
        OFFSET(TI_ADDR_LIMIT, thread_info, addr_limit);
-       OFFSET(TI_RESTART_BLOCK, thread_info, restart_block);
        OFFSET(TI_REGS, thread_info, regs);
        DEFINE(KERNEL_STACK_SIZE, THREAD_SIZE);
        DEFINE(KERNEL_STACK_MASK, THREAD_MASK);
 
        int sig;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        frame = (struct rt_sigframe __user *) regs->regs[0];
        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 
        __u32                   cpu;
        int                     preempt_count; /* 0 => preemptable, <0 => BUG */
        mm_segment_t            addr_limit;     /* thread address space */
-       struct restart_block    restart_block;
        unsigned long           previous_sp;    /* sp of previous stack in case
                                                   of nested IRQ stacks */
        __u8                    supervisor_stack[0];
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block  = {                     \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        DEFINE(TI_FLAGS,        offsetof(struct thread_info, flags));
        DEFINE(TI_CPU,          offsetof(struct thread_info, cpu));
        DEFINE(TI_PRE_COUNT,    offsetof(struct thread_info, preempt_count));
-       DEFINE(TI_RESTART_BLOCK,offsetof(struct thread_info, restart_block));
        DEFINE(TI_SIZE,         sizeof(struct thread_info));
 
 #ifdef CONFIG_HIBERNATION
 
        int r0;
 
         /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                goto badframe;
        int r0;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                goto badframe;
 
        long long ret;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                goto badframe;
        long long ret;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
                goto badframe;
 
        struct reg_window32     reg_window[NSWINS];     /* align for ldd! */
        unsigned long           rwbuf_stkptrs[NSWINS];
        unsigned long           w_saved;
-
-       struct restart_block    restart_block;
 };
 
 /*
        .flags          =       0,                      \
        .cpu            =       0,                      \
        .preempt_count  =       INIT_PREEMPT_COUNT,     \
-       .restart_block  = {                             \
-               .fn     =       do_no_restart_syscall,  \
-       },                                              \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 #define TI_REG_WINDOW  0x30
 #define TI_RWIN_SPTRS  0x230
 #define TI_W_SAVED     0x250
-/* #define TI_RESTART_BLOCK 0x25n */ /* Nobody cares */
 
 /*
  * thread information flag bit numbers
 
        unsigned long           gsr[7];
        unsigned long           xfsr[7];
 
-       struct restart_block    restart_block;
-
        struct pt_regs          *kern_una_regs;
        unsigned int            kern_una_insn;
 
 #define TI_RWIN_SPTRS  0x000003c8
 #define TI_GSR         0x00000400
 #define TI_XFSR                0x00000438
-#define TI_RESTART_BLOCK 0x00000470
-#define TI_KUNA_REGS   0x000004a0
-#define TI_KUNA_INSN   0x000004a8
-#define TI_FPREGS      0x000004c0
+#define TI_KUNA_REGS   0x00000470
+#define TI_KUNA_INSN   0x00000478
+#define TI_FPREGS      0x00000480
 
 /* We embed this in the uppermost byte of thread_info->flags */
 #define FAULT_CODE_WRITE       0x01    /* Write access, implies D-TLB     */
        .current_ds     =       ASI_P,                  \
        .exec_domain    =       &default_exec_domain,   \
        .preempt_count  =       INIT_PREEMPT_COUNT,     \
-       .restart_block  = {                             \
-               .fn     =       do_no_restart_syscall,  \
-       },                                              \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        int err, i;
        
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        synchronize_user_stack();
 
        int err, i;
        
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        synchronize_user_stack();
        regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 
        int err;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        synchronize_user_stack();
 
 
        int err;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        synchronize_user_stack ();
        sf = (struct rt_signal_frame __user *)
 
                     TI_NEW_CHILD != offsetof(struct thread_info, new_child) ||
                     TI_CURRENT_DS != offsetof(struct thread_info,
                                                current_ds) ||
-                    TI_RESTART_BLOCK != offsetof(struct thread_info,
-                                                 restart_block) ||
                     TI_KUNA_REGS != offsetof(struct thread_info,
                                              kern_una_regs) ||
                     TI_KUNA_INSN != offsetof(struct thread_info,
 
 
        mm_segment_t            addr_limit;     /* thread address space
                                                   (KERNEL_DS or USER_DS) */
-       struct restart_block    restart_block;
        struct single_step_state *step_state;   /* single step state
                                                   (if non-zero) */
        int                     align_ctl;      /* controls unaligned access */
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block  = {                     \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
        .step_state     = NULL,                 \
        .align_ctl      = 0,                    \
 }
 
        int err;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Enforce that sigcontext is like pt_regs, and doesn't mess
 
        mm_segment_t            addr_limit;     /* thread address space:
                                                   0-0xBFFFFFFF for user
                                                   0-0xFFFFFFFF for kernel */
-       struct restart_block    restart_block;
        struct thread_info      *real_thread;    /* Points to non-IRQ stack */
 };
 
        .cpu =          0,                      \
        .preempt_count = INIT_PREEMPT_COUNT,    \
        .addr_limit =   KERNEL_DS,              \
-       .restart_block =  {                     \
-               .fn =  do_no_restart_syscall,   \
-       },                                      \
        .real_thread = NULL,                    \
 }
 
 
 #ifdef CONFIG_UNICORE_FPU_F64
        struct fp_state         fpstate __attribute__((aligned(8)));
 #endif
-       struct restart_block    restart_block;
 };
 
 #define INIT_THREAD_INFO(tsk)                                          \
        .flags          = 0,                                            \
        .preempt_count  = INIT_PREEMPT_COUNT,                           \
        .addr_limit     = KERNEL_DS,                                    \
-       .restart_block  = {                                             \
-               .fn     = do_no_restart_syscall,                        \
-       },                                                              \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        struct rt_sigframe __user *frame;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        /*
         * Since we stacked the signal on a 64-bit boundary,
 
        u32 tmp;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        get_user_try {
                /*
 
        __u32                   cpu;            /* current CPU */
        int                     saved_preempt_count;
        mm_segment_t            addr_limit;
-       struct restart_block    restart_block;
        void __user             *sysenter_return;
        unsigned int            sig_on_uaccess_error:1;
        unsigned int            uaccess_err:1;  /* uaccess failed */
        .cpu            = 0,                    \
        .saved_preempt_count = INIT_PREEMPT_COUNT,      \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        unsigned int err = 0;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        get_user_try {
 
 
        int err, pid;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        err = copy_from_user(&sc, from, sizeof(sc));
        if (err)
 
        __s32                   preempt_count;  /* 0 => preemptable,< 0 => BUG*/
 
        mm_segment_t            addr_limit;     /* thread address space */
-       struct restart_block    restart_block;
 
        unsigned long           cpenable;
 
 #define TI_CPU          0x00000010
 #define TI_PRE_COUNT    0x00000014
 #define TI_ADDR_LIMIT   0x00000018
-#define TI_RESTART_BLOCK 0x000001C
 
 #endif
 
        .cpu            = 0,                    \
        .preempt_count  = INIT_PREEMPT_COUNT,   \
        .addr_limit     = KERNEL_DS,            \
-       .restart_block = {                      \
-               .fn = do_no_restart_syscall,    \
-       },                                      \
 }
 
 #define init_thread_info       (init_thread_union.thread_info)
 
        int ret;
 
        /* Always make any pending restarted system calls return -EINTR */
-       current_thread_info()->restart_block.fn = do_no_restart_syscall;
+       current->restart_block.fn = do_no_restart_syscall;
 
        if (regs->depc > 64)
                panic("rt_sigreturn in double exception!\n");
 
        if (ret == -EINTR) {
                struct restart_block *restart_block;
 
-               restart_block = ¤t_thread_info()->restart_block;
+               restart_block = ¤t->restart_block;
                restart_block->fn = do_restart_poll;
                restart_block->poll.ufds = ufds;
                restart_block->poll.nfds = nfds;
 
        .nr_cpus_allowed= NR_CPUS,                                      \
        .mm             = NULL,                                         \
        .active_mm      = &init_mm,                                     \
+       .restart_block = {                                              \
+               .fn = do_no_restart_syscall,                            \
+       },                                                              \
        .se             = {                                             \
                .group_node     = LIST_HEAD_INIT(tsk.se.group_node),    \
        },                                                              \
 
 
        unsigned long atomic_flags; /* Flags needing atomic access. */
 
+       struct restart_block restart_block;
+
        pid_t pid;
        pid_t tgid;
 
 
         * core implementation decides to return random nonsense.
         */
        if (ret == -ERESTART_RESTARTBLOCK) {
-               struct restart_block *restart
-                       = ¤t_thread_info()->restart_block;
+               struct restart_block *restart = ¤t->restart_block;
 
                restart->fn = compat_nanosleep_restart;
                restart->nanosleep.compat_rmtp = rmtp;
                return -EFAULT;
 
        if (err == -ERESTART_RESTARTBLOCK) {
-               restart = ¤t_thread_info()->restart_block;
+               restart = ¤t->restart_block;
                restart->fn = compat_clock_nanosleep_restart;
                restart->nanosleep.compat_rmtp = rmtp;
        }
 
        if (!abs_time)
                goto out;
 
-       restart = ¤t_thread_info()->restart_block;
+       restart = ¤t->restart_block;
        restart->fn = futex_wait_restart;
        restart->futex.uaddr = uaddr;
        restart->futex.val = val;
 
  */
 SYSCALL_DEFINE0(restart_syscall)
 {
-       struct restart_block *restart = ¤t_thread_info()->restart_block;
+       struct restart_block *restart = ¤t->restart_block;
        return restart->fn(restart);
 }
 
 
                        goto out;
        }
 
-       restart = ¤t_thread_info()->restart_block;
+       restart = ¤t->restart_block;
        restart->fn = alarm_timer_nsleep_restart;
        restart->nanosleep.clockid = type;
        restart->nanosleep.expires = exp.tv64;
 
                        goto out;
        }
 
-       restart = ¤t_thread_info()->restart_block;
+       restart = ¤t->restart_block;
        restart->fn = hrtimer_nanosleep_restart;
        restart->nanosleep.clockid = t.timer.base->clockid;
        restart->nanosleep.rmtp = rmtp;
 
 static int posix_cpu_nsleep(const clockid_t which_clock, int flags,
                            struct timespec *rqtp, struct timespec __user *rmtp)
 {
-       struct restart_block *restart_block =
-               ¤t_thread_info()->restart_block;
+       struct restart_block *restart_block = ¤t->restart_block;
        struct itimerspec it;
        int error;