diff --git a/configure.ac b/configure.ac
index e7456931d2..c76a394a08 100644
--- a/configure.ac
+++ b/configure.ac
@@ -139,7 +139,7 @@ fi
 # Libraries
 #
 
-PKG_CHECK_MODULES(GLIB, [glib-2.0 >= 2.50])
+PKG_CHECK_MODULES(GLIB, [glib-2.0 >= 2.68])
 AC_SUBST(GLIB_CFLAGS)
 AC_SUBST(GLIB_LIBS)
 
diff --git a/modules/lvm2/data/org.freedesktop.UDisks2.lvm2.xml b/modules/lvm2/data/org.freedesktop.UDisks2.lvm2.xml
index c1d61d44f3..ff55d08f89 100644
--- a/modules/lvm2/data/org.freedesktop.UDisks2.lvm2.xml
+++ b/modules/lvm2/data/org.freedesktop.UDisks2.lvm2.xml
@@ -160,6 +160,13 @@
     -->
     <property name="NeedsPolling" type="b" access="read"/>
 
+    <!-- MissingPhysicalVolumes:
+         @since: 2.10.0
+
+         A list of the UUIDs of missing physical volumes.
+    -->
+    <property name="MissingPhysicalVolumes" type="as" access="read"/>
+
     <!-- Poll:
 
          Make sure that all properties of this volume group and of all
@@ -251,13 +258,27 @@
       <arg name="options" direction="in" type="a{sv}"/>
     </method>
 
+    <!-- RemoveMissingPhysicalVolumes:
+         @since: 2.10.0
+
+         Forget about all physical volumes that went missing.
+
+         No additional options are currently defined.
+    -->
+    <method name="RemoveMissingPhysicalVolumes">
+      <arg name="options" direction="in" type="a{sv}"/>
+    </method>
+
     <!-- CreatePlainVolume:
          @name: The name of the new logical volume.
          @size: The size.
          @options: Additional options.
          @result: The object path of the new logical volume.
 
-         Create a 'normal' new logical volume.
+         Create a 'normal' new logical volume.  Calling this method is
+         equivalent to calling CreatePlainVolumeWithLayout with
+         "linear" as the layout type and an empty array of physical
+         volumes.
 
          No additional options are currently defined.
     -->
@@ -268,6 +289,30 @@
       <arg name="result" type="o" direction="out"/>
     </method>
 
+    <!-- CreatePlainVolumeWithLayout:
+         @name: The name of the new logical volume.
+         @size: The size.
+         @layout: The layout type, like "linear", "raid5"
+         @pvs: The physical volumes to use
+         @options: Additional options.
+         @result: The object path of the new logical volume.
+         @since: 2.10.0
+
+         Create a 'normal' new logical volume with the given layout
+         type on the given physical volumes.  It is okay to leave
+         "pvs" empty; LVM2 will then choose suitable ones on its own.
+
+         No additional options are currently defined.
+    -->
+    <method name="CreatePlainVolumeWithLayout">
+      <arg name="name" type="s" direction="in"/>
+      <arg name="size" type="t" direction="in"/>
+      <arg name="layout" type="s" direction="in"/>
+      <arg name="pvs" type="ao" direction="in"/>
+      <arg name="options" type="a{sv}" direction="in"/>
+      <arg name="result" type="o" direction="out"/>
+    </method>
+
     <!-- CreateThinPoolVolume:
          @name: The name of the new logical volume.
          @size: The total size.
@@ -436,6 +481,71 @@
     -->
     <property name="Type" type="s" access="read"/>
 
+    <!-- Layout:
+         @since: 2.10.0
+
+         The layout of this logical volume, such as "linear", "raid5",
+         etc.
+    -->
+    <property name="Layout" type="s" access="read"/>
+
+    <!-- Structure:
+         @since: 2.10.0
+
+         The detailed structure of how this logical volume is stored on physical volumes.
+
+         The following fields are present:
+
+         - name (s): The name of the logical volume.
+         - type (s): The layout type of the logical volume.
+         - size (t): The size in bytes of the logical volume.
+
+         If the logical volume is stored directly on physical volumes,
+         this field is present as well:
+
+         - segs (a(tto)): Information about the segments of the logical volume (see below).
+
+         A segment is represented by a "(tto)" tuple, where the fields
+         have these meanings:
+
+         - (t): The start of this segement on the physical volume, in bytes.
+         - (t): The size of the segment, in bytes.
+         - (o): The path of the org.freedesktop.UDisks.Block object of the physical volume.
+
+         For a healthy logical volume, the sizes of its segments will
+         add up exactly to its own size.  If a volume group has lost
+         some physical volumes, a affected logical volume will have a
+         list of segments here that do not add up to its full size.
+
+         If the logical volume is stored on other logical volumes,
+         these fields are present in the "Structure" value instead of
+         "segs":
+
+         - data (aa{sv}): The list of "Structure" objects for the data sub-volumes.
+         - metadata (aa{sv}): The list of "Structure" objects for the metadata sub-volumes.
+
+         For example, a minimal "raid5" layout will have three "data"
+         sub-volumes (and three parallel "metadata" sub-volumes),
+         which are the three stripes of the RAID configuration.  Each
+         of those sub-volume will be stored directly on physical
+         volumes and one can inspect the "segs" field of those to
+         figure out how many are damaged.  From that, one can deduce
+         whether the RAID is degraded (exactly one damaged), or has
+         lost data (more than one damaged).
+    -->
+    <property name="Structure" type="a{sv}" access="read"/>
+
+    <!-- SyncRatio:
+         @since: 2.10.0
+
+         How far along the logical volume is with resynchronizing.  A
+         value of 1.0 corresponds to fully synchronized and indicates
+         that no operation is in progress.  This is only relevant for
+         logical volumes with some redundancy, like "raid1" or
+         "raid5".
+    -->
+    <property name="SyncRatio" type="d" access="read"/>
+
     <!-- ThinPool:
 
          For a thin volume, the object path of its pool.
@@ -557,6 +667,23 @@
       <arg name="options" type="a{sv}" direction="in"/>
     </method>
 
+    <!-- Repair:
+         @pvs: A list of physical volumes to use for the repair.
+         @options: Additional options.
+         @since: 2.10.0
+
+         Attempt a repair of this logical volume after it has lost
+         some physical volumes.  Space is allocated from the given
+         physical volumes as needed.  A empty list means to allocate
+         from all physical volumes.
+
+         No additional options are currently defined.
+    -->
+    <method name="Repair">
+      <arg name="pvs" type="ao" direction="in"/>
+      <arg name="options" direction="in" type="a{sv}"/>
+    </method>
+
     <!-- CreateSnapshot:
          @name: The name of the snapshot.
          @size: The size of the backing store for the snapshot, in bytes.
diff --git a/modules/lvm2/jobhelpers.c b/modules/lvm2/jobhelpers.c
index a0e9892516..9b35bacf36 100644
--- a/modules/lvm2/jobhelpers.c
+++ b/modules/lvm2/jobhelpers.c
@@ -34,7 +34,7 @@ gboolean lvcreate_job_func (UDisksThreadedJob  *job,
                             GError            **error)
 {
     LVJobData *data = user_data;
-    return bd_lvm_lvcreate (data->vg_name, data->new_lv_name, data->new_lv_size, NULL /* type */, NULL /* pvs */, NULL /* extra_args */, error);
+    return bd_lvm_lvcreate (data->vg_name, data->new_lv_name, data->new_lv_size, data->new_lv_layout, data->new_lv_pvs, NULL /* extra_args */, error);
 }
 
 gboolean lvcreate_thin_pool_job_func (UDisksThreadedJob  *job,
@@ -207,6 +207,15 @@ gboolean lv_vdo_deduplication_job_func (UDisksThreadedJob  *job,
         return bd_lvm_vdo_disable_deduplication (data->vg_name, data->lv_name, NULL /* extra_args */, error);
 }
 
+gboolean lvrepair_job_func (UDisksThreadedJob  *job,
+                            GCancellable       *cancellable,
+                            gpointer            user_data,
+                            GError            **error)
+{
+    LVJobData *data = user_data;
+    return bd_lvm_lvrepair (data->vg_name, data->lv_name, data->new_lv_pvs, NULL /* extra_args */, error);
+}
+
 gboolean vgcreate_job_func (UDisksThreadedJob  *job,
                             GCancellable       *cancellable,
                             gpointer            user_data,
@@ -349,7 +358,7 @@ void lvs_task_func (GTask        *task,
   BDLVMLVdata **ret = NULL;
   gchar *vg_name = (gchar*) task_data;
 
-  ret = bd_lvm_lvs (vg_name, &error);
+  ret = bd_lvm_lvs_tree (vg_name, &error);
   if (!ret)
     g_task_return_error (task, error);
   else
diff --git a/modules/lvm2/jobhelpers.h b/modules/lvm2/jobhelpers.h
index 314bfb6431..35468f84c4 100644
--- a/modules/lvm2/jobhelpers.h
+++ b/modules/lvm2/jobhelpers.h
@@ -34,6 +34,8 @@ typedef struct {
   const gchar *vg_name;
   const gchar *lv_name;
   const gchar *new_lv_name;
+  const gchar *new_lv_layout;
+  const gchar **new_lv_pvs;
   const gchar *pool_name;
   guint64 new_lv_size;
   guint64 virtual_size;
@@ -98,6 +100,11 @@ gboolean lvresize_job_func (UDisksThreadedJob  *job,
                             gpointer            user_data,
                             GError            **error);
 
+gboolean lvrepair_job_func (UDisksThreadedJob  *job,
+                            GCancellable       *cancellable,
+                            gpointer            user_data,
+                            GError            **error);
+
 gboolean lvactivate_job_func (UDisksThreadedJob  *job,
                               GCancellable       *cancellable,
                               gpointer            user_data,
diff --git a/modules/lvm2/udiskslinuxlogicalvolume.c b/modules/lvm2/udiskslinuxlogicalvolume.c
index e3d3a4cb03..7390d3aebe 100644
--- a/modules/lvm2/udiskslinuxlogicalvolume.c
+++ b/modules/lvm2/udiskslinuxlogicalvolume.c
@@ -132,6 +132,100 @@ udisks_linux_logical_volume_new (void)
 
 /* ---------------------------------------------------------------------------------------------------- */
 
+static GVariant *
+build_segment (UDisksDaemon *daemon,
+               UDisksVolumeGroup *group,
+               BDLVMSEGdata *seg)
+{
+  GVariantBuilder seg_builder;
+  UDisksObject *block_object;
+  guint64 extent_size = udisks_volume_group_get_extent_size (group);
+
+  g_variant_builder_init (&seg_builder, G_VARIANT_TYPE ("(tto)"));
+  g_variant_builder_add (&seg_builder, "t", seg->pv_start_pe * extent_size);
+  g_variant_builder_add (&seg_builder, "t", seg->size_pe * extent_size);
+  block_object = udisks_daemon_find_block_by_device_file (daemon, seg->pvdev);
+  if (block_object)
+    {
+      g_variant_builder_add (&seg_builder, "o", g_dbus_object_get_object_path (G_DBUS_OBJECT (block_object)));
+      g_object_unref (block_object);
+    }
+  else
+    g_variant_builder_add (&seg_builder, "o", "/");
+  return g_variant_builder_end (&seg_builder);
+}
+
+static GVariant *build_structure (UDisksDaemon *daemon, UDisksVolumeGroup *group, BDLVMLVdata *lv, BDLVMLVdata **all);
+
+static gboolean
+lvnameeq (gchar *name, gchar *maybe_bracketed_name)
+{
+  size_t len = strlen (maybe_bracketed_name);
+  return (g_strcmp0 (name, maybe_bracketed_name) == 0
+          || (maybe_bracketed_name[0] == '['
+              && maybe_bracketed_name[len-1] == ']'
+              && strlen (name) == len-2
+              && strncmp (name, maybe_bracketed_name+1, len-2) == 0));
+}
+
+static GVariant *
+build_structures (UDisksDaemon *daemon,
+                  UDisksVolumeGroup *group,
+                  gchar **lv_names,
+                  BDLVMLVdata **all)
+{
+  GVariantBuilder list_builder;
+  g_variant_builder_init (&list_builder, G_VARIANT_TYPE ("aa{sv}"));
+  for (int i = 0; lv_names[i]; i++)
+    {
+      int j;
+      for (j = 0; all[j]; j++) {
+        if (lvnameeq (lv_names[i], all[j]->lv_name))
+          break;
+      }
+      if (all[j])
+        g_variant_builder_add_value (&list_builder, build_structure (daemon, group, all[j], all));
+    }
+  return g_variant_builder_end (&list_builder);
+}
+
+static GVariant *
+build_structure (UDisksDaemon *daemon,
+                 UDisksVolumeGroup *group,
+                 BDLVMLVdata *lv,
+                 BDLVMLVdata **all)
+{
+  GVariantBuilder lv_builder;
+
+  g_variant_builder_init (&lv_builder, G_VARIANT_TYPE_VARDICT);
+  if (lv->lv_name[0] == '[')
+    {
+      gchar *name = g_strndup (lv->lv_name + 1, strlen (lv->lv_name) - 2);
+      g_variant_builder_add (&lv_builder, "{sv}", "name", g_variant_new_string (name));
+      g_free (name);
+    }
+  else
+    g_variant_builder_add (&lv_builder, "{sv}", "name", g_variant_new_string (lv->lv_name));
+
+  g_variant_builder_add (&lv_builder, "{sv}", "type", g_variant_new_string (lv->segtype));
+  g_variant_builder_add (&lv_builder, "{sv}", "size", g_variant_new_uint64 (lv->size));
+
+  if (lv->segs) {
+    GVariantBuilder segs_builder;
+    g_variant_builder_init (&segs_builder, G_VARIANT_TYPE ("a(tto)"));
+    for (int i = 0; lv->segs[i]; i++)
+      g_variant_builder_add_value (&segs_builder, build_segment (daemon, group, lv->segs[i]));
+    g_variant_builder_add (&lv_builder, "{sv}", "segments", g_variant_builder_end (&segs_builder));
+  } else {
+    if (lv->data_lvs)
+      g_variant_builder_add (&lv_builder, "{sv}", "data", build_structures (daemon, group, lv->data_lvs, all));
+    if (lv->metadata_lvs)
+      g_variant_builder_add (&lv_builder, "{sv}", "metadata", build_structures (daemon, group, lv->metadata_lvs, all));
+  }
+
+  return g_variant_builder_end (&lv_builder);
+}
+
 /**
  * udisks_linux_logical_volume_update:
  * @logical_volume: A #UDisksLinuxLogicalVolume.
@@ -145,16 +239,24 @@ udisks_linux_logical_volume_update (UDisksLinuxLogicalVolume     *logical_volume
                                     UDisksLinuxVolumeGroupObject *group_object,
                                     BDLVMLVdata                  *lv_info,
                                     BDLVMLVdata                  *meta_lv_info,
+                                    BDLVMLVdata                 **all_lv_infos,
                                     gboolean                     *needs_polling_ret)
 {
+  UDisksLinuxModuleLVM2 *module;
+  UDisksDaemon *daemon;
   UDisksLogicalVolume *iface;
+  UDisksVolumeGroup *group;
   const char *type;
   gboolean active;
   const char *pool_objpath;
   const char *origin_objpath;
   guint64 size = 0;
 
+  module = udisks_linux_volume_group_object_get_module (group_object);
+  daemon = udisks_module_get_daemon (UDISKS_MODULE (module));
+
   iface = UDISKS_LOGICAL_VOLUME (logical_volume);
+  group = udisks_object_get_volume_group (UDISKS_OBJECT (group_object));
 
   udisks_logical_volume_set_name (iface, lv_info->lv_name);
   udisks_logical_volume_set_uuid (iface, lv_info->uuid);
@@ -182,6 +284,20 @@ udisks_linux_logical_volume_update (UDisksLinuxLogicalVolume     *logical_volume
         active = TRUE;
     }
   udisks_logical_volume_set_type_ (iface, type);
+  if (g_strcmp0 (lv_info->segtype, "error") == 0)
+    udisks_logical_volume_set_layout (iface, "linear");
+  else
+    udisks_logical_volume_set_layout (iface, lv_info->segtype);
+  if ((g_str_has_prefix (lv_info->segtype, "raid") && g_strcmp0 (lv_info->segtype, "raid0") != 0)
+      || g_strcmp0 (lv_info->segtype, "mirror") == 0)
+    {
+      udisks_logical_volume_set_sync_ratio (iface, lv_info->copy_percent / 100.0);
+      if (lv_info->copy_percent != 100)
+        *needs_polling_ret = TRUE;
+    }
+  else
+    udisks_logical_volume_set_sync_ratio (iface, 1.0);
+
   udisks_logical_volume_set_active (iface, active);
   udisks_logical_volume_set_size (iface, size);
 
@@ -232,6 +348,8 @@ udisks_linux_logical_volume_update (UDisksLinuxLogicalVolume     *logical_volume
       g_free (dev_file);
     }
 
+  udisks_logical_volume_set_structure (iface, build_structure (daemon, group, lv_info, all_lv_infos));
+
   g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (iface));
 }
 
@@ -409,8 +527,7 @@ common_setup (UDisksLinuxLogicalVolume           *volume,
                                                out_uid,
                                                &error))
     {
-      g_dbus_method_invocation_return_gerror (invocation, error);
-      g_clear_error (&error);
+      g_dbus_method_invocation_take_error (invocation, error);
       goto out;
     }
 
@@ -508,6 +625,65 @@ handle_delete (UDisksLogicalVolume   *_volume,
 
 /* ---------------------------------------------------------------------------------------------------- */
 
+static gboolean
+handle_repair (UDisksLogicalVolume   *_volume,
+               GDBusMethodInvocation *invocation,
+               const gchar *const    *arg_pvs,
+               GVariant              *options)
+{
+  GError *error = NULL;
+  UDisksLinuxLogicalVolume *volume = UDISKS_LINUX_LOGICAL_VOLUME (_volume);
+  UDisksLinuxLogicalVolumeObject *object = NULL;
+  UDisksDaemon *daemon = NULL;
+  uid_t caller_uid;
+  UDisksLinuxVolumeGroupObject *group_object;
+  LVJobData data = {0};
+  g_auto(GStrv) pvs = NULL;
+
+  if (!common_setup (volume, invocation, options,
+                     N_("Authentication is required to repair a logical volume"),
+                     &object, &daemon, &caller_uid))
+    goto out;
+
+  group_object = udisks_linux_logical_volume_object_get_volume_group (object);
+  data.vg_name = udisks_linux_volume_group_object_get_name (group_object);
+  data.lv_name = udisks_linux_logical_volume_object_get_name (object);
+  pvs = udisks_daemon_util_lvm2_gather_pvs (daemon, group_object, arg_pvs, &error);
+  if (pvs == NULL)
+    {
+      g_dbus_method_invocation_take_error (invocation, error);
+      goto out;
+    }
+  data.new_lv_pvs = (const gchar **)pvs;
+
+  if (!udisks_daemon_launch_threaded_job_sync (daemon,
+                                               UDISKS_OBJECT (object),
+                                               "lvm-lvol-repair",
+                                               caller_uid,
+                                               lvrepair_job_func,
+                                               &data,
+                                               NULL, /* user_data_free_func */
+                                               NULL, /* GCancellable */
+                                               &error))
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             UDISKS_ERROR,
+                                             UDISKS_ERROR_FAILED,
+                                             "Error repairing logical volume: %s",
+                                             error->message);
+      g_clear_error (&error);
+      goto out;
+    }
+
+  udisks_logical_volume_complete_repair (_volume, invocation);
+
+ out:
+  g_clear_object (&object);
+  return TRUE;
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
 static UDisksObject *
 wait_for_logical_volume_object (UDisksDaemon *daemon,
                                 gpointer      user_data)
@@ -1054,6 +1230,7 @@ logical_volume_iface_init (UDisksLogicalVolumeIface *iface)
   iface->handle_delete = handle_delete;
   iface->handle_rename = handle_rename;
   iface->handle_resize = handle_resize;
+  iface->handle_repair = handle_repair;
   iface->handle_activate = handle_activate;
   iface->handle_deactivate = handle_deactivate;
   iface->handle_create_snapshot = handle_create_snapshot;
diff --git a/modules/lvm2/udiskslinuxlogicalvolume.h b/modules/lvm2/udiskslinuxlogicalvolume.h
index f371f2e022..0582015415 100644
--- a/modules/lvm2/udiskslinuxlogicalvolume.h
+++ b/modules/lvm2/udiskslinuxlogicalvolume.h
@@ -39,6 +39,7 @@ void                 udisks_linux_logical_volume_update   (UDisksLinuxLogicalVol
                                                            UDisksLinuxVolumeGroupObject *group_object,
                                                            BDLVMLVdata                  *lv_info,
                                                            BDLVMLVdata                  *meta_lv_info,
+                                                           BDLVMLVdata                 **all_lv_infos,
                                                            gboolean                     *needs_polling_ret);
 void                   udisks_linux_logical_volume_update_etctabs (UDisksLinuxLogicalVolume     *logical_volume,
                                                                    UDisksLinuxVolumeGroupObject *group_object);
diff --git a/modules/lvm2/udiskslinuxlogicalvolumeobject.c b/modules/lvm2/udiskslinuxlogicalvolumeobject.c
index 8d1ba7a23f..da1f8b8576 100644
--- a/modules/lvm2/udiskslinuxlogicalvolumeobject.c
+++ b/modules/lvm2/udiskslinuxlogicalvolumeobject.c
@@ -300,6 +300,7 @@ void
 udisks_linux_logical_volume_object_update (UDisksLinuxLogicalVolumeObject *object,
                                            BDLVMLVdata *lv_info,
                                            BDLVMLVdata *meta_lv_info,
+                                           BDLVMLVdata **all_lv_infos,
                                            BDLVMVDOPooldata *vdo_info,
                                            gboolean *needs_polling_ret)
 {
@@ -307,7 +308,7 @@ udisks_linux_logical_volume_object_update (UDisksLinuxLogicalVolumeObject *objec
 
   udisks_linux_logical_volume_update (UDISKS_LINUX_LOGICAL_VOLUME (object->iface_logical_volume),
                                       object->volume_group,
-                                      lv_info, meta_lv_info,
+                                      lv_info, meta_lv_info, all_lv_infos,
                                       needs_polling_ret);
 
   if (vdo_info)
diff --git a/modules/lvm2/udiskslinuxlogicalvolumeobject.h b/modules/lvm2/udiskslinuxlogicalvolumeobject.h
index 8569657539..66f7347557 100644
--- a/modules/lvm2/udiskslinuxlogicalvolumeobject.h
+++ b/modules/lvm2/udiskslinuxlogicalvolumeobject.h
@@ -45,6 +45,7 @@ const gchar                    *udisks_linux_logical_volume_object_get_name
 void                            udisks_linux_logical_volume_object_update           (UDisksLinuxLogicalVolumeObject *object,
                                                                                      BDLVMLVdata                    *lv_info,
                                                                                      BDLVMLVdata                    *meta_lv_info,
+                                                                                     BDLVMLVdata                   **all_lv_infos,
                                                                                      BDLVMVDOPooldata               *vdo_info,
                                                                                      gboolean                       *needs_polling_ret);
 void                            udisks_linux_logical_volume_object_update_etctabs   (UDisksLinuxLogicalVolumeObject *object);
diff --git a/modules/lvm2/udiskslinuxvolumegroup.c b/modules/lvm2/udiskslinuxvolumegroup.c
index 3fbf6f025b..b53728ecc3 100644
--- a/modules/lvm2/udiskslinuxvolumegroup.c
+++ b/modules/lvm2/udiskslinuxvolumegroup.c
@@ -133,6 +133,7 @@ udisks_linux_volume_group_new (void)
 void
 udisks_linux_volume_group_update (UDisksLinuxVolumeGroup *volume_group,
                                   BDLVMVGdata            *vg_info,
+                                  GSList                 *vg_pvs,
                                   gboolean               *needs_polling_ret)
 {
   UDisksVolumeGroup *iface = UDISKS_VOLUME_GROUP (volume_group);
@@ -143,6 +144,21 @@ udisks_linux_volume_group_update (UDisksLinuxVolumeGroup *volume_group,
   udisks_volume_group_set_free_size (iface, vg_info->free);
   udisks_volume_group_set_extent_size (iface, vg_info->extent_size);
 
+  {
+    g_autoptr(GStrvBuilder) missing_builder = g_strv_builder_new ();
+    g_auto(GStrv) missing = NULL;
+
+    for (GSList *vg_pvs_p=vg_pvs; vg_pvs_p; vg_pvs_p=vg_pvs_p->next)
+      {
+        BDLVMPVdata *pv_info = vg_pvs_p->data;
+        if (pv_info->missing)
+          g_strv_builder_add (missing_builder, pv_info->pv_uuid);
+      }
+
+    missing = g_strv_builder_end (missing_builder);
+    udisks_volume_group_set_missing_physical_volumes (iface, (const gchar *const *)missing);
+  }
+
   g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (iface));
 }
 
@@ -771,6 +787,80 @@ handle_empty_device (UDisksVolumeGroup     *_group,
 
 /* ---------------------------------------------------------------------------------------------------- */
 
+static gboolean
+handle_remove_missing_physical_volumes (UDisksVolumeGroup     *_group,
+                                        GDBusMethodInvocation *invocation,
+                                        GVariant              *options)
+{
+  UDisksLinuxVolumeGroup *group = UDISKS_LINUX_VOLUME_GROUP (_group);
+  UDisksLinuxModuleLVM2 *module;
+  UDisksDaemon *daemon;
+  UDisksLinuxVolumeGroupObject *object;
+  uid_t caller_uid;
+  GError *error = NULL;
+  VGJobData data;
+
+  object = udisks_daemon_util_dup_object (group, &error);
+  if (object == NULL)
+    {
+      g_dbus_method_invocation_take_error (invocation, error);
+      goto out;
+    }
+
+  module = udisks_linux_volume_group_object_get_module (object);
+  daemon = udisks_module_get_daemon (UDISKS_MODULE (module));
+
+  error = NULL;
+  if (!udisks_daemon_util_get_caller_uid_sync (daemon,
+                                               invocation,
+                                               NULL /* GCancellable */,
+                                               &caller_uid,
+                                               &error))
+    {
+      g_dbus_method_invocation_return_gerror (invocation, error);
+      g_clear_error (&error);
+      goto out;
+    }
+
+  /* Policy check. */
+  UDISKS_DAEMON_CHECK_AUTHORIZATION (daemon,
+                                     UDISKS_OBJECT (object),
+                                     LVM2_POLICY_ACTION_ID,
+                                     options,
+                                     N_("Authentication is required to remove missing physical volumes from a volume group"),
+                                     invocation);
+
+  data.vg_name = udisks_linux_volume_group_object_get_name (object);
+  data.pv_path = NULL;
+
+  if (!udisks_daemon_launch_threaded_job_sync (daemon,
+                                               UDISKS_OBJECT (object),
+                                               "lvm-vg-rem-device",
+                                               caller_uid,
+                                               vgreduce_job_func,
+                                               &data,
+                                               NULL, /* user_data_free_func */
+                                               NULL, /* GCancellable */
+                                               &error))
+    {
+      g_dbus_method_invocation_return_error (invocation,
+                                             UDISKS_ERROR,
+                                             UDISKS_ERROR_FAILED,
+                                             "Error removing missing physical volumes: %s",
+                                             error->message);
+      g_clear_error (&error);
+      goto out;
+    }
+
+  udisks_volume_group_complete_remove_missing_physical_volumes (_group, invocation);
+
+ out:
+  g_clear_object (&object);
+  return TRUE; /* returning TRUE means that we handled the method invocation */
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
 struct WaitData {
   UDisksLinuxVolumeGroupObject *group_object;
   const gchar *name;
@@ -839,7 +929,9 @@ handle_create_volume (UDisksVolumeGroup              *_group,
                       guint64                         arg_index_memory,
                       gboolean                        arg_compression,
                       gboolean                        arg_deduplication,
-                      const gchar                    *arg_write_policy)
+                      const gchar                    *arg_write_policy,
+                      const gchar                    *arg_layout,
+                      const gchar             *const *arg_pvs)
 {
   GError *error = NULL;
   UDisksLinuxVolumeGroup *group = UDISKS_LINUX_VOLUME_GROUP (_group);
@@ -849,6 +941,7 @@ handle_create_volume (UDisksVolumeGroup              *_group,
   uid_t caller_uid;
   const gchar *lv_objpath;
   LVJobData data = {0};
+  g_auto(GStrv) pvs = NULL;
   UDisksLinuxLogicalVolumeObject *pool_object = NULL;
   const gchar *auth_error_msg = NULL;
   UDisksThreadedJobFunc create_function = NULL;
@@ -911,6 +1004,31 @@ handle_create_volume (UDisksVolumeGroup              *_group,
   data.new_lv_name = arg_name;
   data.new_lv_size = arg_size;
 
+  if (VOL_PLAIN == vol_creation_type)
+    {
+      if (arg_layout != NULL
+          && g_strcmp0 (arg_layout, "linear") != 0
+          && !g_str_has_prefix (arg_layout, "raid")
+          && g_strcmp0 (arg_layout, "mirror") != 0)
+        {
+          g_dbus_method_invocation_return_error (invocation, UDISKS_ERROR, UDISKS_ERROR_FAILED,
+                                                 "Not a valid layout for a plain volume: %s", arg_layout);
+          goto out;
+        }
+
+      data.new_lv_layout = arg_layout;
+      if (arg_pvs)
+        {
+          pvs = udisks_daemon_util_lvm2_gather_pvs (daemon, object, arg_pvs, &error);
+          if (pvs == NULL)
+            {
+              g_dbus_method_invocation_take_error (invocation, error);
+              goto out;
+            }
+          data.new_lv_pvs = (const gchar **)pvs;
+        }
+    }
+
   if (VOL_THIN_POOL == vol_creation_type)
     data.extent_size = udisks_volume_group_get_extent_size (UDISKS_VOLUME_GROUP (group));
 
@@ -981,7 +1099,22 @@ handle_create_plain_volume (UDisksVolumeGroup     *_group,
                             GVariant              *options)
 {
   return handle_create_volume(_group, invocation, arg_name, arg_size, options,
-                              VOL_PLAIN, NULL, 0, 0, FALSE, FALSE, NULL);
+                              VOL_PLAIN, NULL, 0, 0, FALSE, FALSE, NULL,
+                              NULL, NULL);
+}
+
+static gboolean
+handle_create_plain_volume_with_layout (UDisksVolumeGroup     *_group,
+                                        GDBusMethodInvocation *invocation,
+                                        const gchar           *arg_name,
+                                        guint64                arg_size,
+                                        const gchar           *arg_layout,
+                                        const gchar *const    *arg_pvs,
+                                        GVariant              *options)
+{
+  return handle_create_volume(_group, invocation, arg_name, arg_size, options,
+                              VOL_PLAIN, NULL, 0, 0, FALSE, FALSE, NULL,
+                              arg_layout, arg_pvs);
 }
 
 /* ---------------------------------------------------------------------------------------------------- */
@@ -994,7 +1127,8 @@ handle_create_thin_pool_volume (UDisksVolumeGroup     *_group,
                                 GVariant              *options)
 {
   return handle_create_volume(_group, invocation, arg_name, arg_size, options,
-                              VOL_THIN_POOL, NULL, 0, 0, FALSE, FALSE, NULL);
+                              VOL_THIN_POOL, NULL, 0, 0, FALSE, FALSE, NULL,
+                              NULL, NULL);
 }
 
 /* ---------------------------------------------------------------------------------------------------- */
@@ -1008,7 +1142,8 @@ handle_create_thin_volume (UDisksVolumeGroup     *_group,
                            GVariant              *options)
 {
   return handle_create_volume(_group, invocation, arg_name, arg_size, options,
-                              VOL_THIN_VOLUME, arg_pool, 0, 0, FALSE, FALSE, NULL);
+                              VOL_THIN_VOLUME, arg_pool, 0, 0, FALSE, FALSE, NULL,
+                              NULL, NULL);
 }
 
 static gboolean
@@ -1026,7 +1161,8 @@ handle_create_vdo_volume (UDisksVolumeGroup     *_group,
 {
   return handle_create_volume (_group, invocation, arg_name, arg_size, options,
                                VOL_VDO_VOLUME, arg_pool, arg_virtual_size, arg_index_memory,
-                               arg_compression, arg_deduplication, arg_write_policy);
+                               arg_compression, arg_deduplication, arg_write_policy,
+                               NULL, NULL);
 }
 
 /* ---------------------------------------------------------------------------------------------------- */
@@ -1042,8 +1178,10 @@ volume_group_iface_init (UDisksVolumeGroupIface *iface)
   iface->handle_add_device = handle_add_device;
   iface->handle_remove_device = handle_remove_device;
   iface->handle_empty_device = handle_empty_device;
+  iface->handle_remove_missing_physical_volumes = handle_remove_missing_physical_volumes;
 
   iface->handle_create_plain_volume = handle_create_plain_volume;
+  iface->handle_create_plain_volume_with_layout = handle_create_plain_volume_with_layout;
   iface->handle_create_thin_pool_volume = handle_create_thin_pool_volume;
   iface->handle_create_thin_volume = handle_create_thin_volume;
 
diff --git a/modules/lvm2/udiskslinuxvolumegroup.h b/modules/lvm2/udiskslinuxvolumegroup.h
index 6d8ff86ab3..3468bcc309 100644
--- a/modules/lvm2/udiskslinuxvolumegroup.h
+++ b/modules/lvm2/udiskslinuxvolumegroup.h
@@ -36,6 +36,7 @@ GType              udisks_linux_volume_group_get_type  (void) G_GNUC_CONST;
 UDisksVolumeGroup *udisks_linux_volume_group_new       (void);
 void               udisks_linux_volume_group_update    (UDisksLinuxVolumeGroup  *volume_group,
                                                         BDLVMVGdata             *vg_info,
+                                                        GSList                  *vg_pvs,
                                                         gboolean                *needs_polling_ret);
 
 GList *udisks_linux_volume_group_get_logical_volumes (UDisksVolumeGroup *group,
diff --git a/modules/lvm2/udiskslinuxvolumegroupobject.c b/modules/lvm2/udiskslinuxvolumegroupobject.c
index ead08de7b1..7cb06cb294 100644
--- a/modules/lvm2/udiskslinuxvolumegroupobject.c
+++ b/modules/lvm2/udiskslinuxvolumegroupobject.c
@@ -611,7 +611,8 @@ update_vg (GObject      *source_obj,
   daemon = udisks_module_get_daemon (UDISKS_MODULE (object->module));
   manager = udisks_daemon_get_object_manager (daemon);
 
-  udisks_linux_volume_group_update (UDISKS_LINUX_VOLUME_GROUP (object->iface_volume_group), vg_info, &needs_polling);
+  udisks_linux_volume_group_update (UDISKS_LINUX_VOLUME_GROUP (object->iface_volume_group), vg_info, vg_pvs,
+                                    &needs_polling);
 
   if (!g_dbus_object_manager_server_is_exported (manager, G_DBUS_OBJECT_SKELETON (object)))
     g_dbus_object_manager_server_export_uniquely (manager, G_DBUS_OBJECT_SKELETON (object));
@@ -653,13 +654,13 @@ update_vg (GObject      *source_obj,
       if (volume == NULL)
         {
           volume = udisks_linux_logical_volume_object_new (object->module, object, lv_name);
-          udisks_linux_logical_volume_object_update (volume, lv_info, meta_lv_info, vdo_info, &needs_polling);
+          udisks_linux_logical_volume_object_update (volume, lv_info, meta_lv_info, lvs, vdo_info, &needs_polling);
           udisks_linux_logical_volume_object_update_etctabs (volume);
           g_dbus_object_manager_server_export_uniquely (manager, G_DBUS_OBJECT_SKELETON (volume));
           g_hash_table_insert (object->logical_volumes, g_strdup (lv_name), volume);
         }
       else
-        udisks_linux_logical_volume_object_update (volume, lv_info, meta_lv_info, vdo_info, &needs_polling);
+        udisks_linux_logical_volume_object_update (volume, lv_info, meta_lv_info, lvs, vdo_info, &needs_polling);
 
       if (vdo_info)
         bd_lvm_vdopooldata_free (vdo_info);
@@ -805,7 +806,7 @@ poll_vg_update (GObject      *source_obj,
       update_operations (object, lv_name, lv_info, &needs_polling);
       volume = g_hash_table_lookup (object->logical_volumes, lv_name);
       if (volume)
-        udisks_linux_logical_volume_object_update (volume, lv_info, meta_lv_info, vdo_info, &needs_polling);
+        udisks_linux_logical_volume_object_update (volume, lv_info, meta_lv_info, lvs, vdo_info, &needs_polling);
     }
 
   lv_list_free (lvs);
diff --git a/modules/lvm2/udiskslvm2daemonutil.c b/modules/lvm2/udiskslvm2daemonutil.c
index 3c4afb92e8..3acebbfb3f 100644
--- a/modules/lvm2/udiskslvm2daemonutil.c
+++ b/modules/lvm2/udiskslvm2daemonutil.c
@@ -271,3 +271,74 @@ udisks_daemon_util_lvm2_trigger_udev (const gchar *device_file)
   if (fd >= 0)
     close (fd);
 }
+
+/* -------------------------------------------------------------------------------- */
+
+GStrv
+udisks_daemon_util_lvm2_gather_pvs (UDisksDaemon                  *daemon,
+                                    UDisksLinuxVolumeGroupObject  *vgroup_object,
+                                    const gchar *const            *arg_pvs,
+                                    GError                       **error)
+{
+  GStrv result = g_new0 (gchar *, g_strv_length ((GStrv)arg_pvs)+1);
+
+  for (int i = 0; arg_pvs[i] != NULL; i++)
+    {
+      UDisksObject *pvol_object = NULL;
+      UDisksBlock *block = NULL;
+      UDisksPhysicalVolume *pvol = NULL;
+
+      pvol_object = udisks_daemon_find_object (daemon, arg_pvs[i]);
+      if (pvol_object == NULL)
+        {
+          g_set_error (error,
+                       UDISKS_ERROR,
+                       UDISKS_ERROR_FAILED,
+                       "Invalid object path %s at index %u",
+                       arg_pvs[i], i);
+          goto out;
+        }
+
+      block = udisks_object_get_block (pvol_object);
+      pvol = udisks_object_get_physical_volume (pvol_object);
+      if (block == NULL || pvol == NULL)
+        {
+          g_set_error (error,
+                       UDISKS_ERROR,
+                       UDISKS_ERROR_FAILED,
+                       "Object path %s for index %u is not a physical volume",
+                       arg_pvs[i], i);
+          if (block)
+            g_object_unref (block);
+          if (pvol)
+            g_object_unref (pvol);
+          g_object_unref (pvol_object);
+          goto out;
+        }
+
+      if (g_strcmp0 (udisks_physical_volume_get_volume_group (pvol),
+                     g_dbus_object_get_object_path (G_DBUS_OBJECT (vgroup_object))) != 0)
+        {
+          g_set_error (error,
+                       UDISKS_ERROR,
+                       UDISKS_ERROR_FAILED,
+                       "Physical volume %s for index %u does not belong to this volume group",
+                       arg_pvs[i], i);
+          g_object_unref (pvol_object);
+          g_object_unref (pvol);
+          g_object_unref (block);
+          goto out;
+        }
+
+      result[i] = udisks_block_dup_device (block);
+      g_object_unref (block);
+      g_object_unref (pvol);
+      g_object_unref (pvol_object);
+    }
+
+  return result;
+
+ out:
+  g_strfreev (result);
+  return NULL;
+}
diff --git a/modules/lvm2/udiskslvm2daemonutil.h b/modules/lvm2/udiskslvm2daemonutil.h
index 42f4ef20e2..6e5a84ae14 100644
--- a/modules/lvm2/udiskslvm2daemonutil.h
+++ b/modules/lvm2/udiskslvm2daemonutil.h
@@ -37,6 +37,11 @@ gboolean udisks_daemon_util_lvm2_name_is_reserved (const gchar *name);
 
 void udisks_daemon_util_lvm2_trigger_udev (const gchar *device_file);
 
+GStrv udisks_daemon_util_lvm2_gather_pvs (UDisksDaemon             *daemon,
+                                          UDisksLinuxVolumeGroupObject  *vgroup_object,
+                                          const gchar *const       *objects_paths,
+                                          GError                  **error);
+
 G_END_DECLS
 
 #endif /* __UDISKS_LVM2_DAEMON_UTIL_H__ */
diff --git a/src/tests/dbus-tests/test_20_LVM.py b/src/tests/dbus-tests/test_20_LVM.py
index 733cc484ba..e2befa375d 100644
--- a/src/tests/dbus-tests/test_20_LVM.py
+++ b/src/tests/dbus-tests/test_20_LVM.py
@@ -4,6 +4,7 @@
 import time
 import unittest
 import six
+import sys
 
 from packaging.version import Version
 
@@ -63,6 +64,13 @@ def _remove_vg(self, vg, tear_down=False, ignore_removed=False):
 class UdisksLVMTest(UDisksLVMTestBase):
     '''This is a basic LVM test suite'''
 
+    def tearDown(self):
+        # Bring back all vdevs that have been deleted by the test.
+        ret, out = self.run_command("for f in $(find /sys/devices -path '*tcm_loop*/scan'); do echo '- - -' >$f; done")
+        if ret != 0:
+            raise RuntimeError("Cannot rescan vdevs: %s", out)
+        super().tearDown()
+
     def test_01_manager_interface(self):
         '''Test for module D-Bus Manager interface presence'''
 
@@ -124,6 +132,23 @@ def test_10_linear(self):
         dbus_type = self.get_property(lv, '.LogicalVolume', 'Type')
         dbus_type.assertEqual('block')  # type is only 'block' or 'pool'
 
+        dbus_layout = self.get_property(lv, '.LogicalVolume', 'Layout')
+        dbus_layout.assertEqual('linear')
+
+        def assertSegs(pvs):
+            # Check that there is exactly one segment per PV
+            struct = self.get_property(lv, '.LogicalVolume', 'Structure').value
+            self.assertEqual(struct["type"], "linear")
+            self.assertNotIn("data", struct)
+            self.assertNotIn("metadata", struct)
+            segs = struct["segments"]
+            self.assertEqual(len(segs), len(pvs))
+            seg_pvs = list(map(lambda s: s[2], segs))
+            for p in pvs:
+                self.assertIn(p.object_path, seg_pvs)
+
+        assertSegs(devs)
+
         _ret, sys_uuid = self.run_command('lvs -o uuid --no-heading %s' % os.path.join(vgname, lvname))
         dbus_uuid = self.get_property(lv, '.LogicalVolume', 'UUID')
         dbus_uuid.assertEqual(sys_uuid)
@@ -171,6 +196,8 @@ def test_10_linear(self):
         new_lvsize = self.get_property(lv, '.LogicalVolume', 'Size')
         new_lvsize.assertEqual(new_vgsize.value)
 
+        assertSegs(devs + [ new_dev_obj ])
+
         # rename the LV
         lvname = 'udisks_test_lv2'
         new_lvpath = lv.Rename(lvname, self.no_options, dbus_interface=self.iface_prefix + '.LogicalVolume')
@@ -197,6 +224,102 @@ def test_10_linear(self):
         objects = udisks.GetManagedObjects(dbus_interface='org.freedesktop.DBus.ObjectManager')
         self.assertNotIn(new_lvpath, objects.keys())
 
+    def test_15_raid(self):
+        '''Test raid volumes functionality'''
+
+        vgname = 'udisks_test_vg'
+
+        # Use all the virtual devices
+        devs = dbus.Array()
+        for d in self.vdevs:
+            dev_obj = self.get_object('/block_devices/' + os.path.basename(d))
+            self.assertIsNotNone(dev_obj)
+            devs.append(dev_obj)
+        vg = self._create_vg(vgname, devs)
+        self.addCleanup(self._remove_vg, vg)
+
+        dbus_vgname = self.get_property(vg, '.VolumeGroup', 'Name')
+        dbus_vgname.assertEqual(vgname)
+
+        first_vdev_uuid = self.get_property(devs[0], '.Block', 'IdUUID').value
+
+        # Create raid1 LV on the VG
+        lvname = 'udisks_test_lv'
+        vg_freesize = self.get_property(vg, '.VolumeGroup', 'FreeSize')
+        vdev_size = vg_freesize.value / len(devs)
+        lv_size = int(vdev_size * 0.75)
+        lv_path = vg.CreatePlainVolumeWithLayout(lvname, dbus.UInt64(lv_size),
+                                                 "raid1", devs[0:2],
+                                                 self.no_options,
+                                                 dbus_interface=self.iface_prefix + '.VolumeGroup')
+        self.assertIsNotNone(lv_path)
+
+        lv = self.bus.get_object(self.iface_prefix, lv_path)
+        self.get_property(lv, '.LogicalVolume', 'SyncRatio').assertEqual(1.0, timeout=60, poll_vg=vg)
+
+        _ret, sys_type = self.run_command('lvs -o seg_type --noheadings --nosuffix %s/%s' % (vgname, lvname))
+        self.assertEqual(sys_type, "raid1")
+        self.get_property(lv, '.LogicalVolume', 'Layout').assertEqual("raid1")
+
+        def assertSegs(struct, size, pv):
+            self.assertEqual(struct["type"], "linear")
+            self.assertNotIn("data", struct)
+            self.assertNotIn("metadata", struct)
+            if pv is not None:
+                self.assertEqual(len(struct["segments"]), 1)
+                if size is not None:
+                    self.assertEqual(struct["segments"][0][1], size)
+                self.assertEqual(struct["segments"][0][2], pv.object_path)
+            else:
+                self.assertEqual(len(struct["segments"]), 0)
+
+        def assertRaid1Stripes(structs, size, pv1, pv2):
+            self.assertEqual(len(structs), 2)
+            assertSegs(structs[0], size, pv1)
+            assertSegs(structs[1], size, pv2)
+
+        def assertRaid1Structure(pv1, pv2):
+            struct = self.get_property(lv, '.LogicalVolume', 'Structure').value
+            self.assertEqual(struct["type"], "raid1")
+            self.assertEqual(struct["size"], lv_size)
+            self.assertNotIn("segments", struct)
+            assertRaid1Stripes(struct["data"], lv_size, pv1, pv2)
+            assertRaid1Stripes(struct["metadata"], None, pv1, pv2)
+
+        def waitRaid1Structure(pv1, pv2):
+            for _ in range(5):
+                try:
+                    assertRaid1Structure(pv1, pv2)
+                    return
+                except AssertionError:
+                    pass
+                time.sleep(1)
+            # Once again for the error message
+            assertRaid1Structure(pv1, pv2)
+
+        waitRaid1Structure(devs[0], devs[1])
+
+        # Yank out the first vdev and repair the LV with the third
+        _ret, _output = self.run_command('echo yes >/sys/block/%s/device/delete' % os.path.basename(self.vdevs[0]))
+        self.get_property(vg, '.VolumeGroup', 'MissingPhysicalVolumes').assertEqual([first_vdev_uuid])
+        _ret, sys_health = self.run_command('lvs -o health_status --noheadings --nosuffix %s/%s' % (vgname, lvname))
+        self.assertEqual(sys_health, "partial")
+
+        waitRaid1Structure(None, devs[1])
+
+        lv.Repair(devs[2:3], self.no_options,
+                  dbus_interface=self.iface_prefix + '.LogicalVolume')
+        _ret, sys_health = self.run_command('lvs -o health_status --noheadings --nosuffix %s/%s' % (vgname, lvname))
+        self.assertEqual(sys_health, "")
+        self.get_property(lv, '.LogicalVolume', 'SyncRatio').assertEqual(1.0, timeout=60, poll_vg=vg)
+
+        waitRaid1Structure(devs[2], devs[1])
+
+        # Tell the VG that everything is alright
+        vg.RemoveMissingPhysicalVolumes(self.no_options,
+                                        dbus_interface=self.iface_prefix + '.VolumeGroup')
+        self.get_property(vg, '.VolumeGroup', 'MissingPhysicalVolumes').assertEqual([])
+
     def test_20_thin(self):
         '''Test thin volumes functionality'''
 
diff --git a/src/tests/dbus-tests/udiskstestcase.py b/src/tests/dbus-tests/udiskstestcase.py
index 8a8c28c8c7..673bce6bb7 100644
--- a/src/tests/dbus-tests/udiskstestcase.py
+++ b/src/tests/dbus-tests/udiskstestcase.py
@@ -161,7 +161,7 @@ def value(self):
     def _update_value(self):
         self._value = self.obj.Get(self.iface, self.prop, dbus_interface=dbus.PROPERTIES_IFACE)
 
-    def _check(self, timeout, check_fn):
+    def _check(self, timeout, check_fn, poll_vg=None):
         for _ in range(int(timeout / 0.5)):
             try:
                 self._update_value()
@@ -171,16 +171,18 @@ def _check(self, timeout, check_fn):
                 # ignore all exceptions -- they might be result of property
                 # not having the expected type (e.g. 'None' when checking for len)
                 pass
+            if poll_vg:
+                poll_vg.Poll(dbus_interface='org.freedesktop.UDisks2.VolumeGroup')
             time.sleep(0.5)
 
         return False
 
-    def assertEqual(self, value, timeout=TIMEOUT, getter=None):
+    def assertEqual(self, value, timeout=TIMEOUT, getter=None, poll_vg=None):
         if getter is not None:
             check_fn = lambda x: getter(x) == value
         else:
             check_fn = lambda x: x == value
-        ret = self._check(timeout, check_fn)
+        ret = self._check(timeout, check_fn, poll_vg)
 
         if not ret:
             if getter is not None: