利用qemu-guest-agent冻结文件系统_qemu-guest-agent centos8

#直接用virsh命令，freeze文件系统
[root@node-12 ~]# virsh qemu-agent-command 90 '{"execute":"guest-fsfreeze-freeze"}'
{"return":1}
 
#freeze后，可以查询当前虚拟机文件系统的状态，表明是frozen
[root@node-12 ~]# virsh qemu-agent-command 90 '{"execute":"guest-fsfreeze-status"}'
{"return":"frozen"}
 
#thaw（解封）文件系统
[root@node-12 ~]# virsh qemu-agent-command 90 '{"execute":"guest-fsfreeze-thaw"}'
{"return":1}
 
#thaw后，文件系统为解封状态
[root@node-12 ~]# virsh qemu-agent-command 90 '{"execute":"guest-fsfreeze-status"}'
{"return":"thawed"}

nova image-meta 6410b84d-a473-4ece-83e5-09848a545645 set hw_qemu_guest_agent=yes

    # NOTE(melwitt): We don't check instance lock for snapshot because lock is
    #                intended to prevent accidental change/delete of instances
    @check_instance_state(vm_state=[vm_states.ACTIVE, vm_states.STOPPED])
    def snapshot_volume_backed(self, context, instance, image_meta, name,
                               extra_properties=None):
        """Snapshot the given volume-backed instance.
 
        :param instance: nova.objects.instance.Instance object
        :param image_meta: metadata for the new image
        :param name: name of the backup or snapshot
        :param extra_properties: dict of extra image properties to include
 
        :returns: the new image metadata
        """
        image_meta['name'] = name
        image_meta['is_public'] = False
        properties = image_meta['properties']
        if instance.root_device_name:
            properties['root_device_name'] = instance.root_device_name
        properties.update(extra_properties or {})
 
        quiesced = False
        if instance.vm_state == vm_states.ACTIVE:
            try:
                #封锁文件系统
                self.compute_rpcapi.quiesce_instance(context, instance)
                quiesced = True
            except (exception.InstanceQuiesceNotSupported,
                    exception.NovaException, NotImplementedError) as err:
                if strutils.bool_from_string(properties.get(
                        'os_require_quiesce')):
                    raise
                else:
                    LOG.info(_LI('Skipping quiescing instance: '
                                 '%(reason)s.'), {'reason': err},
                             context=context, instance=instance)
 
        bdms = objects.BlockDeviceMappingList.get_by_instance_uuid(
                context, instance.uuid)
 
        mapping = []
        for bdm in bdms:
            if bdm.no_device:
                continue
 
            if bdm.is_volume:
                # create snapshot based on volume_id
                volume = self.volume_api.get(context, bdm.volume_id)
                # NOTE(yamahata): Should we wait for snapshot creation?
                #                 Linux LVM snapshot creation completes in
                #                 short time, it doesn't matter for now.
                name = _('snapshot for %s') % image_meta['name']
                #创建volume的snapshot
                snapshot = self.volume_api.create_snapshot_force(
                    context, volume['id'], name, volume['display_description'])
                mapping_dict = block_device.snapshot_from_bdm(snapshot['id'],
                                                              bdm)
                mapping_dict = mapping_dict.get_image_mapping()
            else:
                mapping_dict = bdm.get_image_mapping()
 
            mapping.append(mapping_dict)
 
        #解封文件系统
        if quiesced:
            self.compute_rpcapi.unquiesce_instance(context, instance, mapping)
 
        # NOTE (ndipanov): Remove swap/ephemerals from mappings as they will be
        # in the block_device_mapping for the new image.
        image_mappings = properties.get('mappings')
        if image_mappings:
            properties['mappings'] = [m for m in image_mappings
                                      if not block_device.is_swap_or_ephemeral(
                                          m['virtual'])]
        if mapping:
            properties['block_device_mapping'] = mapping
            properties['bdm_v2'] = True
 
        for attr in ('status', 'location', 'id', 'owner'):
            image_meta.pop(attr, None)
 
        # the new image is simply a bucket of properties (particularly the
        # block device mapping, kernel and ramdisk IDs) with no image data,
        # hence the zero size
        image_meta['size'] = 0
 
        return self.image_api.create(context, image_meta)

    def quiesce_instance(self, ctxt, instance):
        version = self._compat_ver('4.0', '3.39')
        cctxt = self.client.prepare(server=_compute_host(None, instance),
                version=version)
        #向消息队列中发送封锁文件系统的指令，此函数最终由compute/manager.py中的def quiesce_instance执行
        return cctxt.call(ctxt, 'quiesce_instance', instance=instance)

    @wrap_exception()
    def quiesce_instance(self, context, instance):
        """Quiesce an instance on this host."""
        context = context.elevated()
        #通过instance得到instance所使用的image信息
        image_ref = instance.image_ref
        #通过image信息得到image保存的metadata信息，因为凡是支持qemu-ga的，对应的image都需要有hw_qemu_guest_agent=yes的metedata信息
        image_meta = compute_utils.get_image_metadata(
            context, self.image_api, image_ref, instance)
        #调用具体的driver（比如libvirt，vmware，xen等等）来实现
        self.driver.quiesce(context, instance, image_meta)

    def quiesce(self, context, instance, image_meta):
        """Freeze the guest filesystems to prepare for snapshot.
 
        The qemu-guest-agent must be setup to execute fsfreeze.
        """
        #继续调用
        self._set_quiesced(context, instance, image_meta, True)
 
 
    def _set_quiesced(self, context, instance, image_meta, quiesced):
        #判断是否支持封锁文件系统的操作，需要满足3点
        #1.虚拟机类型是qemu/kvm
        #2.qemu版本必须大于1.2.5
        #3.image_meta中必须有hw_qemu_guest_agent=yes
        supported, reason = self._can_quiesce(image_meta)
        #不支持，就抛异常
        if not supported:
            raise exception.InstanceQuiesceNotSupported(
                instance_id=instance.uuid, reason=reason)
 
        try:
            domain = self._host.get_domain(instance)
            if quiesced:
                #调用libvirt库函数，封锁文件系统。类似于执行了virsh qemu-agent-command 90   '{"execute":"guest-fsfreeze-freeze"}'
                domain.fsFreeze()
            else:
                #调用libvirt库函数，解除文件系统封锁。类似于执行了virsh qemu-agent-command 90   '{"execute":"guest-fsfreeze-thaw"}'
                domain.fsThaw()
        except libvirt.libvirtError as ex:
            error_code = ex.get_error_code()
            msg = (_('Error from libvirt while quiescing %(instance_name)s: '
                     '[Error Code %(error_code)s] %(ex)s')
                   % {'instance_name': instance.name,
                      'error_code': error_code, 'ex': ex})
            raise exception.NovaException(msg)