Coverage for drivers/qcow2util.py: 26%

717 raise xs_errors.XenError("Multiple openers for {}".format(path)) # TODO: There might be multiple PID? Yes, we can have the chain enabled for multiple leaf (i.e. after a clone), taken into account in cleanup.py

718 pid = pid_openers[0]

719 tapdiskList = TapCtl.list(pid=pid)

720 if len(tapdiskList) > 1: #TODO: There might more than one minor for this blktap?

721 raise xs_errors.XenError("TapdiskAlreadyRunning", "There is multiple minor for this tapdisk process")

722 minor = tapdiskList[0]["minor"]

723 return (pid, minor)

724 raise xs_errors.XenError("TapdiskFailed", "No tapdisk process found for {}".format(path))

725

726 @override

727 def coalesceOnline(self, path: str) -> int:

728 pid, minor = self._getTapdisk(path)

729 logger = util.LoggerCounter(10)

730

731 try:

732 TapCtl.commit(pid, minor, QCOW2_TYPE, path)

733 # We need to wait for query to return concluded

734 # We are technically ininterruptible since being interrupted will only stop checking if the job is done.

735 # We need to call `tap-ctl cancel` if we are interrupted, it is done in cleanup.py code.

736

737 status, nb, _ = TapCtl.query(pid, minor)

738 if status == "undefined":

739 util.SMlog("Tapdisk {} (m: {}) coalesce status undefined for {}".format(pid, minor, path))

740 return 0

741

742 while status != "concluded":

743 time.sleep(1)

744 status, nb, _ = TapCtl.query(pid, minor, quiet=True)

745 logger.log("Got status {} for tapdisk {} (m: {})".format(status, pid, minor))

746 return nb

747 except TapCtl.CommandFailure:

748 util.SMlog("Query command failed on tapdisk instance {}. Raising...".format(pid))

749 raise

750

751 @override

752 def cancelCoalesceOnline(self, path: str) -> None:

753 pid, minor = self._getTapdisk(path)

754

755 try:

756 TapCtl.cancel_commit(pid, minor)

757 except TapCtl.CommandFailure:

758 util.SMlog("Cancel command failed on tapdisk instance {}. Raising...".format(pid))

759 raise

760

761 @override

762 def coalesce(self, path: str) -> int:

763 # -d on commit make it not empty the original image since we don't intend to keep it

764 cmd = [QEMU_IMG, "commit", "-f", QCOW2_TYPE, path, "-d"]

765 ret = cast(str, self._ioretry(cmd)) # Allows to parse for byte coalesced, our qemu-img is supposed to be patched to output it.

766 lines = ret.splitlines()

767 if re.match("Image committed.", lines[-1]):

768 res_line = lines[-2]

769 else:

770 res_line = lines[-1]

771

772 results = re.match(r"\((\d+)/(\d+)\)", res_line)

773 if results:

774 committed_bytes = int(results.group(1))

775 return committed_bytes

776 raise xs_errors.XenError("TapdiskFailed", "Couldn't get commited size from qemu-img commit call") # TODO: We might not want to raise in this case, it would break if the qemu-img called isn't modified to print the coalesce result even if it succeeded in coalesceing

777

778 @override

779 def create(self, path: str, size: int, static: bool, msize: int = 0, block_size: Optional[int] = None) -> None:

780 cmd = [QEMU_IMG, "create", "-f", QCOW2_TYPE, path, str(size)]

781 if static:

782 cmd.extend(["-o", "preallocation=full"])

783 if block_size:

784 cmd.extend(["-o", f"cluster_size={str(block_size)}"])

785 self._ioretry(cmd)

786 self.setHidden(path, False) #We add hidden header at creation

787

788 @override

789 def snapshot(

790 self,

791 path: str,

792 parent: str,

793 parentRaw: bool,

794 msize: int = 0,

795 checkEmpty: bool = True,

796 is_mirror_image: bool = False

797 ) -> None:

798 # TODO: msize, it's use to preallocate metadata, could we honor this too?

799 # TODO: checkEmpty? If it is False, then the parent could be empty and should still be used for snapshot

800 # But if True, if the parent is empty, we do what? vhd would just use the parent of parent as base, should we emulate this behavior?

801

802 cmd = [QEMU_IMG, "create"]

803

804 if parentRaw:

805 parent_type = RAW_TYPE

806 cluster_size = QCOW2_DEFAULT_CLUSTER_SIZE

807 else:

808 parent_type = QCOW2_TYPE

809 cluster_size = self.getBlockSize(parent)

810 args = ["-f", QCOW2_TYPE, "-F", parent_type, "-b", parent]

811

812 if is_mirror_image:

813 # is_mirror_image override the cluster size to ensure that we have a write of 512b to avoid having to read the parent during a migration.

814 # This is needed because the blkif blocksize is only 512b, as such it will try to only write blocks smaller than the cluster size.

815 # To write a smaller block, we would need to read the parent image cluster then change the 512b block.

816 # The parent being empty during the mirroring phase, reading from it would read zeros and corrupt the cluster.

817 # It also enable extended_l2 for this purpose, this is only done in the snapshot used for the mirror, this configuration will be lost when coalesced in its parent.

818 # Ensuring we go back to a better cluster_size for performance reasons.

819 # This limit our images max size to 64TiB.

820 cluster_size = 16 * 1024 # 16KiB

821 args.extend(["-o", "extended_l2=on"])

822

823 args.extend(["-o", f"cluster_size={cluster_size}"])

824 cmd.extend(args)

825 cmd.append(path)

826

827 self._ioretry(cmd)

828 self.setHidden(path, False) #We add hidden header at creation

829