Coverage for drivers/qcow2util.py: 26%

719 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

720 pid = pid_openers[0]

721 tapdiskList = TapCtl.list(pid=pid)

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

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

724 minor = tapdiskList[0]["minor"]

725 return (pid, minor)

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

727

728 @override

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

730 pid, minor = self._getTapdisk(path)

731 logger = util.LoggerCounter(10)

732

733 try:

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

735 # We need to wait for query to return concluded

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

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

738

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

740 if status == "undefined":

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

742 return 0

743

744 while status != "concluded":

745 time.sleep(1)

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

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

748 return nb

749 except TapCtl.CommandFailure:

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

751 raise

752

753 @override

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

755 pid, minor = self._getTapdisk(path)

756

757 try:

758 TapCtl.cancel_commit(pid, minor)

759 except TapCtl.CommandFailure:

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

761 raise

762

763 @override

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

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

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

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

768 lines = ret.splitlines()

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

770 res_line = lines[-2]

771 else:

772 res_line = lines[-1]

773

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

775 if results:

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

777 return committed_bytes

778 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

779

780 @override

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

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

783 if static:

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

785 if block_size:

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

787 self._ioretry(cmd)

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

789

790 @override

791 def snapshot(

792 self,

793 path: str,

794 parent: str,

795 parentRaw: bool,

796 msize: int = 0,

797 checkEmpty: bool = True,

798 is_mirror_image: bool = False

799 ) -> None:

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

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

802 # 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?

803

804 cmd = [QEMU_IMG, "create"]

805

806 if parentRaw:

807 parent_type = RAW_TYPE

808 cluster_size = QCOW2_DEFAULT_CLUSTER_SIZE

809 else:

810 parent_type = QCOW2_TYPE

811 cluster_size = self.getBlockSize(parent)

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

813

814 if is_mirror_image:

815 # 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.

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

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

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

819 # 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.

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

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

822 cluster_size = 16 * 1024 # 16KiB

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

824

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

826 cmd.extend(args)

827 cmd.append(path)

828

829 self._ioretry(cmd)

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

831