+ From 9651cead2f1bb34b9b72f9c2c5dc81baea2b082e Mon Sep 17 00:00:00 2001

+ From: Michael Vogt <mvogt@redhat.com>

+ Date: Tue, 1 Oct 2024 17:14:53 +0200

+ Subject: [PATCH] linux-user: add openat2 support in linux-user

+ 

+ This commit adds support for the `openat2()` syscall in the

+ `linux-user` userspace emulator.

+ 

+ It is implemented by extracting a new helper `maybe_do_fake_open()`

+ out of the exiting `do_guest_openat()` and share that with the

+ new `do_guest_openat2()`. Unfortunately we cannot just make

+ do_guest_openat2() a superset of do_guest_openat() because the

+ openat2() syscall is stricter with the argument checking and

+ will return an error for invalid flags or mode combinations (which

+ open()/openat() will ignore).

+ 

+ The implementation is similar to SYSCALL_DEFINE(openat2), i.e.

+ a new `copy_struct_from_user()` is used that works the same

+ as the kernels version to support backwards-compatibility

+ for struct syscall argument.

+ 

+ Instead of including openat2.h we create a copy of `open_how`

+ as `open_how_ver0` to ensure that if the structure grows we

+ can log a LOG_UNIMP warning.

+ 

+ Note that in this commit using openat2() for a "faked" file in

+ /proc will honor the "resolve" flags for

+ RESOLVE_NO_{MAGIC,SYM}LINKS for path based access to /proc/self/exe

+ (which is the only magic link we support for faked files).

+ Note it will not catch special access via e.g. dirfd. This is not

+ great but it seems similar to the exiting behavior when openat()

+ is called with a dirfd to "/proc". Here too the fake file lookup

+ may not catch the special file because no dirfd is used to

+ determine if the path is in /proc.

+ 

+ Signed-off-by: Michael Vogt <mvogt@redhat.com>

+ Buglink: https://github.com/osbuild/bootc-image-builder/issues/619

+ Reviewed-by: Laurent Vivier <laurent@vivier.eu>

+ Message-ID: <1c2c8c9db3731ed4c6fd9b10c63637c3e4caf8f5.1727795334.git.mvogt@redhat.com>

+ Signed-off-by: Richard Henderson <richard.henderson@linaro.org>

+ ---

+  linux-user/syscall.c      | 105 +++++++++++++++++++++++++++++++++++++-

+  linux-user/syscall_defs.h |  13 +++++

+  2 files changed, 116 insertions(+), 2 deletions(-)

+ 

+ diff --git a/linux-user/syscall.c b/linux-user/syscall.c

+ index a666986189..2febc3bc3f 100644

+ --- a/linux-user/syscall.c

+ +++ b/linux-user/syscall.c

+ @@ -602,6 +602,34 @@ static int check_zeroed_user(abi_long addr, size_t ksize, size_t usize)

+      return 1;

+  }

+  

+ +/*

+ + * Copies a target struct to a host struct, in a way that guarantees

+ + * backwards-compatibility for struct syscall arguments.

+ + *

+ + * Similar to kernels uaccess.h:copy_struct_from_user()

+ + */

+ +static int

+ +copy_struct_from_user(void *dst, size_t ksize, abi_ptr src, size_t usize)

+ +{

+ +    size_t size = MIN(ksize, usize);

+ +    size_t rest = MAX(ksize, usize) - size;

+ +

+ +    /* Deal with trailing bytes. */

+ +    if (usize < ksize) {

+ +        memset(dst + size, 0, rest);

+ +    } else if (usize > ksize) {

+ +        int ret = check_zeroed_user(src, ksize, usize);

+ +        if (ret <= 0) {

+ +            return ret ?: -TARGET_E2BIG;

+ +        }

+ +    }

+ +    /* Copy the interoperable parts of the struct. */

+ +    if (copy_from_user(dst, src, size)) {

+ +        return -TARGET_EFAULT;

+ +    }

+ +    return 0;

+ +}

+ +

+  #define safe_syscall0(type, name) \

+  static type safe_##name(void) \

+  { \

+ @@ -653,6 +681,15 @@ safe_syscall3(ssize_t, read, int, fd, void *, buff, size_t, count)

+  safe_syscall3(ssize_t, write, int, fd, const void *, buff, size_t, count)

+  safe_syscall4(int, openat, int, dirfd, const char *, pathname, \

+                int, flags, mode_t, mode)

+ +

+ +struct open_how_ver0 {

+ +    __u64 flags;

+ +    __u64 mode;

+ +    __u64 resolve;

+ +};

+ +safe_syscall4(int, openat2, int, dirfd, const char *, pathname, \

+ +              const struct open_how_ver0 *, how, size_t, size)

+ +

+  #if defined(TARGET_NR_wait4) || defined(TARGET_NR_waitpid)

+  safe_syscall4(pid_t, wait4, pid_t, pid, int *, status, int, options, \

+                struct rusage *, rusage)

+ @@ -8332,8 +8369,9 @@ static int open_net_route(CPUArchState *cpu_env, int fd)

+  }

+  #endif

+  

+ -int do_guest_openat(CPUArchState *cpu_env, int dirfd, const char *fname,

+ -                    int flags, mode_t mode, bool safe)

+ +static int maybe_do_fake_open(CPUArchState *cpu_env, int dirfd,

+ +                              const char *fname, int flags, mode_t mode,

+ +                              int openat2_resolve, bool safe)

+  {

+      g_autofree char *proc_name = NULL;

+      const char *pathname;

+ @@ -8370,6 +8408,12 @@ int do_guest_openat(CPUArchState *cpu_env, int dirfd, const char *fname,

+      }

+  

+      if (is_proc_myself(pathname, "exe")) {

+ +        /* Honor openat2 resolve flags */

+ +        if ((openat2_resolve & RESOLVE_NO_MAGICLINKS) ||

+ +            (openat2_resolve & RESOLVE_NO_SYMLINKS)) {

+ +            errno = ELOOP;

+ +            return -1;

+ +        }

+          if (safe) {

+              return safe_openat(dirfd, exec_path, flags, mode);

+          } else {

+ @@ -8416,6 +8460,17 @@ int do_guest_openat(CPUArchState *cpu_env, int dirfd, const char *fname,

+          return fd;

+      }

+  

+ +    return -2;

+ +}

+ +

+ +int do_guest_openat(CPUArchState *cpu_env, int dirfd, const char *pathname,

+ +                    int flags, mode_t mode, bool safe)

+ +{

+ +    int fd = maybe_do_fake_open(cpu_env, dirfd, pathname, flags, mode, 0, safe);

+ +    if (fd > -2) {

+ +        return fd;

+ +    }

+ +

+      if (safe) {

+          return safe_openat(dirfd, path(pathname), flags, mode);

+      } else {

+ @@ -8423,6 +8478,49 @@ int do_guest_openat(CPUArchState *cpu_env, int dirfd, const char *fname,

+      }

+  }

+  

+ +

+ +static int do_openat2(CPUArchState *cpu_env, abi_long dirfd,

+ +                      abi_ptr guest_pathname, abi_ptr guest_open_how,

+ +                      abi_ulong guest_size)

+ +{

+ +    struct open_how_ver0 how = {0};

+ +    char *pathname;

+ +    int ret;

+ +

+ +    if (guest_size < sizeof(struct target_open_how_ver0)) {

+ +        return -TARGET_EINVAL;

+ +    }

+ +    ret = copy_struct_from_user(&how, sizeof(how), guest_open_how, guest_size);

+ +    if (ret) {

+ +        if (ret == -TARGET_E2BIG) {

+ +            qemu_log_mask(LOG_UNIMP,

+ +                          "Unimplemented openat2 open_how size: "

+ +                          TARGET_ABI_FMT_lu "\n", guest_size);

+ +        }

+ +        return ret;

+ +    }

+ +    pathname = lock_user_string(guest_pathname);

+ +    if (!pathname) {

+ +        return -TARGET_EFAULT;

+ +    }

+ +

+ +    how.flags = target_to_host_bitmask(tswap64(how.flags), fcntl_flags_tbl);

+ +    how.mode = tswap64(how.mode);

+ +    how.resolve = tswap64(how.resolve);

+ +    int fd = maybe_do_fake_open(cpu_env, dirfd, pathname, how.flags, how.mode,

+ +                                how.resolve, true);

+ +    if (fd > -2) {

+ +        ret = get_errno(fd);

+ +    } else {

+ +        ret = get_errno(safe_openat2(dirfd, pathname, &how,

+ +                                     sizeof(struct open_how_ver0)));

+ +    }

+ +

+ +    fd_trans_unregister(ret);

+ +    unlock_user(pathname, guest_pathname, 0);

+ +    return ret;

+ +}

+ +

+  ssize_t do_guest_readlink(const char *pathname, char *buf, size_t bufsiz)

+  {

+      ssize_t ret;

+ @@ -9195,6 +9293,9 @@ static abi_long do_syscall1(CPUArchState *cpu_env, int num, abi_long arg1,

+          fd_trans_unregister(ret);

+          unlock_user(p, arg2, 0);

+          return ret;

+ +    case TARGET_NR_openat2:

+ +        ret = do_openat2(cpu_env, arg1, arg2, arg3, arg4);

+ +        return ret;

+  #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)

+      case TARGET_NR_name_to_handle_at:

+          ret = do_name_to_handle_at(arg1, arg2, arg3, arg4, arg5);

+ diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h

+ index e08d088740..de5091c977 100644

+ --- a/linux-user/syscall_defs.h

+ +++ b/linux-user/syscall_defs.h

+ @@ -2748,4 +2748,17 @@ struct target_sched_param {

+      abi_int sched_priority;

+  };

+  

+ +/* from kernel's include/uapi/linux/openat2.h */

+ +struct target_open_how_ver0 {

+ +    abi_ullong flags;

+ +    abi_ullong mode;

+ +    abi_ullong resolve;

+ +};

+ +#ifndef RESOLVE_NO_MAGICLINKS

+ +#define RESOLVE_NO_MAGICLINKS   0x02

+ +#endif

+ +#ifndef RESOLVE_NO_SYMLINKS

+ +#define RESOLVE_NO_SYMLINKS     0x04

+ +#endif

+ +

+  #endif

+ -- 

+ 2.47.0

+ 

+ From b5aa46fc7bb03877bbea711903e19ad4e27e8259 Mon Sep 17 00:00:00 2001

+ From: Michael Vogt <michael.vogt@gmail.com>

+ Date: Wed, 23 Oct 2024 09:50:56 +0200

+ Subject: [PATCH] linux-user: guard openat2 with `#if

+  defined(TARGET_NR_openat2)`

+ 

+ This commit adds a bunch of `#ifdef` around the openat2 support.

+ We need this to build the `cris-linux-user` target which is still

+ present in this version but got dropped from upstream in commit

+ 44e4075bf4 but is still present in v9.1.0.

+ 

+ This patch can be dropped once cris is also removed from the

+ package.

+ ---

+  linux-user/syscall.c | 9 ++++++++-

+  1 file changed, 8 insertions(+), 1 deletion(-)

+ 

+ diff --git a/linux-user/syscall.c b/linux-user/syscall.c

+ index 85d61db546..22e5ad3c5f 100644

+ --- a/linux-user/syscall.c

+ +++ b/linux-user/syscall.c

+ @@ -608,6 +608,7 @@ static int check_zeroed_user(abi_long addr, size_t ksize, size_t usize)

+   *

+   * Similar to kernels uaccess.h:copy_struct_from_user()

+   */

+ +#if defined(TARGET_NR_openat2)

+  static int

+  copy_struct_from_user(void *dst, size_t ksize, abi_ptr src, size_t usize)

+  {

+ @@ -629,6 +630,7 @@ copy_struct_from_user(void *dst, size_t ksize, abi_ptr src, size_t usize)

+      }

+      return 0;

+  }

+ +#endif

+  

+  #define safe_syscall0(type, name) \

+  static type safe_##name(void) \

+ @@ -682,6 +684,7 @@ safe_syscall3(ssize_t, write, int, fd, const void *, buff, size_t, count)

+  safe_syscall4(int, openat, int, dirfd, const char *, pathname, \

+                int, flags, mode_t, mode)

+  

+ +#if defined(TARGET_NR_openat2)

+  struct open_how_ver0 {

+      __u64 flags;

+      __u64 mode;

+ @@ -689,6 +692,7 @@ struct open_how_ver0 {

+  };

+  safe_syscall4(int, openat2, int, dirfd, const char *, pathname, \

+                const struct open_how_ver0 *, how, size_t, size)

+ +#endif

+  

+  #if defined(TARGET_NR_wait4) || defined(TARGET_NR_waitpid)

+  safe_syscall4(pid_t, wait4, pid_t, pid, int *, status, int, options, \

+ @@ -8480,7 +8484,7 @@ int do_guest_openat(CPUArchState *cpu_env, int dirfd, const char *pathname,

+      }

+  }

+  

+ -

+ +#if defined(TARGET_NR_openat2)

+  static int do_openat2(CPUArchState *cpu_env, abi_long dirfd,

+                        abi_ptr guest_pathname, abi_ptr guest_open_how,

+                        abi_ulong guest_size)

+ @@ -8522,6 +8526,7 @@ static int do_openat2(CPUArchState *cpu_env, abi_long dirfd,

+      unlock_user(pathname, guest_pathname, 0);

+      return ret;

+  }

+ +#endif

+  

+  ssize_t do_guest_readlink(const char *pathname, char *buf, size_t bufsiz)

+  {

+ @@ -9295,9 +9300,11 @@ static abi_long do_syscall1(CPUArchState *cpu_env, int num, abi_long arg1,

+          fd_trans_unregister(ret);

+          unlock_user(p, arg2, 0);

+          return ret;

+ +#if defined(TARGET_NR_openat2)

+      case TARGET_NR_openat2:

+          ret = do_openat2(cpu_env, arg1, arg2, arg3, arg4);

+          return ret;

+ +#endif

+  #if defined(TARGET_NR_name_to_handle_at) && defined(CONFIG_OPEN_BY_HANDLE)

+      case TARGET_NR_name_to_handle_at:

+          ret = do_name_to_handle_at(arg1, arg2, arg3, arg4, arg5);

+ -- 

+ 2.47.0

+ 

+ From: Roberto Campesato <render@metalabs.org>

+ diff --git a/crypto/tlscredsx509.c b/crypto/tlscredsx509.c

+ --- a/crypto/tlscredsx509.c

+ +++ b/crypto/tlscredsx509.c

+ @@ -502,14 +502,6 @@ qcrypto_tls_creds_x509_sanity_check(QCryptoTLSCredsX509 *creds,

+          goto cleanup;

+      }

+ 

+ -    for (i = 0; i < ncacerts; i++) {

+ -        if (qcrypto_tls_creds_check_cert(creds,

+ -                                         cacerts[i], cacertFile,

+ -                                         isServer, true, errp) < 0) {

+ -            goto cleanup;

+ -        }

+ -    }

+ -

+      if (cert && ncacerts &&

+          qcrypto_tls_creds_check_cert_pair(cert, certFile, cacerts,

+                                            ncacerts, cacertFile,

+ diff --git a/tests/unit/test-crypto-tlscredsx509.c b/tests/unit/test-crypto-tlscredsx509.c

+ --- a/tests/unit/test-crypto-tlscredsx509.c

+ +++ b/tests/unit/test-crypto-tlscredsx509.c

+ @@ -285,7 +285,7 @@ int main(int argc, char **argv)

+      TLS_TEST_REG(badca1, true, cacert4req.filename, servercert4req.filename,

+                   true);

+      TLS_TEST_REG(badca2, true,

+ -                 cacert5req.filename, servercert5req.filename, true);

+ +                 cacert5req.filename, servercert5req.filename, false);

+      TLS_TEST_REG(badca3, true,

+                   cacert6req.filename, servercert6req.filename, true);

+ 

+ From: Roberto Campesato <render@metalabs.org>

+ diff --git a/linux-user/main.c b/linux-user/main.c

+ index 0cdaf30d34..553faf1309 100644

+ --- a/linux-user/main.c

+ +++ b/linux-user/main.c

+ @@ -357,6 +357,10 @@ static void handle_arg_uname(const char *arg)

+ 

+  static void handle_arg_cpu(const char *arg)

+  {

+ +    if (cpu_model != NULL) {

+ +        free(cpu_model);

+ +        cpu_model = NULL;

+ +    }

+      cpu_model = strdup(arg);

+      if (cpu_model == NULL || is_help_option(cpu_model)) {

+          list_cpus();

+ @@ -717,7 +721,16 @@ int main(int argc, char **argv, char **envp)

+          }

+      }

+ 

+ +    /* This is a pretty disgusting hack, in place to get a default

+ +       CPU that has x86_64-v2 support, required for emulating a

+ +       CPU that CentOS 9 is happy to run on (via binfmt_misc).  */

+ +#if defined(TARGET_X86_64) && !defined(__x86_64__)

+ +    cpu_model = strdup("Nehalem-v1");

+ +#elif defined(TARGET_AARCH64) && !defined(__aarch64__)

+ +    cpu_model = strdup("cortex-a72");

+ +#else

+      cpu_model = NULL;

+ +#endif

+ 

+      qemu_add_opts(&qemu_trace_opts);

+      qemu_plugin_add_opts();

+ From: Roberto Campesato <render@metalabs.org>

+ diff --git a/linux-user/ioctls.h b/linux-user/ioctls.h

+ --- a/linux-user/ioctls.h

+ +++ b/linux-user/ioctls.h

+ @@ -154,6 +154,10 @@

+       IOCTL(BTRFS_IOC_SNAP_CREATE, IOC_W,

+             MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_vol_args)))

+  #endif

+ +#ifdef BTRFS_IOC_SNAP_CREATE_V2

+ +     IOCTL(BTRFS_IOC_SNAP_CREATE_V2, IOC_W,

+ +           MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_vol_args_v2)))

+ +#endif

+  #ifdef BTRFS_IOC_SCAN_DEV

+       IOCTL(BTRFS_IOC_SCAN_DEV, IOC_W,

+             MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_vol_args)))

+ @@ -170,14 +174,26 @@

+       IOCTL(BTRFS_IOC_RM_DEV, IOC_W,

+             MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_vol_args)))

+  #endif

+ +#ifdef BTRFS_IOC_RM_DEV_V2

+ +     IOCTL(BTRFS_IOC_RM_DEV_V2, IOC_W,

+ +           MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_vol_args_v2)))

+ +#endif

+  #ifdef BTRFS_IOC_SUBVOL_CREATE

+       IOCTL(BTRFS_IOC_SUBVOL_CREATE, IOC_W,

+             MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_vol_args)))

+  #endif

+ +#ifdef BTRFS_IOC_SUBVOL_CREATE_V2

+ +     IOCTL(BTRFS_IOC_SUBVOL_CREATE_V2, IOC_W,

+ +           MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_vol_args_v2)))

+ +#endif

+  #ifdef BTRFS_IOC_SNAP_DESTROY

+       IOCTL(BTRFS_IOC_SNAP_DESTROY, IOC_W,

+             MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_vol_args)))

+  #endif

+ +#ifdef BTRFS_IOC_SNAP_DESTROY_V2

+ +     IOCTL(BTRFS_IOC_SNAP_DESTROY_V2, IOC_W,

+ +           MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_vol_args_v2)))

+ +#endif

+  #ifdef BTRFS_IOC_INO_LOOKUP

+       IOCTL(BTRFS_IOC_INO_LOOKUP, IOC_RW,

+             MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_ino_lookup_args)))

+ @@ -273,6 +289,10 @@

+       IOCTL(BTRFS_IOC_INO_LOOKUP_USER, IOC_RW,

+             MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_ino_lookup_user_args)))

+  #endif

+ +#ifdef BTRFS_IOC_TREE_SEARCH

+ +     IOCTL(BTRFS_IOC_TREE_SEARCH, IOC_RW,

+ +           MK_PTR(MK_STRUCT(STRUCT_btrfs_ioctl_search_args)))

+ +#endif

+ 

+  #ifdef CONFIG_USBFS

+    /* USB ioctls */

+ diff --git a/linux-user/syscall_defs.h b/linux-user/syscall_defs.h

+ --- a/linux-user/syscall_defs.h

+ +++ b/linux-user/syscall_defs.h

+ @@ -966,9 +966,12 @@

+  #define TARGET_BTRFS_IOC_RM_DEV                 TARGET_IOWU(BTRFS_IOCTL_MAGIC, 11)

+  #define TARGET_BTRFS_IOC_SUBVOL_CREATE          TARGET_IOWU(BTRFS_IOCTL_MAGIC, 14)

+  #define TARGET_BTRFS_IOC_SNAP_DESTROY           TARGET_IOWU(BTRFS_IOCTL_MAGIC, 15)

+ +#define TARGET_BTRFS_IOC_TREE_SEARCH            TARGET_IOWRU(BTRFS_IOCTL_MAGIC, 17)

+  #define TARGET_BTRFS_IOC_INO_LOOKUP             TARGET_IOWRU(BTRFS_IOCTL_MAGIC, 18)

+  #define TARGET_BTRFS_IOC_DEFAULT_SUBVOL         TARGET_IOW(BTRFS_IOCTL_MAGIC, 19, \

+                                                             abi_ullong)

+ +#define TARGET_BTRFS_IOC_SNAP_CREATE_V2         TARGET_IOWU(BTRFS_IOCTL_MAGIC, 23)

+ +#define TARGET_BTRFS_IOC_SUBVOL_CREATE_V2       TARGET_IOWU(BTRFS_IOCTL_MAGIC, 24)

+  #define TARGET_BTRFS_IOC_SUBVOL_GETFLAGS        TARGET_IOR(BTRFS_IOCTL_MAGIC, 25, \

+                                                             abi_ullong)

+  #define TARGET_BTRFS_IOC_SUBVOL_SETFLAGS        TARGET_IOW(BTRFS_IOCTL_MAGIC, 26, \

+ @@ -990,10 +993,12 @@

+  #define TARGET_BTRFS_IOC_GET_FEATURES           TARGET_IORU(BTRFS_IOCTL_MAGIC, 57)

+  #define TARGET_BTRFS_IOC_SET_FEATURES           TARGET_IOWU(BTRFS_IOCTL_MAGIC, 57)

+  #define TARGET_BTRFS_IOC_GET_SUPPORTED_FEATURES TARGET_IORU(BTRFS_IOCTL_MAGIC, 57)

+ +#define TARGET_BTRFS_IOC_RM_DEV_V2              TARGET_IOWU(BTRFS_IOCTL_MAGIC, 58)

+  #define TARGET_BTRFS_IOC_LOGICAL_INO_V2         TARGET_IOWRU(BTRFS_IOCTL_MAGIC, 59)

+  #define TARGET_BTRFS_IOC_GET_SUBVOL_INFO        TARGET_IORU(BTRFS_IOCTL_MAGIC, 60)

+  #define TARGET_BTRFS_IOC_GET_SUBVOL_ROOTREF     TARGET_IOWRU(BTRFS_IOCTL_MAGIC, 61)

+  #define TARGET_BTRFS_IOC_INO_LOOKUP_USER        TARGET_IOWRU(BTRFS_IOCTL_MAGIC, 62)

+ +#define TARGET_BTRFS_IOC_SNAP_DESTROY_V2        TARGET_IOWU(BTRFS_IOCTL_MAGIC, 63)

+  #endif

+ 

+  /* usb ioctls */

+ diff --git a/linux-user/syscall_types.h b/linux-user/syscall_types.h

+ --- a/linux-user/syscall_types.h

+ +++ b/linux-user/syscall_types.h

+ @@ -373,6 +373,37 @@

+         MK_ARRAY(TYPE_CHAR, BTRFS_PATH_NAME_MAX + 1)) /* name */

+  #endif

+ 

+ +#if defined(BTRFS_IOC_SNAP_CREATE_V2) || \

+ +    defined(BTRFS_IOC_SUBVOL_CREATE_V2) || \

+ +    defined(BTRFS_IOC_RM_DEV_V2) || defined(BTRFS_IOC_SNAP_DESTROY_V2)

+ +STRUCT(btrfs_ioctl_vol_args_v2,

+ +       TYPE_LONGLONG, /* fd */

+ +       TYPE_ULONGLONG, /* transid */

+ +       TYPE_ULONGLONG, /* flags */

+ +       MK_ARRAY(TYPE_ULONGLONG, 4), /* unused */

+ +       MK_ARRAY(TYPE_CHAR, BTRFS_SUBVOL_NAME_MAX + 1)) /* name */

+ +#endif

+ +

+ +#ifdef BTRFS_IOC_TREE_SEARCH

+ +STRUCT(btrfs_ioctl_search_args,

+ +       TYPE_ULONGLONG, /* tree_id */

+ +       TYPE_ULONGLONG, /* min_objectid */

+ +       TYPE_ULONGLONG, /* max_objectid */

+ +       TYPE_ULONGLONG, /* min_offset */

+ +       TYPE_ULONGLONG, /* max_offset */

+ +       TYPE_ULONGLONG, /* min_transid */

+ +       TYPE_ULONGLONG, /* max_transid */

+ +       TYPE_INT,       /* min_type */

+ +       TYPE_INT,       /* max_type */

+ +       TYPE_INT,       /* nr_items */

+ +       TYPE_INT,       /* unused */

+ +       TYPE_ULONGLONG, /* unused1 */

+ +       TYPE_ULONGLONG, /* unused2 */

+ +       TYPE_ULONGLONG, /* unused3 */

+ +       TYPE_ULONGLONG, /* unused4 */

+ +       MK_ARRAY(TYPE_CHAR, BTRFS_SEARCH_ARGS_BUFSIZE)) /* buf */

+ +#endif

+ +

+  #ifdef BTRFS_IOC_GET_SUBVOL_INFO

+  STRUCT(btrfs_ioctl_timespec,

+         TYPE_ULONGLONG, /* sec */

+ From: Roberto Campesato <render@metalabs.org>

+ diff --git a/accel/kvm/kvm-all.c b/accel/kvm/kvm-all.c

+ index 75d11a07b2..4da3b75af9 100644

+ --- a/accel/kvm/kvm-all.c

+ +++ b/accel/kvm/kvm-all.c

+ @@ -2966,9 +2966,13 @@ int kvm_convert_memory(hwaddr start, hwaddr size, bool to_private)

+               */

+              goto out_unref;

+          }

+ -        ret = ram_block_discard_range(rb, offset, size);

+ +        ret = ram_block_discard_is_disabled()

+ +              ? ram_block_discard_range(rb, offset, size)

+ +              : 0;

+      } else {

+ -        ret = ram_block_discard_guest_memfd_range(rb, offset, size);

+ +        ret = ram_block_discard_is_disabled()

+ +              ? ram_block_discard_guest_memfd_range(rb, offset, size)

+ +              : 0;

+      }

+ 

+  out_unref:

+ diff --git a/system/physmem.c b/system/physmem.c

+ index 94600a33ec..16e1dd4f22 100644

+ --- a/system/physmem.c

+ +++ b/system/physmem.c

+ @@ -1880,19 +1880,10 @@ static void ram_block_add(RAMBlock *new_block, Error **errp)

+      }

+ 

+      if (new_block->flags & RAM_GUEST_MEMFD) {

+ -        int ret;

+ 

+          assert(kvm_enabled());

+          assert(new_block->guest_memfd < 0);

+ 

+ -        ret = ram_block_discard_require(true);

+ -        if (ret < 0) {

+ -            error_setg_errno(errp, -ret,

+ -                             "cannot set up private guest memory: discard currently blocked");

+ -            error_append_hint(errp, "Are you using assigned devices?\n");

+ -            goto out_free;

+ -        }

+ -

+          new_block->guest_memfd = kvm_create_guest_memfd(new_block->max_length,

+                                                          0, errp);

+          if (new_block->guest_memfd < 0) {

+ @@ -2156,7 +2147,6 @@ static void reclaim_ramblock(RAMBlock *block)

+ 

+      if (block->guest_memfd >= 0) {

+          close(block->guest_memfd);

+ -        ram_block_discard_require(false);

+      }

+ 

+      g_free(block);

+ From: Roberto Campesato <render@metalabs.org>

+ diff --git a/accel/kvm/kvm-all.c b/accel/kvm/kvm-all.c

+ index bcd2094944..8f6318aa3d 100644

+ --- a/accel/kvm/kvm-all.c

+ +++ b/accel/kvm/kvm-all.c

+ @@ -2461,12 +2461,6 @@ static int kvm_init(MachineState *ms)

+          s->nr_slots = 32;

+      }

+ 

+ -    s->nr_as = kvm_check_extension(s, KVM_CAP_MULTI_ADDRESS_SPACE);

+ -    if (s->nr_as <= 1) {

+ -        s->nr_as = 1;

+ -    }

+ -    s->as = g_new0(struct KVMAs, s->nr_as);

+ -

+      if (object_property_find(OBJECT(current_machine), "kvm-type")) {

+          g_autofree char *kvm_type = object_property_get_str(OBJECT(current_machine),

+                                                              "kvm-type",

+ @@ -2515,6 +2509,12 @@ static int kvm_init(MachineState *ms)

+ 

+      s->vmfd = ret;

+ 

+ +    s->nr_as = kvm_vm_check_extension(s, KVM_CAP_MULTI_ADDRESS_SPACE);

+ +    if (s->nr_as <= 1) {

+ +        s->nr_as = 1;

+ +    }

+ +    s->as = g_new0(struct KVMAs, s->nr_as);

+ +

+      /* check the vcpu limits */

+      soft_vcpus_limit = kvm_recommended_vcpus(s);

+      hard_vcpus_limit = kvm_max_vcpus(s);

+ @@ -2603,7 +2603,7 @@ static int kvm_init(MachineState *ms)

+      }

+ 

+      kvm_readonly_mem_allowed =

+ -        (kvm_check_extension(s, KVM_CAP_READONLY_MEM) > 0);

+ +        (kvm_vm_check_extension(s, KVM_CAP_READONLY_MEM) > 0);

+ 

+      kvm_resamplefds_allowed =

+          (kvm_check_extension(s, KVM_CAP_IRQFD_RESAMPLE) > 0);

+ # TODO(Hyperscale): enable when RHBZ#2233161 is resolved

+ %if 0%{?fedora} || 0%{?centos_hs}

+ %global have_jack %{defined centos_hs}

+ %if 0%{?fedora} || 0%{?centos_hs}

+ %if 0%{?rhel} >= 9 && ! 0%{?centos_hs}

+ %global baserelease 1

+ 

+ # Hyperscale release

+ %global hsrel .1

+ Version: 9.1.1

+ Release: %{baserelease}%{?rcrel}%{?hsrel}%{?dist}

+ License: %{shrink:

+     Apache-2.0 AND

+     BSD-2-Clause AND

+     BSD-3-Clause AND

+     FSFAP AND

+     GPL-1.0-or-later AND

+     GPL-2.0-only AND

+     GPL-2.0-or-later AND

+     GPL-2.0-or-later WITH GCC-exception-2.0 AND

+     LGPL-2.0-only AND

+     LGPL-2.0-or-later AND

+     LGPL-2.1-only AND

+     LGPL-2.1-or-later AND

+     MIT AND

+     LicenseRef-Fedora-Public-Domain AND

+     CC-BY-3.0

+ }

+ # fb-only patches.

+ %if 0%{?facebook}

+ # internal hack #1: skip validation of all CA certs in the provided bundle including

+ # those not in the chain of trust. evaluating rework for potential upstreaming.

+ Patch: 0001-relax-CA-certs-checks.patch

+ 

+ # internal hack #2: when using qemu-user from binfmt_misc we cannot pass parameters to select

+ # which cpu to use. changing the default to use the oldest cpu supported by CentOS 9.

+ # evaluating if an environment variable could be used for this

+ Patch: 0003-linux-user-default-cpu-model.patch

+ 

+ # Add new btrfs *_v2 ioctls for user-level emulation.

+ # will be reworked for potential upstreaming.

+ Patch: 0004-BTRFS_V2_IOCTLS.patch

+ 

+ # Include experimental changes based AMD patches for SEV/SNP to make PCI passthrough

+ # work with SNP

+ Patch: 0005-disable_ram_block_discard_for_pci_passthrough_on_AMD_SEV_SNP.patch

+ Patch: 0006-change_kvm_readonly_mem_allowed_check_for_AMD_SEV_SNP.patch

+ 

+ %endif

+ 

+ # Fix compat with new glibc (not upstream yet)

+ Patch: schedattr.patch

+ 

+ # Openat2 support (upstream commit 9651cea)

+ Patch: 0001-linux-user-add-openat2-support-in-linux-user.patch

+ # linux-user-cris support for openat2, can be removed once "cris" is

+ # removed (after v9.1.0)

+ Patch: 0001-linux-user-guard-openat2-with-if-defined-TARGET_NR_o.patch

+ * Fri Oct 25 2024 Roberto Campesato <render@metalabs.org> - 9.1.1-1.1

+ - Merge latest changes from Fedora

+ - Added fb-only patch based on experimental AMD changes for SEV/SNP

+   to make PCI passthrough work with SNP

+ 

+ * Thu Oct 24 2024 Cole Robinson <crobinso@redhat.com> - 9.1.1-1

+ - Rebase to qemu 9.1.1 stable

+ 

+ * Thu Oct 24 2024 Daniel P. Berrangé <berrange@redhat.com> - 9.1.0-4

+ - Add openat2 support to linux-user

+ - Fix compat with new glibc for 'struct sched_attr'

+ 

+ * Wed Oct 16 2024 Daniel P. Berrangé <berrange@redhat.com> - 9.1.0-3

+ * Mon Oct 14 2024 Roberto Campesato <render@metalabs.org> - 2:9.1.0-2.1

+ - Merge latest changes from Fedora

+ 

+ * Wed Sep 11 2024 Roberto Campesato <render@metalabs.org> - 9.1.0-1.1

+ - Merge latest changes from Fedora

+ - Added fb-only patch based on experimental AMD changes for SEV/SNP

+   to make PCI passthrough work with SNP

+ 

+ * Tue Mar 26 2024 Roberto Campesato <render@metalabs.org> - 8.2.2-1.1

+ - include unit test change in patch relaxing CA cert bundle validation

+ 

+ * Tue Mar 19 2024 Roberto Campesato <render@metalabs.org> - 8.2.2-1.1

+ - Merge latest changes from Fedora

+ - Re-enabled libblkio (RHBZ#2232766 closed)

+ - Added fb-only patches

+   . relaxing CA cert bundle validatation

+   . setting default cpu_model for linux-user x86_64 and aarch64

+   . btrfs v2 ioctls

+ 

+ * Tue Sep 19 2023 Davide Cavalca <dcavalca@centosproject.org> - 2:8.1.0-2.1

+ - Merge latest changes from Fedora

+ - Enable libcacard support for Hyperscale builds

+ 

+ * Thu Aug 17 2023 Davide Cavalca <dcavalca@centosproject.org> - 2:8.0.3-1.1

+ - Merge latest changes from Fedora

+ - Temporarily disable virgl for Hyperscale due to missing dependencies

+ - Adjust Requires for virtiofsd for RHEL 9 and earlier

+   Upstream PR: https://src.fedoraproject.org/rpms/qemu/pull-request/47

+ - Enable jack support for Hyperscale builds

+ 

+ * Thu Sep 08 2022 Davide Cavalca <dcavalca@centosproject.org> - 7.1.0-3.1

+ - Enable some additional features for Hyperscale

+ - Number patches for compatibility with el8

+ 

+ From qemu-devel-bounces+berrange=redhat.com@nongnu.org Fri Oct 11 20:32:42 2024

+ Delivered-To: berrange@gapps.redhat.com

+ Received: by 2002:a05:612c:fcb:b0:49e:3967:5c with SMTP id kg11csp620284vqb;

+         Fri, 11 Oct 2024 12:32:43 -0700 (PDT)

+ X-Forwarded-Encrypted: i=2; AJvYcCXPcgyQ0/+OIS7vrT6LX5S6B3Hgz9IoezpGzlHzuQ86lhsSq6u4TrVfGwET6WFesjl4msgGP886/Q==@gapps.redhat.com

+ X-Google-Smtp-Source: AGHT+IGI1MzgaHjMk041SIq3SzZGJRAF05keA8usOtLVfsqz+UnG8gS/7JH2MnqELZrotA/GJ+FI

+ X-Received: by 2002:a05:6870:530c:b0:277:e35a:d2d5 with SMTP id 586e51a60fabf-2886e0d7223mr2593115fac.47.1728675162879;

+         Fri, 11 Oct 2024 12:32:42 -0700 (PDT)

+ ARC-Seal: i=1; a=rsa-sha256; t=1728675162; cv=none;

+         d=google.com; s=arc-20240605;

+         b=alETPlokQysotchMz04b4QkeW4n7IaCvDHuYMZh698k8mF5RJMclj7AfzOWMyGXURw

+          kFfdMDxoHBlzWY9bTAGsH6EBkFDcJ9RyMs2Oy/exl09b3Zbt/LaW/PgqJZWi7DqZe7FD

+          Zo3bqW5OSwWxU/vpy6n8B4EV22uFeRNhdTlzj0nbU4h+YpUcUzXR++ssowqa367TMQ5s

+          THtVdddGT62AlbkeybdC/gTVxTt0RktEBMKTh+MzuZJ1rcgMb+pbG6h/XF5Iub2C+szk

+          EkyaW96aO1YTzalK4HCCL7cuCauVGvVShSjUfPFMqXRxvzVfFqn02zZh6C4AXb/a/gIT

+          YiXA==

+ ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605;

+         h=content-transfer-encoding:sender:errors-to:list-subscribe:list-help

+          :list-post:list-archive:list-unsubscribe:list-id:precedence