#include <uapi/linux/audit.h>
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_ALPHA;
 }
 
 }
 
 static inline int
-syscall_get_arch(void)
+syscall_get_arch(struct task_struct *task)
 {
        return IS_ENABLED(CONFIG_ISA_ARCOMPACT)
                ? (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN)
 
        memcpy(®s->ARM_r0 + i, args, n * sizeof(args[0]));
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        /* ARM tasks don't change audit architectures on the fly. */
        return AUDIT_ARCH_ARM;
 
  * We don't care about endianness (__AUDIT_ARCH_LE bit) here because
  * AArch64 has the same system calls both on little- and big- endian.
  */
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
-       if (is_compat_task())
+       if (is_compat_thread(task_thread_info(task)))
                return AUDIT_ARCH_ARM;
 
        return AUDIT_ARCH_AARCH64;
 
        }
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return IS_ENABLED(CONFIG_CPU_BIG_ENDIAN)
                ? AUDIT_ARCH_C6XBE : AUDIT_ARCH_C6X;
 
 }
 
 static inline int
-syscall_get_arch(void)
+syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_CSKY;
 }
 
 }
 
 static inline int
-syscall_get_arch(void)
+syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_H8300;
 }
 
        memcpy(args, &(®s->r00)[i], n * sizeof(args[0]));
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_HEXAGON;
 }
 
        ia64_syscall_get_set_arguments(task, regs, i, n, args, 1);
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_IA64;
 }
 
 
 #include <uapi/linux/audit.h>
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_M68K;
 }
 
 asmlinkage unsigned long do_syscall_trace_enter(struct pt_regs *regs);
 asmlinkage void do_syscall_trace_leave(struct pt_regs *regs);
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_MICROBLAZE;
 }
 
 extern const unsigned long sys32_call_table[];
 extern const unsigned long sysn32_call_table[];
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        int arch = AUDIT_ARCH_MIPS;
 #ifdef CONFIG_64BIT
-       if (!test_thread_flag(TIF_32BIT_REGS)) {
+       if (!test_tsk_thread_flag(task, TIF_32BIT_REGS)) {
                arch |= __AUDIT_ARCH_64BIT;
                /* N32 sets only TIF_32BIT_ADDR */
-               if (test_thread_flag(TIF_32BIT_ADDR))
+               if (test_tsk_thread_flag(task, TIF_32BIT_ADDR))
                        arch |= __AUDIT_ARCH_CONVENTION_MIPS64_N32;
        }
 #endif
 
                unsigned long args[6];
 
                sd.nr = syscall;
-               sd.arch = syscall_get_arch();
+               sd.arch = syscall_get_arch(current);
                syscall_get_arguments(current, regs, 0, 6, args);
                for (i = 0; i < 6; i++)
                        sd.args[i] = args[i];
 
 }
 
 static inline int
-syscall_get_arch(void)
+syscall_get_arch(struct task_struct *task)
 {
        return IS_ENABLED(CONFIG_CPU_BIG_ENDIAN)
                ? AUDIT_ARCH_NDS32BE : AUDIT_ARCH_NDS32;
 
        }
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_NIOS2;
 }
 
        memcpy(®s->gpr[3 + i], args, n * sizeof(args[0]));
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_OPENRISC;
 }
 
        /* do nothing */
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        int arch = AUDIT_ARCH_PARISC;
 #ifdef CONFIG_64BIT
-       if (!is_compat_task())
+       if (!__is_compat_task(task))
                arch = AUDIT_ARCH_PARISC64;
 #endif
        return arch;
 
                regs->orig_gpr3 = args[0];
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
-       int arch = is_32bit_task() ? AUDIT_ARCH_PPC : AUDIT_ARCH_PPC64;
+       int arch;
+
+       if (IS_ENABLED(CONFIG_PPC64) && !test_tsk_thread_flag(task, TIF_32BIT))
+               arch = AUDIT_ARCH_PPC64;
+       else
+               arch = AUDIT_ARCH_PPC;
+
 #ifdef __LITTLE_ENDIAN__
        arch |= __AUDIT_ARCH_LE;
 #endif
 
        memcpy(®s->a1 + i * sizeof(regs->a1), args, n * sizeof(regs->a0));
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
 #ifdef CONFIG_64BIT
        return AUDIT_ARCH_RISCV64;
 
                regs->orig_gpr2 = args[0];
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
 #ifdef CONFIG_COMPAT
-       if (test_tsk_thread_flag(current, TIF_31BIT))
+       if (test_tsk_thread_flag(task, TIF_31BIT))
                return AUDIT_ARCH_S390;
 #endif
        return AUDIT_ARCH_S390X;
 
        }
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        int arch = AUDIT_ARCH_SH;
 
 
        memcpy(®s->regs[2 + i], args, n * sizeof(args[0]));
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        int arch = AUDIT_ARCH_SH;
 
 
                regs->u_regs[UREG_I0 + i + j] = args[j];
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
 #if defined(CONFIG_SPARC64) && defined(CONFIG_COMPAT)
-       return in_compat_syscall() ? AUDIT_ARCH_SPARC : AUDIT_ARCH_SPARC64;
+       return test_tsk_thread_flag(task, TIF_32BIT)
+               ? AUDIT_ARCH_SPARC : AUDIT_ARCH_SPARC64;
 #elif defined(CONFIG_SPARC64)
        return AUDIT_ARCH_SPARC64;
 #else
 
 
 #include <uapi/linux/audit.h>
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_UNICORE;
 }
 
        memcpy(®s->bx + i, args, n * sizeof(args[0]));
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_I386;
 }
                }
 }
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        /* x32 tasks should be considered AUDIT_ARCH_X86_64. */
-       return in_ia32_syscall() ? AUDIT_ARCH_I386 : AUDIT_ARCH_X86_64;
+       return (IS_ENABLED(CONFIG_IA32_EMULATION) &&
+               task->thread_info.status & TS_COMPAT)
+               ? AUDIT_ARCH_I386 : AUDIT_ARCH_X86_64;
 }
 #endif /* CONFIG_X86_32 */
 
 
                                          unsigned long, unsigned long,
                                          unsigned long, unsigned long);
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
 #ifdef CONFIG_X86_32
        return AUDIT_ARCH_I386;
 
 #include <asm/ptrace.h>
 #include <uapi/linux/audit.h>
 
-static inline int syscall_get_arch(void)
+static inline int syscall_get_arch(struct task_struct *task)
 {
        return AUDIT_ARCH_XTENSA;
 }
 
 
 /**
  * syscall_get_arch - return the AUDIT_ARCH for the current system call
+ * @task:      task of interest, must be blocked
  *
  * Returns the AUDIT_ARCH_* based on the system call convention in use.
  *
- * It's only valid to call this when current is stopped on entry to a system
+ * It's only valid to call this when @task is stopped on entry to a system
  * call, due to %TIF_SYSCALL_TRACE, %TIF_SYSCALL_AUDIT, or %TIF_SECCOMP.
  *
  * Architectures which permit CONFIG_HAVE_ARCH_SECCOMP_FILTER must
  * provide an implementation of this.
  */
-int syscall_get_arch(void);
+int syscall_get_arch(struct task_struct *task);
 #endif /* _ASM_SYSCALL_H */
 
                        return;
        }
 
-       context->arch       = syscall_get_arch();
+       context->arch       = syscall_get_arch(current);
        context->major      = major;
        context->argv[0]    = a1;
        context->argv[1]    = a2;
                return;
        audit_log_task(ab);
        audit_log_format(ab, " sig=%ld arch=%x syscall=%ld compat=%d ip=0x%lx code=0x%x",
-                        signr, syscall_get_arch(), syscall,
+                        signr, syscall_get_arch(current), syscall,
                         in_compat_syscall(), KSTK_EIP(current), code);
        audit_log_end(ab);
 }
 
        unsigned long args[6];
 
        sd->nr = syscall_get_nr(task, regs);
-       sd->arch = syscall_get_arch();
+       sd->arch = syscall_get_arch(task);
        syscall_get_arguments(task, regs, 0, 6, args);
        sd->args[0] = args[0];
        sd->args[1] = args[1];
        info->si_code = SYS_SECCOMP;
        info->si_call_addr = (void __user *)KSTK_EIP(current);
        info->si_errno = reason;
-       info->si_arch = syscall_get_arch();
+       info->si_arch = syscall_get_arch(current);
        info->si_syscall = syscall;
 }