diff --git a/modules/lvm2/data/org.freedesktop.UDisks2.lvm2.xml b/modules/lvm2/data/org.freedesktop.UDisks2.lvm2.xml
index c1d61d44f3..7ff4cebbb2 100644
--- a/modules/lvm2/data/org.freedesktop.UDisks2.lvm2.xml
+++ b/modules/lvm2/data/org.freedesktop.UDisks2.lvm2.xml
@@ -160,6 +160,12 @@
     -->
     <property name="NeedsPolling" type="b" access="read"/>
 
+    <!-- MissingPhysicalVolumes:
+
+         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 +257,26 @@
       <arg name="options" direction="in" type="a{sv}"/>
     </method>
 
+    <!-- RemoveMissingPhysicalVolumes:
+
+         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 +287,29 @@
       <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.
+
+         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 +478,23 @@
     -->
     <property name="Type" type="s" access="read"/>
 
+    <!-- Layout:
+
+         The layout of this logical volume, such as "linear", "raid5",
+         etc.
+    -->
+    <property name="Layout" type="s" access="read"/>
+
+    <!-- SyncRatio:
+
+         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 +616,22 @@
       <arg name="options" type="a{sv}" direction="in"/>
     </method>
 
+    <!-- Repair:
+         @pvs: A list of physical volumes to use for the repair.
+         @options: Additional options.
+
+         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..c309c851ce 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,
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..c455ab9226 100644
--- a/modules/lvm2/udiskslinuxlogicalvolume.c
+++ b/modules/lvm2/udiskslinuxlogicalvolume.c
@@ -145,6 +145,7 @@ 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)
 {
   UDisksLogicalVolume *iface;
@@ -182,6 +183,16 @@ udisks_linux_logical_volume_update (UDisksLinuxLogicalVolume     *logical_volume
         active = TRUE;
     }
   udisks_logical_volume_set_type_ (iface, type);
+  udisks_logical_volume_set_layout (iface, lv_info->segtype);
+  if (g_str_has_prefix (lv_info->segtype, "raid") || g_strcmp0 (lv_info->segtype, "mirror"))
+    {
+      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);
 
@@ -508,6 +519,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 delete 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_return_gerror (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 +1124,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/udiskslinuxmodulelvm2.c b/modules/lvm2/udiskslinuxmodulelvm2.c
index 8e1ea13aec..ac4b5959fa 100644
--- a/modules/lvm2/udiskslinuxmodulelvm2.c
+++ b/modules/lvm2/udiskslinuxmodulelvm2.c
@@ -280,8 +280,10 @@ lvm_update_vgs (GObject      *source_obj,
         }
 
       for (pvs_p = pvs; *pvs_p; pvs_p++)
-        if (g_strcmp0 ((*pvs_p)->vg_name, vg_name) == 0)
+        {
+          if (g_strcmp0 ((*pvs_p)->vg_name, vg_name) == 0)
             vg_pvs = g_slist_prepend (vg_pvs, bd_lvm_pvdata_copy (*pvs_p));
+        }
 
       udisks_linux_volume_group_object_update (group, *vgs_p, vg_pvs);
     }
diff --git a/modules/lvm2/udiskslinuxvolumegroup.c b/modules/lvm2/udiskslinuxvolumegroup.c
index 3fbf6f025b..f8fbadae91 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 a device 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,22 @@ handle_create_volume (UDisksVolumeGroup              *_group,
   data.new_lv_name = arg_name;
   data.new_lv_size = arg_size;
 
+  if (VOL_PLAIN == vol_creation_type)
+    {
+      // XXX - make sure layout is valid (and not something like "thin")
+      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_return_gerror (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 +1090,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 +1118,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 +1133,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 +1152,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 +1169,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 ce941cb250..6e58cb1c3f 100644
--- a/modules/lvm2/udiskslinuxvolumegroupobject.c
+++ b/modules/lvm2/udiskslinuxvolumegroupobject.c
@@ -602,7 +602,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));
@@ -644,13 +645,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);
@@ -793,7 +794,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..a6b68e2494 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
 
@@ -197,6 +198,59 @@ 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_path = vg.CreatePlainVolumeWithLayout(lvname, dbus.UInt64(vdev_size * 0.75),
+                                                 "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")
+
+        # 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")
+        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)
+
+        # 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: