[lvm2.git] / lib / metadata / lv_manip.c

/*
 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
 * Copyright (C) 2004-2012 Red Hat, Inc. All rights reserved.
 *
 * This file is part of LVM2.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU Lesser General Public License v.2.1.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "lib.h"
#include "metadata.h"
#include "locking.h"
#include "pv_map.h"
#include "lvm-string.h"
#include "toolcontext.h"
#include "lv_alloc.h"
#include "pv_alloc.h"
#include "display.h"
#include "segtype.h"
#include "archiver.h"
#include "activate.h"
#include "str_list.h"
#include "defaults.h"

typedef enum {
        PREFERRED,
        USE_AREA,
        NEXT_PV,
        NEXT_AREA
} area_use_t;

/* FIXME: remove RAID_METADATA_AREA_LEN macro after defining 'raid_log_extents'*/
#define RAID_METADATA_AREA_LEN 1

/* FIXME These ended up getting used differently from first intended.  Refactor. */
/* Only one of A_CONTIGUOUS_TO_LVSEG, A_CLING_TO_LVSEG, A_CLING_TO_ALLOCED may be set */
#define A_CONTIGUOUS_TO_LVSEG   0x01    /* Must be contiguous to an existing segment */
#define A_CLING_TO_LVSEG        0x02    /* Must use same disks as existing LV segment */
#define A_CLING_TO_ALLOCED      0x04    /* Must use same disks as already-allocated segment */

#define A_CLING_BY_TAGS         0x08    /* Must match tags against existing segment */
#define A_CAN_SPLIT             0x10

/*
 * Constant parameters during a single allocation attempt.
 */
struct alloc_parms {
        alloc_policy_t alloc;
        unsigned flags;         /* Holds A_* */
        struct lv_segment *prev_lvseg;
        uint32_t extents_still_needed;
};

/*
 * Holds varying state of each allocation attempt.
 */
struct alloc_state {
        struct pv_area_used *areas;
        uint32_t areas_size;
        uint32_t log_area_count_still_needed;   /* Number of areas still needing to be allocated for the log */
        uint32_t allocated;     /* Total number of extents allocated so far */
};

struct lv_names {
        const char *old;
        const char *new;
};

int add_seg_to_segs_using_this_lv(struct logical_volume *lv,
                                  struct lv_segment *seg)
{
        struct seg_list *sl;

        dm_list_iterate_items(sl, &lv->segs_using_this_lv) {
                if (sl->seg == seg) {
                        sl->count++;
                        return 1;
                }
        }

        log_very_verbose("Adding %s:%" PRIu32 " as an user of %s",
                         seg->lv->name, seg->le, lv->name);

        if (!(sl = dm_pool_zalloc(lv->vg->vgmem, sizeof(*sl)))) {
                log_error("Failed to allocate segment list");
                return 0;
        }

        sl->count = 1;
        sl->seg = seg;
        dm_list_add(&lv->segs_using_this_lv, &sl->list);

        return 1;
}

int remove_seg_from_segs_using_this_lv(struct logical_volume *lv,
                                       struct lv_segment *seg)
{
        struct seg_list *sl;

        dm_list_iterate_items(sl, &lv->segs_using_this_lv) {
                if (sl->seg != seg)
                        continue;
                if (sl->count > 1)
                        sl->count--;
                else {
                        log_very_verbose("%s:%" PRIu32 " is no longer a user "
                                         "of %s", seg->lv->name, seg->le,
                                         lv->name);
                        dm_list_del(&sl->list);
                }
                return 1;
        }

        return 0;
}

/*
 * This is a function specialized for the common case where there is
 * only one segment which uses the LV.
 * e.g. the LV is a layer inserted by insert_layer_for_lv().
 *
 * In general, walk through lv->segs_using_this_lv.
 */
struct lv_segment *get_only_segment_using_this_lv(struct logical_volume *lv)
{
        struct seg_list *sl;

        if (dm_list_size(&lv->segs_using_this_lv) != 1) {
                log_error("%s is expected to have only one segment using it, "
                          "while it has %d", lv->name,
                          dm_list_size(&lv->segs_using_this_lv));
                return NULL;
        }

        dm_list_iterate_items(sl, &lv->segs_using_this_lv)
                break; /* first item */

        if (sl->count != 1) {
                log_error("%s is expected to have only one segment using it, "
                          "while %s:%" PRIu32 " uses it %d times",
                          lv->name, sl->seg->lv->name, sl->seg->le, sl->count);
                return NULL;
        }

        return sl->seg;
}

/*
 * PVs used by a segment of an LV
 */
struct seg_pvs {
        struct dm_list list;

        struct dm_list pvs;     /* struct pv_list */

        uint32_t le;
        uint32_t len;
};

static struct seg_pvs *_find_seg_pvs_by_le(struct dm_list *list, uint32_t le)
{
        struct seg_pvs *spvs;

        dm_list_iterate_items(spvs, list)
                if (le >= spvs->le && le < spvs->le + spvs->len)
                        return spvs;

        return NULL;
}

/*
 * Find first unused LV number.
 */
uint32_t find_free_lvnum(struct logical_volume *lv)
{
        int lvnum_used[MAX_RESTRICTED_LVS + 1];
        uint32_t i = 0;
        struct lv_list *lvl;
        int lvnum;

        memset(&lvnum_used, 0, sizeof(lvnum_used));

        dm_list_iterate_items(lvl, &lv->vg->lvs) {
                lvnum = lvnum_from_lvid(&lvl->lv->lvid);
                if (lvnum <= MAX_RESTRICTED_LVS)
                        lvnum_used[lvnum] = 1;
        }

        while (lvnum_used[i])
                i++;

        /* FIXME What if none are free? */

        return i;
}

/*
 * All lv_segments get created here.
 */
struct lv_segment *alloc_lv_segment(const struct segment_type *segtype,
                                    struct logical_volume *lv,
                                    uint32_t le, uint32_t len,
                                    uint64_t status,
                                    uint32_t stripe_size,
                                    struct logical_volume *log_lv,
                                    struct logical_volume *thin_pool_lv,
                                    uint32_t area_count,
                                    uint32_t area_len,
                                    uint32_t chunk_size,
                                    uint32_t region_size,
                                    uint32_t extents_copied,
                                    struct lv_segment *pvmove_source_seg)
{
        struct lv_segment *seg;
        struct dm_pool *mem = lv->vg->vgmem;
        uint32_t areas_sz = area_count * sizeof(*seg->areas);

        if (!segtype) {
                log_error(INTERNAL_ERROR "alloc_lv_segment: Missing segtype.");
                return NULL;
        }

        if (!(seg = dm_pool_zalloc(mem, sizeof(*seg))))
                return_NULL;

        if (!(seg->areas = dm_pool_zalloc(mem, areas_sz))) {
                dm_pool_free(mem, seg);
                return_NULL;
        }

        if (segtype_is_raid(segtype) &&
            !(seg->meta_areas = dm_pool_zalloc(mem, areas_sz))) {
                dm_pool_free(mem, seg); /* frees everything alloced since seg */
                return_NULL;
        }

        seg->segtype = segtype;
        seg->lv = lv;
        seg->le = le;
        seg->len = len;
        seg->status = status;
        seg->stripe_size = stripe_size;
        seg->area_count = area_count;
        seg->area_len = area_len;
        seg->chunk_size = chunk_size;
        seg->region_size = region_size;
        seg->extents_copied = extents_copied;
        seg->pvmove_source_seg = pvmove_source_seg;
        dm_list_init(&seg->tags);
        dm_list_init(&seg->thin_messages);

        if (thin_pool_lv) {
                /* If this thin volume, thin snapshot is being created */
                if (lv_is_thin_volume(thin_pool_lv)) {
                        seg->transaction_id = first_seg(first_seg(thin_pool_lv)->pool_lv)->transaction_id;
                        if (!attach_pool_lv(seg, first_seg(thin_pool_lv)->pool_lv, thin_pool_lv))
                                return_NULL;
                } else {
                        seg->transaction_id = first_seg(thin_pool_lv)->transaction_id;
                        if (!attach_pool_lv(seg, thin_pool_lv, NULL))
                                return_NULL;
                }
        }

        if (log_lv && !attach_mirror_log(seg, log_lv))
                return_NULL;

        return seg;
}

struct lv_segment *alloc_snapshot_seg(struct logical_volume *lv,
                                      uint64_t status, uint32_t old_le_count)
{
        struct lv_segment *seg;
        const struct segment_type *segtype;

        segtype = get_segtype_from_string(lv->vg->cmd, "snapshot");
        if (!segtype) {
                log_error("Failed to find snapshot segtype");
                return NULL;
        }

        if (!(seg = alloc_lv_segment(segtype, lv, old_le_count,
                                     lv->le_count - old_le_count, status, 0,
                                     NULL, NULL, 0, lv->le_count - old_le_count,
                                     0, 0, 0, NULL))) {
                log_error("Couldn't allocate new snapshot segment.");
                return NULL;
        }

        dm_list_add(&lv->segments, &seg->list);
        lv->status |= VIRTUAL;

        return seg;
}

void release_lv_segment_area(struct lv_segment *seg, uint32_t s,
                             uint32_t area_reduction)
{
        if (seg_type(seg, s) == AREA_UNASSIGNED)
                return;

        if (seg_type(seg, s) == AREA_PV) {
                if (release_pv_segment(seg_pvseg(seg, s), area_reduction) &&
                    seg->area_len == area_reduction)
                        seg_type(seg, s) = AREA_UNASSIGNED;
                return;
        }

        if ((seg_lv(seg, s)->status & MIRROR_IMAGE) ||
            (seg_lv(seg, s)->status & THIN_POOL_DATA)) {
                if (!lv_reduce(seg_lv(seg, s), area_reduction))
                        stack; /* FIXME: any upper level reporting */
                return;
        }

        if (seg_lv(seg, s)->status & RAID_IMAGE) {
                /*
                 * FIXME: Use lv_reduce not lv_remove
                 *  We use lv_remove for now, because I haven't figured out
                 *  why lv_reduce won't remove the LV.
                lv_reduce(seg_lv(seg, s), area_reduction);
                */
                if (area_reduction != seg->area_len) {
                        log_error("Unable to reduce RAID LV - operation not implemented.");
                        return;
                } else {
                        if (!lv_remove(seg_lv(seg, s))) {
                                log_error("Failed to remove RAID image %s",
                                          seg_lv(seg, s)->name);
                                return;
                        }
                }

                /* Remove metadata area if image has been removed */
                if (area_reduction == seg->area_len) {
                        if (!lv_reduce(seg_metalv(seg, s),
                                       seg_metalv(seg, s)->le_count)) {
                                log_error("Failed to remove RAID meta-device %s",
                                          seg_metalv(seg, s)->name);
                                return;
                        }
                }
                return;
        }

        if (area_reduction == seg->area_len) {
                log_very_verbose("Remove %s:%" PRIu32 "[%" PRIu32 "] from "
                                 "the top of LV %s:%" PRIu32,
                                 seg->lv->name, seg->le, s,
                                 seg_lv(seg, s)->name, seg_le(seg, s));

                remove_seg_from_segs_using_this_lv(seg_lv(seg, s), seg);
                seg_lv(seg, s) = NULL;
                seg_le(seg, s) = 0;
                seg_type(seg, s) = AREA_UNASSIGNED;
        }
}

/*
 * Move a segment area from one segment to another
 */
int move_lv_segment_area(struct lv_segment *seg_to, uint32_t area_to,
                         struct lv_segment *seg_from, uint32_t area_from)
{
        struct physical_volume *pv;
        struct logical_volume *lv;
        uint32_t pe, le;

        switch (seg_type(seg_from, area_from)) {
        case AREA_PV:
                pv = seg_pv(seg_from, area_from);
                pe = seg_pe(seg_from, area_from);

                release_lv_segment_area(seg_from, area_from,
                                        seg_from->area_len);
                release_lv_segment_area(seg_to, area_to, seg_to->area_len);

                if (!set_lv_segment_area_pv(seg_to, area_to, pv, pe))
                        return_0;

                break;

        case AREA_LV:
                lv = seg_lv(seg_from, area_from);
                le = seg_le(seg_from, area_from);

                release_lv_segment_area(seg_from, area_from,
                                        seg_from->area_len);
                release_lv_segment_area(seg_to, area_to, seg_to->area_len);

                if (!set_lv_segment_area_lv(seg_to, area_to, lv, le, 0))
                        return_0;

                break;

        case AREA_UNASSIGNED:
                release_lv_segment_area(seg_to, area_to, seg_to->area_len);
        }

        return 1;
}

/*
 * Link part of a PV to an LV segment.
 */
int set_lv_segment_area_pv(struct lv_segment *seg, uint32_t area_num,
                           struct physical_volume *pv, uint32_t pe)
{
        seg->areas[area_num].type = AREA_PV;

        if (!(seg_pvseg(seg, area_num) =
              assign_peg_to_lvseg(pv, pe, seg->area_len, seg, area_num)))
                return_0;

        return 1;
}

/*
 * Link one LV segment to another.  Assumes sizes already match.
 */
int set_lv_segment_area_lv(struct lv_segment *seg, uint32_t area_num,
                           struct logical_volume *lv, uint32_t le,
                           uint64_t status)
{
        log_very_verbose("Stack %s:%" PRIu32 "[%" PRIu32 "] on LV %s:%" PRIu32,
                         seg->lv->name, seg->le, area_num, lv->name, le);

        if (status & RAID_META) {
                seg->meta_areas[area_num].type = AREA_LV;
                seg_metalv(seg, area_num) = lv;
                if (le) {
                        log_error(INTERNAL_ERROR "Meta le != 0");
                        return 0;
                }
                seg_metale(seg, area_num) = 0;
        } else {
                seg->areas[area_num].type = AREA_LV;
                seg_lv(seg, area_num) = lv;
                seg_le(seg, area_num) = le;
        }
        lv->status |= status;

        if (!add_seg_to_segs_using_this_lv(lv, seg))
                return_0;

        return 1;
}

/*
 * Prepare for adding parallel areas to an existing segment.
 */
static int _lv_segment_add_areas(struct logical_volume *lv,
                                 struct lv_segment *seg,
                                 uint32_t new_area_count)
{
        struct lv_segment_area *newareas;
        uint32_t areas_sz = new_area_count * sizeof(*newareas);

        if (!(newareas = dm_pool_zalloc(lv->vg->cmd->mem, areas_sz)))
                return_0;

        memcpy(newareas, seg->areas, seg->area_count * sizeof(*seg->areas));

        seg->areas = newareas;
        seg->area_count = new_area_count;

        return 1;
}

/*
 * Reduce the size of an lv_segment.  New size can be zero.
 */
static int _lv_segment_reduce(struct lv_segment *seg, uint32_t reduction)
{
        uint32_t area_reduction, s;

        /* Caller must ensure exact divisibility */
        if (seg_is_striped(seg)) {
                if (reduction % seg->area_count) {
                        log_error("Segment extent reduction %" PRIu32
                                  " not divisible by #stripes %" PRIu32,
                                  reduction, seg->area_count);
                        return 0;
                }
                area_reduction = (reduction / seg->area_count);
        } else
                area_reduction = reduction;

        for (s = 0; s < seg->area_count; s++)
                release_lv_segment_area(seg, s, area_reduction);

        seg->len -= reduction;
        seg->area_len -= area_reduction;

        return 1;
}

/*
 * Entry point for all LV reductions in size.
 */
static int _lv_reduce(struct logical_volume *lv, uint32_t extents, int delete)
{
        struct lv_segment *seg;
        uint32_t count = extents;
        uint32_t reduction;

        dm_list_iterate_back_items(seg, &lv->segments) {
                if (!count)
                        break;

                if (seg->len <= count) {
                        /* remove this segment completely */
                        /* FIXME Check this is safe */
                        if (seg->log_lv && !lv_remove(seg->log_lv))
                                return_0;

                        if (seg->metadata_lv && !lv_remove(seg->metadata_lv))
                                return_0;

                        if (seg->pool_lv) {
                                if (!detach_pool_lv(seg))
                                        return_0;
                        }

                        dm_list_del(&seg->list);
                        reduction = seg->len;
                } else
                        reduction = count;

                if (!_lv_segment_reduce(seg, reduction))
                        return_0;
                count -= reduction;
        }

        lv->le_count -= extents;
        lv->size = (uint64_t) lv->le_count * lv->vg->extent_size;

        if (!delete)
                return 1;

        /* Remove the LV if it is now empty */
        if (!lv->le_count && !unlink_lv_from_vg(lv))
                return_0;
        else if (lv->vg->fid->fmt->ops->lv_setup &&
                   !lv->vg->fid->fmt->ops->lv_setup(lv->vg->fid, lv))
                return_0;

        return 1;
}

/*
 * Empty an LV.
 */
int lv_empty(struct logical_volume *lv)
{
        return _lv_reduce(lv, lv->le_count, 0);
}

/*
 * Empty an LV and add error segment.
 */
int replace_lv_with_error_segment(struct logical_volume *lv)
{
        uint32_t len = lv->le_count;

        if (len && !lv_empty(lv))
                return_0;

        /* Minimum size required for a table. */
        if (!len)
                len = 1;

        /*
         * Since we are replacing the whatever-was-there with
         * an error segment, we should also clear any flags
         * that suggest it is anything other than "error".
         */
        lv->status &= ~(MIRRORED|PVMOVE);

        /* FIXME: Should we bug if we find a log_lv attached? */

        if (!lv_add_virtual_segment(lv, 0, len, get_segtype_from_string(lv->vg->cmd, "error"), NULL))
                return_0;

        return 1;
}

/*
 * Remove given number of extents from LV.
 */
int lv_reduce(struct logical_volume *lv, uint32_t extents)
{
        return _lv_reduce(lv, extents, 1);
}

/*
 * Completely remove an LV.
 */
int lv_remove(struct logical_volume *lv)
{

        if (!lv_reduce(lv, lv->le_count))
                return_0;

        return 1;
}

/*
 * A set of contiguous physical extents allocated
 */
struct alloced_area {
        struct dm_list list;

        struct physical_volume *pv;
        uint32_t pe;
        uint32_t len;
};

/*
 * Details of an allocation attempt
 */
struct alloc_handle {
        struct cmd_context *cmd;
        struct dm_pool *mem;

        alloc_policy_t alloc;           /* Overall policy */
        uint32_t new_extents;           /* Number of new extents required */
        uint32_t area_count;            /* Number of parallel areas */
        uint32_t parity_count;   /* Adds to area_count, but not area_multiple */
        uint32_t area_multiple;         /* seg->len = area_len * area_multiple */
        uint32_t log_area_count;        /* Number of parallel logs */
        uint32_t metadata_area_count;   /* Number of parallel metadata areas */
        uint32_t log_len;               /* Length of log/metadata_area */
        uint32_t region_size;           /* Mirror region size */
        uint32_t total_area_len;        /* Total number of parallel extents */

        unsigned maximise_cling;
        unsigned mirror_logs_separate;  /* Force mirror logs on separate PVs? */

        /*
         * RAID devices require a metadata area that accompanies each
         * device.  During initial creation, it is best to look for space
         * that is new_extents + log_len and then split that between two
         * allocated areas when found.  'alloc_and_split_meta' indicates
         * that this is the desired dynamic.
         */
        unsigned alloc_and_split_meta;

        const struct dm_config_node *cling_tag_list_cn;

        struct dm_list *parallel_areas; /* PVs to avoid */

        /*
         * Contains area_count lists of areas allocated to data stripes
         * followed by log_area_count lists of areas allocated to log stripes.
         */
        struct dm_list alloced_areas[0];
};

static uint32_t _calc_area_multiple(const struct segment_type *segtype,
                                    const uint32_t area_count, const uint32_t stripes)
{
        if (!area_count)
                return 1;

        /* Striped */
        if (segtype_is_striped(segtype))
                return area_count;

        /* Mirrored stripes */
        if (stripes)
                return stripes;

        /* Mirrored */
        return 1;
}

/*
 * Returns log device size in extents, algorithm from kernel code
 */
#define BYTE_SHIFT 3
static uint32_t mirror_log_extents(uint32_t region_size, uint32_t pe_size, uint32_t area_len)
{
        size_t area_size, bitset_size, log_size, region_count;

        area_size = area_len * pe_size;
        region_count = dm_div_up(area_size, region_size);

        /* Work out how many "unsigned long"s we need to hold the bitset. */
        bitset_size = dm_round_up(region_count, sizeof(uint32_t) << BYTE_SHIFT);
        bitset_size >>= BYTE_SHIFT;

        /* Log device holds both header and bitset. */
        log_size = dm_round_up((MIRROR_LOG_OFFSET << SECTOR_SHIFT) + bitset_size, 1 << SECTOR_SHIFT);
        log_size >>= SECTOR_SHIFT;
        log_size = dm_div_up(log_size, pe_size);

        /*
         * Kernel requires a mirror to be at least 1 region large.  So,
         * if our mirror log is itself a mirror, it must be at least
         * 1 region large.  This restriction may not be necessary for
         * non-mirrored logs, but we apply the rule anyway.
         *
         * (The other option is to make the region size of the log
         * mirror smaller than the mirror it is acting as a log for,
         * but that really complicates things.  It's much easier to
         * keep the region_size the same for both.)
         */
        return (log_size > (region_size / pe_size)) ? log_size :
                (region_size / pe_size);
}

/*
 * Preparation for a specific allocation attempt
 * stripes and mirrors refer to the parallel areas used for data.
 * If log_area_count > 1 it is always mirrored (not striped).
 */
static struct alloc_handle *_alloc_init(struct cmd_context *cmd,
                                        struct dm_pool *mem,
                                        const struct segment_type *segtype,
                                        alloc_policy_t alloc,
                                        uint32_t new_extents,
                                        uint32_t mirrors,
                                        uint32_t stripes,
                                        uint32_t metadata_area_count,
                                        uint32_t extent_size,
                                        uint32_t region_size,
                                        struct dm_list *parallel_areas)
{
        struct alloc_handle *ah;
        uint32_t s, area_count, alloc_count, parity_count;
        size_t size = 0;

        /* FIXME Caller should ensure this */
        if (mirrors && !stripes)
                stripes = 1;

        if (segtype_is_virtual(segtype))
                area_count = 0;
        else if (mirrors > 1)
                area_count = mirrors * stripes;
        else
                area_count = stripes;

        size = sizeof(*ah);

        /*
         * It is a requirement that RAID 4/5/6 are created with a number of
         * stripes that is greater than the number of parity devices.  (e.g
         * RAID4/5 must have at least 2 stripes and RAID6 must have at least
         * 3.)  It is also a constraint that, when replacing individual devices
         * in a RAID 4/5/6 array, no more devices can be replaced than
         * there are parity devices.  (Otherwise, there would not be enough
         * redundancy to maintain the array.)  Understanding these two
         * constraints allows us to infer whether the caller of this function
         * is intending to allocate an entire array or just replacement
         * component devices.  In the former case, we must account for the
         * necessary parity_count.  In the later case, we do not need to
         * account for the extra parity devices because the array already
         * exists and they only want replacement drives.
         */
        parity_count = (area_count <= segtype->parity_devs) ? 0 :
                segtype->parity_devs;
        alloc_count = area_count + parity_count;
        if (segtype_is_raid(segtype) && metadata_area_count)
                /* RAID has a meta area for each device */
                alloc_count *= 2;
        else
                /* mirrors specify their exact log count */
                alloc_count += metadata_area_count;

        size += sizeof(ah->alloced_areas[0]) * alloc_count;

        if (!(ah = dm_pool_zalloc(mem, size))) {
                log_error("allocation handle allocation failed");
                return NULL;
        }

        ah->cmd = cmd;

        if (segtype_is_virtual(segtype))
                return ah;

        if (!(area_count + metadata_area_count)) {
                log_error(INTERNAL_ERROR "_alloc_init called for non-virtual segment with no disk space.");
                return NULL;
        }

        if (!(ah->mem = dm_pool_create("allocation", 1024))) {
                log_error("allocation pool creation failed");
                return NULL;
        }

        if (mirrors || stripes)
                ah->new_extents = new_extents;
        else
                ah->new_extents = 0;
        ah->area_count = area_count;
        ah->parity_count = parity_count;
        ah->region_size = region_size;
        ah->alloc = alloc;
        ah->area_multiple = _calc_area_multiple(segtype, area_count, stripes);
        ah->mirror_logs_separate = find_config_tree_bool(cmd, "allocation/mirror_logs_require_separate_pvs",
                                                         DEFAULT_MIRROR_LOGS_REQUIRE_SEPARATE_PVS);

        if (segtype_is_raid(segtype)) {
                if (metadata_area_count) {
                        if (metadata_area_count != area_count)
                                log_error(INTERNAL_ERROR
                                          "Bad metadata_area_count");
                        ah->metadata_area_count = area_count;
                        ah->alloc_and_split_meta = 1;

                        ah->log_len = RAID_METADATA_AREA_LEN;

                        /*
                         * We need 'log_len' extents for each
                         * RAID device's metadata_area
                         */
                        ah->new_extents += (ah->log_len * ah->area_multiple);
                } else {
                        ah->log_area_count = 0;
                        ah->log_len = 0;
                }
        } else if (segtype_is_thin_pool(segtype)) {
                ah->log_area_count = metadata_area_count;
                /* thin_pool uses region_size to pass metadata size in extents */
                ah->log_len = ah->region_size;
                ah->region_size = 0;
                ah->mirror_logs_separate =
                        find_config_tree_bool(cmd, "allocation/thin_pool_metadata_require_separate_pvs",
                                              DEFAULT_THIN_POOL_METADATA_REQUIRE_SEPARATE_PVS);
        } else {
                ah->log_area_count = metadata_area_count;
                ah->log_len = !metadata_area_count ? 0 :
                        mirror_log_extents(ah->region_size, extent_size,
                                           new_extents / ah->area_multiple);
        }

        for (s = 0; s < alloc_count; s++)
                dm_list_init(&ah->alloced_areas[s]);

        ah->parallel_areas = parallel_areas;

        ah->cling_tag_list_cn = find_config_tree_node(cmd, "allocation/cling_tag_list");

        ah->maximise_cling = find_config_tree_bool(cmd, "allocation/maximise_cling", DEFAULT_MAXIMISE_CLING);

        return ah;
}

void alloc_destroy(struct alloc_handle *ah)
{
        if (ah->mem)
                dm_pool_destroy(ah->mem);
}

/* Is there enough total space or should we give up immediately? */
static int _sufficient_pes_free(struct alloc_handle *ah, struct dm_list *pvms,
                                uint32_t allocated, uint32_t extents_still_needed)
{
        uint32_t area_extents_needed = (extents_still_needed - allocated) * ah->area_count / ah->area_multiple;
        uint32_t parity_extents_needed = (extents_still_needed - allocated) * ah->parity_count / ah->area_multiple;
        uint32_t metadata_extents_needed = ah->metadata_area_count * RAID_METADATA_AREA_LEN; /* One each */
        uint32_t total_extents_needed = area_extents_needed + parity_extents_needed + metadata_extents_needed;
        uint32_t free_pes = pv_maps_size(pvms);

        if (total_extents_needed > free_pes) {
                log_error("Insufficient free space: %" PRIu32 " extents needed,"
                          " but only %" PRIu32 " available",
                          total_extents_needed, free_pes);
                return 0;
        }

        return 1;
}

/* For striped mirrors, all the areas are counted, through the mirror layer */
static uint32_t _stripes_per_mimage(struct lv_segment *seg)
{
        struct lv_segment *last_lvseg;

        if (seg_is_mirrored(seg) && seg->area_count && seg_type(seg, 0) == AREA_LV) {
                last_lvseg = dm_list_item(dm_list_last(&seg_lv(seg, 0)->segments), struct lv_segment);
                if (seg_is_striped(last_lvseg))
                        return last_lvseg->area_count;
        }

        return 1;
}

static void _init_alloc_parms(struct alloc_handle *ah, struct alloc_parms *alloc_parms, alloc_policy_t alloc,
                              struct lv_segment *prev_lvseg, unsigned can_split,
                              uint32_t allocated, uint32_t extents_still_needed)
{
        alloc_parms->alloc = alloc;
        alloc_parms->prev_lvseg = prev_lvseg;
        alloc_parms->flags = 0;
        alloc_parms->extents_still_needed = extents_still_needed;

        /* Are there any preceding segments we must follow on from? */
        if (alloc_parms->prev_lvseg) {
                if (alloc_parms->alloc == ALLOC_CONTIGUOUS)
                        alloc_parms->flags |= A_CONTIGUOUS_TO_LVSEG;
                else if ((alloc_parms->alloc == ALLOC_CLING) || (alloc_parms->alloc == ALLOC_CLING_BY_TAGS))
                        alloc_parms->flags |= A_CLING_TO_LVSEG;
        } else
                /*
                 * A cling allocation that follows a successful contiguous allocation
                 * must use the same PVs (or else fail).
                 */
                if ((alloc_parms->alloc == ALLOC_CLING) || (alloc_parms->alloc == ALLOC_CLING_BY_TAGS))
                        alloc_parms->flags |= A_CLING_TO_ALLOCED;

        if (alloc_parms->alloc == ALLOC_CLING_BY_TAGS)
                alloc_parms->flags |= A_CLING_BY_TAGS;

        /*
         * For normal allocations, if any extents have already been found 
         * for allocation, prefer to place further extents on the same disks as
         * have already been used.
         */
        if (ah->maximise_cling && alloc_parms->alloc == ALLOC_NORMAL && allocated != alloc_parms->extents_still_needed)
                alloc_parms->flags |= A_CLING_TO_ALLOCED;

        if (can_split)
                alloc_parms->flags |= A_CAN_SPLIT;
}

static int _log_parallel_areas(struct dm_pool *mem, struct dm_list *parallel_areas)
{
        struct seg_pvs *spvs;
        struct pv_list *pvl;
        char *pvnames;

        if (!parallel_areas)
                return 1;

        dm_list_iterate_items(spvs, parallel_areas) {
                if (!dm_pool_begin_object(mem, 256)) {
                        log_error("dm_pool_begin_object failed");
                        return 0;
                }

                dm_list_iterate_items(pvl, &spvs->pvs) {
                        if (!dm_pool_grow_object(mem, pv_dev_name(pvl->pv), strlen(pv_dev_name(pvl->pv)))) {
                                log_error("dm_pool_grow_object failed");
                                dm_pool_abandon_object(mem);
                                return 0;
                        }
                        if (!dm_pool_grow_object(mem, " ", 1)) {
                                log_error("dm_pool_grow_object failed");
                                dm_pool_abandon_object(mem);
                                return 0;
                        }
                }

                if (!dm_pool_grow_object(mem, "\0", 1)) {
                        log_error("dm_pool_grow_object failed");
                        dm_pool_abandon_object(mem);
                        return 0;
                }

                pvnames = dm_pool_end_object(mem);
                log_debug("Parallel PVs at LE %" PRIu32 " length %" PRIu32 ": %s",
                          spvs->le, spvs->len, pvnames);
                dm_pool_free(mem, pvnames);
        }

        return 1;
}

static int _setup_alloced_segment(struct logical_volume *lv, uint64_t status,
                                  uint32_t area_count,
                                  uint32_t stripe_size,
                                  const struct segment_type *segtype,
                                  struct alloced_area *aa,
                                  uint32_t region_size)
{
        uint32_t s, extents, area_multiple;
        struct lv_segment *seg;

        area_multiple = _calc_area_multiple(segtype, area_count, 0);

        if (!(seg = alloc_lv_segment(segtype, lv, lv->le_count,
                                     aa[0].len * area_multiple,
                                     status, stripe_size, NULL, NULL,
                                     area_count,
                                     aa[0].len, 0u, region_size, 0u, NULL))) {
                log_error("Couldn't allocate new LV segment.");
                return 0;
        }

        for (s = 0; s < area_count; s++)
                if (!set_lv_segment_area_pv(seg, s, aa[s].pv, aa[s].pe))
                        return_0;

        dm_list_add(&lv->segments, &seg->list);

        extents = aa[0].len * area_multiple;
        lv->le_count += extents;
        lv->size += (uint64_t) extents *lv->vg->extent_size;

        if (segtype_is_mirrored(segtype))
                lv->status |= MIRRORED;

        return 1;
}

static int _setup_alloced_segments(struct logical_volume *lv,
                                   struct dm_list *alloced_areas,
                                   uint32_t area_count,
                                   uint64_t status,
                                   uint32_t stripe_size,
                                   const struct segment_type *segtype,
                                   uint32_t region_size)
{
        struct alloced_area *aa;

        dm_list_iterate_items(aa, &alloced_areas[0]) {
                if (!_setup_alloced_segment(lv, status, area_count,
                                            stripe_size, segtype, aa,
                                            region_size))
                        return_0;
        }

        return 1;
}

/*
 * This function takes a list of pv_areas and adds them to allocated_areas.
 * If the complete area is not needed then it gets split.
 * The part used is removed from the pv_map so it can't be allocated twice.
 */
static int _alloc_parallel_area(struct alloc_handle *ah, uint32_t max_to_allocate,
                                struct alloc_state *alloc_state, uint32_t ix_log_offset)
{
        uint32_t area_len, len;
        uint32_t s;
        uint32_t ix_log_skip = 0; /* How many areas to skip in middle of array to reach log areas */
        uint32_t total_area_count;
        struct alloced_area *aa;
        struct pv_area *pva;

        total_area_count = ah->area_count + alloc_state->log_area_count_still_needed;
        total_area_count += ah->parity_count;
        if (!total_area_count) {
                log_error(INTERNAL_ERROR "_alloc_parallel_area called without any allocation to do.");
                return 1;
        }

        area_len = max_to_allocate / ah->area_multiple;

        /* Reduce area_len to the smallest of the areas */
        for (s = 0; s < ah->area_count + ah->parity_count; s++)
                if (area_len > alloc_state->areas[s].used)
                        area_len = alloc_state->areas[s].used;

        len = (ah->alloc_and_split_meta) ? total_area_count * 2 : total_area_count;
        len *= sizeof(*aa);
        if (!(aa = dm_pool_alloc(ah->mem, len))) {
                log_error("alloced_area allocation failed");
                return 0;
        }

        /*
         * Areas consists of area_count areas for data stripes, then
         * ix_log_skip areas to skip, then log_area_count areas to use for the
         * log, then some areas too small for the log.
         */
        len = area_len;
        for (s = 0; s < total_area_count; s++) {
                if (s == (ah->area_count + ah->parity_count)) {
                        ix_log_skip = ix_log_offset - ah->area_count;
                        len = ah->log_len;
                }

                pva = alloc_state->areas[s + ix_log_skip].pva;
                if (ah->alloc_and_split_meta) {
                        /*
                         * The metadata area goes at the front of the allocated
                         * space for now, but could easily go at the end (or
                         * middle!).
                         *
                         * Even though we split these two from the same
                         * allocation, we store the images at the beginning
                         * of the areas array and the metadata at the end.
                         */
                        s += ah->area_count + ah->parity_count;
                        aa[s].pv = pva->map->pv;
                        aa[s].pe = pva->start;
                        aa[s].len = ah->log_len;

                        log_debug("Allocating parallel metadata area %" PRIu32
                                  " on %s start PE %" PRIu32
                                  " length %" PRIu32 ".",
                                  (s - (ah->area_count + ah->parity_count)),
                                  pv_dev_name(aa[s].pv), aa[s].pe,
                                  ah->log_len);

                        consume_pv_area(pva, ah->log_len);
                        dm_list_add(&ah->alloced_areas[s], &aa[s].list);
                        s -= ah->area_count + ah->parity_count;
                }
                aa[s].pv = pva->map->pv;
                aa[s].pe = pva->start;
                aa[s].len = (ah->alloc_and_split_meta) ? len - ah->log_len : len;

                log_debug("Allocating parallel area %" PRIu32
                          " on %s start PE %" PRIu32 " length %" PRIu32 ".",
                          s, pv_dev_name(aa[s].pv), aa[s].pe, aa[s].len);

                consume_pv_area(pva, aa[s].len);

                dm_list_add(&ah->alloced_areas[s], &aa[s].list);
        }

        /* Only need to alloc metadata from the first batch */
        ah->alloc_and_split_meta = 0;

        ah->total_area_len += area_len;

        alloc_state->allocated += area_len * ah->area_multiple;

        return 1;
}

/*
 * Call fn for each AREA_PV used by the LV segment at lv:le of length *max_seg_len.
 * If any constituent area contains more than one segment, max_seg_len is
 * reduced to cover only the first.
 * fn should return 0 on error, 1 to continue scanning or >1 to terminate without error.
 * In the last case, this function passes on the return code.
 */
static int _for_each_pv(struct cmd_context *cmd, struct logical_volume *lv,
                        uint32_t le, uint32_t len, struct lv_segment *seg,
                        uint32_t *max_seg_len,
                        uint32_t first_area, uint32_t max_areas,
                        int top_level_area_index,
                        int only_single_area_segments,
                        int (*fn)(struct cmd_context *cmd,
                                  struct pv_segment *peg, uint32_t s,
                                  void *data),
                        void *data)
{
        uint32_t s;
        uint32_t remaining_seg_len, area_len, area_multiple;
        uint32_t stripes_per_mimage = 1;
        int r = 1;

        if (!seg && !(seg = find_seg_by_le(lv, le))) {
                log_error("Failed to find segment for %s extent %" PRIu32,
                          lv->name, le);
                return 0;
        }

        /* Remaining logical length of segment */
        remaining_seg_len = seg->len - (le - seg->le);

        if (remaining_seg_len > len)
                remaining_seg_len = len;

        if (max_seg_len && *max_seg_len > remaining_seg_len)
                *max_seg_len = remaining_seg_len;

        area_multiple = _calc_area_multiple(seg->segtype, seg->area_count, 0);
        area_len = remaining_seg_len / area_multiple ? : 1;

        /* For striped mirrors, all the areas are counted, through the mirror layer */
        if (top_level_area_index == -1)
                stripes_per_mimage = _stripes_per_mimage(seg);

        for (s = first_area;
             s < seg->area_count && (!max_areas || s <= max_areas);
             s++) {
                if (seg_type(seg, s) == AREA_LV) {
                        if (!(r = _for_each_pv(cmd, seg_lv(seg, s),
                                               seg_le(seg, s) +
                                               (le - seg->le) / area_multiple,
                                               area_len, NULL, max_seg_len, 0,
                                               (stripes_per_mimage == 1) && only_single_area_segments ? 1U : 0U,
                                               (top_level_area_index != -1) ? top_level_area_index : (int) (s * stripes_per_mimage),
                                               only_single_area_segments, fn,
                                               data)))
                                stack;
                } else if (seg_type(seg, s) == AREA_PV)
                        if (!(r = fn(cmd, seg_pvseg(seg, s), top_level_area_index != -1 ? (uint32_t) top_level_area_index + s : s, data)))
                                stack;
                if (r != 1)
                        return r;
        }

        /* FIXME only_single_area_segments used as workaround to skip log LV - needs new param? */
        if (!only_single_area_segments && seg_is_mirrored(seg) && seg->log_lv) {
                if (!(r = _for_each_pv(cmd, seg->log_lv, 0, seg->log_lv->le_count, NULL,
                                       NULL, 0, 0, 0, only_single_area_segments,
                                       fn, data)))
                        stack;
                if (r != 1)
                        return r;
        }

        /* FIXME Add snapshot cow LVs etc. */

        return 1;
}

static int _comp_area(const void *l, const void *r)
{
        const struct pv_area_used *lhs = (const struct pv_area_used *) l;
        const struct pv_area_used *rhs = (const struct pv_area_used *) r;

        if (lhs->used < rhs->used)
                return 1;

        else if (lhs->used > rhs->used)
                return -1;

        return 0;
}

/*
 * Search for pvseg that matches condition
 */
struct pv_match {
        int (*condition)(struct pv_match *pvmatch, struct pv_segment *pvseg, struct pv_area *pva);

        struct pv_area_used *areas;
        struct pv_area *pva;
        uint32_t areas_size;
        const struct dm_config_node *cling_tag_list_cn;
        int s;  /* Area index of match */
};

/*
 * Is PV area on the same PV?
 */
static int _is_same_pv(struct pv_match *pvmatch __attribute((unused)), struct pv_segment *pvseg, struct pv_area *pva)
{
        if (pvseg->pv != pva->map->pv)
                return 0;

        return 1;
}

/*
 * Does PV area have a tag listed in allocation/cling_tag_list that 
 * matches a tag of the PV of the existing segment?
 */
static int _pvs_have_matching_tag(const struct dm_config_node *cling_tag_list_cn, struct physical_volume *pv1, struct physical_volume *pv2)
{
        const struct dm_config_value *cv;
        const char *str;
        const char *tag_matched;

        for (cv = cling_tag_list_cn->v; cv; cv = cv->next) {
                if (cv->type != DM_CFG_STRING) {
                        log_error("Ignoring invalid string in config file entry "
                                  "allocation/cling_tag_list");
                        continue;
                }
                str = cv->v.str;
                if (!*str) {
                        log_error("Ignoring empty string in config file entry "
                                  "allocation/cling_tag_list");
                        continue;
                }

                if (*str != '@') {
                        log_error("Ignoring string not starting with @ in config file entry "
                                  "allocation/cling_tag_list: %s", str);
                        continue;
                }

                str++;

                if (!*str) {
                        log_error("Ignoring empty tag in config file entry "
                                  "allocation/cling_tag_list");
                        continue;
                }

                /* Wildcard matches any tag against any tag. */
                if (!strcmp(str, "*")) {
                        if (!str_list_match_list(&pv1->tags, &pv2->tags, &tag_matched))
                                continue;
                        else {
                                log_debug("Matched allocation PV tag %s on existing %s with free space on %s.",
                                          tag_matched, pv_dev_name(pv1), pv_dev_name(pv2));
                                return 1;
                        }
                }

                if (!str_list_match_item(&pv1->tags, str) ||
                    !str_list_match_item(&pv2->tags, str))
                        continue;
                else {
                        log_debug("Matched allocation PV tag %s on existing %s with free space on %s.",
                                  str, pv_dev_name(pv1), pv_dev_name(pv2));
                        return 1;
                }
        }

        return 0;
}

static int _has_matching_pv_tag(struct pv_match *pvmatch, struct pv_segment *pvseg, struct pv_area *pva)
{
        return _pvs_have_matching_tag(pvmatch->cling_tag_list_cn, pvseg->pv, pva->map->pv);
}

/*
 * Is PV area contiguous to PV segment?
 */
static int _is_contiguous(struct pv_match *pvmatch __attribute((unused)), struct pv_segment *pvseg, struct pv_area *pva)
{
        if (pvseg->pv != pva->map->pv)
                return 0;

        if (pvseg->pe + pvseg->len != pva->start)
                return 0;

        return 1;
}

static void _reserve_area(struct pv_area_used *area_used, struct pv_area *pva, uint32_t required,
                          uint32_t ix_pva, uint32_t unreserved)
{
        log_debug("%s allocation area %" PRIu32 " %s %s start PE %" PRIu32
                  " length %" PRIu32 " leaving %" PRIu32 ".",
                  area_used->pva ? "Changing   " : "Considering", 
                  ix_pva - 1, area_used->pva ? "to" : "as", 
                  dev_name(pva->map->pv->dev), pva->start, required, unreserved);

        area_used->pva = pva;
        area_used->used = required;
}

static int _is_condition(struct cmd_context *cmd __attribute__((unused)),
                         struct pv_segment *pvseg, uint32_t s,
                         void *data)
{
        struct pv_match *pvmatch = data;

        if (pvmatch->areas[s].pva)
                return 1;       /* Area already assigned */

        if (!pvmatch->condition(pvmatch, pvseg, pvmatch->pva))
                return 1;       /* Continue */

        if (s >= pvmatch->areas_size)
                return 1;

        /*
         * Only used for cling and contiguous policies (which only make one allocation per PV)
         * so it's safe to say all the available space is used.
         */
        _reserve_area(&pvmatch->areas[s], pvmatch->pva, pvmatch->pva->count, s + 1, 0);

        return 2;       /* Finished */
}

/*
 * Is pva on same PV as any existing areas?
 */
static int _check_cling(struct alloc_handle *ah,
                        const struct dm_config_node *cling_tag_list_cn,
                        struct lv_segment *prev_lvseg, struct pv_area *pva,
                        struct alloc_state *alloc_state)
{
        struct pv_match pvmatch;
        int r;
        uint32_t le, len;

        pvmatch.condition = cling_tag_list_cn ? _has_matching_pv_tag : _is_same_pv;
        pvmatch.areas = alloc_state->areas;
        pvmatch.areas_size = alloc_state->areas_size;
        pvmatch.pva = pva;
        pvmatch.cling_tag_list_cn = cling_tag_list_cn;

        if (ah->maximise_cling) {
                /* Check entire LV */
                le = 0;
                len = prev_lvseg->le + prev_lvseg->len;
        } else {
                /* Only check 1 LE at end of previous LV segment */
                le = prev_lvseg->le + prev_lvseg->len - 1;
                len = 1;
        }

        /* FIXME Cope with stacks by flattening */
        if (!(r = _for_each_pv(ah->cmd, prev_lvseg->lv, le, len, NULL, NULL,
                               0, 0, -1, 1,
                               _is_condition, &pvmatch)))
                stack;

        if (r != 2)
                return 0;

        return 1;
}

/*
 * Is pva contiguous to any existing areas or on the same PV?
 */
static int _check_contiguous(struct cmd_context *cmd,
                             struct lv_segment *prev_lvseg, struct pv_area *pva,
                             struct alloc_state *alloc_state)
{
        struct pv_match pvmatch;
        int r;

        pvmatch.condition = _is_contiguous;
        pvmatch.areas = alloc_state->areas;
        pvmatch.areas_size = alloc_state->areas_size;
        pvmatch.pva = pva;
        pvmatch.cling_tag_list_cn = NULL;

        /* FIXME Cope with stacks by flattening */
        if (!(r = _for_each_pv(cmd, prev_lvseg->lv,
                               prev_lvseg->le + prev_lvseg->len - 1, 1, NULL, NULL,
                               0, 0, -1, 1,
                               _is_condition, &pvmatch)))
                stack;

        if (r != 2)
                return 0;

        return 1;
}

/*
 * Is pva on same PV as any areas already used in this allocation attempt?
 */
static int _check_cling_to_alloced(struct alloc_handle *ah, const struct dm_config_node *cling_tag_list_cn,
                                   struct pv_area *pva, struct alloc_state *alloc_state)
{
        unsigned s;
        struct alloced_area *aa;

        /*
         * Ignore log areas.  They are always allocated whole as part of the
         * first allocation.  If they aren't yet set, we know we've nothing to do.
         */
        if (alloc_state->log_area_count_still_needed)
                return 0;

        for (s = 0; s < ah->area_count; s++) {
                if (alloc_state->areas[s].pva)
                        continue;       /* Area already assigned */
                dm_list_iterate_items(aa, &ah->alloced_areas[s]) {
                        if ((!cling_tag_list_cn && (pva->map->pv == aa[0].pv)) ||
                            (cling_tag_list_cn && _pvs_have_matching_tag(cling_tag_list_cn, pva->map->pv, aa[0].pv))) {
                                _reserve_area(&alloc_state->areas[s], pva, pva->count, s + 1, 0);
                                return 1;
                        }
                }
        }

        return 0;
}

static int _pv_is_parallel(struct physical_volume *pv, struct dm_list *parallel_pvs)
{
        struct pv_list *pvl;

        dm_list_iterate_items(pvl, parallel_pvs)
                if (pv == pvl->pv)
                        return 1;

        return 0;
}

/*
 * Decide whether or not to try allocation from supplied area pva.
 * alloc_state->areas may get modified.
 */
static area_use_t _check_pva(struct alloc_handle *ah, struct pv_area *pva, uint32_t still_needed,
                             const struct alloc_parms *alloc_parms, struct alloc_state *alloc_state,
                             unsigned already_found_one, unsigned iteration_count, unsigned log_iteration_count)
{
        unsigned s;

        /* Skip fully-reserved areas (which are not currently removed from the list). */
        if (!pva->unreserved)
                return NEXT_AREA;

        /* FIXME Should this test be removed? */
        if (iteration_count)
                /*
                * Don't use an area twice.
                */
                for (s = 0; s < alloc_state->areas_size; s++)
                        if (alloc_state->areas[s].pva == pva)
                                return NEXT_AREA;

        /* If maximise_cling is set, perform several checks, otherwise perform exactly one. */
        if (!iteration_count && !log_iteration_count && alloc_parms->flags & (A_CONTIGUOUS_TO_LVSEG | A_CLING_TO_LVSEG | A_CLING_TO_ALLOCED)) {
                /* Contiguous? */
                if (((alloc_parms->flags & A_CONTIGUOUS_TO_LVSEG) || (ah->maximise_cling && alloc_parms->prev_lvseg)) &&
                    _check_contiguous(ah->cmd, alloc_parms->prev_lvseg, pva, alloc_state))
                        return PREFERRED;
        
                /* Try next area on same PV if looking for contiguous space */
                if (alloc_parms->flags & A_CONTIGUOUS_TO_LVSEG)
                        return NEXT_AREA;

                /* Cling to prev_lvseg? */
                if (((alloc_parms->flags & A_CLING_TO_LVSEG) || (ah->maximise_cling && alloc_parms->prev_lvseg)) &&
                    _check_cling(ah, NULL, alloc_parms->prev_lvseg, pva, alloc_state))
                        /* If this PV is suitable, use this first area */
                        return PREFERRED;

                /* Cling_to_alloced? */
                if ((alloc_parms->flags & A_CLING_TO_ALLOCED) &&
                    _check_cling_to_alloced(ah, NULL, pva, alloc_state))
                        return PREFERRED;

                /* Cling_by_tags? */
                if (!(alloc_parms->flags & A_CLING_BY_TAGS) || !ah->cling_tag_list_cn)
                        return NEXT_PV;

                if (alloc_parms->prev_lvseg) {
                        if (_check_cling(ah, ah->cling_tag_list_cn, alloc_parms->prev_lvseg, pva, alloc_state))
                                return PREFERRED;
                } else if (_check_cling_to_alloced(ah, ah->cling_tag_list_cn, pva, alloc_state))
                        return PREFERRED;

                /* All areas on this PV give same result so pointless checking more */
                return NEXT_PV;
        }

        /* Normal/Anywhere */

        /* Is it big enough on its own? */
        if (pva->unreserved * ah->area_multiple < still_needed &&
            ((!(alloc_parms->flags & A_CAN_SPLIT) && !ah->log_area_count) ||
             (already_found_one && alloc_parms->alloc != ALLOC_ANYWHERE)))
                return NEXT_PV;

        return USE_AREA;
}

/*
 * Decide how many extents we're trying to obtain from a given area.
 * Removes the extents from further consideration.
 */
static uint32_t _calc_required_extents(struct alloc_handle *ah, struct pv_area *pva, unsigned ix_pva, uint32_t max_to_allocate, alloc_policy_t alloc)
{
        uint32_t required = max_to_allocate / ah->area_multiple;

        /*
         * Update amount unreserved - effectively splitting an area 
         * into two or more parts.  If the whole stripe doesn't fit,
         * reduce amount we're looking for.
         */
        if (alloc == ALLOC_ANYWHERE) {
                if (ix_pva - 1 >= ah->area_count)
                        required = ah->log_len;
        } else if (required < ah->log_len)
                required = ah->log_len;

        if (required >= pva->unreserved) {
                required = pva->unreserved;
                pva->unreserved = 0;
        } else {
                pva->unreserved -= required;
                reinsert_changed_pv_area(pva);
        }

        return required;
}

static int _reserve_required_area(struct alloc_handle *ah, uint32_t max_to_allocate,
                                  unsigned ix_pva, struct pv_area *pva,
                                  struct alloc_state *alloc_state, alloc_policy_t alloc)
{
        uint32_t required = _calc_required_extents(ah, pva, ix_pva, max_to_allocate, alloc);
        uint32_t s;

        /* Expand areas array if needed after an area was split. */
        if (ix_pva > alloc_state->areas_size) {
                alloc_state->areas_size *= 2;
                if (!(alloc_state->areas = dm_realloc(alloc_state->areas, sizeof(*alloc_state->areas) * (alloc_state->areas_size)))) {
                        log_error("Memory reallocation for parallel areas failed.");
                        return 0;
                }
                for (s = alloc_state->areas_size / 2; s < alloc_state->areas_size; s++)
                        alloc_state->areas[s].pva = NULL;
        }

        _reserve_area(&alloc_state->areas[ix_pva - 1], pva, required, ix_pva, pva->unreserved);

        return 1;
}

static void _clear_areas(struct alloc_state *alloc_state)
{
        uint32_t s;

        for (s = 0; s < alloc_state->areas_size; s++)
                alloc_state->areas[s].pva = NULL;
}

static void _reset_unreserved(struct dm_list *pvms)
{
        struct pv_map *pvm;
        struct pv_area *pva;

        dm_list_iterate_items(pvm, pvms)
                dm_list_iterate_items(pva, &pvm->areas)
                        if (pva->unreserved != pva->count) {
                                pva->unreserved = pva->count;
                                reinsert_changed_pv_area(pva);
                        }
}

static void _report_needed_allocation_space(struct alloc_handle *ah,
                                            struct alloc_state *alloc_state)
{
        const char *metadata_type;
        uint32_t parallel_areas_count, parallel_area_size;
        uint32_t metadata_count, metadata_size;

        parallel_area_size = (ah->new_extents - alloc_state->allocated) / ah->area_multiple -
                      ((ah->alloc_and_split_meta) ? ah->log_len : 0);

        parallel_areas_count = ah->area_count + ah->parity_count;

        metadata_size = ah->log_len;
        if (ah->alloc_and_split_meta) {
                metadata_type = "RAID metadata area";
                metadata_count = parallel_areas_count;
        } else {
                metadata_type = "mirror log";
                metadata_count = alloc_state->log_area_count_still_needed;
        }

        log_debug("Still need %" PRIu32 " total extents:",
                parallel_area_size * parallel_areas_count + metadata_size * metadata_count);
        log_debug("  %" PRIu32 " (%" PRIu32 " data/%" PRIu32
                  " parity) parallel areas of %" PRIu32 " extents each",
                  parallel_areas_count, ah->area_count, ah->parity_count, parallel_area_size);
        log_debug("  %" PRIu32 " %ss of %" PRIu32 " extents each",
                  metadata_count, metadata_type, metadata_size);
}
/*
 * Returns 1 regardless of whether any space was found, except on error.
 */
static int _find_some_parallel_space(struct alloc_handle *ah, const struct alloc_parms *alloc_parms,
                                     struct dm_list *pvms, struct alloc_state *alloc_state,
                                     struct dm_list *parallel_pvs, uint32_t max_to_allocate)
{
        unsigned ix = 0;
        unsigned last_ix;
        struct pv_map *pvm;
        struct pv_area *pva;
        unsigned preferred_count = 0;
        unsigned already_found_one;
        unsigned ix_offset = 0; /* Offset for non-preferred allocations */
        unsigned ix_log_offset; /* Offset to start of areas to use for log */
        unsigned too_small_for_log_count; /* How many too small for log? */
        unsigned iteration_count = 0; /* cling_to_alloced may need 2 iterations */
        unsigned log_iteration_count = 0; /* extra iteration for logs on data devices */
        struct alloced_area *aa;
        uint32_t s;
        uint32_t devices_needed = ah->area_count + ah->parity_count;

        /* ix_offset holds the number of parallel allocations that must be contiguous/cling */
        /* At most one of A_CONTIGUOUS_TO_LVSEG, A_CLING_TO_LVSEG or A_CLING_TO_ALLOCED may be set */
        if (alloc_parms->flags & (A_CONTIGUOUS_TO_LVSEG | A_CLING_TO_LVSEG))
                ix_offset = _stripes_per_mimage(alloc_parms->prev_lvseg) * alloc_parms->prev_lvseg->area_count;

        if (alloc_parms->flags & A_CLING_TO_ALLOCED)
                ix_offset = ah->area_count;

        if (alloc_parms->alloc == ALLOC_NORMAL || (alloc_parms->flags & A_CLING_TO_ALLOCED))
                log_debug("Cling_to_allocated is %sset",
                          alloc_parms->flags & A_CLING_TO_ALLOCED ? "" : "not ");

        _clear_areas(alloc_state);
        _reset_unreserved(pvms);

        _report_needed_allocation_space(ah, alloc_state);

        /* ix holds the number of areas found on other PVs */
        do {
                if (log_iteration_count) {
                        log_debug("Found %u areas for %" PRIu32 " parallel areas and %" PRIu32 " log areas so far.", ix, devices_needed, alloc_state->log_area_count_still_needed);
                } else if (iteration_count)
                        log_debug("Filled %u out of %u preferred areas so far.", preferred_count, ix_offset);

                /*
                 * Provide for escape from the loop if no progress is made.
                 * This should not happen: ALLOC_ANYWHERE should be able to use
                 * all available space. (If there aren't enough extents, the code
                 * should not reach this point.)
                 */
                last_ix = ix;

                /*
                 * Put the smallest area of each PV that is at least the
                 * size we need into areas array.  If there isn't one
                 * that fits completely and we're allowed more than one
                 * LV segment, then take the largest remaining instead.
                 */
                dm_list_iterate_items(pvm, pvms) {
                        /* PV-level checks */
                        if (dm_list_empty(&pvm->areas))
                                continue;       /* Next PV */

                        if (alloc_parms->alloc != ALLOC_ANYWHERE) {
                                /* Don't allocate onto the log PVs */
                                if (ah->log_area_count)
                                        dm_list_iterate_items(aa, &ah->alloced_areas[ah->area_count])
                                                for (s = 0; s < ah->log_area_count; s++)
                                                        if (!aa[s].pv)
                                                                goto next_pv;

                                /* FIXME Split into log and non-log parallel_pvs and only check the log ones if log_iteration? */
                                /* (I've temporatily disabled the check.) */
                                /* Avoid PVs used by existing parallel areas */
                                if (!log_iteration_count && parallel_pvs && _pv_is_parallel(pvm->pv, parallel_pvs))
                                        goto next_pv;

                                /*
                                 * Avoid PVs already set aside for log.  
                                 * We only reach here if there were enough PVs for the main areas but
                                 * not enough for the logs.
                                 */
                                if (log_iteration_count) {
                                        for (s = devices_needed; s < ix + ix_offset; s++)
                                                if (alloc_state->areas[s].pva && alloc_state->areas[s].pva->map->pv == pvm->pv)
                                                        goto next_pv;
                                /* On a second pass, avoid PVs already used in an uncommitted area */
                                } else if (iteration_count)
                                        for (s = 0; s < devices_needed; s++)
                                                if (alloc_state->areas[s].pva && alloc_state->areas[s].pva->map->pv == pvm->pv)
                                                        goto next_pv;
                        }

                        already_found_one = 0;
                        /* First area in each list is the largest */
                        dm_list_iterate_items(pva, &pvm->areas) {
                                /*
                                 * There are two types of allocations, which can't be mixed at present.
                                 * PREFERRED are stored immediately in a specific parallel slot.
                                 * USE_AREA are stored for later, then sorted and chosen from.
                                 */
                                switch(_check_pva(ah, pva, max_to_allocate, alloc_parms,
                                                  alloc_state, already_found_one, iteration_count, log_iteration_count)) {

                                case PREFERRED:
                                        preferred_count++;
                                        /* Fall through */

                                case NEXT_PV:
                                        goto next_pv;

                                case NEXT_AREA:
                                        continue;

                                case USE_AREA:
                                        /*
                                         * Except with ALLOC_ANYWHERE, replace first area with this
                                         * one which is smaller but still big enough.
                                         */
                                        if (!already_found_one ||
                                            alloc_parms->alloc == ALLOC_ANYWHERE) {
                                                ix++;
                                                already_found_one = 1;
                                        }

                                        /* Reserve required amount of pva */
                                        if (!_reserve_required_area(ah, max_to_allocate, ix + ix_offset,
                                                                    pva, alloc_state, alloc_parms->alloc))
                                                return_0;
                                }

                        }

                next_pv:
                        /* With ALLOC_ANYWHERE we ignore further PVs once we have at least enough areas */
                        /* With cling and contiguous we stop if we found a match for *all* the areas */
                        /* FIXME Rename these variables! */
                        if ((alloc_parms->alloc == ALLOC_ANYWHERE &&
                            ix + ix_offset >= devices_needed + alloc_state->log_area_count_still_needed) ||
                            (preferred_count == ix_offset &&
                             (ix_offset == devices_needed + alloc_state->log_area_count_still_needed)))
                                break;
                }
        } while ((alloc_parms->alloc == ALLOC_ANYWHERE && last_ix != ix && ix < devices_needed + alloc_state->log_area_count_still_needed) ||
                /* With cling_to_alloced and normal, if there were gaps in the preferred areas, have a second iteration */
                 (alloc_parms->alloc == ALLOC_NORMAL && preferred_count &&
                  (preferred_count < ix_offset || alloc_state->log_area_count_still_needed) &&
                  (alloc_parms->flags & A_CLING_TO_ALLOCED) && !iteration_count++) ||
                /* Extra iteration needed to fill log areas on PVs already used? */
                 (alloc_parms->alloc == ALLOC_NORMAL && preferred_count == ix_offset && !ah->mirror_logs_separate &&
                  (ix + preferred_count >= devices_needed) &&
                  (ix + preferred_count < devices_needed + alloc_state->log_area_count_still_needed) && !log_iteration_count++));

        if (preferred_count < ix_offset && !(alloc_parms->flags & A_CLING_TO_ALLOCED))
                return 1;

        if (ix + preferred_count < devices_needed + alloc_state->log_area_count_still_needed)
                return 1;

        /* Sort the areas so we allocate from the biggest */
        if (log_iteration_count) {
                if (ix > devices_needed + 1) {
                        log_debug("Sorting %u log areas", ix - devices_needed);
                        qsort(alloc_state->areas + devices_needed, ix - devices_needed, sizeof(*alloc_state->areas),
                              _comp_area);
                }
        } else if (ix > 1) {
                log_debug("Sorting %u areas", ix);
                qsort(alloc_state->areas + ix_offset, ix, sizeof(*alloc_state->areas),
                      _comp_area);
        }

        /* If there are gaps in our preferred areas, fill then from the sorted part of the array */
        if (preferred_count && preferred_count != ix_offset) {
                for (s = 0; s < devices_needed; s++)
                        if (!alloc_state->areas[s].pva) {
                                alloc_state->areas[s].pva = alloc_state->areas[ix_offset].pva;
                                alloc_state->areas[s].used = alloc_state->areas[ix_offset].used;
                                alloc_state->areas[ix_offset++].pva = NULL;
                        }
        }
        
        /*
         * First time around, if there's a log, allocate it on the
         * smallest device that has space for it.
         */
        too_small_for_log_count = 0;
        ix_log_offset = 0;

        /* FIXME This logic is due to its heritage and can be simplified! */
        if (alloc_state->log_area_count_still_needed) {
                /* How many areas are too small for the log? */
                while (too_small_for_log_count < ix_offset + ix &&
                       (*(alloc_state->areas + ix_offset + ix - 1 -
                          too_small_for_log_count)).used < ah->log_len)
                        too_small_for_log_count++;
                ix_log_offset = ix_offset + ix - too_small_for_log_count - ah->log_area_count;
        }

        if (ix + ix_offset < devices_needed +
            (alloc_state->log_area_count_still_needed ? alloc_state->log_area_count_still_needed +
                                    too_small_for_log_count : 0))
                return 1;

        /*
         * Finally add the space identified to the list of areas to be used.
         */
        if (!_alloc_parallel_area(ah, max_to_allocate, alloc_state, ix_log_offset))
                return_0;

        /*
         * Log is always allocated first time.
         */
        alloc_state->log_area_count_still_needed = 0;

        return 1;
}

/*
 * Choose sets of parallel areas to use, respecting any constraints 
 * supplied in alloc_parms.
 */
static int _find_max_parallel_space_for_one_policy(struct alloc_handle *ah, struct alloc_parms *alloc_parms,
                                                   struct dm_list *pvms, struct alloc_state *alloc_state)
{
        uint32_t max_tmp;
        uint32_t max_to_allocate;       /* Maximum extents to allocate this time */
        uint32_t old_allocated;
        uint32_t next_le;
        struct seg_pvs *spvs;
        struct dm_list *parallel_pvs;

        /* FIXME This algorithm needs a lot of cleaning up! */
        /* FIXME anywhere doesn't find all space yet */
        do {
                parallel_pvs = NULL;
                max_to_allocate = alloc_parms->extents_still_needed - alloc_state->allocated;

                /*
                 * If there are existing parallel PVs, avoid them and reduce
                 * the maximum we can allocate in one go accordingly.
                 */
                if (ah->parallel_areas) {
                        next_le = (alloc_parms->prev_lvseg ? alloc_parms->prev_lvseg->le + alloc_parms->prev_lvseg->len : 0) + alloc_state->allocated / ah->area_multiple;
                        dm_list_iterate_items(spvs, ah->parallel_areas) {
                                if (next_le >= spvs->le + spvs->len)
                                        continue;

                                max_tmp = max_to_allocate +
                                        alloc_state->allocated;

                                /*
                                 * Because a request that groups metadata and
                                 * data together will be split, we must adjust
                                 * the comparison accordingly.
                                 */
                                if (ah->alloc_and_split_meta)
                                        max_tmp -= ah->log_len;
                                if (max_tmp > (spvs->le + spvs->len) * ah->area_multiple) {
                                        max_to_allocate = (spvs->le + spvs->len) * ah->area_multiple - alloc_state->allocated;
                                        max_to_allocate += ah->alloc_and_split_meta ? ah->log_len : 0;
                                }
                                parallel_pvs = &spvs->pvs;
                                break;
                        }
                }

                old_allocated = alloc_state->allocated;

                if (!_find_some_parallel_space(ah, alloc_parms, pvms, alloc_state, parallel_pvs, max_to_allocate))
                        return_0;

                /*
                 * If we didn't allocate anything this time with ALLOC_NORMAL and had
                 * A_CLING_TO_ALLOCED set, try again without it.
                 *
                 * For ALLOC_NORMAL, if we did allocate something without the
                 * flag set, set it and continue so that further allocations
                 * remain on the same disks where possible.
                 */
                if (old_allocated == alloc_state->allocated) {
                        if ((alloc_parms->alloc == ALLOC_NORMAL) && (alloc_parms->flags & A_CLING_TO_ALLOCED))
                                alloc_parms->flags &= ~A_CLING_TO_ALLOCED;
                        else
                                break;  /* Give up */
                } else if (ah->maximise_cling && alloc_parms->alloc == ALLOC_NORMAL &&
                           !(alloc_parms->flags & A_CLING_TO_ALLOCED))
                        alloc_parms->flags |= A_CLING_TO_ALLOCED;
        } while ((alloc_parms->alloc != ALLOC_CONTIGUOUS) && alloc_state->allocated != alloc_parms->extents_still_needed && (alloc_parms->flags & A_CAN_SPLIT));

        return 1;
}

/*
 * Allocate several segments, each the same size, in parallel.
 * If mirrored_pv and mirrored_pe are supplied, it is used as
 * the first area, and additional areas are allocated parallel to it.
 */
static int _allocate(struct alloc_handle *ah,
                     struct volume_group *vg,
                     struct logical_volume *lv,
                     unsigned can_split,
                     struct dm_list *allocatable_pvs)
{
        uint32_t old_allocated;
        struct lv_segment *prev_lvseg = NULL;
        int r = 0;
        struct dm_list *pvms;
        alloc_policy_t alloc;
        struct alloc_parms alloc_parms;
        struct alloc_state alloc_state;

        alloc_state.allocated = lv ? lv->le_count : 0;

        if (alloc_state.allocated >= ah->new_extents && !ah->log_area_count) {
                log_error("_allocate called with no work to do!");
                return 1;
        }

        if (ah->area_multiple > 1 &&
            (ah->new_extents - alloc_state.allocated) % ah->area_multiple) {
                log_error("Number of extents requested (%d) needs to be divisible by %d.",
                          ah->new_extents - alloc_state.allocated,
                          ah->area_multiple);
                return 0;
        }

        alloc_state.log_area_count_still_needed = ah->log_area_count;

        if (ah->alloc == ALLOC_CONTIGUOUS)
                can_split = 0;

        if (lv && !dm_list_empty(&lv->segments))
                prev_lvseg = dm_list_item(dm_list_last(&lv->segments),
                                       struct lv_segment);
        /*
         * Build the sets of available areas on the pv's.
         */
        if (!(pvms = create_pv_maps(ah->mem, vg, allocatable_pvs)))
                return_0;

        if (!_log_parallel_areas(ah->mem, ah->parallel_areas))
                stack;

        alloc_state.areas_size = dm_list_size(pvms);
        if (alloc_state.areas_size &&
            alloc_state.areas_size < (ah->area_count + ah->parity_count + ah->log_area_count)) {
                if (ah->alloc != ALLOC_ANYWHERE && ah->mirror_logs_separate) {
                        log_error("Not enough PVs with free space available "
                                  "for parallel allocation.");
                        log_error("Consider --alloc anywhere if desperate.");
                        return 0;
                }
                alloc_state.areas_size = ah->area_count + ah->parity_count + ah->log_area_count;
        }

        /* Upper bound if none of the PVs in prev_lvseg is in pvms */
        /* FIXME Work size out properly */
        if (prev_lvseg)
                alloc_state.areas_size += _stripes_per_mimage(prev_lvseg) * prev_lvseg->area_count;

        /* Allocate an array of pv_areas to hold the largest space on each PV */
        if (!(alloc_state.areas = dm_malloc(sizeof(*alloc_state.areas) * alloc_state.areas_size))) {
                log_error("Couldn't allocate areas array.");
                return 0;
        }

        /*
         * cling includes implicit cling_by_tags
         * but it does nothing unless the lvm.conf setting is present.
         */
        if (ah->alloc == ALLOC_CLING)
                ah->alloc = ALLOC_CLING_BY_TAGS;

        /* Attempt each defined allocation policy in turn */
        for (alloc = ALLOC_CONTIGUOUS; alloc <= ah->alloc; alloc++) {
                /* Skip cling_by_tags if no list defined */
                if (alloc == ALLOC_CLING_BY_TAGS && !ah->cling_tag_list_cn)
                        continue;
                old_allocated = alloc_state.allocated;
                log_debug("Trying allocation using %s policy.", get_alloc_string(alloc));

                if (!_sufficient_pes_free(ah, pvms, alloc_state.allocated, ah->new_extents))
                        goto_out;

                _init_alloc_parms(ah, &alloc_parms, alloc, prev_lvseg,
                                  can_split, alloc_state.allocated,
                                  ah->new_extents);

                if (!_find_max_parallel_space_for_one_policy(ah, &alloc_parms, pvms, &alloc_state))
                        goto_out;

                if ((alloc_state.allocated == ah->new_extents && !alloc_state.log_area_count_still_needed) ||
                    (!can_split && (alloc_state.allocated != old_allocated)))
                        break;
        }

        if (alloc_state.allocated != ah->new_extents) {
                log_error("Insufficient suitable %sallocatable extents "
                          "for logical volume %s: %u more required",
                          can_split ? "" : "contiguous ",
                          lv ? lv->name : "",
                          (ah->new_extents - alloc_state.allocated) * ah->area_count
                          / ah->area_multiple);
                goto out;
        }

        if (alloc_state.log_area_count_still_needed) {
                log_error("Insufficient free space for log allocation "
                          "for logical volume %s.",
                          lv ? lv->name : "");
                goto out;
        }

        r = 1;

      out:
        dm_free(alloc_state.areas);
        return r;
}

int lv_add_virtual_segment(struct logical_volume *lv, uint64_t status,
                           uint32_t extents, const struct segment_type *segtype,
                           const char *thin_pool_name)
{
        struct lv_segment *seg;
        struct logical_volume *thin_pool_lv = NULL;
        struct lv_list *lvl;
        uint32_t size;

        if (thin_pool_name) {
                if (!(lvl = find_lv_in_vg(lv->vg, thin_pool_name))) {
                        log_error("Unable to find existing pool LV %s in VG %s.",
                                  thin_pool_name, lv->vg->name);
                        return 0;
                }
                thin_pool_lv = lvl->lv;
                size = first_seg(thin_pool_lv)->chunk_size;
                if (lv->vg->extent_size < size) {
                        /* Align extents on chunk boundary size */
                        size = ((uint64_t)lv->vg->extent_size * extents + size - 1) /
                                size * size / lv->vg->extent_size;
                        if (size != extents) {
                                log_print("Rounding size (%d extents) up to chunk boundary "
                                          "size (%d extents).", extents, size);
                                extents = size;
                        }
                }
        }

        if (!dm_list_empty(&lv->segments) &&
            (seg = last_seg(lv)) && (seg->segtype == segtype)) {
                seg->area_len += extents;
                seg->len += extents;
        } else {
                if (!(seg = alloc_lv_segment(segtype, lv, lv->le_count, extents,
                                             status, 0, NULL, thin_pool_lv, 0,
                                             extents, 0, 0, 0, NULL))) {
                        log_error("Couldn't allocate new zero segment.");
                        return 0;
                }
                lv->status |= VIRTUAL;
                dm_list_add(&lv->segments, &seg->list);
        }

        lv->le_count += extents;
        lv->size += (uint64_t) extents *lv->vg->extent_size;

        return 1;
}

/*
 * Entry point for all extent allocations.
 */
struct alloc_handle *allocate_extents(struct volume_group *vg,
                                      struct logical_volume *lv,
                                      const struct segment_type *segtype,
                                      uint32_t stripes,
                                      uint32_t mirrors, uint32_t log_count,
                                      uint32_t region_size, uint32_t extents,
                                      struct dm_list *allocatable_pvs,
                                      alloc_policy_t alloc,
                                      struct dm_list *parallel_areas)
{
        struct alloc_handle *ah;
        uint32_t new_extents;

        if (segtype_is_virtual(segtype)) {
                log_error("allocate_extents does not handle virtual segments");
                return NULL;
        }

        if (!allocatable_pvs) {
                log_error(INTERNAL_ERROR "Missing allocatable pvs.");
                return NULL;
        }

        if (vg->fid->fmt->ops->segtype_supported &&
            !vg->fid->fmt->ops->segtype_supported(vg->fid, segtype)) {
                log_error("Metadata format (%s) does not support required "
                          "LV segment type (%s).", vg->fid->fmt->name,
                          segtype->name);
                log_error("Consider changing the metadata format by running "
                          "vgconvert.");
                return NULL;
        }

        if (alloc >= ALLOC_INHERIT)
                alloc = vg->alloc;

        new_extents = (lv ? lv->le_count : 0) + extents;
        if (!(ah = _alloc_init(vg->cmd, vg->cmd->mem, segtype, alloc,
                               new_extents, mirrors, stripes, log_count,
                               vg->extent_size, region_size,
                               parallel_areas)))
                return_NULL;

        if (!_allocate(ah, vg, lv, 1, allocatable_pvs)) {
                alloc_destroy(ah);
                return_NULL;
        }

        return ah;
}

/*
 * Add new segments to an LV from supplied list of areas.
 */
int lv_add_segment(struct alloc_handle *ah,
                   uint32_t first_area, uint32_t num_areas,
                   struct logical_volume *lv,
                   const struct segment_type *segtype,
                   uint32_t stripe_size,
                   uint64_t status,
                   uint32_t region_size)
{
        if (!segtype) {
                log_error("Missing segtype in lv_add_segment().");
                return 0;
        }

        if (segtype_is_virtual(segtype)) {
                log_error("lv_add_segment cannot handle virtual segments");
                return 0;
        }

        if ((status & MIRROR_LOG) && dm_list_size(&lv->segments)) {
                log_error("Log segments can only be added to an empty LV");
                return 0;
        }

        if (!_setup_alloced_segments(lv, &ah->alloced_areas[first_area],
                                     num_areas, status,
                                     stripe_size, segtype,
                                     region_size))
                return_0;

        if ((segtype->flags & SEG_CAN_SPLIT) && !lv_merge_segments(lv)) {
                log_error("Couldn't merge segments after extending "
                          "logical volume.");
                return 0;
        }

        if (lv->vg->fid->fmt->ops->lv_setup &&
            !lv->vg->fid->fmt->ops->lv_setup(lv->vg->fid, lv))
                return_0;

        return 1;
}

/*
 * "mirror" segment type doesn't support split.
 * So, when adding mirrors to linear LV segment, first split it,
 * then convert it to "mirror" and add areas.
 */
static struct lv_segment *_convert_seg_to_mirror(struct lv_segment *seg,
                                                 uint32_t region_size,
                                                 struct logical_volume *log_lv)
{
        struct lv_segment *newseg;
        uint32_t s;

        if (!seg_is_striped(seg)) {
                log_error("Can't convert non-striped segment to mirrored.");
                return NULL;
        }

        if (seg->area_count > 1) {
                log_error("Can't convert striped segment with multiple areas "
                          "to mirrored.");
                return NULL;
        }

        if (!(newseg = alloc_lv_segment(get_segtype_from_string(seg->lv->vg->cmd, "mirror"),
                                        seg->lv, seg->le, seg->len,
                                        seg->status, seg->stripe_size,
                                        log_lv, NULL,
                                        seg->area_count, seg->area_len,
                                        seg->chunk_size, region_size,
                                        seg->extents_copied, NULL))) {
                log_error("Couldn't allocate converted LV segment");
                return NULL;
        }

        for (s = 0; s < seg->area_count; s++)
                if (!move_lv_segment_area(newseg, s, seg, s))
                        return_NULL;

        seg->pvmove_source_seg = NULL; /* Not maintained after allocation */

        dm_list_add(&seg->list, &newseg->list);
        dm_list_del(&seg->list);

        return newseg;
}

/*
 * Add new areas to mirrored segments
 */
int lv_add_mirror_areas(struct alloc_handle *ah,
                        struct logical_volume *lv, uint32_t le,
                        uint32_t region_size)
{
        struct alloced_area *aa;
        struct lv_segment *seg;
        uint32_t current_le = le;
        uint32_t s, old_area_count, new_area_count;

        dm_list_iterate_items(aa, &ah->alloced_areas[0]) {
                if (!(seg = find_seg_by_le(lv, current_le))) {
                        log_error("Failed to find segment for %s extent %"
                                  PRIu32, lv->name, current_le);
                        return 0;
                }

                /* Allocator assures aa[0].len <= seg->area_len */
                if (aa[0].len < seg->area_len) {
                        if (!lv_split_segment(lv, seg->le + aa[0].len)) {
                                log_error("Failed to split segment at %s "
                                          "extent %" PRIu32, lv->name, le);
                                return 0;
                        }
                }

                if (!seg_is_mirrored(seg) &&
                    (!(seg = _convert_seg_to_mirror(seg, region_size, NULL))))
                        return_0;

                old_area_count = seg->area_count;
                new_area_count = old_area_count + ah->area_count;

                if (!_lv_segment_add_areas(lv, seg, new_area_count))
                        return_0;

                for (s = 0; s < ah->area_count; s++) {
                        if (!set_lv_segment_area_pv(seg, s + old_area_count,
                                                    aa[s].pv, aa[s].pe))
                                return_0;
                }

                current_le += seg->area_len;
        }

        lv->status |= MIRRORED;

        if (lv->vg->fid->fmt->ops->lv_setup &&
            !lv->vg->fid->fmt->ops->lv_setup(lv->vg->fid, lv))
                return_0;

        return 1;
}

/*
 * Add mirror image LVs to mirrored segments
 */
int lv_add_mirror_lvs(struct logical_volume *lv,
                      struct logical_volume **sub_lvs,
                      uint32_t num_extra_areas,
                      uint64_t status, uint32_t region_size)
{
        struct lv_segment *seg;
        uint32_t old_area_count, new_area_count;
        uint32_t m;
        struct segment_type *mirror_segtype;

        seg = first_seg(lv);

        if (dm_list_size(&lv->segments) != 1 || seg_type(seg, 0) != AREA_LV) {
                log_error("Mirror layer must be inserted before adding mirrors");
                return 0;
        }

        mirror_segtype = get_segtype_from_string(lv->vg->cmd, "mirror");
        if (seg->segtype != mirror_segtype)
                if (!(seg = _convert_seg_to_mirror(seg, region_size, NULL)))
                        return_0;

        if (region_size && region_size != seg->region_size) {
                log_error("Conflicting region_size");
                return 0;
        }

        old_area_count = seg->area_count;
        new_area_count = old_area_count + num_extra_areas;

        if (!_lv_segment_add_areas(lv, seg, new_area_count)) {
                log_error("Failed to allocate widened LV segment for %s.",
                          lv->name);
                return 0;
        }

        for (m = 0; m < old_area_count; m++)
                seg_lv(seg, m)->status |= status;

        for (m = old_area_count; m < new_area_count; m++) {
                if (!set_lv_segment_area_lv(seg, m, sub_lvs[m - old_area_count],
                                            0, status))
                        return_0;
                lv_set_hidden(sub_lvs[m - old_area_count]);
        }

        lv->status |= MIRRORED;

        return 1;
}

/*
 * Turn an empty LV into a mirror log.
 *
 * FIXME: Mirrored logs are built inefficiently.
 * A mirrored log currently uses the same layout that a mirror
 * LV uses.  The mirror layer sits on top of AREA_LVs which form the
 * legs, rather on AREA_PVs.  This is done to allow re-use of the
 * various mirror functions to also handle the mirrored LV that makes
 * up the log.
 *
 * If we used AREA_PVs under the mirror layer of a log, we could
 * assemble it all at once by calling 'lv_add_segment' with the
 * appropriate segtype (mirror/stripe), like this:
 *      lv_add_segment(ah, ah->area_count, ah->log_area_count,
 *                     log_lv, segtype, 0, MIRROR_LOG, 0);
 *
 * For now, we use the same mechanism to build a mirrored log as we
 * do for building a mirrored LV: 1) create initial LV, 2) add a
 * mirror layer, and 3) add the remaining copy LVs
 */
int lv_add_log_segment(struct alloc_handle *ah, uint32_t first_area,
                       struct logical_volume *log_lv, uint64_t status)
{

        return lv_add_segment(ah, ah->area_count + first_area, 1, log_lv,
                              get_segtype_from_string(log_lv->vg->cmd,
                                                      "striped"),
                              0, status, 0);
}

static int _lv_insert_empty_sublvs(struct logical_volume *lv,
                                   const struct segment_type *segtype,
                                   uint32_t stripe_size, uint32_t region_size,
                                   uint32_t devices)
{
        struct logical_volume *sub_lv;
        uint32_t i;
        uint64_t sub_lv_status = 0;
        const char *layer_name;
        size_t len = strlen(lv->name) + 32;
        char img_name[len];
        struct lv_segment *mapseg;

        if (lv->le_count || !dm_list_empty(&lv->segments)) {
                log_error(INTERNAL_ERROR
                          "Non-empty LV passed to _lv_insert_empty_sublv");
                return 0;
        }

        if (segtype_is_raid(segtype)) {
                lv->status |= RAID;
                sub_lv_status = RAID_IMAGE;
                layer_name = "rimage";
        } else if (segtype_is_mirrored(segtype)) {
                lv->status |= MIRRORED;
                sub_lv_status = MIRROR_IMAGE;
                layer_name = "mimage";
        } else
                return_0;

        /*
         * First, create our top-level segment for our top-level LV
         */
        if (!(mapseg = alloc_lv_segment(segtype, lv, 0, 0, lv->status,
                                        stripe_size, NULL, NULL,
                                        devices, 0, 0, region_size, 0, NULL))) {
                log_error("Failed to create mapping segment for %s", lv->name);
                return 0;
        }

        /*
         * Next, create all of our sub_lv's and link them in.
         */
        for (i = 0; i < devices; i++) {
                /* Data LVs */
                if (devices > 1) {
                        if (dm_snprintf(img_name, len, "%s_%s_%u",
                                        lv->name, layer_name, i) < 0)
                                return_0;
                } else {
                        if (dm_snprintf(img_name, len, "%s_%s",
                                        lv->name, layer_name) < 0)
                                return_0;
                }

                /* FIXME Should use ALLOC_INHERIT here and inherit from parent LV */
                if (!(sub_lv = lv_create_empty(img_name, NULL,
                                         LVM_READ | LVM_WRITE,
                                         lv->alloc, lv->vg)))
                        return_0;

                if (!set_lv_segment_area_lv(mapseg, i, sub_lv, 0, sub_lv_status))
                        return_0;

                /* Metadata LVs for raid */
                if (segtype_is_raid(segtype)) {
                        if (dm_snprintf(img_name, len, "%s_rmeta_%u", lv->name, i) < 0)
                                return_0;
                } else
                        continue;

                /* FIXME Should use ALLOC_INHERIT here and inherit from parent LV */
                if (!(sub_lv = lv_create_empty(img_name, NULL,
                                               LVM_READ | LVM_WRITE,
                                               lv->alloc, lv->vg)))
                        return_0;

                if (!set_lv_segment_area_lv(mapseg, i, sub_lv, 0, RAID_META))
                                return_0;
        }

        dm_list_add(&lv->segments, &mapseg->list);

        return 1;
}

static int _lv_extend_layered_lv(struct alloc_handle *ah,
                                 struct logical_volume *lv,
                                 uint32_t extents, uint32_t first_area,
                                 uint32_t stripes, uint32_t stripe_size)
{
        const struct segment_type *segtype;
        struct logical_volume *sub_lv, *meta_lv;
        struct lv_segment *seg;
        uint32_t fa, s;
        int clear_metadata = 0;

        segtype = get_segtype_from_string(lv->vg->cmd, "striped");

        /*
         * The component devices of a "striped" LV all go in the same
         * LV.  However, RAID has an LV for each device - making the
         * 'stripes' and 'stripe_size' parameters meaningless.
         */
        if (seg_is_raid(first_seg(lv))) {
                stripes = 1;
                stripe_size = 0;
        }

        seg = first_seg(lv);
        for (fa = first_area, s = 0; s < seg->area_count; s++) {
                if (is_temporary_mirror_layer(seg_lv(seg, s))) {
                        if (!_lv_extend_layered_lv(ah, seg_lv(seg, s), extents,
                                                   fa, stripes, stripe_size))
                                return_0;
                        fa += lv_mirror_count(seg_lv(seg, s));
                        continue;
                }

                sub_lv = seg_lv(seg, s);
                if (!lv_add_segment(ah, fa, stripes, sub_lv, segtype,
                                    stripe_size, sub_lv->status, 0)) {
                        log_error("Aborting. Failed to extend %s in %s.",
                                  sub_lv->name, lv->name);
                        return 0;
                }

                /* Extend metadata LVs only on initial creation */
                if (seg_is_raid(seg) && !lv->le_count) {
                        if (!seg->meta_areas) {
                                log_error("No meta_areas for RAID type");
                                return 0;
                        }

                        meta_lv = seg_metalv(seg, s);
                        if (!lv_add_segment(ah, fa + seg->area_count, 1,
                                            meta_lv, segtype, 0,
                                            meta_lv->status, 0)) {
                                log_error("Failed to extend %s in %s.",
                                          meta_lv->name, lv->name);
                                return 0;
                        }
                        lv_set_visible(meta_lv);
                        clear_metadata = 1;
                }

                fa += stripes;
        }

        if (clear_metadata) {
                /*
                 * We must clear the metadata areas upon creation.
                 */
                if (!vg_write(lv->vg) || !vg_commit(lv->vg))
                        return_0;

                for (s = 0; s < seg->area_count; s++) {
                        meta_lv = seg_metalv(seg, s);
                        if (!activate_lv(meta_lv->vg->cmd, meta_lv)) {
                                log_error("Failed to activate %s/%s for clearing",
                                          meta_lv->vg->name, meta_lv->name);
                                return 0;
                        }

                        log_verbose("Clearing metadata area of %s/%s",
                                    meta_lv->vg->name, meta_lv->name);
                        /*
                         * Rather than wiping meta_lv->size, we can simply
                         * wipe '1' to remove the superblock of any previous
                         * RAID devices.  It is much quicker.
                         */
                        if (!set_lv(meta_lv->vg->cmd, meta_lv, 1, 0)) {
                                log_error("Failed to zero %s/%s",
                                          meta_lv->vg->name, meta_lv->name);
                                return 0;
                        }

                        if (!deactivate_lv(meta_lv->vg->cmd, meta_lv)) {
                                log_error("Failed to deactivate %s/%s",
                                          meta_lv->vg->name, meta_lv->name);
                                return 0;
                        }
                        lv_set_hidden(meta_lv);
                }
        }

        seg->area_len += extents;
        seg->len += extents;
        lv->le_count += extents;
        lv->size += (uint64_t) extents *lv->vg->extent_size;

        return 1;
}

/*
 * Entry point for single-step LV allocation + extension.
 */
int lv_extend(struct logical_volume *lv,
              const struct segment_type *segtype,
              uint32_t stripes, uint32_t stripe_size,
              uint32_t mirrors, uint32_t region_size,
              uint32_t extents, const char *thin_pool_name,
              struct dm_list *allocatable_pvs, alloc_policy_t alloc)
{
        int r = 1;
        int log_count = 0;
        struct alloc_handle *ah;
        uint32_t sub_lv_count;

        log_very_verbose("Extending segment type, %s", segtype->name);

        if (segtype_is_virtual(segtype))
                return lv_add_virtual_segment(lv, 0u, extents, segtype, thin_pool_name);

        if (!lv->le_count && segtype_is_thin_pool(segtype)) {
                /* Thin pool allocation treats its metadata device like a mirror log. */
                /* FIXME Allow pool and data on same device with NORMAL */
                /* FIXME Support striped metadata pool */
                log_count = 1;
        } else if (segtype_is_raid(segtype) && !lv->le_count)
                log_count = mirrors * stripes;
        /* FIXME log_count should be 1 for mirrors */

        if (!(ah = allocate_extents(lv->vg, lv, segtype, stripes, mirrors,
                                    log_count, region_size, extents,
                                    allocatable_pvs, alloc, NULL)))
                return_0;

        if (segtype_is_thin_pool(segtype)) {
                if (!lv->le_count) {
                        if (!(r = extend_pool(lv, segtype, ah, stripes, stripe_size)))
                                stack;
                } else if (!(r = _lv_extend_layered_lv(ah, lv, extents, 0,
                                                       stripes, stripe_size)))
                        stack;
        } else if (!segtype_is_mirrored(segtype) && !segtype_is_raid(segtype)) {
                if (!(r = lv_add_segment(ah, 0, ah->area_count, lv, segtype,
                                         stripe_size, 0u, 0)))
                        stack;
        } else {
                /*
                 * For RAID, all the devices are AREA_LV.
                 * However, for 'mirror on stripe' using non-RAID targets,
                 * the mirror legs are AREA_LV while the stripes underneath
                 * are AREA_PV.
                 */
                if (segtype_is_raid(segtype))
                        sub_lv_count = mirrors * stripes + segtype->parity_devs;
                else
                        sub_lv_count = mirrors;

                if (!lv->le_count &&
                    !(r = _lv_insert_empty_sublvs(lv, segtype, stripe_size,
                                                  region_size, sub_lv_count))) {
                        log_error("Failed to insert layer for %s", lv->name);
                        goto out;
                }

                if (!(r = _lv_extend_layered_lv(ah, lv, extents, 0,
                                                stripes, stripe_size)))
                        goto_out;

                /*
                 * If we are expanding an existing mirror, we can skip the
                 * resync of the extension if the LV is currently in-sync
                 * and the LV has the LV_NOTSYNCED flag set.
                 */
                if ((lv->le_count != extents) &&
                    segtype_is_mirrored(segtype) &&
                    (lv->status & LV_NOTSYNCED)) {
                        percent_t sync_percent = PERCENT_INVALID;

                        if (!lv_is_active(lv)) {
                                log_print("%s/%s is not active."
                                          "  Unable to get sync percent.",
                                          lv->vg->name, lv->name);
                                if (yes_no_prompt("Do full resync of extended "
                                                  "portion of %s/%s?  [y/n]: ",
                                                  lv->vg->name, lv->name) == 'y')
                                        goto out;
                                r = 0;
                                goto out;
                        }

                        if (!(r = lv_mirror_percent(lv->vg->cmd, lv, 0,
                                                    &sync_percent, NULL))) {
                                log_error("Failed to get sync percent for %s/%s",
                                          lv->vg->name, lv->name);
                                goto out;
                        } else if (sync_percent == PERCENT_100) {
                                log_verbose("Skipping initial resync for "
                                            "extended portion of %s/%s",
                                            lv->vg->name, lv->name);
                                init_mirror_in_sync(1);
                                lv->status |= LV_NOTSYNCED;
                        } else {
                                log_error("%s/%s cannot be extended while"
                                          " it is recovering.",
                                          lv->vg->name, lv->name);
                                r = 0;
                                goto out;
                        }
                }
        }

out:
        alloc_destroy(ah);
        return r;
}

/*
 * Minimal LV renaming function.
 * Metadata transaction should be made by caller.
 * Assumes new_name is allocated from cmd->mem pool.
 */
static int _rename_single_lv(struct logical_volume *lv, char *new_name)
{
        struct volume_group *vg = lv->vg;

        if (find_lv_in_vg(vg, new_name)) {
                log_error("Logical volume \"%s\" already exists in "
                          "volume group \"%s\"", new_name, vg->name);
                return 0;
        }

        if (lv->status & LOCKED) {
                log_error("Cannot rename locked LV %s", lv->name);
                return 0;
        }

        lv->name = new_name;

        return 1;
}

/*
 * Rename sub LV.
 * 'lv_name_old' and 'lv_name_new' are old and new names of the main LV.
 */
static int _rename_sub_lv(struct cmd_context *cmd,
                          struct logical_volume *lv,
                          const char *lv_name_old, const char *lv_name_new)
{
        const char *suffix;
        char *new_name;
        size_t len;

        /*
         * A sub LV name starts with lv_name_old + '_'.
         * The suffix follows lv_name_old and includes '_'.
         */
        len = strlen(lv_name_old);
        if (strncmp(lv->name, lv_name_old, len) || lv->name[len] != '_') {
                log_error("Cannot rename \"%s\": name format not recognized "
                          "for internal LV \"%s\"",
                          lv_name_old, lv->name);
                return 0;
        }
        suffix = lv->name + len;

        /*
         * Compose a new name for sub lv:
         *   e.g. new name is "lvol1_mlog"
         *      if the sub LV is "lvol0_mlog" and
         *      a new name for main LV is "lvol1"
         */
        len = strlen(lv_name_new) + strlen(suffix) + 1;
        new_name = dm_pool_alloc(cmd->mem, len);
        if (!new_name) {
                log_error("Failed to allocate space for new name");
                return 0;
        }
        if (dm_snprintf(new_name, len, "%s%s", lv_name_new, suffix) < 0) {
                log_error("Failed to create new name");
                return 0;
        }

        /* Rename it */
        return _rename_single_lv(lv, new_name);
}

/* Callback for for_each_sub_lv */
static int _rename_cb(struct cmd_context *cmd, struct logical_volume *lv,
                      void *data)
{
        struct lv_names *lv_names = (struct lv_names *) data;

        return _rename_sub_lv(cmd, lv, lv_names->old, lv_names->new);
}

/*
 * Loop down sub LVs and call fn for each.
 * fn is responsible to log necessary information on failure.
 */
int for_each_sub_lv(struct cmd_context *cmd, struct logical_volume *lv,
                    int (*fn)(struct cmd_context *cmd,
                              struct logical_volume *lv, void *data),
                    void *data)
{
        struct logical_volume *org;
        struct lv_segment *seg;
        uint32_t s;

        if (lv_is_cow(lv) && lv_is_virtual_origin(org = origin_from_cow(lv))) {
                if (!fn(cmd, org, data))
                        return_0;
                if (!for_each_sub_lv(cmd, org, fn, data))
                        return_0;
        }

        dm_list_iterate_items(seg, &lv->segments) {
                if (seg->log_lv) {
                        if (!fn(cmd, seg->log_lv, data))
                                return_0;
                        if (!for_each_sub_lv(cmd, seg->log_lv, fn, data))
                                return_0;
                }

                if (seg->metadata_lv) {
                        if (!fn(cmd, seg->metadata_lv, data))
                                return_0;
                        if (!for_each_sub_lv(cmd, seg->metadata_lv, fn, data))
                                return_0;
                }

                for (s = 0; s < seg->area_count; s++) {
                        if (seg_type(seg, s) != AREA_LV)
                                continue;
                        if (!fn(cmd, seg_lv(seg, s), data))
                                return_0;
                        if (!for_each_sub_lv(cmd, seg_lv(seg, s), fn, data))
                                return_0;
                }

                if (!seg_is_raid(seg))
                        continue;

                /* RAID has meta_areas */
                for (s = 0; s < seg->area_count; s++) {
                        if (seg_metatype(seg, s) != AREA_LV)
                                continue;
                        if (!fn(cmd, seg_metalv(seg, s), data))
                                return_0;
                        if (!for_each_sub_lv(cmd, seg_metalv(seg, s), fn, data))
                                return_0;
                }
        }

        return 1;
}


/*
 * Core of LV renaming routine.
 * VG must be locked by caller.
 */
int lv_rename(struct cmd_context *cmd, struct logical_volume *lv,
              const char *new_name)
{
        struct volume_group *vg = lv->vg;
        struct lv_names lv_names;
        DM_LIST_INIT(lvs_changed);
        struct lv_list lvl, lvl2, *lvlp;
        int r = 0;

        /* rename is not allowed on sub LVs */
        if (!lv_is_visible(lv)) {
                log_error("Cannot rename internal LV \"%s\".", lv->name);
                return 0;
        }

        if (find_lv_in_vg(vg, new_name)) {
                log_error("Logical volume \"%s\" already exists in "
                          "volume group \"%s\"", new_name, vg->name);
                return 0;
        }

        if (lv->status & LOCKED) {
                log_error("Cannot rename locked LV %s", lv->name);
                return 0;
        }

        if (!archive(vg))
                return 0;

        /* rename sub LVs */
        lv_names.old = lv->name;
        lv_names.new = new_name;
        if (!for_each_sub_lv(cmd, lv, _rename_cb, (void *) &lv_names))
                return 0;

        /* rename main LV */
        if (!(lv->name = dm_pool_strdup(cmd->mem, new_name))) {
                log_error("Failed to allocate space for new name");
                return 0;
        }

        lvl.lv = lv;
        dm_list_add(&lvs_changed, &lvl.list);

        /* rename active virtual origin too */
        if (lv_is_cow(lv) && lv_is_virtual_origin(lvl2.lv = origin_from_cow(lv)))
                dm_list_add_h(&lvs_changed, &lvl2.list);

        log_verbose("Writing out updated volume group");
        if (!vg_write(vg))
                return 0;

        if (!suspend_lvs(cmd, &lvs_changed, vg))
                goto_out;

        if (!(r = vg_commit(vg)))
                stack;

        /*
         * FIXME: resume LVs in reverse order to prevent memory
         * lock imbalance when resuming virtual snapshot origin
         * (resume of snapshot resumes origin too)
         */
        dm_list_iterate_back_items(lvlp, &lvs_changed)
                if (!resume_lv(cmd, lvlp->lv))
                        stack;
out:
        backup(vg);
        return r;
}

char *generate_lv_name(struct volume_group *vg, const char *format,
                       char *buffer, size_t len)
{
        struct lv_list *lvl;
        int high = -1, i;

        dm_list_iterate_items(lvl, &vg->lvs) {
                if (sscanf(lvl->lv->name, format, &i) != 1)
                        continue;

                if (i > high)
                        high = i;
        }

        if (dm_snprintf(buffer, len, format, high + 1) < 0)
                return NULL;

        return buffer;
}

int vg_max_lv_reached(struct volume_group *vg)
{
        if (!vg->max_lv)
                return 0;

        if (vg->max_lv > vg_visible_lvs(vg))
                return 0;

        log_verbose("Maximum number of logical volumes (%u) reached "
                    "in volume group %s", vg->max_lv, vg->name);

        return 1;
}

struct logical_volume *alloc_lv(struct dm_pool *mem)
{
        struct logical_volume *lv;

        if (!(lv = dm_pool_zalloc(mem, sizeof(*lv)))) {
                log_error("Unable to allocate logical volume structure");
                return NULL;
        }

        lv->snapshot = NULL;
        dm_list_init(&lv->snapshot_segs);
        dm_list_init(&lv->segments);
        dm_list_init(&lv->tags);
        dm_list_init(&lv->segs_using_this_lv);
        dm_list_init(&lv->rsites);

        return lv;
}

/*
 * Create a new empty LV.
 */
struct logical_volume *lv_create_empty(const char *name,
                                       union lvid *lvid,
                                       uint64_t status,
                                       alloc_policy_t alloc,
                                       struct volume_group *vg)
{
        struct format_instance *fi = vg->fid;
        struct logical_volume *lv;
        char dname[NAME_LEN];

        if (vg_max_lv_reached(vg))
                stack;

        if (strstr(name, "%d") &&
            !(name = generate_lv_name(vg, name, dname, sizeof(dname)))) {
                log_error("Failed to generate unique name for the new "
                          "logical volume");
                return NULL;
        } else if (find_lv_in_vg(vg, name)) {
                log_error("Unable to create LV %s in Volume Group %s: "
                          "name already in use.", name, vg->name);
                return NULL;
        }

        log_verbose("Creating logical volume %s", name);

        if (!(lv = alloc_lv(vg->vgmem)))
                return_NULL;

        if (!(lv->name = dm_pool_strdup(vg->vgmem, name)))
                goto_bad;

        lv->status = status;
        lv->alloc = alloc;
        lv->read_ahead = vg->cmd->default_settings.read_ahead;
        lv->major = -1;
        lv->minor = -1;
        lv->size = UINT64_C(0);
        lv->le_count = 0;

        if (lvid)
                lv->lvid = *lvid;

        if (!link_lv_to_vg(vg, lv))
                goto_bad;

        if (!lv_set_creation(lv, NULL, 0))
                goto_bad;
 
        if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv))
                goto_bad;
 
        return lv;
bad:
        dm_pool_free(vg->vgmem, lv);
        return NULL;
}

static int _add_pvs(struct cmd_context *cmd, struct pv_segment *peg,
                    uint32_t s __attribute__((unused)), void *data)
{
        struct seg_pvs *spvs = (struct seg_pvs *) data;
        struct pv_list *pvl;

        /* Don't add again if it's already on list. */
        if (find_pv_in_pv_list(&spvs->pvs, peg->pv))
                        return 1;

        if (!(pvl = dm_pool_alloc(cmd->mem, sizeof(*pvl)))) {
                log_error("pv_list allocation failed");
                return 0;
        }

        pvl->pv = peg->pv;

        dm_list_add(&spvs->pvs, &pvl->list);

        return 1;
}

/*
 * Construct dm_list of segments of LVs showing which PVs they use.
 * For pvmove we use the *parent* LV so we can pick up stripes & existing mirrors etc.
 */
struct dm_list *build_parallel_areas_from_lv(struct logical_volume *lv,
                                             unsigned use_pvmove_parent_lv)
{
        struct cmd_context *cmd = lv->vg->cmd;
        struct dm_list *parallel_areas;
        struct seg_pvs *spvs;
        uint32_t current_le = 0;
        uint32_t raid_multiple;
        struct lv_segment *seg = first_seg(lv);

        if (!(parallel_areas = dm_pool_alloc(cmd->mem, sizeof(*parallel_areas)))) {
                log_error("parallel_areas allocation failed");
                return NULL;
        }

        dm_list_init(parallel_areas);

        do {
                if (!(spvs = dm_pool_zalloc(cmd->mem, sizeof(*spvs)))) {
                        log_error("allocation failed");
                        return NULL;
                }

                dm_list_init(&spvs->pvs);

                spvs->le = current_le;
                spvs->len = lv->le_count - current_le;

                dm_list_add(parallel_areas, &spvs->list);

                if (use_pvmove_parent_lv && !(seg = find_seg_by_le(lv, current_le))) {
                        log_error("Failed to find segment for %s extent %" PRIu32,
                                  lv->name, current_le);
                        return 0;
                }

                /* Find next segment end */
                /* FIXME Unnecessary nesting! */
                if (!_for_each_pv(cmd, use_pvmove_parent_lv ? seg->pvmove_source_seg->lv : lv,
                                  use_pvmove_parent_lv ? seg->pvmove_source_seg->le : current_le,
                                  use_pvmove_parent_lv ? spvs->len * _calc_area_multiple(seg->pvmove_source_seg->segtype, seg->pvmove_source_seg->area_count, 0) : spvs->len,
                                  use_pvmove_parent_lv ? seg->pvmove_source_seg : NULL,
                                  &spvs->len,
                                  0, 0, -1, 0, _add_pvs, (void *) spvs))
                        return_NULL;

                current_le = spvs->le + spvs->len;
                raid_multiple = (seg->segtype->parity_devs) ?
                        seg->area_count - seg->segtype->parity_devs : 1;
        } while ((current_le * raid_multiple) < lv->le_count);

        /* FIXME Merge adjacent segments with identical PV lists (avoids need for contiguous allocation attempts between successful allocations) */

        return parallel_areas;
}

int link_lv_to_vg(struct volume_group *vg, struct logical_volume *lv)
{
        struct lv_list *lvl;

        if (vg_max_lv_reached(vg))
                stack;

        if (!(lvl = dm_pool_zalloc(vg->vgmem, sizeof(*lvl))))
                return_0;

        lvl->lv = lv;
        lv->vg = vg;
        dm_list_add(&vg->lvs, &lvl->list);

        return 1;
}

int unlink_lv_from_vg(struct logical_volume *lv)
{
        struct lv_list *lvl;

        if (!(lvl = find_lv_in_vg(lv->vg, lv->name)))
                return_0;

        dm_list_del(&lvl->list);

        return 1;
}

void lv_set_visible(struct logical_volume *lv)
{
        if (lv_is_visible(lv))
                return;

        lv->status |= VISIBLE_LV;

        log_debug("LV %s in VG %s is now visible.",  lv->name, lv->vg->name);
}

void lv_set_hidden(struct logical_volume *lv)
{
        if (!lv_is_visible(lv))
                return;

        lv->status &= ~VISIBLE_LV;

        log_debug("LV %s in VG %s is now hidden.",  lv->name, lv->vg->name);
}

int lv_remove_single(struct cmd_context *cmd, struct logical_volume *lv,
                     const force_t force)
{
        struct volume_group *vg;
        struct lvinfo info;
        struct logical_volume *format1_origin = NULL;
        int format1_reload_required = 0;
        int visible;
        struct logical_volume *pool_lv = NULL;

        vg = lv->vg;

        if (!vg_check_status(vg, LVM_WRITE))
                return_0;

        if (lv_is_origin(lv)) {
                log_error("Can't remove logical volume \"%s\" under snapshot",
                          lv->name);
                return 0;
        }

        if (lv->status & MIRROR_IMAGE) {
                log_error("Can't remove logical volume %s used by a mirror",
                          lv->name);
                return 0;
        }

        if (lv->status & MIRROR_LOG) {
                log_error("Can't remove logical volume %s used as mirror log",
                          lv->name);
                return 0;
        }

        if (lv->status & (RAID_META | RAID_IMAGE)) {
                log_error("Can't remove logical volume %s used as RAID device",
                          lv->name);
                return 0;
        }

        if (lv_is_thin_pool_data(lv) || lv_is_thin_pool_metadata(lv)) {
                log_error("Can't remove logical volume %s used by a thin pool.",
                          lv->name);
                return 0;
        } else if (lv_is_thin_volume(lv))
                pool_lv = first_seg(lv)->pool_lv;

        if (lv->status & LOCKED) {
                log_error("Can't remove locked LV %s", lv->name);
                return 0;
        }

        /* FIXME Ensure not referred to by another existing LVs */

        if (lv_info(cmd, lv, 0, &info, 1, 0)) {
                if (!lv_check_not_in_use(cmd, lv, &info))
                        return_0;

                if ((force == PROMPT) &&
                    lv_is_visible(lv) &&
                    lv_is_active(lv) &&
                    yes_no_prompt("Do you really want to remove active "
                                  "%slogical volume %s? [y/n]: ",
                                  vg_is_clustered(vg) ? "clustered " : "",
                                  lv->name) == 'n') {
                        log_error("Logical volume %s not removed", lv->name);
                        return 0;
                }
        }

        if (!archive(vg))
                return 0;

        if (lv_is_cow(lv)) {
                /* Old format1 code */
                if (!(lv->vg->fid->fmt->features & FMT_MDAS))
                        format1_origin = origin_from_cow(lv);

                log_verbose("Removing snapshot %s", lv->name);
                /* vg_remove_snapshot() will preload origin/former snapshots */
                if (!vg_remove_snapshot(lv))
                        return_0;
        }

        /* FIXME Review and fix the snapshot error paths! */
        if (!deactivate_lv(cmd, lv)) {
                log_error("Unable to deactivate logical volume \"%s\"",
                          lv->name);
                return 0;
        }

        /* Clear thin pool stacked messages */
        if (pool_lv && !pool_has_message(first_seg(pool_lv), lv, 0) &&
            !update_pool_lv(pool_lv, 1)) {
                log_error("Failed to update thin pool %s.", pool_lv->name);
                return 0;
        }

        visible = lv_is_visible(lv);

        log_verbose("Releasing logical volume \"%s\"", lv->name);
        if (!lv_remove(lv)) {
                log_error("Error releasing logical volume \"%s\"", lv->name);
                return 0;
        }

        /*
         * Old format1 code: If no snapshots left reload without -real.
         */
        if (format1_origin && !lv_is_origin(format1_origin)) {
                log_warn("WARNING: Support for snapshots with old LVM1-style metadata is deprecated.");
                log_warn("WARNING: Please use lvconvert to update to lvm2 metadata at your convenience.");
                format1_reload_required = 1;
        }

        /* store it on disks */
        if (!vg_write(vg))
                return_0;

        /* format1 */
        if (format1_reload_required && !suspend_lv(cmd, format1_origin))
                log_error("Failed to refresh %s without snapshot.", format1_origin->name);

        if (!vg_commit(vg))
                return_0;
 
        /* format1 */
        if (format1_reload_required && !resume_lv(cmd, format1_origin)) {
                log_error("Failed to resume %s.", format1_origin->name);
                return 0;
        }

        /* Release unneeded blocks in thin pool */
        /* TODO: defer when multiple LVs relased at once */
        if (pool_lv && !update_pool_lv(pool_lv, 1)) {
                log_error("Failed to update thin pool %s.", pool_lv->name);
                return 0;
        }

        backup(vg);

        if (visible)
                log_print("Logical volume \"%s\" successfully removed", lv->name);

        return 1;
}

/*
 * remove LVs with its dependencies - LV leaf nodes should be removed first
 */
int lv_remove_with_dependencies(struct cmd_context *cmd, struct logical_volume *lv,
                                const force_t force, unsigned level)
{
        percent_t snap_percent;
        struct dm_list *snh, *snht;
        struct seg_list *sl, *tsl;
        struct lvinfo info;

        if (lv_is_cow(lv)) {
                /*
                 * A merging snapshot cannot be removed directly unless
                 * it has been invalidated or failed merge removal is requested.
                 */
                if (lv_is_merging_cow(lv) && !level) {
                        if (lv_info(lv->vg->cmd, lv, 0, &info, 1, 0) &&
                            info.exists && info.live_table) {
                                if (!lv_snapshot_percent(lv, &snap_percent)) {
                                        log_error("Failed to obtain merging snapshot progress percentage for logical volume %s.",
                                                  lv->name);
                                        return 0;
                                }
                                if ((snap_percent != PERCENT_INVALID) &&
                                     (snap_percent != PERCENT_MERGE_FAILED)) {
                                        log_error("Can't remove merging snapshot logical volume \"%s\"",
                                                  lv->name);
                                        return 0;
                                } else if ((snap_percent == PERCENT_MERGE_FAILED) &&
                                         (force == PROMPT) &&
                                         yes_no_prompt("Removing snapshot \"%s\" that failed to merge may leave origin \"%s\" inconsistent. "
                                                       "Proceed? [y/n]: ", lv->name, origin_from_cow(lv)->name) == 'n') {
                                        log_error("Logical volume %s not removed.", lv->name);
                                        return 0;
                                }
                        }
                }
        }

        if (lv_is_origin(lv)) {
                /* Remove snapshot LVs first */
                if ((force == PROMPT) &&
                    /* Active snapshot already needs to confirm each active LV */
                    !lv_is_active(lv) &&
                    yes_no_prompt("Removing origin %s will also remove %u "
                                  "snapshots(s). Proceed? [y/n]: ",
                                  lv->name, lv->origin_count) == 'n') {
                        log_error("Logical volume %s not removed.", lv->name);
                        return 0;
                }

                dm_list_iterate_safe(snh, snht, &lv->snapshot_segs)
                        if (!lv_remove_with_dependencies(cmd, dm_list_struct_base(snh, struct lv_segment,
                                                                                  origin_list)->cow,
                                                         force, level + 1))
                                return_0;
        }

        if (lv_is_used_thin_pool(lv)) {
                /* Remove thin LVs first */
                if ((force == PROMPT) &&
                    yes_no_prompt("Removing pool %s will also remove %u "
                                  "thin volume(s). OK? [y/n]: ", lv->name,
                                  /* Note: Snaphosts not included */
                                  dm_list_size(&lv->segs_using_this_lv)) == 'n') {
                        log_error("Logical volume %s not removed.", lv->name);
                        return 0;
                }

                dm_list_iterate_items_safe(sl, tsl, &lv->segs_using_this_lv)
                        if (!lv_remove_with_dependencies(cmd, sl->seg->lv,
                                                         force, level + 1))
                                return_0;
        }

        return lv_remove_single(cmd, lv, force);
}

/*
 * insert_layer_for_segments_on_pv() inserts a layer segment for a segment area.
 * However, layer modification could split the underlying layer segment.
 * This function splits the parent area according to keep the 1:1 relationship
 * between the parent area and the underlying layer segment.
 * Since the layer LV might have other layers below, build_parallel_areas()
 * is used to find the lowest-level segment boundaries.
 */
static int _split_parent_area(struct lv_segment *seg, uint32_t s,
                              struct dm_list *layer_seg_pvs)
{
        uint32_t parent_area_len, parent_le, layer_le;
        uint32_t area_multiple;
        struct seg_pvs *spvs;

        if (seg_is_striped(seg))
                area_multiple = seg->area_count;
        else
                area_multiple = 1;

        parent_area_len = seg->area_len;
        parent_le = seg->le;
        layer_le = seg_le(seg, s);

        while (parent_area_len > 0) {
                /* Find the layer segment pointed at */
                if (!(spvs = _find_seg_pvs_by_le(layer_seg_pvs, layer_le))) {
                        log_error("layer segment for %s:%" PRIu32 " not found",
                                  seg->lv->name, parent_le);
                        return 0;
                }

                if (spvs->le != layer_le) {
                        log_error("Incompatible layer boundary: "
                                  "%s:%" PRIu32 "[%" PRIu32 "] on %s:%" PRIu32,
                                  seg->lv->name, parent_le, s,
                                  seg_lv(seg, s)->name, layer_le);
                        return 0;
                }

                if (spvs->len < parent_area_len) {
                        parent_le += spvs->len * area_multiple;
                        if (!lv_split_segment(seg->lv, parent_le))
                                return_0;
                }

                parent_area_len -= spvs->len;
                layer_le += spvs->len;
        }

        return 1;
}

/*
 * Split the parent LV segments if the layer LV below it is splitted.
 */
int split_parent_segments_for_layer(struct cmd_context *cmd,
                                    struct logical_volume *layer_lv)
{
        struct lv_list *lvl;
        struct logical_volume *parent_lv;
        struct lv_segment *seg;
        uint32_t s;
        struct dm_list *parallel_areas;

        if (!(parallel_areas = build_parallel_areas_from_lv(layer_lv, 0)))
                return_0;

        /* Loop through all LVs except itself */
        dm_list_iterate_items(lvl, &layer_lv->vg->lvs) {
                parent_lv = lvl->lv;
                if (parent_lv == layer_lv)
                        continue;

                /* Find all segments that point at the layer LV */
                dm_list_iterate_items(seg, &parent_lv->segments) {
                        for (s = 0; s < seg->area_count; s++) {
                                if (seg_type(seg, s) != AREA_LV ||
                                    seg_lv(seg, s) != layer_lv)
                                        continue;

                                if (!_split_parent_area(seg, s, parallel_areas))
                                        return_0;
                        }
                }
        }

        return 1;
}

/* Remove a layer from the LV */
int remove_layers_for_segments(struct cmd_context *cmd,
                               struct logical_volume *lv,
                               struct logical_volume *layer_lv,
                               uint64_t status_mask, struct dm_list *lvs_changed)
{
        struct lv_segment *seg, *lseg;
        uint32_t s;
        int lv_changed = 0;
        struct lv_list *lvl;

        log_very_verbose("Removing layer %s for segments of %s",
                         layer_lv->name, lv->name);

        /* Find all segments that point at the temporary mirror */
        dm_list_iterate_items(seg, &lv->segments) {
                for (s = 0; s < seg->area_count; s++) {
                        if (seg_type(seg, s) != AREA_LV ||
                            seg_lv(seg, s) != layer_lv)
                                continue;

                        /* Find the layer segment pointed at */
                        if (!(lseg = find_seg_by_le(layer_lv, seg_le(seg, s)))) {
                                log_error("Layer segment found: %s:%" PRIu32,
                                          layer_lv->name, seg_le(seg, s));
                                return 0;
                        }

                        /* Check the segment params are compatible */
                        if (!seg_is_striped(lseg) || lseg->area_count != 1) {
                                log_error("Layer is not linear: %s:%" PRIu32,
                                          layer_lv->name, lseg->le);
                                return 0;
                        }
                        if ((lseg->status & status_mask) != status_mask) {
                                log_error("Layer status does not match: "
                                          "%s:%" PRIu32 " status: 0x%" PRIx64 "/0x%" PRIx64,
                                          layer_lv->name, lseg->le,
                                          lseg->status, status_mask);
                                return 0;
                        }
                        if (lseg->le != seg_le(seg, s) ||
                            lseg->area_len != seg->area_len) {
                                log_error("Layer boundary mismatch: "
                                          "%s:%" PRIu32 "-%" PRIu32 " on "
                                          "%s:%" PRIu32 " / "
                                          "%" PRIu32 "-%" PRIu32 " / ",
                                          lv->name, seg->le, seg->area_len,
                                          layer_lv->name, seg_le(seg, s),
                                          lseg->le, lseg->area_len);
                                return 0;
                        }

                        if (!move_lv_segment_area(seg, s, lseg, 0))
                                return_0;

                        /* Replace mirror with error segment */
                        if (!(lseg->segtype =
                              get_segtype_from_string(lv->vg->cmd, "error"))) {
                                log_error("Missing error segtype");
                                return 0;
                        }
                        lseg->area_count = 0;

                        /* First time, add LV to list of LVs affected */
                        if (!lv_changed && lvs_changed) {
                                if (!(lvl = dm_pool_alloc(cmd->mem, sizeof(*lvl)))) {
                                        log_error("lv_list alloc failed");
                                        return 0;
                                }
                                lvl->lv = lv;
                                dm_list_add(lvs_changed, &lvl->list);
                                lv_changed = 1;
                        }
                }
        }
        if (lv_changed && !lv_merge_segments(lv))
                stack;

        return 1;
}

/* Remove a layer */
int remove_layers_for_segments_all(struct cmd_context *cmd,
                                   struct logical_volume *layer_lv,
                                   uint64_t status_mask,
                                   struct dm_list *lvs_changed)
{
        struct lv_list *lvl;
        struct logical_volume *lv1;

        /* Loop through all LVs except the temporary mirror */
        dm_list_iterate_items(lvl, &layer_lv->vg->lvs) {
                lv1 = lvl->lv;
                if (lv1 == layer_lv)
                        continue;

                if (!remove_layers_for_segments(cmd, lv1, layer_lv,
                                                status_mask, lvs_changed))
                        return_0;
        }

        if (!lv_empty(layer_lv))
                return_0;

        return 1;
}

int move_lv_segments(struct logical_volume *lv_to,
                     struct logical_volume *lv_from,
                     uint64_t set_status, uint64_t reset_status)
{
        struct lv_segment *seg;

        dm_list_iterate_items(seg, &lv_to->segments)
                if (seg->origin) {
                        log_error("Can't move snapshot segment.");
                        return 0;
                }

        dm_list_init(&lv_to->segments);
        dm_list_splice(&lv_to->segments, &lv_from->segments);

        dm_list_iterate_items(seg, &lv_to->segments) {
                seg->lv = lv_to;
                seg->status &= ~reset_status;
                seg->status |= set_status;
        }

        lv_to->le_count = lv_from->le_count;
        lv_to->size = lv_from->size;

        lv_from->le_count = 0;
        lv_from->size = 0;

        return 1;
}

/* Remove a layer from the LV */
int remove_layer_from_lv(struct logical_volume *lv,
                         struct logical_volume *layer_lv)
{
        struct logical_volume *parent;
        struct lv_segment *parent_seg;
        struct segment_type *segtype;

        log_very_verbose("Removing layer %s for %s", layer_lv->name, lv->name);

        if (!(parent_seg = get_only_segment_using_this_lv(layer_lv))) {
                log_error("Failed to find layer %s in %s",
                layer_lv->name, lv->name);
                return 0;
        }
        parent = parent_seg->lv;

        /*
         * Before removal, the layer should be cleaned up,
         * i.e. additional segments and areas should have been removed.
         */
        if (dm_list_size(&parent->segments) != 1 ||
            parent_seg->area_count != 1 ||
            seg_type(parent_seg, 0) != AREA_LV ||
            layer_lv != seg_lv(parent_seg, 0) ||
            parent->le_count != layer_lv->le_count)
                return_0;

        if (!lv_empty(parent))
                return_0;

        if (!move_lv_segments(parent, layer_lv, 0, 0))
                return_0;

        /* Replace the empty layer with error segment */
        segtype = get_segtype_from_string(lv->vg->cmd, "error");
        if (!lv_add_virtual_segment(layer_lv, 0, parent->le_count, segtype, NULL))
                return_0;

        return 1;
}

/*
 * Create and insert a linear LV "above" lv_where.
 * After the insertion, a new LV named lv_where->name + suffix is created
 * and all segments of lv_where is moved to the new LV.
 * lv_where will have a single segment which maps linearly to the new LV.
 */
struct logical_volume *insert_layer_for_lv(struct cmd_context *cmd,
                                           struct logical_volume *lv_where,
                                           uint64_t status,
                                           const char *layer_suffix)
{
        int r;
        char *name;
        size_t len;
        struct str_list *sl;
        struct logical_volume *layer_lv;
        struct segment_type *segtype;
        struct lv_segment *mapseg;
        unsigned exclusive = 0;

        /* create an empty layer LV */
        len = strlen(lv_where->name) + 32;
        if (!(name = alloca(len))) {
                log_error("layer name allocation failed. "
                          "Remove new LV and retry.");
                return NULL;
        }

        if (dm_snprintf(name, len, "%s%s", lv_where->name, layer_suffix) < 0) {
                log_error("layer name allocation failed. "
                          "Remove new LV and retry.");
                return NULL;
        }

        if (!(layer_lv = lv_create_empty(name, NULL, LVM_READ | LVM_WRITE,
                                         ALLOC_INHERIT, lv_where->vg))) {
                log_error("Creation of layer LV failed");
                return NULL;
        }

        if (lv_is_active_exclusive_locally(lv_where))
                exclusive = 1;

        if (lv_is_active(lv_where) && strstr(name, "_mimagetmp")) {
                log_very_verbose("Creating transient LV %s for mirror conversion in VG %s.", name, lv_where->vg->name);

                segtype = get_segtype_from_string(cmd, "error");

                if (!lv_add_virtual_segment(layer_lv, 0, lv_where->le_count, segtype, NULL)) {
                        log_error("Creation of transient LV %s for mirror conversion in VG %s failed.", name, lv_where->vg->name);
                        return NULL;
                }

                /* Temporary tags for activation of the transient LV */
                dm_list_iterate_items(sl, &lv_where->tags)
                        if (!str_list_add(cmd->mem, &layer_lv->tags, sl->str)) {
                                log_error("Aborting.  Unable to tag"
                                          " transient mirror layer.");
                                return NULL;
                        }

                if (!vg_write(lv_where->vg)) {
                        log_error("Failed to write intermediate VG %s metadata for mirror conversion.", lv_where->vg->name);
                        return NULL;
                }

                if (!vg_commit(lv_where->vg)) {
                        log_error("Failed to commit intermediate VG %s metadata for mirror conversion.", lv_where->vg->name);
                        vg_revert(lv_where->vg);
                        return NULL;
                }

                if (exclusive)
                        r = activate_lv_excl(cmd, layer_lv);
                else
                        r = activate_lv(cmd, layer_lv);

                if (!r) {
                        log_error("Failed to resume transient LV"
                                  " %s for mirror conversion in VG %s.",
                                  name, lv_where->vg->name);
                        return NULL;
                }

                /* Remove the temporary tags */
                dm_list_iterate_items(sl, &lv_where->tags)
                        str_list_del(&layer_lv->tags, sl->str);

        }

        log_very_verbose("Inserting layer %s for %s",
                         layer_lv->name, lv_where->name);

        if (!move_lv_segments(layer_lv, lv_where, 0, 0))
                return_NULL;

        if (!(segtype = get_segtype_from_string(cmd, "striped")))
                return_NULL;

        /* allocate a new linear segment */
        if (!(mapseg = alloc_lv_segment(segtype, lv_where, 0, layer_lv->le_count,
                                        status, 0, NULL, NULL, 1, layer_lv->le_count,
                                        0, 0, 0, NULL)))
                return_NULL;

        /* map the new segment to the original underlying are */
        if (!set_lv_segment_area_lv(mapseg, 0, layer_lv, 0, 0))
                return_NULL;

        /* add the new segment to the layer LV */
        dm_list_add(&lv_where->segments, &mapseg->list);
        lv_where->le_count = layer_lv->le_count;
        lv_where->size = (uint64_t) lv_where->le_count * lv_where->vg->extent_size;

        return layer_lv;
}

/*
 * Extend and insert a linear layer LV beneath the source segment area.
 */
static int _extend_layer_lv_for_segment(struct logical_volume *layer_lv,
                                        struct lv_segment *seg, uint32_t s,
                                        uint64_t status)
{
        struct lv_segment *mapseg;
        struct segment_type *segtype;
        struct physical_volume *src_pv = seg_pv(seg, s);
        uint32_t src_pe = seg_pe(seg, s);

        if (seg_type(seg, s) != AREA_PV && seg_type(seg, s) != AREA_LV)
                return_0;

        if (!(segtype = get_segtype_from_string(layer_lv->vg->cmd, "striped")))
                return_0;

        /* FIXME Incomplete message? Needs more context */
        log_very_verbose("Inserting %s:%" PRIu32 "-%" PRIu32 " of %s/%s",
                         pv_dev_name(src_pv),
                         src_pe, src_pe + seg->area_len - 1,
                         seg->lv->vg->name, seg->lv->name);

        /* allocate a new segment */
        if (!(mapseg = alloc_lv_segment(segtype, layer_lv, layer_lv->le_count,
                                        seg->area_len, status, 0,
                                        NULL, NULL, 1, seg->area_len, 0, 0, 0, seg)))
                return_0;

        /* map the new segment to the original underlying are */
        if (!move_lv_segment_area(mapseg, 0, seg, s))
                return_0;

        /* add the new segment to the layer LV */
        dm_list_add(&layer_lv->segments, &mapseg->list);
        layer_lv->le_count += seg->area_len;
        layer_lv->size += (uint64_t) seg->area_len * layer_lv->vg->extent_size;

        /* map the original area to the new segment */
        if (!set_lv_segment_area_lv(seg, s, layer_lv, mapseg->le, 0))
                return_0;

        return 1;
}

/*
 * Match the segment area to PEs in the pvl
 * (the segment area boundary should be aligned to PE ranges by
 *  _adjust_layer_segments() so that there is no partial overlap.)
 */
static int _match_seg_area_to_pe_range(struct lv_segment *seg, uint32_t s,
                                       struct pv_list *pvl)
{
        struct pe_range *per;
        uint32_t pe_start, per_end;

        if (!pvl)
                return 1;

        if (seg_type(seg, s) != AREA_PV || seg_dev(seg, s) != pvl->pv->dev)
                return 0;

        pe_start = seg_pe(seg, s);

        /* Do these PEs match to any of the PEs in pvl? */
        dm_list_iterate_items(per, pvl->pe_ranges) {
                per_end = per->start + per->count - 1;

                if ((pe_start < per->start) || (pe_start > per_end))
                        continue;

                /* FIXME Missing context in this message - add LV/seg details */
                log_debug("Matched PE range %s:%" PRIu32 "-%" PRIu32 " against "
                          "%s %" PRIu32 " len %" PRIu32, dev_name(pvl->pv->dev),
                          per->start, per_end, dev_name(seg_dev(seg, s)),
                          seg_pe(seg, s), seg->area_len);

                return 1;
        }

        return 0;
}

/*
 * For each segment in lv_where that uses a PV in pvl directly,
 * split the segment if it spans more than one underlying PV.
 */
static int _align_segment_boundary_to_pe_range(struct logical_volume *lv_where,
                                               struct pv_list *pvl)
{
        struct lv_segment *seg;
        struct pe_range *per;
        uint32_t pe_start, pe_end, per_end, stripe_multiplier, s;

        if (!pvl)
                return 1;

        /* Split LV segments to match PE ranges */
        dm_list_iterate_items(seg, &lv_where->segments) {
                for (s = 0; s < seg->area_count; s++) {
                        if (seg_type(seg, s) != AREA_PV ||
                            seg_dev(seg, s) != pvl->pv->dev)
                                continue;

                        /* Do these PEs match with the condition? */
                        dm_list_iterate_items(per, pvl->pe_ranges) {
                                pe_start = seg_pe(seg, s);
                                pe_end = pe_start + seg->area_len - 1;
                                per_end = per->start + per->count - 1;

                                /* No overlap? */
                                if ((pe_end < per->start) ||
                                    (pe_start > per_end))
                                        continue;

                                if (seg_is_striped(seg))
                                        stripe_multiplier = seg->area_count;
                                else
                                        stripe_multiplier = 1;

                                if ((per->start != pe_start &&
                                     per->start > pe_start) &&
                                    !lv_split_segment(lv_where, seg->le +
                                                      (per->start - pe_start) *
                                                      stripe_multiplier))
                                        return_0;

                                if ((per_end != pe_end &&
                                     per_end < pe_end) &&
                                    !lv_split_segment(lv_where, seg->le +
                                                      (per_end - pe_start + 1) *
                                                      stripe_multiplier))
                                        return_0;
                        }
                }
        }

        return 1;
}

/*
 * Scan lv_where for segments on a PV in pvl, and for each one found
 * append a linear segment to lv_layer and insert it between the two.
 *
 * If pvl is empty, a layer is placed under the whole of lv_where.
 * If the layer is inserted, lv_where is added to lvs_changed.
 */
int insert_layer_for_segments_on_pv(struct cmd_context *cmd,
                                    struct logical_volume *lv_where,
                                    struct logical_volume *layer_lv,
                                    uint64_t status,
                                    struct pv_list *pvl,
                                    struct dm_list *lvs_changed)
{
        struct lv_segment *seg;
        struct lv_list *lvl;
        int lv_used = 0;
        uint32_t s;

        log_very_verbose("Inserting layer %s for segments of %s on %s",
                         layer_lv->name, lv_where->name,
                         pvl ? pv_dev_name(pvl->pv) : "any");

        if (!_align_segment_boundary_to_pe_range(lv_where, pvl))
                return_0;

        /* Work through all segments on the supplied PV */
        dm_list_iterate_items(seg, &lv_where->segments) {
                for (s = 0; s < seg->area_count; s++) {
                        if (!_match_seg_area_to_pe_range(seg, s, pvl))
                                continue;

                        /* First time, add LV to list of LVs affected */
                        if (!lv_used && lvs_changed) {
                                if (!(lvl = dm_pool_alloc(cmd->mem, sizeof(*lvl)))) {
                                        log_error("lv_list alloc failed");
                                        return 0;
                                }
                                lvl->lv = lv_where;
                                dm_list_add(lvs_changed, &lvl->list);
                                lv_used = 1;
                        }

                        if (!_extend_layer_lv_for_segment(layer_lv, seg, s,
                                                          status)) {
                                log_error("Failed to insert segment in layer "
                                          "LV %s under %s:%" PRIu32 "-%" PRIu32,
                                          layer_lv->name, lv_where->name,
                                          seg->le, seg->le + seg->len);
                                return 0;
                        }
                }
        }

        return 1;
}

/*
 * Initialize the LV with 'value'.
 */
int set_lv(struct cmd_context *cmd, struct logical_volume *lv,
           uint64_t sectors, int value)
{
        struct device *dev;
        char *name;

        /*
         * FIXME:
         * <clausen> also, more than 4k
         * <clausen> say, reiserfs puts it's superblock 32k in, IIRC
         * <ejt_> k, I'll drop a fixme to that effect
         *         (I know the device is at least 4k, but not 32k)
         */
        if (!(name = dm_pool_alloc(cmd->mem, PATH_MAX))) {
                log_error("Name allocation failed - device not cleared");
                return 0;
        }

        if (dm_snprintf(name, PATH_MAX, "%s%s/%s", cmd->dev_dir,
                        lv->vg->name, lv->name) < 0) {
                log_error("Name too long - device not cleared (%s)", lv->name);
                return 0;
        }

        sync_local_dev_names(cmd);  /* Wait until devices are available */

        log_verbose("Clearing start of logical volume \"%s\"", lv->name);

        if (!(dev = dev_cache_get(name, NULL))) {
                log_error("%s: not found: device not cleared", name);
                return 0;
        }

        if (!dev_open_quiet(dev))
                return_0;

        if (!sectors)
                sectors = UINT64_C(4096) >> SECTOR_SHIFT;

        if (sectors > lv->size)
                sectors = lv->size;

        if (!dev_set(dev, UINT64_C(0), (size_t) sectors << SECTOR_SHIFT, value))
                stack;

        dev_flush(dev);

        if (!dev_close_immediate(dev))
                stack;

        return 1;
}

static struct logical_volume *_create_virtual_origin(struct cmd_context *cmd,
                                                     struct volume_group *vg,
                                                     const char *lv_name,
                                                     uint32_t permission,
                                                     uint64_t voriginextents)
{
        const struct segment_type *segtype;
        size_t len;
        char *vorigin_name;
        struct logical_volume *lv;

        if (!(segtype = get_segtype_from_string(cmd, "zero"))) {
                log_error("Zero segment type for virtual origin not found");
                return NULL;
        }

        len = strlen(lv_name) + 32;
        if (!(vorigin_name = alloca(len)) ||
            dm_snprintf(vorigin_name, len, "%s_vorigin", lv_name) < 0) {
                log_error("Virtual origin name allocation failed.");
                return NULL;
        }

        if (!(lv = lv_create_empty(vorigin_name, NULL, permission,
                                   ALLOC_INHERIT, vg)))
                return_NULL;

        if (!lv_extend(lv, segtype, 1, 0, 1, 0, voriginextents,
                       NULL, NULL, ALLOC_INHERIT))
                return_NULL;

        /* store vg on disk(s) */
        if (!vg_write(vg) || !vg_commit(vg))
                return_NULL;

        backup(vg);

        return lv;
}

/* Thin notes:
 * If lp->thin OR lp->activate is AY*, activate the pool if not already active.
 * If lp->thin, create thin LV within the pool - as a snapshot if lp->snapshot.
 *   If lp->activate is AY*, activate it.
 *   If lp->activate was AN* and the pool was originally inactive, deactivate it.
 */
static struct logical_volume *_lv_create_an_lv(struct volume_group *vg, struct lvcreate_params *lp,
                                               const char *new_lv_name)
{
        struct cmd_context *cmd = vg->cmd;
        uint32_t size_rest;
        uint64_t status = UINT64_C(0);
        struct logical_volume *lv, *org = NULL;
        struct logical_volume *pool_lv;
        struct lv_list *lvl;
        int origin_active = 0;
        struct lvinfo info;

        if (new_lv_name && find_lv_in_vg(vg, new_lv_name)) {
                log_error("Logical volume \"%s\" already exists in "
                          "volume group \"%s\"", new_lv_name, lp->vg_name);
                return NULL;
        }

        if (vg_max_lv_reached(vg)) {
                log_error("Maximum number of logical volumes (%u) reached "
                          "in volume group %s", vg->max_lv, vg->name);
                return NULL;
        }

        if ((segtype_is_mirrored(lp->segtype) ||
             segtype_is_raid(lp->segtype) || segtype_is_thin(lp->segtype)) &&
            !(vg->fid->fmt->features & FMT_SEGMENTS)) {
                log_error("Metadata does not support %s segments.",
                          lp->segtype->name);
                return NULL;
        }

        if (lp->read_ahead != DM_READ_AHEAD_AUTO &&
            lp->read_ahead != DM_READ_AHEAD_NONE &&
            (vg->fid->fmt->features & FMT_RESTRICTED_READAHEAD) &&
            (lp->read_ahead < 2 || lp->read_ahead > 120)) {
                log_error("Metadata only supports readahead values between 2 and 120.");
                return NULL;
        }

        if (lp->stripe_size > vg->extent_size) {
                log_error("Reducing requested stripe size %s to maximum, "
                          "physical extent size %s",
                          display_size(cmd, (uint64_t) lp->stripe_size),
                          display_size(cmd, (uint64_t) vg->extent_size));
                lp->stripe_size = vg->extent_size;
        }

        /* Need to check the vg's format to verify this - the cmd format isn't setup properly yet */
        if (lp->stripes > 1 &&
            !(vg->fid->fmt->features & FMT_UNLIMITED_STRIPESIZE) &&
            (lp->stripe_size > STRIPE_SIZE_MAX)) {
                log_error("Stripe size may not exceed %s",
                          display_size(cmd, (uint64_t) STRIPE_SIZE_MAX));
                return NULL;
        }

        if ((size_rest = lp->extents % lp->stripes)) {
                log_print("Rounding size (%d extents) up to stripe boundary "
                          "size (%d extents)", lp->extents,
                          lp->extents - size_rest + lp->stripes);
                lp->extents = lp->extents - size_rest + lp->stripes;
        }

        /* Does LV need to be zeroed?  Thin handles this as a per-pool in-kernel setting. */
        if (lp->zero && !segtype_is_thin(lp->segtype) && !activation()) {
                log_error("Can't wipe start of new LV without using "
                          "device-mapper kernel driver");
                return NULL;
        }

        status |= lp->permission | VISIBLE_LV;

        if (lp->snapshot && lp->thin) {
                if (!(org = find_lv(vg, lp->origin))) {
                        log_error("Couldn't find origin volume '%s'.",
                                  lp->origin);
                        return NULL;
                }

                if (org->status & LOCKED) {
                        log_error("Snapshots of locked devices are not supported.");
                        return NULL;
                }

                lp->voriginextents = org->le_count;
        } else if (lp->snapshot) {
                if (!activation()) {
                        log_error("Can't create snapshot without using "
                                  "device-mapper kernel driver");
                        return NULL;
                }

                /* Must zero cow */
                status |= LVM_WRITE;

                if (lp->voriginsize)
                        origin_active = 1;
                else {

                        if (!(org = find_lv(vg, lp->origin))) {
                                log_error("Couldn't find origin volume '%s'.",
                                          lp->origin);
                                return NULL;
                        }
                        if (lv_is_virtual_origin(org)) {
                                log_error("Can't share virtual origins. "
                                          "Use --virtualsize.");
                                return NULL;
                        }
                        if (lv_is_cow(org)) {
                                log_error("Snapshots of snapshots are not "
                                          "supported yet.");
                                return NULL;
                        }
                        if (org->status & LOCKED) {
                                log_error("Snapshots of locked devices are not "
                                          "supported yet");
                                return NULL;
                        }
                        if (lv_is_merging_origin(org)) {
                                log_error("Snapshots of an origin that has a "
                                          "merging snapshot is not supported");
                                return NULL;
                        }

                        if (lv_is_thin_type(org) && !lv_is_thin_volume(org)) {
                                log_error("Snapshots of thin pool %sdevices "
                                          "are not supported.",
                                          lv_is_thin_pool_data(org) ? "data " :
                                          lv_is_thin_pool_metadata(org) ?
                                          "metadata " : "");
                                return NULL;
                        }

                        if (lv_is_mirror_type(org) &&
                            !seg_is_raid(first_seg(org))) {
                                log_error("Snapshots of \"mirror\" segment types"
                                          " are not supported");
                                return NULL;
                        }

                        if (!lv_info(cmd, org, 0, &info, 0, 0)) {
                                log_error("Check for existence of active snapshot "
                                          "origin '%s' failed.", org->name);
                                return NULL;
                        }
                        origin_active = info.exists;

                        if (vg_is_clustered(vg) &&
                            !lv_is_active_exclusive_locally(org)) {
                                log_error("%s must be active exclusively to"
                                          " create snapshot", org->name);
                                return NULL;
                        }
                }
        }

        if (!seg_is_thin_volume(lp) && !lp->extents) {
                log_error("Unable to create new logical volume with no extents");
                return NULL;
        }

        if (seg_is_thin_pool(lp) &&
            ((uint64_t)lp->extents * vg->extent_size < lp->chunk_size)) {
                log_error("Unable to create thin pool smaller than 1 chunk.");
                return NULL;
        }

        if (lp->snapshot && !lp->thin && ((uint64_t)lp->extents * vg->extent_size < 2 * lp->chunk_size)) {
                log_error("Unable to create a snapshot smaller than 2 chunks.");
                return NULL;
        }

        if (!seg_is_virtual(lp) &&
            vg->free_count < lp->extents) {
                log_error("Volume group \"%s\" has insufficient free space "
                          "(%u extents): %u required.",
                          vg->name, vg->free_count, lp->extents);
                return NULL;
        }

        if (lp->stripes > dm_list_size(lp->pvh) && lp->alloc != ALLOC_ANYWHERE) {
                log_error("Number of stripes (%u) must not exceed "
                          "number of physical volumes (%d)", lp->stripes,
                          dm_list_size(lp->pvh));
                return NULL;
        }

        if (!activation() &&
            (seg_is_mirrored(lp) ||
             seg_is_raid(lp) ||
             seg_is_thin_pool(lp))) {
                /*
                 * FIXME: For thin pool add some code to allow delayed
                 * initialization of empty thin pool volume.
                 * i.e. using some LV flag, fake message,...
                 * and testing for metadata pool header signature?
                 */
                log_error("Can't create %s without using "
                          "device-mapper kernel driver.",
                          segtype_is_raid(lp->segtype) ? lp->segtype->name :
                          segtype_is_mirrored(lp->segtype) ?  "mirror" :
                          "thin pool volume");
                return NULL;
        }

        /* The snapshot segment gets created later */
        if (lp->snapshot && !lp->thin &&
            !(lp->segtype = get_segtype_from_string(cmd, "striped")))
                return_NULL;

        if (!archive(vg))
                return_NULL;

        if (!dm_list_empty(&lp->tags)) {
                if (!(vg->fid->fmt->features & FMT_TAGS)) {
                        log_error("Volume group %s does not support tags",
                                  vg->name);
                        return NULL;
                }
        }

        if (seg_is_thin_volume(lp) &&
            ((lp->activate == CHANGE_AY) ||
             (lp->activate == CHANGE_AE) ||
             (lp->activate == CHANGE_ALY))) {
                /* Ensure all stacked messages are submitted */
                if (!(lvl = find_lv_in_vg(vg, lp->pool))) {
                        log_error("Unable to find existing pool LV %s in VG %s.",
                                  lp->pool, vg->name);
                        return 0;
                }
                if (!update_pool_lv(lvl->lv, 1))
                        return_0;
        }

        if (segtype_is_mirrored(lp->segtype) || segtype_is_raid(lp->segtype)) {
                init_mirror_in_sync(lp->nosync);

                if (lp->nosync) {
                        log_warn("WARNING: New %s won't be synchronised. "
                                 "Don't read what you didn't write!",
                                 lp->segtype->name);
                        status |= LV_NOTSYNCED;
                }

                lp->region_size = adjusted_mirror_region_size(vg->extent_size,
                                                              lp->extents,
                                                              lp->region_size);
        }

        if (!(lv = lv_create_empty(new_lv_name ? : "lvol%d", NULL,
                                   status, lp->alloc, vg)))
                return_NULL;

        if (lp->read_ahead != lv->read_ahead) {
                log_verbose("Setting read ahead sectors");
                lv->read_ahead = lp->read_ahead;
        }

        if (!seg_is_thin_pool(lp) && lp->minor >= 0) {
                lv->major = lp->major;
                lv->minor = lp->minor;
                lv->status |= FIXED_MINOR;
                log_verbose("Setting device number to (%d, %d)", lv->major,
                            lv->minor);
        }

        dm_list_splice(&lv->tags, &lp->tags);

        if (!lv_extend(lv, lp->segtype,
                       lp->stripes, lp->stripe_size,
                       lp->mirrors,
                       seg_is_thin_pool(lp) ? lp->poolmetadataextents : lp->region_size,
                       seg_is_thin_volume(lp) ? lp->voriginextents : lp->extents,
                       seg_is_thin_volume(lp) ? (org ? org->name : lp->pool) : NULL, lp->pvh, lp->alloc))
                return_NULL;

        if (seg_is_thin_pool(lp)) {
                first_seg(lv)->zero_new_blocks = lp->zero ? 1 : 0;
                first_seg(lv)->chunk_size = lp->chunk_size;
                /* FIXME: use lowwatermark  via lvm.conf global for all thinpools ? */
                first_seg(lv)->low_water_mark = 0;
        } else if (seg_is_thin_volume(lp)) {
                pool_lv = first_seg(lv)->pool_lv;

                if (!(first_seg(lv)->device_id =
                      get_free_pool_device_id(first_seg(pool_lv)))) {
                        stack;
                        goto revert_new_lv;
                }

                if (!attach_pool_message(first_seg(pool_lv),
                                         DM_THIN_MESSAGE_CREATE_THIN, lv, 0, 0)) {
                        stack;
                        goto revert_new_lv;
                }
        }

        /* FIXME Log allocation and attachment should have happened inside lv_extend. */
        if (lp->log_count &&
            !seg_is_raid(first_seg(lv)) && seg_is_mirrored(first_seg(lv))) {
                if (!add_mirror_log(cmd, lv, lp->log_count,
                                    first_seg(lv)->region_size,
                                    lp->pvh, lp->alloc)) {
                        stack;
                        goto revert_new_lv;
                }
        }

        /* store vg on disk(s) */
        if (!vg_write(vg) || !vg_commit(vg))
                return_NULL;

        backup(vg);

        if (test_mode()) {
                log_verbose("Test mode: Skipping activation and zeroing.");
                goto out;
        }

        if (seg_is_thin(lp)) {
                /* For snapshot, suspend active thin origin first */
                if (org && lv_is_active(org)) {
                        if (!pool_below_threshold(first_seg(first_seg(org)->pool_lv))) {
                                log_error("Cannot create thin snapshot. Pool %s/%s is filled "
                                          "over the autoextend threshold.",
                                          org->vg->name, first_seg(org)->pool_lv->name);
                                goto revert_new_lv;
                        }
                        if (!suspend_lv_origin(cmd, org)) {
                                log_error("Failed to suspend thin snapshot origin %s/%s.",
                                          org->vg->name, org->name);
                                goto revert_new_lv;
                        }
                        if (!resume_lv_origin(cmd, org)) { /* deptree updates thin-pool */
                                log_error("Failed to resume thin snapshot origin %s/%s.",
                                          org->vg->name, org->name);
                                goto revert_new_lv;
                        }
                        /* At this point remove pool messages, snapshot is active */
                        if (!update_pool_lv(first_seg(org)->pool_lv, 0)) {
                                stack;
                                goto deactivate_and_revert_new_lv;
                        }
                }
                if (((lp->activate == CHANGE_AY) ||
                     (lp->activate == CHANGE_AE) ||
                     (lp->activate == CHANGE_ALY))) {
                        /* At this point send message to kernel thin mda */
                        pool_lv = lv_is_thin_pool(lv) ? lv : first_seg(lv)->pool_lv;
                        if (!update_pool_lv(pool_lv, 1)) {
                                stack;
                                goto deactivate_and_revert_new_lv;
                        }
                        if (!activate_lv_excl(cmd, lv)) {
                                log_error("Aborting. Failed to activate thin %s.",
                                          lv->name);
                                goto deactivate_and_revert_new_lv;
                        }
                }
        } else if (lp->snapshot) {
                if (!activate_lv_excl(cmd, lv)) {
                        log_error("Aborting. Failed to activate snapshot "
                                  "exception store.");
                        goto revert_new_lv;
                }
        } else if ((lp->activate == CHANGE_AY && !activate_lv(cmd, lv)) ||
                   (lp->activate == CHANGE_AE && !activate_lv_excl(cmd, lv)) ||
                   (lp->activate == CHANGE_ALY && !activate_lv_local(cmd, lv))) {
                log_error("Failed to activate new LV.");
                if (lp->zero)
                        goto deactivate_and_revert_new_lv;
                return NULL;
        }

        if (!seg_is_thin(lp) && !lp->zero && !lp->snapshot)
                log_warn("WARNING: \"%s\" not zeroed", lv->name);
        else if ((!seg_is_thin(lp) ||
                  (lv_is_thin_volume(lv) &&
                   !first_seg(first_seg(lv)->pool_lv)->zero_new_blocks)) &&
                 !set_lv(cmd, lv, UINT64_C(0), 0)) {
                log_error("Aborting. Failed to wipe %s.",
                          lp->snapshot ? "snapshot exception store" :
                                         "start of new LV");
                goto deactivate_and_revert_new_lv;
        }

        if (lp->snapshot && !lp->thin) {
                /* Reset permission after zeroing */
                if (!(lp->permission & LVM_WRITE))
                        lv->status &= ~LVM_WRITE;

                /* COW area must be deactivated if origin is not active */
                if (!origin_active && !deactivate_lv(cmd, lv)) {
                        log_error("Aborting. Couldn't deactivate snapshot "
                                  "COW area. Manual intervention required.");
                        return NULL;
                }

                /* A virtual origin must be activated explicitly. */
                if (lp->voriginsize &&
                    (!(org = _create_virtual_origin(cmd, vg, lv->name,
                                                    lp->permission,
                                                    lp->voriginextents)) ||
                     !activate_lv_excl(cmd, org))) {
                        log_error("Couldn't create virtual origin for LV %s",
                                  lv->name);
                        if (org && !lv_remove(org))
                                stack;
                        goto deactivate_and_revert_new_lv;
                }

                /* cow LV remains active and becomes snapshot LV */

                if (!vg_add_snapshot(org, lv, NULL,
                                     org->le_count, lp->chunk_size)) {
                        log_error("Couldn't create snapshot.");
                        goto deactivate_and_revert_new_lv;
                }

                /* store vg on disk(s) */
                if (!vg_write(vg))
                        return_NULL;

                if (!suspend_lv(cmd, org)) {
                        log_error("Failed to suspend origin %s", org->name);
                        vg_revert(vg);
                        return NULL;
                }

                if (!vg_commit(vg))
                        return_NULL;

                if (!resume_lv(cmd, org)) {
                        log_error("Problem reactivating origin %s", org->name);
                        return NULL;
                }
        }
        /* FIXME out of sequence */
        backup(vg);

out:
        return lv;

deactivate_and_revert_new_lv:
        if (!deactivate_lv(cmd, lv)) {
                log_error("Unable to deactivate failed new LV. "
                          "Manual intervention required.");
                return NULL;
        }

revert_new_lv:
        /* FIXME Better to revert to backup of metadata? */
        if (!lv_remove(lv) || !vg_write(vg) || !vg_commit(vg))
                log_error("Manual intervention may be required to remove "
                          "abandoned LV(s) before retrying.");
        else
                backup(vg);

        return NULL;
}

int lv_create_single(struct volume_group *vg,
                     struct lvcreate_params *lp)
{
        struct logical_volume *lv;

        /* Create thin pool first if necessary */
        if (lp->create_thin_pool) {
                if (!seg_is_thin_pool(lp) &&
                    !(lp->segtype = get_segtype_from_string(vg->cmd, "thin-pool")))
                        return_0;

                if (!(lv = _lv_create_an_lv(vg, lp, lp->pool)))
                        return_0;

                if (!lp->thin)
                        goto out;

                lp->pool = lv->name;

                if (!(lp->segtype = get_segtype_from_string(vg->cmd, "thin")))
                        return_0;
        }

        if (!(lv = _lv_create_an_lv(vg, lp, lp->lv_name)))
                return_0;

out:
        log_print("Logical volume \"%s\" created", lv->name);

        return 1;
}