diff --git a/blivet/devicelibs/lvm.py b/blivet/devicelibs/lvm.py
index d6a3f4b..469cd34 100644
--- a/blivet/devicelibs/lvm.py
+++ b/blivet/devicelibs/lvm.py
@@ -316,22 +316,32 @@ def vgextend(vg_name, pv_list, rm=False):
         raise LVMError("vgextend failed for %s: %s" % (vg_name, msg))
 
 def vginfo(vg_name):
-    args = ["vgs", "--noheadings", "--nosuffix"] + \
-            ["--units", "m"] + \
+    args = ["vgs", "--noheadings", "--nosuffix", "--nameprefixes"] + \
+            ["--unquoted", "--rows", "--units", "k"] + \
             ["-o", "uuid,size,free,extent_size,extent_count,free_count,pv_count"] + \
             _getConfigArgs(read_only_locking=True) + \
             [vg_name]
 
     buf = util.capture_output(["lvm"] + args)
-    info = buf.split()
-    if len(info) != 7:
-        raise LVMError(_("vginfo failed for %s" % vg_name))
+    vars = buf.split()
+    info = {}
+    for var in vars:
+        (name, equals, value) = var.partition("=")
+        if not equals:
+            continue
+
+        val = value.strip()
+
+        if name not in info:
+            info[name] = []
+
+        info[name].append(val)
 
     return info
 
 def lvs(vg_name):
     args = ["lvs",
-            "--unit", "m", "--nosuffix", "--nameprefixes", "--rows",
+            "-a", "--unit", "m", "--nosuffix", "--nameprefixes", "--rows",
             "--unquoted", "--noheadings",
             "-olv_name,lv_uuid,lv_size,lv_attr"] + \
             _getConfigArgs(read_only_locking=True) + \
diff --git a/blivet/devicetree.py b/blivet/devicetree.py
index 3cb9989..037dbc3 100644
--- a/blivet/devicetree.py
+++ b/blivet/devicetree.py
@@ -1120,21 +1120,10 @@ class DeviceTree(object):
         ret = False
         vg_name = vg_device.name
 
-        if not flags.installer_mode:
-            info = devicelibs.lvm.lvs(vg_name)
-            try:
-                lv_names = udev_device_get_lv_names(info)
-                lv_uuids = udev_device_get_lv_uuids(info)
-                lv_sizes = udev_device_get_lv_sizes(info)
-                lv_attr = udev_device_get_lv_attr(info)
-            except KeyError as e:
-                log.warning("invalid data for %s: %s" % (vg_name, e))
-                return
-        else:
-            lv_names = vg_device.lv_names
-            lv_uuids = vg_device.lv_uuids
-            lv_sizes = vg_device.lv_sizes
-            lv_attr = vg_device.lv_attr
+        lv_names = vg_device.lv_names
+        lv_uuids = vg_device.lv_uuids
+        lv_sizes = vg_device.lv_sizes
+        lv_attr = vg_device.lv_attr
 
         if not vg_device.complete:
             log.warning("Skipping LVs for incomplete VG %s" % vg_name)
@@ -1163,7 +1152,7 @@ class DeviceTree(object):
         # the end
         indices = range(len(lv_names))
         indices.sort(key=lambda i: lv_attr[i], cmp=lv_attr_cmp)
-        mirrors = {}
+        raid = {}
         for index in indices:
             lv_name = lv_names[index]
             name = "%s-%s" % (vg_name, lv_name)
@@ -1196,23 +1185,34 @@ class DeviceTree(object):
                 continue
             elif lv_attr[index][0] in 'Ii':
                 # mirror image
-                lv_name = re.sub(r'_mimage.+', '', lv_name[1:-1])
+                lv_name = re.sub(r'_[rm]image.+', '', lv_name[1:-1])
                 name = "%s-%s" % (vg_name, lv_name)
-                if name not in mirrors:
-                    mirrors[name] = {"stripes": 0, "log": 0}
+                if name not in raid:
+                    raid[name] = {"mirror": 0, "log": 0, "meta": 0}
 
-                mirrors[name]["stripes"] += 1
+                raid[name]["mirror"] += 1
+            elif lv_attr[index][0] in 'e':
+                # metadata
+                lv_name = re.sub(r'_rmeta.+', '', lv_name[1:-1])
+                name = "%s-%s" % (vg_name, lv_name)
+                if name not in raid:
+                    raid[name] = {"mirror": 0, "log": 0, "meta": 0}
+
+                raid[name]["meta"] += lv_sizes[index]
             elif lv_attr[index][0] == 'l':
                 # log volume
                 lv_name = re.sub(r'_mlog.*', '', lv_name[1:-1])
                 name = "%s-%s" % (vg_name, lv_name)
-                if name not in mirrors:
-                    mirrors[name] = {"stripes": 0, "log": 0}
+                if name not in raid:
+                    raid[name] = {"mirror": 0, "log": 0, "meta": 0}
 
-                mirrors[name]["log"] = lv_sizes[index]
+                raid[name]["log"] = lv_sizes[index]
 
             lv_dev = self.getDeviceByUuid(lv_uuids[index])
             if lv_dev is None:
+                lv_dev = self.getDeviceByName(name)
+
+            if lv_dev is None:
                 lv_uuid = lv_uuids[index]
                 lv_size = lv_sizes[index]
                 lv_device = LVMLogicalVolumeDevice(lv_name,
@@ -1236,10 +1236,11 @@ class DeviceTree(object):
 
                 ret = True
 
-        for name, mirror in mirrors.items():
+        for name, raid in raid.items():
             lv_dev = self.getDeviceByName(name)
-            lv_dev.stripes = mirror["stripes"]
-            lv_dev.logSize = mirror["log"]
+            lv_dev.logSize = raid["log"]
+            lv_dev.metaDataSize = raid["meta"]
+            lv_dev.mirrors = raid["mirror"]
             log.debug("set %s stripes to %d, log size to %dMB, total size %dMB"
                         % (lv_dev.name, lv_dev.stripes, lv_dev.logSize,
                            lv_dev.vgSpaceUsed))
@@ -1284,7 +1285,7 @@ class DeviceTree(object):
             self._addDevice(vg_device)
 
         if not flags.installer_mode:
-            info.update(lvm.vginfo(vg_name))
+            info.update(lvm.lvs(vg_name))
 
         # Now we add any lv info found in this pv to the vg_device, we
         # do this for all pvs as pvs only contain lv info for lvs which they
diff --git a/blivet/util.py b/blivet/util.py
index 495dba1..0d8b319 100644
--- a/blivet/util.py
+++ b/blivet/util.py
@@ -33,6 +33,7 @@ def _run_program(argv, root='/', stdin=None, env_prune=None):
                                     stdin=stdin,
                                     stdout=subprocess.PIPE,
                                     stderr=subprocess.STDOUT,
+                                    close_fds=True,
                                     preexec_fn=chroot, cwd=root, env=env)
 
             out = proc.communicate()[0]
