diff --git a/include/seccomp.h.in b/include/seccomp.h.in
index 6bf6751..5b9057f 100644
--- a/include/seccomp.h.in
+++ b/include/seccomp.h.in
@@ -185,6 +185,12 @@ struct scmp_arg_cmp {
 #define SCMP_ARCH_S390X		AUDIT_ARCH_S390X
 
 /**
+ * The PA-RISC hppa architecture tokens
+ */
+#define SCMP_ARCH_PARISC	AUDIT_ARCH_PARISC
+#define SCMP_ARCH_PARISC64	AUDIT_ARCH_PARISC64
+
+/**
  * Convert a syscall name into the associated syscall number
  * @param x the syscall name
  */
diff --git a/src/Makefile.am b/src/Makefile.am
index c2d805e..dcc79d9 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -35,6 +35,8 @@ SOURCES_ALL = \
 	arch-mips.h arch-mips.c arch-mips-syscalls.c \
 	arch-mips64.h arch-mips64.c arch-mips64-syscalls.c \
 	arch-mips64n32.h arch-mips64n32.c arch-mips64n32-syscalls.c \
+	arch-parisc.h arch-parisc.c arch-parisc-syscalls.c \
+	arch-parisc64.h arch-parisc64.c \
 	arch-ppc.h arch-ppc.c arch-ppc-syscalls.c \
 	arch-ppc64.h arch-ppc64.c arch-ppc64-syscalls.c \
 	arch-s390.h arch-s390.c arch-s390-syscalls.c \
diff --git a/src/arch-parisc-syscalls.c b/src/arch-parisc-syscalls.c
new file mode 100644
index 0000000..2827bb5
--- /dev/null
+++ b/src/arch-parisc-syscalls.c
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) 2016 Helge Deller <deller@gmx.de>
+ * Author: Helge Deller <deller@gmx.de>
+ */
+
+#include <string.h>
+
+#include <seccomp.h>
+
+#include "arch.h"
+#include "arch-parisc.h"
+
+/* NOTE: based on Linux 4.5-rc4 */
+const struct arch_syscall_def parisc_syscall_table[] = { \
+	{ "_llseek",	140 },
+	{ "_newselect",	142 },
+	{ "_sysctl",	149 },
+	{ "accept",	35 },
+	{ "accept4",	320 },
+	{ "access",	33 },
+	{ "acct",	51 },
+	{ "add_key",	264 },
+	{ "adjtimex",	124 },
+	{ "afs_syscall",137 },
+	{ "alarm",	27 },
+	{ "arm_fadvise64_64", __PNR_arm_fadvise64_64 },
+	{ "arm_sync_file_range", __PNR_arm_sync_file_range },
+	{ "arch_prctl", __PNR_arch_prctl },
+	{ "bdflush",	134 },
+	{ "bind",	22 },
+	{ "bpf",	341 },
+	{ "break",	__PNR_break },
+	{ "breakpoint", __PNR_breakpoint },
+	{ "brk",	45 },
+	{ "cachectl",	__PNR_cachectl },
+	{ "cacheflush",	__PNR_cacheflush },
+	{ "capget",	106 },
+	{ "capset",	107 },
+	{ "chdir",	12 },
+	{ "chmod",	15 },
+	{ "chown",	180 },
+	{ "chown32",	__PNR_chown32 },
+	{ "chroot",	61 },
+	{ "clock_adjtime",	324 },
+	{ "clock_getres",	257 },
+	{ "clock_gettime",	256 },
+	{ "clock_nanosleep",	258 },
+	{ "clock_settime",	255 },
+	{ "clone",	120 },
+	{ "close",	6 },
+	{ "connect",	31 },
+	{ "copy_file_range", 346 },
+	{ "creat",	8 },
+	{ "create_module",	127 },
+	{ "delete_module",	129 },
+	{ "dup",	41 },
+	{ "dup2",	63 },
+	{ "dup3",	312 },
+	{ "epoll_create",	224 },
+	{ "epoll_create1",	311 },
+	{ "epoll_ctl",	225 },
+	{ "epoll_ctl_old", __PNR_epoll_ctl_old },
+	{ "epoll_pwait",	297 },
+	{ "epoll_wait",	226 },
+	{ "epoll_wait_old", __PNR_epoll_wait_old },
+	{ "eventfd",	304 },
+	{ "eventfd2",	310 },
+	{ "execve",	11 },
+	{ "execveat",	342 },
+	{ "exit",	1 },
+	{ "exit_group",	222 },
+	{ "faccessat",	287 },
+	{ "fadvise64",	__PNR_fadvise64 },
+	{ "fadvise64_64",	236 },
+	{ "fallocate",	305 },
+	{ "fanotify_init",	322 },
+	{ "fanotify_mark",	323 },
+	{ "fchdir",	133 },
+	{ "fchmod",	94 },
+	{ "fchmodat",	286 },
+	{ "fchown",	95 },
+	{ "fchown32",	__PNR_fchown32 },
+	{ "fchownat",	278 },
+	{ "fcntl",	55 },
+	{ "fcntl64",	202 },
+	{ "fdatasync",	148 },
+	{ "fgetxattr",	243 },
+	{ "finit_module",	333 },
+	{ "flistxattr",	246 },
+	{ "flock",	143 },
+	{ "fork",	2 },
+	{ "fremovexattr",	249 },
+	{ "fsetxattr",	240 },
+	{ "fstat",	28 },
+	{ "fstat64",	112 },
+	{ "fstatat64",	280 },
+	{ "fstatfs",	100 },
+	{ "fstatfs64",	299 },
+	{ "fsync",	118 },
+	{ "ftime",	__PNR_ftime },
+	{ "ftruncate",	93 },
+	{ "ftruncate64",	200 },
+	{ "futex",	210 },
+	{ "futimesat",	279 },
+	{ "get_kernel_syms",	130 },
+	{ "get_mempolicy",	261 },
+	{ "get_robust_list",	290 },
+	{ "get_thread_area",	214 },
+	{ "getcpu",	296 },
+	{ "getcwd",	110 },
+	{ "getdents",	141 },
+	{ "getdents64",	201 },
+	{ "getegid",	50 },
+	{ "getegid32", __PNR_getegid32 },
+	{ "geteuid",	49 },
+	{ "geteuid32", __PNR_geteuid32 },
+	{ "getgid",	47 },
+	{ "getgid32",	__PNR_getgid32 },
+	{ "getgroups",	80 },
+	{ "getgroups32",__PNR_getgroups32 },
+	{ "getitimer",	105 },
+	{ "getpeername",	53 },
+	{ "getpgid",	132 },
+	{ "getpgrp",	65 },
+	{ "getpid",	20 },
+	{ "getpmsg",	196 },
+	{ "getppid",	64 },
+	{ "getpriority",	96 },
+	{ "getrandom",	339 },
+	{ "getresgid",	171 },
+	{ "getresgid32",__PNR_getresgid32 },
+	{ "getresuid",	165 },
+	{ "getresuid32",__PNR_getresuid32 },
+	{ "getrlimit",	76 },
+	{ "getrusage",	77 },
+	{ "getsid",	147 },
+	{ "getsockname",	44 },
+	{ "getsockopt",	182 },
+	{ "gettid",	206 },
+	{ "gettimeofday",	78 },
+	{ "getuid",	24 },
+	{ "getuid32",	__PNR_getuid32 },
+	{ "getxattr",	241 },
+	{ "gtty",	__PNR_gtty },
+	{ "idle",	__PNR_idle },
+	{ "init_module",	128 },
+	{ "inotify_add_watch",	270 },
+	{ "inotify_init",	269 },
+	{ "inotify_init1",	314 },
+	{ "inotify_rm_watch",	271 },
+	{ "io_cancel",	219 },
+	{ "io_destroy",	216 },
+	{ "io_getevents",	217 },
+	{ "io_setup",	215 },
+	{ "io_submit",	218 },
+	{ "ioctl",	54 },
+	{ "ioperm",	__PNR_ioperm },
+	{ "iopl",	__PNR_iopl },
+	{ "ioprio_get",	268 },
+	{ "ioprio_set",	267 },
+	{ "ipc",	__PNR_ipc },
+	{ "kcmp",	332 },
+	{ "kexec_file_load", __PNR_kexec_file_load },
+	{ "kexec_load",	300 },
+	{ "keyctl",	266 },
+	{ "kill",	37 },
+	{ "lchown",	16 },
+	{ "lchown32",	__PNR_lchown32 },
+	{ "lgetxattr",	242 },
+	{ "link",	9 },
+	{ "linkat",	283 },
+	{ "listen",	32 },
+	{ "listxattr",	244 },
+	{ "llistxattr",	245 },
+	{ "lock",	__PNR_lock },
+	{ "lookup_dcookie",	223 },
+	{ "lremovexattr",	248 },
+	{ "lseek",	19 },
+	{ "lsetxattr",	239 },
+	{ "lstat",	84 },
+	{ "lstat64",	198 },
+	{ "madvise",	119 },
+	{ "mbind",	260 },
+	{ "membarrier",	343 },
+	{ "memfd_create",	340 },
+	{ "migrate_pages",	272 },
+	{ "mincore",	72 },
+	{ "mkdir",	39 },
+	{ "mkdirat",	276 },
+	{ "mknod",	14 },
+	{ "mknodat",	277 },
+	{ "mlock",	150 },
+	{ "mlock2",	345 },
+	{ "mlockall",	152 },
+	{ "mmap",	90 },
+	{ "mmap2",	89 },
+	{ "modify_ldt",	__PNR_modify_ldt },
+	{ "mount",	21 },
+	{ "move_pages",	295 },
+	{ "mprotect",	125 },
+	{ "mpx",	__PNR_mpx },
+	{ "mq_getsetattr",	234 },
+	{ "mq_notify",	233 },
+	{ "mq_open",	229 },
+	{ "mq_timedreceive",	232 },
+	{ "mq_timedsend",	231 },
+	{ "mq_unlink",	230 },
+	{ "mremap",	163 },
+	{ "msgctl",	191 },
+	{ "msgget",	190 },
+	{ "msgrcv",	189 },
+	{ "msgsnd",	188 },
+	{ "msync",	144 },
+	{ "multiplexer", __PNR_multiplexer },
+	{ "munlock",	151 },
+	{ "munlockall",	153 },
+	{ "munmap",	91 },
+	{ "name_to_handle_at",	325 },
+	{ "nanosleep",	162 },
+	{ "newfstatat", __PNR_newfstatat },
+	{ "nfsservctl",	169 },
+	{ "nice",	34 },
+	{ "oldfstat",	__PNR_oldfstat },
+	{ "oldlstat",	__PNR_oldlstat },
+	{ "oldolduname",__PNR_oldolduname },
+	{ "oldstat",	__PNR_oldstat },
+	{ "olduname",	__PNR_olduname },
+	{ "oldwait4",	__PNR_oldwait4 },
+	{ "open",	5 },
+	{ "open_by_handle_at",	326 },
+	{ "openat",	275 },
+	{ "pause",	29 },
+	{ "pciconfig_iobase", __PNR_pciconfig_iobase },
+	{ "pciconfig_read", __PNR_pciconfig_read },
+	{ "pciconfig_write", __PNR_pciconfig_write },
+	{ "perf_event_open",	318 },
+	{ "personality",	136 },
+	{ "pipe",	42 },
+	{ "pipe2",	313 },
+	{ "pivot_root",	67 },
+	{ "poll",	168 },
+	{ "ppoll",	274 },
+	{ "prctl",	172 },
+	{ "pread64",	108 },
+	{ "preadv",	315 },
+	{ "prlimit64",	321 },
+	{ "process_vm_readv",	330 },
+	{ "process_vm_writev",	331 },
+	{ "prof",	__PNR_prof },
+	{ "profil",	__PNR_profil },
+	{ "pselect6",	273 },
+	{ "ptrace",	26 },
+	{ "putpmsg",	197 },
+	{ "pwrite64",	109 },
+	{ "pwritev",	316 },
+	{ "query_module",	167 },
+	{ "quotactl",	131 },
+	{ "read",	3 },
+	{ "readahead",	207 },
+	{ "readdir",	__PNR_readdir },
+	{ "readlink",	85 },
+	{ "readlinkat",	285 },
+	{ "readv",	145 },
+	{ "reboot",	88 },
+	{ "recv",	98 },
+	{ "recvfrom",	123 },
+	{ "recvmmsg",	319 },
+	{ "recvmsg",	184 },
+	{ "remap_file_pages",	227 },
+	{ "removexattr",	247 },
+	{ "rename",	38 },
+	{ "renameat",	282 },
+	{ "renameat2",	337 },
+	{ "request_key",	265 },
+	{ "restart_syscall",	0 },
+	{ "rmdir",	40 },
+	{ "rt_sigaction",	174 },
+	{ "rt_sigpending",	176 },
+	{ "rt_sigprocmask",	175 },
+	{ "rt_sigqueueinfo",	178 },
+	{ "rt_sigreturn",	173 },
+	{ "rt_sigsuspend",	179 },
+	{ "rt_sigtimedwait",	177 },
+	{ "rt_tgsigqueueinfo",	317 },
+	{ "rtas", __PNR_rtas },
+	{ "s390_pci_mmio_read", __PNR_s390_pci_mmio_read },
+	{ "s390_pci_mmio_write", __PNR_s390_pci_mmio_write },
+	{ "s390_runtime_instr", __PNR_s390_runtime_instr },
+	{ "sched_get_priority_max",	159 },
+	{ "sched_get_priority_min",	160 },
+	{ "sched_getaffinity",	212 },
+	{ "sched_getattr",	335 },
+	{ "sched_getparam",	155 },
+	{ "sched_getscheduler",	157 },
+	{ "sched_rr_get_interval",	161 },
+	{ "sched_setaffinity",	211 },
+	{ "sched_setattr",	334 },
+	{ "sched_setparam",	154 },
+	{ "sched_setscheduler",	156 },
+	{ "sched_yield",	158 },
+	{ "seccomp",	338 },
+	{ "security",	__PNR_security },
+	{ "select",	__PNR_select },
+	{ "semctl",	187 },
+	{ "semget",	186 },
+	{ "semop",	185 },
+	{ "semtimedop",	228 },
+	{ "send",	58 },
+	{ "sendfile",	122 },
+	{ "sendfile64",	209 },
+	{ "sendmmsg",	329 },
+	{ "sendmsg",	183 },
+	{ "sendto",	82 },
+	{ "set_mempolicy",	262 },
+	{ "set_robust_list",	289 },
+	{ "set_thread_area",	213 },
+	{ "set_tid_address",	237 },
+	{ "set_tls", __PNR_set_tls },
+	{ "setdomainname",	121 },
+	{ "setfsgid",	139 },
+	{ "setfsgid32",	__PNR_setfsgid32 },
+	{ "setfsuid",	138 },
+	{ "setfsuid32",	__PNR_setfsuid32 },
+	{ "setgid",	46 },
+	{ "setgid32",	__PNR_setgid32 },
+	{ "setgroups",	81 },
+	{ "setgroups32", __PNR_setgroups32},
+	{ "sethostname",	74 },
+	{ "setitimer",	104 },
+	{ "setns",	328 },
+	{ "setpgid",	57 },
+	{ "setpriority",	97 },
+	{ "setregid",	71 },
+	{ "setregid32", __PNR_setregid32 },
+	{ "setresgid",	170 },
+	{ "setresgid32",__PNR_setresgid32 },
+	{ "setresuid",	164 },
+	{ "setresuid32",__PNR_setresuid32 },
+	{ "setreuid",	70 },
+	{ "setreuid32",	__PNR_setreuid32 },
+	{ "setrlimit",	75 },
+	{ "setsid",	66 },
+	{ "setsockopt",	181 },
+	{ "settimeofday",	79 },
+	{ "setuid",	23 },
+	{ "setuid32",	__PNR_setuid32 },
+	{ "setxattr",	238 },
+	{ "sgetmask",	68 },
+	{ "shmat",	192 },
+	{ "shmctl",	195 },
+	{ "shmdt",	193 },
+	{ "shmget",	194 },
+	{ "shutdown",	117 },
+	{ "sigaction",	__PNR_sigaction },
+	{ "sigaltstack",166 },
+	{ "signal",	48 },
+	{ "signalfd",	302 },
+	{ "signalfd4",	309 },
+	{ "sigpending",	73 },
+	{ "sigprocmask",	126 },
+	{ "sigreturn",	__PNR_sigreturn },
+	{ "sigsuspend",	__PNR_sigsuspend },
+	{ "socket",	17 },
+	{ "socketcall",	__PNR_socketcall },
+	{ "socketpair",	56 },
+	{ "splice",	291 },
+	{ "spu_create", __PNR_spu_create },
+	{ "spu_run", __PNR_spu_run },
+	{ "ssetmask",	69 },
+	{ "stat",	18 },
+	{ "stat64",	101 },
+	{ "statfs",	99 },
+	{ "statfs64",	298 },
+	{ "stime",	25 },
+	{ "stty",	__PNR_stty },
+	{ "subpage_prot", __PNR_subpage_prot },
+	{ "swapcontext", __PNR_swapcontext },
+	{ "swapoff",	115 },
+	{ "swapon",	87 },
+	{ "switch_endian", __PNR_switch_endian },
+	{ "symlink",	83 },
+	{ "symlinkat",	284 },
+	{ "sync",	36 },
+	{ "sync_file_range",	292 },
+	{ "sync_file_range2", __PNR_sync_file_range2 },
+	{ "syncfs",	327 },
+	{ "syscall", __PNR_syscall },
+	{ "sys_debug_setcontext", __PNR_sys_debug_setcontext },
+	{ "sysfs",	135 },
+	{ "sysinfo",	116 },
+	{ "syslog",	103 },
+	{ "sysmips",	__PNR_sysmips },
+	{ "tee",	293 },
+	{ "tgkill",	259 },
+	{ "time",	13 },
+	{ "timer_create",	250 },
+	{ "timer_delete",	254 },
+	{ "timer_getoverrun",	253 },
+	{ "timer_gettime",	252 },
+	{ "timer_settime",	251 },
+	{ "timerfd",	303 },
+	{ "timerfd_create",	306 },
+	{ "timerfd_gettime",	308 },
+	{ "timerfd_settime",	307 },
+	{ "times",	43 },
+	{ "tkill",	208 },
+	{ "truncate",	92 },
+	{ "truncate64",	199 },
+	{ "tuxcall",	__PNR_tuxcall },
+	{ "ugetrlimit", __PNR_ugetrlimit },
+	{ "ulimit",	__PNR_ulimit },
+	{ "umask",	60 },
+	{ "umount",	__PNR_umount },
+	{ "umount2",	52 },
+	{ "uname",	59 },
+	{ "unlink",	10 },
+	{ "unlinkat",	281 },
+	{ "unshare",	288 },
+	{ "uselib",	86 },
+	{ "userfaultfd", 344 },
+	{ "usr26",	__PNR_usr26 },
+	{ "usr32",	__PNR_usr32 },
+	{ "ustat",	62 },
+	{ "utime",	30 },
+	{ "utimensat",	301 },
+	{ "utimes",	336 },
+	{ "vfork",	113 },
+	{ "vhangup",	111 },
+	{ "vm86",	__PNR_vm86 },
+	{ "vm86old",	__PNR_vm86old },
+	{ "vmsplice",	294 },
+	{ "vserver",	263 },
+	{ "wait4",	114 },
+	{ "waitid",	235 },
+	{ "waitpid",	7 },
+	{ "write",	4 },
+	{ "writev",	146 },
+	{ NULL, __NR_SCMP_ERROR },
+};
+
+/**
+ * Resolve a syscall name to a number
+ * @param name the syscall name
+ *
+ * Resolve the given syscall name to the syscall number using the syscall table.
+ * Returns the syscall number on success, including negative pseudo syscall
+ * numbers; returns __NR_SCMP_ERROR on failure.
+ *
+ */
+int parisc_syscall_resolve_name(const char *name)
+{
+	unsigned int iter;
+	const struct arch_syscall_def *table = parisc_syscall_table;
+
+	/* XXX - plenty of room for future improvement here */
+	for (iter = 0; table[iter].name != NULL; iter++) {
+		if (strcmp(name, table[iter].name) == 0)
+			return table[iter].num;
+	}
+
+	return __NR_SCMP_ERROR;
+}
+
+/**
+ * Resolve a syscall number to a name
+ * @param num the syscall number
+ *
+ * Resolve the given syscall number to the syscall name using the syscall table.
+ * Returns a pointer to the syscall name string on success, including pseudo
+ * syscall names; returns NULL on failure.
+ *
+ */
+const char *parisc_syscall_resolve_num(int num)
+{
+	unsigned int iter;
+	const struct arch_syscall_def *table = parisc_syscall_table;
+
+	/* XXX - plenty of room for future improvement here */
+	for (iter = 0; table[iter].num != __NR_SCMP_ERROR; iter++) {
+		if (num == table[iter].num)
+			return table[iter].name;
+	}
+
+	return NULL;
+}
+
+/**
+ * Iterate through the syscall table and return the syscall name
+ * @param spot the offset into the syscall table
+ *
+ * Return the syscall name at position @spot or NULL on failure.  This function
+ * should only ever be used internally by libseccomp.
+ *
+ */
+const char *parisc_syscall_iterate_name(unsigned int spot)
+{
+	/* XXX - no safety checks here */
+	return parisc_syscall_table[spot].name;
+}
diff --git a/src/arch-parisc.c b/src/arch-parisc.c
new file mode 100644
index 0000000..f317fed
--- /dev/null
+++ b/src/arch-parisc.c
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2016 Helge Deller <deller@gmx.de>
+ * Author: Helge Deller <deller@gmx.de>
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <linux/audit.h>
+
+#include "arch.h"
+#include "arch-parisc.h"
+
+const struct arch_def arch_def_parisc = {
+	.token = SCMP_ARCH_PARISC,
+	.token_bpf = AUDIT_ARCH_PARISC,
+	.size = ARCH_SIZE_32,
+	.endian = ARCH_ENDIAN_BIG,
+	.syscall_resolve_name = parisc_syscall_resolve_name,
+	.syscall_resolve_num = parisc_syscall_resolve_num,
+	.syscall_rewrite = NULL,
+	.rule_add = NULL,
+};
diff --git a/src/arch-parisc.h b/src/arch-parisc.h
new file mode 100644
index 0000000..b9fe1df
--- /dev/null
+++ b/src/arch-parisc.h
@@ -0,0 +1,38 @@
+/**
+ * Enhanced Seccomp PARISC Specific Code
+ *
+ * Copyright (c) 2016 Helge Deller <deller@gmx.de>
+ *
+ */
+
+/*
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of version 2.1 of the GNU Lesser General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; if not, see <http://www.gnu.org/licenses>.
+ */
+
+#ifndef _ARCH_PARISC_H
+#define _ARCH_PARISC_H
+
+#include <inttypes.h>
+
+#include "arch.h"
+#include "system.h"
+
+extern const struct arch_def arch_def_parisc;
+extern const struct arch_def arch_def_parisc64;
+
+int parisc_syscall_resolve_name(const char *name);
+const char *parisc_syscall_resolve_num(int num);
+
+const char *parisc_syscall_iterate_name(unsigned int spot);
+
+#endif
diff --git a/src/arch-parisc64.c b/src/arch-parisc64.c
new file mode 100644
index 0000000..2b63120
--- /dev/null
+++ b/src/arch-parisc64.c
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2016 Helge Deller <deller@gmx.de>
+ * Author: Helge Deller <deller@gmx.de>
+*/
+
+#include <stdlib.h>
+#include <errno.h>
+#include <linux/audit.h>
+
+#include "arch.h"
+#include "arch-parisc.h"
+
+const struct arch_def arch_def_parisc64 = {
+	.token = SCMP_ARCH_PARISC64,
+	.token_bpf = AUDIT_ARCH_PARISC64,
+	.size = ARCH_SIZE_64,
+	.endian = ARCH_ENDIAN_BIG,
+	.syscall_resolve_name = parisc_syscall_resolve_name,
+	.syscall_resolve_num = parisc_syscall_resolve_num,
+	.syscall_rewrite = NULL,
+	.rule_add = NULL,
+};
diff --git a/src/arch-syscall-check.c b/src/arch-syscall-check.c
index 71ec0b5..db7fb89 100644
--- a/src/arch-syscall-check.c
+++ b/src/arch-syscall-check.c
@@ -33,6 +33,7 @@
 #include "arch-mips.h"
 #include "arch-mips64.h"
 #include "arch-mips64n32.h"
+#include "arch-parisc.h"
 #include "arch-ppc.h"
 #include "arch-ppc64.h"
 #include "arch-s390.h"
@@ -71,6 +72,7 @@ int main(int argc, char *argv[])
 	int i_mips = 0;
 	int i_mips64 = 0;
 	int i_mips64n32 = 0;
+	int i_parisc = 0;
 	int i_ppc = 0;
 	int i_ppc64 = 0;
 	int i_s390 = 0;
@@ -101,6 +103,8 @@ int main(int argc, char *argv[])
 			      mips64_syscall_iterate_name(i_mips64));
 		syscall_check(str_miss, sys_name, "mips64n32",
 			      mips64n32_syscall_iterate_name(i_mips64n32));
+		syscall_check(str_miss, sys_name, "parisc",
+			      parisc_syscall_iterate_name(i_parisc));
 		syscall_check(str_miss, sys_name, "ppc",
 			      ppc_syscall_iterate_name(i_ppc));
 		syscall_check(str_miss, sys_name, "ppc64",
@@ -135,6 +139,8 @@ int main(int argc, char *argv[])
 			i_mips64 = -1;
 		if (!mips64n32_syscall_iterate_name(++i_mips64n32))
 			i_mips64n32 = -1;
+		if (!parisc_syscall_iterate_name(++i_parisc))
+			i_parisc = -1;
 		if (!ppc_syscall_iterate_name(++i_ppc))
 			i_ppc = -1;
 		if (!ppc64_syscall_iterate_name(++i_ppc64))
@@ -146,6 +152,7 @@ int main(int argc, char *argv[])
 	} while (i_x86_64 >= 0 && i_x32 >= 0 &&
 		 i_arm >= 0 && i_aarch64 >= 0 &&
 		 i_mips >= 0 && i_mips64 >= 0 && i_mips64n32 >= 0 &&
+		 i_parisc >= 0 &&
 		 i_ppc >= 0 && i_ppc64 >= 0 &&
 		 i_s390 >= 0 && i_s390x >= 0);
 
@@ -190,6 +197,10 @@ int main(int argc, char *argv[])
 		       mips64n32_syscall_iterate_name(i_mips64n32));
 		return 1;
 	}
+	if (i_parisc >= 0) {
+		printf("%s: ERROR, parisc has additional syscalls\n",
+		       parisc_syscall_iterate_name(i_parisc));
+	}
 	if (i_ppc >= 0) {
 		printf("%s: ERROR, ppc has additional syscalls\n",
 		       ppc_syscall_iterate_name(i_ppc));
diff --git a/src/arch-syscall-dump.c b/src/arch-syscall-dump.c
index 636fd9a..c95b899 100644
--- a/src/arch-syscall-dump.c
+++ b/src/arch-syscall-dump.c
@@ -38,6 +38,7 @@
 #include "arch-mips64.h"
 #include "arch-mips64n32.h"
 #include "arch-aarch64.h"
+#include "arch-parisc.h"
 #include "arch-ppc.h"
 #include "arch-ppc64.h"
 #include "arch-s390.h"
@@ -116,6 +117,10 @@ int main(int argc, char *argv[])
 		case SCMP_ARCH_MIPSEL64N32:
 			sys_name = mips64n32_syscall_iterate_name(iter);
 			break;
+		case SCMP_ARCH_PARISC:
+		case SCMP_ARCH_PARISC64:
+			sys_name = parisc_syscall_iterate_name(iter);
+			break;
 		case SCMP_ARCH_PPC:
 			sys_name = ppc_syscall_iterate_name(iter);
 			break;
diff --git a/src/arch.c b/src/arch.c
index 0f24d1c..f5a898d 100644
--- a/src/arch.c
+++ b/src/arch.c
@@ -38,6 +38,7 @@
 #include "arch-mips.h"
 #include "arch-mips64.h"
 #include "arch-mips64n32.h"
+#include "arch-parisc.h"
 #include "arch-ppc.h"
 #include "arch-ppc64.h"
 #include "arch-s390.h"
@@ -79,6 +80,10 @@ const struct arch_def *arch_def_native = &arch_def_mips64n32;
 #elif __MIPSEL__
 const struct arch_def *arch_def_native = &arch_def_mipsel64n32;
 #endif /* _MIPS_SIM_NABI32 */
+#elif __hppa64__ /* hppa64 must be checked before hppa */
+const struct arch_def *arch_def_native = &arch_def_parisc64;
+#elif __hppa__
+const struct arch_def *arch_def_native = &arch_def_parisc;
 #elif __PPC64__
 #ifdef __BIG_ENDIAN__
 const struct arch_def *arch_def_native = &arch_def_ppc64;
@@ -139,6 +144,10 @@ const struct arch_def *arch_def_lookup(uint32_t token)
 		return &arch_def_mips64n32;
 	case SCMP_ARCH_MIPSEL64N32:
 		return &arch_def_mipsel64n32;
+	case SCMP_ARCH_PARISC:
+		return &arch_def_parisc;
+	case SCMP_ARCH_PARISC64:
+		return &arch_def_parisc64;
 	case SCMP_ARCH_PPC:
 		return &arch_def_ppc;
 	case SCMP_ARCH_PPC64:
@@ -185,6 +194,10 @@ const struct arch_def *arch_def_lookup_name(const char *arch_name)
 		return &arch_def_mips64n32;
 	else if (strcmp(arch_name, "mipsel64n32") == 0)
 		return &arch_def_mipsel64n32;
+	else if (strcmp(arch_name, "parisc64") == 0)
+		return &arch_def_parisc64;
+	else if (strcmp(arch_name, "parisc") == 0)
+		return &arch_def_parisc;
 	else if (strcmp(arch_name, "ppc") == 0)
 		return &arch_def_ppc;
 	else if (strcmp(arch_name, "ppc64") == 0)
diff --git a/src/gen_pfc.c b/src/gen_pfc.c
index 99c3297..b9c122e 100644
--- a/src/gen_pfc.c
+++ b/src/gen_pfc.c
@@ -71,6 +71,10 @@ static const char *_pfc_arch(const struct arch_def *arch)
 		return "mips64n32";
 	case SCMP_ARCH_MIPSEL64N32:
 		return "mipsel64n32";
+	case SCMP_ARCH_PARISC:
+		return "parisc";
+	case SCMP_ARCH_PARISC64:
+		return "parisc64";
 	case SCMP_ARCH_PPC64:
 		return "ppc64";
 	case SCMP_ARCH_PPC64LE:
diff --git a/src/python/libseccomp.pxd b/src/python/libseccomp.pxd
index 15c94f8..500da15 100644
--- a/src/python/libseccomp.pxd
+++ b/src/python/libseccomp.pxd
@@ -43,6 +43,8 @@ cdef extern from "seccomp.h":
         SCMP_ARCH_MIPSEL
         SCMP_ARCH_MIPSEL64
         SCMP_ARCH_MIPSEL64N32
+        SCMP_ARCH_PARISC
+        SCMP_ARCH_PARISC64
         SCMP_ARCH_PPC
         SCMP_ARCH_PPC64
         SCMP_ARCH_PPC64LE
diff --git a/src/python/seccomp.pyx b/src/python/seccomp.pyx
index c87bc3f..cb17642 100644
--- a/src/python/seccomp.pyx
+++ b/src/python/seccomp.pyx
@@ -147,6 +147,8 @@ cdef class Arch:
     MIPSEL - MIPS little endian O32 ABI
     MIPSEL64 - MIPS little endian 64-bit ABI
     MIPSEL64N32 - MIPS little endian N32 ABI
+    PARISC - 32-bit PA-RISC
+    PARISC64 - 64-bit PA-RISC
     PPC64 - 64-bit PowerPC
     PPC - 32-bit PowerPC
     """
@@ -165,6 +167,8 @@ cdef class Arch:
     MIPSEL = libseccomp.SCMP_ARCH_MIPSEL
     MIPSEL64 = libseccomp.SCMP_ARCH_MIPSEL64
     MIPSEL64N32 = libseccomp.SCMP_ARCH_MIPSEL64N32
+    PARISC = libseccomp.SCMP_ARCH_PARISC
+    PARISC64 = libseccomp.SCMP_ARCH_PARISC64
     PPC = libseccomp.SCMP_ARCH_PPC
     PPC64 = libseccomp.SCMP_ARCH_PPC64
     PPC64LE = libseccomp.SCMP_ARCH_PPC64LE
@@ -205,6 +209,10 @@ cdef class Arch:
                 self._token = libseccomp.SCMP_ARCH_MIPSEL64
             elif arch == libseccomp.SCMP_ARCH_MIPSEL64N32:
                 self._token = libseccomp.SCMP_ARCH_MIPSEL64N32
+            elif arch == libseccomp.SCMP_ARCH_PARISC:
+                self._token = libseccomp.SCMP_ARCH_PARISC
+            elif arch == libseccomp.SCMP_ARCH_PARISC64:
+                self._token = libseccomp.SCMP_ARCH_PARISC64
             elif arch == libseccomp.SCMP_ARCH_PPC:
                 self._token = libseccomp.SCMP_ARCH_PPC
             elif arch == libseccomp.SCMP_ARCH_PPC64:
diff --git a/tests/26-sim-arch_all_be_basic.c b/tests/26-sim-arch_all_be_basic.c
index d2c191c..d31ce12 100644
--- a/tests/26-sim-arch_all_be_basic.c
+++ b/tests/26-sim-arch_all_be_basic.c
@@ -52,6 +52,12 @@ int main(int argc, char *argv[])
 	rc = seccomp_arch_add(ctx, seccomp_arch_resolve_name("mips64n32"));
 	if (rc != 0)
 		goto out;
+	rc = seccomp_arch_add(ctx, seccomp_arch_resolve_name("parisc"));
+	if (rc != 0)
+		goto out;
+	rc = seccomp_arch_add(ctx, seccomp_arch_resolve_name("parisc64"));
+	if (rc != 0)
+		goto out;
 	rc = seccomp_arch_add(ctx, seccomp_arch_resolve_name("ppc"));
 	if (rc != 0)
 		goto out;
diff --git a/tests/26-sim-arch_all_be_basic.py b/tests/26-sim-arch_all_be_basic.py
index b0b660a..3a177b4 100755
--- a/tests/26-sim-arch_all_be_basic.py
+++ b/tests/26-sim-arch_all_be_basic.py
@@ -33,6 +33,8 @@ def test(args):
     f.add_arch(Arch("mips"))
     f.add_arch(Arch("mips64"))
     f.add_arch(Arch("mips64n32"))
+    f.add_arch(Arch("parisc"))
+    f.add_arch(Arch("parisc64"))
     f.add_arch(Arch("ppc"))
     f.add_arch(Arch("ppc64"))
     f.add_arch(Arch("s390"))
diff --git a/tests/regression b/tests/regression
index 229b8a4..40567d5 100755
--- a/tests/regression
+++ b/tests/regression
@@ -28,6 +28,7 @@ GLBL_ARCH_LE_SUPPORT=" \
 	ppc64le"
 GLBL_ARCH_BE_SUPPORT=" \
 	mips mips64 mips64n32 \
+	parisc parisc64 \
 	ppc ppc64 \
 	s390 s390x"
 
@@ -702,7 +703,7 @@ function run_test_live() {
 
 	# setup the arch specific return values
 	case "$arch" in
-	x86|x86_64|x32|arm|aarch64|ppc|ppc64|ppc64le|ppc|s390|s390x)
+	x86|x86_64|x32|arm|aarch64|parisc|parisc64|ppc|ppc64|ppc64le|ppc|s390|s390x)
 		rc_kill=159
 		rc_allow=160
 		rc_trap=161
diff --git a/tools/scmp_arch_detect.c b/tools/scmp_arch_detect.c
index 4b452d1..ad43f2d 100644
--- a/tools/scmp_arch_detect.c
+++ b/tools/scmp_arch_detect.c
@@ -99,6 +99,12 @@ int main(int argc, char *argv[])
 		case SCMP_ARCH_MIPSEL64N32:
 			printf("mipsel64n32\n");
 			break;
+		case SCMP_ARCH_PARISC:
+			printf("parisc\n");
+			break;
+		case SCMP_ARCH_PARISC64:
+			printf("parisc64\n");
+			break;
 		case SCMP_ARCH_PPC:
 			printf("ppc\n");
 			break;
diff --git a/tools/scmp_bpf_sim.c b/tools/scmp_bpf_sim.c
index a0cf6d1..3d3204a 100644
--- a/tools/scmp_bpf_sim.c
+++ b/tools/scmp_bpf_sim.c
@@ -265,6 +265,10 @@ int main(int argc, char *argv[])
 				arch = AUDIT_ARCH_MIPS64N32;
 			else if (strcmp(optarg, "mipsel64n32") == 0)
 				arch = AUDIT_ARCH_MIPSEL64N32;
+			else if (strcmp(optarg, "parisc") == 0)
+				arch = AUDIT_ARCH_PARISC;
+			else if (strcmp(optarg, "parisc64") == 0)
+				arch = AUDIT_ARCH_PARISC64;
 			else if (strcmp(optarg, "ppc") == 0)
 				arch = AUDIT_ARCH_PPC;
 			else if (strcmp(optarg, "ppc64") == 0)
diff --git a/tools/util.c b/tools/util.c
index cc48647..7122335 100644
--- a/tools/util.c
+++ b/tools/util.c
@@ -62,6 +62,10 @@
 #elif __MIPSEL__
 #define ARCH_NATIVE		AUDIT_ARCH_MIPSEL64N32
 #endif /* _MIPS_SIM_NABI32 */
+#elif __hppa64__
+#define ARCH_NATIVE		AUDIT_ARCH_PARISC64
+#elif __hppa__
+#define ARCH_NATIVE		AUDIT_ARCH_PARISC
 #elif __PPC64__
 #ifdef __BIG_ENDIAN__
 #define ARCH_NATIVE		AUDIT_ARCH_PPC64
