1. 13 May, 2012 1 commit
    • Jim Meyering's avatar
      fix some common typos · a31f0531
      Jim Meyering authored
      These were identified using: http://github.com/lyda/misspell-check
      and run like this to create a bourne shell script using GNU sed's
      -i option:
      
      git ls-files|grep -vF .bin | misspellings -f - |grep -v '^ERROR:' |perl \
      -pe 's/^(.*?)\[(\d+)\]: (\w+) -> "(.*?)"$/sed -i '\''${2}s!$3!$4!'\'' $1/'
      
      Manually eliding the FP, "rela->real" and resolving "addres" to
      address (not "adders") we get this:
      
        sed -i '450s!thru!through!' Changelog
        sed -i '260s!neccessary!necessary!' coroutine-sigaltstack.c
        sed -i '54s!miniscule!minuscule!' disas.c
        sed -i '1094s!thru!through!' hw/usb/hcd-ehci.c
        sed -i '1095s!thru!through!' hw/usb/hcd-ehci.c
        sed -i '21s!unecessary!unnecessary!' qapi-schema-guest.json
        sed -i '307s!explictly!explicitly!' qemu-ga.c
        sed -i '490s!preceeding!preceding!' qga/commands-posix.c
        sed -i '792s!addres!address!' qga/commands-posix.c
        sed -i '6s!beeing!being!' tests/tcg/test-mmap.c
      
      Also, manually fix "arithmentic", spotted by Peter Maydell:
      
        sed -i 's!arithmentic!arithmetic!' coroutine-sigaltstack.c
      Signed-off-by: default avatarJim Meyering <meyering@redhat.com>
      Reviewed-by: default avatarPeter Maydell <peter.maydell@linaro.org>
      a31f0531
  2. 30 Apr, 2012 2 commits
    • Michael Roth's avatar
      qemu-ga: persist tracking of fsfreeze state via filesystem · f789aa7b
      Michael Roth authored
      Currently, qemu-ga may die/get killed/go away for whatever reason after
      guest-fsfreeze-freeze has been issued, and before guest-fsfreeze-thaw
      has been issued. This means the only way to unfreeze the guest is via
      VNC/network/console access, but obtaining that access after-the-fact can
      often be very difficult when filesystems are frozen. Logins will almost
      always hang, for instance. In many cases the only recourse would be to
      reboot the guest without any quiescing of volatile state, which makes
      this a corner-case worth giving some attention to.
      
      A likely failsafe for this situation would be to use a watchdog to
      restart qemu-ga if it goes away. There are some precautions qemu-ga
      needs to take in order to avoid immediately hanging itself on I/O,
      however, namely, we must disable logging and defer to processing/creation
      of user-specific logfiles, along with creation of the pid file if we're
      running as a daemon. We also need to disable non-fsfreeze-safe commands,
      as we normally would when processing the guest-fsfreeze-freeze command.
      
      To track when we need to do this in a way that persists between multiple
      invocations of qemu-ga, we create a file on the guest filesystem before
      issuing the fsfreeze, and delete it when doing the thaw. On qemu-ga
      startup, we check for the existance of this file to determine
      the need to take the above precautions.
      
      We're forced to do it this way since a more traditional approach such as
      reading/writing state to a dedicated state file will cause
      access/modification time updates, respectively, both of which will hang
      if the file resides on a frozen filesystem. Both can occur even if
      relatime is enabled. Checking for file existence will not update the
      access time, however, so it's a safe way to check for fsfreeze state.
      
      An actual watchdog-based restart of qemu-ga can itself cause an access
      time update that would thus hang the invocation of qemu-ga, but the
      logic to workaround that can be handled via the watchdog, so we don't
      address that here (for relatime we'd periodically touch the qemu-ga
      binary if the file $qga_statedir/qga.state.isfrozen is not present, this
      avoids qemu-ga updates or the 1 day relatime threshold causing an
      access-time update if we try to respawn qemu-ga shortly after it goes
      away)
      Signed-off-by: default avatarMichael Roth <mdroth@linux.vnet.ibm.com>
      f789aa7b
    • Michael Roth's avatar
      qemu-ga: improve recovery options for fsfreeze · 9e8aded4
      Michael Roth authored
      guest-fsfreeze-thaw relies on state information obtained from
      guest-fsfreeze-freeze to determine what filesystems to unfreeze.
      This is unreliable due to the fact that that state does not account
      for FIFREEZE being issued by other processes, or previous instances
      of qemu-ga. This means in certain situations we cannot thaw
      filesystems even with a responsive qemu-ga instance at our disposal.
      
      This patch allows guest-fsfreeze-thaw to be issued unconditionally.
      It also adds some additional logic to allow us to thaw filesystems
      regardless of how many times the filesystem's "frozen" refcount has
      been incremented by any guest processes.
      
      Also, guest-fsfreeze-freeze now operates atomically: on success all
      freezable filesystems are frozen, and on error all filesystems are
      thawed. The ambiguous "GUEST_FSFREEZE_STATUS_ERROR" state is no
      longer entered.
      Signed-off-by: default avatarMichael Roth <mdroth@linux.vnet.ibm.com>
      9e8aded4
  3. 12 Mar, 2012 5 commits
    • Michael Roth's avatar
      qemu-ga: add guest-sync-delimited · 3cf0bed8
      Michael Roth authored
      guest-sync leaves it as an exercise to the user as to how to reliably
      obtain the response to guest-sync if the client had previously read in a
      partial response (due qemu-ga previously being restarted mid-"sentence"
      due to reboot, forced restart, etc).
      
      qemu-ga handles this situation on its end by having a client precede
      their guest-sync request with a 0xFF byte (invalid UTF-8), which
      qemu-ga/QEMU JSON parsers will treat as a flush event. Thus we can
      reliably flush the qemu-ga parser state in preparation for receiving
      the guest-sync request.
      
      guest-sync-delimited provides the same functionality for a client: when
      a guest-sync-delimited is issued, qemu-ga will precede it's response
      with a 0xFF byte that the client can use as an indicator to flush its
      buffer/parser state in preparation for reliably receiving the
      guest-sync-delimited response.
      
      It is also useful as an optimization for clients, since, after issuing a
      guest-sync-delimited, clients can safely discard all stale data read
      from the channel until the 0xFF is found.
      
      More information available on the wiki:
      
      http://wiki.qemu.org/Features/QAPI/GuestAgent#QEMU_Guest_Agent_ProtocolSigned-off-by: default avatarMichael Roth <mdroth@linux.vnet.ibm.com>
      3cf0bed8
    • Michal Privoznik's avatar
      qemu-ga: add guest-network-get-interfaces command · 3424fc9f
      Michal Privoznik authored
      This command returns an array of:
      
       [ifname, hwaddr, [ipaddr, ipaddr_family, prefix] ]
      
      for each interface in the system.
      Currently, only IPv4 and IPv6 are supported.
      Signed-off-by: default avatarMichal Privoznik <mprivozn@redhat.com>
      3424fc9f
    • Luiz Capitulino's avatar
      95f4f404
    • Luiz Capitulino's avatar
      qemu-ga: add guest-suspend-ram · fbf42210
      Luiz Capitulino authored
      Signed-off-by: default avatarLuiz Capitulino <lcapitulino@redhat.com>
      fbf42210
    • Luiz Capitulino's avatar
      qemu-ga: add guest-suspend-disk · 11d0f125
      Luiz Capitulino authored
      As the command name implies, this command suspends the guest to disk.
      
      The suspend operation is implemented by two functions: bios_supports_mode()
      and guest_suspend(). Both functions are generic enough to be used by
      other suspend modes (introduced by next commits).
      
      Both functions will try to use the scripts provided by the pm-utils
      package if it's available. If it's not available, a manual method,
      which consists of directly writing to '/sys/power/state', will be used.
      
      To reap terminated children, a new signal handler is installed in the
      parent to catch SIGCHLD signals and a non-blocking call to waitpid()
      is done to collect their exit statuses. The statuses, however, are
      discarded.
      
      The approach used to query the guest for suspend support deserves some
      explanation. It's implemented by bios_supports_mode() and shown below:
      
        qemu-ga
           |
       create pipe
           |
         fork()
           -----------------
           |               |
           |               |
           |             fork()
           |               --------------------------
           |               |                        |
           |               |                        |
           |               |               exec('pm-is-supported')
           |               |
           |              wait()
           |       write exit status to pipe
           |              exit
           |
        read pipe
      
      This might look complex, but the resulting code is quite simple.
      The purpose of that approach is to allow qemu-ga to reap its children
      (semi-)automatically from its SIGCHLD handler.
      
      Implementing this the obvious way, that's, doing the exec() call from
      the first child process, would force us to introduce a more complex way
      to reap qemu-ga's children. Like registering PIDs to be reaped and
      having a way to wait for them when returning their exit status to
      qemu-ga is necessary. The approach explained above avoids that complexity.
      Signed-off-by: default avatarLuiz Capitulino <lcapitulino@redhat.com>
      11d0f125
  4. 23 Feb, 2012 1 commit
  5. 14 Dec, 2011 1 commit
  6. 12 Dec, 2011 1 commit
  7. 21 Jul, 2011 1 commit
    • Michael Roth's avatar
      guest agent: add guest agent RPCs/commands · e3d4d252
      Michael Roth authored
      This adds the initial set of QMP/QAPI commands provided by the guest
      agent:
      
      guest-sync
      guest-ping
      guest-info
      guest-shutdown
      guest-file-open
      guest-file-read
      guest-file-write
      guest-file-seek
      guest-file-flush
      guest-file-close
      guest-fsfreeze-freeze
      guest-fsfreeze-thaw
      guest-fsfreeze-status
      
      The input/output specification for these commands are documented in the
      schema.
      
      Example usage:
      
        host:
          qemu -device virtio-serial \
               -chardev socket,path=/tmp/vs0.sock,server,nowait,id=qga0 \
               -device virtserialport,chardev=qga0,name=org.qemu.quest_agent.0
               ...
      
          echo "{'execute':'guest-info'}" | socat stdio unix-connect:/tmp/qga0.sock
      
        guest:
          qemu-ga -m virtio-serial -p /dev/virtio-ports/org.qemu.guest_agent.0 \
                  -p /var/run/qemu-guest-agent.pid -d
      Signed-off-by: default avatarMichael Roth <mdroth@linux.vnet.ibm.com>
      Signed-off-by: default avatarLuiz Capitulino <lcapitulino@gmail.com>
      e3d4d252