Re: [Qemu-devel] [PATCH] Initial support for Ilumos build and Illumos-kvm

[Paolo Bonzini <pbonzini@redhat.com>]

Il 16/03/2012 10:23, Lee Essen ha scritto:
> diff --git a/Makefile.objs b/Makefile.objs
> index 226b01d..c2a440a 100644
> --- a/Makefile.objs
> +++ b/Makefile.objs
> @@ -373,12 +373,12 @@ else
>  trace.h: trace.h-timestamp
>  endif
>  trace.h-timestamp: $(SRC_PATH)/trace-events $(BUILD_DIR)/config-host.mak
> -       $(call quiet-command,sh $(SRC_PATH)/scripts/tracetool
> --$(TRACE_BACKEND) -h < $< > $@,"  GEN   trace.h")
> +       $(call quiet-command,$(SHELL) $(SRC_PATH)/scripts/tracetool
> --$(TRACE_BACKEND) -h < $< > $@,"  GEN   trace.h")
>         @cmp -s $@ trace.h || cp $@ trace.h
>  
>  trace.c: trace.c-timestamp
>  trace.c-timestamp: $(SRC_PATH)/trace-events $(BUILD_DIR)/config-host.mak
> -       $(call quiet-command,sh $(SRC_PATH)/scripts/tracetool
> --$(TRACE_BACKEND) -c < $< > $@,"  GEN   trace.c")
> +       $(call quiet-command,$(SHELL) $(SRC_PATH)/scripts/tracetool
> --$(TRACE_BACKEND) -c < $< > $@,"  GEN   trace.c")
>         @cmp -s $@ trace.c || cp $@ trace.c
>  
>  trace.o: trace.c $(GENERATED_HEADERS)
> @@ -391,7 +391,7 @@ trace-dtrace.h: trace-dtrace.dtrace
>  # rule file. So we use '.dtrace' instead
>  trace-dtrace.dtrace: trace-dtrace.dtrace-timestamp
>  trace-dtrace.dtrace-timestamp: $(SRC_PATH)/trace-events
> $(BUILD_DIR)/config-host.mak
> -       $(call quiet-command,sh $(SRC_PATH)/scripts/tracetool
> --$(TRACE_BACKEND) -d < $< > $@,"  GEN   trace-dtrace.dtrace")
> +       $(call quiet-command,$(SHELL) $(SRC_PATH)/scripts/tracetool
> --$(TRACE_BACKEND) -d < $< > $@,"  GEN   trace-dtrace.dtrace")
>         @cmp -s $@ trace-dtrace.dtrace || cp $@ trace-dtrace.dtrace
>  
>  trace-dtrace.o: trace-dtrace.dtrace $(GENERATED_HEADERS)
> diff --git a/Makefile.target b/Makefile.target
> index eb25941..d32afc9 100644
> --- a/Makefile.target
> +++ b/Makefile.target
> @@ -59,7 +59,7 @@ TARGET_TYPE=system
>  endif
>  
>  $(QEMU_PROG).stp:
> -       $(call quiet-command,sh $(SRC_PATH)/scripts/tracetool \
> +       $(call quiet-command,$(SHELL) $(SRC_PATH)/scripts/tracetool \
>                 --$(TRACE_BACKEND) \
>                 --binary $(bindir)/$(QEMU_PROG) \
>                 --target-arch $(TARGET_ARCH) \
> @@ -443,10 +443,10 @@ gdbstub-xml.c: $(TARGET_XML_FILES)
> $(SRC_PATH)/scripts/feature_to_c.sh
>         $(call quiet-command,rm -f $@ && $(SHELL)
> $(SRC_PATH)/scripts/feature_to_c.sh $@ $(TARGET_XML_FILES),"  GEN  
> $(TARGET_DIR)$@")
>  
>  hmp-commands.h: $(SRC_PATH)/hmp-commands.hx
> -       $(call quiet-command,sh $(SRC_PATH)/scripts/hxtool -h < $< >
> $@,"  GEN   $(TARGET_DIR)$@")
> +       $(call quiet-command,$(SHELL) $(SRC_PATH)/scripts/hxtool -h < $<
>> $@,"  GEN   $(TARGET_DIR)$@")
>  
>  qmp-commands-old.h: $(SRC_PATH)/qmp-commands.hx
> -       $(call quiet-command,sh $(SRC_PATH)/scripts/hxtool -h < $< >
> $@,"  GEN   $(TARGET_DIR)$@")
> +       $(call quiet-command,$(SHELL) $(SRC_PATH)/scripts/hxtool -h < $<
>> $@,"  GEN   $(TARGET_DIR)$@")
>  
>  clean:
>         rm -f *.o *.a *~ $(PROGS) nwfpe/*.o fpu/*.o
> diff --git a/configure b/configure
> index afe7395..601f77a 100755
> --- a/configure
> +++ b/configure
> @@ -101,6 +101,7 @@ audio_win_int=""
>  cc_i386=i386-pc-linux-gnu-gcc
>  libs_qga=""
>  debug_info="yes"
> +shell="sh"
>  
>  target_list=""
>  
> @@ -442,6 +443,7 @@ SunOS)
>    # have to select again, because `uname -m` returns i86pc
>    # even on an x86_64 box.
>    solariscpu=`isainfo -k`
> +  shell="bash"
>    if test "${solariscpu}" = "amd64" ; then
>      cpu="x86_64"
>    fi
> @@ -471,6 +473,7 @@ SunOS)
>    QEMU_CFLAGS="-D__EXTENSIONS__ $QEMU_CFLAGS"
>    QEMU_CFLAGS="-std=gnu99 $QEMU_CFLAGS"
>    LIBS="-lsocket -lnsl -lresolv $LIBS"
> +  libs_qga="-lsocket -lxnet $lib_qga"
>  ;;
>  AIX)
>    aix="yes"
> @@ -1097,7 +1100,7 @@ echo "  --disable-docs           disable
> documentation build"
>  echo "  --disable-vhost-net      disable vhost-net acceleration support"
>  echo "  --enable-vhost-net       enable vhost-net acceleration support"
>  echo "  --enable-trace-backend=B Set trace backend"
> -echo "                           Available backends:"
> $("$source_path"/scripts/tracetool --list-backends)
> +echo "                           Available backends:" $($shell
> "$source_path"/scripts/tracetool --list-backends)
>  echo "  --with-trace-file=NAME   Full PATH,NAME of file to store traces"
>  echo "                           Default:trace-<pid>"
>  echo "  --disable-spice          disable spice"
> @@ -2654,7 +2657,7 @@ fi
>  ##########################################
>  # check if trace backend exists
>  
> -sh "$source_path/scripts/tracetool" "--$trace_backend" --check-backend
>> /dev/null 2> /dev/null
> +$shell "$source_path/scripts/tracetool" "--$trace_backend"
> --check-backend > /dev/null 2> /dev/null
>  if test "$?" -ne 0 ; then
>    echo
>    echo "Error: invalid trace backend"
> @@ -3358,6 +3361,7 @@ echo "LIBS+=$LIBS" >> $config_host_mak
>  echo "LIBS_TOOLS+=$libs_tools" >> $config_host_mak
>  echo "EXESUF=$EXESUF" >> $config_host_mak
>  echo "LIBS_QGA+=$libs_qga" >> $config_host_mak
> +echo "SHELL=$shell" >> $config_host_mak
>  
>  # generate list of library paths for linker script
>  
> diff --git a/cpus.c b/cpus.c

Everything up to here should be a separate patch, but it looks sane.

> index 25ba621..7a32ee6 100644
> --- a/cpus.c
> +++ b/cpus.c
> @@ -455,7 +455,7 @@ static void cpu_signal(int sig)
>      exit_request = 1;
>  }
>  
> -#ifdef CONFIG_LINUX
> +#if defined(CONFIG_LINUX) || defined(CONFIG_SOLARIS)
>  static void sigbus_reraise(void)
>  {
>      sigset_t set;
> @@ -491,7 +491,9 @@ static void qemu_init_sigbus(void)
>      action.sa_sigaction = (void (*)(int, siginfo_t*, void*))sigbus_handler;
>      sigaction(SIGBUS, &action, NULL);
>  
> +#ifndef __sun__
>      prctl(PR_MCE_KILL, PR_MCE_KILL_SET, PR_MCE_KILL_EARLY, 0, 0);
> +#endif
>  }
>  
>  static void qemu_kvm_eat_signals(CPUArchState *env)
> diff --git a/exec.c b/exec.c
> index 8fd50a1..57e2890 100644
> --- a/exec.c
> +++ b/exec.c
> @@ -2853,6 +2853,79 @@ static ram_addr_t last_ram_offset(void)
>      return last;
>  }
>  
> +#ifdef CONFIG_SOLARIS
> +static int
> +qemu_mlock(caddr_t base, ram_addr_t size)
> +{
> +  /* LEE - todo */
> +  qemu_real_host_page_size = getpagesize();
> +
> +  ram_addr_t ps = qemu_real_host_page_size, nbytes, locked = 0;
> +  ram_addr_t remaining = size / ps;
> +  ram_addr_t step = remaining;
> +  timespec_t tv;
> +  hrtime_t waiting = 0, threshold;
> +
> +  tv.tv_sec = 0;
> +  tv.tv_nsec = NANOSEC / MILLISEC;
> +  threshold = 10 * (hrtime_t)NANOSEC;
> +
> +  /*
> +   * We cannot lock memory with a single call to mlock() because it
> +   * won't result in sustained memory pressure:  if there is a
> +   * substantial amount of kernel memory in use electively (e.g., for
> +   * the ARC) a single call to mlock() may fail where sustained memory
> +   * pressure would succeed.  We therefore start by trying to lock the
> +   * entire region, adjusting our size down as we fail with EAGAIN; once
> +   * we successfully lock a portion of the region, we advance to the
> +   * unlocked portion of the region (if any remains) and increase the
> +   * size.  Note that this will continue to hoard memory until it locks
> +   * what it needs -- it won't give up.  To help debug situations in
> +   * which one has mistakenly overprovisioned, we emit a message every
> +   * ten seconds with no forward progress.
> +   */
> +  while (remaining) {
> +    if (step > remaining) {
> +        step = remaining;
> +    }
> +
> +    while (mlock(base, (nbytes = step * ps)) == -1) {
> +        if (errno != EAGAIN) {
> +            return -1;
> +        }
> +
> +        if (waiting == 0) {
> +            waiting = gethrtime();

Please use qemu_get_clock_ns(rt_clock) here.

> +        }
> +
> +        if (step > 1) {
> +            step >>= 1;
> +            continue;
> +        }
> +
> +        (void) nanosleep(&tv, NULL);
> +
> +        if (gethrtime() - waiting > threshold) {
> +            (void) fprintf(stderr, "qemu_mlock: have only "
> +              "locked %ld of %ld bytes; still "
> +              "trying...\n", locked, size);
> +            waiting = 0;
> +        }
> +    }
> +
> +    waiting = 0;
> +    base += nbytes;
> +    locked += nbytes;
> +    remaining -= step;
> +
> +    step <<= 1;
> +  }
> +
> +  return 0;
> +}
> +#endif
> +
> +
>  void qemu_ram_set_idstr(ram_addr_t addr, const char *name, DeviceState
> *dev)
>  {
>      RAMBlock *new_block, *block;
> @@ -2931,6 +3004,21 @@ ram_addr_t qemu_ram_alloc_from_ptr(ram_addr_t
> size, void *host,
>                  new_block->host = qemu_vmalloc(size);
>              }
>  #endif
> +
> +#ifdef CONFIG_SOLARIS
> +            /*
> +              * XXX For right now, we'll lock down the memory.  This needs
> +              * to be revisited if we implement mmu notifiers in the
> kernel.
> +              * Note also that pages are touched in
> kvm_set_user_memory_region.
> +              */
> +            if (qemu_mlock((caddr_t)new_block->host, size) != 0) {
> +                fprintf(stderr, "qemu_ram_alloc: Could not lock %ld
> memory,"
> +                    " errno = %d\n",
> +                    size, errno);
> +                exit(1);
> +            }
> +#endif /*CONFIG_SOLARIS*/
> +
>              qemu_madvise(new_block->host, size, QEMU_MADV_MERGEABLE);
>          }
>      }
> diff --git a/fpu/softfloat-specialize.h b/fpu/softfloat-specialize.h
> index c5e2dab..3889041 100644
> --- a/fpu/softfloat-specialize.h
> +++ b/fpu/softfloat-specialize.h
> @@ -89,8 +89,10 @@ const float64 float64_default_nan =
> const_float64(LIT64( 0xFFF8000000000000 ));
>  #define floatx80_default_nan_low  LIT64( 0xC000000000000000 )
>  #endif
>  
> +#ifndef __sun__
>  const floatx80 floatx80_default_nan =
> make_floatx80(floatx80_default_nan_high,
>                                                    
>  floatx80_default_nan_low);
> +#endif

Why is this needed.

>  
>  /*----------------------------------------------------------------------------
>  | The pattern for a default generated quadruple-precision NaN.  The
> `high' and
> @@ -104,8 +106,10 @@ const floatx80 floatx80_default_nan =
> make_floatx80(floatx80_default_nan_high,
>  #define float128_default_nan_low  LIT64( 0x0000000000000000 )
>  #endif
>  
> +#ifndef __sun__
>  const float128 float128_default_nan =
> make_float128(float128_default_nan_high,
>                                                    
>  float128_default_nan_low);
> +#endif
>  
>  /*----------------------------------------------------------------------------
>  | Raises the exceptions specified by `flags'.  Floating-point traps can be
> diff --git a/hw/kvm/clock.c b/hw/kvm/clock.c
> index 446bd62..3fd5e1e 100644
> --- a/hw/kvm/clock.c
> +++ b/hw/kvm/clock.c
> @@ -19,8 +19,12 @@
>  #include "hw/sysbus.h"
>  #include "hw/kvm/clock.h"
>  
> +#ifdef __sun__
> +#include <sys/kvm.h>
> +#else
>  #include <linux/kvm.h>
>  #include <linux/kvm_para.h>
> +#endif

Perhaps you can put this in kvm.h instead, and just include that file:

#ifdef __sun__
#include <sys/kvm.h>
#else
#include <linux/kvm.h>
#endif
#include <linux/kvm_para.h>

kvm_para.h should be independent of the host OS, hoping there's no
conflict between Solaris and Linux headers.

>  
>  typedef struct KVMClockState {
>      SysBusDevice busdev;
> diff --git a/kvm-all.c b/kvm-all.c
> index 42e5e23..27f3177 100644
> --- a/kvm-all.c
> +++ b/kvm-all.c
> @@ -18,7 +18,11 @@
>  #include <sys/mman.h>
>  #include <stdarg.h>
>  
> +#ifdef __sun__
> +#include <sys/kvm.h>
> +#else
>  #include <linux/kvm.h>
> +#endif
>  
>  #include "qemu-common.h"
>  #include "qemu-barrier.h"
> @@ -176,12 +180,23 @@ int kvm_physical_memory_addr_from_host(KVMState
> *s, void *ram,
>  static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
>  {
>      struct kvm_userspace_memory_region mem;
> +#ifdef CONFIG_SOLARIS
> +    caddr_t p;
> +    char c;
> +#endif
>  
>      mem.slot = slot->slot;
>      mem.guest_phys_addr = slot->start_addr;
>      mem.memory_size = slot->memory_size;
>      mem.userspace_addr = (unsigned long)slot->ram;
>      mem.flags = slot->flags;
> +#ifdef CONFIG_SOLARIS
> +    for (p = (caddr_t)mem.userspace_addr;
> +      p < (caddr_t)mem.userspace_addr + mem.memory_size;
> +      p += PAGE_SIZE)
> +        c = *p;
> +#endif /* CONFIG_SOLARIS */

What is this needed for?

> +
>      if (s->migration_log) {
>          mem.flags |= KVM_MEM_LOG_DIRTY_PAGES;
>      }
> @@ -200,6 +215,31 @@ int kvm_pit_in_kernel(void)
>      return kvm_state->pit_in_kernel;
>  }
>  
> +#ifdef CONFIG_SOLARIS
> +static int kvm_vm_clone(KVMState *s)
> +{
> +    struct stat stat;
> +    int fd;
> +
> +    if (fstat(s->fd, &stat) != 0) {
> +        return -errno;
> +    }
> +
> +    fd = qemu_open("/dev/kvm", O_RDWR);
> +
> +    if (fd == -1) {
> +        return -errno;
> +    }
> +
> +    if (ioctl(fd, KVM_CLONE, stat.st_rdev) == -1) {
> +        close(fd);
> +        return -errno;
> +    }
> +
> +    return fd;
> +}
> +#endif
> +
>  int kvm_init_vcpu(CPUArchState *env)
>  {
>      KVMState *s = kvm_state;
> @@ -208,14 +248,29 @@ int kvm_init_vcpu(CPUArchState *env)
>  
>      DPRINTF("kvm_init_vcpu\n");
>  
> +#ifdef CONFIG_SOLARIS
> +    ret = kvm_vm_clone(kvm_state);
> +
> +    if (ret < 0) {
> +        fprintf(stderr, "kvm_init_vcpu could not clone fd: %m\n");
> +        goto err;
> +    }
> +    env->kvm_fd = ret;
> +    env->kvm_state = kvm_state;
> +
> +    ret = ioctl(env->kvm_fd, KVM_CREATE_VCPU, env->cpu_index);
> +#else
>      ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
> +#endif
>      if (ret < 0) {
>          DPRINTF("kvm_create_vcpu failed\n");
>          goto err;
>      }
>  
> +#ifndef CONFIG_SOLARIS
>      env->kvm_fd = ret;
>      env->kvm_state = s;
> +#endif

env->kvm_state assignment need not be split, right?

>      env->kvm_vcpu_dirty = 1;
>  
>      mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
> @@ -1021,6 +1076,9 @@ int kvm_init(void)
>          ret = s->vmfd;
>          goto err;
>      }
> +#ifdef CONFIG_SOLARIS
> +    s->vmfd = s->fd;
> +#endif
>  
>      missing_cap = kvm_check_extension_list(s, kvm_required_capabilites);
>      if (!missing_cap) {
> @@ -1287,6 +1345,19 @@ int kvm_cpu_exec(CPUArchState *env)
>              DPRINTF("irq_window_open\n");
>              ret = EXCP_INTERRUPT;
>              break;
> +#ifdef CONFIG_SOLARIS
> +        /*
> +         * In the case of an external interrupt we can get a zero
> +         * return from the ioctl, with a KVM_EXIT_INTR. This doesn't
> +         * happen on linux
> +         *
> +         * Not entirely sure what to do here.
> +         */
> +        case KVM_EXIT_INTR:
> +            DPRINTF("exit_intr (run_ret is %d)\n", run_ret);
> +            ret = EXCP_INTERRUPT;
> +            break;
> +#endif
>          case KVM_EXIT_SHUTDOWN:
>              DPRINTF("shutdown\n");
>              qemu_system_reset_request();
> @@ -1631,7 +1702,7 @@ int kvm_set_signal_mask(CPUArchState *env, const
> sigset_t *sigset)
>  
>      sigmask = g_malloc(sizeof(*sigmask) + sizeof(*sigset));
>  
> -    sigmask->len = 8;
> +    sigmask->len = sizeof(sigset_t);
>      memcpy(sigmask->sigset, sigset, sizeof(*sigset));
>      r = kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, sigmask);
>      g_free(sigmask);
> @@ -1641,6 +1712,7 @@ int kvm_set_signal_mask(CPUArchState *env, const
> sigset_t *sigset)
>  
>  int kvm_set_ioeventfd_mmio_long(int fd, uint32_t addr, uint32_t val,
> bool assign)
>  {
> +#ifdef CONFIG_EVENTFD
>      int ret;
>      struct kvm_ioeventfd iofd;
>  
> @@ -1665,10 +1737,14 @@ int kvm_set_ioeventfd_mmio_long(int fd, uint32_t
> addr, uint32_t val, bool assign
>      }
>  
>      return 0;
> +#else
> +    return -ENOSYS;
> +#endif

The guard probably needs to be added also around ioeventfd definitions
in virtio-pci.c.

>  }
>  
>  int kvm_set_ioeventfd_pio_word(int fd, uint16_t addr, uint16_t val,
> bool assign)
>  {
> +#ifdef CONFIG_EVENTFD
>      struct kvm_ioeventfd kick = {
>          .datamatch = val,
>          .addr = addr,
> @@ -1688,6 +1764,9 @@ int kvm_set_ioeventfd_pio_word(int fd, uint16_t
> addr, uint16_t val, bool assign)
>          return r;
>      }
>      return 0;
> +#else
> +    return -ENOSYS;
> +#endif
>  }
>  
>  int kvm_on_sigbus_vcpu(CPUArchState *env, int code, void *addr)
> diff --git a/kvm.h b/kvm.h
> index 330f17b..8960b4e 100644
> --- a/kvm.h
> +++ b/kvm.h
> @@ -19,8 +19,23 @@
>  #include "qemu-queue.h"
>  
>  #ifdef CONFIG_KVM
> +#ifdef __sun__
> +#include <sys/kvm.h>
> +/*
> + * it's a bit horrible to include these here, but the kvm_para.h
> include file
> + * isn't public with the illumos kvm implementation
> + */
> +#define KVM_CPUID_SIGNATURE       0x40000000
> +#define KVM_CPUID_FEATURES        0x40000001
> +#define KVM_FEATURE_CLOCKSOURCE   0
> +#define KVM_FEATURE_NOP_IO_DELAY  1
> +#define KVM_FEATURE_MMU_OP        2
> +#define KVM_FEATURE_CLOCKSOURCE2  3
> +#define HYPERV_CPUID_MIN          0x40000005
> +#else
>  #include <linux/kvm.h>
>  #endif
> +#endif
>  
>  extern int kvm_allowed;
>  extern bool kvm_kernel_irqchip;
> diff --git a/qemu-timer.c b/qemu-timer.c
> index d7f56e5..f35ad4e 100644
> --- a/qemu-timer.c
> +++ b/qemu-timer.c
> @@ -77,7 +77,7 @@ struct qemu_alarm_timer {
>      int (*start)(struct qemu_alarm_timer *t);
>      void (*stop)(struct qemu_alarm_timer *t);
>      void (*rearm)(struct qemu_alarm_timer *t, int64_t nearest_delta_ns);
> -#if defined(__linux__)
> +#if defined(__linux__) || defined(__sun__)

Starting from here it would also be a separate patch.

Perhaps you can add a configure test for timer_t instead.

>      int fd;
>      timer_t timer;
>  #elif defined(_WIN32)
> @@ -165,7 +165,7 @@ static int unix_start_timer(struct qemu_alarm_timer *t);
>  static void unix_stop_timer(struct qemu_alarm_timer *t);
>  static void unix_rearm_timer(struct qemu_alarm_timer *t, int64_t delta);
>  
> -#ifdef __linux__
> +#if defined(__linux__) || defined(__sun__)
>  
>  static int dynticks_start_timer(struct qemu_alarm_timer *t);
>  static void dynticks_stop_timer(struct qemu_alarm_timer *t);
> @@ -177,7 +177,7 @@ static void dynticks_rearm_timer(struct
> qemu_alarm_timer *t, int64_t delta);
>  
>  static struct qemu_alarm_timer alarm_timers[] = {
>  #ifndef _WIN32
> -#ifdef __linux__
> +#if defined(__linux__) || defined(__sun__)
>      {"dynticks", dynticks_start_timer,
>       dynticks_stop_timer, dynticks_rearm_timer},
>  #endif
> @@ -502,7 +502,7 @@ static void host_alarm_handler(int host_signum)
>      }
>  }
>  
> -#if defined(__linux__)
> +#if defined(__linux__) || defined(__sun__)
>  
>  #include "compatfd.h"
>  
> @@ -585,7 +585,7 @@ static void dynticks_rearm_timer(struct
> qemu_alarm_timer *t,
>      }
>  }
>  
> -#endif /* defined(__linux__) */
> +#endif /* defined(__linux__) || defined(__sun__) */
>  
>  #if !defined(_WIN32)
>  
> diff --git a/qga/channel-posix.c b/qga/channel-posix.c
> index 40f7658..86245c1 100644
> --- a/qga/channel-posix.c
> +++ b/qga/channel-posix.c
> @@ -3,6 +3,10 @@
>  #include "qemu_socket.h"
>  #include "qga/channel.h"
>  
> +#ifdef CONFIG_SOLARIS
> +#include <sys/stropts.h>
> +#endif
> +
>  #define GA_CHANNEL_BAUDRATE_DEFAULT B38400 /* for isa-serial channels */
>  
>  struct GAChannel {

Starting from here it would also be a separate patch.

> @@ -123,7 +127,19 @@ static gboolean ga_channel_open(GAChannel *c, const
> gchar *path, GAChannelMethod
>  
>      switch (c->method) {
>      case GA_CHANNEL_VIRTIO_SERIAL: {
> +#ifdef CONFIG_SOLARIS
> +        int fd = qemu_open(path, O_RDWR | O_NONBLOCK);
> +        if (fd == -1) {
> +            g_critical("error opening channel: %s", strerror(errno));
> +            exit(EXIT_FAILURE);
> +        }
> +        if (ioctl(fd, I_SETSIG, S_OUTPUT | S_INPUT | S_HIPRI) < 0) {
> +            g_critical("error with setsig on channel: %s",
> strerror(errno));
> +            exit(EXIT_FAILURE);
> +        }
> +#else
>          int fd = qemu_open(path, O_RDWR | O_NONBLOCK | O_ASYNC);
> +#endif
>          if (fd == -1) {
>              g_critical("error opening channel: %s", strerror(errno));
>              exit(EXIT_FAILURE);
> diff --git a/qga/commands-posix.c b/qga/commands-posix.c
> index 7b2be2f..67531aa 100644
> --- a/qga/commands-posix.c
> +++ b/qga/commands-posix.c
> @@ -35,6 +35,11 @@
>  #include "qemu-queue.h"
>  #include "host-utils.h"
>  
> +#if defined(__sun__)
> +#include <sys/sockio.h>
> +extern char **environ;
> +#endif
> +
>  static void reopen_fd_to_null(int fd)
>  {
>      int nullfd;
> @@ -807,7 +812,11 @@ GuestNetworkInterfaceList
> *qmp_guest_network_get_interfaces(Error **errp)
>                  goto error;
>              }
>  
> +#if defined(__sun__)
> +            mac_addr = (unsigned char *) &ifr.ifr_enaddr;
> +#else
>              mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
> +#endif
>  
>              if (asprintf(&info->value->hardware_address,
>                           "%02x:%02x:%02x:%02x:%02x:%02x",
> diff --git a/target-i386/hyperv.h b/target-i386/hyperv.h
> index bacb1d4..9c08750 100644
> --- a/target-i386/hyperv.h
> +++ b/target-i386/hyperv.h
> @@ -15,8 +15,12 @@
>  
>  #include "qemu-common.h"
>  #ifdef CONFIG_KVM
> +#ifdef __sun__
> +#include <hyperv.h>
> +#else
>  #include <asm/hyperv.h>
>  #endif
> +#endif
>  
>  #ifndef HYPERV_SPINLOCK_NEVER_RETRY
>  #define HYPERV_SPINLOCK_NEVER_RETRY             0xFFFFFFFF
> diff --git a/target-i386/kvm.c b/target-i386/kvm.c
> index e74a9e4..6d007cc 100644
> --- a/target-i386/kvm.c
> +++ b/target-i386/kvm.c
> @@ -17,8 +17,12 @@
>  #include <sys/mman.h>
>  #include <sys/utsname.h>
>  
> +#ifdef __sun__
> +#include <sys/kvm.h>
> +#else
>  #include <linux/kvm.h>
>  #include <linux/kvm_para.h>
> +#endif
>  
>  #include "qemu-common.h"
>  #include "sysemu.h"
> @@ -61,7 +65,9 @@ const KVMCapabilityInfo
> kvm_arch_required_capabilities[] = {
>  static bool has_msr_star;
>  static bool has_msr_hsave_pa;
>  static bool has_msr_tsc_deadline;
> +#ifdef KVM_CAP_ASYNC_PF
>  static bool has_msr_async_pf_en;
> +#endif
>  static bool has_msr_misc_enable;
>  static int lm_capable_kernel;
>  
> @@ -97,7 +103,9 @@ struct kvm_para_features {
>      { KVM_CAP_CLOCKSOURCE, KVM_FEATURE_CLOCKSOURCE },
>      { KVM_CAP_NOP_IO_DELAY, KVM_FEATURE_NOP_IO_DELAY },
>      { KVM_CAP_PV_MMU, KVM_FEATURE_MMU_OP },
> +#ifdef KVM_CAP_ASYNC_PF
>      { KVM_CAP_ASYNC_PF, KVM_FEATURE_ASYNC_PF },
> +#endif
>      { -1, -1 }
>  };
>  
> @@ -442,7 +450,9 @@ int kvm_arch_init_vcpu(CPUX86State *env)
>          c->edx = signature[2];
>      }
>  
> +#ifdef KVM_CAP_ASYNC_PF
>      has_msr_async_pf_en = c->eax & (1 << KVM_FEATURE_ASYNC_PF);
> +#endif
>  
>      cpu_x86_cpuid(env, 0, 0, &limit, &unused, &unused, &unused);
>  
> @@ -561,6 +571,7 @@ int kvm_arch_init_vcpu(CPUX86State *env)
>          return r;
>      }
>  
> +#ifdef KVM_CAP_TSC_CONTROL
>      r = kvm_check_extension(env->kvm_state, KVM_CAP_TSC_CONTROL);
>      if (r && env->tsc_khz) {
>          r = kvm_vcpu_ioctl(env, KVM_SET_TSC_KHZ, env->tsc_khz);
> @@ -569,10 +580,12 @@ int kvm_arch_init_vcpu(CPUX86State *env)
>              return r;
>          }
>      }
> -
> +#endif
> +#ifdef KVM_CAP_XSAVE
>      if (kvm_has_xsave()) {
>          env->kvm_xsave_buf = qemu_memalign(4096, sizeof(struct kvm_xsave));
>      }
> +#endif
>  
>      return 0;
>  }
> @@ -759,7 +772,7 @@ static void get_seg(SegmentCache *lhs, const struct
> kvm_segment *rhs)
>                   (rhs->avl * DESC_AVL_MASK);
>  }
>  
> -static void kvm_getput_reg(__u64 *kvm_reg, target_ulong *qemu_reg, int set)
> +static void kvm_getput_reg(uint64_t *kvm_reg, target_ulong *qemu_reg,
> int set)
>  {
>      if (set) {
>          *kvm_reg = *qemu_reg;
> @@ -841,6 +854,7 @@ static int kvm_put_fpu(CPUX86State *env)
>  #define XSAVE_XSTATE_BV   128
>  #define XSAVE_YMMH_SPACE  144
>  
> +#ifdef KVM_CAP_XSAVE
>  static int kvm_put_xsave(CPUX86State *env)
>  {
>      struct kvm_xsave* xsave = env->kvm_xsave_buf;
> @@ -874,7 +888,9 @@ static int kvm_put_xsave(CPUX86State *env)
>      r = kvm_vcpu_ioctl(env, KVM_SET_XSAVE, xsave);
>      return r;
>  }
> +#endif
>  
> +#ifdef KVM_CAP_XSCRS
>  static int kvm_put_xcrs(CPUX86State *env)
>  {
>      struct kvm_xcrs xcrs;
> @@ -889,6 +905,7 @@ static int kvm_put_xcrs(CPUX86State *env)
>      xcrs.xcrs[0].value = env->xcr0;
>      return kvm_vcpu_ioctl(env, KVM_SET_XCRS, &xcrs);
>  }
> +#endif
>  
>  static int kvm_put_sregs(CPUX86State *env)
>  {
> @@ -1000,10 +1017,12 @@ static int kvm_put_msrs(CPUX86State *env, int level)
>          kvm_msr_entry_set(&msrs[n++], MSR_KVM_SYSTEM_TIME,
>                            env->system_time_msr);
>          kvm_msr_entry_set(&msrs[n++], MSR_KVM_WALL_CLOCK,
> env->wall_clock_msr);
> +#ifdef KVM_CAP_ASYNC_PF
>          if (has_msr_async_pf_en) {
>              kvm_msr_entry_set(&msrs[n++], MSR_KVM_ASYNC_PF_EN,
>                                env->async_pf_en_msr);
>          }
> +#endif
>          if (hyperv_hypercall_available()) {
>              kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_GUEST_OS_ID, 0);
>              kvm_msr_entry_set(&msrs[n++], HV_X64_MSR_HYPERCALL, 0);
> @@ -1055,6 +1074,7 @@ static int kvm_get_fpu(CPUX86State *env)
>      return 0;
>  }
>  
> +#ifdef KVM_CAP_XSAVE
>  static int kvm_get_xsave(CPUX86State *env)
>  {
>      struct kvm_xsave* xsave = env->kvm_xsave_buf;
> @@ -1092,7 +1112,9 @@ static int kvm_get_xsave(CPUX86State *env)
>              sizeof env->ymmh_regs);
>      return 0;
>  }
> +#endif
>  
> +#ifdef KVM_CAP_XCRS
>  static int kvm_get_xcrs(CPUX86State *env)
>  {
>      int i, ret;
> @@ -1116,6 +1138,7 @@ static int kvm_get_xcrs(CPUX86State *env)
>      }
>      return 0;
>  }
> +#endif
>  
>  static int kvm_get_sregs(CPUX86State *env)
>  {
> @@ -1243,9 +1266,11 @@ static int kvm_get_msrs(CPUX86State *env)
>  #endif
>      msrs[n++].index = MSR_KVM_SYSTEM_TIME;
>      msrs[n++].index = MSR_KVM_WALL_CLOCK;
> +#ifdef KVM_CAP_ASYNC_PF
>      if (has_msr_async_pf_en) {
>          msrs[n++].index = MSR_KVM_ASYNC_PF_EN;
>      }
> +#endif
>  
>      if (env->mcg_cap) {
>          msrs[n++].index = MSR_MCG_STATUS;
> @@ -1322,9 +1347,11 @@ static int kvm_get_msrs(CPUX86State *env)
>                  env->mce_banks[msrs[i].index - MSR_MC0_CTL] = msrs[i].data;
>              }
>              break;
> +#ifdef KVM_CAP_ASYNC_PF
>          case MSR_KVM_ASYNC_PF_EN:
>              env->async_pf_en_msr = msrs[i].data;
>              break;
> +#endif
>          }
>      }
>  
> @@ -1482,6 +1509,7 @@ static int kvm_guest_debug_workarounds(CPUX86State
> *env)
>      return ret;
>  }
>  
> +#ifdef KVM_CAP_DEBUGREGS
>  static int kvm_put_debugregs(CPUX86State *env)
>  {
>      struct kvm_debugregs dbgregs;
> @@ -1522,6 +1550,7 @@ static int kvm_get_debugregs(CPUX86State *env)
>  
>      return 0;
>  }
> +#endif
>  
>  int kvm_arch_put_registers(CPUX86State *env, int level)
>  {
> @@ -1533,14 +1562,20 @@ int kvm_arch_put_registers(CPUX86State *env, int
> level)
>      if (ret < 0) {
>          return ret;
>      }
> +#ifdef KVM_CAP_XSAVE
>      ret = kvm_put_xsave(env);
> +#else
> +    ret = kvm_put_fpu(env);
> +#endif
>      if (ret < 0) {
>          return ret;
>      }
> +#ifdef KVM_CAP_XCRS
>      ret = kvm_put_xcrs(env);
>      if (ret < 0) {
>          return ret;
>      }
> +#endif
>      ret = kvm_put_sregs(env);
>      if (ret < 0) {
>          return ret;
> @@ -1568,10 +1603,12 @@ int kvm_arch_put_registers(CPUX86State *env, int
> level)
>      if (ret < 0) {
>          return ret;
>      }
> +#ifdef KVM_CAP_DEBUGREGS
>      ret = kvm_put_debugregs(env);
>      if (ret < 0) {
>          return ret;
>      }
> +#endif
>      /* must be last */
>      ret = kvm_guest_debug_workarounds(env);
>      if (ret < 0) {
> @@ -1590,14 +1627,20 @@ int kvm_arch_get_registers(CPUX86State *env)
>      if (ret < 0) {
>          return ret;
>      }
> +#ifdef KVM_CAP_XSAVE
>      ret = kvm_get_xsave(env);
> +#else
> +    ret = kvm_get_fpu(env);
> +#endif
>      if (ret < 0) {
>          return ret;
>      }
> +#ifdef KVM_CAP_XCRS
>      ret = kvm_get_xcrs(env);
>      if (ret < 0) {
>          return ret;
>      }
> +#endif
>      ret = kvm_get_sregs(env);
>      if (ret < 0) {
>          return ret;
> @@ -1618,10 +1661,12 @@ int kvm_arch_get_registers(CPUX86State *env)
>      if (ret < 0) {
>          return ret;
>      }
> +#ifdef KVM_CAP_DEBUGREGS
>      ret = kvm_get_debugregs(env);
>      if (ret < 0) {
>          return ret;
>      }
> +#endif
>      return 0;
>  }
>  
> @@ -1770,6 +1815,7 @@ static int kvm_handle_tpr_access(CPUX86State *env)
>      return 1;
>  }
>  
> +#ifdef KVM_CAP_SET_GUEST_DEBUG
>  int kvm_arch_insert_sw_breakpoint(CPUX86State *env, struct
> kvm_sw_breakpoint *bp)
>  {
>      static const uint8_t int3 = 0xcc;
> @@ -1950,6 +1996,7 @@ void kvm_arch_update_guest_debug(CPUX86State *env,
> struct kvm_guest_debug *dbg)
>          }
>      }
>  }
> +#endif /* KVM_CAP_SET_GUEST_DEBUG */
>  
>  static bool host_supports_vmx(void)
>  {
> @@ -1999,10 +2046,12 @@ int kvm_arch_handle_exit(CPUX86State *env,
> struct kvm_run *run)
>                  run->ex.exception, run->ex.error_code);
>          ret = -1;
>          break;
> +#ifdef KVM_CAP_SET_GUEST_DEBUG
>      case KVM_EXIT_DEBUG:
>          DPRINTF("kvm_exit_debug\n");
>          ret = kvm_handle_debug(&run->debug.arch);
>          break;
> +#endif
>      default:
>          fprintf(stderr, "KVM: unknown exit reason %d\n", run->exit_reason);
>          ret = -1;
> 

Did you have any problem with IOV_MAX?  IIRC, it's quite low (16
perhaps) in Solaris.

Paolo