diff -Nru libseccomp-2.4.3/debian/changelog libseccomp-2.4.3/debian/changelog --- libseccomp-2.4.3/debian/changelog 2020-06-02 04:39:28.000000000 +0000 +++ libseccomp-2.4.3/debian/changelog 2020-08-17 05:26:06.000000000 +0000 @@ -1,3 +1,21 @@ +libseccomp (2.4.3-1ubuntu3.18.04.4) bionic; urgency=medium + + * Update syscall tables for new upstream kernel versions (LP: 1891810) + - d/p/update-internal-syscall-tables.patch: Upstream patch to update the + internal syscall tables to list all syscalls from the 5.8-rc7 upstream + kernel + + -- Alex Murray Mon, 17 Aug 2020 14:56:06 +0930 + +libseccomp (2.4.3-1ubuntu3.18.04.3) bionic; urgency=medium + + * d/p/db-consolidate-some-of-the-code-which-adds-rules.patch + * d/p/db-add-shadow-transactions.patch (LP: #1861177) + Backport upstream patches to address performance regression introduced + in libseccomp 2.4. + + -- Ioanna Alifieraki Mon, 29 Jun 2020 13:52:22 +0100 + libseccomp (2.4.3-1ubuntu3.18.04.2) bionic; urgency=medium * Updated to new upstream 2.4.3 version for updated syscalls support diff -Nru libseccomp-2.4.3/debian/patches/db-add-shadow-transactions.patch libseccomp-2.4.3/debian/patches/db-add-shadow-transactions.patch --- libseccomp-2.4.3/debian/patches/db-add-shadow-transactions.patch 1970-01-01 00:00:00.000000000 +0000 +++ libseccomp-2.4.3/debian/patches/db-add-shadow-transactions.patch 2020-06-29 12:52:22.000000000 +0000 @@ -0,0 +1,208 @@ +From bc3a6c0453b0350ee43e4925482f705a2fbf5a4d Mon Sep 17 00:00:00 2001 +From: Paul Moore +Origin: Upstream, https://github.com/seccomp/libseccomp/pull/180/commits/bc3a6c0453b0350ee43e4925482f705a2fbf5a4d +Bug: https://github.com/seccomp/libseccomp/issues/153 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/1861177 +Date: Mon, 4 Nov 2019 20:15:20 -0500 +Subject: [PATCH] db: add shadow transactions + +Creating a transaction can be very time consuming on large filters since we +create a duplicate filter tree iteratively using the rules supplied by the +caller. In an effort to speed this up we introduce the idea of shadow +transactions where on a successful transaction commit we preserve the old +transaction checkpoint and bring it up to date with the current filter and +save it for future use. The next time we start a new transaction we check +to see if a shadow transaction exists, if it does we use that instead of +creating a new transaction checkpoint from scratch. + +Signed-off-by: Paul Moore +--- + src/db.c | 127 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- + src/db.h | 1 + + 2 files changed, 127 insertions(+), 1 deletion(-) + +Index: libseccomp-2.4.3/src/db.c +=================================================================== +--- libseccomp-2.4.3.orig/src/db.c ++++ libseccomp-2.4.3/src/db.c +@@ -909,6 +909,9 @@ static void _db_snap_release(struct db_f + { + unsigned int iter; + ++ if (snap == NULL) ++ return; ++ + if (snap->filter_cnt > 0) { + for (iter = 0; iter < snap->filter_cnt; iter++) { + if (snap->filters[iter]) +@@ -1128,6 +1131,7 @@ init_failure: + void db_col_release(struct db_filter_col *col) + { + unsigned int iter; ++ struct db_filter_snap *snap; + + if (col == NULL) + return; +@@ -1135,6 +1139,13 @@ void db_col_release(struct db_filter_col + /* set the state, just in case */ + col->state = _DB_STA_FREED; + ++ /* free any snapshots */ ++ while (col->snapshots != NULL) { ++ snap = col->snapshots; ++ col->snapshots = snap->next; ++ _db_snap_release(snap); ++ } ++ + /* free any filters */ + for (iter = 0; iter < col->filter_cnt; iter++) + _db_release(col->filters[iter]); +@@ -2307,6 +2318,20 @@ int db_col_transaction_start(struct db_f + struct db_filter *filter_o, *filter_s; + struct db_api_rule_list *rule_o, *rule_s = NULL; + ++ /* check to see if a shadow snapshot exists */ ++ if (col->snapshots && col->snapshots->shadow) { ++ /* we have a shadow! this will be easy */ ++ ++ /* NOTE: we don't bother to do any verification of the shadow ++ * because we start a new transaction every time we add ++ * a new rule to the filter(s); if this ever changes we ++ * will need to add a mechanism to verify that the shadow ++ * transaction is current/correct */ ++ ++ col->snapshots->shadow = false; ++ return 0; ++ } ++ + /* allocate the snapshot */ + snap = zmalloc(sizeof(*snap)); + if (snap == NULL) +@@ -2400,14 +2425,114 @@ void db_col_transaction_abort(struct db_ + * Commit the top most seccomp filter transaction + * @param col the filter collection + * +- * This function commits the most recent seccomp filter transaction. ++ * This function commits the most recent seccomp filter transaction and ++ * attempts to create a shadow transaction that is a duplicate of the current ++ * filter to speed up future transactions. + * + */ + void db_col_transaction_commit(struct db_filter_col *col) + { ++ int rc; ++ unsigned int iter; + struct db_filter_snap *snap; ++ struct db_filter *filter_o, *filter_s; ++ struct db_api_rule_list *rule_o, *rule_s; + + snap = col->snapshots; ++ if (snap == NULL) ++ return; ++ ++ /* check for a shadow set by a higher transaction commit */ ++ if (snap->shadow) { ++ /* leave the shadow intact, but drop the next snapshot */ ++ if (snap->next) { ++ snap->next = snap->next->next; ++ _db_snap_release(snap->next); ++ } ++ return; ++ } ++ ++ /* adjust the number of filters if needed */ ++ if (col->filter_cnt > snap->filter_cnt) { ++ unsigned int tmp_i; ++ struct db_filter **tmp_f; ++ ++ /* add filters */ ++ tmp_f = realloc(snap->filters, ++ sizeof(struct db_filter *) * col->filter_cnt); ++ if (tmp_f == NULL) ++ goto shadow_err; ++ snap->filters = tmp_f; ++ do { ++ tmp_i = snap->filter_cnt; ++ snap->filters[tmp_i] = ++ _db_init(col->filters[tmp_i]->arch); ++ if (snap->filters[tmp_i] == NULL) ++ goto shadow_err; ++ snap->filter_cnt++; ++ } while (snap->filter_cnt < col->filter_cnt); ++ } else if (col->filter_cnt < snap->filter_cnt) { ++ /* remove filters */ ++ ++ /* NOTE: while we release the filters we no longer need, we ++ * don't bother to resize the filter array, we just ++ * adjust the filter counter, this *should* be harmless ++ * at the cost of a not reaping all the memory possible */ ++ ++ do { ++ _db_release(snap->filters[snap->filter_cnt--]); ++ } while (snap->filter_cnt > col->filter_cnt); ++ } ++ ++ /* loop through each filter and update the rules on the snapshot */ ++ for (iter = 0; iter < col->filter_cnt; iter++) { ++ filter_o = col->filters[iter]; ++ filter_s = snap->filters[iter]; ++ ++ /* skip ahead to the new rule(s) */ ++ rule_o = filter_o->rules; ++ rule_s = filter_s->rules; ++ if (rule_o == NULL) ++ /* nothing to shadow */ ++ continue; ++ if (rule_s != NULL) { ++ do { ++ rule_o = rule_o->next; ++ rule_s = rule_s->next; ++ } while (rule_s != filter_s->rules); ++ ++ /* did we actually add any rules? */ ++ if (rule_o == filter_o->rules) ++ /* no, we are done in this case */ ++ continue; ++ } ++ ++ /* update the old snapshot to make it a shadow */ ++ do { ++ /* duplicate the rule */ ++ rule_s = db_rule_dup(rule_o); ++ if (rule_s == NULL) ++ goto shadow_err; ++ ++ /* add the rule */ ++ rc = _db_col_rule_add(filter_s, rule_s); ++ if (rc != 0) { ++ free(rule_s); ++ goto shadow_err; ++ } ++ ++ /* next rule */ ++ rule_o = rule_o->next; ++ } while (rule_o != filter_o->rules); ++ } ++ ++ /* success, mark the snapshot as a shadow and return */ ++ snap->shadow = true; ++ return; ++ ++shadow_err: ++ /* we failed making a shadow, cleanup and return */ + col->snapshots = snap->next; + _db_snap_release(snap); ++ return; + } +Index: libseccomp-2.4.3/src/db.h +=================================================================== +--- libseccomp-2.4.3.orig/src/db.h ++++ libseccomp-2.4.3/src/db.h +@@ -133,6 +133,7 @@ struct db_filter_snap { + /* individual filters */ + struct db_filter **filters; + unsigned int filter_cnt; ++ bool shadow; + + struct db_filter_snap *next; + }; diff -Nru libseccomp-2.4.3/debian/patches/db-consolidate-some-of-the-code-which-adds-rules.patch libseccomp-2.4.3/debian/patches/db-consolidate-some-of-the-code-which-adds-rules.patch --- libseccomp-2.4.3/debian/patches/db-consolidate-some-of-the-code-which-adds-rules.patch 1970-01-01 00:00:00.000000000 +0000 +++ libseccomp-2.4.3/debian/patches/db-consolidate-some-of-the-code-which-adds-rules.patch 2020-06-29 12:52:22.000000000 +0000 @@ -0,0 +1,157 @@ +From fb0dfd1289883b086311bb8ce6ebd8575378f24b Mon Sep 17 00:00:00 2001 +From: Paul Moore +Origin: Upstream, https://github.com/seccomp/libseccomp/pull/180/commits/fb0dfd1289883b086311bb8ce6ebd8575378f24b +Bug: https://github.com/seccomp/libseccomp/issues/153 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/1861177 +Date: Fri, 1 Nov 2019 12:05:58 -0400 +Subject: [PATCH] db: consolidate some of the code which adds rules to a single + filter + +Pay back some of the technical debt in db_col_rule_add(), no logic +changes in this patch, just removing some code duplication. + +Signed-off-by: Paul Moore +--- + src/db.c | 85 +++++++++++++++++++++++++++++--------------------------- + 1 file changed, 44 insertions(+), 41 deletions(-) + +Index: libseccomp-2.4.3/src/db.c +=================================================================== +--- libseccomp-2.4.3.orig/src/db.c ++++ libseccomp-2.4.3/src/db.c +@@ -2147,6 +2147,44 @@ priority_failure: + } + + /** ++ * Add a new rule to a single filter ++ * @param filter the filter ++ * @param rule the filter rule ++ * ++ * This is a helper function for db_col_rule_add() and similar functions, it ++ * isn't generally useful. Returns zero on success, negative values on error. ++ * ++ */ ++static int _db_col_rule_add(struct db_filter *filter, ++ struct db_api_rule_list *rule) ++{ ++ int rc; ++ struct db_api_rule_list *iter; ++ ++ /* add the rule to the filter */ ++ rc = arch_filter_rule_add(filter, rule); ++ if (rc != 0) ++ return rc; ++ ++ /* insert the chain to the end of the rule list */ ++ iter = rule; ++ while (iter->next) ++ iter = iter->next; ++ if (filter->rules != NULL) { ++ rule->prev = filter->rules->prev; ++ iter->next = filter->rules; ++ filter->rules->prev->next = rule; ++ filter->rules->prev = iter; ++ } else { ++ rule->prev = iter; ++ iter->next = rule; ++ filter->rules = rule; ++ } ++ ++ return 0; ++} ++ ++/** + * Add a new rule to the current filter + * @param col the filter collection + * @param strict the strict flag +@@ -2174,7 +2212,7 @@ int db_col_rule_add(struct db_filter_col + size_t chain_size; + struct db_api_arg *chain = NULL; + struct scmp_arg_cmp arg_data; +- struct db_api_rule_list *rule, *rule_tmp; ++ struct db_api_rule_list *rule; + struct db_filter *db; + + /* collect the arguments for the filter rule */ +@@ -2222,9 +2260,6 @@ int db_col_rule_add(struct db_filter_col + + /* add the rule to the different filters in the collection */ + for (iter = 0; iter < col->filter_cnt; iter++) { +- +- /* TODO: consolidate with db_col_transaction_start() */ +- + db = col->filters[iter]; + + /* create the rule */ +@@ -2235,24 +2270,10 @@ int db_col_rule_add(struct db_filter_col + } + + /* add the rule */ +- rc_tmp = arch_filter_rule_add(db, rule); +- if (rc_tmp == 0) { +- /* insert the chain to the end of the rule list */ +- rule_tmp = rule; +- while (rule_tmp->next) +- rule_tmp = rule_tmp->next; +- if (db->rules != NULL) { +- rule->prev = db->rules->prev; +- rule_tmp->next = db->rules; +- db->rules->prev->next = rule; +- db->rules->prev = rule_tmp; +- } else { +- rule->prev = rule_tmp; +- rule_tmp->next = rule; +- db->rules = rule; +- } +- } else ++ rc_tmp = _db_col_rule_add(db, rule); ++ if (rc_tmp != 0) + free(rule); ++ + add_arch_fail: + if (rc_tmp != 0 && rc == 0) + rc = rc_tmp; +@@ -2284,7 +2305,7 @@ int db_col_transaction_start(struct db_f + unsigned int iter; + struct db_filter_snap *snap; + struct db_filter *filter_o, *filter_s; +- struct db_api_rule_list *rule_o, *rule_s = NULL, *rule_tmp; ++ struct db_api_rule_list *rule_o, *rule_s = NULL; + + /* allocate the snapshot */ + snap = zmalloc(sizeof(*snap)); +@@ -2314,33 +2335,15 @@ int db_col_transaction_start(struct db_f + if (rule_o == NULL) + continue; + do { +- +- /* TODO: consolidate with db_col_rule_add() */ +- + /* duplicate the rule */ + rule_s = db_rule_dup(rule_o); + if (rule_s == NULL) + goto trans_start_failure; + + /* add the rule */ +- rc = arch_filter_rule_add(filter_s, rule_s); ++ rc = _db_col_rule_add(filter_s, rule_s); + if (rc != 0) + goto trans_start_failure; +- +- /* insert the chain to the end of the rule list */ +- rule_tmp = rule_s; +- while (rule_tmp->next) +- rule_tmp = rule_tmp->next; +- if (filter_s->rules != NULL) { +- rule_s->prev = filter_s->rules->prev; +- rule_tmp->next = filter_s->rules; +- filter_s->rules->prev->next = rule_s; +- filter_s->rules->prev = rule_tmp; +- } else { +- rule_s->prev = rule_tmp; +- rule_tmp->next = rule_s; +- filter_s->rules = rule_s; +- } + rule_s = NULL; + + /* next rule */ diff -Nru libseccomp-2.4.3/debian/patches/series libseccomp-2.4.3/debian/patches/series --- libseccomp-2.4.3/debian/patches/series 2020-05-19 05:08:40.000000000 +0000 +++ libseccomp-2.4.3/debian/patches/series 2020-08-17 05:26:00.000000000 +0000 @@ -1,2 +1,5 @@ fix-aarch64-syscalls.patch add-5.4-local-syscall-headers.patch +db-consolidate-some-of-the-code-which-adds-rules.patch +db-add-shadow-transactions.patch +update-internal-syscall-tables.ptch diff -Nru libseccomp-2.4.3/debian/patches/update-internal-syscall-tables.ptch libseccomp-2.4.3/debian/patches/update-internal-syscall-tables.ptch --- libseccomp-2.4.3/debian/patches/update-internal-syscall-tables.ptch 1970-01-01 00:00:00.000000000 +0000 +++ libseccomp-2.4.3/debian/patches/update-internal-syscall-tables.ptch 2020-08-17 05:26:00.000000000 +0000 @@ -0,0 +1,754 @@ +From b3206ad5645dceda89538ea8acc984078ab697ab Mon Sep 17 00:00:00 2001 +From: Tom Hromatka +Date: Tue, 28 Jul 2020 14:03:56 -0600 +Subject: [PATCH] arch: Update the internal syscall tables to Linux v5.8-rc7 + +Most architectures had minor changes (faccessat2, openat2, pidfd_getfd), +but a significant number of changes were made to parisc since it went +so long without being checked by arch-syscall-validate. + +Signed-off-by: Tom Hromatka +Acked-by: Paul Moore +--- + src/arch-aarch64-syscalls.c | 5 +- + src/arch-arm-syscalls.c | 5 +- + src/arch-mips-syscalls.c | 5 +- + src/arch-mips64-syscalls.c | 5 +- + src/arch-mips64n32-syscalls.c | 5 +- + src/arch-parisc-syscalls.c | 97 ++++++++++++++++++----------------- + src/arch-ppc-syscalls.c | 5 +- + src/arch-ppc64-syscalls.c | 5 +- + src/arch-s390-syscalls.c | 5 +- + src/arch-s390x-syscalls.c | 5 +- + src/arch-x32-syscalls.c | 5 +- + src/arch-x86-syscalls.c | 5 +- + src/arch-x86_64-syscalls.c | 5 +- + 13 files changed, 98 insertions(+), 59 deletions(-) + +diff --git a/src/arch-aarch64-syscalls.c b/src/arch-aarch64-syscalls.c +index 7454eabe..de2ea63e 100644 +--- a/src/arch-aarch64-syscalls.c ++++ b/src/arch-aarch64-syscalls.c +@@ -26,7 +26,7 @@ + #include "arch.h" + #include "arch-aarch64.h" + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def aarch64_syscall_table[] = { \ + { "_llseek", __PNR__llseek }, + { "_newselect", __PNR__newselect }, +@@ -92,6 +92,7 @@ const struct arch_syscall_def aarch64_syscall_table[] = { \ + { "exit", 93 }, + { "exit_group", 94 }, + { "faccessat", 48 }, ++ { "faccessat2", 439 }, + { "fadvise64", 223 }, + { "fadvise64_64", __PNR_fadvise64_64 }, + { "fallocate", 47 }, +@@ -266,12 +267,14 @@ const struct arch_syscall_def aarch64_syscall_table[] = { \ + { "open_by_handle_at", 265 }, + { "open_tree", 428 }, + { "openat", 56 }, ++ { "openat2", 437 }, + { "pause", __PNR_pause }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", 241 }, + { "personality", 92 }, ++ { "pidfd_getfd", 438 }, + { "pidfd_open", 434 }, + { "pidfd_send_signal", 424 }, + { "pipe", __PNR_pipe }, +diff --git a/src/arch-arm-syscalls.c b/src/arch-arm-syscalls.c +index 923aae9d..c574e2ec 100644 +--- a/src/arch-arm-syscalls.c ++++ b/src/arch-arm-syscalls.c +@@ -37,7 +37,7 @@ + #define __SCMP_NR_BASE __SCMP_NR_OABI_SYSCALL_BASE + #endif + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def arm_syscall_table[] = { \ + /* NOTE: arm_sync_file_range() and sync_file_range2() share values */ + { "_llseek", (__SCMP_NR_BASE + 140) }, +@@ -104,6 +104,7 @@ const struct arch_syscall_def arm_syscall_table[] = { \ + { "exit", (__SCMP_NR_BASE + 1) }, + { "exit_group", (__SCMP_NR_BASE + 248) }, + { "faccessat", (__SCMP_NR_BASE + 334) }, ++ { "faccessat2", (__SCMP_NR_BASE + 439) }, + { "fadvise64", __PNR_fadvise64 }, + { "fadvise64_64", __PNR_fadvise64_64 }, + { "fallocate", (__SCMP_NR_BASE + 352) }, +@@ -278,12 +279,14 @@ const struct arch_syscall_def arm_syscall_table[] = { \ + { "open_by_handle_at", (__SCMP_NR_BASE + 371) }, + { "open_tree", (__SCMP_NR_BASE + 428) }, + { "openat", (__SCMP_NR_BASE + 322) }, ++ { "openat2", (__SCMP_NR_BASE + 437) }, + { "pause", (__SCMP_NR_BASE + 29) }, + { "pciconfig_iobase", (__SCMP_NR_BASE + 271) }, + { "pciconfig_read", (__SCMP_NR_BASE + 272) }, + { "pciconfig_write", (__SCMP_NR_BASE + 273) }, + { "perf_event_open", (__SCMP_NR_BASE + 364) }, + { "personality", (__SCMP_NR_BASE + 136) }, ++ { "pidfd_getfd", (__SCMP_NR_BASE + 438) }, + { "pidfd_open", (__SCMP_NR_BASE + 434) }, + { "pidfd_send_signal", (__SCMP_NR_BASE + 424) }, + { "pipe", (__SCMP_NR_BASE + 42) }, +diff --git a/src/arch-mips-syscalls.c b/src/arch-mips-syscalls.c +index c0c5d409..ae10f841 100644 +--- a/src/arch-mips-syscalls.c ++++ b/src/arch-mips-syscalls.c +@@ -30,7 +30,7 @@ + /* O32 ABI */ + #define __SCMP_NR_BASE 4000 + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def mips_syscall_table[] = { \ + { "_llseek", (__SCMP_NR_BASE + 140) }, + { "_newselect", (__SCMP_NR_BASE + 142) }, +@@ -96,6 +96,7 @@ const struct arch_syscall_def mips_syscall_table[] = { \ + { "exit", (__SCMP_NR_BASE + 1) }, + { "exit_group", (__SCMP_NR_BASE + 246) }, + { "faccessat", (__SCMP_NR_BASE + 300) }, ++ { "faccessat2", (__SCMP_NR_BASE + 439) }, + { "fadvise64", __SCMP_NR_BASE + 254 }, + { "fadvise64_64", __PNR_fadvise64_64 }, + { "fallocate", (__SCMP_NR_BASE + 320) }, +@@ -270,12 +271,14 @@ const struct arch_syscall_def mips_syscall_table[] = { \ + { "open_by_handle_at", (__SCMP_NR_BASE + 340) }, + { "open_tree", (__SCMP_NR_BASE + 428) }, + { "openat", (__SCMP_NR_BASE + 288) }, ++ { "openat2", (__SCMP_NR_BASE + 437) }, + { "pause", (__SCMP_NR_BASE + 29) }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", (__SCMP_NR_BASE + 333) }, + { "personality", (__SCMP_NR_BASE + 136) }, ++ { "pidfd_getfd", (__SCMP_NR_BASE + 438) }, + { "pidfd_open", (__SCMP_NR_BASE + 434) }, + { "pidfd_send_signal", (__SCMP_NR_BASE + 424) }, + { "pipe", (__SCMP_NR_BASE + 42) }, +diff --git a/src/arch-mips64-syscalls.c b/src/arch-mips64-syscalls.c +index af23ff4c..43d15457 100644 +--- a/src/arch-mips64-syscalls.c ++++ b/src/arch-mips64-syscalls.c +@@ -30,7 +30,7 @@ + /* 64 ABI */ + #define __SCMP_NR_BASE 5000 + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def mips64_syscall_table[] = { \ + { "_llseek", __PNR__llseek }, + { "_newselect", (__SCMP_NR_BASE + 22) }, +@@ -96,6 +96,7 @@ const struct arch_syscall_def mips64_syscall_table[] = { \ + { "exit", (__SCMP_NR_BASE + 58) }, + { "exit_group", (__SCMP_NR_BASE + 205) }, + { "faccessat", (__SCMP_NR_BASE + 259) }, ++ { "faccessat2", (__SCMP_NR_BASE + 439) }, + { "fadvise64", (__SCMP_NR_BASE + 215) }, + { "fadvise64_64", __PNR_fadvise64_64 }, + { "fallocate", (__SCMP_NR_BASE + 279) }, +@@ -270,12 +271,14 @@ const struct arch_syscall_def mips64_syscall_table[] = { \ + { "open_by_handle_at", (__SCMP_NR_BASE + 299) }, + { "open_tree", (__SCMP_NR_BASE + 428) }, + { "openat", (__SCMP_NR_BASE + 247) }, ++ { "openat2", (__SCMP_NR_BASE + 437) }, + { "pause", (__SCMP_NR_BASE + 33) }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", (__SCMP_NR_BASE + 292) }, + { "personality", (__SCMP_NR_BASE + 132) }, ++ { "pidfd_getfd", (__SCMP_NR_BASE + 438) }, + { "pidfd_open", (__SCMP_NR_BASE + 434) }, + { "pidfd_send_signal", (__SCMP_NR_BASE + 424) }, + { "pipe", (__SCMP_NR_BASE + 21) }, +diff --git a/src/arch-mips64n32-syscalls.c b/src/arch-mips64n32-syscalls.c +index 2159bccc..e4f40fe2 100644 +--- a/src/arch-mips64n32-syscalls.c ++++ b/src/arch-mips64n32-syscalls.c +@@ -30,7 +30,7 @@ + /* N32 ABI */ + #define __SCMP_NR_BASE 6000 + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def mips64n32_syscall_table[] = { \ + { "_llseek", __PNR__llseek }, + { "_newselect", (__SCMP_NR_BASE + 22) }, +@@ -96,6 +96,7 @@ const struct arch_syscall_def mips64n32_syscall_table[] = { \ + { "exit", (__SCMP_NR_BASE + 58) }, + { "exit_group", (__SCMP_NR_BASE + 205) }, + { "faccessat", (__SCMP_NR_BASE + 263) }, ++ { "faccessat2", (__SCMP_NR_BASE + 439) }, + { "fadvise64", (__SCMP_NR_BASE + 216) }, + { "fadvise64_64", __PNR_fadvise64_64 }, + { "fallocate", (__SCMP_NR_BASE + 283) }, +@@ -270,12 +271,14 @@ const struct arch_syscall_def mips64n32_syscall_table[] = { \ + { "open_by_handle_at", (__SCMP_NR_BASE + 304) }, + { "open_tree", (__SCMP_NR_BASE + 428) }, + { "openat", (__SCMP_NR_BASE + 251) }, ++ { "openat2", (__SCMP_NR_BASE + 437) }, + { "pause", (__SCMP_NR_BASE + 33) }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", (__SCMP_NR_BASE + 296) }, + { "personality", (__SCMP_NR_BASE + 132) }, ++ { "pidfd_getfd", (__SCMP_NR_BASE + 438) }, + { "pidfd_open", (__SCMP_NR_BASE + 434) }, + { "pidfd_send_signal", (__SCMP_NR_BASE + 424) }, + { "pipe", (__SCMP_NR_BASE + 21) }, +diff --git a/src/arch-parisc-syscalls.c b/src/arch-parisc-syscalls.c +index c516c16e..2ab5e3ce 100644 +--- a/src/arch-parisc-syscalls.c ++++ b/src/arch-parisc-syscalls.c +@@ -10,7 +10,7 @@ + #include "arch.h" + #include "arch-parisc.h" + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def parisc_syscall_table[] = { \ + { "_llseek", 140 }, + { "_newselect", 142 }, +@@ -21,7 +21,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "acct", 51 }, + { "add_key", 264 }, + { "adjtimex", 124 }, +- { "afs_syscall", 137 }, ++ { "afs_syscall", __PNR_afs_syscall }, + { "alarm", 27 }, + { "arm_fadvise64_64", __PNR_arm_fadvise64_64 }, + { "arm_sync_file_range", __PNR_arm_sync_file_range }, +@@ -42,22 +42,22 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "chown32", __PNR_chown32 }, + { "chroot", 61 }, + { "clock_adjtime", 324 }, +- { "clock_adjtime64", __PNR_clock_adjtime64 }, ++ { "clock_adjtime64", 405 }, + { "clock_getres", 257 }, +- { "clock_getres_time64", __PNR_clock_getres_time64 }, ++ { "clock_getres_time64", 406 }, + { "clock_gettime", 256 }, +- { "clock_gettime64", __PNR_clock_gettime64 }, ++ { "clock_gettime64", 403 }, + { "clock_nanosleep", 258 }, +- { "clock_nanosleep_time64", __PNR_clock_nanosleep_time64 }, ++ { "clock_nanosleep_time64", 407 }, + { "clock_settime", 255 }, +- { "clock_settime64", __PNR_clock_settime64 }, ++ { "clock_settime64", 404 }, + { "clone", 120 }, +- { "clone3", __PNR_clone3 }, ++ { "clone3", 435 }, + { "close", 6 }, + { "connect", 31 }, + { "copy_file_range", 346 }, + { "creat", 8 }, +- { "create_module", 127 }, ++ { "create_module", __PNR_create_module }, + { "delete_module", 129 }, + { "dup", 41 }, + { "dup2", 63 }, +@@ -76,6 +76,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "exit", 1 }, + { "exit_group", 222 }, + { "faccessat", 287 }, ++ { "faccessat2", 439 }, + { "fadvise64", __PNR_fadvise64 }, + { "fadvise64_64", 236 }, + { "fallocate", 305 }, +@@ -96,11 +97,11 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "flock", 143 }, + { "fork", 2 }, + { "fremovexattr", 249 }, +- { "fsconfig", __PNR_fsconfig }, ++ { "fsconfig", 431 }, + { "fsetxattr", 240 }, +- { "fsmount", __PNR_fsmount }, +- { "fsopen", __PNR_fsopen }, +- { "fspick", __PNR_fspick }, ++ { "fsmount", 432 }, ++ { "fsopen", 430 }, ++ { "fspick", 433 }, + { "fstat", 28 }, + { "fstat64", 112 }, + { "fstatat64", 280 }, +@@ -111,12 +112,12 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "ftruncate", 93 }, + { "ftruncate64", 200 }, + { "futex", 210 }, +- { "futex_time64", __PNR_futex_time64 }, ++ { "futex_time64", 422 }, + { "futimesat", 279 }, +- { "get_kernel_syms", 130 }, ++ { "get_kernel_syms", __PNR_get_kernel_syms }, + { "get_mempolicy", 261 }, + { "get_robust_list", 290 }, +- { "get_thread_area", 214 }, ++ { "get_thread_area", __PNR_get_thread_area }, + { "get_tls", __PNR_get_tls }, + { "getcpu", 296 }, + { "getcwd", 110 }, +@@ -135,7 +136,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "getpgid", 132 }, + { "getpgrp", 65 }, + { "getpid", 20 }, +- { "getpmsg", 196 }, ++ { "getpmsg", __PNR_getpmsg }, + { "getppid", 64 }, + { "getpriority", 96 }, + { "getrandom", 339 }, +@@ -163,8 +164,8 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "io_cancel", 219 }, + { "io_destroy", 216 }, + { "io_getevents", 217 }, +- { "io_pgetevents", __PNR_io_pgetevents }, +- { "io_pgetevents_time64", __PNR_io_pgetevents_time64 }, ++ { "io_pgetevents", 350 }, ++ { "io_pgetevents_time64", 416 }, + { "io_setup", 215 }, + { "io_submit", 218 }, + { "io_uring_setup", 425 }, +@@ -177,7 +178,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "ioprio_set", 267 }, + { "ipc", __PNR_ipc }, + { "kcmp", 332 }, +- { "kexec_file_load", __PNR_kexec_file_load }, ++ { "kexec_file_load", 355 }, + { "kexec_load", 300 }, + { "keyctl", 266 }, + { "kill", 37 }, +@@ -213,7 +214,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "mmap2", 89 }, + { "modify_ldt", __PNR_modify_ldt }, + { "mount", 21 }, +- { "move_mount", __PNR_move_mount }, ++ { "move_mount", 429 }, + { "move_pages", 295 }, + { "mprotect", 125 }, + { "mpx", __PNR_mpx }, +@@ -221,9 +222,9 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "mq_notify", 233 }, + { "mq_open", 229 }, + { "mq_timedreceive", 232 }, +- { "mq_timedreceive_time64", __PNR_mq_timedreceive_time64 }, ++ { "mq_timedreceive_time64", 419 }, + { "mq_timedsend", 231 }, +- { "mq_timedsend_time64", __PNR_mq_timedsend_time64 }, ++ { "mq_timedsend_time64", 418 }, + { "mq_unlink", 230 }, + { "mremap", 163 }, + { "msgctl", 191 }, +@@ -238,7 +239,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "name_to_handle_at", 325 }, + { "nanosleep", 162 }, + { "newfstatat", __PNR_newfstatat }, +- { "nfsservctl", 169 }, ++ { "nfsservctl", __PNR_nfsservctl }, + { "nice", 34 }, + { "oldfstat", __PNR_oldfstat }, + { "oldlstat", __PNR_oldlstat }, +@@ -248,25 +249,27 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "oldwait4", __PNR_oldwait4 }, + { "open", 5 }, + { "open_by_handle_at", 326 }, +- { "open_tree", __PNR_open_tree }, ++ { "open_tree", 428 }, + { "openat", 275 }, ++ { "openat2", 437 }, + { "pause", 29 }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", 318 }, + { "personality", 136 }, +- { "pidfd_open", __PNR_pidfd_open }, +- { "pidfd_send_signal", __PNR_pidfd_send_signal }, ++ { "pidfd_getfd", 438 }, ++ { "pidfd_open", 434 }, ++ { "pidfd_send_signal", 424 }, + { "pipe", 42 }, + { "pipe2", 313 }, + { "pivot_root", 67 }, +- { "pkey_alloc", __PNR_pkey_alloc }, +- { "pkey_free", __PNR_pkey_free }, +- { "pkey_mprotect", __PNR_pkey_mprotect }, ++ { "pkey_alloc", 352 }, ++ { "pkey_free", 353 }, ++ { "pkey_mprotect", 351 }, + { "poll", 168 }, + { "ppoll", 274 }, +- { "ppoll_time64", __PNR_ppoll_time64 }, ++ { "ppoll_time64", 414 }, + { "prctl", 172 }, + { "pread64", 108 }, + { "preadv", 315 }, +@@ -277,13 +280,13 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "prof", __PNR_prof }, + { "profil", __PNR_profil }, + { "pselect6", 273 }, +- { "pselect6_time64", __PNR_pselect6_time64 }, ++ { "pselect6_time64", 413 }, + { "ptrace", 26 }, +- { "putpmsg", 197 }, ++ { "putpmsg", __PNR_putpmsg }, + { "pwrite64", 109 }, + { "pwritev", 316 }, + { "pwritev2", 348 }, +- { "query_module", 167 }, ++ { "query_module", __PNR_query_module }, + { "quotactl", 131 }, + { "read", 3 }, + { "readahead", 207 }, +@@ -295,7 +298,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "recv", 98 }, + { "recvfrom", 123 }, + { "recvmmsg", 319 }, +- { "recvmmsg_time64", __PNR_recvmmsg_time64 }, ++ { "recvmmsg_time64", 417 }, + { "recvmsg", 184 }, + { "remap_file_pages", 227 }, + { "removexattr", 247 }, +@@ -305,7 +308,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "request_key", 265 }, + { "restart_syscall", 0 }, + { "rmdir", 40 }, +- { "rseq", __PNR_rseq }, ++ { "rseq", 354 }, + { "rt_sigaction", 174 }, + { "rt_sigpending", 176 }, + { "rt_sigprocmask", 175 }, +@@ -313,7 +316,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "rt_sigreturn", 173 }, + { "rt_sigsuspend", 179 }, + { "rt_sigtimedwait", 177 }, +- { "rt_sigtimedwait_time64", __PNR_rt_sigtimedwait_time64 }, ++ { "rt_sigtimedwait_time64", 421 }, + { "rt_tgsigqueueinfo", 317 }, + { "rtas", __PNR_rtas }, + { "s390_guarded_storage", __PNR_s390_guarded_storage }, +@@ -328,7 +331,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "sched_getparam", 155 }, + { "sched_getscheduler", 157 }, + { "sched_rr_get_interval", 161 }, +- { "sched_rr_get_interval_time64", __PNR_sched_rr_get_interval_time64 }, ++ { "sched_rr_get_interval_time64", 423 }, + { "sched_setaffinity", 211 }, + { "sched_setattr", 334 }, + { "sched_setparam", 154 }, +@@ -341,7 +344,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "semget", 186 }, + { "semop", 185 }, + { "semtimedop", 228 }, +- { "semtimedop_time64", __PNR_semtimedop_time64 }, ++ { "semtimedop_time64", 420 }, + { "send", 58 }, + { "sendfile", 122 }, + { "sendfile64", 209 }, +@@ -350,7 +353,7 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "sendto", 82 }, + { "set_mempolicy", 262 }, + { "set_robust_list", 289 }, +- { "set_thread_area", 213 }, ++ { "set_thread_area", __PNR_set_thread_area }, + { "set_tid_address", 237 }, + { "set_tls", __PNR_set_tls }, + { "setdomainname", 121 }, +@@ -435,15 +438,15 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "timer_delete", 254 }, + { "timer_getoverrun", 253 }, + { "timer_gettime", 252 }, +- { "timer_gettime64", __PNR_timer_gettime64 }, ++ { "timer_gettime64", 408 }, + { "timer_settime", 251 }, +- { "timer_settime64", __PNR_timer_settime64 }, +- { "timerfd", 303 }, ++ { "timer_settime64", 409 }, ++ { "timerfd", __PNR_timerfd }, + { "timerfd_create", 306 }, + { "timerfd_gettime", 308 }, +- { "timerfd_gettime64", __PNR_timerfd_gettime64 }, ++ { "timerfd_gettime64", 410 }, + { "timerfd_settime", 307 }, +- { "timerfd_settime64", __PNR_timerfd_settime64 }, ++ { "timerfd_settime64", 411 }, + { "times", 43 }, + { "tkill", 208 }, + { "truncate", 92 }, +@@ -465,14 +468,14 @@ const struct arch_syscall_def parisc_syscall_table[] = { \ + { "ustat", 62 }, + { "utime", 30 }, + { "utimensat", 301 }, +- { "utimensat_time64", __PNR_utimensat_time64 }, ++ { "utimensat_time64", 412 }, + { "utimes", 336 }, + { "vfork", 113 }, + { "vhangup", 111 }, + { "vm86", __PNR_vm86 }, + { "vm86old", __PNR_vm86old }, + { "vmsplice", 294 }, +- { "vserver", 263 }, ++ { "vserver", __PNR_vserver }, + { "wait4", 114 }, + { "waitid", 235 }, + { "waitpid", 7 }, +diff --git a/src/arch-ppc-syscalls.c b/src/arch-ppc-syscalls.c +index fbfa1df3..0cdac6fe 100644 +--- a/src/arch-ppc-syscalls.c ++++ b/src/arch-ppc-syscalls.c +@@ -27,7 +27,7 @@ + #include "arch.h" + #include "arch-ppc.h" + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def ppc_syscall_table[] = { \ + { "_llseek", 140 }, + { "_newselect", 142 }, +@@ -93,6 +93,7 @@ const struct arch_syscall_def ppc_syscall_table[] = { \ + { "exit", 1 }, + { "exit_group", 234 }, + { "faccessat", 298 }, ++ { "faccessat2", 439 }, + { "fadvise64", 233 }, + { "fadvise64_64", 254 }, + { "fallocate", 309 }, +@@ -267,12 +268,14 @@ const struct arch_syscall_def ppc_syscall_table[] = { \ + { "open_by_handle_at", 346 }, + { "open_tree", 428 }, + { "openat", 286 }, ++ { "openat2", 437 }, + { "pause", 29 }, + { "pciconfig_iobase", 200 }, + { "pciconfig_read", 198 }, + { "pciconfig_write", 199 }, + { "perf_event_open", 319 }, + { "personality", 136 }, ++ { "pidfd_getfd", 438 }, + { "pidfd_open", 434 }, + { "pidfd_send_signal", 424 }, + { "pipe", 42 }, +diff --git a/src/arch-ppc64-syscalls.c b/src/arch-ppc64-syscalls.c +index 41f82afa..18c37533 100644 +--- a/src/arch-ppc64-syscalls.c ++++ b/src/arch-ppc64-syscalls.c +@@ -27,7 +27,7 @@ + #include "arch.h" + #include "arch-ppc64.h" + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def ppc64_syscall_table[] = { \ + { "_llseek", 140 }, + { "_newselect", 142 }, +@@ -93,6 +93,7 @@ const struct arch_syscall_def ppc64_syscall_table[] = { \ + { "exit", 1 }, + { "exit_group", 234 }, + { "faccessat", 298 }, ++ { "faccessat2", 439 }, + { "fadvise64", 233 }, + { "fadvise64_64", __PNR_fadvise64_64 }, + { "fallocate", 309 }, +@@ -267,12 +268,14 @@ const struct arch_syscall_def ppc64_syscall_table[] = { \ + { "open_by_handle_at", 346 }, + { "open_tree", 428 }, + { "openat", 286 }, ++ { "openat2", 437 }, + { "pause", 29 }, + { "pciconfig_iobase", 200 }, + { "pciconfig_read", 198 }, + { "pciconfig_write", 199 }, + { "perf_event_open", 319 }, + { "personality", 136 }, ++ { "pidfd_getfd", 438 }, + { "pidfd_open", 434 }, + { "pidfd_send_signal", 424 }, + { "pipe", 42 }, +diff --git a/src/arch-s390-syscalls.c b/src/arch-s390-syscalls.c +index 6dd84db5..1a609701 100644 +--- a/src/arch-s390-syscalls.c ++++ b/src/arch-s390-syscalls.c +@@ -10,7 +10,7 @@ + #include "arch.h" + #include "arch-s390.h" + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def s390_syscall_table[] = { \ + { "_llseek", 140 }, + { "_newselect", 142 }, +@@ -76,6 +76,7 @@ const struct arch_syscall_def s390_syscall_table[] = { \ + { "exit", 1 }, + { "exit_group", 248 }, + { "faccessat", 300 }, ++ { "faccessat2", 439 }, + { "fadvise64", 253 }, + { "fadvise64_64", 264 }, + { "fallocate", 314 }, +@@ -250,12 +251,14 @@ const struct arch_syscall_def s390_syscall_table[] = { \ + { "open_by_handle_at", 336 }, + { "open_tree", 428 }, + { "openat", 288 }, ++ { "openat2", 437 }, + { "pause", 29 }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", 331 }, + { "personality", 136 }, ++ { "pidfd_getfd", 438 }, + { "pidfd_open", 434 }, + { "pidfd_send_signal", 424 }, + { "pipe", 42 }, +diff --git a/src/arch-s390x-syscalls.c b/src/arch-s390x-syscalls.c +index 703eaf12..129d17b2 100644 +--- a/src/arch-s390x-syscalls.c ++++ b/src/arch-s390x-syscalls.c +@@ -10,7 +10,7 @@ + #include "arch.h" + #include "arch-s390x.h" + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def s390x_syscall_table[] = { \ + { "_llseek", __PNR__llseek }, + { "_newselect", __PNR__newselect }, +@@ -76,6 +76,7 @@ const struct arch_syscall_def s390x_syscall_table[] = { \ + { "exit", 1 }, + { "exit_group", 248 }, + { "faccessat", 300 }, ++ { "faccessat2", 439 }, + { "fadvise64", 253 }, + { "fadvise64_64", __PNR_fadvise64_64 }, + { "fallocate", 314 }, +@@ -250,12 +251,14 @@ const struct arch_syscall_def s390x_syscall_table[] = { \ + { "open_by_handle_at", 336 }, + { "open_tree", 428 }, + { "openat", 288 }, ++ { "openat2", 437 }, + { "pause", 29 }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", 331 }, + { "personality", 136 }, ++ { "pidfd_getfd", 438 }, + { "pidfd_open", 434 }, + { "pidfd_send_signal", 424 }, + { "pipe", 42 }, +diff --git a/src/arch-x32-syscalls.c b/src/arch-x32-syscalls.c +index e5cfadba..eb54d35d 100644 +--- a/src/arch-x32-syscalls.c ++++ b/src/arch-x32-syscalls.c +@@ -26,7 +26,7 @@ + #include "arch.h" + #include "arch-x32.h" + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def x32_syscall_table[] = { \ + { "_llseek", __PNR__llseek }, + { "_newselect", __PNR__newselect }, +@@ -92,6 +92,7 @@ const struct arch_syscall_def x32_syscall_table[] = { \ + { "exit", (X32_SYSCALL_BIT + 60) }, + { "exit_group", (X32_SYSCALL_BIT + 231) }, + { "faccessat", (X32_SYSCALL_BIT + 269) }, ++ { "faccessat2", (X32_SYSCALL_BIT + 439) }, + { "fadvise64", (X32_SYSCALL_BIT + 221) }, + { "fadvise64_64", __PNR_fadvise64_64 }, + { "fallocate", (X32_SYSCALL_BIT + 285) }, +@@ -266,12 +267,14 @@ const struct arch_syscall_def x32_syscall_table[] = { \ + { "open_by_handle_at", (X32_SYSCALL_BIT + 304) }, + { "open_tree", (X32_SYSCALL_BIT + 428) }, + { "openat", (X32_SYSCALL_BIT + 257) }, ++ { "openat2", (X32_SYSCALL_BIT + 437) }, + { "pause", (X32_SYSCALL_BIT + 34) }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", (X32_SYSCALL_BIT + 298) }, + { "personality", (X32_SYSCALL_BIT + 135) }, ++ { "pidfd_getfd", (X32_SYSCALL_BIT + 438) }, + { "pidfd_open", (X32_SYSCALL_BIT + 434) }, + { "pidfd_send_signal", (X32_SYSCALL_BIT + 424) }, + { "pipe", (X32_SYSCALL_BIT + 22) }, +diff --git a/src/arch-x86-syscalls.c b/src/arch-x86-syscalls.c +index ff555e9f..ae870f1c 100644 +--- a/src/arch-x86-syscalls.c ++++ b/src/arch-x86-syscalls.c +@@ -26,7 +26,7 @@ + #include "arch.h" + #include "arch-x86.h" + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def x86_syscall_table[] = { \ + { "_llseek", 140 }, + { "_newselect", 142 }, +@@ -92,6 +92,7 @@ const struct arch_syscall_def x86_syscall_table[] = { \ + { "exit", 1 }, + { "exit_group", 252 }, + { "faccessat", 307 }, ++ { "faccessat2", 439 }, + { "fadvise64", 250 }, + { "fadvise64_64", 272 }, + { "fallocate", 324 }, +@@ -266,12 +267,14 @@ const struct arch_syscall_def x86_syscall_table[] = { \ + { "open_by_handle_at", 342 }, + { "open_tree", 428 }, + { "openat", 295 }, ++ { "openat2", 437 }, + { "pause", 29 }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", 336 }, + { "personality", 136 }, ++ { "pidfd_getfd", 438 }, + { "pidfd_open", 434 }, + { "pidfd_send_signal", 424 }, + { "pipe", 42 }, +diff --git a/src/arch-x86_64-syscalls.c b/src/arch-x86_64-syscalls.c +index a2fdef88..23a4899a 100644 +--- a/src/arch-x86_64-syscalls.c ++++ b/src/arch-x86_64-syscalls.c +@@ -26,7 +26,7 @@ + #include "arch.h" + #include "arch-x86_64.h" + +-/* NOTE: based on Linux v5.4-rc4 */ ++/* NOTE: based on Linux v5.8-rc7 */ + const struct arch_syscall_def x86_64_syscall_table[] = { \ + { "_llseek", __PNR__llseek }, + { "_newselect", __PNR__newselect }, +@@ -92,6 +92,7 @@ const struct arch_syscall_def x86_64_syscall_table[] = { \ + { "exit", 60 }, + { "exit_group", 231 }, + { "faccessat", 269 }, ++ { "faccessat2", 439 }, + { "fadvise64", 221 }, + { "fadvise64_64", __PNR_fadvise64_64 }, + { "fallocate", 285 }, +@@ -266,12 +267,14 @@ const struct arch_syscall_def x86_64_syscall_table[] = { \ + { "open_by_handle_at", 304 }, + { "open_tree", 428 }, + { "openat", 257 }, ++ { "openat2", 437 }, + { "pause", 34 }, + { "pciconfig_iobase", __PNR_pciconfig_iobase }, + { "pciconfig_read", __PNR_pciconfig_read }, + { "pciconfig_write", __PNR_pciconfig_write }, + { "perf_event_open", 298 }, + { "personality", 135 }, ++ { "pidfd_getfd", 438 }, + { "pidfd_open", 434 }, + { "pidfd_send_signal", 424 }, + { "pipe", 22 },