[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: [Libvir] PATCH: 14/16: disk partition backend



This implements a storage pool for partitioning local disks.
It uses parted as the tool for reading & writing disk partitions.
Since parted is GPLv3, we cannot link against the code directly.
So, this driver calls out to the regular 'parted' command line
tool for creationg/deletion. For listing of partiitons we have
a trivial helper program '/usr/libexec/libvirt_parthelper'. This
outputs partition listing in a easily parseable format - each
partition, or free space extent is a record, containing 5 fields.
Records and fields are separated by NULLs. The internal libvirt
helper API virStorageBackendRunProgNul can reliably parse this
data format (thanks to Jim for the suggestion of using NULLs
instead of whitespace, since the latter is not so easy to protect
against bogus files)

Creating volumes from disk partitions is more complex than most
of the drivers. This is because partition tables have quite
strict placement constraints. There are free extent regions
and a partition must fall within one, and further more be aligned
to a suitable byte boundary. For this reason the pool XML format
will contain information about the free extents on a disk. The
volume XML will also detail the actual extents used by a partition
on disk.

All of the parted partition table types are supported. A new disk
can be initialized with the 'build' operation which will write a
new partition table. When creating volumes a partition entry type
can be specified if required. For simply assigning volumes to guests
though, it is not neccessary to use anything other than the default
of 'none'.

 .hgignore                    |    1 
 b/src/parthelper.c           |  127 ++++++++++
 b/src/storage_backend_disk.c |  508 +++++++++++++++++++++++++++++++++++++++++++
 b/src/storage_backend_disk.h |   45 +++
 configure.in                 |   48 ++++
 libvirt.spec.in              |    5 
 src/Makefile.am              |   18 +
 src/storage_backend.c        |   14 +
 8 files changed, 766 insertions(+)

diff -r 4c283aac5fd6 .hgignore
--- a/.hgignore	Thu Feb 07 14:17:57 2008 -0500
+++ b/.hgignore	Thu Feb 07 16:51:32 2008 -0500
@@ -18,6 +18,7 @@ Makefile\.in$
 ^src/virsh
 ^src/libvirt.la
 ^src/\.libs
+^src/parthelper
 ^aclocal.m4$
 ^docs/devhelp/libvirt.devhelp$
 ^libtool$
diff -r 4c283aac5fd6 configure.in
--- a/configure.in	Thu Feb 07 14:17:57 2008 -0500
+++ b/configure.in	Thu Feb 07 16:51:32 2008 -0500
@@ -27,6 +27,7 @@ GNUTLS_REQUIRED="1.0.25"
 GNUTLS_REQUIRED="1.0.25"
 AVAHI_REQUIRED="0.6.0"
 POLKIT_REQUIRED="0.6"
+PARTED_REQUIRED="1.8.0"
 
 dnl Checks for C compiler.
 AC_PROG_CC
@@ -563,6 +564,8 @@ AC_ARG_WITH(storage-lvm,
 [  --with-storage-lvm          with LVM backend for the storage driver (on)],[],[with_storage_lvm=check])
 AC_ARG_WITH(storage-iscsi,
 [  --with-storage-iscsi        with iSCSI backend for the storage driver (on)],[],[with_storage_iscsi=check])
+AC_ARG_WITH(storage-disk,
+[  --with-storage-disk         with GPartd Disk backend for the storage driver (on)],[],[with_storage_disk=check])
 
 if test "$with_storage_fs" = "yes" -o "$with_storage_fs" = "check"; then
   AC_PATH_PROG(MOUNT, [mount], [], [$PATH:/sbin:/usr/sbin])
@@ -674,6 +677,50 @@ if test "$with_storage_iscsi" = "yes" -o
   fi
 fi
 AM_CONDITIONAL(WITH_STORAGE_ISCSI, [test "$with_storage_iscsi" = "yes"])
+
+
+
+LIBPARTED_CFLAGS=
+LIBPARTED_LIBS=
+if test "$with_storage_disk" = "yes" -o "$with_storage_disk" = "check"; then
+  AC_PATH_PROG(PARTED, [parted], [], [$PATH:/sbin:/usr/sbin])
+  if test -z "$PARTED" ; then with_storage_disk=no ; fi
+
+  PARTED_FOUND=yes
+  if test "$with_storage_disk" != "no" -a "x$PKG_CONFIG" != "x" ; then
+    PKG_CHECK_MODULES(LIBPARTED, libparted >= $PARTED_REQUIRED, [], [PARTED_FOUND=no])
+  fi
+  if test "$PARTED_FOUND" = "no"; then
+    # RHEL-5 vintage parted is missing pkg-config files
+    save_LIBS="$LIBS"
+    save_CFLAGS="$CFLAGS"
+    PARTED_FOUND=yes
+    AC_CHECK_HEADER(parted/parted.h,,[PARTED_FOUND=no])
+    AC_CHECK_LIB(uuid, uuid_generate,,[PARTED_FOUND=no])
+    AC_CHECK_LIB(parted, ped_device_read,,[PARTED_FOUND=no])
+    LIBPARTED_LIBS="-luuid -lparted"
+    LIBS="$save_LIBS"
+    CFLAGS="$save_CFLAGS"
+  fi
+
+  if test "$PARTED_FOUND" = "no" ; then
+    if test "$with_storage_disk" = "yes" ; then
+      AC_MSG_ERROR(We need parted for disk storage driver)
+    else
+      with_storage_disk=no
+    fi
+  else
+    with_storage_disk=yes
+  fi
+
+  if test "$with_storage_disk" = "yes"; then
+    AC_DEFINE_UNQUOTED(WITH_STORAGE_DISK, 1, [whether Disk backend for storage driver is enabled])
+    AC_DEFINE_UNQUOTED([PARTED],["$PARTED"], [Location or name of the parted program])
+  fi
+fi
+AM_CONDITIONAL(WITH_STORAGE_DISK, [test "$with_storage_disk" = "yes"])
+AC_SUBST(LIBPARTED_CFLAGS)
+AC_SUBST(LIBPARTED_LIBS)
 
 
 dnl
@@ -891,6 +938,7 @@ AC_MSG_NOTICE([   NetFS: $with_storage_f
 AC_MSG_NOTICE([   NetFS: $with_storage_fs])
 AC_MSG_NOTICE([     LVM: $with_storage_lvm])
 AC_MSG_NOTICE([   iSCSI: $with_storage_iscsi])
+AC_MSG_NOTICE([    Disk: $with_storage_disk])
 AC_MSG_NOTICE([])
 AC_MSG_NOTICE([Libraries])
 AC_MSG_NOTICE([])
diff -r 4c283aac5fd6 libvirt.spec.in
--- a/libvirt.spec.in	Thu Feb 07 14:17:57 2008 -0500
+++ b/libvirt.spec.in	Thu Feb 07 16:51:32 2008 -0500
@@ -53,6 +53,8 @@ Requires: lvm2
 Requires: lvm2
 # For ISCSI driver
 Requires: iscsi-initiator-utils
+# For disk driver
+Requires: parted
 BuildRequires: xen-devel
 BuildRequires: libxml2-devel
 BuildRequires: readline-devel
@@ -81,6 +83,8 @@ BuildRequires: lvm2
 BuildRequires: lvm2
 # For ISCSI driver
 BuildRequires: iscsi-initiator-utils
+# For disk driver
+BuildRequires: parted-devel
 Obsoletes: libvir
 ExclusiveArch: i386 x86_64 ia64
 
@@ -203,6 +207,7 @@ fi
 %if %{with_proxy} == "yes"
 %attr(4755, root, root) %{_libexecdir}/libvirt_proxy
 %endif
+%attr(0755, root, root) %{_libexecdir}/libvirt_parthelper
 %attr(0755, root, root) %{_sbindir}/libvirtd
 %doc docs/*.rng
 %doc docs/*.xml
diff -r 4c283aac5fd6 src/Makefile.am
--- a/src/Makefile.am	Thu Feb 07 14:17:57 2008 -0500
+++ b/src/Makefile.am	Thu Feb 07 16:51:32 2008 -0500
@@ -81,6 +81,13 @@ EXTRA_DIST +=  storage_backend_iscsi.h s
 EXTRA_DIST +=  storage_backend_iscsi.h storage_backend_iscsi.c
 endif
 
+if WITH_STORAGE_DISK
+CLIENT_SOURCES += storage_backend_disk.h storage_backend_disk.c
+else
+EXTRA_DIST += storage_backend_disk.h storage_backend_disk.c
+endif
+
+
 
 
 libvirt_la_SOURCES = $(CLIENT_SOURCES) $(SERVER_SOURCES)
@@ -100,6 +107,17 @@ virsh_LDADD = $(LDADDS) $(VIRSH_LIBS)
 virsh_LDADD = $(LDADDS) $(VIRSH_LIBS)
 virsh_CFLAGS = $(COVERAGE_CFLAGS) $(READLINE_CFLAGS)
 
+if WITH_STORAGE_DISK
+libexec_PROGRAMS = libvirt_parthelper
+
+libvirt_parthelper_SOURCES = parthelper.c
+libvirt_parthelper_LDFLAGS = $(WARN_CFLAGS) $(COVERAGE_LDCFLAGS)
+libvirt_parthelper_LDADD = $(LIBPARTED_LIBS)
+libvirt_parthelper_CFLAGS =  $(LIBPARTED_CFLAGS)
+else
+EXTRA_DIST += parthelper.c
+endif
+
 #
 # target to ease building test programs
 #
diff -r 4c283aac5fd6 src/parthelper.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/parthelper.c	Thu Feb 07 16:51:32 2008 -0500
@@ -0,0 +1,127 @@
+/*
+ * parthelper.c: Helper program to talk to parted with.
+ *
+ * This helper exists because parted is GPLv3+, while libvirt is LGPLv2+.
+ * Thus we can't link to parted in libvirt.so without the combined work
+ * being GPLv3+. Thus we separate via an external command. NB, this source
+ * code is still LGPLv2+, but the binary helper is effectively GPLv3+
+ *
+ * The existing 'parted' command line tool is also incredibly hard to parse
+ * in a reliable fashion if merely after a list of partitions & sizes,
+ * though it is fine for creating partitions.
+ *
+ * Copyright (C) 2007-2008 Red Hat, Inc.
+ * Copyright (C) 2007-2008 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange redhat com>
+ */
+
+#include <config.h>
+
+#include <parted/parted.h>
+#include <stdio.h>
+
+int main(int argc, char **argv)
+{
+    PedDevice *dev;
+    PedDisk *disk;
+    PedPartition *part;
+
+    if (argc !=  2) {
+        fprintf(stderr, "syntax: %s DEVICE\n", argv[0]);
+        return 1;
+    }
+
+    if ((dev = ped_device_get(argv[1])) == NULL) {
+        fprintf(stderr, "unable to access device %s\n", argv[1]);
+        return 2;
+    }
+
+    if ((disk = ped_disk_new(dev)) == NULL) {
+        fprintf(stderr, "unable to access disk %s\n", argv[1]);
+        return 2;
+    }
+
+    /* Get the first partition, and then iterate over all */
+    part = ped_disk_get_partition(disk, 1);
+    while (part) {
+        const char *type;
+        const char *content;
+        if (part->type & PED_PARTITION_LOGICAL) {
+            type = "logical";
+            if (part->type & PED_PARTITION_FREESPACE)
+                content = "free";
+            else if (part->type & PED_PARTITION_METADATA)
+                content = "metadata";
+            else if (part->type & PED_PARTITION_PROTECTED)
+                content = "protected";
+            else
+                content = "data";
+        } else if (part->type == PED_PARTITION_EXTENDED) {
+            type = "extended";
+            content = "metadata";
+        } else {
+            type = "normal";
+            if (part->type & PED_PARTITION_FREESPACE)
+                content = "free";
+            else if (part->type & PED_PARTITION_METADATA)
+                content = "metadata";
+            else if (part->type & PED_PARTITION_PROTECTED)
+                content = "protected";
+            else
+                content = "data";
+        }
+
+        /* We do +1 on geom.end, because we want end of the last sector
+         * in bytes, not the last sector number
+         */
+        if (part->num != -1) {
+            printf("%s%d%c%s%c%s%c%llu%c%llu%c%llu%c",
+                   part->geom.dev->path,
+                   part->num, '\0',
+                   type, '\0',
+                   content, '\0',
+                   part->geom.start * 512llu, '\0',
+                   (part->geom.end + 1 ) * 512llu, '\0',
+                   part->geom.length * 512llu, '\0');
+        } else {
+            printf("%s%c%s%c%s%c%llu%c%llu%c%llu%c",
+                   "-", '\0',
+                   type, '\0',
+                   content, '\0',
+                   part->geom.start * 512llu, '\0',
+                   (part->geom.end + 1 ) * 512llu, '\0',
+                   part->geom.length * 512llu, '\0');
+        }
+        part = ped_disk_next_partition(disk, part);
+    }
+
+    return 0;
+}
+/*
+ * vim: set tabstop=4:
+ * vim: set shiftwidth=4:
+ * vim: set expandtab:
+ */
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff -r 4c283aac5fd6 src/storage_backend.c
--- a/src/storage_backend.c	Thu Feb 07 14:17:57 2008 -0500
+++ b/src/storage_backend.c	Thu Feb 07 16:51:32 2008 -0500
@@ -42,6 +42,9 @@
 #if WITH_STORAGE_ISCSI
 #include "storage_backend_iscsi.h"
 #endif
+#if WITH_STORAGE_DISK
+#include "storage_backend_disk.h"
+#endif
 
 
 #include "util.h"
@@ -60,6 +63,9 @@ static virStorageBackendPtr backends[] =
 #endif
 #if WITH_STORAGE_ISCSI
     &virStorageBackendISCSI,
+#endif
+#if WITH_STORAGE_DISK
+    &virStorageBackendDisk,
 #endif
 };
 
@@ -105,6 +111,10 @@ int virStorageBackendFromString(const ch
 #if WITH_STORAGE_ISCSI
     if (STREQ(type, "iscsi"))
         return VIR_STORAGE_POOL_ISCSI;
+#endif
+#if WITH_STORAGE_DISK
+    if (STREQ(type, "disk"))
+        return VIR_STORAGE_POOL_DISK;
 #endif
     virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "unknown storage backend type %s", type);
     return -1;
@@ -127,6 +137,10 @@ const char *virStorageBackendToString(in
 #if WITH_STORAGE_ISCSI
     case VIR_STORAGE_POOL_ISCSI:
         return "iscsi";
+#endif
+#if WITH_STORAGE_DISK
+    case VIR_STORAGE_POOL_DISK:
+        return "disk";
 #endif
     }
 
diff -r 4c283aac5fd6 src/storage_backend_disk.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/storage_backend_disk.c	Thu Feb 07 16:51:32 2008 -0500
@@ -0,0 +1,508 @@
+/*
+ * storage_backend_disk.c: storage backend for disk handling
+ *
+ * Copyright (C) 2007-2008 Red Hat, Inc.
+ * Copyright (C) 2007-2008 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange redhat com>
+ */
+
+#include <config.h>
+
+#include "storage_backend_disk.h"
+#include "util.h"
+
+enum {
+    VIR_STORAGE_POOL_DISK_DOS = 0,
+    VIR_STORAGE_POOL_DISK_DVH,
+    VIR_STORAGE_POOL_DISK_GPT,
+    VIR_STORAGE_POOL_DISK_MAC,
+    VIR_STORAGE_POOL_DISK_BSD,
+    VIR_STORAGE_POOL_DISK_PC98,
+    VIR_STORAGE_POOL_DISK_SUN,
+};
+
+/*
+ * XXX these are basically partition types.
+ *
+ * fdisk has a bazillion partition ID types
+ * parted has practically none, and splits the
+ * info across 3 different attributes.
+ *
+ * So this is a semi-generic set
+ */
+enum {
+    VIR_STORAGE_VOL_DISK_NONE = 0,
+    VIR_STORAGE_VOL_DISK_LINUX,
+    VIR_STORAGE_VOL_DISK_FAT16,
+    VIR_STORAGE_VOL_DISK_FAT32,
+    VIR_STORAGE_VOL_DISK_LINUX_SWAP,
+    VIR_STORAGE_VOL_DISK_LINUX_LVM,
+    VIR_STORAGE_VOL_DISK_LINUX_RAID,
+    VIR_STORAGE_VOL_DISK_EXTENDED,
+};
+
+#define PARTHELPER BINDIR "/libvirt_parthelper"
+
+static int virStorageBackendDiskPoolFormatFromString(virConnectPtr conn,
+                                                     const char *format) {
+    if (format == NULL)
+        return VIR_STORAGE_POOL_DISK_DOS;
+
+    if (STREQ(format, "dos"))
+        return VIR_STORAGE_POOL_DISK_DOS;
+    if (STREQ(format, "dvh"))
+        return VIR_STORAGE_POOL_DISK_DVH;
+    if (STREQ(format, "gpt"))
+        return VIR_STORAGE_POOL_DISK_GPT;
+    if (STREQ(format, "mac"))
+        return VIR_STORAGE_POOL_DISK_MAC;
+    if (STREQ(format, "bsd"))
+        return VIR_STORAGE_POOL_DISK_BSD;
+    if (STREQ(format, "pc98"))
+        return VIR_STORAGE_POOL_DISK_PC98;
+    if (STREQ(format, "sun"))
+        return VIR_STORAGE_POOL_DISK_SUN;
+
+    virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "unsupported pool format %s", format);
+    return -1;
+}
+
+static const char *virStorageBackendDiskPoolFormatToString(virConnectPtr conn,
+                                                           int format) {
+    switch (format) {
+    case VIR_STORAGE_POOL_DISK_DOS:
+        return "dos";
+    case VIR_STORAGE_POOL_DISK_DVH:
+        return "dvh";
+    case VIR_STORAGE_POOL_DISK_GPT:
+        return "gpt";
+    case VIR_STORAGE_POOL_DISK_MAC:
+        return "mac";
+    case VIR_STORAGE_POOL_DISK_BSD:
+        return "bsd";
+    case VIR_STORAGE_POOL_DISK_PC98:
+        return "pc98";
+    case VIR_STORAGE_POOL_DISK_SUN:
+        return "sun";
+    }
+
+    virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "unsupported pool format %d", format);
+    return NULL;
+}
+
+static int virStorageBackendDiskVolFormatFromString(virConnectPtr conn,
+                                                    const char *format) {
+    if (format == NULL)
+        return VIR_STORAGE_VOL_DISK_NONE;
+
+    if (STREQ(format, "none"))
+        return VIR_STORAGE_VOL_DISK_NONE;
+    if (STREQ(format, "linux"))
+        return VIR_STORAGE_VOL_DISK_LINUX;
+    if (STREQ(format, "fat16"))
+        return VIR_STORAGE_VOL_DISK_FAT16;
+    if (STREQ(format, "fat32"))
+        return VIR_STORAGE_VOL_DISK_FAT32;
+    if (STREQ(format, "linux-swap"))
+        return VIR_STORAGE_VOL_DISK_LINUX_SWAP;
+    if (STREQ(format, "linux-lvm"))
+        return VIR_STORAGE_VOL_DISK_LINUX_LVM;
+    if (STREQ(format, "linux-raid"))
+        return VIR_STORAGE_VOL_DISK_LINUX_RAID;
+    if (STREQ(format, "extended"))
+        return VIR_STORAGE_VOL_DISK_EXTENDED;
+
+    virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "unsupported volume format %s", format);
+    return -1;
+}
+
+static const char *virStorageBackendDiskVolFormatToString(virConnectPtr conn,
+                                                          int format) {
+    switch (format) {
+    case VIR_STORAGE_VOL_DISK_NONE:
+        return "none";
+    case VIR_STORAGE_VOL_DISK_LINUX:
+        return "linux";
+    case VIR_STORAGE_VOL_DISK_FAT16:
+        return "fat16";
+    case VIR_STORAGE_VOL_DISK_FAT32:
+        return "fat32";
+    case VIR_STORAGE_VOL_DISK_LINUX_SWAP:
+        return "swap";
+    case VIR_STORAGE_VOL_DISK_LINUX_LVM:
+        return "lvm";
+    case VIR_STORAGE_VOL_DISK_LINUX_RAID:
+        return "raid";
+    case VIR_STORAGE_VOL_DISK_EXTENDED:
+        return "extended";
+    }
+
+    virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "unsupported volume format %d", format);
+    return NULL;
+}
+
+static int virStorageBackendDiskMakeDataVol(virConnectPtr conn,
+                                            virStoragePoolObjPtr pool,
+                                            char **const groups,
+                                            virStorageVolDefPtr vol)
+{
+    char *tmp, *devpath;
+
+    if (vol == NULL) {
+        if ((vol = calloc(1, sizeof(virStorageVolDef))) == NULL) {
+            virStorageReportError(conn, VIR_ERR_NO_MEMORY, "volume");
+            return -1;
+        }
+
+        vol->next = pool->volumes;
+        pool->volumes = vol;
+        pool->nvolumes++;
+
+        /* Prepended path will be same for all partitions, so we can
+         * strip the path to form a reasonable pool-unique name
+         */
+        tmp = strrchr(groups[0], '/');
+        if ((vol->name = strdup(tmp ? tmp + 1 : groups[0])) == NULL) {
+            virStorageReportError(conn, VIR_ERR_NO_MEMORY, "volume");
+            return -1;
+        }
+    }
+
+    if (vol->target.path == NULL) {
+        if ((devpath = strdup(groups[0])) == NULL) {
+            virStorageReportError(conn, VIR_ERR_NO_MEMORY, "volume");
+            return -1;
+        }
+
+        /* Now figure out the stable path
+         *
+         * XXX this method is O(N) because it scans the pool target
+         * dir every time its run. Should figure out a more efficient
+         * way of doing this...
+         */
+        if ((vol->target.path = virStorageBackendStablePath(conn, pool, devpath)) == NULL)
+            return -1;
+
+        if (devpath != vol->target.path)
+            free(devpath);
+        devpath = NULL;
+    }
+
+    if (vol->key == NULL) {
+        /* XXX base off a unique key of the underlying disk */
+        if ((vol->key = strdup(vol->target.path)) == NULL) {
+            virStorageReportError(conn, VIR_ERR_NO_MEMORY, "volume");
+            return -1;
+        }
+    }
+
+    if (vol->source.extents == NULL) {
+        if ((vol->source.extents = calloc(1, sizeof(*(vol->source.extents)))) == NULL) {
+            virStorageReportError(conn, VIR_ERR_NO_MEMORY, "volume extents");
+            return -1;
+        }
+        vol->source.nextent = 1;
+
+        if (xstrtol_ull(groups[3], NULL, 10,
+                        &vol->source.extents[0].start) < 0) {
+            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "cannot parse device start location");
+            return -1;
+        }
+
+        if (xstrtol_ull(groups[4], NULL, 10,
+                        &vol->source.extents[0].end) < 0) {
+            virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "cannot parse device end location");
+            return -1;
+        }
+
+        if ((vol->source.extents[0].path = strdup(pool->def->source.devices[0].path)) == NULL) {
+            virStorageReportError(conn, VIR_ERR_NO_MEMORY, "extents");
+            return -1;
+        }
+    }
+
+    /* Refresh allocation/capacity/perms */
+    if (virStorageBackendUpdateVolInfo(conn, vol, 1) < 0)
+        return -1;
+
+    /* The above gets allocation wrong for extended partitions, so overwrite it */
+    vol->allocation = vol->capacity = (vol->source.extents[0].end - vol->source.extents[0].start);
+
+    if (STRNEQ(groups[2], "metadata"))
+        pool->def->allocation += vol->allocation;
+    if (vol->source.extents[0].end > pool->def->capacity)
+        pool->def->capacity = vol->source.extents[0].end;
+
+    return 0;
+}
+
+static int virStorageBackendDiskMakeFreeExtent(virConnectPtr conn ATTRIBUTE_UNUSED,
+                                               virStoragePoolObjPtr pool,
+                                               char **const groups)
+{
+    virStoragePoolSourceDeviceExtentPtr tmp;
+    virStoragePoolSourceDevicePtr dev = &pool->def->source.devices[0];
+
+    if ((tmp = realloc(dev->freeExtents,
+                       sizeof(*tmp) * (dev->nfreeExtent+1))) == NULL)
+        return -1;
+    dev->freeExtents = tmp;
+
+    memset(dev->freeExtents +
+           dev->nfreeExtent, 0, sizeof(*tmp));
+
+    if (xstrtol_ull(groups[3], NULL, 10,
+                    &dev->freeExtents[dev->nfreeExtent].start) < 0)
+        return -1; /* Don't bother to re-alloc freeExtents - it'll be free'd shortly */
+
+    if (xstrtol_ull(groups[4], NULL, 10,
+                    &dev->freeExtents[dev->nfreeExtent].end) < 0)
+        return -1; /* Don't bother to re-alloc freeExtents - it'll be free'd shortly */
+
+    pool->def->available +=
+        (dev->freeExtents[dev->nfreeExtent].end -
+         dev->freeExtents[dev->nfreeExtent].start);
+    if (dev->freeExtents[dev->nfreeExtent].end > pool->def->capacity)
+        pool->def->capacity = dev->freeExtents[dev->nfreeExtent].end;
+
+    dev->nfreeExtent++;
+
+    return 0;
+}
+
+
+static int virStorageBackendDiskMakeVol(virConnectPtr conn,
+                                        virStoragePoolObjPtr pool,
+                                        size_t ntok ATTRIBUTE_UNUSED,
+                                        char **const groups,
+                                        void *data)
+{
+    /*
+     * Ignore normal+metadata, and logical+metadata partitions
+     * since they're basically internal book-keeping regions
+     * we have no control over. Do keep extended+metadata though
+     * because that's the MS-DOS extended partition region we
+     * need to be able to view/create/delete
+     */
+    if ((STREQ(groups[1], "normal") ||
+         STREQ(groups[1], "logical")) &&
+        STREQ(groups[2], "metadata"))
+        return 0;
+
+    /* Remaining data / metdata parts get turn into volumes... */
+    if (STREQ(groups[2], "metadata") ||
+        STREQ(groups[2], "data")) {
+        virStorageVolDefPtr vol = data;
+        /* We're searching for a specific vol only, so ignore others */
+        if (vol &&
+            STRNEQ(vol->name, groups[0]))
+            return 0;
+
+        return virStorageBackendDiskMakeDataVol(conn, pool, groups, vol);
+    } else if (STREQ(groups[2], "free")) {
+        /* ....or free space extents */
+        return virStorageBackendDiskMakeFreeExtent(conn, pool, groups);
+    } else {
+        /* This codepath should never happen unless someone changed
+         * libvirt_parthelper forgot to change this code */
+        return -1;
+    }
+}
+
+
+/* To get a list of partitions we run an external helper
+ * tool which then uses parted APIs. This is because
+ * parted's API is not compatible with libvirt's license
+ * but we really really want to use parted because the
+ * other options all suck :-)
+ *
+ * All the other storage backends run an external tool for
+ * listing volumes so this really isn't too much of a pain,
+ * and we can even ensure the output is friendly.
+ */
+static int virStorageBackendDiskReadPartitions(virConnectPtr conn,
+                                               virStoragePoolObjPtr pool,
+                                               virStorageVolDefPtr vol)
+{
+
+    /*
+     *  # libvirt_parthelper DEVICE
+     * /dev/sda1      normal       data        32256    106928128    106896384
+     * /dev/sda2      normal       data    106928640 100027629568  99920701440
+     * -              normal   metadata 100027630080 100030242304      2612736
+     *
+     */
+    const char *prog[] = {
+        PARTHELPER, pool->def->source.devices[0].path, NULL,
+    };
+
+    pool->def->allocation = pool->def->capacity = pool->def->available = 0;
+
+    return virStorageBackendRunProgNul(conn,
+                                       pool,
+                                       prog,
+                                       6,
+                                       virStorageBackendDiskMakeVol,
+                                       vol);
+}
+
+
+static int virStorageBackendDiskRefreshPool(virConnectPtr conn,
+                                            virStoragePoolObjPtr pool)
+{
+    free(pool->def->source.devices[0].freeExtents);
+    pool->def->source.devices[0].nfreeExtent = 0;
+    pool->def->source.devices[0].freeExtents = NULL;
+
+    return virStorageBackendDiskReadPartitions(conn, pool, NULL);
+}
+
+
+/**
+ * Write a new partition table header
+ */
+static int virStorageBackendDiskBuildPool(virConnectPtr conn,
+                                          virStoragePoolObjPtr pool,
+                                          unsigned int flags ATTRIBUTE_UNUSED)
+{
+    /* eg parted /dev/sda mklabel msdos */
+    const char *prog[] = {
+        PARTED,
+        pool->def->source.devices[0].path,
+        "mklabel",
+        virStorageBackendDiskPoolFormatToString(conn, pool->def->source.format),
+        NULL,
+    };
+
+    if (virRun(conn, (char**)prog, NULL) < 0)
+        return -1;
+
+    return 0;
+}
+
+
+static int virStorageBackendDiskDeleteVol(virConnectPtr conn,
+                                          virStoragePoolObjPtr pool,
+                                          virStorageVolDefPtr vol,
+                                          unsigned int flags);
+
+static int virStorageBackendDiskCreateVol(virConnectPtr conn,
+                                          virStoragePoolObjPtr pool,
+                                          virStorageVolDefPtr vol)
+{
+    int i;
+    char start[100], end[100];
+    unsigned long long startOffset, endOffset, smallestSize = 0, smallestExtent = -1;
+    virStoragePoolSourceDevicePtr dev = &pool->def->source.devices[0];
+    /* XXX customizable partition types */
+    const char *cmdargv[] = {
+        PARTED,
+        pool->def->source.devices[0].path,
+        "mkpart",
+        "--script",
+        "ext2",
+        start,
+        end,
+        NULL
+    };
+
+    for (i = 0 ; i < dev->nfreeExtent ; i++) {
+        unsigned long long size =
+            dev->freeExtents[i].end -
+            dev->freeExtents[i].start;
+        if (size > vol->allocation &&
+            (smallestSize == 0 ||
+             size < smallestSize)) {
+            smallestSize = size;
+            smallestExtent = i;
+        }
+    }
+    if (smallestExtent == -1) {
+        virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "no large enough free extent");
+        return -1;
+    }
+    startOffset = dev->freeExtents[smallestExtent].start;
+    endOffset = startOffset + vol->allocation;
+
+    snprintf(start, sizeof(start)-1, "%lluB", startOffset);
+    start[sizeof(start)-1] = '\0';
+    snprintf(end, sizeof(end)-1, "%lluB", endOffset);
+    end[sizeof(end)-1] = '\0';
+
+    if (virRun(conn, (char**)cmdargv, NULL) < 0)
+        return -1;
+
+    /* Blow away free extent info, as we're about to re-populate it */
+    free(pool->def->source.devices[0].freeExtents);
+    pool->def->source.devices[0].nfreeExtent = 0;
+    pool->def->source.devices[0].freeExtents = NULL;
+
+    /* Fetch actual extent info */
+    if (virStorageBackendDiskReadPartitions(conn, pool, vol) < 0)
+        return -1;
+
+    return 0;
+}
+
+
+static int virStorageBackendDiskDeleteVol(virConnectPtr conn,
+                                          virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
+                                          virStorageVolDefPtr vol ATTRIBUTE_UNUSED,
+                                          unsigned int flags ATTRIBUTE_UNUSED)
+{
+    /* delete a partition */
+    virStorageReportError(conn, VIR_ERR_NO_SUPPORT, "Disk pools are not yet supported");
+    return -1;
+}
+
+
+virStorageBackend virStorageBackendDisk = {
+    .type = VIR_STORAGE_POOL_DISK,
+
+    .buildPool = virStorageBackendDiskBuildPool,
+    .refreshPool = virStorageBackendDiskRefreshPool,
+
+    .createVol = virStorageBackendDiskCreateVol,
+    .deleteVol = virStorageBackendDiskDeleteVol,
+
+    .poolOptions = {
+        .flags = (VIR_STORAGE_BACKEND_POOL_SOURCE_DEVICE),
+        .formatFromString = virStorageBackendDiskPoolFormatFromString,
+        .formatToString = virStorageBackendDiskPoolFormatToString,
+    },
+    .volOptions = {
+        .formatFromString = virStorageBackendDiskVolFormatFromString,
+        .formatToString = virStorageBackendDiskVolFormatToString,
+    },
+
+    .volType = VIR_STORAGE_VOL_BLOCK,
+};
+
+/*
+ * vim: set tabstop=4:
+ * vim: set shiftwidth=4:
+ * vim: set expandtab:
+ */
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */
diff -r 4c283aac5fd6 src/storage_backend_disk.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/storage_backend_disk.h	Thu Feb 07 16:51:32 2008 -0500
@@ -0,0 +1,45 @@
+/*
+ * storage_backend_disk.h: storage backend for disk handling
+ *
+ * Copyright (C) 2007-2008 Red Hat, Inc.
+ * Copyright (C) 2007-2008 Daniel P. Berrange
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ *
+ * Author: Daniel P. Berrange <berrange redhat com>
+ */
+
+#ifndef __VIR_STORAGE_BACKEND_DISK_H__
+#define __VIR_STORAGE_BACKEND_DISK_H__
+
+#include "storage_backend.h"
+
+extern virStorageBackend virStorageBackendDisk;
+
+#endif /* __VIR_STORAGE_BACKEND_DISK_H__ */
+
+/*
+ * vim: set tabstop=4:
+ * vim: set shiftwidth=4:
+ * vim: set expandtab:
+ */
+/*
+ * Local variables:
+ *  indent-tabs-mode: nil
+ *  c-indent-level: 4
+ *  c-basic-offset: 4
+ *  tab-width: 4
+ * End:
+ */

-- 
|=- Red Hat, Engineering, Emerging Technologies, Boston.  +1 978 392 2496 -=|
|=-           Perl modules: http://search.cpan.org/~danberr/              -=|
|=-               Projects: http://freshmeat.net/~danielpb/               -=|
|=-  GnuPG: 7D3B9505   F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505  -=| 


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]