debian/0000775000000000000000000000000012257137653007203 5ustar debian/source/0000775000000000000000000000000012210402253010457 5ustar debian/source/format0000664000000000000000000000001412204574414011701 0ustar 3.0 (quilt) debian/source/include-binaries0000664000000000000000000000016012210402253013614 0ustar lib/balloon_util.o lib/check.o lib/delta_read.o lib/delta_sysfs.o lib/logger.o lib/ploop.o lib/uuid.o lib/xml.o debian/watch0000664000000000000000000000154412204575236010233 0ustar # Example watch control file for uscan # Rename this file to "watch" and then you can run the "uscan" command # to check for upstream updates and more. # See uscan(1) for format # Compulsory line, this is a version 3 file version=3 http://download.openvz.org/utils/ploop/(\d.*)/src/ploop-(\d.*)\.(?:tgz|tbz2|txz|tar\.(?:gz|bz2|xz) # Uncomment to examine a Webpage # #http://www.example.com/downloads.php ploop-(.*)\.tar\.gz # Uncomment to examine a Webserver directory #http://www.example.com/pub/ploop-(.*)\.tar\.gz # Uncommment to examine a FTP server #ftp://ftp.example.com/pub/ploop-(.*)\.tar\.gz debian uupdate # Uncomment to find new files on sourceforge, for devscripts >= 2.9 # http://sf.net/ploop/ploop-(.*)\.tar\.gz # Uncomment to find new files on GooglePages # http://example.googlepages.com/foo.html ploop-(.*)\.tar\.gz debian/patches/0000775000000000000000000000000012257137560010627 5ustar debian/patches/ia64-build-fix.patch-x0000664000000000000000000001563512256111652014544 0ustar Description: fix to make it build on ia64 There is a problem to build on ia64 due to the format used to print some values when the image is corrupted. Solved by casting. Author: Ola Lundqvist Origin: vendor Bug: https://bugzilla.openvz.org/show_bug.cgi?id=2790 Forwarded: https://bugzilla.openvz.org/show_bug.cgi?id=2790 Reviewed-By: Ola Lundqvist Last-Update: 2013-10-31 Index: ploop-1.9/lib/balloon_util.c =================================================================== --- ploop-1.9.orig/lib/balloon_util.c 2013-10-31 19:50:00.137551247 +0100 +++ ploop-1.9/lib/balloon_util.c 2013-10-31 19:51:25.335218874 +0100 @@ -273,14 +273,14 @@ ploop_err(0, "Image corrupted: L2[%u] == %u (max=%llu)", clu + j - l2_slot, delta->l2[j], - (rlen - 1) * B2S(cluster)); + (long long unsigned)((rlen - 1) * B2S(cluster))); return(SYSEXIT_PLOOPFMT); } if (ridx < delta->l1_size) { ploop_err(0, "Image corrupted: L2[%u] == %u (min=%llu)", clu + j - l2_slot, delta->l2[j], - delta->l1_size * B2S(cluster)); + (long long unsigned)(delta->l1_size * B2S(cluster))); return(SYSEXIT_PLOOPFMT); } @@ -538,14 +538,14 @@ ploop_err(0, "Image corrupted: L2[%u] == %u (max=%llu) (2)", clu, delta->l2[l2_slot], - (rlen - 1) * B2S(cluster)); + (long long unsigned)((rlen - 1) * B2S(cluster))); return SYSEXIT_PLOOPFMT; } if (ridx && ridx < delta->l1_size) { ploop_err(0, "Image corrupted: L2[%u] == %u (min=%llu) (2)", clu, delta->l2[l2_slot], - delta->l1_size * B2S(cluster)); + (long long unsigned)(delta->l1_size * B2S(cluster))); return SYSEXIT_PLOOPFMT; } Index: ploop-1.9/lib/ploop.c =================================================================== --- ploop-1.9.orig/lib/ploop.c 2013-10-31 19:50:00.137551247 +0100 +++ ploop-1.9/lib/ploop.c 2013-10-31 19:51:25.347218544 +0100 @@ -285,7 +285,8 @@ if (sectors > max) { ploop_err(0, "An incorrect block device size is specified: %llu sectors." " The maximum allowed size is %llu sectors.", - sectors, max); + (unsigned long long)sectors, + (unsigned long long)max); return -1; } return 0; @@ -2010,7 +2011,7 @@ ploop_err(0, "Unable to change image size to %lu " "sectors, minimal size is %llu", (long)new_fs_size, - (blocks - available_balloon_size)); + (unsigned long long)(blocks - available_balloon_size)); ret = SYSEXIT_PARAM; goto err; } Index: ploop-1.9/lib/balloon.c =================================================================== --- ploop-1.9.orig/lib/balloon.c 2013-10-31 19:50:00.137551247 +0100 +++ ploop-1.9/lib/balloon.c 2013-10-31 19:51:25.355218327 +0100 @@ -859,7 +859,7 @@ range.minlen = MAX(MAX_DISCARD_CLU * cluster, minlen_b); for (; range.minlen >= minlen_b; range.minlen /= 2) { - ploop_log(1, "Call FITRIM, for minlen=%lld", range.minlen); + ploop_log(1, "Call FITRIM, for minlen=%lld", (long long)range.minlen); ret = ioctl(fd, FITRIM, &range); if (ret < 0) { if (trim_stop) @@ -893,7 +893,9 @@ if (start % S2B(cluster) && len > range[1]) range[1] -= start % S2B(cluster); - ploop_log(1, "Call BLKDISCARD start=%llu length=%llu ", range[0], range[1]); + ploop_log(1, "Call BLKDISCARD start=%llu length=%llu ", + (unsigned long long)range[0], + (unsigned long long)range[1]); ret = ioctl_device(fd, BLKDISCARD, range); if (ret) return ret; @@ -917,9 +919,12 @@ if (blk_discard_range != NULL) ploop_log(0, "Discard %s start=%llu length=%llu", - device, blk_discard_range[0], blk_discard_range[1]); + device, + (unsigned long long)blk_discard_range[0], + (unsigned long long)blk_discard_range[1]); else - ploop_log(3, "Trying to find free extents bigger than %llu bytes", minlen_b); + ploop_log(3, "Trying to find free extents bigger than %llu bytes", + (unsigned long long)minlen_b); if (ploop_lock_di(di)) return SYSEXIT_LOCK; Index: ploop-1.9/lib/gpt.c =================================================================== --- ploop-1.9.orig/lib/gpt.c 2013-10-31 19:50:00.137551247 +0100 +++ ploop-1.9/lib/gpt.c 2013-10-31 19:51:25.359218217 +0100 @@ -145,7 +145,8 @@ part.length = S2B(pe->ending_lba - pe->starting_lba + 1); ploop_log(3, "update partition table start=%llu length=%llu", - part.start, part.length); + (unsigned long long)part.start, + (unsigned long long)part.length); ioctl_arg.op = BLKPG_RESIZE_PARTITION; ioctl_arg.flags = 0; ioctl_arg.datalen = sizeof(struct blkpg_partition); @@ -183,7 +184,7 @@ if (new_size > size) { ploop_err(0, "Unable to resize GPT partition:" " incorrect parameter new_size=%llu size=%lu", - new_size, (long)size); + (unsigned long long)new_size, (long)size); return SYSEXIT_PARAM; } Index: ploop-1.9/lib/xml.c =================================================================== --- ploop-1.9.orig/lib/xml.c 2013-10-31 19:50:00.137551247 +0100 +++ ploop-1.9/lib/xml.c 2013-10-31 19:51:25.367217995 +0100 @@ -474,7 +474,7 @@ ploop_err(0, "Error at xmlTextWriter Disk_Parameters"); goto err; } - rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "Disk_size", "%llu", di->size); + rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "Disk_size", "%llu", (unsigned long long)di->size); if (rc < 0) { ploop_err(0, "Error at xmlTextWriter Disk_size"); goto err; @@ -491,7 +491,7 @@ goto err; } rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "Sectors", "%llu", - di->size /(di->cylinders * di->heads)); + (unsigned long long)(di->size /(di->cylinders * di->heads))); if (rc < 0) { ploop_err(0, "Error at xmlTextWriter Sectors"); goto err; @@ -527,7 +527,7 @@ ploop_err(0, "Error at xmlTextWriter Start"); goto err; } - rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "End", "%llu", di->size); + rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "End", "%llu", (unsigned long long)di->size); if (rc < 0) { ploop_err(0, "Error at xmlTextWriter End"); goto err; Index: ploop-1.9/lib/fsutils.c =================================================================== --- ploop-1.9.orig/lib/fsutils.c 2013-10-31 19:49:54.597702904 +0100 +++ ploop-1.9/lib/fsutils.c 2013-10-31 20:03:52.986751173 +0100 @@ -186,13 +186,13 @@ while (fgets(buf, sizeof(buf), fp) != NULL) { if ((found & BLOCK_COUNT_BIT) && - sscanf(buf, "Block count: %llu", &data->block_count) == 1) + sscanf(buf, "Block count: %llu", (unsigned long long *)&data->block_count) == 1) found &= ~BLOCK_COUNT_BIT; else if ((found & BLOCK_FREE_BIT) && - sscanf(buf, "Free blocks: %llu", &data->block_free) == 1) + sscanf(buf, "Free blocks: %llu", (unsigned long long *)&data->block_free) == 1) found &= ~BLOCK_FREE_BIT; else if ((found & BLOCK_SIZE_BIT) && - sscanf(buf, "Block size: %u", &data->block_size) == 1) + sscanf(buf, "Block size: %u", &data->block_size) == 1) found &= ~BLOCK_SIZE_BIT; } debian/patches/series0000664000000000000000000000002512256112674012037 0ustar ia64-build-fix.patch debian/patches/ia64-build-fix.patch0000664000000000000000000001767712257137524014316 0ustar Description: fix to make it build on ia64 There is a problem to build on ia64 due to the format used to print some values when the image is corrupted. Solved by casting. Author: Ola Lundqvist Origin: vendor Bug: https://bugzilla.openvz.org/show_bug.cgi?id=2790 Forwarded: https://bugzilla.openvz.org/show_bug.cgi?id=2790 Reviewed-By: Ola Lundqvist Last-Update: 2013-12-16 Index: ploop-1.10/lib/balloon_util.c =================================================================== --- ploop-1.10.orig/lib/balloon_util.c 2013-12-23 20:57:04.429171298 +0100 +++ ploop-1.10/lib/balloon_util.c 2013-12-27 00:36:12.000000000 +0100 @@ -273,14 +273,14 @@ ploop_err(0, "Image corrupted: L2[%u] == %u (max=%llu)", clu + j - l2_slot, delta->l2[j], - (rlen - 1) * B2S(cluster)); + (long long unsigned)((rlen - 1) * B2S(cluster))); return(SYSEXIT_PLOOPFMT); } if (ridx < delta->l1_size) { ploop_err(0, "Image corrupted: L2[%u] == %u (min=%llu)", clu + j - l2_slot, delta->l2[j], - delta->l1_size * B2S(cluster)); + (long long unsigned)(delta->l1_size * B2S(cluster))); return(SYSEXIT_PLOOPFMT); } @@ -538,14 +538,14 @@ ploop_err(0, "Image corrupted: L2[%u] == %u (max=%llu) (2)", clu, delta->l2[l2_slot], - (rlen - 1) * B2S(cluster)); + (long long unsigned)((rlen - 1) * B2S(cluster))); return SYSEXIT_PLOOPFMT; } if (ridx && ridx < delta->l1_size) { ploop_err(0, "Image corrupted: L2[%u] == %u (min=%llu) (2)", clu, delta->l2[l2_slot], - delta->l1_size * B2S(cluster)); + (long long unsigned)(delta->l1_size * B2S(cluster))); return SYSEXIT_PLOOPFMT; } Index: ploop-1.10/lib/balloon.c =================================================================== --- ploop-1.10.orig/lib/balloon.c 2013-12-23 20:57:04.429171298 +0100 +++ ploop-1.10/lib/balloon.c 2013-12-27 00:36:12.000000000 +0100 @@ -860,7 +860,7 @@ range.minlen = MAX(MAX_DISCARD_CLU * cluster, minlen_b); for (; range.minlen >= minlen_b; range.minlen /= 2) { - ploop_log(1, "Call FITRIM, for minlen=%lld", range.minlen); + ploop_log(1, "Call FITRIM, for minlen=%lld", (long long)range.minlen); ret = ioctl(fd, FITRIM, &range); if (ret < 0) { if (trim_stop) @@ -894,7 +894,9 @@ if (start % S2B(cluster) && len > range[1]) range[1] -= start % S2B(cluster); - ploop_log(1, "Call BLKDISCARD start=%llu length=%llu ", range[0], range[1]); + ploop_log(1, "Call BLKDISCARD start=%llu length=%llu ", + (unsigned long long)range[0], + (unsigned long long)range[1]); ret = ioctl_device(fd, BLKDISCARD, range); if (ret) return ret; @@ -918,9 +920,12 @@ if (blk_discard_range != NULL) ploop_log(0, "Discard %s start=%llu length=%llu", - device, blk_discard_range[0], blk_discard_range[1]); + device, + (unsigned long long)blk_discard_range[0], + (unsigned long long)blk_discard_range[1]); else - ploop_log(3, "Trying to find free extents bigger than %llu bytes", minlen_b); + ploop_log(3, "Trying to find free extents bigger than %llu bytes", + (unsigned long long)minlen_b); if (ploop_lock_di(di)) return SYSEXIT_LOCK; Index: ploop-1.10/lib/gpt.c =================================================================== --- ploop-1.10.orig/lib/gpt.c 2013-12-23 20:57:04.429171298 +0100 +++ ploop-1.10/lib/gpt.c 2013-12-27 00:36:12.000000000 +0100 @@ -147,7 +147,8 @@ part.length = S2B(pe->ending_lba - pe->starting_lba + 1); ploop_log(3, "update partition table start=%llu length=%llu", - part.start, part.length); + (unsigned long long)part.start, + (unsigned long long)part.length); ioctl_arg.op = BLKPG_RESIZE_PARTITION; ioctl_arg.flags = 0; ioctl_arg.datalen = sizeof(struct blkpg_partition); @@ -185,7 +186,7 @@ if (new_size > size) { ploop_err(0, "Unable to resize GPT partition:" " incorrect parameter new_size=%llu size=%lu", - new_size, (long)size); + (unsigned long long)new_size, (long)size); return SYSEXIT_PARAM; } Index: ploop-1.10/lib/xml.c =================================================================== --- ploop-1.10.orig/lib/xml.c 2013-12-23 20:57:04.429171298 +0100 +++ ploop-1.10/lib/xml.c 2013-12-27 00:36:12.000000000 +0100 @@ -474,7 +474,7 @@ ploop_err(0, "Error at xmlTextWriter Disk_Parameters"); goto err; } - rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "Disk_size", "%llu", di->size); + rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "Disk_size", "%llu", (unsigned long long)di->size); if (rc < 0) { ploop_err(0, "Error at xmlTextWriter Disk_size"); goto err; @@ -491,7 +491,7 @@ goto err; } rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "Sectors", "%llu", - di->size /(di->cylinders * di->heads)); + (unsigned long long)(di->size /(di->cylinders * di->heads))); if (rc < 0) { ploop_err(0, "Error at xmlTextWriter Sectors"); goto err; @@ -527,7 +527,7 @@ ploop_err(0, "Error at xmlTextWriter Start"); goto err; } - rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "End", "%llu", di->size); + rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "End", "%llu", (unsigned long long)di->size); if (rc < 0) { ploop_err(0, "Error at xmlTextWriter End"); goto err; Index: ploop-1.10/lib/fsutils.c =================================================================== --- ploop-1.10.orig/lib/fsutils.c 2013-12-27 00:34:13.755789570 +0100 +++ ploop-1.10/lib/fsutils.c 2013-12-27 00:36:12.000000000 +0100 @@ -121,7 +121,7 @@ if (max_online_resize > (__u32)~0) max_online_resize = (__u32)~0; snprintf(ext_opts, sizeof(ext_opts), "-Elazy_itable_init,resize=%llu", - max_online_resize); + (unsigned long long)max_online_resize); argv[5] = ext_opts; /* Set the journal size to 128M to allow online resize up to 16T * independly on the initial image size @@ -221,13 +221,13 @@ while (fgets(buf, sizeof(buf), fp) != NULL) { if ((found & BLOCK_COUNT_BIT) && - sscanf(buf, "Block count: %llu", &data->block_count) == 1) + sscanf(buf, "Block count: %llu", (unsigned long long *)&data->block_count) == 1) found &= ~BLOCK_COUNT_BIT; else if ((found & BLOCK_FREE_BIT) && - sscanf(buf, "Free blocks: %llu", &data->block_free) == 1) + sscanf(buf, "Free blocks: %llu", (unsigned long long *)&data->block_free) == 1) found &= ~BLOCK_FREE_BIT; else if ((found & BLOCK_SIZE_BIT) && - sscanf(buf, "Block size: %u", &data->block_size) == 1) + sscanf(buf, "Block size: %u", &data->block_size) == 1) found &= ~BLOCK_SIZE_BIT; } Index: ploop-1.10/lib/ploop.c =================================================================== --- ploop-1.10.orig/lib/ploop.c 2013-12-23 20:58:56.726228189 +0100 +++ ploop-1.10/lib/ploop.c 2013-12-27 00:36:12.000000000 +0100 @@ -286,7 +286,8 @@ if (sectors > max) { ploop_err(0, "An incorrect block device size is specified: %llu sectors." " The maximum allowed size is %llu sectors", - sectors, max); + (unsigned long long)sectors, + (unsigned long long)max); return -1; } return 0; @@ -2093,7 +2094,7 @@ ploop_err(0, "Unable to change image size to %lu " "sectors, minimal size is %llu", (long)new_fs_size, - (blocks - available_balloon_size)); + (unsigned long long)(blocks - available_balloon_size)); ret = SYSEXIT_PARAM; goto err; } Index: ploop-1.10/lib/check.c =================================================================== --- ploop-1.10.orig/lib/check.c 2013-12-16 21:52:57.000000000 +0000 +++ ploop-1.10/lib/check.c 2013-12-26 23:23:03.000000000 +0000 @@ -539,7 +539,7 @@ ploop_err(0, "Delta file %s contains uninitialized blocks" " (offset=%llu len=%llu)" " which are not aligned to cluster size", - image, fm_ext[i].fe_logical, fm_ext[i].fe_length); + image, (unsigned long long)fm_ext[i].fe_logical, (unsigned long long)fm_ext[i].fe_length); if (fill_hole(image, fd, fm_ext[i].fe_logical, fm_ext[i].fe_logical + fm_ext[i].fe_length, &log, repair)) debian/copyright0000664000000000000000000000206012204576167011133 0ustar Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: ploop Source: http://download.openvz.org/utils/ploop Files: * Copyright: 2008-2012, Parallels, Inc. License: GPL-2.0+ Files: debian/* Copyright: 2013 Ola Lundqvist License: GPL-2.0+ License: GPL-2.0+ This package is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. . This package is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. . You should have received a copy of the GNU General Public License along with this program. If not, see . On Debian systems, the complete text of the GNU General Public License version 2 can be found in "/usr/share/common-licenses/GPL-2". debian/ploop.install0000664000000000000000000000006712207037405011714 0ustar sbin/* usr/sbin/* usr/share/man/* usr/lib/tmpfiles.d/* debian/ploop.lintian-overrides0000664000000000000000000000100112207041206013663 0ustar ploop binary: binary-without-manpage sbin/mount.ploop ploop binary: binary-without-manpage sbin/umount.ploop ploop binary: binary-without-manpage usr/sbin/ploop-balloon ploop binary: binary-without-manpage usr/sbin/ploop-check ploop binary: binary-without-manpage usr/sbin/ploop-copy ploop binary: binary-without-manpage usr/sbin/ploop-fsck ploop binary: binary-without-manpage usr/sbin/ploop-grow ploop binary: binary-without-manpage usr/sbin/ploop-merge ploop binary: binary-without-manpage usr/sbin/ploop-stat debian/ploop.postinst0000664000000000000000000000172512207121244012126 0ustar #!/bin/sh # postinst script for ploop # # see: dh_installdeb(1) set -e # summary of how this script can be called: # * `configure' # * `abort-upgrade' # * `abort-remove' `in-favour' # # * `abort-remove' # * `abort-deconfigure' `in-favour' # `removing' # # for details, see http://www.debian.org/doc/debian-policy/ or # the debian-policy package case "$1" in configure) mkdir -p /var/lock/ploop ;; abort-upgrade|abort-remove|abort-deconfigure) ;; *) echo "postinst called with unknown argument \`$1'" >&2 exit 1 ;; esac # dh_installdeb will replace this with shell code automatically # generated by other debhelper scripts. #DEBHELPER# exit 0 debian/libploop1.install0000775000000000000000000000007312207205607012465 0ustar #!/usr/bin/dh-exec usr/lib/${DEB_HOST_MULTIARCH}/lib*.so.* debian/compat0000664000000000000000000000000212207203142010357 0ustar 9 debian/libploop-dev.install0000775000000000000000000000023012207205406013150 0ustar #!/usr/bin/dh-exec usr/include/* usr/lib/${DEB_HOST_MULTIARCH}/lib*.a usr/lib/${DEB_HOST_MULTIARCH}/lib*.so #usr/lib/pkgconfig/* #usr/share/pkgconfig/* debian/rules0000775000000000000000000000150112210403613010235 0ustar #!/usr/bin/make -f # -*- makefile -*- # Sample debian/rules that uses debhelper. # This file was originally written by Joey Hess and Craig Small. # As a special exception, when this file is copied by dh-make into a # dh-make output file, you may use that output file without restriction. # This special exception was added by Craig Small in version 0.37 of dh-make. # Uncomment this to turn on verbose mode. #export DH_VERBOSE=1 export DEB_BUILD_HARDENING=1 DEB_HOST_MULTIARCH ?= $(shell dpkg-architecture -qDEB_HOST_MULTIARCH) %: dh $@ #override_dh_auto_make: # $(MAKE) LIBDIR=/usr/lib/$(DEB_HOST_MULTIARCH) override_dh_auto_install: $(MAKE) DESTDIR=$$(pwd)/debian/tmp install rmdir debian/tmp/var/lock/ploop rmdir debian/tmp/var/lock rmdir debian/tmp/var override_dh_auto_clean: $(MAKE) clean $(MAKE) distclean debian/ploop.postrm0000664000000000000000000000177212224047131011572 0ustar #!/bin/sh # postrm script for ploop # # see: dh_installdeb(1) set -e # summary of how this script can be called: # * `remove' # * `purge' # * `upgrade' # * `failed-upgrade' # * `abort-install' # * `abort-install' # * `abort-upgrade' # * `disappear' # # for details, see http://www.debian.org/doc/debian-policy/ or # the debian-policy package case "$1" in upgrade|remove|failed-upgrade|abort-install|abort-upgrade|disappear) ;; purge) if [ -d /var/lock/ploop ] ; then rmdir /var/lock/ploop 2>/dev/null||true fi ;; *) echo "postrm called with unknown argument \`$1'" >&2 exit 1 ;; esac # dh_installdeb will replace this with shell code automatically # generated by other debhelper scripts. #DEBHELPER# exit 0 debian/control0000664000000000000000000000224012236000164010563 0ustar Source: ploop Section: libs Priority: extra Maintainer: Ola Lundqvist Build-Depends: debhelper (>= 9.0.0), e2fslibs-dev, libxml2-dev, dh-exec (>=0.3), hardening-wrapper, pkg-config Standards-Version: 3.9.3 Homepage: http://download.openvz.org/utils/ploop Vcs-Git: git://git.openvz.org/ploop Vcs-Browser: http://git.openvz.org/pub/ploop Package: ploop Architecture: linux-any Depends: ${shlibs:Depends}, ${misc:Depends}, libploop1 (= ${binary:Version}) Description: tools to work with ploop devices and images This package contains tools to work with ploop devices and images. Package: libploop-dev Section: libdevel Architecture: i386 ia64 amd64 powerpc sparc Depends: libploop1 (= ${binary:Version}), ${shlibs:Depends}, ${misc:Depends} Description: ploop API development library Headers and a static version of Parallels loopback (ploop) block device API library. Package: libploop1 Section: libs Architecture: linux-any Multi-Arch: same Depends: ${shlibs:Depends}, ${misc:Depends}, parted, util-linux, e2fsprogs Recommends: lsof, findutils Pre-Depends: ${misc:Pre-Depends} Description: ploop API library Parallels loopback (ploop) block device API library. debian/.pc/0000775000000000000000000000000012257136326007657 5ustar debian/.pc/.version0000664000000000000000000000000212256111602011322 0ustar 2 debian/.pc/.quilt_patches0000664000000000000000000000001012256111602012501 0ustar patches debian/.pc/.quilt_series0000664000000000000000000000000712256111602012352 0ustar series debian/.pc/applied-patches0000664000000000000000000000002512256111616012634 0ustar ia64-build-fix.patch debian/.pc/ia64-build-fix.patch~refresh0000664000000000000000000000000012256111616015061 0ustar debian/.pc/ia64-build-fix.patch/0000775000000000000000000000000012256111616013373 5ustar debian/.pc/lib/0000775000000000000000000000000012257136400010416 5ustar debian/.pc/lib/fsutils.c0000644000000000000000000001501512256112620012250 0ustar /* * Copyright (C) 2008-2013, Parallels, Inc. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include "ploop.h" #define __stringify_1(x...) #x #define __stringify(x...) __stringify_1(x) /* A macro to create a list of versions of an e2fs utility * (such as tune2fs, resize2fs or dumpe2fs) to look for, * ordered by priority: * 1 Our own private version from /usr/libexec * 2 A version from e4fsprogs (for RHEL5 systems) * 3 A standard one from /sbin * 4 Just a name without a path, letting run_prg() * to look it up in all the standard locations. */ #define GEN_E2FS_PROG(name) \ static char * name ## 2fs_progs[] = { \ "/usr/libexec/" __stringify(name) "2fs", \ "/sbin/" __stringify(name) "4fs", \ "/sbin/" __stringify(name) "2fs", \ __stringify(name) "2fs", \ NULL}; \ GEN_E2FS_PROG(tune) GEN_E2FS_PROG(resize) GEN_E2FS_PROG(dumpe) #undef GEN_E2FS_PROG static char *get_prog(char *progs[]) { int i; for (i = 0; progs[i] != NULL; i++) if (access(progs[i], X_OK) == 0) return progs[i]; /* the last in the list is default */ return progs[i - 1]; } int create_gpt_partition(const char *device, off_t size, __u32 blocksize) { unsigned long long start = blocksize; unsigned long long end = size - start - GPT_DATA_SIZE; char *argv[7]; char s1[22], s2[22]; if (size <= start + GPT_DATA_SIZE) { ploop_err(0, "Image size should be greater than %llu", start); return -1; } argv[0] = "parted"; argv[1] = "-s"; argv[2] = (char *)device; argv[3] = "mklabel gpt mkpart primary"; snprintf(s1, sizeof(s1), "%llus", (start >> 3) << 3); argv[4] = s1; snprintf(s2, sizeof(s2), "%llus", ((end >> 3) << 3) - 1); argv[5] = s2; argv[6] = NULL; if (run_prg(argv)) { ploop_err(0, "Failed to create partition"); return -1; } return 0; } int make_fs(const char *device, const char *fstype, unsigned int fsblocksize) { char part_device[64]; char fsblock_size[14]; char *argv[9]; char ext_opts[1024]; __u64 max_online_resize; fsblocksize = fsblocksize != 0 ? fsblocksize : 4096; if (get_partition_device_name(device, part_device, sizeof(part_device))) return SYSEXIT_MKFS; argv[0] = "mkfs"; argv[1] = "-t"; argv[2] = (char*)fstype; argv[3] = "-j"; snprintf(fsblock_size, sizeof(fsblock_size), "-b%u", fsblocksize); argv[4] = fsblock_size; /* Reserve enough space so that the block group descriptor table can grow to 16T * Note: the max_online_resize is __u32 in mkfs.ext4 */ max_online_resize = PLOOP_MAX_FS_SIZE / fsblocksize; if (max_online_resize > (__u32)~0) max_online_resize = (__u32)~0; snprintf(ext_opts, sizeof(ext_opts), "-Elazy_itable_init,resize=%llu", max_online_resize); argv[5] = ext_opts; /* Set the journal size to 128M to allow online resize up to 16T * independly on the initial image size */ argv[6] = "-Jsize=128"; argv[7] = part_device; argv[8] = NULL; if (run_prg(argv)) return SYSEXIT_MKFS; argv[0] = get_prog(tune2fs_progs); argv[1] = "-ouser_xattr,acl"; argv[2] = "-c0"; argv[3] = "-i0"; argv[4] = part_device; argv[5] = NULL; if (run_prg(argv)) return SYSEXIT_MKFS; return 0; } void tune_fs(const char *target, const char *device, unsigned long long size_sec) { unsigned long long reserved_blocks; struct statfs fs; char *argv[5]; char buf[21]; if (statfs(target, &fs) != 0) { ploop_err(errno, "tune_fs: can't statfs %s", target); return; } reserved_blocks = size_sec / 100 * 5 * 512 / fs.f_bsize; if (reserved_blocks == 0) { ploop_err(0, "Can't set reserved blocks for size %llu", size_sec); return; } argv[0] = get_prog(tune2fs_progs); argv[1] = "-r"; snprintf(buf, sizeof(buf), "%llu", reserved_blocks); argv[2] = buf; argv[3] = (char *)device; argv[4] = NULL; run_prg(argv); } int resize_fs(const char *device, off_t size_sec) { char *argv[5]; char buf[22]; argv[0] = get_prog(resize2fs_progs); argv[1] = "-p"; argv[2] = (char *)device; if (size_sec) { // align size to 4K snprintf(buf, sizeof(buf), "%luk", (long)(size_sec >> 3 << 3) >> 1); argv[3] = buf; } else argv[3] = NULL; argv[4] = NULL; if (run_prg(argv)) return SYSEXIT_RESIZE_FS; return 0; } enum { BLOCK_COUNT, BLOCK_FREE, BLOCK_SIZE, }; #define BLOCK_COUNT_BIT (1 << BLOCK_COUNT) #define BLOCK_FREE_BIT (1 << BLOCK_FREE) #define BLOCK_SIZE_BIT (1 << BLOCK_SIZE) int dumpe2fs(const char *device, struct dump2fs_data *data) { char cmd[512]; char buf[512]; FILE *fp; int found = BLOCK_COUNT_BIT | BLOCK_FREE_BIT | BLOCK_SIZE_BIT; snprintf(cmd, sizeof(cmd), "LANG=C " DEF_PATH_ENV " %s -h %s", get_prog(dumpe2fs_progs), device); fp = popen(cmd, "r"); if (fp == NULL) { ploop_err(0, "Failed %s", cmd); return SYSEXIT_SYS; } while (fgets(buf, sizeof(buf), fp) != NULL) { if ((found & BLOCK_COUNT_BIT) && sscanf(buf, "Block count: %llu", &data->block_count) == 1) found &= ~BLOCK_COUNT_BIT; else if ((found & BLOCK_FREE_BIT) && sscanf(buf, "Free blocks: %llu", &data->block_free) == 1) found &= ~BLOCK_FREE_BIT; else if ((found & BLOCK_SIZE_BIT) && sscanf(buf, "Block size: %u", &data->block_size) == 1) found &= ~BLOCK_SIZE_BIT; } if (pclose(fp)) { ploop_err(0, "failed %s", cmd); return SYSEXIT_SYS; } if (found) { ploop_err(0, "Not enough data: %s (0x%x)", cmd, found); return SYSEXIT_SYS; } return 0; } int e2fsck(const char *device, int flags) { char *arg[5]; int i = 0; int ret; arg[i++] = "fsck.ext4"; if (flags & E2FSCK_PREEN) arg[i++] = "-p"; if (flags & E2FSCK_FORCE) arg[i++] = "-f"; arg[i++] = (char *)device; arg[i++] = NULL; if (run_prg_rc(arg, &ret)) return SYSEXIT_FSCK; /* exit code < 4 is OK, see man e2fsck */ if (ret >= 4) { ploop_err(0, "e2fsck failed (exit code %d)\n", ret); return SYSEXIT_FSCK; } return 0; } debian/.pc/lib/check.c0000644000000000000000000003231312253673071011645 0ustar /* * Copyright (C) 2008-2012, Parallels, Inc. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ploop.h" static int check_and_repair_sparse(const char *image, int fd, __u64 cluster, int flags); enum { ZEROFIX = 0, IGNORE }; enum { NONFATAL = 0, FATAL }; enum { SOFT_FIX = 0, HARD_FIX }; struct ploop_check_desc { int fd; int ro; int hard_force; int check; off_t bd_size; off_t size; __u32 *bmap; int *clean; int *fatality; __u32 *alloc_head; }; static int read_safe(int fd, void * buf, unsigned int size, off_t pos, char *msg) { ssize_t res; res = pread(fd, buf, size, pos); if (res == size) return 0; if (res < 0) { ploop_err(errno, "%s", msg); return SYSEXIT_READ; } ploop_log(0, "Short %s", msg); return SYSEXIT_READ; } static int write_safe(int fd, void * buf, unsigned int size, off_t pos, char *msg) { ssize_t res; res = pwrite(fd, buf, size, pos); if (res == size) return 0; if (res < 0) { ploop_err(errno, "%s", msg); return SYSEXIT_WRITE; } ploop_log(0, "Short %s", msg); return SYSEXIT_WRITE; } static int fsync_safe(int fd) { if (fsync(fd)) { ploop_err(errno, "fsync"); return SYSEXIT_WRITE; } return 0; } static int close_safe(int fd) { if (close(fd)) { ploop_err(errno, "close"); return SYSEXIT_WRITE; } return 0; } static int zero_index(int fd, __u32 clu) { __u32 zero = 0; return write_safe(fd, &zero, sizeof(zero), clu * sizeof(clu) + sizeof(struct ploop_pvd_header), "write zero index"); } static int zero_index_fix(struct ploop_check_desc *d, __u32 clu, int hard_fix, int ignore, int fatal) { char *msg; int skip = d->ro; int ret = 0; if (hard_fix && !d->hard_force) skip = 1; if (skip) { msg = fatal ? "FATAL" : "Skipped"; *d->clean = 0; if (fatal) *d->fatality = 1; } else { msg = ignore ? "Ignored" : "Fixed"; if (!ignore) ret = zero_index(d->fd, clu); } ploop_log(0, "%s", msg); return ret; } static int check_one_slot(struct ploop_check_desc *d, __u32 clu, off_t isec, __u32 blocksize, int version) { __u64 cluster = S2B(blocksize); __u32 cluster_log = ffs(blocksize) - 1; __u32 iblk = isec >> cluster_log; if ((clu << cluster_log) > d->bd_size) { ploop_log(0, "Data cluster (%u) beyond block device size... ", clu); return zero_index_fix(d, clu, SOFT_FIX, ZEROFIX, NONFATAL); } if (version == PLOOP_FMT_V1 && (isec % (1 << cluster_log) != 0)) { ploop_log(0, "L2 slot (%u) corrupted... ", clu); return zero_index_fix(d, clu, HARD_FIX, ZEROFIX, FATAL); } if ((off_t)iblk * cluster + cluster > d->size) { ploop_log(0, "Data cluster %u beyond EOF, vsec=%u... ", iblk, clu); return zero_index_fix(d, clu, HARD_FIX, ZEROFIX, FATAL); } if (d->check) { if (d->bmap[iblk / 32] & (1 << (iblk % 32))) { ploop_log(0, "Block %u is used more than once, vsec=%u... ", iblk, clu); zero_index_fix(d, clu, HARD_FIX, IGNORE, FATAL); } d->bmap[iblk / 32] |= (1 << (iblk % 32)); } if (iblk > *d->alloc_head) *d->alloc_head = iblk; return 0; } int ploop_check(char *img, int flags, int ro, int raw, int verbose, __u32 *blocksize_p) { struct ploop_check_desc d; int i, j; int fd; int ret = 0; int ret2; off_t bd_size; struct stat stb; void *buf = NULL; __u32 *l2_ptr = NULL; struct ploop_pvd_header vh_buf; struct ploop_pvd_header *vh = &vh_buf; __u32 alloc_head; __u32 l1_slots; __u32 l2_slot = 0; __u32 m_Flags; __u32 *bmap = NULL; unsigned int bmap_size = 0; int fatality = 0; /* fatal errors detected */ int clean = 1; /* image is clean */ __u64 cluster; int force = (flags & CHECK_FORCE); int hard_force = (flags & CHECK_HARDFORCE); int check = (flags & CHECK_DETAILED); int version; fd = open(img, ro ? O_RDONLY : O_RDWR); if (fd < 0) { ploop_err(errno, "ploop_check: can't open %s", img); return SYSEXIT_OPEN; } if (raw) { if (!blocksize_p || !*blocksize_p) { ploop_err(0, "Cluster blocksize required for raw image"); ret = SYSEXIT_PARAM; goto done; } cluster = S2B(*blocksize_p); ret = 0; goto done; } if (fstat(fd, &stb)) { ploop_err(errno, "ploop_check: can't fstat %s", img); ret = SYSEXIT_OPEN; goto done; } ret = read_safe(fd, vh, sizeof(*vh), 0, "read PVD header"); if (ret) goto done; ret = SYSEXIT_PLOOPFMT; version = ploop1_version(vh); if (version == PLOOP_FMT_ERROR) { ploop_err(0, "Wrong signature in image %s", img); goto done; } if (vh->m_Type != PRL_IMAGE_COMPRESSED) { ploop_err(0, "Wrong type in image %s", img); goto done; } if (!is_valid_blocksize(vh->m_Sectors)) { ploop_err(0, "Wrong cluster size %d in image %s", vh->m_Sectors, img); goto done; } l1_slots = vh->m_FirstBlockOffset >> (ffs(vh->m_Sectors) - 1); if (vh->m_FirstBlockOffset % vh->m_Sectors != 0 || l1_slots == 0) { ploop_err(0, "Wrong first block offset in image %s", img); goto done; } if (blocksize_p != NULL) *blocksize_p = vh->m_Sectors; cluster = S2B(vh->m_Sectors); if (p_memalign(&buf, 4096, cluster)) { ret = SYSEXIT_MALLOC; goto done; } l2_ptr = (__u32*)buf; ret = 0; bd_size = get_SizeInSectors(vh); alloc_head = l1_slots - 1; if (!vh->m_DiskInUse && !force) { if (verbose) ploop_log(0, "Image is clean, check is skipped"); goto done; } if (vh->m_DiskInUse && (vh->m_Flags & CIF_FmtVersionConvert)) { ploop_err(0, "Image %s is in the changing version state", img); ret = SYSEXIT_EBUSY; goto done; } if (check) { bmap_size = (stb.st_size + cluster - 1)/(cluster); bmap_size = (bmap_size + 31)/8; bmap = malloc(bmap_size); if (bmap == NULL) { ploop_err(ENOMEM, "ploop_check: malloc"); if (verbose) { check = 0; } else { ret = SYSEXIT_MALLOC; goto done; } } if (check) { memset(bmap, 0, bmap_size); for (i = 0; i < l1_slots; i++) bmap[i / 32] |= 1 << (i % 32); } } /* in */ d.fd = fd; d.ro = ro; d.hard_force = hard_force; d.check = check; d.bd_size = bd_size; d.size = stb.st_size; /* out */ d.bmap = bmap; d.clean = &clean; d.fatality = &fatality; d.alloc_head = &alloc_head; for (i = 0; i < l1_slots; i++) { int skip = (i == 0) ? sizeof(*vh) / sizeof(__u32) : 0; ret = read_safe(fd, buf, cluster, i * cluster, "read index table"); if (ret) goto done; if (!ro && vh->m_DiskInUse) { ret = write_safe(fd, buf, cluster, i * cluster, "re-write index table"); if (ret) goto done; } for (j = skip; j < cluster/4; j++, l2_slot++) { if (l2_ptr[j] == 0) continue; ret = check_one_slot(&d, l2_slot, ploop_ioff_to_sec(l2_ptr[j], vh->m_Sectors, version), vh->m_Sectors, version); if (ret) goto done; } } alloc_head++; if (check) { for (i = 0; i < bmap_size/4; i++) { int k; if (bmap[i] == 0xFFFFFFFF) continue; if (i * 32 >= alloc_head) break; for (k = 0; k < 32 && k < alloc_head - i * 32; k++) { if (!(bmap[i] & (1 << k))) { ploop_log(0, "Hole at block %u", i*32 + k); } } } } if (fatality) { ploop_err(0, "Fatal errors were found, image %s is not repaired", img); ret = SYSEXIT_PLOOPFMT; goto done; } if ((off_t)alloc_head * cluster < stb.st_size) { if (!ro) { ploop_log(0, "Trimming tail"); if (ftruncate(fd, (off_t)alloc_head * cluster)) { ploop_err(errno, "ftruncate"); ret = SYSEXIT_FTRUNCATE; goto done; } } else { ploop_err(0, "Want to trim tail"); alloc_head = (stb.st_size + cluster - 1)/(cluster); } } if (alloc_head > l1_slots) m_Flags = vh->m_Flags & ~CIF_Empty; else m_Flags = vh->m_Flags | CIF_Empty; if (vh->m_DiskInUse != 0) { ploop_err(0, "Dirty flag is set"); if (!(flags & CHECK_DROPINUSE)) { ret = SYSEXIT_PLOOPINUSE; goto done; } } if (vh->m_Flags != m_Flags) ploop_err(0, "CIF_Empty flag is incorrect"); /* useless to repair header if content was not fixed */ if (!clean) { ret = SYSEXIT_PLOOPFMT; goto done; } /* the content is clean, only header checks remained */ if (vh->m_DiskInUse == 0 && vh->m_Flags == m_Flags) goto done; /* header needs fix but we can't */ if (ro) { ploop_err(0, "Image is clean but unable to fix the header on ro image"); ret = SYSEXIT_WRITE; goto done; } vh->m_DiskInUse = 0; vh->m_Flags = m_Flags; ret = write_safe(fd, vh, sizeof(*vh), 0, "write PVD header"); if (!ret) ret = fsync_safe(fd); done: if (ret == 0) ret = check_and_repair_sparse(img, fd, cluster, flags); ret2 = close_safe(fd); if (ret2 && !ret) ret = ret2; free(bmap); free(buf); return ret; } static int fill_hole(const char *image, int fd, off_t start, off_t end, int *log, int repair) { static char buf[0x100000]; off_t offset; if (!*log) { ploop_err(0, "%s: ploop image '%s' is sparse", repair ? "Warning" : "Error", image); if (!repair) return SYSEXIT_PLOOPFMT; *log = 1; ploop_log(0, "Reallocating sparse blocks back"); } ploop_log(1, "Filling hole at start=%lu len=%lu", (long unsigned)start, (long unsigned)(end - start)); bzero(buf, sizeof(buf)); for (offset = start; offset < end; offset += sizeof(buf)) { ssize_t n, len; len = end - offset; if (len > sizeof(buf)) len = sizeof(buf); n = pwrite(fd, buf, len, offset); if (n != len) { if (n >= 0) errno = EIO; ploop_err(errno, "Failed to write"); return SYSEXIT_WRITE; } } return fsync_safe(fd); } static int check_and_repair_sparse(const char *image, int fd, __u64 cluster, int flags) { int last; int i, ret; struct statfs sfs; struct stat st; __u64 prev_end; char buf[40960] = ""; struct fiemap *fiemap = (struct fiemap *)buf; struct fiemap_extent *fm_ext = &fiemap->fm_extents[0]; int log = 0; int count = (sizeof(buf) - sizeof(*fiemap)) / sizeof(struct fiemap_extent); int repair = flags & CHECK_REPAIR_SPARSE; ret = fstatfs(fd, &sfs); if (ret < 0) { ploop_err(errno, "Unable to statfs delta file %s", image); return SYSEXIT_FSTAT; } if (sfs.f_type != EXT4_SUPER_MAGIC) return 0; ret = fstat(fd, &st); if (ret < 0) { ploop_err(errno, "Unable to stat delta file %s", image); return SYSEXIT_FSTAT; } prev_end = 0; last = 0; while (!last && prev_end < st.st_size) { fiemap->fm_start = prev_end; fiemap->fm_length = st.st_size; fiemap->fm_flags = FIEMAP_FLAG_SYNC; fiemap->fm_extent_count = count; ret = ioctl_device(fd, FS_IOC_FIEMAP, (unsigned long) fiemap); if (ret) return ret; if (fiemap->fm_mapped_extents == 0) break; for (i = 0; i < fiemap->fm_mapped_extents; i++) { if (fm_ext[i].fe_flags & FIEMAP_EXTENT_LAST) last = 1; if ((fm_ext[i].fe_flags & FIEMAP_EXTENT_UNWRITTEN) && (fm_ext[i].fe_logical % cluster || fm_ext[i].fe_length % cluster)) { ploop_err(0, "Delta file %s contains uninitialized blocks" " (offset=%llu len=%llu)" " which are not aligned to cluster size", image, fm_ext[i].fe_logical, fm_ext[i].fe_length); if (fill_hole(image, fd, fm_ext[i].fe_logical, fm_ext[i].fe_logical + fm_ext[i].fe_length, &log, repair)) return SYSEXIT_PLOOPFMT; } if (fm_ext[i].fe_flags & ~(FIEMAP_EXTENT_LAST | FIEMAP_EXTENT_UNWRITTEN)) ploop_log(1, "Warning: extent with unexpected flags 0x%x", fm_ext[i].fe_flags); if (prev_end != fm_ext[i].fe_logical && fill_hole(image, fd, prev_end, fm_ext[i].fe_logical, &log, repair)) return SYSEXIT_PLOOPFMT; prev_end = fm_ext[i].fe_logical + fm_ext[i].fe_length; } } if (prev_end < st.st_size && fill_hole(image, fd, prev_end, st.st_size, &log, repair)) return SYSEXIT_PLOOPFMT; return 0; } int check_deltas(struct ploop_disk_images_data *di, char **images, struct ploop_mount_param *param, int raw, __u32 *blocksize) { int i; int ret = 0; for (i = 0; images[i] != NULL; i++) { int ro; int flags = CHECK_DETAILED | (di ? (CHECK_DROPINUSE | CHECK_REPAIR_SPARSE) : 0); int raw_delta = (raw && i == 0); __u32 cur_blocksize = raw_delta ? *blocksize : 0; ro = (images[i+1] != NULL || param->ro) ? 1 : 0; ret = ploop_check(images[i], flags, ro, raw_delta, 0, &cur_blocksize); if (ret) { ploop_err(0, "%s (%s): irrecoverable errors", images[i], ro ? "ro" : "rw"); break; } if (*blocksize == 0) *blocksize = cur_blocksize; if (cur_blocksize != *blocksize) { ploop_err(0, "Incorrect blocksize %s bs=%d [current bs=%d]", images[i], *blocksize, cur_blocksize); ret = SYSEXIT_PARAM; break; } } return ret; } debian/changelog0000664000000000000000000000561712257137626011066 0ustar ploop (1.10-2) unstable; urgency=low * Fix ia64 build. -- Ola Lundqvist Fri, 27 Dec 2013 00:45:05 +0100 ploop (1.10-1) unstable; urgency=low * New upstream release. Now upstream includes the solution for #728173. -- Ola Lundqvist Mon, 23 Dec 2013 14:05:46 +0100 ploop (1.9-10) unstable; urgency=medium * Added parted, e2fsprogs and util-linux to the dependencies for libploop1. * Added recommendation for lsof and findutils (they are only used in special error cases). -- Ola Lundqvist Mon, 04 Nov 2013 21:19:10 +0100 ploop (1.9-9) unstable; urgency=low * Finally it is possible to build on ia64. Verified on a porter box. -- Ola Lundqvist Thu, 31 Oct 2013 19:48:35 +0100 ploop (1.9-8) unstable; urgency=low * One more fix for ia64. This time it is the '%lld' macro. -- Ola Lundqvist Thu, 31 Oct 2013 17:29:58 +0100 ploop (1.9-7) unstable; urgency=low * Build on ia64 is harder than it looks. More files need to be patched. -- Ola Lundqvist Wed, 30 Oct 2013 21:38:20 +0100 ploop (1.9-6) unstable; urgency=low * The previous fix for ia64 was not good enough. Better fix this time. -- Ola Lundqvist Wed, 30 Oct 2013 20:00:38 +0100 ploop (1.9-5) unstable; urgency=low * Fixed build problem on ia64 architecture. -- Ola Lundqvist Wed, 30 Oct 2013 19:18:19 +0100 ploop (1.9-4) unstable; urgency=low * Applied a patch from upstream that solves the problem with builds on architectures other than i386 and amd64, reported by Aaron M. Ucko . Closes: #728173. * Made the package arhitecture linux-any based on the information from upstream that there is nothing that should prevent it from being architecture agnostic. -- Ola Lundqvist Tue, 29 Oct 2013 21:12:00 +0100 ploop (1.9-3) unstable; urgency=low * Added dependency on pkg-config to make sure it builds in a minimal build environment. Closes: #728172. * Limited the architectures to i386 ia64 amd64 powerpc sparc which is the same as vzctl is limited to. Closes: #728174. -- Ola Lundqvist Tue, 29 Oct 2013 18:24:50 +0100 ploop (1.9-2) unstable; urgency=low * Applied patch from upstream to make sure /var/lock/ploop directory is created. -- Ola Lundqvist Sat, 05 Oct 2013 11:50:45 +0200 ploop (1.9-1) unstable; urgency=low * New upstream release. * Added hardening-wrapper to build depends. * Applied a patch from git to make this source build with hardening on. * Fixed possible rmdir error in postrm and prerm scripts. -- Ola Lundqvist Tue, 10 Sep 2013 14:21:02 +0200 ploop (1.8-1) unstable; urgency=low * Initial release (Closes: #720292) * Support for multiarch. -- Ola Lundqvist Tue, 20 Aug 2013 07:05:12 +0200