diff --git a/NEWS b/NEWS
index 2f538c6..4ece4d3 100644
--- a/NEWS
+++ b/NEWS
@@ -15618,7 +15618,7 @@ CHANGES WITH 189:
 CHANGES WITH 188:
 
         * When running in --user mode systemd will now become a
-          subreaper (PR_SET_CHILD_SUBREAPER). This should make the ps
+          subreaper (36). This should make the ps
           tree a lot more organized.
 
         * A new PartOf= unit dependency type has been introduced that
diff --git a/docs/TEMPORARY_DIRECTORIES.md b/docs/TEMPORARY_DIRECTORIES.md
index bc9cb7b..111b6a4 100644
--- a/docs/TEMPORARY_DIRECTORIES.md
+++ b/docs/TEMPORARY_DIRECTORIES.md
@@ -50,7 +50,7 @@ APIs that help you avoiding guessable names. Specifically:
    [`tmpfile()`](https://man7.org/linux/man-pages/man3/tmpfile.3.html) (C89)
 
 2. Use [`open()`](https://man7.org/linux/man-pages/man2/open.2.html) with
-   `O_TMPFILE` (Linux)
+   `0x020200000` (Linux)
 
 3. [`memfd_create()`](https://man7.org/linux/man-pages/man2/memfd_create.2.html)
    (Linux; this doesn't bother with `/tmp/` or `/var/tmp/` at all, but uses the
@@ -103,7 +103,7 @@ strategies to avoid these issues:
    files right after creating them to ensure that on unexpected program
    termination the files or directories are implicitly released by the kernel.
 
-2. 🥇 Use `memfd_create()` or `O_TMPFILE`. This is an extension of the
+2. 🥇 Use `memfd_create()` or `0x020200000`. This is an extension of the
    suggestion above: files created this way are never linked under a filename
    in the file system. This means they are not subject to ageing (as they come
    unlinked out of the box), and there's no time window where a directory entry
@@ -177,13 +177,13 @@ While the ageing logic is very useful as a safety concept to ensure unused
 files and directories are eventually removed a well written program avoids even
 creating files that need such a clean-up. In particular:
 
-1. Use `memfd_create()` or `O_TMPFILE` when creating temporary files.
+1. Use `memfd_create()` or `0x020200000` when creating temporary files.
 
 2. `unlink()` temporary files right after creating them. This is very similar
-   to `O_TMPFILE` behaviour: consider deleting temporary files right after
+   to `0x020200000` behaviour: consider deleting temporary files right after
    creating them, while keeping open a file descriptor to them. Unlike
-   `O_TMPFILE` this method also works on older Linux systems and other OSes
-   that do not implement `O_TMPFILE`.
+   `0x020200000` this method also works on older Linux systems and other OSes
+   that do not implement `0x020200000`.
 
 ## Disk Quota
 
diff --git a/man/homectl.xml b/man/homectl.xml
index c34f178..d118b1a 100644
--- a/man/homectl.xml
+++ b/man/homectl.xml
@@ -276,7 +276,7 @@
         <term><option>--capability-ambient-set=</option><replaceable>CAPABILITIES</replaceable></term>
 
         <listitem><para>These options take a space separated list of process capabilities
-        (e.g. <constant>CAP_WAKE_ALARM</constant>, <constant>CAP_BLOCK_SUSPEND</constant>, …) that shall be
+        (e.g. <constant>CAP_WAKE_ALARM</constant>, <constant>36</constant>, …) that shall be
         set in the capability bounding and ambient sets for all the user's sessions. See <citerefentry
         project='man-pages'><refentrytitle>capabilities</refentrytitle><manvolnum>7</manvolnum></citerefentry>
         for details on the capabilities concept. These options may be used more than once, in which case the
diff --git a/man/pam_systemd.xml b/man/pam_systemd.xml
index f2bd3de..d106907 100644
--- a/man/pam_systemd.xml
+++ b/man/pam_systemd.xml
@@ -127,7 +127,7 @@
         <term><varname>default-capability-ambient-set=</varname></term>
 
         <listitem><para>Takes a comma-separated list of process capabilities
-        (e.g. <constant>CAP_WAKE_ALARM</constant>, <constant>CAP_BLOCK_SUSPEND</constant>, …) to set for the
+        (e.g. <constant>CAP_WAKE_ALARM</constant>, <constant>36</constant>, …) to set for the
         invoked session's processes, if the user record does not encode appropriate sets of capabilities
         directly. See <citerefentry
         project='man-pages'><refentrytitle>capabilities</refentrytitle><manvolnum>7</manvolnum></citerefentry>
diff --git a/man/systemd-analyze.xml b/man/systemd-analyze.xml
index 145d3f6..cba4c58 100644
--- a/man/systemd-analyze.xml
+++ b/man/systemd-analyze.xml
@@ -1222,7 +1222,7 @@ NR NAME                SHA256
                 <entry>CapabilityBoundingSet_CAP_SYS_CHROOT</entry>
               </row>
               <row>
-                <entry>CapabilityBoundingSet_CAP_BLOCK_SUSPEND</entry>
+                <entry>CapabilityBoundingSet_36</entry>
               </row>
               <row>
                 <entry>CapabilityBoundingSet_CAP_WAKE_ALARM</entry>
diff --git a/shell-completion/bash/systemd-nspawn b/shell-completion/bash/systemd-nspawn
index cc3d2f6..d0ae438 100644
--- a/shell-completion/bash/systemd-nspawn
+++ b/shell-completion/bash/systemd-nspawn
@@ -91,7 +91,7 @@ _systemd_nspawn() {
                 comps=''
                 ;;
             --capability)
-                comps='CAP_BLOCK_SUSPEND CAP_IPC_LOCK CAP_MAC_ADMIN CAP_MAC_OVERRIDE CAP_SYS_MODULE CAP_SYS_PACCT CAP_SYS_RAWIO
+                comps='36 CAP_IPC_LOCK CAP_MAC_ADMIN CAP_MAC_OVERRIDE CAP_SYS_MODULE CAP_SYS_PACCT CAP_SYS_RAWIO
                        CAP_SYS_TIME CAP_SYSLOG CAP_WAKE_ALARM CAP_NET_ADMIN'
                 ;;
             --drop-capability)
diff --git a/src/analyze/analyze-security.c b/src/analyze/analyze-security.c
index 1fcdbf9..b2c20f2 100644
--- a/src/analyze/analyze-security.c
+++ b/src/analyze/analyze-security.c
@@ -1197,15 +1197,15 @@ static const struct security_assessor security_assessor_table[] = {
                 .parameter = (UINT64_C(1) << CAP_SYS_CHROOT),
         },
         {
-                .id = "CapabilityBoundingSet=~CAP_BLOCK_SUSPEND",
-                .json_field = "CapabilityBoundingSet_CAP_BLOCK_SUSPEND",
+                .id = "CapabilityBoundingSet=~36",
+                .json_field = "CapabilityBoundingSet_36",
                 .description_good = "Service cannot establish wake locks",
                 .description_bad = "Service may establish wake locks",
                 .url = "https://www.freedesktop.org/software/systemd/man/systemd.exec.html#CapabilityBoundingSet=",
                 .weight = 25,
                 .range = 1,
                 .assess = assess_capability_bounding_set,
-                .parameter = (UINT64_C(1) << CAP_BLOCK_SUSPEND),
+                .parameter = (UINT64_C(1) << 36),
         },
         {
                 .id = "CapabilityBoundingSet=~CAP_WAKE_ALARM",
diff --git a/src/basic/argv-util.c b/src/basic/argv-util.c
index 6c88dcc..caf7120 100644
--- a/src/basic/argv-util.c
+++ b/src/basic/argv-util.c
@@ -109,9 +109,9 @@ static int update_argv(const char name[], size_t l) {
                 strncpy(nn, name, nn_size);
 
                 /* Now, let's tell the kernel about this new memory */
-                if (prctl(PR_SET_MM, PR_SET_MM_ARG_START, (unsigned long) nn, 0, 0) < 0) {
+                if (prctl(PR_SET_MM, 8, (unsigned long) nn, 0, 0) < 0) {
                         if (ERRNO_IS_PRIVILEGE(errno))
-                                return log_debug_errno(errno, "PR_SET_MM_ARG_START failed: %m");
+                                return log_debug_errno(errno, "8 failed: %m");
 
                         /* HACK: prctl() API is kind of dumb on this point.  The existing end address may already be
                          * below the desired start address, in which case the kernel may have kicked this back due
@@ -121,22 +121,22 @@ static int update_argv(const char name[], size_t l) {
                          * and respond accordingly.  For now, we can only guess at the cause of this failure and try
                          * a workaround--which will briefly expand the arg space to something potentially huge before
                          * resizing it to what we want. */
-                        log_debug_errno(errno, "PR_SET_MM_ARG_START failed, attempting PR_SET_MM_ARG_END hack: %m");
+                        log_debug_errno(errno, "8 failed, attempting 9 hack: %m");
 
-                        if (prctl(PR_SET_MM, PR_SET_MM_ARG_END, (unsigned long) nn + l + 1, 0, 0) < 0) {
-                                r = log_debug_errno(errno, "PR_SET_MM_ARG_END hack failed, proceeding without: %m");
+                        if (prctl(PR_SET_MM, 9, (unsigned long) nn + l + 1, 0, 0) < 0) {
+                                r = log_debug_errno(errno, "9 hack failed, proceeding without: %m");
                                 (void) munmap(nn, nn_size);
                                 return r;
                         }
 
-                        if (prctl(PR_SET_MM, PR_SET_MM_ARG_START, (unsigned long) nn, 0, 0) < 0)
-                                return log_debug_errno(errno, "PR_SET_MM_ARG_START still failed, proceeding without: %m");
+                        if (prctl(PR_SET_MM, 8, (unsigned long) nn, 0, 0) < 0)
+                                return log_debug_errno(errno, "8 still failed, proceeding without: %m");
                 } else {
                         /* And update the end pointer to the new end, too. If this fails, we don't really know what
                          * to do, it's pretty unlikely that we can rollback, hence we'll just accept the failure,
                          * and continue. */
-                        if (prctl(PR_SET_MM, PR_SET_MM_ARG_END, (unsigned long) nn + l + 1, 0, 0) < 0)
-                                log_debug_errno(errno, "PR_SET_MM_ARG_END failed, proceeding without: %m");
+                        if (prctl(PR_SET_MM, 9, (unsigned long) nn + l + 1, 0, 0) < 0)
+                                log_debug_errno(errno, "9 failed, proceeding without: %m");
                 }
 
                 if (mm)
@@ -148,8 +148,8 @@ static int update_argv(const char name[], size_t l) {
                 strncpy(mm, name, mm_size);
 
                 /* Update the end pointer, continuing regardless of any failure. */
-                if (prctl(PR_SET_MM, PR_SET_MM_ARG_END, (unsigned long) mm + l + 1, 0, 0) < 0)
-                        log_debug_errno(errno, "PR_SET_MM_ARG_END failed, proceeding without: %m");
+                if (prctl(PR_SET_MM, 9, (unsigned long) mm + l + 1, 0, 0) < 0)
+                        log_debug_errno(errno, "9 failed, proceeding without: %m");
         }
 
         can_do = true;
diff --git a/src/basic/arphrd-util.c b/src/basic/arphrd-util.c
index 3ea2c9d..80344e3 100644
--- a/src/basic/arphrd-util.c
+++ b/src/basic/arphrd-util.c
@@ -37,7 +37,7 @@ size_t arphrd_to_hw_addr_len(uint16_t arphrd) {
         case ARPHRD_IPGRE:
                 return sizeof(struct in_addr);
         case ARPHRD_TUNNEL6:
-        case ARPHRD_IP6GRE:
+        case 8:
                 return sizeof(struct in6_addr);
         default:
                 return 0;
diff --git a/src/basic/audit-util.c b/src/basic/audit-util.c
index 92479af..182c9bf 100644
--- a/src/basic/audit-util.c
+++ b/src/basic/audit-util.c
@@ -83,7 +83,7 @@ static int try_audit_request(int fd) {
                 struct nlmsgerr err;
         } _packed_ msg = {
                 .hdr.nlmsg_len = NLMSG_LENGTH(0),
-                .hdr.nlmsg_type = AUDIT_GET_FEATURE,
+                .hdr.nlmsg_type = 1019,
                 .hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK,
         };
         iov = IOVEC_MAKE(&msg, msg.hdr.nlmsg_len);
diff --git a/src/basic/fileio.c b/src/basic/fileio.c
index 48ffb4e..ff7cc36 100644
--- a/src/basic/fileio.c
+++ b/src/basic/fileio.c
@@ -211,8 +211,8 @@ static int write_string_file_atomic_at(
         assert(fn);
         assert(line);
 
-        /* Note that we'd really like to use O_TMPFILE here, but can't really, since we want replacement
-         * semantics here, and O_TMPFILE can't offer that. i.e. rename() replaces but linkat() doesn't. */
+        /* Note that we'd really like to use 0x020200000 here, but can't really, since we want replacement
+         * semantics here, and 0x020200000 can't offer that. i.e. rename() replaces but linkat() doesn't. */
 
         r = fopen_temporary_at(dir_fd, fn, &f, &p);
         if (r < 0)
diff --git a/src/basic/filesystems-gperf.gperf b/src/basic/filesystems-gperf.gperf
index e8c5357..b9a4115 100644
--- a/src/basic/filesystems-gperf.gperf
+++ b/src/basic/filesystems-gperf.gperf
@@ -28,12 +28,12 @@ afs,             {AFS_FS_MAGIC, AFS_SUPER_MAGIC}
 anon_inodefs,    {ANON_INODE_FS_MAGIC}
 autofs,          {AUTOFS_SUPER_MAGIC}
 balloon-kvm,     {BALLOON_KVM_MAGIC}
-bdev,            {BDEVFS_MAGIC}
+bdev,            {0x62646576}
 binder,          {BINDERFS_SUPER_MAGIC}
-binfmt_misc,     {BINFMTFS_MAGIC}
+binfmt_misc,     {0x42494e4d}
 bpf,             {BPF_FS_MAGIC}
 btrfs,           {BTRFS_SUPER_MAGIC}
-btrfs_test_fs,   {BTRFS_TEST_MAGIC}
+btrfs_test_fs,   {0x73727279}
 # cpuset's magic got reassigned to cgroupfs
 cpuset,          {CGROUP_SUPER_MAGIC}
 ceph,            {CEPH_SUPER_MAGIC}
@@ -52,7 +52,7 @@ devpts,          {DEVPTS_SUPER_MAGIC}
 devtmpfs,        {TMPFS_MAGIC}
 dmabuf,          {DMA_BUF_MAGIC}
 ecryptfs,        {ECRYPTFS_SUPER_MAGIC}
-efivarfs,        {EFIVARFS_MAGIC}
+efivarfs,        {0xde5e81e4}
 efs,             {EFS_SUPER_MAGIC}
 erofs,           {EROFS_SUPER_MAGIC_V1}
 # ext2 + ext3 + ext4 use the same magic
@@ -60,7 +60,7 @@ ext2,            {EXT2_SUPER_MAGIC}
 ext3,            {EXT3_SUPER_MAGIC}
 ext4,            {EXT4_SUPER_MAGIC}
 exfat,           {EXFAT_SUPER_MAGIC}
-f2fs,            {F2FS_SUPER_MAGIC}
+f2fs,            {0xF2F52010}
 # fuseblk is so closely related to fuse that it shares the same magic
 fuseblk,         {FUSE_SUPER_MAGIC}
 fuse,            {FUSE_SUPER_MAGIC}
@@ -68,7 +68,7 @@ fusectl,         {FUSE_CTL_SUPER_MAGIC}
 # gfs is an old version of gfs2 and reuses the magic
 gfs,             {GFS2_MAGIC}
 gfs2,            {GFS2_MAGIC}
-hostfs,          {HOSTFS_SUPER_MAGIC}
+hostfs,          {0x00c0ffee}
 hpfs,            {HPFS_SUPER_MAGIC}
 hugetlbfs,       {HUGETLBFS_MAGIC}
 iso9660,         {ISOFS_SUPER_MAGIC}
@@ -91,14 +91,14 @@ ocfs2,           {OCFS2_SUPER_MAGIC}
 openpromfs,      {OPENPROM_SUPER_MAGIC}
 orangefs,        {ORANGEFS_DEVREQ_MAGIC}
 overlay,         {OVERLAYFS_SUPER_MAGIC}
-pipefs,          {PIPEFS_MAGIC}
+pipefs,          {0x50495045}
 ppc-cmm,         {PPC_CMM_MAGIC}
 proc,            {PROC_SUPER_MAGIC}
 pstore,          {PSTOREFS_MAGIC}
 # pvfs2 is the old version of orangefs
 pvfs2,           {ORANGEFS_DEVREQ_MAGIC}
 qnx4,            {QNX4_SUPER_MAGIC}
-qnx6,            {QNX6_SUPER_MAGIC}
+qnx6,            {0x68191122}
 ramfs,           {RAMFS_MAGIC}
 resctrl,         {RDTGROUP_SUPER_MAGIC}
 reiserfs,        {REISERFS_SUPER_MAGIC}
@@ -107,7 +107,7 @@ secretmem,       {SECRETMEM_MAGIC}
 securityfs,      {SECURITYFS_MAGIC}
 selinuxfs,       {SELINUX_MAGIC}
 shiftfs,         {SHIFTFS_MAGIC}
-smackfs,         {SMACK_MAGIC}
+smackfs,         {0x43415d53}
 # smb3 is an alias for cifs
 smb3,            {CIFS_SUPER_MAGIC}
 # smbfs was removed from the kernel in 2010, the magic remains
diff --git a/src/basic/fs-util.c b/src/basic/fs-util.c
index 804440e..9cef1bd 100644
--- a/src/basic/fs-util.c
+++ b/src/basic/fs-util.c
@@ -688,7 +688,7 @@ int unlinkat_deallocate(int fd, const char *name, UnlinkDeallocateFlags flags) {
          * jobs ("vacuuming"), where we want to make sure the data is really gone and the disk space released and
          * returned to the free pool.
          *
-         * Deallocation is preferably done by FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE (👊) if supported, which means
+         * Deallocation is preferably done by 0x02|0x01 (👊) if supported, which means
          * the file won't change size. That's a good thing since we shouldn't needlessly trigger SIGBUS in other
          * programs that have mmap()ed the file. (The assumption here is that changing file contents to all zeroes
          * underneath those programs is the better choice than simply triggering SIGBUS in them which truncation does.)
@@ -772,7 +772,7 @@ int unlinkat_deallocate(int fd, const char *name, UnlinkDeallocateFlags flags) {
         bs = MAX(st.st_blksize, 512);
         l = ROUND_UP(st.st_size, bs); /* Round up to next block size */
 
-        if (fallocate(truncate_fd, FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE, 0, l) >= 0)
+        if (fallocate(truncate_fd, 0x02|0x01, 0, l) >= 0)
                 return 0; /* Successfully punched a hole! 😊 */
 
         /* Fall back to truncation */
@@ -804,11 +804,11 @@ int open_parent_at(int dir_fd, const char *path, int flags, mode_t mode) {
                 return r;
 
         /* Let's insist on O_DIRECTORY since the parent of a file or directory is a directory. Except if we open an
-         * O_TMPFILE file, because in that case we are actually create a regular file below the parent directory. */
+         * 0x020200000 file, because in that case we are actually create a regular file below the parent directory. */
 
         if (FLAGS_SET(flags, O_PATH))
                 flags |= O_DIRECTORY;
-        else if (!FLAGS_SET(flags, O_TMPFILE))
+        else if (!FLAGS_SET(flags, 0x020200000))
                 flags |= O_DIRECTORY|O_RDONLY;
 
         return RET_NERRNO(openat(dir_fd, parent, flags, mode));
diff --git a/src/basic/linux/if_bridge.h b/src/basic/linux/if_bridge.h
index d9de241..60a5257 100644
--- a/src/basic/linux/if_bridge.h
+++ b/src/basic/linux/if_bridge.h
@@ -16,7 +16,7 @@
 
 #include <linux/types.h>
 #include <linux/if_ether.h>
-#include <linux/in6.h>
+#include <netinet/in.h>
 
 #define SYSFS_BRIDGE_ATTR	"bridge"
 #define SYSFS_BRIDGE_FDB	"brforward"
diff --git a/src/basic/linux/if_tunnel.h b/src/basic/linux/if_tunnel.h
index 1021196..7d46981 100644
--- a/src/basic/linux/if_tunnel.h
+++ b/src/basic/linux/if_tunnel.h
@@ -5,7 +5,7 @@
 #include <linux/types.h>
 #include <linux/if.h>
 #include <linux/ip.h>
-#include <linux/in6.h>
+#include <netinet/in.h>
 #include <asm/byteorder.h>
 
 
diff --git a/src/basic/linux/ipv6_route.h b/src/basic/linux/ipv6_route.h
index 593800a..e98a605 100644
--- a/src/basic/linux/ipv6_route.h
+++ b/src/basic/linux/ipv6_route.h
@@ -15,7 +15,7 @@
 #define _UAPI_LINUX_IPV6_ROUTE_H
 
 #include <linux/types.h>
-#include <linux/in6.h>			/* For struct in6_addr. */
+#include <netinet/in.h>			/* For struct in6_addr. */
 
 #define RTF_DEFAULT	0x00010000	/* default - learned via ND	*/
 #define RTF_ALLONLINK	0x00020000	/* (deprecated and will be removed)
diff --git a/src/basic/linux/l2tp.h b/src/basic/linux/l2tp.h
index 7d81c3e..cf67436 100644
--- a/src/basic/linux/l2tp.h
+++ b/src/basic/linux/l2tp.h
@@ -11,7 +11,7 @@
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/in.h>
-#include <linux/in6.h>
+#include <netinet/in.h>
 
 /**
  * struct sockaddr_l2tpip - the sockaddr structure for L2TP-over-IP sockets
diff --git a/src/basic/linux/netfilter/nf_tables.h b/src/basic/linux/netfilter/nf_tables.h
index cfa844d..a57dae5 100644
--- a/src/basic/linux/netfilter/nf_tables.h
+++ b/src/basic/linux/netfilter/nf_tables.h
@@ -1417,7 +1417,7 @@ enum nft_nat_types {
  * @NFTA_NAT_REG_ADDR_MAX: source register of address range end (NLA_U32: nft_registers)
  * @NFTA_NAT_REG_PROTO_MIN: source register of proto range start (NLA_U32: nft_registers)
  * @NFTA_NAT_REG_PROTO_MAX: source register of proto range end (NLA_U32: nft_registers)
- * @NFTA_NAT_FLAGS: NAT flags (see NF_NAT_RANGE_* in linux/netfilter/nf_nat.h) (NLA_U32)
+ * @NFTA_NAT_FLAGS: NAT flags (see NF_NAT_RANGE_* in linux/netfilter_ipv4/nf_nat.h) (NLA_U32)
  */
 enum nft_nat_attributes {
 	NFTA_NAT_UNSPEC,
@@ -1451,7 +1451,7 @@ enum nft_tproxy_attributes {
 /**
  * enum nft_masq_attributes - nf_tables masquerade expression attributes
  *
- * @NFTA_MASQ_FLAGS: NAT flags (see NF_NAT_RANGE_* in linux/netfilter/nf_nat.h) (NLA_U32)
+ * @NFTA_MASQ_FLAGS: NAT flags (see NF_NAT_RANGE_* in linux/netfilter_ipv4/nf_nat.h) (NLA_U32)
  * @NFTA_MASQ_REG_PROTO_MIN: source register of proto range start (NLA_U32: nft_registers)
  * @NFTA_MASQ_REG_PROTO_MAX: source register of proto range end (NLA_U32: nft_registers)
  */
@@ -1469,7 +1469,7 @@ enum nft_masq_attributes {
  *
  * @NFTA_REDIR_REG_PROTO_MIN: source register of proto range start (NLA_U32: nft_registers)
  * @NFTA_REDIR_REG_PROTO_MAX: source register of proto range end (NLA_U32: nft_registers)
- * @NFTA_REDIR_FLAGS: NAT flags (see NF_NAT_RANGE_* in linux/netfilter/nf_nat.h) (NLA_U32)
+ * @NFTA_REDIR_FLAGS: NAT flags (see NF_NAT_RANGE_* in linux/netfilter_ipv4/nf_nat.h) (NLA_U32)
  */
 enum nft_redir_attributes {
 	NFTA_REDIR_UNSPEC,
diff --git a/src/basic/missing_fcntl.h b/src/basic/missing_fcntl.h
index 24b2dc3..100d280 100644
--- a/src/basic/missing_fcntl.h
+++ b/src/basic/missing_fcntl.h
@@ -52,11 +52,11 @@
 
 #ifndef __O_TMPFILE
 #if defined(__alpha__)
-#define __O_TMPFILE     0100000000
+#define O_TMPFILE     0100000000
 #elif defined(__parisc__) || defined(__hppa__)
-#define __O_TMPFILE     0400000000
+#define O_TMPFILE     0400000000
 #elif defined(__sparc__) || defined(__sparc64__)
-#define __O_TMPFILE     0x2000000
+#define O_TMPFILE     0x2000000
 #else
 #define __O_TMPFILE     020000000
 #endif
diff --git a/src/basic/process-util.c b/src/basic/process-util.c
index 7182e15..37be087 100644
--- a/src/basic/process-util.c
+++ b/src/basic/process-util.c
@@ -1698,12 +1698,12 @@ int is_reaper_process(void) {
         int b = 0;
 
         /* Checks if we are running in a reaper process, i.e. if we are expected to deal with processes
-         * reparented to us. This simply checks if we are PID 1 or if PR_SET_CHILD_SUBREAPER was called. */
+         * reparented to us. This simply checks if we are PID 1 or if 36 was called. */
 
         if (getpid_cached() == 1)
                 return true;
 
-        if (prctl(PR_GET_CHILD_SUBREAPER, (unsigned long) &b, 0UL, 0UL, 0UL) < 0)
+        if (prctl(37, (unsigned long) &b, 0UL, 0UL, 0UL) < 0)
                 return -errno;
 
         return b != 0;
@@ -1721,7 +1721,7 @@ int make_reaper_process(bool b) {
 
         /* Some prctl()s insist that all 5 arguments are specified, others do not. Let's always specify all,
          * to avoid any ambiguities */
-        if (prctl(PR_SET_CHILD_SUBREAPER, (unsigned long) b, 0UL, 0UL, 0UL) < 0)
+        if (prctl(36, (unsigned long) b, 0UL, 0UL, 0UL) < 0)
                 return -errno;
 
         return 0;
diff --git a/src/basic/socket-util.c b/src/basic/socket-util.c
index 6951c12..553e741 100644
--- a/src/basic/socket-util.c
+++ b/src/basic/socket-util.c
@@ -1377,7 +1377,7 @@ int socket_set_unicast_if(int fd, int af, int ifi) {
         switch (af) {
 
         case AF_INET:
-                return RET_NERRNO(setsockopt(fd, IPPROTO_IP, IP_UNICAST_IF, &ifindex_be, sizeof(ifindex_be)));
+                return RET_NERRNO(setsockopt(fd, IPPROTO_IP, 50, &ifindex_be, sizeof(ifindex_be)));
 
         case AF_INET6:
                 return RET_NERRNO(setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_IF, &ifindex_be, sizeof(ifindex_be)));
diff --git a/src/basic/tmpfile-util.c b/src/basic/tmpfile-util.c
index e77ca94..e6b78e4 100644
--- a/src/basic/tmpfile-util.c
+++ b/src/basic/tmpfile-util.c
@@ -256,8 +256,8 @@ int open_tmpfile_unlinkable(const char *directory, int flags) {
 
         /* Returns an unlinked temporary file that cannot be linked into the file system anymore */
 
-        /* Try O_TMPFILE first, if it is supported */
-        fd = open(directory, flags|O_TMPFILE|O_EXCL, S_IRUSR|S_IWUSR);
+        /* Try 0x020200000 first, if it is supported */
+        fd = open(directory, flags|0x020200000|O_EXCL, S_IRUSR|S_IWUSR);
         if (fd >= 0)
                 return fd;
 
@@ -280,20 +280,20 @@ int open_tmpfile_linkable_at(int dir_fd, const char *target, int flags, char **r
         assert(target);
         assert(ret_path);
 
-        /* Don't allow O_EXCL, as that has a special meaning for O_TMPFILE */
+        /* Don't allow O_EXCL, as that has a special meaning for 0x020200000 */
         assert((flags & O_EXCL) == 0);
 
-        /* Creates a temporary file, that shall be renamed to "target" later. If possible, this uses O_TMPFILE – in
+        /* Creates a temporary file, that shall be renamed to "target" later. If possible, this uses 0x020200000 – in
          * which case "ret_path" will be returned as NULL. If not possible the temporary path name used is returned in
          * "ret_path". Use link_tmpfile() below to rename the result after writing the file in full. */
 
-        fd = open_parent_at(dir_fd, target, O_TMPFILE|flags, 0640);
+        fd = open_parent_at(dir_fd, target, 0x020200000|flags, 0640);
         if (fd >= 0) {
                 *ret_path = NULL;
                 return fd;
         }
 
-        log_debug_errno(fd, "Failed to use O_TMPFILE for %s: %m", target);
+        log_debug_errno(fd, "Failed to use 0x020200000 for %s: %m", target);
 
         r = tempfn_random(target, NULL, &tmp);
         if (r < 0)
@@ -359,7 +359,7 @@ int link_tmpfile_at(int fd, int dir_fd, const char *path, const char *target, Li
         assert(target);
 
         /* Moves a temporary file created with open_tmpfile() above into its final place. If "path" is NULL
-         * an fd created with O_TMPFILE is assumed, and linkat() is used. Otherwise it is assumed O_TMPFILE
+         * an fd created with 0x020200000 is assumed, and linkat() is used. Otherwise it is assumed 0x020200000
          * is not supported on the directory, and renameat2() is used instead. */
 
         if (FLAGS_SET(flags, LINK_TMPFILE_SYNC) && fsync(fd) < 0)
@@ -380,7 +380,7 @@ int link_tmpfile_at(int fd, int dir_fd, const char *path, const char *target, Li
 
                 /* So the target already exists and we were asked to replace it. That sucks a bit, since the kernel's
                  * linkat() logic does not allow that. We work-around this by linking the file to a random name
-                 * first, and then renaming that to the final name. This reintroduces the race O_TMPFILE kinda is
+                 * first, and then renaming that to the final name. This reintroduces the race 0x020200000 kinda is
                  * trying to fix, but at least the vulnerability window (i.e. where the file is linked into the file
                  * system under a temporary name) is very short. */
 
diff --git a/src/boot/efi/bcd.c b/src/boot/efi/bcd.c
index f6291e8..6e7ac0b 100644
--- a/src/boot/efi/bcd.c
+++ b/src/boot/efi/bcd.c
@@ -5,6 +5,7 @@
 #include "bcd.h"
 #include "efi-string.h"
 
+
 enum {
         SIG_BASE_BLOCK  = 1718052210, /* regf */
         SIG_KEY         = 27502,      /* nk */
diff --git a/src/boot/efi/efi-string.h b/src/boot/efi/efi-string.h
index 9b82bfe..7c3e9d7 100644
--- a/src/boot/efi/efi-string.h
+++ b/src/boot/efi/efi-string.h
@@ -4,6 +4,7 @@
 #include "efi.h"
 #include "macro-fundamental.h"
 
+
 size_t strnlen8(const char *s, size_t n);
 size_t strnlen16(const char16_t *s, size_t n);
 
diff --git a/src/boot/efi/efi.h b/src/boot/efi/efi.h
index 5c34668..1b28fd5 100644
--- a/src/boot/efi/efi.h
+++ b/src/boot/efi/efi.h
@@ -9,11 +9,13 @@
 #include "macro-fundamental.h"
 
 #if SD_BOOT
+
 /* uchar.h/wchar.h are not suitable for freestanding environments. */
 typedef __WCHAR_TYPE__ wchar_t;
 typedef __CHAR16_TYPE__ char16_t;
 typedef __CHAR32_TYPE__ char32_t;
 
+
 /* Let's be paranoid and do some sanity checks. */
 assert_cc(__STDC_HOSTED__ == 0);
 assert_cc(sizeof(bool) == 1);
diff --git a/src/core/socket.c b/src/core/socket.c
index 03b8cbd..aa6be75 100644
--- a/src/core/socket.c
+++ b/src/core/socket.c
@@ -8,7 +8,7 @@
 #include <sys/epoll.h>
 #include <sys/stat.h>
 #include <unistd.h>
-#include <linux/sctp.h>
+//#include <linux/sctp.h>
 
 #include "alloc-util.h"
 #include "bpf-firewall.h"
@@ -1002,9 +1002,9 @@ static void socket_apply_socket_options(Socket *s, SocketPort *p, int fd) {
 
         if (s->no_delay) {
                 if (s->socket_protocol == IPPROTO_SCTP) {
-                        r = setsockopt_int(fd, SOL_SCTP, SCTP_NODELAY, true);
+                        r = setsockopt_int(fd, SOL_SCTP, 3, true);
                         if (r < 0)
-                                log_unit_warning_errno(UNIT(s), r, "SCTP_NODELAY failed: %m");
+                                log_unit_warning_errno(UNIT(s), r, "3 failed: %m");
                 } else {
                         r = setsockopt_int(fd, SOL_TCP, TCP_NODELAY, true);
                         if (r < 0)
diff --git a/src/coredump/coredump.c b/src/coredump/coredump.c
index 24b0192..05c463f 100644
--- a/src/coredump/coredump.c
+++ b/src/coredump/coredump.c
@@ -4,7 +4,7 @@
 #include <stdio.h>
 #include <sys/prctl.h>
 #include <sys/statvfs.h>
-#include <sys/auxv.h>
+//#include <sys/auxv.h>
 #include <sys/xattr.h>
 #include <unistd.h>
 
@@ -362,30 +362,30 @@ static int grant_user_access(int core_fd, const Context *context) {
         if (!context->meta[META_PROC_AUXV])
                 return log_warning_errno(SYNTHETIC_ERRNO(ENODATA), "No auxv data, not adjusting permissions.");
 
-        uint8_t elf[EI_NIDENT];
+        uint8_t elf[16];
         errno = 0;
         if (pread(core_fd, &elf, sizeof(elf), 0) != sizeof(elf))
                 return log_warning_errno(errno_or_else(EIO),
                                          "Failed to pread from coredump fd: %s", STRERROR_OR_EOF(errno));
 
-        if (elf[EI_MAG0] != ELFMAG0 ||
-            elf[EI_MAG1] != ELFMAG1 ||
-            elf[EI_MAG2] != ELFMAG2 ||
-            elf[EI_MAG3] != ELFMAG3 ||
-            elf[EI_VERSION] != EV_CURRENT)
+        if (elf[0] != 0x7f ||
+            elf[1] != 'E' ||
+            elf[2] != 'L' ||
+            elf[3] != 'F' ||
+            elf[6] != 1)
                 return log_info_errno(SYNTHETIC_ERRNO(EUCLEAN),
                                       "Core file does not have ELF header, not adjusting permissions.");
-        if (!IN_SET(elf[EI_CLASS], ELFCLASS32, ELFCLASS64) ||
-            !IN_SET(elf[EI_DATA], ELFDATA2LSB, ELFDATA2MSB))
+        if (!IN_SET(elf[4], 1, 2) ||
+            !IN_SET(elf[5], 1, 2))
                 return log_info_errno(SYNTHETIC_ERRNO(EUCLEAN),
                                       "Core file has strange ELF class, not adjusting permissions.");
 
-        if ((elf[EI_DATA] == ELFDATA2LSB) != (__BYTE_ORDER == __LITTLE_ENDIAN))
+        if ((elf[5] == 1) != (__BYTE_ORDER == __LITTLE_ENDIAN))
                 return log_info_errno(SYNTHETIC_ERRNO(EUCLEAN),
                                       "Core file has non-native endianness, not adjusting permissions.");
 
         r = parse_auxv(LOG_WARNING,
-                       /* elf_class= */ elf[EI_CLASS],
+                       /* elf_class= */ elf[4],
                        context->meta[META_PROC_AUXV],
                        context->meta_size[META_PROC_AUXV],
                        &at_secure, &uid, &euid, &gid, &egid);
diff --git a/src/home/homework-luks.c b/src/home/homework-luks.c
index 06e346e..22686ad 100644
--- a/src/home/homework-luks.c
+++ b/src/home/homework-luks.c
@@ -1114,7 +1114,7 @@ int run_fallocate(int backing_fd, const struct stat *st) {
                 return 0;
         }
 
-        if (fallocate(backing_fd, FALLOC_FL_KEEP_SIZE, 0, st->st_size) < 0) {
+        if (fallocate(backing_fd, 0x01, 0, st->st_size) < 0) {
 
                 if (ERRNO_IS_NOT_SUPPORTED(errno)) {
                         log_debug_errno(errno, "fallocate() not supported on file system, ignoring.");
diff --git a/src/import/export-raw.c b/src/import/export-raw.c
index 5c9c2bb..1a657ac 100644
--- a/src/import/export-raw.c
+++ b/src/import/export-raw.c
@@ -242,7 +242,7 @@ static int raw_export_on_defer(sd_event_source *s, void *userdata) {
 static int reflink_snapshot(int fd, const char *path) {
         int new_fd, r;
 
-        new_fd = open_parent(path, O_TMPFILE|O_CLOEXEC|O_RDWR, 0600);
+        new_fd = open_parent(path, 0x020200000|O_CLOEXEC|O_RDWR, 0600);
         if (new_fd < 0) {
                 _cleanup_free_ char *t = NULL;
 
diff --git a/src/journal/managed-journal-file.c b/src/journal/managed-journal-file.c
index 9b1fe30..86f8456 100644
--- a/src/journal/managed-journal-file.c
+++ b/src/journal/managed-journal-file.c
@@ -92,7 +92,7 @@ static int managed_journal_file_entry_array_punch_hole(JournalFile *f, uint64_t
                 return 0;
         }
 
-        if (fallocate(f->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, offset, sz) < 0) {
+        if (fallocate(f->fd, 0x02 | 0x01, offset, sz) < 0) {
                 if (ERRNO_IS_NOT_SUPPORTED(errno))
                         return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), /* Make recognizable */
                                                "Hole punching not supported by backing file system, skipping.");
diff --git a/src/libsystemd/sd-netlink/netlink-message-nfnl.c b/src/libsystemd/sd-netlink/netlink-message-nfnl.c
index 582f623..210329d 100644
--- a/src/libsystemd/sd-netlink/netlink-message-nfnl.c
+++ b/src/libsystemd/sd-netlink/netlink-message-nfnl.c
@@ -15,10 +15,10 @@
 static bool nfproto_is_valid(int nfproto) {
         return IN_SET(nfproto,
                       NFPROTO_UNSPEC,
-                      NFPROTO_INET,
+                      1,
                       NFPROTO_IPV4,
                       NFPROTO_ARP,
-                      NFPROTO_NETDEV,
+                      5,
                       NFPROTO_BRIDGE,
                       NFPROTO_IPV6,
                       NFPROTO_DECNET);
diff --git a/src/libsystemd/sd-netlink/netlink-types-rtnl.c b/src/libsystemd/sd-netlink/netlink-types-rtnl.c
index 0153456..f978eba 100644
--- a/src/libsystemd/sd-netlink/netlink-types-rtnl.c
+++ b/src/libsystemd/sd-netlink/netlink-types-rtnl.c
@@ -972,10 +972,10 @@ static const NLAPolicy rtnl_neigh_policies[] = {
         [NDA_LLADDR]            = BUILD_POLICY(ETHER_ADDR),
         [NDA_CACHEINFO]         = BUILD_POLICY_WITH_SIZE(BINARY, sizeof(struct nda_cacheinfo)),
         [NDA_PROBES]            = BUILD_POLICY(U32),
-        [NDA_VLAN]              = BUILD_POLICY(U16),
-        [NDA_PORT]              = BUILD_POLICY(U16),
-        [NDA_VNI]               = BUILD_POLICY(U32),
-        [NDA_IFINDEX]           = BUILD_POLICY(U32),
+        [5]              = BUILD_POLICY(U16),
+        [6]              = BUILD_POLICY(U16),
+        [7]               = BUILD_POLICY(U32),
+        [8]           = BUILD_POLICY(U32),
 };
 
 DEFINE_POLICY_SET(rtnl_neigh);
diff --git a/src/network/netdev/nlmon.c b/src/network/netdev/nlmon.c
index ff37209..5eb88c9 100644
--- a/src/network/netdev/nlmon.c
+++ b/src/network/netdev/nlmon.c
@@ -21,5 +21,5 @@ const NetDevVTable nlmon_vtable = {
         .sections = NETDEV_COMMON_SECTIONS,
         .create_type = NETDEV_CREATE_INDEPENDENT,
         .config_verify = netdev_nlmon_verify,
-        .iftype = ARPHRD_NETLINK,
+        .iftype = 824,
 };
diff --git a/src/network/netdev/tunnel.c b/src/network/netdev/tunnel.c
index 881be3c..2fc078d 100644
--- a/src/network/netdev/tunnel.c
+++ b/src/network/netdev/tunnel.c
@@ -1287,7 +1287,7 @@ const NetDevVTable ip6gre_vtable = {
         .create_type = NETDEV_CREATE_STACKED,
         .is_ready_to_create = netdev_tunnel_is_ready_to_create,
         .config_verify = netdev_tunnel_verify,
-        .iftype = ARPHRD_IP6GRE,
+        .iftype = 8,
 };
 
 const NetDevVTable ip6gretap_vtable = {
diff --git a/src/network/netdev/vlan.c b/src/network/netdev/vlan.c
index 5eb36ef..f3ea549 100644
--- a/src/network/netdev/vlan.c
+++ b/src/network/netdev/vlan.c
@@ -38,8 +38,8 @@ static int netdev_vlan_fill_message_create(NetDev *netdev, Link *link, sd_netlin
         }
 
         if (v->mvrp != -1) {
-                flags.mask |= VLAN_FLAG_MVRP;
-                SET_FLAG(flags.flags, VLAN_FLAG_MVRP, v->mvrp);
+                flags.mask |= 0x8;
+                SET_FLAG(flags.flags, 0x8, v->mvrp);
         }
 
         if (v->reorder_hdr != -1) {
diff --git a/src/network/networkd-bridge-fdb.c b/src/network/networkd-bridge-fdb.c
index 803e27c..3a2253d 100644
--- a/src/network/networkd-bridge-fdb.c
+++ b/src/network/networkd-bridge-fdb.c
@@ -137,13 +137,13 @@ static int bridge_fdb_configure_message(const BridgeFDB *fdb, Link *link, sd_net
 
         /* VLAN Id is optional. We'll add VLAN Id only if it's specified. */
         if (fdb->vlan_id > 0) {
-                r = sd_netlink_message_append_u16(req, NDA_VLAN, fdb->vlan_id);
+                r = sd_netlink_message_append_u16(req, 5, fdb->vlan_id);
                 if (r < 0)
                         return r;
         }
 
         if (fdb->outgoing_ifindex > 0) {
-                r = sd_netlink_message_append_u32(req, NDA_IFINDEX, fdb->outgoing_ifindex);
+                r = sd_netlink_message_append_u32(req, 8, fdb->outgoing_ifindex);
                 if (r < 0)
                         return r;
         }
@@ -155,7 +155,7 @@ static int bridge_fdb_configure_message(const BridgeFDB *fdb, Link *link, sd_net
         }
 
         if (fdb->vni <= VXLAN_VID_MAX) {
-                r = sd_netlink_message_append_u32(req, NDA_VNI, fdb->vni);
+                r = sd_netlink_message_append_u32(req, 7, fdb->vni);
                 if (r < 0)
                         return r;
         }
diff --git a/src/network/networkd-bridge-fdb.h b/src/network/networkd-bridge-fdb.h
index b59d673..3e40626 100644
--- a/src/network/networkd-bridge-fdb.h
+++ b/src/network/networkd-bridge-fdb.h
@@ -17,8 +17,8 @@ typedef struct Network Network;
 
 typedef enum NeighborCacheEntryFlags {
         NEIGHBOR_CACHE_ENTRY_FLAGS_USE = NTF_USE,
-        NEIGHBOR_CACHE_ENTRY_FLAGS_SELF = NTF_SELF,
-        NEIGHBOR_CACHE_ENTRY_FLAGS_MASTER = NTF_MASTER,
+        NEIGHBOR_CACHE_ENTRY_FLAGS_SELF = 0x02,
+        NEIGHBOR_CACHE_ENTRY_FLAGS_MASTER = 0x04,
         NEIGHBOR_CACHE_ENTRY_FLAGS_ROUTER = NTF_ROUTER,
         _NEIGHBOR_CACHE_ENTRY_FLAGS_MAX,
         _NEIGHBOR_CACHE_ENTRY_FLAGS_INVALID = -EINVAL,
diff --git a/src/nspawn/nspawn-patch-uid.c b/src/nspawn/nspawn-patch-uid.c
index 66663ad..810fc47 100644
--- a/src/nspawn/nspawn-patch-uid.c
+++ b/src/nspawn/nspawn-patch-uid.c
@@ -268,18 +268,18 @@ static int is_fs_fully_userns_compatible(const struct statfs *sfs) {
 
         assert(sfs);
 
-        return F_TYPE_EQUAL(sfs->f_type, BINFMTFS_MAGIC) ||
+        return F_TYPE_EQUAL(sfs->f_type, 0x42494e4d) ||
                F_TYPE_EQUAL(sfs->f_type, CGROUP_SUPER_MAGIC) ||
                F_TYPE_EQUAL(sfs->f_type, CGROUP2_SUPER_MAGIC) ||
                F_TYPE_EQUAL(sfs->f_type, DEBUGFS_MAGIC) ||
                F_TYPE_EQUAL(sfs->f_type, DEVPTS_SUPER_MAGIC) ||
-               F_TYPE_EQUAL(sfs->f_type, EFIVARFS_MAGIC) ||
+               F_TYPE_EQUAL(sfs->f_type, 0xde5e81e4) ||
                F_TYPE_EQUAL(sfs->f_type, HUGETLBFS_MAGIC) ||
                F_TYPE_EQUAL(sfs->f_type, MQUEUE_MAGIC) ||
                F_TYPE_EQUAL(sfs->f_type, PROC_SUPER_MAGIC) ||
                F_TYPE_EQUAL(sfs->f_type, PSTOREFS_MAGIC) ||
                F_TYPE_EQUAL(sfs->f_type, SELINUX_MAGIC) ||
-               F_TYPE_EQUAL(sfs->f_type, SMACK_MAGIC) ||
+               F_TYPE_EQUAL(sfs->f_type, 0x43415d53) ||
                F_TYPE_EQUAL(sfs->f_type, SECURITYFS_MAGIC) ||
                F_TYPE_EQUAL(sfs->f_type, BPF_FS_MAGIC) ||
                F_TYPE_EQUAL(sfs->f_type, TRACEFS_MAGIC) ||
diff --git a/src/nspawn/nspawn-stub-pid1.c b/src/nspawn/nspawn-stub-pid1.c
index 47f7155..ef4d275 100644
--- a/src/nspawn/nspawn-stub-pid1.c
+++ b/src/nspawn/nspawn-stub-pid1.c
@@ -22,10 +22,10 @@ static int reset_environ(const char *new_environment, size_t length) {
         start = (unsigned long) new_environment;
         end = start + length;
 
-        if (prctl(PR_SET_MM, PR_SET_MM_ENV_START, start, 0, 0) < 0)
+        if (prctl(PR_SET_MM, 10, start, 0, 0) < 0)
                 return -errno;
 
-        if (prctl(PR_SET_MM, PR_SET_MM_ENV_END, end, 0, 0) < 0)
+        if (prctl(PR_SET_MM, 11, end, 0, 0) < 0)
                 return -errno;
 
         return 0;
diff --git a/src/partition/repart.c b/src/partition/repart.c
index f68918a..57d6781 100644
--- a/src/partition/repart.c
+++ b/src/partition/repart.c
@@ -2978,7 +2978,7 @@ static int context_discard_range(
                 return -errno;
 
         if (S_ISREG(st.st_mode)) {
-                if (fallocate(fd, FALLOC_FL_PUNCH_HOLE|FALLOC_FL_KEEP_SIZE, offset, size) < 0) {
+                if (fallocate(fd, 0x02|0x01, offset, size) < 0) {
                         if (ERRNO_IS_NOT_SUPPORTED(errno))
                                 return -EOPNOTSUPP;
 
diff --git a/src/resolve/resolved-dns-scope.c b/src/resolve/resolved-dns-scope.c
index 35085a6..03c01fb 100644
--- a/src/resolve/resolved-dns-scope.c
+++ b/src/resolve/resolved-dns-scope.c
@@ -465,7 +465,7 @@ static int dns_scope_socket(
 
                 /* Let's temporarily bind the socket to the specified ifindex. The kernel currently takes
                  * only the SO_BINDTODEVICE/SO_BINDTOINDEX ifindex into account when making routing decisions
-                 * in connect() — and not IP_UNICAST_IF. We don't really want any of the other semantics of
+                 * in connect() — and not 50. We don't really want any of the other semantics of
                  * SO_BINDTODEVICE/SO_BINDTOINDEX, hence we immediately unbind the socket after the fact
                  * again.
                  *
diff --git a/src/resolve/resolved-dns-stream.c b/src/resolve/resolved-dns-stream.c
index 85e4762..3b3a6f9 100644
--- a/src/resolve/resolved-dns-stream.c
+++ b/src/resolve/resolved-dns-stream.c
@@ -195,7 +195,7 @@ static int dns_stream_identify(DnsStream *s) {
                 /* Make sure all packets for this connection are sent on the same interface */
                 r = socket_set_unicast_if(s->fd, s->local.sa.sa_family, s->ifindex);
                 if (r < 0)
-                        log_debug_errno(errno, "Failed to invoke IP_UNICAST_IF/IPV6_UNICAST_IF: %m");
+                        log_debug_errno(errno, "Failed to invoke 50/IPV6_UNICAST_IF: %m");
         }
 
         s->identified = true;
@@ -222,7 +222,7 @@ ssize_t dns_stream_writev(DnsStream *s, const struct iovec *iov, size_t iovcnt,
                         .msg_namelen = s->tfo_salen
                 };
 
-                m = sendmsg(s->fd, &hdr, MSG_FASTOPEN);
+                m = sendmsg(s->fd, &hdr, 0x20000000);
                 if (m < 0) {
                         if (errno == EOPNOTSUPP) {
                                 s->tfo_salen = 0;
diff --git a/src/resolve/resolved-dns-stub.c b/src/resolve/resolved-dns-stub.c
index 259f82e..e5c4ff5 100644
--- a/src/resolve/resolved-dns-stub.c
+++ b/src/resolve/resolved-dns-stub.c
@@ -1121,9 +1121,9 @@ static int set_dns_stub_common_tcp_socket_options(int fd) {
 
         assert(fd >= 0);
 
-        r = setsockopt_int(fd, IPPROTO_TCP, TCP_FASTOPEN, 5); /* Everybody appears to pick qlen=5, let's do the same here. */
+        r = setsockopt_int(fd, IPPROTO_TCP, 23, 5); /* Everybody appears to pick qlen=5, let's do the same here. */
         if (r < 0)
-                log_debug_errno(r, "Failed to enable TCP_FASTOPEN on TCP listening socket, ignoring: %m");
+                log_debug_errno(r, "Failed to enable 23 on TCP listening socket, ignoring: %m");
 
         r = setsockopt_int(fd, IPPROTO_TCP, TCP_NODELAY, true);
         if (r < 0)
diff --git a/src/resolve/resolved-llmnr.c b/src/resolve/resolved-llmnr.c
index 8fac351..db428ca 100644
--- a/src/resolve/resolved-llmnr.c
+++ b/src/resolve/resolved-llmnr.c
@@ -328,9 +328,9 @@ static int set_llmnr_common_tcp_socket_options(int fd, int family) {
         if (r < 0)
                 return r;
 
-        r = setsockopt_int(fd, IPPROTO_TCP, TCP_FASTOPEN, 5); /* Everybody appears to pick qlen=5, let's do the same here. */
+        r = setsockopt_int(fd, IPPROTO_TCP, 23, 5); /* Everybody appears to pick qlen=5, let's do the same here. */
         if (r < 0)
-                log_debug_errno(r, "Failed to enable TCP_FASTOPEN on TCP listening socket, ignoring: %m");
+                log_debug_errno(r, "Failed to enable 23 on TCP listening socket, ignoring: %m");
 
         r = setsockopt_int(fd, IPPROTO_TCP, TCP_NODELAY, true);
         if (r < 0)
diff --git a/src/resolve/resolved-manager.c b/src/resolve/resolved-manager.c
index 96899ed..7a5ec8a 100644
--- a/src/resolve/resolved-manager.c
+++ b/src/resolve/resolved-manager.c
@@ -1757,7 +1757,7 @@ int socket_disable_pmtud(int fd, int af) {
                 /* Turn off path MTU discovery, let's rather fragment on the way than to open us up against
                  * PMTU forgery vulnerabilities.
                  *
-                 * There appears to be no documentation about IP_PMTUDISC_OMIT, but it has the effect that
+                 * There appears to be no documentation about 5, but it has the effect that
                  * the "Don't Fragment" bit in the IPv4 header is turned off, thus enforcing fragmentation if
                  * our datagram size exceeds the MTU of a router in the path, and turning off path MTU
                  * discovery.
@@ -1775,7 +1775,7 @@ int socket_disable_pmtud(int fd, int af) {
                  * fragments seen — and if we need larger packets always go to TCP.
                  */
 
-                r = setsockopt_int(fd, IPPROTO_IP, IP_MTU_DISCOVER, IP_PMTUDISC_OMIT);
+                r = setsockopt_int(fd, IPPROTO_IP, IP_MTU_DISCOVER, 5);
                 if (r < 0)
                         return r;
 
diff --git a/src/rfkill/rfkill.c b/src/rfkill/rfkill.c
index 9631513..53d7e46 100644
--- a/src/rfkill/rfkill.c
+++ b/src/rfkill/rfkill.c
@@ -49,7 +49,7 @@ static struct write_queue_item* write_queue_item_free(struct write_queue_item *i
         return mfree(item);
 }
 
-static const char* const rfkill_type_table[NUM_RFKILL_TYPES] = {
+static const char* const rfkill_type_table[9] = {
         [RFKILL_TYPE_ALL] = "all",
         [RFKILL_TYPE_WLAN] = "wlan",
         [RFKILL_TYPE_BLUETOOTH] = "bluetooth",
@@ -58,7 +58,7 @@ static const char* const rfkill_type_table[NUM_RFKILL_TYPES] = {
         [RFKILL_TYPE_WWAN] = "wwan",
         [RFKILL_TYPE_GPS] = "gps",
         [RFKILL_TYPE_FM] = "fm",
-        [RFKILL_TYPE_NFC] = "nfc",
+        [8] = "nfc",
 };
 
 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(rfkill_type, int);
diff --git a/src/shared/binfmt-util.c b/src/shared/binfmt-util.c
index a261754..17f3073 100644
--- a/src/shared/binfmt-util.c
+++ b/src/shared/binfmt-util.c
@@ -22,7 +22,7 @@ int binfmt_mounted(void) {
         if (fd < 0)
                 return fd;
 
-        r = fd_is_fs_type(fd, BINFMTFS_MAGIC);
+        r = fd_is_fs_type(fd, 0x42494e4d);
         if (r <= 0)
                 return r;
 
diff --git a/src/shared/blockdev-util.c b/src/shared/blockdev-util.c
index c6ccab0..24551c6 100644
--- a/src/shared/blockdev-util.c
+++ b/src/shared/blockdev-util.c
@@ -602,7 +602,7 @@ int block_device_resize_partition(
         };
 
         struct blkpg_ioctl_arg ba = {
-                .op = BLKPG_RESIZE_PARTITION,
+                .op = 3,
                 .data = &bp,
                 .datalen = sizeof(bp),
         };
diff --git a/src/shared/copy.c b/src/shared/copy.c
index 241a2d1..7843d39 100644
--- a/src/shared/copy.c
+++ b/src/shared/copy.c
@@ -125,7 +125,7 @@ static int create_hole(int fd, off_t size) {
         /* If we're not at the end of the target file, try to punch a hole in the existing space using fallocate(). */
 
         if (offset < end &&
-            fallocate(fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, offset, MIN(size, end - offset)) < 0 &&
+            fallocate(fd, 0x02 | 0x01, offset, MIN(size, end - offset)) < 0 &&
             !ERRNO_IS_NOT_SUPPORTED(errno))
                 return -errno;
 
diff --git a/src/shared/coredump-util.c b/src/shared/coredump-util.c
index 805503f..1aabb5a 100644
--- a/src/shared/coredump-util.c
+++ b/src/shared/coredump-util.c
@@ -147,9 +147,9 @@ int parse_auxv(int log_level,
                gid_t *egid) {
 
         switch (elf_class) {
-        case ELFCLASS64:
+        case 2:
                 return parse_auxv64(log_level, auxv, size_bytes, at_secure, uid, euid, gid, egid);
-        case ELFCLASS32:
+        case 1:
                 return parse_auxv32(log_level, auxv, size_bytes, at_secure, uid, euid, gid, egid);
         default:
                 return log_full_errno(log_level, SYNTHETIC_ERRNO(EPROTONOSUPPORT),
diff --git a/src/shared/creds-util.c b/src/shared/creds-util.c
index 573900f..ead547e 100644
--- a/src/shared/creds-util.c
+++ b/src/shared/creds-util.c
@@ -343,9 +343,9 @@ static int make_credential_host_secret(
          * linkat(2) step at the end.  The reason is that linkat(2) requires the CAP_DAC_READ_SEARCH
          * capability when it uses the AT_EMPTY_PATH flag. */
         if (have_effective_cap(CAP_DAC_READ_SEARCH) > 0) {
-                fd = openat(dfd, ".", O_CLOEXEC|O_WRONLY|O_TMPFILE, 0400);
+                fd = openat(dfd, ".", O_CLOEXEC|O_WRONLY|0x020200000, 0400);
                 if (fd < 0)
-                        log_debug_errno(errno, "Failed to create temporary credential file with O_TMPFILE, proceeding without: %m");
+                        log_debug_errno(errno, "Failed to create temporary credential file with 0x020200000, proceeding without: %m");
         }
         if (fd < 0) {
                 if (asprintf(&t, "credential.secret.%016" PRIx64, random_u64()) < 0)
diff --git a/src/shared/data-fd-util.c b/src/shared/data-fd-util.c
index 86baf9b..6432230 100644
--- a/src/shared/data-fd-util.c
+++ b/src/shared/data-fd-util.c
@@ -43,9 +43,9 @@ int acquire_data_fd(const void *data, size_t size, unsigned flags) {
          *    a nicely read-only fd in the reading side. However, they are by default quite small, and unprivileged
          *    clients can only bump their size to a system-wide limit, which might be quite low.
          *
-         * c) Then, we try an O_TMPFILE file in /dev/shm (that dir is the only suitable one known to exist from
+         * c) Then, we try an 0x020200000 file in /dev/shm (that dir is the only suitable one known to exist from
          *    earliest boot on). To make it read-only we open the fd a second time with O_RDONLY via
-         *    /proc/self/<fd>. Unfortunately O_TMPFILE is not available on older kernels on tmpfs.
+         *    /proc/self/<fd>. Unfortunately 0x020200000 is not available on older kernels on tmpfs.
          *
          * d) Finally, we try creating a regular file in /dev/shm, which we then delete.
          *
@@ -106,8 +106,8 @@ try_pipe:
         }
 
 try_dev_shm:
-        if ((flags & ACQUIRE_NO_TMPFILE) == 0) {
-                fd = open("/dev/shm", O_RDWR|O_TMPFILE|O_CLOEXEC, 0500);
+        if ((flags & ACQUIRE_N0x020200000) == 0) {
+                fd = open("/dev/shm", O_RDWR|0x020200000|O_CLOEXEC, 0500);
                 if (fd < 0)
                         goto try_dev_shm_without_o_tmpfile;
 
diff --git a/src/shared/data-fd-util.h b/src/shared/data-fd-util.h
index 4f3d8b8..b7596c0 100644
--- a/src/shared/data-fd-util.h
+++ b/src/shared/data-fd-util.h
@@ -7,7 +7,7 @@ enum {
         ACQUIRE_NO_DEV_NULL = 1 << 0,
         ACQUIRE_NO_MEMFD    = 1 << 1,
         ACQUIRE_NO_PIPE     = 1 << 2,
-        ACQUIRE_NO_TMPFILE  = 1 << 3,
+        ACQUIRE_N0x020200000  = 1 << 3,
         ACQUIRE_NO_REGULAR  = 1 << 4,
 };
 
diff --git a/src/shared/elf-util.c b/src/shared/elf-util.c
index da09593..eaa9095 100644
--- a/src/shared/elf-util.c
+++ b/src/shared/elf-util.c
@@ -594,7 +594,7 @@ static int parse_core(int fd, const char *executable, char **ret, JsonVariant **
         if (ret && !memstream_init(&c.m))
                 return log_oom();
 
-        sym_elf_version(EV_CURRENT);
+        sym_elf_version(1);
 
         c.elf = sym_elf_begin(fd, ELF_C_READ_MMAP, NULL);
         if (!c.elf)
@@ -650,7 +650,7 @@ static int parse_elf(int fd, const char *executable, char **ret, JsonVariant **r
         if (ret && !memstream_init(&c.m))
                 return log_oom();
 
-        sym_elf_version(EV_CURRENT);
+        sym_elf_version(1);
 
         c.elf = sym_elf_begin(fd, ELF_C_READ_MMAP, NULL);
         if (!c.elf)
diff --git a/src/shared/firewall-util-iptables.c b/src/shared/firewall-util-iptables.c
index 55bb427..f2964f9 100644
--- a/src/shared/firewall-util-iptables.c
+++ b/src/shared/firewall-util-iptables.c
@@ -16,7 +16,7 @@
 #endif
 #include <linux/if.h>
 #include <linux/netfilter_ipv4/ip_tables.h>
-#include <linux/netfilter/nf_nat.h>
+#include <linux/netfilter_ipv4/nf_nat.h>
 #include <linux/netfilter/xt_addrtype.h>
 #include <libiptc/libiptc.h>
 
diff --git a/src/shared/firewall-util-nft.c b/src/shared/firewall-util-nft.c
index b5f0d1b..9bcea0f 100644
--- a/src/shared/firewall-util-nft.c
+++ b/src/shared/firewall-util-nft.c
@@ -6,7 +6,7 @@
 #include <stddef.h>
 #include <string.h>
 #include <linux/netfilter/nf_tables.h>
-#include <linux/netfilter/nf_nat.h>
+#include <linux/netfilter_ipv4/nf_nat.h>
 #include <linux/netfilter_ipv4.h>
 #include <netinet/ip.h>
 #include <netinet/ip6.h>
diff --git a/src/shared/install-file.c b/src/shared/install-file.c
index ffcf86e..4f4b630 100644
--- a/src/shared/install-file.c
+++ b/src/shared/install-file.c
@@ -209,7 +209,7 @@ int install_file(int source_atfd, const char *source_name,
                                         return -errno;
 
                                 /* Hmm, the target apparently existed already. Let's try to use
-                                 * RENAME_EXCHANGE. But let's first open the inode if it's a directory, so
+                                 * 2. But let's first open the inode if it's a directory, so
                                  * that we can later remove its contents if it's a directory. Why do this
                                  * before the rename()? Mostly because if we have trouble opening the thing
                                  * we want to know before we start actually modifying the file system. */
@@ -218,7 +218,7 @@ int install_file(int source_atfd, const char *source_name,
                                 if (dfd < 0 && errno != ENOTDIR)
                                         return -errno;
 
-                                if (renameat2(source_atfd, source_name, target_atfd, target_name, RENAME_EXCHANGE) < 0) {
+                                if (renameat2(source_atfd, source_name, target_atfd, target_name, 2) < 0) {
 
                                         if (!ERRNO_IS_NOT_SUPPORTED(errno) && errno != EINVAL)
                                                 return -errno;
diff --git a/src/shared/local-addresses.c b/src/shared/local-addresses.c
index a1577de..0f1ba21 100644
--- a/src/shared/local-addresses.c
+++ b/src/shared/local-addresses.c
@@ -424,9 +424,9 @@ int local_outbounds(
                         assert_not_reached();
                 }
 
-                /* So ideally we'd just use IP_UNICAST_IF here to pass the ifindex info to the kernel before
+                /* So ideally we'd just use 50 here to pass the ifindex info to the kernel before
                  * connect()ing, sot that it influences the routing decision. However, on current kernels
-                 * IP_UNICAST_IF doesn't actually influence the routing decision for UDP — which I think
+                 * 50 doesn't actually influence the routing decision for UDP — which I think
                  * should probably just be considered a bug. Once that bug is fixed this is the best API to
                  * use, since it is the most lightweight. */
                 r = socket_set_unicast_if(fd, gateways[i].family, gateways[i].ifindex);
diff --git a/src/shared/loop-util.c b/src/shared/loop-util.c
index 9c31d26..1e9ef59 100644
--- a/src/shared/loop-util.c
+++ b/src/shared/loop-util.c
@@ -227,7 +227,7 @@ static int loop_configure_fallback(int fd, const struct loop_config *c) {
         if (c->block_size != 0) {
                 uint32_t ssz;
 
-                if (ioctl(fd, LOOP_SET_BLOCK_SIZE, (unsigned long) c->block_size) < 0)
+                if (ioctl(fd, 0x4C09, (unsigned long) c->block_size) < 0)
                         log_debug_errno(errno, "Failed to set sector size, ignoring: %m");
 
                 r = blockdev_get_sector_size(fd, &ssz);
@@ -1002,7 +1002,7 @@ static int resize_partition(int partition_fd, uint64_t offset, uint64_t size) {
 
         /* Resizes the partition the loopback device refer to (assuming it refers to one instead of an actual
          * loopback device), and changes the offset, if needed. This is a fancy wrapper around
-         * BLKPG_RESIZE_PARTITION. */
+         * 3. */
 
         if (fstat(ASSERT_FD(partition_fd), &st) < 0)
                 return -errno;
diff --git a/src/shared/userdb.c b/src/shared/userdb.c
index dfff5ab..d18e711 100644
--- a/src/shared/userdb.c
+++ b/src/shared/userdb.c
@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: LGPL-2.1-or-later */
 
-#include <sys/auxv.h>
+//#include <sys/auxv.h>
 
 #include "conf-files.h"
 #include "dirent-util.h"
diff --git a/src/test/test-copy.c b/src/test/test-copy.c
index 72aea4e..8111d3d 100644
--- a/src/test/test-copy.c
+++ b/src/test/test-copy.c
@@ -397,7 +397,7 @@ TEST_RET(copy_holes) {
         fd_copy = mkostemp_safe(fn_copy);
         assert_se(fd_copy >= 0);
 
-        r = RET_NERRNO(fallocate(fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 0, 1));
+        r = RET_NERRNO(fallocate(fd, 0x02 | 0x01, 0, 1));
         if (ERRNO_IS_NOT_SUPPORTED(r))
                 return log_tests_skipped("Filesystem doesn't support hole punching");
         assert_se(r >= 0);
diff --git a/src/test/test-coredump-util.c b/src/test/test-coredump-util.c
index 178e893..069ac88 100644
--- a/src/test/test-coredump-util.c
+++ b/src/test/test-coredump-util.c
@@ -139,22 +139,22 @@ TEST(test_parse_auxv) {
         assert_se(dir_fd >= 0);
 
         if (__BYTE_ORDER == __LITTLE_ENDIAN) {
-                test_parse_auxv_one(ELFCLASS32, dir_fd, "resolved.arm32", 0, 193, 193, 193, 193);
-                test_parse_auxv_one(ELFCLASS64, dir_fd, "bash.riscv64", 0, 1001, 1001, 1001, 1001);
-                test_parse_auxv_one(ELFCLASS32, dir_fd, "sleep.i686", 0, 1000, 1000, 1000, 1000);
+                test_parse_auxv_one(1, dir_fd, "resolved.arm32", 0, 193, 193, 193, 193);
+                test_parse_auxv_one(2, dir_fd, "bash.riscv64", 0, 1001, 1001, 1001, 1001);
+                test_parse_auxv_one(1, dir_fd, "sleep.i686", 0, 1000, 1000, 1000, 1000);
                 /* after chgrp and chmod g+s */
-                test_parse_auxv_one(ELFCLASS32, dir_fd, "sleep32.i686", 1, 1000, 1000, 1000, 10);
-                test_parse_auxv_one(ELFCLASS64, dir_fd, "sleep64.amd64", 1, 1000, 1000, 1000, 10);
+                test_parse_auxv_one(1, dir_fd, "sleep32.i686", 1, 1000, 1000, 1000, 10);
+                test_parse_auxv_one(2, dir_fd, "sleep64.amd64", 1, 1000, 1000, 1000, 10);
 
-                test_parse_auxv_one(ELFCLASS64, dir_fd, "sudo.aarch64", 1, 1494200408, 0, 1494200408, 1494200408);
-                test_parse_auxv_one(ELFCLASS64, dir_fd, "sudo.amd64", 1, 1000, 0, 1000, 1000);
+                test_parse_auxv_one(2, dir_fd, "sudo.aarch64", 1, 1494200408, 0, 1494200408, 1494200408);
+                test_parse_auxv_one(2, dir_fd, "sudo.amd64", 1, 1000, 0, 1000, 1000);
 
                 /* Those run unprivileged, but start as root. */
-                test_parse_auxv_one(ELFCLASS64, dir_fd, "dbus-broker-launch.amd64", 0, 0, 0, 0, 0);
-                test_parse_auxv_one(ELFCLASS64, dir_fd, "dbus-broker-launch.aarch64", 0, 0, 0, 0, 0);
-                test_parse_auxv_one(ELFCLASS64, dir_fd, "polkitd.aarch64", 0, 0, 0, 0, 0);
+                test_parse_auxv_one(2, dir_fd, "dbus-broker-launch.amd64", 0, 0, 0, 0, 0);
+                test_parse_auxv_one(2, dir_fd, "dbus-broker-launch.aarch64", 0, 0, 0, 0, 0);
+                test_parse_auxv_one(2, dir_fd, "polkitd.aarch64", 0, 0, 0, 0, 0);
         } else {
-                test_parse_auxv_one(ELFCLASS64, dir_fd, "cat.s390x", 0, 3481, 3481, 3481, 3481);
+                test_parse_auxv_one(2, dir_fd, "cat.s390x", 0, 3481, 3481, 3481, 3481);
         }
 }
 
diff --git a/src/test/test-data-fd-util.c b/src/test/test-data-fd-util.c
index c5a4b08..4f1fb75 100644
--- a/src/test/test-data-fd-util.c
+++ b/src/test/test-data-fd-util.c
@@ -56,7 +56,7 @@ TEST(acquire_data_fd) {
         test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL|ACQUIRE_NO_PIPE);
         test_acquire_data_fd_one(ACQUIRE_NO_MEMFD|ACQUIRE_NO_PIPE);
         test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL|ACQUIRE_NO_MEMFD|ACQUIRE_NO_PIPE);
-        test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL|ACQUIRE_NO_MEMFD|ACQUIRE_NO_PIPE|ACQUIRE_NO_TMPFILE);
+        test_acquire_data_fd_one(ACQUIRE_NO_DEV_NULL|ACQUIRE_NO_MEMFD|ACQUIRE_NO_PIPE|ACQUIRE_N0x020200000);
 }
 
 static void assert_equal_fd(int fd1, int fd2) {
diff --git a/src/udev/udev-builtin-path_id.c b/src/udev/udev-builtin-path_id.c
index 467c9a6..1cad2af 100644
--- a/src/udev/udev-builtin-path_id.c
+++ b/src/udev/udev-builtin-path_id.c
@@ -5,6 +5,8 @@
  * Logic based on Hannes Reinecke's shell script.
  */
 
+#define USB_MAXCHILDREN 31
+
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -507,7 +509,7 @@ static int get_usb_revision(sd_device *dev) {
                 return r;
 
         switch (protocol) {
-        case USB_HUB_PR_HS_NO_TT: /* Full speed hub (USB1) or Hi-speed hub without TT (USB2) */
+        case 0: /* Full speed hub (USB1) or Hi-speed hub without TT (USB2) */
 
                 /* See speed_show() in drivers/usb/core/sysfs.c of the kernel. */
                 r = sd_device_get_sysattr_value(dev, "speed", &s);
@@ -519,11 +521,11 @@ static int get_usb_revision(sd_device *dev) {
 
                 return 1;
 
-        case USB_HUB_PR_HS_SINGLE_TT: /* Hi-speed hub with single TT */
-        case USB_HUB_PR_HS_MULTI_TT: /* Hi-speed hub with multiple TT */
+        case 1: /* Hi-speed hub with single TT */
+        case 2: /* Hi-speed hub with multiple TT */
                 return 2;
 
-        case USB_HUB_PR_SS: /* Super speed hub */
+        case 3: /* Super speed hub */
                 return 3;
 
         default:
diff --git a/src/udev/v4l_id/v4l_id.c b/src/udev/v4l_id/v4l_id.c
index 30527e9..7643f8e 100644
--- a/src/udev/v4l_id/v4l_id.c
+++ b/src/udev/v4l_id/v4l_id.c
@@ -85,8 +85,8 @@ static int run(int argc, char *argv[]) {
                 printf("ID_V4L_PRODUCT=%s\n", v2cap.card);
                 printf("ID_V4L_CAPABILITIES=:");
 
-                if (v2cap.capabilities & V4L2_CAP_DEVICE_CAPS)
-                        capabilities = v2cap.device_caps;
+                if (v2cap.capabilities & 0x80000000)
+                        capabilities = v2cap.reserved[0];
                 else
                         capabilities = v2cap.capabilities;
 
diff --git a/test/units/testsuite-13.nspawn.sh b/test/units/testsuite-13.nspawn.sh
index 9bcdec9..5350d91 100755
--- a/test/units/testsuite-13.nspawn.sh
+++ b/test/units/testsuite-13.nspawn.sh
@@ -359,7 +359,7 @@ Environment=FOO=bar
 Environment=BAZ="hello world"
 User=root
 WorkingDirectory=/tmp
-Capability=CAP_BLOCK_SUSPEND CAP_BPF CAP_CHOWN
+Capability=36 CAP_BPF CAP_CHOWN
 DropCapability=CAP_AUDIT_CONTROL CAP_AUDIT_WRITE
 AmbientCapability=CAP_BPF CAP_CHOWN
 NoNewPrivileges=no
diff --git a/test/units/testsuite-65.sh b/test/units/testsuite-65.sh
index 7183a4e..bfa7dee 100755
--- a/test/units/testsuite-65.sh
+++ b/test/units/testsuite-65.sh
@@ -516,7 +516,7 @@ cat <<EOF >/tmp/testfile.json
     "weight": 50,
     "range": 1
     },
-"CapabilityBoundingSet_CAP_BLOCK_SUSPEND":
+"CapabilityBoundingSet_36":
     {"description_good": "Service cannot establish wake locks",
     "description_bad": "Service may establish wake locks",
     "weight": 25,
