Attachment #35296 for bug #56873





	if (!(cn = find_config_node(cmd->cft->root, "activation/volume_list"))) {
		/* If no hosts tags defined, activate */
		if (lvm_list_empty(&cmd->tags))
			return 1;

		/* If any host tag matches any LV or VG tag, activate */


	log_very_verbose("Getting driver version");
	if (!(dmt = dm_task_create(DM_DEVICE_VERSION))) {
		STACK;
		return 0;
	}



	log_very_verbose("Getting target version for %s", target_name);
	if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS))) {
		STACK;
		return 0;
	}


		return 0;

	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
		STACK;
		return 0;
	}

	if (!(r = dev_manager_info(dm, lv, mknodes, &dminfo)))
		STACK;

	info->exists = dminfo.exists;
	info->suspended = dminfo.suspended;

		return 0;

	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
		STACK;
		return 0;
	}

	if (!(r = dev_manager_snapshot_percent(dm, lv, percent)))
		STACK;

	dev_manager_destroy(dm);


		return 0;

	if (!lv_info(lv, &info)) {
		STACK;
		return 0;
	}


		return 0;

	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
		STACK;
		return 0;
	}

	if (!(r = dev_manager_mirror_percent(dm, lv, wait, percent, event_nr)))
		STACK;

	dev_manager_destroy(dm);


	struct lvinfo info;

	if (!lv_info(lv, &info)) {
		STACK;
		return -1;
	}


	struct lvinfo info;

	if (!lv_info(lv, &info)) {
		STACK;
		return -1;
	}


	struct dev_manager *dm;

	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
		STACK;
		return 0;
	}

	if (!(r = dev_manager_activate(dm, lv)))
		STACK;

	dev_manager_destroy(dm);
	return r;

	struct dev_manager *dm;

	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
		STACK;
		return 0;
	}

	if (!(r = dev_manager_deactivate(dm, lv)))
		STACK;

	dev_manager_destroy(dm);
	return r;

	struct dev_manager *dm;

	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
		STACK;
		return 0;
	}

	if (!(r = dev_manager_suspend(dm, lv)))
		STACK;

	dev_manager_destroy(dm);
	return r;

 */
int lvs_in_vg_activated(struct volume_group *vg)
{
	struct lvm_list *lvh;
	struct logical_volume *lv;
	int count = 0;

	if (!activation())
		return 0;

	lvm_list_iterate(lvh, &vg->lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;
		count += (_lv_active(lv) == 1);
	}



int lvs_in_vg_opened(struct volume_group *vg)
{
	struct lvm_list *lvh;
	struct logical_volume *lv;
	int count = 0;

	if (!activation())
		return 0;

	lvm_list_iterate(lvh, &vg->lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;
		count += (_lv_open_count(lv) > 0);
	}


	}

	if (!lv_info(lv, &info)) {
		STACK;
		return 0;
	}


	}

	if (!lv_info(lv, &info)) {
		STACK;
		return 0;
	}


	}

	if (!lv_info(lv, &info)) {
		STACK;
		return 0;
	}


	}

	if (!lv_info(lv, &info)) {
		STACK;
		return 0;
	}


	}

	if (!_lv_info(lv, 1, &info)) {
		STACK;
		return 0;
	}





	 * Devices that must be created before this one can be created.
	 * Reloads get propagated to this list.  Holds str_lists.
	 */
	struct lvm_list pre_create;

	/* Inverse of pre_create */
	struct lvm_list pre_suspend;

};

struct dl_list {
	struct lvm_list list;
	struct dev_layer *dl;
};


	 * list of struct lv_list, contains lvs that we wish to
	 * be active after execution.
	 */
	struct lvm_list active_list;

	/*
	 * Layers that need reloading.
	 */
	struct lvm_list reload_list;

	/*
	 * Layers that need suspending.
	 */
	struct lvm_list suspend_list;

	/*
	 * Layers that will need removing after activation.
	 */
	struct lvm_list remove_list;

	struct hash_table *layers;
};

	len += hyphens + 2;

	if (!(r = pool_alloc(mem, len))) {
		STACK;
		return NULL;
	}


	len = strlen(lvid) + strlen(layer) + 2;

	if (!(dlid = pool_alloc(mem, len))) {
		STACK;
		return NULL;
	}


	struct dm_task *dmt;

	if (!(dmt = dm_task_create(task))) {
		STACK;
		return NULL;
	}


	dmtask = mknodes ? DM_DEVICE_MKNODES : DM_DEVICE_INFO;

	if (!(dmt = _setup_task(name, uuid, 0, dmtask))) {
		STACK;
		return 0;
	}

	if (!dm_task_run(dmt)) {
		STACK;
		goto out;
	}

	if (!dm_task_get_info(dmt, info)) {
		STACK;
		goto out;
	}

	if (info->exists && uuid_out) {
		if (!(u = dm_task_get_uuid(dmt))) {
			STACK;
			goto out;
		}
		*uuid_out = pool_strdup(mem, u);

	char *params = NULL;

	if (!(dmt = _setup_task(name, uuid, 0, DM_DEVICE_STATUS))) {
		STACK;
		return 0;
	}

	if (!dm_task_run(dmt)) {
		STACK;
		goto out;
	}


	char *type = NULL;
	char *params = NULL;
	float percent2;
	struct lvm_list *segh = &lv->segments;
	struct lv_segment *seg = NULL;

	uint64_t numerator, denominator;

	if (!(dmt = _setup_task(name, uuid, event_nr,
				wait ? DM_DEVICE_WAITEVENT : DM_DEVICE_STATUS)))
	{
		STACK;
		return 0;
	}

	if (!dm_task_run(dmt)) {
		STACK;
		goto out;
	}

	if (!dm_task_get_info(dmt, &info) || !info.exists) {
		STACK;
		goto out;
	}


		next = dm_get_next_target(dmt, next, &start, &length, &type,
					  &params);
		if (lv) {
			if (!(segh = lvm_list_next(&lv->segments, segh))) {
				log_error("Number of segments in active LV %s "
					  "does not match metadata", lv->name);
				goto out;
			}
			seg = lvm_list_item(segh, struct lv_segment);
		}

		if (!type || !params || strcmp(type, target_type))

		}
	} while (next);

	if (lv && (segh = lvm_list_next(&lv->segments, segh))) {
		log_error("Number of segments in active LV %s does not "
			  "match metadata", lv->name);
		goto out;

	log_verbose("Renaming %s to %s", dl->name, newname);

	if (!(dmt = _setup_task(dl->name, NULL, 0, DM_DEVICE_RENAME))) {
		STACK;
		return 0;
	}

	if (!dm_task_set_newname(dmt, newname)) {
		STACK;
		r = 0;
		goto out;
	}

	log_verbose("Loading %s", dl->name);
	if (!(dmt = _setup_task(task == DM_DEVICE_CREATE ? dl->name : NULL,
				dl->dlid, 0, task))) {
		STACK;
		return 0;
	}


	}

	if (!dm_task_get_info(dmt, &dl->info)) {
		STACK;
		r = 0;
		goto out;
	}

	if (!dl->info.exists || !dl->info.live_table) {
		STACK;
		r = 0;
		goto out;
	}

		log_very_verbose("Removing %s", dl->name);

	if (!(dmt = _setup_task(dl->name, NULL, 0, DM_DEVICE_REMOVE))) {
		STACK;
		return 0;
	}



	log_very_verbose("%s %s", sus ? "Suspending" : "Resuming", name);
	if (!(dmt = _setup_task(name, NULL, 0, task))) {
		STACK;
		return 0;
	}


		return 1;

	if (!_suspend_or_resume(dl->name, SUSPEND)) {
		STACK;
		return 0;
	}


		return 1;

	if (!_suspend_or_resume(dl->name, RESUME)) {
		STACK;
		return 0;
	}



	if (!dm_task_add_target(dmt, esize * seg->le, esize * seg->len,
				target, params)) {
		STACK;
		return 0;
	}


		dbg_free(params);

		if (!ret)
			STACK;

		if (ret >= 0)
			return ret;

static int _populate_vanilla(struct dev_manager *dm,
			     struct dm_task *dmt, struct dev_layer *dl)
{
	struct lvm_list *segh;
	struct lv_segment *seg;
	struct logical_volume *lv = dl->lv;

	dm->pvmove_mirror_count = 0u;

	lvm_list_iterate(segh, &lv->segments) {
		seg = lvm_list_item(segh, struct lv_segment);
		if (!_emit_target(dm, dmt, seg)) {
			log_error("Unable to build table for '%s'", lv->name);
			return 0;

	struct dev_layer *dlr;

	if (!(real = _build_dlid(dm->mem, dl->lv->lvid.s, "real"))) {
		STACK;
		return 0;
	}


		  dl->lv->size, params);
	if (!dm_task_add_target(dmt, UINT64_C(0), dl->lv->size,
				"snapshot-origin", params)) {
		STACK;
		return 0;
	}


	}

	if (!(origin = _build_dlid(dm->mem, s->origin->lvid.s, "real"))) {
		STACK;
		return 0;
	}

	if (!(cow = _build_dlid(dm->mem, s->cow->lvid.s, "cow"))) {
		STACK;
		return 0;
	}



	if (lvm_snprintf(params, sizeof(params), "%s %s P %d",
			 devbufo, devbufc, s->chunk_size) == -1) {
		STACK;
		return 0;
	}


		  s->origin->size, params);
	if (!dm_task_add_target
	    (dmt, UINT64_C(0), s->origin->size, "snapshot", params)) {
		STACK;
		return 0;
	}


	struct dev_manager *dm;

	if (!(mem = pool_create(16 * 1024))) {
		STACK;
		return NULL;
	}

	if (!(dm = pool_alloc(mem, sizeof(*dm)))) {
		STACK;
		goto bad;
	}


	dm->mirror_region_size = mirror_region_size;

	if (!(dm->vg_name = pool_strdup(dm->mem, vg_name))) {
		STACK;
		goto bad;
	}

	if (!(dm->layers = hash_create(32))) {
		STACK;
		goto bad;
	}

	lvm_list_init(&dm->active_list);
	lvm_list_init(&dm->reload_list);
	lvm_list_init(&dm->remove_list);
	lvm_list_init(&dm->suspend_list);

	return dm;


	 * Build a name for the top layer.
	 */
	if (!(name = _build_name(dm->mem, lv->vg->name, lv->name, NULL))) {
		STACK;
		return 0;
	}


	 */
	log_debug("Getting device info for %s", name);
	if (!_info(name, lv->lvid.s, mknodes, info, NULL, NULL)) {
		STACK;
		return 0;
	}


	 * Build a name for the top layer.
	 */
	if (!(name = _build_name(dm->mem, lv->vg->name, lv->name, NULL))) {
		STACK;
		return 0;
	}


	log_debug("Getting device status percentage for %s", name);
	if (!(_percent(dm, name, lv->lvid.s, "snapshot", 0, NULL, percent,
		       NULL))) {
		STACK;
		return 0;
	}


	 * Build a name for the top layer.
	 */
	if (!(name = _build_name(dm->mem, lv->vg->name, lv->name, NULL))) {
		STACK;
		return 0;
	}


	log_debug("Getting device mirror status percentage for %s", name);
	if (!(_percent(dm, name, lv->lvid.s, "mirror", wait, lv, percent,
		       event_nr))) {
		STACK;
		return 0;
	}


	char *uuid;

	if (!(dl = pool_zalloc(dm->mem, sizeof(*dl)))) {
		STACK;
		return NULL;
	}



	log_debug("Getting device info for %s", dl->name);
	if (!_info(dl->name, dlid, 0, &dl->info, dm->mem, &uuid)) {
		STACK;
		return NULL;
	}


	else
		dl->dlid = dlid;

	lvm_list_init(&dl->pre_create);
	lvm_list_init(&dl->pre_suspend);

	if (!hash_insert(dm->layers, dl->dlid, dl)) {
		STACK;
		return NULL;
	}


	struct dev_layer *dl;

	if (!(name = _build_name(dm->mem, lv->vg->name, lv->name, layer))) {
		STACK;
		return NULL;
	}

	if (!(dlid = _build_dlid(dm->mem, lv->lvid.s, layer))) {
		STACK;
		return NULL;
	}

	if (!(dl = hash_lookup(dm->layers, dlid)) &&
	    !(dl = _create_dev(dm, name, dlid))) {
		STACK;
		return NULL;
	}


	struct dev_layer *dl;

	if (!(dlid = _build_dlid(dm->mem, lvid, layer))) {
		STACK;
		return NULL;
	}


	 * only one layer.
	 */
	struct dev_layer *dl, *dlr;
	struct lvm_list *segh;
	struct lv_segment *seg;
	uint32_t s;

	if (!(dl = _create_layer(dm, NULL, lv))) {
		STACK;
		return 0;
	}
	dl->populate = _populate_vanilla;

		_set_flag(dl, TOPLEVEL);

	/* Add dependencies for any LVs that segments refer to */
	lvm_list_iterate(segh, &lv->segments) {
		seg = lvm_list_item(segh, struct lv_segment);
		if (seg->type != SEG_STRIPED && seg->type != SEG_MIRRORED)
			continue;
		for (s = 0; s < seg->area_count; s++) {

					  _build_dlid(dm->mem,
						      seg->area[s].u.lv.
						      lv->lvid.s, NULL))) {
				STACK;
				return 0;
			}
			_set_flag(dl, NOPROPAGATE);


	/* Deactivating the last snapshot */
	if (!(dlr = _create_layer(dm, "real", lv))) {
		STACK;
		return 0;
	}


	/* add the dependency on the real device */
	if (!str_list_add(dm->mem, &dl->pre_create,
			  pool_strdup(dm->mem, dlr->dlid))) {
		STACK;
		return 0;
	}


	const char *real_dlid;

	if (!(dl = _create_layer(dm, "real", lv))) {
		STACK;
		return 0;
	}
	dl->populate = _populate_vanilla;

	real_dlid = dl->dlid;

	if (!(dl = _create_layer(dm, NULL, lv))) {
		STACK;
		return 0;
	}
	dl->populate = _populate_origin;

	/* add the dependency on the real device */
	if (!str_list_add(dm->mem, &dl->pre_create,
			  pool_strdup(dm->mem, real_dlid))) {
		STACK;
		return 0;
	}


{
	struct logical_volume *active;
	struct snapshot *s;
	struct lvm_list *sh;

	/*
	 * We only need to create an origin layer if one of our
	 * snapshots is in the active list
	 */
	lvm_list_iterate(sh, &dm->active_list) {
		active = lvm_list_item(sh, struct lv_list)->lv;
		if ((s = find_cow(active)) && (s->origin == lv))
			return _expand_origin_real(dm, lv);
	}

	const char *cow_dlid;

	if (!(dl = _create_layer(dm, "cow", lv))) {
		STACK;
		return 0;
	}
	dl->populate = _populate_vanilla;

	cow_dlid = dl->dlid;

	if (!(dl = _create_layer(dm, NULL, lv))) {
		STACK;
		return 0;
	}
	dl->populate = _populate_snapshot;

	/* add the dependency on the cow device */
	if (!str_list_add(dm->mem, &dl->pre_create,
			  pool_strdup(dm->mem, cow_dlid))) {
		STACK;
		return 0;
	}

	/* add the dependency on the real origin device */
	if (!str_list_add(dm->mem, &dl->pre_create,
			  _build_dlid(dm->mem, s->origin->lvid.s, "real"))) {
		STACK;
		return 0;
	}

	/* add the dependency on the visible origin device */
	if (!str_list_add(dm->mem, &dl->pre_suspend, s->origin->lvid.s)) {
		STACK;
		return 0;
	}


static int _trace_layer_marks(struct dev_manager *dm, struct dev_layer *dl,
			      int flag)
{
	struct lvm_list *sh;
	const char *dlid;
	struct dev_layer *dep;

	lvm_list_iterate(sh, &dl->pre_create) {
		dlid = lvm_list_item(sh, struct str_list)->str;

		if (!(dep = hash_lookup(dm->layers, dlid))) {
			log_error("Couldn't find device layer '%s'.", dlid);

		_set_flag(dep, flag);

		if (!_trace_layer_marks(dm, dep, flag)) {
			STACK;
			return 0;
		}
	}

	hash_iterate(hn, dm->layers) {
		dl = hash_get_data(dm->layers, hn);
		if (_get_flag(dl, flag) && !_trace_layer_marks(dm, dl, flag)) {
			STACK;
			return 0;
		}
	}

 * Marks the top layers, then traces these through the
 * dependencies.
 */
static int _mark_lvs(struct dev_manager *dm, struct lvm_list *lvs, int flag)
{
	struct lvm_list *lvh;
	struct logical_volume *lv;
	struct dev_layer *dl;

	lvm_list_iterate(lvh, lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;

		if (!(dl = _lookup(dm, lv->lvid.s, NULL))) {
			STACK;
			return 0;
		}


	}

	if (!_trace_all_marks(dm, flag)) {
		STACK;
		return 0;
	}



static int _suspend_parents(struct dev_manager *dm, struct dev_layer *dl)
{
	struct lvm_list *sh;
	struct dev_layer *dep;
	const char *dlid;

	lvm_list_iterate(sh, &dl->pre_suspend) {
		dlid = lvm_list_item(sh, struct str_list)->str;

		if (!(dep = hash_lookup(dm->layers, dlid))) {
			log_debug("_suspend_parents couldn't find device "

		}

		if (!_suspend_parents(dm, dep)) {
			STACK;
			return 0;
		}

		if (dep->info.exists & !_suspend(dep)) {
			STACK;
			return 0;
		}
	}


static int _resume_with_deps(struct dev_manager *dm, struct dev_layer *dl)
{
	struct lvm_list *sh;
	struct dev_layer *dep;
	const char *dlid;

	lvm_list_iterate(sh, &dl->pre_create) {
		dlid = lvm_list_item(sh, struct str_list)->str;

		if (!(dep = hash_lookup(dm->layers, dlid))) {
			log_debug("_resume_with_deps couldn't find device "

		}

		if (!_resume_with_deps(dm, dep)) {
			STACK;
			return 0;
		}
	}

	if (dl->info.exists & !_get_flag(dl, SUSPENDED) && !_resume(dl)) {
		STACK;
		return 0;
	}


 */
static int _create_rec(struct dev_manager *dm, struct dev_layer *dl)
{
	struct lvm_list *sh;
	struct dev_layer *dep;
	const char *dlid;
	char *newname, *suffix;

	/* Suspend? */
	if (_get_flag(dl, SUSPENDED) &&
	    (!_suspend_parents(dm, dl) || !_suspend(dl))) {
		STACK;
		return 0;
	}

	lvm_list_iterate(sh, &dl->pre_create) {
		dlid = lvm_list_item(sh, struct str_list)->str;

		if (!(dep = hash_lookup(dm->layers, dlid))) {
			log_error("Couldn't find device layer '%s'.", dlid);

		}

		if (!_create_rec(dm, dep)) {
			STACK;
			return 0;
		}
	}

		if (strcmp(newname, dl->name)) {
			if (!_suspend_parents(dm, dl) ||
			    !_suspend(dl) || !_rename(dl, newname)) {
				STACK;
				return 0;
			}
		}

	if (!dl->info.exists) {
		if (!_suspend_parents(dm, dl) ||
		    !_load(dm, dl, DM_DEVICE_CREATE)) {
			STACK;
			return 0;
		}
		return 1;

	if (_get_flag(dl, RELOAD) &&
	    (!_suspend_parents(dm, dl) || !_suspend(dl) ||
	     !_load(dm, dl, DM_DEVICE_RELOAD))) {
		STACK;
		return 0;
	}



static int _build_all_layers(struct dev_manager *dm, struct volume_group *vg)
{
	struct lvm_list *lvh;
	struct logical_volume *lvt;

	/*
	 * Build layers for complete vg.
	 */
	lvm_list_iterate(lvh, &vg->lvs) {
		lvt = lvm_list_item(lvh, struct lv_list)->lv;
		if (!_expand_lv(dm, lvt)) {
			STACK;
			return 0;
		}
	}

		if (!_get_flag(dl, ACTIVE)) {
			dll = pool_alloc(dm->mem, sizeof(*dll));
			if (!dll) {
				STACK;
				return 0;
			}

			dll->dl = dl;
			lvm_list_add(&dm->remove_list, &dll->list);
		}
	}


{
	struct hash_node *hn;
	struct dev_layer *dl;
	struct lvm_list *sh;
	const char *dlid;
	struct dev_layer *dep;

	hash_iterate(hn, dm->layers) {
		dl = hash_get_data(dm->layers, hn);

		lvm_list_iterate(sh, &dl->pre_suspend) {
			dlid = lvm_list_item(sh, struct str_list)->str;

			if (!(dep = hash_lookup(dm->layers, dlid))) {
				log_debug("_populate_pre_suspend_lists: "


			if (!str_list_add(dm->mem, &dep->pre_create,
					  dl->dlid)) {
				STACK;
				return 0;
			}
		}

		lvm_list_iterate(sh, &dl->pre_create) {
			dlid = lvm_list_item(sh, struct str_list)->str;

			if (!(dep = hash_lookup(dm->layers, dlid))) {
				log_debug("_populate_pre_suspend_lists: "


			if (!str_list_add(dm->mem, &dep->pre_suspend,
					  dl->dlid)) {
				STACK;
				return 0;
			}
		}

static int _remove_old_layers(struct dev_manager *dm)
{
	int change;
	struct lvm_list *rh, *n;
	struct dev_layer *dl;

	do {
		change = 0;
		lvm_list_iterate_safe(rh, n, &dm->remove_list) {
			dl = lvm_list_item(rh, struct dl_list)->dl;

			if (!dl->info.exists) {
				lvm_list_del(rh);
				continue;
			}

			if (_remove(dl)) {
				change = 1;
				lvm_list_del(rh);
			}
		}

	} while (change);

	if (!lvm_list_empty(&dm->remove_list)) {
		lvm_list_iterate(rh, &dm->remove_list) {
			dl = lvm_list_item(rh, struct dl_list)->dl;
			log_error("Couldn't deactivate device %s", dl->name);
		}
		return 0;

	struct dev_layer *dl;

	if (!_build_all_layers(dm, vg)) {
		STACK;
		return 0;
	}


	 */
	_clear_marks(dm, RELOAD);
	if (!_mark_lvs(dm, &dm->reload_list, RELOAD)) {
		STACK;
		return 0;
	}


	 */
	_clear_marks(dm, ACTIVE);
	if (!_mark_lvs(dm, &dm->active_list, ACTIVE)) {
		STACK;
		return 0;
	}


	 */
	_clear_marks(dm, SUSPENDED);
	if (!_mark_lvs(dm, &dm->suspend_list, SUSPENDED)) {
		STACK;
		return 0;
	}

	if (!_fill_in_remove_list(dm)) {
		STACK;
		return 0;
	}

	if (!_populate_pre_suspend_lists(dm)) {
		STACK;
		return 0;
	}



		if (_get_flag(dl, ACTIVE) && _get_flag(dl, TOPLEVEL))
			if (!_create_rec(dm, dl)) {
				STACK;
				return 0;
			}
	}

		dl = hash_get_data(dm->layers, hn);

		if (!_resume_with_deps(dm, dl)) {
			STACK;
			return 0;
		}
	}

	if (!_remove_old_layers(dm)) {
		STACK;
		return 0;
	}


	log_debug("Found existing layer '%s'", name);

	if (!(copy = pool_strdup(dm->mem, name))) {
		STACK;
		return 0;
	}

	if (!(dl = _create_dev(dm, copy, ""))) {
		STACK;
		return 0;
	}


		names = (void *) names + next;
		if (_belong_to_vg(dm->vg_name, names->name) &&
		    !_add_existing_layer(dm, names->name)) {
			STACK;
			r = 0;
			break;
		}

}

static int _add_lv(struct pool *mem,
		   struct lvm_list *head, struct logical_volume *lv)
{
	struct lv_list *lvl;

	if (!(lvl = pool_alloc(mem, sizeof(*lvl)))) {
		STACK;
		return 0;
	}

	lvl->lv = lv;
	lvm_list_add(head, &lvl->list);

	return 1;
}

static int _add_lvs(struct pool *mem,
		    struct lvm_list *head, struct logical_volume *origin)
{
	struct logical_volume *lv;
	struct snapshot *s;
	struct lvm_list *lvh;

	lvm_list_iterate(lvh, &origin->vg->lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;
		if ((s = find_cow(lv)) && s->origin == origin)
			if (!_add_lv(mem, head, lv))
				return 0;

	return _add_lv(mem, head, origin);
}

static void _remove_lv(struct lvm_list *head, struct logical_volume *lv)
{
	struct lvm_list *lvh;
	struct lv_list *lvl;

	lvm_list_iterate(lvh, head) {
		lvl = lvm_list_item(lvh, struct lv_list);
		if (lvl->lv == lv) {
			lvm_list_del(lvh);
			break;
		}
	}

{
	struct logical_volume *active, *old_origin;
	struct snapshot *s;
	struct lvm_list *sh, *active_head;

	active_head = &dm->active_list;

	/* Remove any snapshots with given origin */
	lvm_list_iterate(sh, active_head) {
		active = lvm_list_item(sh, struct lv_list)->lv;
		if ((s = find_cow(active)) && s->origin == lv) {
			_remove_lv(active_head, active);
		}

	old_origin = s->origin;

	/* Was this the last active snapshot with this origin? */
	lvm_list_iterate(sh, active_head) {
		active = lvm_list_item(sh, struct lv_list)->lv;
		if ((s = find_cow(active)) && s->origin == old_origin) {
			return 1;
		}

{
	struct logical_volume *suspended;
	struct snapshot *s;
	struct lvm_list *sh, *suspend_head;

	suspend_head = &dm->suspend_list;

	/* Remove from list any snapshots with given origin */
	lvm_list_iterate(sh, suspend_head) {
		suspended = lvm_list_item(sh, struct lv_list)->lv;
		if ((s = find_cow(suspended)) && s->origin == lv) {
			_remove_lv(suspend_head, suspended);
		}

static int _fill_in_active_list(struct dev_manager *dm, struct volume_group *vg)
{
	char *dlid;
	struct lvm_list *lvh;
	struct logical_volume *lv;
	struct dev_layer *dl;

	lvm_list_iterate(lvh, &vg->lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;

		if (!(dlid = _build_dlid(dm->mem, lv->lvid.s, NULL))) {
			STACK;
			return 0;
		}


				  dl->info.suspended ? " (suspended)" : "");

			if (!_add_lv(dm->mem, &dm->active_list, lv)) {
				STACK;
				return 0;
			}

			if (dl->info.suspended) {
				if (!_add_lv(dm->mem, &dm->suspend_list, lv)) {
					STACK;
					return 0;
				}
			}

		   action_t action)
{
	if (!_scan_existing_devices(dm)) {
		STACK;
		return 0;
	}

	if (!_fill_in_active_list(dm, lv->vg)) {
		STACK;
		return 0;
	}

	if (action == ACTIVATE || action == DEACTIVATE)
		/* Get into known state - remove from active list if present */
		if (!_remove_lvs(dm, lv)) {
			STACK;
			return 0;
		}


		/* Add to active & reload lists */
		if (!_add_lvs(dm->mem, &dm->reload_list, lv) ||
		    !_add_lvs(dm->mem, &dm->active_list, lv)) {
			STACK;
			return 0;
		}
	}

	if (action == SUSPEND || action == RESUME || action == ACTIVATE)
		/* Get into known state - remove from suspend list if present */
		if (!_remove_suspended_lvs(dm, lv)) {
			STACK;
			return 0;
		}

	if (action == SUSPEND) {
		if (!_add_lvs(dm->mem, &dm->suspend_list, lv)) {
			STACK;
			return 0;
		}
	}

	if (!_execute(dm, lv->vg)) {
		STACK;
		return 0;
	}



	if (!(name = _build_name(lv->vg->cmd->mem, lv->vg->name,
				 lv->name, NULL))) {
		STACK;
		return 0;
	}





	case FS_ADD:
		if (!_mk_dir(dev_dir, vg_name) ||
		    !_mk_link(dev_dir, vg_name, lv_name, dev)) {
			STACK;
			return 0;
		}
		break;
	case FS_DEL:
		if (!_rm_link(dev_dir, vg_name, lv_name) ||
		    !_rm_dir(dev_dir, vg_name)) {
			STACK;
			return 0;
		}
		break;
		/* FIXME Use rename() */
	case FS_RENAME:
		if (old_lv_name && !_rm_link(dev_dir, vg_name, old_lv_name))
			STACK;

		if (!_mk_link(dev_dir, vg_name, lv_name, dev))
			STACK;
	}

	return 1;

static LIST_INIT(_fs_ops);

struct fs_op_parms {
	struct lvm_list list;
	fs_op_t type;
	char *dev_dir;
	char *vg_name;

	_store_str(&pos, &fsp->dev, dev);
	_store_str(&pos, &fsp->old_lv_name, old_lv_name);

	lvm_list_add(&_fs_ops, &fsp->list);

	return 1;
}

static void _pop_fs_ops(void)
{
	struct lvm_list *fsph, *fspht;
	struct fs_op_parms *fsp;

	lvm_list_iterate_safe(fsph, fspht, &_fs_ops) {
		fsp = lvm_list_item(fsph, struct fs_op_parms);
		_do_fs_op(fsp->type, fsp->dev_dir, fsp->vg_name, fsp->lv_name,
			  fsp->dev, fsp->old_lv_name);
		lvm_list_del(&fsp->list);
		dbg_free(fsp);
	}
}

	if (memlock()) {
		if (!_stack_fs_op(type, dev_dir, vg_name, lv_name, dev,
				  old_lv_name)) {
			STACK;
			return 0;
		}
		return 1;




static struct hash_table *_vgid_hash = NULL;
static struct hash_table *_vgname_hash = NULL;
static struct hash_table *_lock_hash = NULL;
static struct lvm_list _vginfos;
static int _has_scanned = 0;
static int _vgs_locked = 0;

int lvmcache_init(void)
{
	lvm_list_init(&_vginfos);

	if (!(_vgname_hash = hash_create(128)))
		return 0;

	struct label *label;
	struct dev_iter *iter;
	struct device *dev;
	struct lvm_list *fmth;
	struct format_type *fmt;

	static int _scanning_in_progress = 0;

	_has_scanned = 1;

	/* Perform any format-specific scanning e.g. text files */
	lvm_list_iterate(fmth, &cmd->formats) {
		fmt = lvm_list_item(fmth, struct format_type);
		if (fmt->ops->scan && !fmt->ops->scan(fmt))
			goto out;
	}

	return r;
}

struct lvm_list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan)
{
	struct lvm_list *vgnames;
	struct lvmcache_vginfo *vgi;

	lvmcache_label_scan(cmd, full_scan);

		return NULL;
	}

	lvm_list_iterate_items(vgi, &_vginfos) {
		if (!str_list_add(cmd->mem, vgnames, 
				  pool_strdup(cmd->mem, vgi->vgname))) {
			log_error("strlist allocation failed");


static void _drop_vginfo(struct lvmcache_info *info)
{
	if (!lvm_list_empty(&info->list)) {
		lvm_list_del(&info->list);
		lvm_list_init(&info->list);
	}

	if (info->vginfo && lvm_list_empty(&info->vginfo->infos)) {
		hash_remove(_vgname_hash, info->vginfo->vgname);
		if (info->vginfo->vgname)
			dbg_free(info->vginfo->vgname);
		if (*info->vginfo->vgid)
			hash_remove(_vgid_hash, info->vginfo->vgid);
		lvm_list_del(&info->vginfo->list);
		dbg_free(info->vginfo);
	}


			log_error("cache vgname alloc failed for %s", vgname);
			return 0;
		}
		lvm_list_init(&vginfo->infos);
		if (!hash_insert(_vgname_hash, vginfo->vgname, vginfo)) {
			log_error("cache_update: vg hash insertion failed: %s",
				  vginfo->vgname);

		}
		/* Ensure orphans appear last on list_iterate */
		if (!*vgname)
			lvm_list_add(&_vginfos, &vginfo->list);
		else
			lvm_list_add_h(&_vginfos, &vginfo->list);
	}

	info->vginfo = vginfo;
	lvm_list_add(&vginfo->infos, &info->list);

	/* FIXME Check consistency of list! */
	vginfo->fmt = info->fmt;


int lvmcache_update_vg(struct volume_group *vg)
{
	struct lvm_list *pvh;
	struct physical_volume *pv;
	struct lvmcache_info *info;
	char pvid_s[ID_LEN + 1];


	pvid_s[sizeof(pvid_s) - 1] = '\0';

	lvm_list_iterate(pvh, &vg->pvs) {
		pv = lvm_list_item(pvh, struct pv_list)->pv;
		strncpy(pvid_s, (char *) &pv->id, sizeof(pvid_s) - 1);
		/* FIXME Could pv->dev->pvid ever be different? */
		if ((info = info_from_pvid(pvid_s))) {

	if (!(existing = info_from_pvid(pvid_s)) &&
	    !(existing = info_from_pvid(dev->pvid))) {
		if (!(label = label_create(labeller))) {
			STACK;
			return NULL;
		}
		if (!(info = dbg_malloc(sizeof(*info)))) {


		label->info = info;
		info->label = label;
		lvm_list_init(&info->list);
		info->dev = dev;
	} else {
		if (existing->dev != dev) {

			label_destroy(info->label);
			if (!(info->label = label_create(labeller))) {
				/* FIXME leaves info without label! */
				STACK;
				return NULL;
			}
			info->label->info = info;


	if (!_lvmcache_update_vgid(info, vgid))
		/* Non-critical */
		STACK;

	return info;
}

static void _lvmcache_destroy_entry(struct lvmcache_info *info)
{
	if (!lvm_list_empty(&info->list))
		lvm_list_del(&info->list);
	strcpy(info->dev->pvid, "");
	label_destroy(info->label);
	dbg_free(info);

		_lock_hash = NULL;
	}

	lvm_list_init(&_vginfos);
}




/* Eventual replacement for struct physical_volume perhaps? */

struct lvmcache_vginfo {
	struct lvm_list list;	/* Join these vginfos together */
	struct lvm_list infos;	/* List head for lvmcache_infos */
	char *vgname;		/* "" == orphan */
	char vgid[ID_LEN + 1];
	const struct format_type *fmt;
};

struct lvmcache_info {
	struct lvm_list list;	/* Join VG members together */
	struct lvm_list mdas;	/* list head for metadata areas */
	struct lvm_list das;	/* list head for data areas */
	struct lvmcache_vginfo *vginfo;	/* NULL == unknown */
	struct label *label;
	const struct format_type *fmt;


/* Returns list of struct str_lists containing pool-allocated copy of vgnames */
/* Set full_scan to 1 to reread every filtered device label */
struct lvm_list *lvmcache_get_vgnames(struct cmd_context *cmd, int full_scan);

#endif




	char config_file[PATH_MAX] = "";

	if (!(cmd->cft = create_config_tree())) {
		STACK;
		return 0;
	}


	struct config_value *cv;

	if (!dev_cache_init()) {
		STACK;
		return 0;
	}


	const char *format;

	struct format_type *fmt;
	struct lvm_list *fmth;

#ifdef HAVE_LIBDL
	struct config_node *cn;

	if (!(fmt = init_lvm1_format(cmd)))
		return 0;
	fmt->library = NULL;
	lvm_list_add(&cmd->formats, &fmt->list);
#endif

#ifdef HAVE_LIBDL

			}
			if (!(lib = load_shared_library(cmd->cft, cv->v.str,
							"format"))) {
				STACK;
				return 0;
			}


			if (!(fmt = init_format_fn(cmd)))
				return 0;
			fmt->library = lib;
			lvm_list_add(&cmd->formats, &fmt->list);
		}
	}
#endif

	if (!(fmt = create_text_format(cmd)))
		return 0;
	fmt->library = NULL;
	lvm_list_add(&cmd->formats, &fmt->list);

	cmd->fmt_backup = fmt;

	format = find_config_str(cmd->cft->root, "global/format",
				 DEFAULT_FORMAT);

	lvm_list_iterate(fmth, &cmd->formats) {
		fmt = lvm_list_item(fmth, struct format_type);
		if (!strcasecmp(fmt->name, format) ||
		    (fmt->alias && !strcasecmp(fmt->alias, format))) {
			cmd->default_settings.fmt = fmt;

	const char *tag;
	int passes;

	lvm_list_init(&cmd->tags);

	if (!(tn = find_config_node(cmd->cft->root, "tags")) ||
	    !tn->child) {

			    DEFAULT_HOSTTAGS)) {
		/* FIXME Strip out invalid chars: only A-Za-z0-9_+.- */
		if (!_set_tag(cmd, cmd->hostname)) {
			STACK;
			return 0;
		}
	}

		if (cn->child) {
			passes = 0;
			if (!_check_host_filters(cmd, cn->child, &passes)) {
				STACK;
				return 0;
			}
			if (!passes)
				continue;
		}
		if (!_set_tag(cmd, tag)) {
			STACK;
			return 0;
		}
	}

	}
	memset(cmd, 0, sizeof(*cmd));
	cmd->args = the_args;
	lvm_list_init(&cmd->formats);

	strcpy(cmd->sys_dir, DEFAULT_SYS_DIR);


	return 1;
}

static void _destroy_formats(struct lvm_list *formats)
{
	struct lvm_list *fmtl, *tmp;
	struct format_type *fmt;
	void *lib;

	lvm_list_iterate_safe(fmtl, tmp, formats) {
		fmt = lvm_list_item(fmtl, struct format_type);
		lvm_list_del(&fmt->list);
		lib = fmt->library;
		fmt->ops->destroy(fmt);
#ifdef HAVE_LIBDL

Lines 56-62 Link Here

(-)LVM2.2.00.15.orig/lib/commands/toolcontext.h (-2 / +2 lines)
56	const struct format_type fmt; / Current format to use by default */	56	const struct format_type fmt; / Current format to use by default */
57	struct format_type fmt_backup; / Format to use for backups */	57	struct format_type fmt_backup; / Format to use for backups */
58		58
59	struct list formats; /* Available formats */	59	struct lvm_list formats; /* Available formats */
60	const char *hostname;	60	const char *hostname;
61	const char *kernel_vsn;	61	const char *kernel_vsn;
62		62
Lines 73-79 Link Here
73	struct config_info current_settings;	73	struct config_info current_settings;
74		74
75	/* List of defined tags */	75	/* List of defined tags */
76	struct list tags;	76	struct lvm_list tags;
77		77
78	char sys_dir[PATH_MAX];	78	char sys_dir[PATH_MAX];
79	char dev_dir[PATH_MAX];	79	char dev_dir[PATH_MAX];




	struct pool *mem = pool_create(10 * 1024);

	if (!mem) {
		STACK;
		return 0;
	}

	if (!(c = pool_alloc(mem, sizeof(*c)))) {
		STACK;
		pool_destroy(mem);
		return 0;
	}

	off_t mmap_offset = 0;

	if (!(p = pool_alloc(c->mem, sizeof(*p)))) {
		STACK;
		return 0;
	}
	p->mem = c->mem;

		p->fb = p->fb + mmap_offset;
	} else {
		if (!(p->fb = dbg_malloc(size + size2))) {
			STACK;
			return 0;
		}
		if (!dev_read(dev, (uint64_t) offset, size, p->fb)) {

	p->line = 1;
	_get_token(p, TOK_SECTION_E);
	if (!(cft->root = _file(p))) {
		STACK;
		goto out;
	}


	}

	if (!(dev = dev_create_file(file, NULL, NULL))) {
		STACK;
		return 0;
	}

	if (!dev_open_flags(dev, O_RDONLY, 0, 0)) {
		STACK;
		return 0;
	}


	}

	if (!(dev = dev_create_file(c->filename, NULL, NULL))) {
		STACK;
		return 0;
	}

	if (!dev_open_flags(dev, O_RDONLY, 0, 0)) {
		STACK;
		return 0;
	}


	struct config_node *root = NULL, *n, *l = NULL;
	while (p->t != TOK_EOF) {
		if (!(n = _section(p))) {
			STACK;
			return 0;
		}


	/* IDENTIFIER '{' VALUE* '}' */
	struct config_node *root, *n, *l = NULL;
	if (!(root = _create_node(p))) {
		STACK;
		return 0;
	}

	if (!(root->key = _dup_tok(p))) {
		STACK;
		return 0;
	}


		match(TOK_SECTION_B);
		while (p->t != TOK_SECTION_E) {
			if (!(n = _section(p))) {
				STACK;
				return 0;
			}


	} else {
		match(TOK_EQ);
		if (!(root->v = _value(p))) {
			STACK;
			return 0;
		}
	}

		match(TOK_ARRAY_B);
		while (p->t != TOK_ARRAY_E) {
			if (!(l = _type(p))) {
				STACK;
				return 0;
			}



		p->tb++, p->te--;	/* strip "'s */
		if (!(v->v.str = _dup_tok(p))) {
			STACK;
			return 0;
		}
		p->te++;

	size_t len = p->te - p->tb;
	char *str = pool_alloc(p->mem, len + 1);
	if (!str) {
		STACK;
		return 0;
	}
	strncpy(str, p->tb, len);

Lines 87-93 Link Here

(-)LVM2.2.00.15.orig/lib/datastruct/btree.c (-1 / +1 lines)
87		87
88	if (!*c) {	88	if (!*c) {
89	if (!(n = pool_alloc(t->mem, sizeof(*n)))) {	89	if (!(n = pool_alloc(t->mem, sizeof(*n)))) {
90	stack;	90	STACK;
91	return 0;	91	return 0;
92	}	92	}
93		93

Lines 90-96 Link Here

(-)LVM2.2.00.15.orig/lib/datastruct/hash.c (-2 / +2 lines)
90	struct hash_table hc = dbg_malloc(sizeof(hc));	90	struct hash_table hc = dbg_malloc(sizeof(hc));
91		91
92	if (!hc) {	92	if (!hc) {
93	stack;	93	STACK;
94	return 0;	94	return 0;
95	}	95	}
96		96
Lines 103-109 Link Here
103	hc->num_slots = new_size;	103	hc->num_slots = new_size;
104	len = sizeof((hc->slots)) new_size;	104	len = sizeof((hc->slots)) new_size;
105	if (!(hc->slots = dbg_malloc(len))) {	105	if (!(hc->slots = dbg_malloc(len))) {
106	stack;	106	STACK;
107	goto bad;	107	goto bad;
108	}	108	}
109	memset(hc->slots, 0, len);	109	memset(hc->slots, 0, len);





#include <assert.h>

struct lvm_list {
	struct lvm_list *n, *p;
};

#define LIST_INIT(name)	struct lvm_list name = { &(name), &(name) }

static inline void lvm_list_init(struct lvm_list *head)
{
	head->n = head->p = head;
}

static inline void lvm_list_add(struct lvm_list *head, struct lvm_list *elem)
{
	assert(head->n);


	head->p = elem;
}

static inline void lvm_list_add_h(struct lvm_list *head, struct lvm_list *elem)
{
	assert(head->n);


	head->n = elem;
}

static inline void lvm_list_del(struct lvm_list *elem)
{
	elem->n->p = elem->p;
	elem->p->n = elem->n;
}

static inline int lvm_list_empty(struct lvm_list *head)
{
	return head->n == head;
}

static inline int lvm_list_end(struct lvm_list *head, struct lvm_list *elem)
{
	return elem->n == head;
}

static inline struct lvm_list *lvm_list_next(struct lvm_list *head, struct lvm_list *elem)
{
	return (lvm_list_end(head, elem) ? NULL : elem->n);
}

#define lvm_list_item(v, t) \
    ((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->list))

#define lvm_list_struct_base(v, t, h) \
    ((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->h))

/* Given a known element in a known structure, locate another */
#define struct_field(v, t, e, f) \
    (((t *)((uintptr_t)(v) - (uintptr_t)&((t *) 0)->e))->f)

/* Given a known element in a known structure, locate the lvm_list head */
#define lvm_list_head(v, t, e) struct_field(v, t, e, lvm_list)

#define lvm_list_iterate(v, head) \
	for (v = (head)->n; v != head; v = v->n)

#define lvm_list_uniterate(v, head, start) \
	for (v = (start)->p; v != head; v = v->p)

#define lvm_list_iterate_safe(v, t, head) \
	for (v = (head)->n, t = v->n; v != head; v = t, t = v->n)

#define lvm_list_iterate_items(v, head) \
	for (v = lvm_list_item((head)->n, typeof(*v)); &v->list != (head); \
	     v = lvm_list_item(v->list.n, typeof(*v)))

static inline unsigned int lvm_list_size(const struct lvm_list *head)
{
	unsigned int s = 0;
	const struct lvm_list *v;

	lvm_list_iterate(v, head)
	    s++;

	return s;

Lines 25-31 Link Here

(-)LVM2.2.00.15.orig/lib/datastruct/lvm-types.h (-1 / +1 lines)
25	#define PRIsize_t "Zu"	25	#define PRIsize_t "Zu"
26		26
27	struct str_list {	27	struct str_list {
28	struct list list;	28	struct lvm_list list;
29	const char *str;	29	const char *str;
30	};	30	};
31		31




#include "lib.h"
#include "str_list.h"

struct lvm_list *str_list_create(struct pool *mem)
{
	struct lvm_list *sl;

	if (!(sl = pool_alloc(mem, sizeof(struct lvm_list)))) {
		STACK;
		return NULL;
	}

	lvm_list_init(sl);

	return sl;
}

int str_list_add(struct pool *mem, struct lvm_list *sll, const char *str)
{
	struct str_list *sln;

	if (!str) {
		STACK;
		return 0;
	}


		return 1;

	if (!(sln = pool_alloc(mem, sizeof(*sln)))) {
		STACK;
		return 0;
	}

	sln->str = str;
	lvm_list_add(sll, &sln->list);

	return 1;
}

int str_list_del(struct lvm_list *sll, const char *str)
{
	struct lvm_list *slh, *slht;

	lvm_list_iterate_safe(slh, slht, sll) {
		if (!strcmp(str, lvm_list_item(slh, struct str_list)->str))
			 lvm_list_del(slh);
	}

	return 1;
}

int str_list_dup(struct pool *mem, struct lvm_list *sllnew, struct lvm_list *sllold)
{
	struct str_list *sl;

	lvm_list_init(sllnew);

	lvm_list_iterate_items(sl, sllold) {
		if (!str_list_add(mem, sllnew, strdup(sl->str))) {
			STACK;
			return 0;
		}
	}

/*
 * Is item on list?
 */
int str_list_match_item(struct lvm_list *sll, const char *str)
{
	struct str_list *sl;

	lvm_list_iterate_items(sl, sll)
	    if (!strcmp(str, sl->str))
		return 1;


/*
 * Is at least one item on both lists?
 */
int str_list_match_list(struct lvm_list *sll, struct lvm_list *sll2)
{
	struct str_list *sl;

	lvm_list_iterate_items(sl, sll)
	    if (str_list_match_item(sll2, sl->str))
		return 1;


/*
 * Do both lists contain the same set of items?
 */
int str_list_lists_equal(struct lvm_list *sll, struct lvm_list *sll2)
{
	struct str_list *sl;

	if (lvm_list_size(sll) != lvm_list_size(sll2))
		return 0;

	lvm_list_iterate_items(sl, sll)
	    if (!str_list_match_item(sll2, sl->str))
		return 0;






#include "pool.h"

struct lvm_list *str_list_create(struct pool *mem);
int str_list_add(struct pool *mem, struct lvm_list *sll, const char *str);
int str_list_del(struct lvm_list *sll, const char *str);
int str_list_match_item(struct lvm_list *sll, const char *str);
int str_list_match_list(struct lvm_list *sll, struct lvm_list *sll2);
int str_list_lists_equal(struct lvm_list *sll, struct lvm_list *sll2);
int str_list_dup(struct pool *mem, struct lvm_list *sllnew, struct lvm_list *sllold);

#endif




};

struct dir_list {
	struct lvm_list list;
	char dir[0];
};


	struct btree *devices;

	int has_scanned;
	struct lvm_list dirs;

} _cache;


	dev->flags = DEV_REGULAR;
	if (allocate)
		dev->flags |= DEV_ALLOCED;
	lvm_list_init(&dev->aliases);
	lvm_list_add(&dev->aliases, &alias->list);
	dev->end = UINT64_C(0);
	dev->dev = 0;
	dev->fd = -1;
	dev->open_count = 0;
	memset(dev->pvid, 0, sizeof(dev->pvid));
	lvm_list_init(&dev->open_list);

	return dev;
}

		return NULL;
	}
	dev->flags = 0;
	lvm_list_init(&dev->aliases);
	dev->dev = d;
	dev->fd = -1;
	dev->open_count = 0;
	dev->end = UINT64_C(0);
	memset(dev->pvid, 0, sizeof(dev->pvid));
	lvm_list_init(&dev->open_list);

	return dev;
}

static int _add_alias(struct device *dev, const char *path)
{
	struct str_list *sl = _alloc(sizeof(*sl));
	struct lvm_list *ah;
	const char *oldpath;
	int prefer_old = 1;

	if (!sl) {
		STACK;
		return 0;
	}

	/* Is name already there? */
	lvm_list_iterate(ah, &dev->aliases) {
		if (!strcmp(lvm_list_item(ah, struct str_list)->str, path)) {
			STACK;
			return 1;
		}
	}

	if (!(sl->str = pool_strdup(_cache.mem, path))) {
		STACK;
		return 0;
	}

	if (!lvm_list_empty(&dev->aliases)) {
		oldpath = lvm_list_item(dev->aliases.n, struct str_list)->str;
		prefer_old = _compare_paths(path, oldpath);
		log_debug("%s: Aliased to %s in device cache%s",
			  path, oldpath, prefer_old ? "" : " (preferred name)");

		log_debug("%s: Added to device cache", path);

	if (prefer_old)
		lvm_list_add(&dev->aliases, &sl->list);
	else
		lvm_list_add_h(&dev->aliases, &sl->list);

	return 1;
}

						   (uint32_t) d))) {
		/* create new device */
		if (!(dev = _dev_create(d))) {
			STACK;
			return 0;
		}


			}

			if (!(path = _join(dir, dirent[n]->d_name))) {
				STACK;
				return 0;
			}


		}

		if (!_insert_dev(path, info.st_rdev)) {
			STACK;
			return 0;
		}



static void _full_scan(void)
{
	struct lvm_list *dh;

	if (_cache.has_scanned)
		return;

	lvm_list_iterate(dh, &_cache.dirs) {
		struct dir_list *dl = lvm_list_item(dh, struct dir_list);
		_insert_dir(dl->dir);
	};


	_cache.names = NULL;

	if (!(_cache.mem = pool_create(10 * 1024))) {
		STACK;
		return 0;
	}

	if (!(_cache.names = hash_create(128))) {
		STACK;
		pool_destroy(_cache.mem);
		_cache.mem = 0;
		return 0;

		goto bad;
	}

	lvm_list_init(&_cache.dirs);

	return 1;



	_cache.devices = NULL;
	_cache.has_scanned = 0;
	lvm_list_init(&_cache.dirs);
}

int dev_cache_add_dir(const char *path)

	}

	strcpy(dl->dir, path);
	lvm_list_add(&_cache.dirs, &dl->list);
	return 1;
}


	const char *name;
	int r;

	while ((r = stat(name = lvm_list_item(dev->aliases.n,
					  struct str_list)->str, &buf)) ||
	       (buf.st_rdev != dev->dev)) {
		if (r < 0) {

		/* Leave list alone if there isn't an alternative name */
		/* so dev_name will always find something to return. */
		/* Otherwise add the name to the correct device. */
		if (lvm_list_size(&dev->aliases) > 1) {
			lvm_list_del(dev->aliases.n);
			if (!r)
				_insert(name, 0);
			continue;





	if (!(where->dev->flags & DEV_REGULAR) &&
	    !_get_block_size(where->dev, &block_size)) {
		STACK;
		return 0;
	}


	/* channel the io through the bounce buffer */
	if (!_io(&widened, bounce, 0)) {
		if (!should_write) {
			STACK;
			return 0;
		}
		/* FIXME pre-extend the file */

	if (dev->flags & DEV_REGULAR)
		name = dev_name(dev);
	else if (!(name = dev_name_confirmed(dev, quiet))) {
		STACK;
		return 0;
	}


		dev->end = lseek(dev->fd, (off_t) 0, SEEK_END);
	}

	lvm_list_add(&_open_devices, &dev->open_list);
	log_debug("Opened %s", dev_name(dev));

	return 1;

	if (close(dev->fd))
		log_sys_error("close", dev_name(dev));
	dev->fd = -1;
	lvm_list_del(&dev->open_list);

	log_debug("Closed %s", dev_name(dev));

	if (dev->flags & DEV_ALLOCED) {
		dbg_free((void *) lvm_list_item(dev->aliases.n, struct str_list)->
			 str);
		dbg_free(dev->aliases.n);
		dbg_free(dev);


void dev_close_all(void)
{
	struct lvm_list *doh, *doht;
	struct device *dev;

	lvm_list_iterate_safe(doh, doht, &_open_devices) {
		dev = lvm_list_struct_base(doh, struct device, open_list);
		if (dev->open_count < 1)
			_close(dev);
	}

	char buffer[4096];

	if (!dev_open(dev)) {
		STACK;
		return 0;
	}


	dev->flags |= DEV_ACCESSED_W;

	if (!dev_close(dev))
		STACK;

	/* FIXME: Always display error */
	return (len == 0);




 * pointer comparisons are valid.
 */
struct device {
	struct lvm_list aliases;	/* struct str_list from lvm-types.h */
	dev_t dev;

	/* private */

	int open_count;
	uint32_t flags;
	uint64_t end;
	struct lvm_list open_list;

	char pvid[ID_LEN + 1];
};

struct device_list {
	struct lvm_list list;
	struct device *dev;
};



static inline const char *dev_name(const struct device *dev)
{
	return (dev) ? lvm_list_item(dev->aliases.n, struct str_list)->str :
	    "unknown device";
}





		return;

	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
		STACK;
		return;
	}


		return;

	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
		STACK;
		return;
	}


		return 0;

	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
		STACK;
		return 0;
	}


	int inkernel, snap_active;
	char uuid[64];
	struct snapshot *snap = NULL;
	struct lvm_list *slh, *snaplist;
	float snap_percent;	/* fused, fsize; */

	if (!id_write_format(&lv->lvid.id[1], uuid, sizeof(uuid))) {
		STACK;
		return 0;
	}


		log_print("LV snapshot status     source of");

		snaplist = find_snapshots(lv);
		lvm_list_iterate(slh, snaplist) {
			snap = lvm_list_item(slh, struct snapshot_list)->snapshot;
			snap_active = lv_snapshot_percent(snap->cow,
							  &snap_percent);
			if (!snap_active || snap_percent < 0 ||

    log_print("Allocated LE           %u", lv->allocated_le);
**********/

	log_print("Segments               %u", lvm_list_size(&lv->segments));

/********* FIXME Stripes & stripesize for each segment
	log_print("Stripe size (KByte)    %u", lv->stripesize / 2);

int lvdisplay_segments(struct logical_volume *lv)
{
	uint32_t s;
	struct lvm_list *segh;
	struct lv_segment *seg;

	log_print("--- Segments ---");

	lvm_list_iterate(segh, &lv->segments) {
		seg = lvm_list_item(segh, struct lv_segment);

		log_print("Logical extent %u to %u:",
			  seg->le, seg->le + seg->len - 1);

	char uuid[64];

	if (vg->status & PARTIAL_VG)
		active_pvs = lvm_list_size(&vg->pvs);
	else
		active_pvs = vg->pv_count;


	log_print("Format                %s", vg->fid->fmt->name);
	if (vg->fid->fmt->features & FMT_MDAS) {
		log_print("Metadata Areas        %d",
			  lvm_list_size(&vg->fid->metadata_areas));
		log_print("Metadata Sequence No  %d", vg->seqno);
	}
	access = vg->status & (LVM_READ | LVM_WRITE);

							    2), SIZE_SHORT));

	if (!id_write_format(&vg->id, uuid, sizeof(uuid))) {
		STACK;
		return;
	}


	char uuid[64];

	if (vg->status & PARTIAL_VG)
		active_pvs = lvm_list_size(&vg->pvs);
	else
		active_pvs = vg->pv_count;


	}

	if (!id_write_format(&vg->id, uuid, sizeof(uuid))) {
		STACK;
		return;
	}


Lines 51-57 Link Here

(-)LVM2.2.00.15.orig/lib/filters/filter-composite.c (-1 / +1 lines)
51	struct dev_filter *filters_copy, cf;	51	struct dev_filter *filters_copy, cf;
52		52
53	if (!filters) {	53	if (!filters) {
54	stack;	54	STACK;
55	return NULL;	55	return NULL;
56	}	56	}
57		57




	uint32_t md_magic;

	if (!dev_get_size(dev, &size)) {
		STACK;
		return 0;
	}


		return 1;

	if (!dev_open(dev)) {
		STACK;
		return 0;
	}


			log_debug("%s: Skipping md component device",
				  dev_name(dev));
			if (!dev_close(dev))
				STACK;
			return 0;
		}
	}

	if (!dev_close(dev))
		STACK;

	return 1;
}




		hash_destroy(pf->devices);

	if (!(pf->devices = hash_create(128))) {
		STACK;
		return 0;
	}


	struct config_tree *cft;

	if (!(cft = create_config_tree())) {
		STACK;
		return 0;
	}

	if (!read_config_file(cft, pf->file)) {
		STACK;
		goto out;
	}


	struct pfilter *pf = (struct pfilter *) f->private;
	void *l = hash_lookup(pf->devices, dev_name(dev));
	struct str_list *sl;
	struct lvm_list *ah;

	if (!l) {
		l = pf->real->passes_filter(pf->real, dev) ?
		    PF_GOOD_DEVICE : PF_BAD_DEVICE;

		lvm_list_iterate(ah, &dev->aliases) {
			sl = lvm_list_item(ah, struct str_list);
			hash_insert(pf->devices, sl->str, l);
		}
	}

	struct dev_filter *f = NULL;

	if (!(pf = dbg_malloc(sizeof(*pf)))) {
		STACK;
		return NULL;
	}
	memset(pf, 0, sizeof(*pf));

	if (!(pf->file = dbg_malloc(strlen(file) + 1))) {
		STACK;
		goto bad;
	}
	strcpy(pf->file, file);

	}

	if (!(f = dbg_malloc(sizeof(*f)))) {
		STACK;
		goto bad;
	}





	 * copy the regex
	 */
	if (!(r = pool_strdup(mem, pat))) {
		STACK;
		return 0;
	}


	int i, r = 0;

	if (!(scratch = pool_create(1024))) {
		STACK;
		return 0;
	}


	 * allocate space for them
	 */
	if (!(regex = pool_alloc(scratch, sizeof(*regex) * count))) {
		STACK;
		goto out;
	}


	 */
	if (!(rf->engine = matcher_create(rf->mem, (const char **) regex,
					  count)))
		STACK;
	r = 1;

      out:


static int _accept_p(struct dev_filter *f, struct device *dev)
{
	struct lvm_list *ah;
	int m, first = 1, rejected = 0;
	struct rfilter *rf = (struct rfilter *) f->private;
	struct str_list *sl;

	lvm_list_iterate(ah, &dev->aliases) {
		sl = lvm_list_item(ah, struct str_list);
		m = matcher_run(rf->engine, sl->str);

		if (m >= 0) {

				if (!first) {
					log_debug("%s: New preferred name",
						  sl->str);
					lvm_list_del(&sl->list);
					lvm_list_add_h(&dev->aliases, &sl->list);
				}

				return 1;

	struct dev_filter *f;

	if (!mem) {
		STACK;
		return NULL;
	}

	if (!(rf = pool_alloc(mem, sizeof(*rf)))) {
		STACK;
		goto bad;
	}

	rf->mem = mem;

	if (!_build_matcher(rf, patterns)) {
		STACK;
		goto bad;
	}

	if (!(f = pool_zalloc(mem, sizeof(*f)))) {
		STACK;
		goto bad;
	}


Lines 264-270 Link Here

(-)LVM2.2.00.15.orig/lib/filters/filter-sysfs.c (-1 / +1 lines)
264	}	264	}
265		265
266	if (!(f = pool_zalloc(mem, sizeof(*f)))) {	266	if (!(f = pool_zalloc(mem, sizeof(*f)))) {
267	stack;	267	STACK;
268	goto bad;	268	goto bad;
269	}	269	}
270		270

Lines 212-218 Link Here

(-)LVM2.2.00.15.orig/lib/filters/filter.c (-1 / +1 lines)
212	f->destroy = lvm_type_filter_destroy;	212	f->destroy = lvm_type_filter_destroy;
213		213
214	if (!(f->private = _scan_proc_dev(proc, cn))) {	214	if (!(f->private = _scan_proc_dev(proc, cn))) {
215	stack;	215	STACK;
216	return NULL;	216	return NULL;
217	}	217	}
218		218





#include <fcntl.h>

#define fail do {STACK; return 0;} while(0)
#define xx16(v) disk->v = xlate16(disk->v)
#define xx32(v) disk->v = xlate32(disk->v)
#define xx64(v) disk->v = xlate64(disk->v)

		memcpy(ul->uuid, buffer, NAME_LEN);
		ul->uuid[NAME_LEN - 1] = '\0';

		lvm_list_add(&data->uuids, &ul->list);

		pos += NAME_LEN;
		num_read++;

			continue;

		read++;
		lvm_list_add(&data->lvds, &ll->list);
	}

	return 1;

	struct lvmcache_info *info;

	if (!dl) {
		STACK;
		return NULL;
	}

	dl->dev = dev;
	dl->mem = mem;
	lvm_list_init(&dl->uuids);
	lvm_list_init(&dl->lvds);

	if (!_read_pvd(dev, &dl->pvd)) {
		STACK;
		goto bad;
	}



	if (!(info = lvmcache_add(fmt->labeller, dl->pvd.pv_uuid, dev,
				  dl->pvd.vg_name, NULL)))
		STACK;
	else {
		info->device_size = xlate32(dl->pvd.pv_size) << SECTOR_SHIFT;
		lvm_list_init(&info->mdas);
		info->status &= ~CACHE_INVALID;
	}


	struct disk_list *r;

	if (!dev_open(dev)) {
		STACK;
		return NULL;
	}

	r = __read_disk(fmt, dev, mem, vg_name);

	if (!dev_close(dev))
		STACK;

	return r;
}

static void _add_pv_to_list(struct lvm_list *head, struct disk_list *data)
{
	struct lvm_list *pvdh;
	struct pv_disk *pvd;

	lvm_list_iterate(pvdh, head) {
		pvd = &lvm_list_item(pvdh, struct disk_list)->pvd;
		if (!strncmp(data->pvd.pv_uuid, pvd->pv_uuid,
			     sizeof(pvd->pv_uuid))) {
			if (MAJOR(data->dev->dev) != md_major()) {

			}
			log_very_verbose("Duplicate PV %s - using md %s",
					 pvd->pv_uuid, dev_name(data->dev));
			lvm_list_del(pvdh);
			break;
		}
	}
	lvm_list_add(head, &data->list);
}

/*

 */
int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
		   struct dev_filter *filter, struct pool *mem,
		   struct lvm_list *head)
{
	struct dev_iter *iter;
	struct device *dev;
	struct disk_list *data = NULL;
	struct lvm_list *vgih;
	struct lvmcache_vginfo *vginfo;

	/* Fast path if we already saw this VG and cached the list of PVs */
	if (vg_name && (vginfo = vginfo_from_vgname(vg_name)) &&
	    vginfo->infos.n) {
		lvm_list_iterate(vgih, &vginfo->infos) {
			dev = lvm_list_item(vgih, struct lvmcache_info)->dev;
			if (dev && !(data = read_disk(fmt, dev, mem, vg_name)))
				break;
			_add_pv_to_list(head, data);

		/* Did we find the whole VG? */
		if (!vg_name || !*vg_name ||
		    (data && *data->pvd.vg_name &&
		     lvm_list_size(head) == data->vgd.pv_cur))
			return 1;

		/* Failed */
		lvm_list_init(head);
		/* vgcache_del(vg_name); */
	}


	}
	dev_iter_destroy(iter);

	if (lvm_list_empty(head))
		return 0;

	return 1;

static int _write_uuids(struct disk_list *data)
{
	struct uuid_list *ul;
	struct lvm_list *uh;
	uint64_t pos = data->pvd.pv_uuidlist_on_disk.base;
	uint64_t end = pos + data->pvd.pv_uuidlist_on_disk.size;

	lvm_list_iterate(uh, &data->uuids) {
		if (pos >= end) {
			log_error("Too many uuids to fit on %s",
				  dev_name(data->dev));
			return 0;
		}

		ul = lvm_list_item(uh, struct uuid_list);
		if (!dev_write(data->dev, pos, NAME_LEN, ul->uuid))
			fail;



static int _write_lvs(struct disk_list *data)
{
	struct lvm_list *lvh;
	uint64_t pos, offset;

	pos = data->pvd.lv_on_disk.base;

		return 0;
	}

	lvm_list_iterate(lvh, &data->lvds) {
		struct lvd_list *ll = lvm_list_item(lvh, struct lvd_list);

		offset = sizeof(struct lv_disk) * ll->lvd.lv_number;
		if (offset + sizeof(struct lv_disk) > data->pvd.lv_on_disk.size) {

	int r;

	if (!dev_open(data->dev)) {
		STACK;
		return 0;
	}

	r = __write_all_pvd(fmt, data);

	if (!dev_close(data->dev))
		STACK;

	return r;
}

 * little sanity checking, so make sure correct
 * data is passed to here.
 */
int write_disks(const struct format_type *fmt, struct lvm_list *pvs)
{
	struct lvm_list *pvh;
	struct disk_list *dl;

	lvm_list_iterate(pvh, pvs) {
		dl = lvm_list_item(pvh, struct disk_list);
		if (!(_write_all_pvd(fmt, dl)))
			fail;





} __attribute__ ((packed));

struct uuid_list {
	struct lvm_list list;
	char uuid[NAME_LEN];
};

struct lvd_list {
	struct lvm_list list;
	struct lv_disk lvd;
};

struct disk_list {
	struct lvm_list list;
	struct pool *mem;
	struct device *dev;

	struct pv_disk pvd;
	struct vg_disk vgd;
	struct lvm_list uuids;
	struct lvm_list lvds;
	struct pe_disk *extents;
};



int read_pvs_in_vg(const struct format_type *fmt, const char *vg_name,
		   struct dev_filter *filter,
		   struct pool *mem, struct lvm_list *results);

int write_disks(const struct format_type *fmt, struct lvm_list *pvds);

/*
 * Functions to translate to between disk and in

int import_lv(struct pool *mem, struct logical_volume *lv, struct lv_disk *lvd);

int import_extents(struct pool *mem, struct volume_group *vg,
		   struct lvm_list *pvds);
int export_extents(struct disk_list *dl, uint32_t lv_num,
		   struct logical_volume *lv, struct physical_volume *pv);

int import_pvs(const struct format_type *fmt, struct pool *mem,
	       struct volume_group *vg,
	       struct lvm_list *pvds, struct lvm_list *results, int *count);

int import_lvs(struct pool *mem, struct volume_group *vg, struct lvm_list *pvds);
int export_lvs(struct disk_list *dl, struct volume_group *vg,
	       struct physical_volume *pv, const char *dev_dir);

int import_snapshots(struct pool *mem, struct volume_group *vg,
		     struct lvm_list *pvds);

int export_uuids(struct disk_list *dl, struct volume_group *vg);

void export_numbers(struct lvm_list *pvds, struct volume_group *vg);

void export_pv_act(struct lvm_list *pvds);
void munge_exported_vg(struct pv_disk *pvd);

/* blech */
int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
		       const char *candidate_vg, int *result);
int export_vg_number(struct format_instance *fid, struct lvm_list *pvds,
		     const char *vg_name, struct dev_filter *filter);

#endif




#define FMT_LVM1_NAME "lvm1"

/* VG consistency checks */
static int _check_vgs(struct lvm_list *pvs, int *partial)
{
	struct lvm_list *pvh, *t;
	struct disk_list *dl = NULL;
	struct disk_list *first = NULL;


	 * This means an active VG won't be affected if disks are inserted
	 * bearing an exported VG with the same name.
	 */
	lvm_list_iterate(pvh, pvs) {
		dl = lvm_list_item(pvh, struct disk_list);

		if (first_time) {
			exported = dl->pvd.pv_status & VG_EXPORTED;


		if (exported != (dl->pvd.pv_status & VG_EXPORTED)) {
			/* Remove exported PVs */
			lvm_list_iterate_safe(pvh, t, pvs) {
				dl = lvm_list_item(pvh, struct disk_list);
				if (dl->pvd.pv_status & VG_EXPORTED)
					lvm_list_del(pvh);
			}
			break;
		}
	}

	/* Remove any PVs with VG structs that differ from the first */
	lvm_list_iterate_safe(pvh, t, pvs) {
		dl = lvm_list_item(pvh, struct disk_list);

		if (!first)
			first = dl;

				  dl->vgd.vgda, dl->vgd.pe_size,
				  dl->vgd.pe_total, dl->vgd.pe_allocated,
				  dl->vgd.pvg_total);
			lvm_list_del(pvh);
			if (partial_mode()) {
				*partial = 1;
				continue;

}

static struct volume_group *_build_vg(struct format_instance *fid,
				      struct lvm_list *pvs)
{
	struct pool *mem = fid->fmt->cmd->mem;
	struct volume_group *vg = pool_alloc(mem, sizeof(*vg));

	if (!vg)
		goto bad;

	if (lvm_list_empty(pvs))
		goto bad;

	memset(vg, 0, sizeof(*vg));

	vg->cmd = fid->fmt->cmd;
	vg->fid = fid;
	vg->seqno = 0;
	lvm_list_init(&vg->pvs);
	lvm_list_init(&vg->lvs);
	lvm_list_init(&vg->snapshots);
	lvm_list_init(&vg->tags);

	if (!_check_vgs(pvs, &partial))
		goto bad;

	dl = lvm_list_item(pvs->n, struct disk_list);

	if (!import_vg(mem, vg, dl, partial))
		goto bad;

	return vg;

      bad:
	STACK;
	pool_free(mem, vg);
	return NULL;
}

				     struct metadata_area *mda)
{
	struct pool *mem = pool_create(1024 * 10);
	struct lvm_list pvs;
	struct volume_group *vg = NULL;
	lvm_list_init(&pvs);

	if (!mem) {
		STACK;
		return NULL;
	}



	if (!read_pvs_in_vg
	    (fid->fmt, vg_name, fid->fmt->cmd->filter, mem, &pvs)) {
		STACK;
		goto bad;
	}

	if (!(vg = _build_vg(fid, &pvs))) {
		STACK;
		goto bad;
	}


	struct disk_list *dl = pool_alloc(mem, sizeof(*dl));

	if (!dl) {
		STACK;
		return NULL;
	}

	dl->mem = mem;
	dl->dev = pv->dev;

	lvm_list_init(&dl->uuids);
	lvm_list_init(&dl->lvds);

	if (!export_pv(fid->fmt->cmd, mem, vg, &dl->pvd, pv) ||
	    !export_vg(&dl->vgd, vg) ||
	    !export_uuids(dl, vg) ||
	    !export_lvs(dl, vg, pv, dev_dir) || !calculate_layout(dl)) {
		STACK;
		pool_free(mem, dl);
		return NULL;
	}


static int _flatten_vg(struct format_instance *fid, struct pool *mem,
		       struct volume_group *vg,
		       struct lvm_list *pvds, const char *dev_dir,
		       struct dev_filter *filter)
{
	struct lvm_list *pvh;
	struct pv_list *pvl;
	struct disk_list *data;

	lvm_list_iterate(pvh, &vg->pvs) {
		pvl = lvm_list_item(pvh, struct pv_list);

		if (!(data = _flatten_pv(fid, mem, vg, pvl->pv, dev_dir))) {
			STACK;
			return 0;
		}

		lvm_list_add(pvds, &data->list);
	}

	export_numbers(pvds, vg);
	export_pv_act(pvds);

	if (!export_vg_number(fid, pvds, vg->name, filter)) {
		STACK;
		return 0;
	}


		     struct metadata_area *mda)
{
	struct pool *mem = pool_create(1024 * 10);
	struct lvm_list pvds;
	int r = 0;

	if (!mem) {
		STACK;
		return 0;
	}

	lvm_list_init(&pvds);

	r = (_flatten_vg(fid, mem, vg, &pvds, fid->fmt->cmd->dev_dir,
			 fid->fmt->cmd->filter) &&

}

static int _pv_read(const struct format_type *fmt, const char *pv_name,
		    struct physical_volume *pv, struct lvm_list *mdas)
{
	struct pool *mem = pool_create(1024);
	struct disk_list *dl;

	log_very_verbose("Reading physical volume data %s from disk", pv_name);

	if (!mem) {
		STACK;
		return 0;
	}

	if (!(dev = dev_cache_get(pv_name, fmt->cmd->filter))) {
		STACK;
		goto out;
	}

	if (!(dl = read_disk(fmt, dev, mem, NULL))) {
		STACK;
		goto out;
	}

	if (!import_pv(fmt->cmd->mem, dl->dev, NULL, pv, &dl->pvd)) {
		STACK;
		goto out;
	}


		     uint64_t pe_start, uint32_t extent_count,
		     uint32_t extent_size,
		     int pvmetadatacopies,
		     uint64_t pvmetadatasize, struct lvm_list *mdas,
		     struct physical_volume *pv, struct volume_group *vg)
{
	if (pv->size > MAX_PV_SIZE)

	 * This works out pe_start and pe_count.
	 */
	if (!calculate_extent_count(pv, extent_size, extent_count, pe_start)) {
		STACK;
		return 0;
	}


}

static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
		     struct lvm_list *mdas, int64_t sector)
{
	struct pool *mem;
	struct disk_list *dl;
	struct lvm_list pvs;
	struct label *label;
	struct lvmcache_info *info;

	if (!(info = lvmcache_add(fmt->labeller, (char *) &pv->id, pv->dev,
				  pv->vg_name, NULL))) {
		STACK;
		return 0;
	}
	label = info->label;
	info->device_size = pv->size << SECTOR_SHIFT;
	info->fmt = fmt;

	lvm_list_init(&info->mdas);

	lvm_list_init(&pvs);

	/* Ensure any residual PE structure is gone */
	pv->pe_size = pv->pe_count = 0;
	pv->pe_start = PE_ALIGN;

	if (!(mem = pool_create(1024))) {
		STACK;
		return 0;
	}

	if (!(dl = pool_alloc(mem, sizeof(*dl)))) {
		STACK;
		goto bad;
	}
	dl->mem = mem;
	dl->dev = pv->dev;

	if (!export_pv(fmt->cmd, mem, NULL, &dl->pvd, pv)) {
		STACK;
		goto bad;
	}


	dl->pvd.pv_on_disk.size = PV_SIZE;
	dl->pvd.pe_on_disk.base = PE_ALIGN << SECTOR_SHIFT;

	lvm_list_add(&pvs, &dl->list);
	if (!write_disks(fmt, &pvs)) {
		STACK;
		goto bad;
	}


	struct metadata_area *mda;

	if (!(fid = pool_alloc(fmt->cmd->mem, sizeof(*fid)))) {
		STACK;
		return NULL;
	}

	fid->fmt = fmt;
	lvm_list_init(&fid->metadata_areas);

	/* Define a NULL metadata area */
	if (!(mda = pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {
		STACK;
		pool_free(fmt->cmd->mem, fid);
		return NULL;
	}

	mda->ops = &_metadata_format1_ops;
	mda->metadata_locn = NULL;
	lvm_list_add(&fid->metadata_areas, &mda->list);

	return fid;
}

	struct format_type *fmt = dbg_malloc(sizeof(*fmt));

	if (!fmt) {
		STACK;
		return NULL;
	}






	pv->dev = dev;
	if (!(pv->vg_name = pool_strdup(mem, pvd->vg_name))) {
		STACK;
		return 0;
	}


	pv->pe_count = pvd->pe_total;
	pv->pe_alloc_count = pvd->pe_allocated;

	lvm_list_init(&pv->tags);

	return 1;
}

	memcpy(pvd->pv_uuid, pv->id.uuid, ID_LEN);

	if (!_check_vg_name(pv->vg_name)) {
		STACK;
		return 0;
	}


		    strncmp(vg->system_id, EXPORTED_TAG,
			    sizeof(EXPORTED_TAG) - 1)) {
			if (!_system_id(cmd, pvd->system_id, EXPORTED_TAG)) {
				STACK;
				return 0;
			}
		}

	if (vg && !(vg->status & EXPORTED_VG) && *vg->system_id &&
	    !strncmp(vg->system_id, EXPORTED_TAG, sizeof(EXPORTED_TAG) - 1)) {
		if (!_system_id(cmd, pvd->system_id, IMPORTED_TAG)) {
			STACK;
			return 0;
		}
	}

	/* Generate system_id if PV is in VG */
	if (!pvd->system_id || !*pvd->system_id)
		if (!_system_id(cmd, pvd->system_id, "")) {
			STACK;
			return 0;
		}


	memcpy(vg->id.uuid, vgd->vg_uuid, ID_LEN);

	if (!_check_vg_name(dl->pvd.vg_name)) {
		STACK;
		return 0;
	}

	if (!(vg->name = pool_strdup(mem, dl->pvd.vg_name))) {
		STACK;
		return 0;
	}

	if (!(vg->system_id = pool_alloc(mem, NAME_LEN))) {
		STACK;
		return 0;
	}


	lvid_from_lvnum(&lv->lvid, &lv->vg->id, lvd->lv_number);

	if (!(lv->name = _create_lv_name(mem, lvd->lv_name))) {
		STACK;
		return 0;
	}


	lv->size = lvd->lv_size;
	lv->le_count = lvd->lv_allocated_le;

	lvm_list_init(&lv->segments);
	lvm_list_init(&lv->tags);

	return 1;
}


	lvd->lv_read_ahead = lv->read_ahead;
	lvd->lv_stripes =
	    lvm_list_item(lv->segments.n, struct lv_segment)->area_count;
	lvd->lv_stripesize =
	    lvm_list_item(lv->segments.n, struct lv_segment)->stripe_size;

	lvd->lv_size = lv->size;
	lvd->lv_allocated_le = lv->le_count;

int export_extents(struct disk_list *dl, uint32_t lv_num,
		   struct logical_volume *lv, struct physical_volume *pv)
{
	struct lvm_list *segh;
	struct pe_disk *ped;
	struct lv_segment *seg;
	uint32_t pe, s;

	lvm_list_iterate(segh, &lv->segments) {
		seg = lvm_list_item(segh, struct lv_segment);

		for (s = 0; s < seg->area_count; s++) {
			if (seg->type != SEG_STRIPED) {


int import_pvs(const struct format_type *fmt, struct pool *mem,
	       struct volume_group *vg,
	       struct lvm_list *pvds, struct lvm_list *results, int *count)
{
	struct lvm_list *pvdh;
	struct disk_list *dl;
	struct pv_list *pvl;

	*count = 0;
	lvm_list_iterate(pvdh, pvds) {

		dl = lvm_list_item(pvdh, struct disk_list);

		if (!(pvl = pool_zalloc(mem, sizeof(*pvl))) ||
		    !(pvl->pv = pool_alloc(mem, sizeof(*pvl->pv)))) {
			STACK;
			return 0;
		}

		if (!import_pv(mem, dl->dev, vg, pvl->pv, &dl->pvd)) {
			STACK;
			return 0;
		}

		pvl->pv->fmt = fmt;
		lvm_list_add(results, &pvl->list);
		(*count)++;
	}



	if (!(ll = pool_zalloc(mem, sizeof(*ll))) ||
	    !(ll->lv = pool_zalloc(mem, sizeof(*ll->lv)))) {
		STACK;
		return NULL;
	}
	lv = ll->lv;
	lv->vg = vg;

	if (!import_lv(mem, lv, lvd)) {
		STACK;
		return NULL;
	}

	lvm_list_add(&vg->lvs, &ll->list);
	vg->lv_count++;

	return lv;
}

int import_lvs(struct pool *mem, struct volume_group *vg, struct lvm_list *pvds)
{
	struct disk_list *dl;
	struct lvd_list *ll;
	struct lv_disk *lvd;
	struct lvm_list *pvdh, *lvdh;

	lvm_list_iterate(pvdh, pvds) {
		dl = lvm_list_item(pvdh, struct disk_list);
		lvm_list_iterate(lvdh, &dl->lvds) {
			ll = lvm_list_item(lvdh, struct lvd_list);
			lvd = &ll->lvd;

			if (!find_lv(vg, lvd->lv_name) &&
			    !_add_lv(mem, vg, lvd)) {
				STACK;
				return 0;
			}
		}

	       struct physical_volume *pv, const char *dev_dir)
{
	int r = 0;
	struct lvm_list *lvh, *sh;
	struct lv_list *ll;
	struct lvd_list *lvdl;
	size_t len;

	struct hash_table *lvd_hash;

	if (!_check_vg_name(vg->name)) {
		STACK;
		return 0;
	}

	if (!(lvd_hash = hash_create(32))) {
		STACK;
		return 0;
	}


	 */
	len = sizeof(struct pe_disk) * dl->pvd.pe_total;
	if (!(dl->extents = pool_alloc(dl->mem, len))) {
		STACK;
		goto out;
	}
	memset(dl->extents, 0, len);

	lvm_list_iterate(lvh, &vg->lvs) {
		ll = lvm_list_item(lvh, struct lv_list);
		if (!(lvdl = pool_alloc(dl->mem, sizeof(*lvdl)))) {
			STACK;
			goto out;
		}


		lvdl->lvd.lv_number = lv_num;

		if (!hash_insert(lvd_hash, ll->lv->name, &lvdl->lvd)) {
			STACK;
			goto out;
		}

		if (!export_extents(dl, lv_num + 1, ll->lv, pv)) {
			STACK;
			goto out;
		}

		lvm_list_add(&dl->lvds, &lvdl->list);
		dl->pvd.lv_cur++;
	}


	 * Now we need to run through the snapshots, exporting
	 * the SNAPSHOT_ORG flags etc.
	 */
	lvm_list_iterate(sh, &vg->snapshots) {
		struct lv_disk *org, *cow;
		struct snapshot *s = lvm_list_item(sh,
					       struct snapshot_list)->snapshot;

		if (!(org = hash_lookup(lvd_hash, s->origin->name))) {

 * FIXME: More inefficient code.
 */
int import_snapshots(struct pool *mem, struct volume_group *vg,
		     struct lvm_list *pvds)
{
	struct logical_volume *lvs[MAX_LV];
	struct lvm_list *pvdh, *lvdh;
	struct disk_list *dl;
	struct lv_disk *lvd;
	int lvnum;


	/* build an index of lv numbers */
	memset(lvs, 0, sizeof(lvs));
	lvm_list_iterate(pvdh, pvds) {
		dl = lvm_list_item(pvdh, struct disk_list);

		lvm_list_iterate(lvdh, &dl->lvds) {
			lvd = &(lvm_list_item(lvdh, struct lvd_list)->lvd);

			lvnum = lvd->lv_number;


	/*
	 * Now iterate through yet again adding the snapshots.
	 */
	lvm_list_iterate(pvdh, pvds) {
		dl = lvm_list_item(pvdh, struct disk_list);

		lvm_list_iterate(lvdh, &dl->lvds) {
			lvd = &(lvm_list_item(lvdh, struct lvd_list)->lvd);

			if (!(lvd->lv_access & LV_SNAPSHOT))
				continue;

{
	struct uuid_list *ul;
	struct pv_list *pvl;
	struct lvm_list *pvh;

	lvm_list_iterate(pvh, &vg->pvs) {
		pvl = lvm_list_item(pvh, struct pv_list);
		if (!(ul = pool_alloc(dl->mem, sizeof(*ul)))) {
			STACK;
			return 0;
		}

		memset(ul->uuid, 0, sizeof(ul->uuid));
		memcpy(ul->uuid, pvl->pv->id.uuid, ID_LEN);

		lvm_list_add(&dl->uuids, &ul->list);
	}
	return 1;
}

 * This calculates the nasty pv_number field
 * used by LVM1.
 */
void export_numbers(struct lvm_list *pvds, struct volume_group *vg)
{
	struct lvm_list *pvdh;
	struct disk_list *dl;
	int pv_num = 1;

	lvm_list_iterate(pvdh, pvds) {
		dl = lvm_list_item(pvdh, struct disk_list);
		dl->pvd.pv_number = pv_num++;
	}
}

/*
 * Calculate vg_disk->pv_act.
 */
void export_pv_act(struct lvm_list *pvds)
{
	struct lvm_list *pvdh;
	struct disk_list *dl;
	int act = 0;

	lvm_list_iterate(pvdh, pvds) {
		dl = lvm_list_item(pvdh, struct disk_list);
		if (dl->pvd.pv_status & PV_ACTIVE)
			act++;
	}

	lvm_list_iterate(pvdh, pvds) {
		dl = lvm_list_item(pvdh, struct disk_list);
		dl->vgd.pv_act = act;
	}
}

int export_vg_number(struct format_instance *fid, struct lvm_list *pvds,
		     const char *vg_name, struct dev_filter *filter)
{
	struct lvm_list *pvdh;
	struct disk_list *dl;
	int vg_num;

	if (!get_free_vg_number(fid, filter, vg_name, &vg_num)) {
		STACK;
		return 0;
	}

	lvm_list_iterate(pvdh, pvds) {
		dl = lvm_list_item(pvdh, struct disk_list);
		dl->vgd.vg_number = vg_num;
	}





					  struct volume_group *vg)
{
	struct hash_table *maps = hash_create(32);
	struct lvm_list *llh;
	struct lv_list *ll;
	struct lv_map *lvm;


		return NULL;
	}

	lvm_list_iterate(llh, &vg->lvs) {
		ll = lvm_list_item(llh, struct lv_list);

		if (!(lvm = pool_alloc(mem, sizeof(*lvm)))) {
			STACK;
			goto bad;
		}

		lvm->lv = ll->lv;
		if (!(lvm->map = pool_zalloc(mem, sizeof(*lvm->map)
					     * ll->lv->le_count))) {
			STACK;
			goto bad;
		}

		if (!hash_insert(maps, ll->lv->name, lvm)) {
			STACK;
			goto bad;
		}
	}

static int _fill_lv_array(struct lv_map **lvs,
			  struct hash_table *maps, struct disk_list *dl)
{
	struct lvm_list *lvh;
	struct lv_map *lvm;

	memset(lvs, 0, sizeof(*lvs) * MAX_LV);
	lvm_list_iterate(lvh, &dl->lvds) {
		struct lvd_list *ll = lvm_list_item(lvh, struct lvd_list);

		if (!(lvm = hash_lookup(maps, strrchr(ll->lvd.lv_name, '/')
					+ 1))) {

}

static int _fill_maps(struct hash_table *maps, struct volume_group *vg,
		      struct lvm_list *pvds)
{
	struct lvm_list *pvdh;
	struct disk_list *dl;
	struct physical_volume *pv;
	struct lv_map *lvms[MAX_LV], *lvm;
	struct pe_disk *e;
	uint32_t i, lv_num, le;

	lvm_list_iterate(pvdh, pvds) {
		dl = lvm_list_item(pvdh, struct disk_list);
		pv = find_pv(vg, dl->dev);
		e = dl->extents;

		/* build an array of lv's for this pv */
		if (!_fill_lv_array(lvms, maps, dl)) {
			STACK;
			return 0;
		}


		lvm = (struct lv_map *) hash_get_data(maps, n);

		if (!_check_single_map(lvm)) {
			STACK;
			return 0;
		}
	}


		le += seg->len;

		lvm_list_add(&lvm->lv->segments, &seg->list);
	}

	return 1;


	while (le < len) {
		if (!(seg = alloc_lv_segment(mem, lvm->stripes))) {
			STACK;
			return 0;
		}


		le += seg->len;
		seg->len *= seg->area_count;

		lvm_list_add(&lvm->lv->segments, &seg->list);
	}

	return 1;

	for (n = hash_get_first(maps); n; n = hash_get_next(maps, n)) {
		lvm = (struct lv_map *) hash_get_data(maps, n);
		if (!_build_segments(mem, lvm)) {
			STACK;
			return 0;
		}
	}

	return 1;
}

int import_extents(struct pool *mem, struct volume_group *vg, struct lvm_list *pvds)
{
	int r = 0;
	struct pool *scratch = pool_create(10 * 1024);
	struct hash_table *maps;

	if (!scratch) {
		STACK;
		return 0;
	}


	}

	if (!_check_maps_are_complete(maps) && !(vg->status & PARTIAL_VG)) {
		STACK;
		goto out;
	}


Lines 121-127 Link Here

(-)LVM2.2.00.15.orig/lib/format1/layout.c (-1 / +1 lines)
121	uint32_t end;	121	uint32_t end;
122		122
123	if (!pvd) {	123	if (!pvd) {
124	stack;	124	STACK;
125	return 0;	125	return 0;
126	}	126	}
127		127





	munge_exported_vg(pvd);
	if (!(info = lvmcache_add(l, pvd->pv_uuid, dev, pvd->vg_name, NULL))) {
		STACK;
		return 0;
	}
	*label = info->label;

	info->device_size = xlate32(pvd->pv_size) << SECTOR_SHIFT;
	lvm_list_init(&info->mdas);

	info->status &= ~CACHE_INVALID;





int get_free_vg_number(struct format_instance *fid, struct dev_filter *filter,
		       const char *candidate_vg, int *result)
{
	struct lvm_list *pvh;
	struct lvm_list all_pvs;
	struct disk_list *dl;
	struct pool *mem = pool_create(10 * 1024);
	int numbers[MAX_VG], i, r = 0;

	lvm_list_init(&all_pvs);

	if (!mem) {
		STACK;
		return 0;
	}

	if (!read_pvs_in_vg(fid->fmt, NULL, filter, mem, &all_pvs)) {
		STACK;
		goto out;
	}

	memset(numbers, 0, sizeof(numbers));

	lvm_list_iterate(pvh, &all_pvs) {
		dl = lvm_list_item(pvh, struct disk_list);
		if (!*dl->pvd.vg_name || !strcmp(dl->pvd.vg_name, candidate_vg))
			continue;





 * with the least recent at the head.
 */
struct archive_file {
	struct lvm_list list;

	char *path;
	int index;

	return 1;
}

static void _insert_file(struct lvm_list *head, struct archive_file *b)
{
	struct lvm_list *bh;
	struct archive_file *bf = NULL;

	if (lvm_list_empty(head)) {
		lvm_list_add(head, &b->list);
		return;
	}

	/* index increases through list */
	lvm_list_iterate(bh, head) {
		bf = lvm_list_item(bh, struct archive_file);

		if (bf->index > b->index) {
			lvm_list_add(&bf->list, &b->list);
			return;
		}
	}

	lvm_list_add_h(&bf->list, &b->list);
}

static char *_join(struct pool *mem, const char *dir, const char *name)

	    !pool_grow_object(mem, "/", 1) ||
	    !pool_grow_object(mem, name, strlen(name)) ||
	    !pool_grow_object(mem, "\0", 1)) {
		STACK;
		return NULL;
	}


/*
 * Returns a list of archive_files.
 */
static struct lvm_list *_scan_archive(struct pool *mem,
				  const char *vgname, const char *dir)
{
	int i, count, ix;
	char vgname_found[64], *path;
	struct dirent **dirent;
	struct archive_file *af;
	struct lvm_list *results;

	if (!(results = pool_alloc(mem, sizeof(*results)))) {
		STACK;
		return NULL;
	}

	lvm_list_init(results);

	/* Sort fails beyond 5-digit indexes */
	if ((count = scandir(dir, &dirent, NULL, alphasort)) < 0) {

			continue;

		if (!(path = _join(mem, dir, dirent[i]->d_name))) {
			STACK;
			goto out;
		}


	return results;
}

static void _remove_expired(struct lvm_list *archives, uint32_t archives_size,
			    uint32_t retain_days, uint32_t min_archive)
{
	struct lvm_list *bh;
	struct archive_file *bf;
	struct stat sb;
	time_t retain_time;

	retain_time = time(NULL) - (time_t) retain_days *SECS_PER_DAY;

	/* Assume list is ordered oldest first (by index) */
	lvm_list_iterate(bh, archives) {
		bf = lvm_list_item(bh, struct archive_file);

		/* Get the mtime of the file and unlink if too old */
		if (stat(bf->path, &sb)) {

	struct archive_file *last;
	FILE *fp = NULL;
	char temp_file[PATH_MAX], archive_name[PATH_MAX];
	struct lvm_list *archives;

	/*
	 * Write the vg out to a temporary file.

	}

	if (!text_vg_export_file(vg, desc, fp)) {
		STACK;
		fclose(fp);
		return 0;
	}

		return 0;
	}

	if (lvm_list_empty(archives))
		ix = 0;
	else {
		last = lvm_list_item(archives->p, struct archive_file);
		ix = last->index + 1;
	}


	if (!renamed)
		log_error("Archive rename failed for %s", temp_file);

	_remove_expired(archives, lvm_list_size(archives) + renamed, retain_days,
			min_archive);

	return 1;


int archive_list(struct cmd_context *cmd, const char *dir, const char *vgname)
{
	struct lvm_list *archives, *ah;
	struct archive_file *af;

	if (!(archives = _scan_archive(cmd->mem, vgname, dir))) {

		return 0;
	}

	if (lvm_list_empty(archives))
		log_print("No archives found in %s.", dir);

	lvm_list_iterate(ah, archives) {
		af = lvm_list_item(ah, struct archive_file);

		_display_archive(cmd, af);
	}

	struct archive_file af;

	if (!(af.path = _join(cmd->mem, dir, vgname))) {
		STACK;
		return 0;
	}





	return r;
}

#define _outf(args...) do {if (!_out(args)) {STACK; return 0;}} while (0)

static int _print_header(struct formatter *f,
			 struct volume_group *vg, const char *desc)

	char buffer[4096];

	if (!id_write_format(&vg->id, buffer, sizeof(buffer))) {
		STACK;
		return 0;
	}


	_outf(f, "seqno = %u", vg->seqno);

	if (!print_flags(vg->status, VG_FLAGS, buffer, sizeof(buffer))) {
		STACK;
		return 0;
	}
	_outf(f, "status = %s", buffer);

	if (!lvm_list_empty(&vg->tags)) {
		if (!print_tags(&vg->tags, buffer, sizeof(buffer))) {
			STACK;
			return 0;
		}
		_outf(f, "tags = %s", buffer);


	if (!_out_size(f, (uint64_t) vg->extent_size, "extent_size = %u",
		       vg->extent_size)) {
		STACK;
		return 0;
	}
	_outf(f, "max_lv = %u", vg->max_lv);


static int _print_pvs(struct formatter *f, struct volume_group *vg)
{
	struct lvm_list *pvh;
	struct physical_volume *pv;
	char buffer[4096];
	const char *name;

	_outf(f, "physical_volumes {");
	_inc_indent(f);

	lvm_list_iterate(pvh, &vg->pvs) {
		pv = lvm_list_item(pvh, struct pv_list)->pv;

		if (!(name = _get_pv_name(f, pv))) {
			STACK;
			return 0;
		}


		_inc_indent(f);

		if (!id_write_format(&pv->id, buffer, sizeof(buffer))) {
			STACK;
			return 0;
		}

		_outf(f, "id = \"%s\"", buffer);
		if (!_out_hint(f, "device = \"%s\"", dev_name(pv->dev))) {
			STACK;
			return 0;
		}
		f->nl(f);

		if (!print_flags(pv->status, PV_FLAGS, buffer, sizeof(buffer))) {
			STACK;
			return 0;
		}
		_outf(f, "status = %s", buffer);

		if (!lvm_list_empty(&pv->tags)) {
			if (!print_tags(&pv->tags, buffer, sizeof(buffer))) {
				STACK;
				return 0;
			}
			_outf(f, "tags = %s", buffer);

		_outf(f, "pe_start = %" PRIu64, pv->pe_start);
		if (!_out_size(f, vg->extent_size * (uint64_t) pv->pe_count,
			       "pe_count = %u", pv->pe_count)) {
			STACK;
			return 0;
		}


	_outf(f, "start_extent = %u", seg->le);
	if (!_out_size(f, (uint64_t) seg->len * vg->extent_size,
		       "extent_count = %u", seg->len)) {
		STACK;
		return 0;
	}

	f->nl(f);
	_outf(f, "type = \"%s\"", get_segtype_string(seg->type));

	if (!lvm_list_empty(&seg->tags)) {
		if (!print_tags(&seg->tags, buffer, sizeof(buffer))) {
			STACK;
			return 0;
		}
		_outf(f, "tags = %s", buffer);

			case AREA_PV:
				if (!(name = _get_pv_name(f, seg->
							  area[s].u.pv.pv))) {
					STACK;
					return 0;
				}


static int _count_segments(struct logical_volume *lv)
{
	int r = 0;
	struct lvm_list *segh;

	lvm_list_iterate(segh, &lv->segments)
	    r++;

	return r;

	_inc_indent(f);

	if (!id_write_format(&snap->id, buffer, sizeof(buffer))) {
		STACK;
		return 0;
	}

	_outf(f, "id = \"%s\"", buffer);
	if (!print_flags(LVM_READ | LVM_WRITE | VISIBLE_LV, LV_FLAGS,
			 buffer, sizeof(buffer))) {
		STACK;
		return 0;
	}


	seg.chunk_size = snap->chunk_size;

	/* Can't tag a snapshot independently of its origin */
	lvm_list_init(&seg.tags);

	if (!_print_segment(f, snap->origin->vg, 1, &seg)) {
		STACK;
		return 0;
	}



static int _print_snapshots(struct formatter *f, struct volume_group *vg)
{
	struct lvm_list *sh;
	struct snapshot *s;
	unsigned int count = 0;

	lvm_list_iterate(sh, &vg->snapshots) {
		s = lvm_list_item(sh, struct snapshot_list)->snapshot;

		if (!_print_snapshot(f, s, count++)) {
			STACK;
			return 0;
		}
	}


static int _print_lvs(struct formatter *f, struct volume_group *vg)
{
	struct lvm_list *lvh;
	struct logical_volume *lv;
	struct lv_segment *seg;
	char buffer[4096];

	/*
	 * Don't bother with an lv section if there are no lvs.
	 */
	if (lvm_list_empty(&vg->lvs))
		return 1;

	_outf(f, "logical_volumes {");
	_inc_indent(f);

	lvm_list_iterate(lvh, &vg->lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;

		f->nl(f);
		_outf(f, "%s {", lv->name);


		/* FIXME: Write full lvid */
		if (!id_write_format(&lv->lvid.id[1], buffer, sizeof(buffer))) {
			STACK;
			return 0;
		}

		_outf(f, "id = \"%s\"", buffer);

		if (!print_flags(lv->status, LV_FLAGS, buffer, sizeof(buffer))) {
			STACK;
			return 0;
		}
		_outf(f, "status = %s", buffer);

		if (!lvm_list_empty(&lv->tags)) {
			if (!print_tags(&lv->tags, buffer, sizeof(buffer))) {
				STACK;
				return 0;
			}
			_outf(f, "tags = %s", buffer);

		f->nl(f);

		seg_count = 1;
		lvm_list_iterate_items(seg, &lv->segments) {
			if (!_print_segment(f, vg, seg_count++, seg)) {
				STACK;
				return 0;
			}
		}

	}

	if (!_print_snapshots(f, vg)) {
		STACK;
		return 0;
	}


static int _build_pv_names(struct formatter *f, struct volume_group *vg)
{
	int count = 0;
	struct lvm_list *pvh;
	struct physical_volume *pv;
	char buffer[32], *name;

	if (!(f->mem = pool_create(512))) {
		STACK;
		goto bad;
	}

	if (!(f->pv_names = hash_create(128))) {
		STACK;
		goto bad;
	}

	lvm_list_iterate(pvh, &vg->pvs) {
		pv = lvm_list_item(pvh, struct pv_list)->pv;

		/* FIXME But skip if there's already an LV called pv%d ! */
		if (lvm_snprintf(buffer, sizeof(buffer), "pv%d", count++) < 0) {
			STACK;
			goto bad;
		}

		if (!(name = pool_strdup(f->mem, buffer))) {
			STACK;
			goto bad;
		}

		if (!hash_insert(f->pv_names, dev_name(pv->dev), name)) {
			STACK;
			goto bad;
		}
	}

	int r = 0;

	if (!_build_pv_names(f, vg)) {
		STACK;
		goto out;
	}
#define fail do {STACK; goto out;} while(0)

	if (f->header && !_print_header(f, vg, desc))
		fail;

	_init();

	if (!(f = dbg_malloc(sizeof(*f)))) {
		STACK;
		return 0;
	}


	_init();

	if (!(f = dbg_malloc(sizeof(*f)))) {
		STACK;
		return 0;
	}


	f->nl = &_nl_raw;

	if (!_text_vg_export(f, vg, desc)) {
		STACK;
		r = 0;
		goto out;
	}

Lines 83-89 Link Here

(-)LVM2.2.00.15.orig/lib/format_text/flags.c (-2 / +2 lines)
83	struct flag *flags;	83	struct flag *flags;
84		84
85	if (!(flags = _get_flags(type))) {	85	if (!(flags = _get_flags(type))) {
86	stack;	86	STACK;
87	return 0;	87	return 0;
88	}	88	}
89		89
Lines 124-130 Link Here
124	struct flag *flags;	124	struct flag *flags;
125		125
126	if (!(flags = _get_flags(type))) {	126	if (!(flags = _get_flags(type))) {
127	stack;	127	STACK;
128	return 0;	128	return 0;
129	}	129	}
130		130




						     void *context);

struct dir_list {
	struct lvm_list list;
	char dir[0];
};

struct raw_list {
	struct lvm_list list;
	struct device_area dev_area;
};


	}

	if (!dev_read(dev_area->dev, dev_area->start, MDA_HEADER_SIZE, mdah)) {
		STACK;
		pool_free(fmt->cmd->mem, mdah);
		return NULL;
	}

					     sizeof(mdah->checksum_xl)));

	if (!dev_write(dev, start_byte, MDA_HEADER_SIZE, mdah)) {
		STACK;
		pool_free(fmt->cmd->mem, mdah);
		return 0;
	}

	while (rlocn->offset) {
		if (!dev_read(dev_area->dev, dev_area->start + rlocn->offset,
			      sizeof(vgnamebuf), vgnamebuf)) {
			STACK;
			return NULL;
		}
		if (!strncmp(vgnamebuf, vgname, len = strlen(vgname)) &&

	struct mda_header *mdah;

	if (!(mdah = _raw_read_mda_header(fid->fmt, dev_area))) {
		STACK;
		return NULL;
	}


	int r = 0;

	if (!dev_open(dev_area->dev)) {
		STACK;
		return 0;
	}


		r = 1;

	if (!dev_close(dev_area->dev))
		STACK;

	return r;
}

	uint32_t wrap = 0;

	if (!dev_open(area->dev)) {
		STACK;
		return NULL;
	}

	if (!(mdah = _raw_read_mda_header(fid->fmt, area))) {
		STACK;
		goto out;
	}

	if (!(rlocn = _vg_posn(fid, area, vgname))) {
		STACK;
		goto out;
	}


				     (off_t) (area->start + MDA_HEADER_SIZE),
				     wrap, calc_crc, rlocn->checksum, &when,
				     &desc))) {
		STACK;
		goto out;
	}
	log_debug("Read %s metadata (%u) from %s at %" PRIu64 " size %" PRIu64,


      out:
	if (!dev_close(area->dev))
		STACK;

	return vg;
}

	struct raw_locn *rlocn;
	struct mda_header *mdah;
	struct physical_volume *pv;
	struct lvm_list *pvh;
	int r = 0;
	uint32_t new_wrap = 0, old_wrap = 0;


	int found = 0;

	/* Ignore any mda on a PV outside the VG. vgsplit relies on this */
	lvm_list_iterate(pvh, &vg->pvs) {
		pv = lvm_list_item(pvh, struct pv_list)->pv;
		if (pv->dev == mdac->area.dev) {
			found = 1;
			break;

		return 1;

	if (!dev_open(mdac->area.dev)) {
		STACK;
		return 0;
	}

	if (!(mdah = _raw_read_mda_header(fid->fmt, &mdac->area))) {
		STACK;
		goto out;
	}


	/* Write text out, circularly */
	if (!dev_write(mdac->area.dev, mdac->area.start + mdac->rlocn.offset,
		       (size_t) (mdac->rlocn.size - new_wrap), buf)) {
		STACK;
		goto out;
	}


			       mdac->area.start + MDA_HEADER_SIZE,
			       (size_t) new_wrap,
			       buf + mdac->rlocn.size - new_wrap)) {
			STACK;
			goto out;
		}
	}


      out:
	if (!r && !dev_close(mdac->area.dev))
		STACK;

	return r;
}

	struct mda_header *mdah;
	struct raw_locn *rlocn;
	struct physical_volume *pv;
	struct lvm_list *pvh;
	int r = 0;
	int found = 0;

	/* Ignore any mda on a PV outside the VG. vgsplit relies on this */
	lvm_list_iterate(pvh, &vg->pvs) {
		pv = lvm_list_item(pvh, struct pv_list)->pv;
		if (pv->dev == mdac->area.dev) {
			found = 1;
			break;

		return 1;

	if (!(mdah = _raw_read_mda_header(fid->fmt, &mdac->area))) {
		STACK;
		goto out;
	}



      out:
	if (!dev_close(mdac->area.dev))
		STACK;

	return r;
}

{
	struct mda_context *mdac = (struct mda_context *) mda->metadata_locn;
	struct physical_volume *pv;
	struct lvm_list *pvh;
	int found = 0;

	/* Ignore any mda on a PV outside the VG. vgsplit relies on this */
	lvm_list_iterate(pvh, &vg->pvs) {
		pv = lvm_list_item(pvh, struct pv_list)->pv;
		if (pv->dev == mdac->area.dev) {
			found = 1;
			break;

		return 1;

	if (!dev_close(mdac->area.dev))
		STACK;

	return 1;
}

	int r = 0;

	if (!dev_open(mdac->area.dev)) {
		STACK;
		return 0;
	}

	if (!(mdah = _raw_read_mda_header(fid->fmt, &mdac->area))) {
		STACK;
		goto out;
	}



      out:
	if (!dev_close(mdac->area.dev))
		STACK;

	return r;
}

	char *desc;

	if (!(vg = text_vg_import_file(fid, path_live, &when, &desc))) {
		STACK;
		return NULL;
	}


{
	struct dirent *dirent;
	struct dir_list *dl;
	struct lvm_list *dlh, *dir_list;
	char *tmp;
	DIR *d;
	struct volume_group *vg;


	dir_list = &((struct mda_lists *) fmt->private)->dirs;

	lvm_list_iterate(dlh, dir_list) {
		dl = lvm_list_item(dlh, struct dir_list);
		if (!(d = opendir(dl->dir))) {
			log_sys_error("opendir", dl->dir);
			continue;

	int r = 0;

	if (!dev_open(dev_area->dev)) {
		STACK;
		return 0;
	}

	if (!(mdah = _raw_read_mda_header(fmt, dev_area))) {
		STACK;
		goto out;
	}


	while (rlocn->offset) {
		if (!dev_read(dev_area->dev, dev_area->start + rlocn->offset,
			      size, buf)) {
			STACK;
			goto out;
		}
		len = 0;


		/* Ignore this entry if the characters aren't permissible */
		if (!validate_name(buf)) {
			STACK;
			goto out;
		}



      out:
	if (!dev_close(dev_area->dev))
		STACK;

	return r;
}

static int _scan_raw(const struct format_type *fmt)
{
	struct raw_list *rl;
	struct lvm_list *rlh, *raw_list;
	char vgnamebuf[NAME_LEN + 2];
	struct volume_group *vg;
	struct format_instance fid;

	raw_list = &((struct mda_lists *) fmt->private)->raws;

	fid.fmt = fmt;
	lvm_list_init(&fid.metadata_areas);

	lvm_list_iterate(rlh, raw_list) {
		rl = lvm_list_item(rlh, struct raw_list);

		/* FIXME We're reading mdah twice here... */
		if (vgname_from_mda(fmt, &rl->dev_area, vgnamebuf,

static int _mda_setup(const struct format_type *fmt,
		      uint64_t pe_start, uint64_t pe_end,
		      int pvmetadatacopies,
		      uint64_t pvmetadatasize, struct lvm_list *mdas,
		      struct physical_volume *pv, struct volume_group *vg)
{
	uint64_t mda_adjustment, disk_size, alignment;

/* Only for orphans */
/* Set label_sector to -1 if rewriting existing label into same sector */
static int _pv_write(const struct format_type *fmt, struct physical_volume *pv,
		     struct lvm_list *mdas, int64_t label_sector)
{
	struct label *label;
	struct lvmcache_info *info;
	struct mda_context *mdac;
	struct lvm_list *mdash;
	struct metadata_area *mda;
	char buf[MDA_HEADER_SIZE];
	struct mda_header *mdah = (struct mda_header *) buf;


	if (!(info = lvmcache_add(fmt->labeller, (char *) &pv->id, pv->dev,
				  ORPHAN, NULL))) {
		STACK;
		return 0;
	}
	label = info->label;

		if (info->mdas.n)
			del_mdas(&info->mdas);
		else
			lvm_list_init(&info->mdas);
		lvm_list_iterate(mdash, mdas) {
			mda = lvm_list_item(mdash, struct metadata_area);
			mdac = mda->metadata_locn;
			log_debug("Creating metadata area on %s at sector %"
				  PRIu64 " size %" PRIu64 " sectors",

		}
		/* FIXME Temporary until mda creation supported by tools */
	} else if (!info->mdas.n) {
		lvm_list_init(&info->mdas);
	}

	if (info->das.n)
		del_das(&info->das);
	else
		lvm_list_init(&info->das);

	/* Set pe_start to first aligned sector after any metadata 
	 * areas that begin before pe_start */
	pv->pe_start = PE_ALIGN;
	lvm_list_iterate(mdash, &info->mdas) {
		mda = lvm_list_item(mdash, struct metadata_area);
		mdac = (struct mda_context *) mda->metadata_locn;
		if (pv->dev == mdac->area.dev &&
		    (mdac->area.start < (pv->pe_start << SECTOR_SHIFT)) &&

	if (!add_da
	    (fmt, NULL, &info->das, pv->pe_start << SECTOR_SHIFT,
	     UINT64_C(0))) {
		STACK;
		return 0;
	}

	if (!dev_open(pv->dev)) {
		STACK;
		return 0;
	}

	lvm_list_iterate(mdash, &info->mdas) {
		mda = lvm_list_item(mdash, struct metadata_area);
		mdac = mda->metadata_locn;
		memset(&buf, 0, sizeof(buf));
		mdah->size = mdac->area.size;
		if (!_raw_write_mda_header(fmt, mdac->area.dev,
					   mdac->area.start, mdah)) {
			STACK;
			if (!dev_close(pv->dev))
				STACK;
			return 0;
		}
	}

	label_write(pv->dev, label);

	if (!dev_close(pv->dev)) {
		STACK;
		return 0;
	}


			   const char *id, struct physical_volume *pv)
{
	struct volume_group *vg;
	struct lvm_list *pvh;
	struct pv_list *pvl;
	int consistent = 0;


		log_error("Warning: Volume group %s is not consistent",
			  vg_name);

	lvm_list_iterate(pvh, &vg->pvs) {
		pvl = lvm_list_item(pvh, struct pv_list);
		if (id_equal(&pvl->pv->id, (const struct id *) id)) {
			memcpy(pv, pvl->pv, sizeof(*pv));
			return 1;

	return 0;
}

static int _add_raw(struct lvm_list *raw_list, struct device_area *dev_area)
{
	struct raw_list *rl;
	struct lvm_list *rlh;

	/* Already present? */
	lvm_list_iterate(rlh, raw_list) {
		rl = lvm_list_item(rlh, struct raw_list);
		/* FIXME Check size/overlap consistency too */
		if (rl->dev_area.dev == dev_area->dev &&
		    rl->dev_area.start == dev_area->start)

		return 0;
	}
	memcpy(&rl->dev_area, dev_area, sizeof(*dev_area));
	lvm_list_add(raw_list, &rl->list);

	return 1;
}

static int _pv_read(const struct format_type *fmt, const char *pv_name,
		    struct physical_volume *pv, struct lvm_list *mdas)
{
	struct label *label;
	struct device *dev;
	struct lvmcache_info *info;
	struct metadata_area *mda, *mda_new;
	struct mda_context *mdac, *mdac_new;
	struct lvm_list *mdah, *dah;
	struct data_area_list *da;

	if (!(dev = dev_cache_get(pv_name, fmt->cmd->filter))) {
		STACK;
		return 0;
	}

	/* FIXME Optimise out repeated reading when cache lock held */
	if (!(label_read(dev, &label))) {
		STACK;
		return 0;
	}
	info = (struct lvmcache_info *) label->info;

	memcpy(&pv->id, &info->dev->pvid, sizeof(pv->id));

	/* Currently only support exactly one data area */
	if (lvm_list_size(&info->das) != 1) {
		log_error("Must be exactly one data area (found %d) on PV %s",
			  lvm_list_size(&info->das), dev_name(dev));
		return 0;
	}
	lvm_list_iterate(dah, &info->das) {
		da = lvm_list_item(dah, struct data_area_list);
		pv->pe_start = da->disk_locn.offset >> SECTOR_SHIFT;
	}


		return 1;

	/* Add copy of mdas to supplied list */
	lvm_list_iterate(mdah, &info->mdas) {
		mda = lvm_list_item(mdah, struct metadata_area);
		mdac = (struct mda_context *) mda->metadata_locn;
		if (!(mda_new = pool_alloc(fmt->cmd->mem, sizeof(*mda_new)))) {
			log_error("metadata_area allocation failed");

		memcpy(mda_new, mda, sizeof(*mda));
		memcpy(mdac_new, mdac, sizeof(*mdac));
		mda_new->metadata_locn = mdac_new;
		lvm_list_add(mdas, &mda_new->list);
	}

	return 1;

	return;
}

static void _free_dirs(struct lvm_list *dir_list)
{
	struct lvm_list *dl, *tmp;

	lvm_list_iterate_safe(dl, tmp, dir_list) {
		lvm_list_del(dl);
		dbg_free(dl);
	}
}

static void _free_raws(struct lvm_list *raw_list)
{
	struct lvm_list *rl, *tmp;

	lvm_list_iterate_safe(rl, tmp, raw_list) {
		lvm_list_del(rl);
		dbg_free(rl);
	}
}

		     uint64_t pe_start, uint32_t extent_count,
		     uint32_t extent_size,
		     int pvmetadatacopies,
		     uint64_t pvmetadatasize, struct lvm_list *mdas,
		     struct physical_volume *pv, struct volume_group *vg)
{
	struct metadata_area *mda, *mda_new, *mda2;
	struct mda_context *mdac, *mdac_new, *mdac2;
	struct lvm_list *pvmdas, *pvmdash, *mdash;
	struct lvmcache_info *info;
	int found;
	uint64_t pe_end = 0;

		/* Iterate through all mdas on this PV */
		if ((info = info_from_pvid(pv->dev->pvid))) {
			pvmdas = &info->mdas;
			lvm_list_iterate(pvmdash, pvmdas) {
				mda = lvm_list_item(pvmdash, struct metadata_area);
				mdac =
				    (struct mda_context *) mda->metadata_locn;



				/* Ensure it isn't already on list */
				found = 0;
				lvm_list_iterate(mdash, mdas) {
					mda2 =
					    lvm_list_item(mdash,
						      struct metadata_area);
					if (mda2->ops !=
					    &_metadata_text_raw_ops)


				if (!(mda_new = pool_alloc(fmt->cmd->mem,
							   sizeof(*mda_new)))) {
					STACK;
					return 0;
				}

				if (!(mdac_new = pool_alloc(fmt->cmd->mem,
							    sizeof(*mdac_new))))
				{
					STACK;
					return 0;
				}
				/* FIXME multiple dev_areas inside area */
				memcpy(mda_new, mda, sizeof(*mda));
				memcpy(mdac_new, mdac, sizeof(*mdac));
				mda_new->metadata_locn = mdac_new;
				lvm_list_add(mdas, &mda_new->list);
			}
		}


			pe_end = pe_start + extent_count * extent_size - 1;
		if (!_mda_setup(fmt, pe_start, pe_end, pvmetadatacopies,
				pvmetadatasize, mdas, pv, vg)) {
			STACK;
			return 0;
		}


	struct mda_context *mdac, *mdac_new;
	struct dir_list *dl;
	struct raw_list *rl;
	struct lvm_list *dlh, *dir_list, *rlh, *raw_list, *mdas, *mdash, *infoh;
	char path[PATH_MAX];
	struct lvmcache_vginfo *vginfo;



	fid->fmt = fmt;

	lvm_list_init(&fid->metadata_areas);

	if (!vgname) {
		if (!(mda = pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {
			STACK;
			return NULL;
		}
		mda->ops = &_metadata_text_file_backup_ops;
		mda->metadata_locn = context;
		lvm_list_add(&fid->metadata_areas, &mda->list);
	} else {
		dir_list = &((struct mda_lists *) fmt->private)->dirs;

		lvm_list_iterate(dlh, dir_list) {
			dl = lvm_list_item(dlh, struct dir_list);
			if (lvm_snprintf(path, PATH_MAX, "%s/%s",
					 dl->dir, vgname) < 0) {
				log_error("Name too long %s/%s", dl->dir,


			context = create_text_context(fmt->cmd, path, NULL);
			if (!(mda = pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {
				STACK;
				return NULL;
			}
			mda->ops = &_metadata_text_file_ops;
			mda->metadata_locn = context;
			lvm_list_add(&fid->metadata_areas, &mda->list);
		}

		raw_list = &((struct mda_lists *) fmt->private)->raws;

		lvm_list_iterate(rlh, raw_list) {
			rl = lvm_list_item(rlh, struct raw_list);

			/* FIXME Cache this; rescan below if some missing */
			if (!_raw_holds_vgname(fid, &rl->dev_area, vgname))
				continue;

			if (!(mda = pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {
				STACK;
				return NULL;
			}

			if (!(mdac = pool_alloc(fmt->cmd->mem, sizeof(*mdac)))) {
				STACK;
				return NULL;
			}
			mda->metadata_locn = mdac;

			memcpy(&mdac->area, &rl->dev_area, sizeof(mdac->area));
			mda->ops = &_metadata_text_raw_ops;
			/* FIXME MISTAKE? mda->metadata_locn = context; */
			lvm_list_add(&fid->metadata_areas, &mda->list);
		}

		/* Scan PVs in VG for any further MDAs */
		lvmcache_label_scan(fmt->cmd, 0);
		if (!(vginfo = vginfo_from_vgname(vgname))) {
			STACK;
			goto out;
		}
		lvm_list_iterate(infoh, &vginfo->infos) {
			mdas = &(lvm_list_item(infoh, struct lvmcache_info)->mdas);
			lvm_list_iterate(mdash, mdas) {
				mda = lvm_list_item(mdash, struct metadata_area);
				mdac =
				    (struct mda_context *) mda->metadata_locn;

				/* FIXME Check it holds this VG */
				if (!(mda_new = pool_alloc(fmt->cmd->mem,
							   sizeof(*mda_new)))) {
					STACK;
					return NULL;
				}

				if (!(mdac_new = pool_alloc(fmt->cmd->mem,
							    sizeof(*mdac_new))))
				{
					STACK;
					return NULL;
				}
				/* FIXME multiple dev_areas inside area */
				memcpy(mda_new, mda, sizeof(*mda));
				memcpy(mdac_new, mdac, sizeof(*mdac));
				mda_new->metadata_locn = mdac_new;
				lvm_list_add(&fid->metadata_areas, &mda_new->list);
			}
		}
		/* FIXME Check raw metadata area count - rescan if required */

	}

	if (!(tc = pool_alloc(cmd->mem, sizeof(*tc)))) {
		STACK;
		return NULL;
	}

	if (!(tc->path_live = pool_strdup(cmd->mem, path))) {
		STACK;
		goto no_mem;
	}

	if (!(tc->path_edit = pool_alloc(cmd->mem, strlen(path) + 5))) {
		STACK;
		goto no_mem;
	}
	sprintf(tc->path_edit, "%s.tmp", path);

		desc = "";

	if (!(tc->desc = pool_strdup(cmd->mem, desc))) {
		STACK;
		goto no_mem;
	}


	destroy:_destroy
};

static int _add_dir(const char *dir, struct lvm_list *dir_list)
{
	struct dir_list *dl;

	if (create_dir(dir)) {
		if (!(dl = dbg_malloc(sizeof(struct lvm_list) + strlen(dir) + 1))) {
			log_error("_add_dir allocation failed");
			return 0;
		}
		log_very_verbose("Adding text format metadata dir: %s", dir);
		strcpy(dl->dir, dir);
		lvm_list_add(dir_list, &dl->list);
		return 1;
	}


}

static int _get_config_disk_area(struct cmd_context *cmd,
				 struct config_node *cn, struct lvm_list *raw_list)
{
	struct device_area dev_area;
	char *id_str;

	struct mda_lists *mda_lists;

	if (!(fmt = dbg_malloc(sizeof(*fmt)))) {
		STACK;
		return NULL;
	}


		return NULL;
	}

	lvm_list_init(&mda_lists->dirs);
	lvm_list_init(&mda_lists->raws);
	mda_lists->file_ops = &_metadata_text_file_ops;
	mda_lists->raw_ops = &_metadata_text_raw_ops;
	fmt->private = (void *) mda_lists;





int pvhdr_read(struct device *dev, char *buf);

int add_da(const struct format_type *fmt, struct pool *mem, struct lvm_list *das,
	   uint64_t start, uint64_t size);
void del_das(struct lvm_list *das);

int add_mda(const struct format_type *fmt, struct pool *mem, struct lvm_list *mdas,
	    struct device *dev, uint64_t start, uint64_t size);
void del_mdas(struct lvm_list *mdas);

int vgname_from_mda(const struct format_type *fmt, struct device_area *dev_area,
		    char *buf, uint32_t size);

Lines 55-62 Link Here

(-)LVM2.2.00.15.orig/lib/format_text/import-export.h (-2 / +2 lines)
55	int print_flags(uint32_t status, int type, char *buffer, size_t size);	55	int print_flags(uint32_t status, int type, char *buffer, size_t size);
56	int read_flags(uint32_t status, int type, struct config_value cv);	56	int read_flags(uint32_t status, int type, struct config_value cv);
57		57
58	int print_tags(struct list tags, char buffer, size_t size);	58	int print_tags(struct lvm_list tags, char buffer, size_t size);
59	int read_tags(struct pool mem, struct list tags, struct config_value *cv);	59	int read_tags(struct pool mem, struct lvm_list tags, struct config_value *cv);
60		60
61	int text_vg_export_file(struct volume_group vg, const char desc, FILE *fp);	61	int text_vg_export_file(struct volume_group vg, const char desc, FILE *fp);
62	int text_vg_export_raw(struct volume_group vg, const char desc, char *buf,	62	int text_vg_export_raw(struct volume_group vg, const char desc, char *buf,

Lines 50-56 Link Here

(-)LVM2.2.00.15.orig/lib/format_text/import.c (-2 / +2 lines)
50	*when = 0;	50	*when = 0;
51		51
52	if (!(cft = create_config_tree())) {	52	if (!(cft = create_config_tree())) {
53	stack;	53	STACK;
54	goto out;	54	goto out;
55	}	55	}
56		56
Lines 69-75 Link Here
69	continue;	69	continue;
70		70
71	if (!(vg = (*vsn)->read_vg(fid, cft))) {	71	if (!(vg = (*vsn)->read_vg(fid, cft))) {
72	stack;	72	STACK;
73	goto out;	73	goto out;
74	}	74	}
75		75





	if (!(pvl = pool_zalloc(mem, sizeof(*pvl))) ||
	    !(pvl->pv = pool_zalloc(mem, sizeof(*pvl->pv)))) {
		STACK;
		return 0;
	}


	 * the lv segments.
	 */
	if (!hash_insert(pv_hash, pvn->key, pv)) {
		STACK;
		return 0;
	}


	}

	if (!(pv->vg_name = pool_strdup(mem, vg->name))) {
		STACK;
		return 0;
	}


		return 0;
	}

	lvm_list_init(&pv->tags);

	/* Optional tags */
	if ((cn = find_config_node(pvn, "tags")) &&

	pv->fmt = fid->fmt;

	vg->pv_count++;
	lvm_list_add(&vg->pvs, &pvl->list);

	return 1;
}

static void _insert_segment(struct logical_volume *lv, struct lv_segment *seg)
{
	struct lvm_list *segh;
	struct lv_segment *comp;

	lvm_list_iterate(segh, &lv->segments) {
		comp = lvm_list_item(segh, struct lv_segment);

		if (comp->le > seg->le) {
			lvm_list_add(&comp->list, &seg->list);
			return;
		}
	}

	lv->le_count += seg->len;
	lvm_list_add(&lv->segments, &seg->list);
}

static int _read_segment(struct pool *mem, struct volume_group *vg,

		}

		if (!vg_add_snapshot(org, cow, 1, &lv->lvid.id[1], chunk_size)) {
			STACK;
			return 0;
		}
		break;

		 */
		if (!sn->v) {
			if (!_read_segment(mem, vg, lv, sn, pv_hash)) {
				STACK;
				return 0;
			}


	 * Check there are no gaps or overlaps in the lv.
	 */
	if (!lv_check_segments(lv)) {
		STACK;
		return 0;
	}


	 * Merge segments in case someones been editing things by hand.
	 */
	if (!lv_merge_segments(lv)) {
		STACK;
		return 0;
	}



	if (!(lvl = pool_zalloc(mem, sizeof(*lvl))) ||
	    !(lvl->lv = pool_zalloc(mem, sizeof(*lvl->lv)))) {
		STACK;
		return 0;
	}

	lv = lvl->lv;

	if (!(lv->name = pool_strdup(mem, lvn->key))) {
		STACK;
		return 0;
	}


	if (!_read_int32(lvn, "read_ahead", &lv->read_ahead))
		lv->read_ahead = 0;

	lvm_list_init(&lv->segments);
	lvm_list_init(&lv->tags);

	/* Optional tags */
	if ((cn = find_config_node(lvn, "tags")) &&


	lv->vg = vg;
	vg->lv_count++;
	lvm_list_add(&vg->lvs, &lvl->list);

	return 1;
}

	memcpy(&lv->lvid.id[0], &lv->vg->id, sizeof(lv->lvid.id[0]));

	if (!_read_segments(mem, vg, lv, lvn, pv_hash)) {
		STACK;
		return 0;
	}


		}
	} else {
		vg->lv_count--;
		lvm_list_del(&lvl->list);
	}

	return 1;


	for (n = n->child; n; n = n->sib) {
		if (!fn(fid, mem, vg, n, vgn, pv_hash)) {
			STACK;
			return 0;
		}
	}

	}

	if (!(vg = pool_zalloc(mem, sizeof(*vg)))) {
		STACK;
		return NULL;
	}
	vg->cmd = fid->fmt->cmd;

	vg->fid = fid;

	if (!(vg->name = pool_strdup(mem, vgn->key))) {
		STACK;
		goto bad;
	}

	if (!(vg->system_id = pool_zalloc(mem, NAME_LEN))) {
		STACK;
		goto bad;
	}


		goto bad;
	}

	lvm_list_init(&vg->pvs);
	if (!_read_sections(fid, "physical_volumes", _read_pv, mem, vg,
			    vgn, pv_hash, 0)) {
		log_error("Couldn't find all physical volumes for volume "

		goto bad;
	}

	lvm_list_init(&vg->lvs);
	lvm_list_init(&vg->snapshots);
	lvm_list_init(&vg->tags);

	/* Optional tags */
	if ((cn = find_config_node(vgn, "tags")) &&

Lines 29-35 Link Here

(-)LVM2.2.00.15.orig/lib/format_text/layout.h (-3 / +3 lines)
29		29
30	/* Data areas (holding PEs) */	30	/* Data areas (holding PEs) */
31	struct data_area_list {	31	struct data_area_list {
32	struct list list;	32	struct lvm_list list;
33	struct disk_locn disk_locn;	33	struct disk_locn disk_locn;
34	};	34	};
35		35
Lines 65-72 Link Here
65	} __attribute__ ((packed));	65	} __attribute__ ((packed));
66		66
67	struct mda_lists {	67	struct mda_lists {
68	struct list dirs;	68	struct lvm_list dirs;
69	struct list raws;	69	struct lvm_list raws;
70	struct metadata_area_ops *file_ops;	70	struct metadata_area_ops *file_ops;
71	struct metadata_area_ops *raw_ops;	71	struct metadata_area_ops *raw_ops;
72	};	72	};




#include "str_list.h"
#include "lvm-string.h"

int print_tags(struct lvm_list *tags, char *buffer, size_t size)
{
	struct str_list *sl;
	int first = 1;

	if (!emit_to_buffer(&buffer, &size, "[")) {
		STACK;
		return 0;
	}

	lvm_list_iterate_items(sl, tags) {
		if (!first) {
			if (!emit_to_buffer(&buffer, &size, ", ")) {
				STACK;
				return 0;
			}
		} else
			first = 0;

		if (!emit_to_buffer(&buffer, &size, "\"%s\"", sl->str)) {
			STACK;
			return 0;
		}
	}

	if (!emit_to_buffer(&buffer, &size, "]")) {
		STACK;
		return 0;
	}

	return 1;
}

int read_tags(struct pool *mem, struct lvm_list *tags, struct config_value *cv)
{
	if (cv->type == CFG_EMPTY_ARRAY)
		return 1;

		}

		if (!str_list_add(mem, tags, pool_strdup(mem, cv->v.str))) {
			STACK;
			return 0;
		}





	struct pv_header *pvhdr;
	struct lvmcache_info *info;
	struct disk_locn *pvh_dlocn_xl;
	struct lvm_list *mdash, *dash;
	struct metadata_area *mda;
	struct mda_context *mdac;
	struct data_area_list *da;

	pvh_dlocn_xl = &pvhdr->disk_areas_xl[0];

	/* List of data areas (holding PEs) */
	lvm_list_iterate(dash, &info->das) {
		da = lvm_list_item(dash, struct data_area_list);

		pvh_dlocn_xl->offset = xlate64(da->disk_locn.offset);
		pvh_dlocn_xl->size = xlate64(da->disk_locn.size);

	pvh_dlocn_xl++;

	/* List of metadata area header locations */
	lvm_list_iterate(mdash, &info->mdas) {
		mda = lvm_list_item(mdash, struct metadata_area);
		mdac = (struct mda_context *) mda->metadata_locn;

		if (mdac->area.dev != info->dev)

	return 1;
}

int add_da(const struct format_type *fmt, struct pool *mem, struct lvm_list *das,
	   uint64_t start, uint64_t size)
{
	struct data_area_list *dal;

	dal->disk_locn.offset = start;
	dal->disk_locn.size = size;

	lvm_list_add(das, &dal->list);

	return 1;
}

void del_das(struct lvm_list *das)
{
	struct lvm_list *dah, *tmp;
	struct data_area_list *da;

	lvm_list_iterate_safe(dah, tmp, das) {
		da = lvm_list_item(dah, struct data_area_list);
		lvm_list_del(&da->list);
		dbg_free(da);
	}
}

int add_mda(const struct format_type *fmt, struct pool *mem, struct lvm_list *mdas,
	    struct device *dev, uint64_t start, uint64_t size)
{
/* FIXME List size restricted by pv_header SECTOR_SIZE */

	mdac->area.size = size;
	memset(&mdac->rlocn, 0, sizeof(mdac->rlocn));

	lvm_list_add(mdas, &mdal->list);
	return 1;
}

void del_mdas(struct lvm_list *mdas)
{
	struct lvm_list *mdah, *tmp;
	struct metadata_area *mda;

	lvm_list_iterate_safe(mdah, tmp, mdas) {
		mda = lvm_list_item(mdah, struct metadata_area);
		dbg_free(mda->metadata_locn);
		lvm_list_del(&mda->list);
		dbg_free(mda);
	}
}

	struct lvmcache_info *info;
	struct disk_locn *dlocn_xl;
	uint64_t offset;
	struct lvm_list *mdah;
	struct metadata_area *mda;
	char vgnamebuf[NAME_LEN + 2];
	struct mda_context *mdac;


	if (info->das.n)
		del_das(&info->das);
	lvm_list_init(&info->das);

	if (info->mdas.n)
		del_mdas(&info->mdas);
	lvm_list_init(&info->mdas);

	/* Data areas holding the PEs */
	dlocn_xl = pvhdr->disk_areas_xl;

		dlocn_xl++;
	}

	lvm_list_iterate(mdah, &info->mdas) {
		mda = lvm_list_item(mdah, struct metadata_area);
		mdac = (struct mda_context *) mda->metadata_locn;
		if (vgname_from_mda(info->fmt, &mdac->area, vgnamebuf,
				    sizeof(vgnamebuf))) {




 * Internal labeller struct.
 */
struct labeller_i {
	struct lvm_list list;

	struct labeller *l;
	char name[0];
};

static struct lvm_list _labellers;

static struct labeller_i *_alloc_li(const char *name, struct labeller *l)
{


int label_init(void)
{
	lvm_list_init(&_labellers);
	return 1;
}

void label_exit(void)
{
	struct lvm_list *c, *n;
	struct labeller_i *li;

	for (c = _labellers.n; c != &_labellers; c = n) {
		n = c->n;
		li = lvm_list_item(c, struct labeller_i);
		li->l->ops->destroy(li->l);
		_free_li(li);
	}

	struct labeller_i *li;

	if (!(li = _alloc_li(name, handler))) {
		STACK;
		return 0;
	}

	lvm_list_add(&_labellers, &li->list);
	return 1;
}

struct labeller *label_get_handler(const char *name)
{
	struct lvm_list *lih;
	struct labeller_i *li;

	lvm_list_iterate(lih, &_labellers) {
		li = lvm_list_item(lih, struct labeller_i);
		if (!strcmp(li->name, name))
			return li->l;
	}

static struct labeller *_find_labeller(struct device *dev, char *buf,
				       uint64_t *label_sector)
{
	struct lvm_list *lih;
	struct labeller_i *li;
	struct labeller *r = NULL;
	struct label_header *lh;

	char readbuf[LABEL_SCAN_SIZE];

	if (!dev_open(dev)) {
		STACK;
		return NULL;
	}


				continue;
		}

		lvm_list_iterate(lih, &_labellers) {
			li = lvm_list_item(lih, struct labeller_i);
			if (li->l->ops->can_handle(li->l, (char *) lh, sector)) {
				log_very_verbose("%s: %s label detected",
						 dev_name(dev), li->name);


      out:
	if (!dev_close(dev))
		STACK;

	return r;
}

	int r = 1;
	uint64_t sector;
	int wipe;
	struct lvm_list *lih;
	struct labeller_i *li;
	struct label_header *lh;


	log_very_verbose("Scanning for labels to wipe from %s", dev_name(dev));

	if (!dev_open(dev)) {
		STACK;
		return 0;
	}


			if (xlate64(lh->sector_xl) == sector)
				wipe = 1;
		} else {
			lvm_list_iterate(lih, &_labellers) {
				li = lvm_list_item(lih, struct labeller_i);
				if (li->l->ops->can_handle(li->l, (char *) lh,
							   sector)) {
					wipe = 1;


      out:
	if (!dev_close(dev))
		STACK;

	return r;
}

	int r;

	if (!(l = _find_labeller(dev, buf, &sector))) {
		STACK;
		return 0;
	}


	lh->offset_xl = xlate32(sizeof(*lh));

	if (!label->labeller->ops->write(label, buf)) {
		STACK;
		return 0;
	}


				      ((void *) &lh->offset_xl - (void *) lh)));

	if (!dev_open(dev)) {
		STACK;
		return 0;
	}


	}

	if (!dev_close(dev))
		STACK;

	return r;
}

	uint64_t sector;

	if (!(l = _find_labeller(dev, buf, &sector))) {
		STACK;
		return 0;
	}


Lines 64-70 Link Here

(-)LVM2.2.00.15.orig/lib/locking/external_locking.c (-1 / +1 lines)
64	DEFAULT_LOCKING_LIB);	64	DEFAULT_LOCKING_LIB);
65		65
66	if (!(_locking_lib = load_shared_library(cft, libname, "locking"))) {	66	if (!(_locking_lib = load_shared_library(cft, libname, "locking"))) {
67	stack;	67	STACK;
68	return 0;	68	return 0;
69	}	69	}
70		70




#include <signal.h>

struct lock_list {
	struct lvm_list list;
	int lf;
	char *res;
};

static struct lvm_list _lock_list;
static char _lock_dir[NAME_LEN];

static sig_t _oldhandler;

static int _release_lock(const char *file, int unlock)
{
	struct lock_list *ll;
	struct lvm_list *llh, *llt;

	struct stat buf1, buf2;

	lvm_list_iterate_safe(llh, llt, &_lock_list) {
		ll = lvm_list_item(llh, struct lock_list);

		if (!file || !strcmp(ll->res, file)) {
			lvm_list_del(llh);
			if (unlock) {
				log_very_verbose("Unlocking %s", ll->res);
				if (flock(ll->lf, LOCK_NB | LOCK_UN))

			break;
	} while (!(flags & LCK_NONBLOCK));

	lvm_list_add(&_lock_list, &ll->list);
	return 1;

      err:

	if ((access(_lock_dir, R_OK | W_OK | X_OK) == -1) && (errno == EROFS))
		return 0;

	lvm_list_init(&_lock_list);

	if (sigfillset(&_intsigset) || sigfillset(&_fullsigset)) {
		log_sys_error("sigfillset", "init_file_locking");




}

/* Unlock list of LVs */
int unlock_lvs(struct cmd_context *cmd, struct lvm_list *lvs)
{
	struct lvm_list *lvh;
	struct logical_volume *lv;

	lvm_list_iterate(lvh, lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;
		unlock_lv(cmd, lv->lvid.s);
	}


}

/* Lock a list of LVs */
int lock_lvs(struct cmd_context *cmd, struct lvm_list *lvs, int flags)
{
	struct lvm_list *lvh;
	struct logical_volume *lv;

	lvm_list_iterate(lvh, lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;
		if (!lock_vol(cmd, lv->lvid.s, flags)) {
			log_error("Failed to suspend %s", lv->name);
			lvm_list_uniterate(lvh, lvs, lvh) {
				lv = lvm_list_item(lvh, struct lv_list)->lv;
				unlock_lv(cmd, lv->lvid.s);
			}


Lines 82-87 Link Here

(-)LVM2.2.00.15.orig/lib/locking/locking.h (-2 / +2 lines)
82	#define unlock_vg(cmd, vol) lock_vol(cmd, vol, LCK_VG_UNLOCK)	82	#define unlock_vg(cmd, vol) lock_vol(cmd, vol, LCK_VG_UNLOCK)
83		83
84	/* Process list of LVs */	84	/* Process list of LVs */
85	int lock_lvs(struct cmd_context cmd, struct list lvs, int flags);	85	int lock_lvs(struct cmd_context cmd, struct lvm_list lvs, int flags);
86	int unlock_lvs(struct cmd_context cmd, struct list lvs);	86	int unlock_lvs(struct cmd_context cmd, struct lvm_list lvs);
87		87

Lines 28-34 Link Here

(-)LVM2.2.00.15.orig/lib/log/log.h (-2 / +2 lines)
28	* In addition, messages will be logged to file or syslog if they	28	* In addition, messages will be logged to file or syslog if they
29	* are more serious than the log level specified with the log/debug_level	29	* are more serious than the log level specified with the log/debug_level
30	* parameter in the configuration file. These messages get the file	30	* parameter in the configuration file. These messages get the file
31	* and line number prepended. 'stack' (without arguments) can be used	31	* and line number prepended. 'STACK' (without arguments) can be used
32	* to log this information at debug level.	32	* to log this information at debug level.
33	*	33	*
34	* log_sys_error and log_sys_very_verbose are for errors from system calls	34	* log_sys_error and log_sys_very_verbose are for errors from system calls
Lines 100-106 Link Here
100	#define log_err(x...) plog(_LOG_ERR, x)	100	#define log_err(x...) plog(_LOG_ERR, x)
101	#define log_fatal(x...) plog(_LOG_FATAL, x)	101	#define log_fatal(x...) plog(_LOG_FATAL, x)
102		102
103	#define stack log_debug("<backtrace>") /* Backtrace on error */	103	#define STACK log_debug("<backtrace>") /* Backtrace on error */
104		104
105	#define log_error(args...) log_err(args)	105	#define log_error(args...) log_err(args)
106	#define log_print(args...) log_warn(args)	106	#define log_print(args...) log_warn(args)




	uint32_t len = sizeof(*seg) + (num_areas * sizeof(seg->area[0]));

	if (!(seg = pool_zalloc(mem, len))) {
		STACK;
		return NULL;
	}

	lvm_list_init(&seg->tags);

	return seg;
}

		consume_pv_area(pva, area_len);
	}

	lvm_list_add(&lv->segments, &seg->list);
	*ix += seg->len;
	return 1;
}

}

static int _alloc_parallel(struct logical_volume *lv,
			   struct lvm_list *pvms, uint32_t allocated,
			   uint32_t stripes, uint32_t stripe_size)
{
	int r = 0;
	struct lvm_list *pvmh;
	struct pv_area **areas;
	unsigned int pv_count = 0, ix;
	struct pv_map *pvm;


	area_count = stripes;

	lvm_list_iterate(pvmh, pvms)
	    pv_count++;

	/* allocate an array of pv_areas, one candidate per pv */

	while (allocated != lv->le_count) {

		ix = 0;
		lvm_list_iterate(pvmh, pvms) {
			pvm = lvm_list_item(pvmh, struct pv_map);

			if (lvm_list_empty(&pvm->areas))
				continue;

			areas[ix++] = lvm_list_item(pvm->areas.n, struct pv_area);
		}

		if (ix < area_count) {


		if (!_alloc_parallel_area(lv, area_count, stripe_size, areas,
					  &allocated)) {
			STACK;
			goto out;
		}
	}

	seg->area[0].u.pv.pv = map->pvl->pv;
	seg->area[0].u.pv.pe = pva->start;

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

	consume_pv_area(pva, count);
	*ix += count;

	seg->area[1].type = AREA_PV;
	seg->area[1].u.pv.pv = map->pvl->pv;
	seg->area[1].u.pv.pe = pva->start;
	lvm_list_add(&lv->segments, &seg->list);

	consume_pv_area(pva, count);
	*ix += count;

 * FIXME: subsequent lvextends may not be contiguous.
 */
static int _alloc_contiguous(struct logical_volume *lv,
			     struct lvm_list *pvms, uint32_t allocated)
{
	struct lvm_list *tmp1;
	struct pv_map *pvm;
	struct pv_area *pva;

	lvm_list_iterate(tmp1, pvms) {
		pvm = lvm_list_item(tmp1, struct pv_map);

		if (lvm_list_empty(&pvm->areas))
			continue;

		/* first item in the list is the biggest */
		pva = lvm_list_item(pvm->areas.n, struct pv_area);
		if (pva->count < lv->le_count)
			continue;

		if (!_alloc_linear_area(lv, &allocated, pvm, pva)) {
			STACK;
			return 0;
		}



/* FIXME Contiguous depends on *segment* (i.e. stripe) not LV */
static int _alloc_mirrored(struct logical_volume *lv,
			   struct lvm_list *pvms, uint32_t allocated,
			   struct physical_volume *mirrored_pv,
			   uint32_t mirrored_pe)
{
	struct lvm_list *tmp1;
	struct pv_map *pvm;
	struct pv_area *pva;
	uint32_t max_found = 0;

	/* Try each PV in turn */
	lvm_list_iterate(tmp1, pvms) {
		pvm = lvm_list_item(tmp1, struct pv_map);

		if (lvm_list_empty(&pvm->areas))
			continue;

		/* first item in the list is the biggest */
		pva = lvm_list_item(pvm->areas.n, struct pv_area);
		if (pva->count < lv->le_count - allocated) {
			max_found = pva->count;
			continue;


		if (!_alloc_mirrored_area(lv, &allocated, pvm, pva,
					  mirrored_pv, mirrored_pe)) {
			STACK;
			return 0;
		}


 * is full.
 */
static int _alloc_next_free(struct logical_volume *lv,
			    struct lvm_list *pvms, uint32_t allocated)
{
	struct lvm_list *tmp1, *tmp2;
	struct pv_map *pvm;
	struct pv_area *pva;

	lvm_list_iterate(tmp1, pvms) {
		pvm = lvm_list_item(tmp1, struct pv_map);

		lvm_list_iterate(tmp2, &pvm->areas) {
			pva = lvm_list_item(tmp2, struct pv_area);
			if (!_alloc_linear_area(lv, &allocated, pvm, pva) ||
			    (allocated == lv->le_count))
				goto done;

 * Chooses a correct allocation policy.
 */
static int _allocate(struct volume_group *vg, struct logical_volume *lv,
		     struct lvm_list *allocatable_pvs, uint32_t allocated,
		     uint32_t stripes, uint32_t stripe_size,
		     struct physical_volume *mirrored_pv, uint32_t mirrored_pe,
		     uint32_t status)
{
	int r = 0;
	struct pool *scratch;
	struct lvm_list *pvms, *old_tail = lv->segments.p, *segh;
	struct lv_segment *seg;

	if (!(scratch = pool_create(1024))) {
		STACK;
		return 0;
	}


		 * counts in pv's.
		 */
		for (segh = lv->segments.p; segh != old_tail; segh = segh->p) {
			seg = lvm_list_item(segh, struct lv_segment);
			_get_extents(seg);
			seg->status = status;
		}

static char *_generate_lv_name(struct volume_group *vg, const char *format,
			       char *buffer, size_t len)
{
	struct lvm_list *lvh;
	struct logical_volume *lv;
	int high = -1, i;

	lvm_list_iterate(lvh, &vg->lvs) {
		lv = (lvm_list_item(lvh, struct lv_list)->lv);

		if (sscanf(lv->name, format, &i) != 1)
			continue;

	lv->minor = -1;
	lv->size = UINT64_C(0);
	lv->le_count = 0;
	lvm_list_init(&lv->segments);
	lvm_list_init(&lv->tags);

	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {
		STACK;
		if (ll)
			pool_free(cmd->mem, ll);
		return NULL;
	}

	vg->lv_count++;
	lvm_list_add(&vg->lvs, &ll->list);

	return lv;
}

				 uint32_t stripe_size,
				 uint32_t extents,
				 struct volume_group *vg,
				 struct lvm_list *allocatable_pvs)
{
	struct logical_volume *lv;


		return NULL;
	}

	if (stripes > lvm_list_size(allocatable_pvs)) {
		log_error("Number of stripes (%u) must not exceed "
			  "number of physical volumes (%d)", stripes,
			  lvm_list_size(allocatable_pvs));
		return NULL;
	}

	if (!(lv = lv_create_empty(fi, name, "lvol%d", status, alloc, vg))) {
		STACK;
		return NULL;
	}



	if (!_allocate(vg, lv, allocatable_pvs, 0u, stripes, stripe_size,
		       NULL, 0u, 0u)) {
		STACK;
		return NULL;
	}

	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {
		STACK;
		return NULL;
	}


int lv_reduce(struct format_instance *fi,
	      struct logical_volume *lv, uint32_t extents)
{
	struct lvm_list *segh;
	struct lv_segment *seg;
	uint32_t count = extents;
	int striped;

	for (segh = lv->segments.p;
	     (segh != &lv->segments) && count; segh = segh->p) {
		seg = lvm_list_item(segh, struct lv_segment);

		if (seg->len <= count) {
			/* remove this segment completely */
			count -= seg->len;
			_put_extents(seg);
			lvm_list_del(segh);
		} else {
			/* reduce this segment */
			_put_extents(seg);

	lv->vg->free_count += extents;

	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {
		STACK;
		return 0;
	}


int lv_extend(struct format_instance *fi,
	      struct logical_volume *lv,
	      uint32_t stripes, uint32_t stripe_size,
	      uint32_t extents, struct lvm_list *allocatable_pvs)
{
	uint32_t old_le_count = lv->le_count;
	uint64_t old_size = lv->size;

		       stripes, stripe_size, NULL, 0u, 0u)) {
		lv->le_count = old_le_count;
		lv->size = old_size;
		STACK;
		return 0;
	}


	}

	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {
		STACK;
		return 0;
	}


		     struct logical_volume *lv,
		     struct physical_volume *mirrored_pv,
		     uint32_t mirrored_pe,
		     uint32_t extents, struct lvm_list *allocatable_pvs,
		     uint32_t status)
{
	uint32_t old_le_count = lv->le_count;

		       1, extents, mirrored_pv, mirrored_pe, status)) {
		lv->le_count = old_le_count;
		lv->size = old_size;
		STACK;
		return 0;
	}

	if (fid->fmt->ops->lv_setup && !fid->fmt->ops->lv_setup(fid, lv)) {
		STACK;
		return 0;
	}



int lv_remove(struct volume_group *vg, struct logical_volume *lv)
{
	struct lvm_list *segh;
	struct lv_list *lvl;

	/* find the lv list */
	if (!(lvl = find_lv_in_vg(vg, lv->name))) {
		STACK;
		return 0;
	}

	/* iterate through the lv's segments freeing off the pe's */
	lvm_list_iterate(segh, &lv->segments)
	    _put_extents(lvm_list_item(segh, struct lv_segment));

	vg->lv_count--;
	vg->free_count += lv->le_count;

	lvm_list_del(&lvl->list);

	return 1;
}

{
	int lvnum_used[MAX_RESTRICTED_LVS + 1];
	uint32_t i = 0;
	struct lvm_list *lvh;
	struct lv_list *lvl;
	int lvnum;

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

	lvm_list_iterate(lvh, &lv->vg->lvs) {
		lvl = lvm_list_item(lvh, struct lv_list);
		lvnum = lvnum_from_lvid(&lvl->lv->lvid);
		if (lvnum <= MAX_RESTRICTED_LVS)
			lvnum_used[lvnum] = 1;





int lv_merge_segments(struct logical_volume *lv)
{
	struct lvm_list *segh, *t;
	struct lv_segment *current, *prev = NULL;

	lvm_list_iterate_safe(segh, t, &lv->segments) {
		current = lvm_list_item(segh, struct lv_segment);

		if (_merge(prev, current))
			lvm_list_del(&current->list);
		else
			prev = current;
	}

	uint32_t le = 0;
	unsigned seg_count = 0;

	lvm_list_iterate_items(seg, &lv->segments) {
		seg_count++;
		if (seg->le != le) {
			log_error("LV %s invalid: segment %u should begin at "

	seg->area_len = offset;

	/* Add split off segment to the list _after_ the original one */
	lvm_list_add_h(&seg->list, &split_seg->list);

	return 1;
}

		return 1;

	if (!_lv_split_segment(lv, seg, le)) {
		STACK;
		return 0;
	}





	struct pv_list *pvl;
	struct physical_volume *pv;
	struct pool *mem = fid->fmt->cmd->mem;
	struct lvm_list mdas;

	log_verbose("Adding physical volume '%s' to volume group '%s'",
		    pv_name, vg->name);

		return 0;
	}

	lvm_list_init(&mdas);
	if (!(pv = pv_read(fid->fmt->cmd, pv_name, &mdas, NULL))) {
		log_error("%s not identified as an existing physical volume",
			  pv_name);


	pvl->pv = pv;

	lvm_list_add(&vg->pvs, &pvl->list);
	vg->pv_count++;
	vg->extent_count += pv->pe_count;
	vg->free_count += pv->pe_count;

{
	struct pool *mem = cmd->mem;
	struct physical_volume *pv;
	struct lvm_list *pvh;

	if (!(vg->name = pool_strdup(mem, new_name))) {
		log_error("vg->name allocation failed for '%s'", new_name);
		return 0;
	}

	lvm_list_iterate(pvh, &vg->pvs) {
		pv = lvm_list_item(pvh, struct pv_list)->pv;
		if (!(pv->vg_name = pool_strdup(mem, new_name))) {
			log_error("pv->vg_name allocation failed for '%s'",
				  dev_name(pv->dev));

	int old_partial;

	if (!(vg = pool_zalloc(mem, sizeof(*vg)))) {
		STACK;
		return NULL;
	}


	vg->cmd = cmd;

	if (!(vg->name = pool_strdup(mem, vg_name))) {
		STACK;
		goto bad;
	}


	vg->max_pv = max_pv;

	vg->pv_count = 0;
	lvm_list_init(&vg->pvs);

	vg->lv_count = 0;
	lvm_list_init(&vg->lvs);

	vg->snapshot_count = 0;
	lvm_list_init(&vg->snapshots);

	lvm_list_init(&vg->tags);

	if (!(vg->fid = cmd->fmt->ops->create_instance(cmd->fmt, vg_name,
						       NULL))) {

				  uint32_t existing_extent_count,
				  uint32_t existing_extent_size,
				  int pvmetadatacopies,
				  uint64_t pvmetadatasize, struct lvm_list *mdas)
{
	struct pool *mem = fmt->cmd->mem;
	struct physical_volume *pv = pool_alloc(mem, sizeof(*pv));

	if (!pv) {
		STACK;
		return NULL;
	}


	pv->dev = dev;

	if (!(pv->vg_name = pool_zalloc(mem, NAME_LEN))) {
		STACK;
		goto bad;
	}


	pv->pe_alloc_count = 0;
	pv->fmt = fmt;

	lvm_list_init(&pv->tags);

	if (!fmt->ops->pv_setup(fmt, pe_start, existing_extent_count,
				existing_extent_size,


struct pv_list *find_pv_in_vg(struct volume_group *vg, const char *pv_name)
{
	struct lvm_list *pvh;
	struct pv_list *pvl;

	lvm_list_iterate(pvh, &vg->pvs) {
		pvl = lvm_list_item(pvh, struct pv_list);
		if (pvl->pv->dev == dev_cache_get(pv_name, vg->cmd->filter))
			return pvl;
	}


int pv_is_in_vg(struct volume_group *vg, struct physical_volume *pv)
{
	struct lvm_list *pvh;

	lvm_list_iterate(pvh, &vg->pvs) {
		if (pv == lvm_list_item(pvh, struct pv_list)->pv)
			 return 1;
	}


struct physical_volume *find_pv_in_vg_by_uuid(struct volume_group *vg,
					      struct id *id)
{
	struct lvm_list *pvh;
	struct pv_list *pvl;

	lvm_list_iterate(pvh, &vg->pvs) {
		pvl = lvm_list_item(pvh, struct pv_list);
		if (id_equal(&pvl->pv->id, id))
			return pvl->pv;
	}


struct lv_list *find_lv_in_vg(struct volume_group *vg, const char *lv_name)
{
	struct lvm_list *lvh;
	struct lv_list *lvl;
	const char *ptr;


	else
		ptr = lv_name;

	lvm_list_iterate(lvh, &vg->lvs) {
		lvl = lvm_list_item(lvh, struct lv_list);
		if (!strcmp(lvl->lv->name, ptr))
			return lvl;
	}

struct lv_list *find_lv_in_vg_by_lvid(struct volume_group *vg,
				      const union lvid *lvid)
{
	struct lvm_list *lvh;
	struct lv_list *lvl;

	lvm_list_iterate(lvh, &vg->lvs) {
		lvl = lvm_list_item(lvh, struct lv_list);
		if (!strncmp(lvl->lv->lvid.s, lvid->s, sizeof(*lvid)))
			return lvl;
	}


struct physical_volume *find_pv(struct volume_group *vg, struct device *dev)
{
	struct lvm_list *pvh;
	struct physical_volume *pv;

	lvm_list_iterate(pvh, &vg->pvs) {
		pv = lvm_list_item(pvh, struct pv_list)->pv;

		if (dev == pv->dev)
			return pv;

/* Find segment at a given logical extent in an LV */
struct lv_segment *find_seg_by_le(struct logical_volume *lv, uint32_t le)
{
	struct lvm_list *segh;
	struct lv_segment *seg;

	lvm_list_iterate(segh, &lv->segments) {
		seg = lvm_list_item(segh, struct lv_segment);
		if (le >= seg->le && le < seg->le + seg->len)
			return seg;
	}


int vg_remove(struct volume_group *vg)
{
	struct lvm_list *mdah;
	struct metadata_area *mda;

	/* FIXME Improve recovery situation? */
	/* Remove each copy of the metadata */
	lvm_list_iterate(mdah, &vg->fid->metadata_areas) {
		mda = lvm_list_item(mdah, struct metadata_area);
		if (mda->ops->vg_remove &&
		    !mda->ops->vg_remove(vg->fid, vg, mda)) {
			STACK;
			return 0;
		}
	}

 */
int vg_write(struct volume_group *vg)
{
	struct lvm_list *mdah, *mdah2;
	struct metadata_area *mda;

	if (vg->status & PARTIAL_VG) {

		return 0;
	}

	if (lvm_list_empty(&vg->fid->metadata_areas)) {
		log_error("Aborting vg_write: No metadata areas to write to!");
		return 0;
	}

	vg->seqno++;

	/* Write to each copy of the metadata area */
	lvm_list_iterate(mdah, &vg->fid->metadata_areas) {
		mda = lvm_list_item(mdah, struct metadata_area);
		if (!mda->ops->vg_write) {
			log_error("Format does not support writing volume"
				  "group metadata areas");
			/* Revert */
			lvm_list_uniterate(mdah2, &vg->fid->metadata_areas, mdah) {
				mda = lvm_list_item(mdah2, struct metadata_area);
				if (mda->ops->vg_revert &&
				    !mda->ops->vg_revert(vg->fid, vg, mda)) {
					STACK;
				}
			}
			return 0;
		}
		if (!mda->ops->vg_write(vg->fid, vg, mda)) {
			STACK;
			/* Revert */
			lvm_list_uniterate(mdah2, &vg->fid->metadata_areas, mdah) {
				mda = lvm_list_item(mdah2, struct metadata_area);
				if (mda->ops->vg_revert &&
				    !mda->ops->vg_revert(vg->fid, vg, mda)) {
					STACK;
				}
			}
			return 0;

/* Commit pending changes */
int vg_commit(struct volume_group *vg)
{
	struct lvm_list *mdah;
	struct metadata_area *mda;
	int cache_updated = 0;
	int failed = 0;

	/* Commit to each copy of the metadata area */
	lvm_list_iterate(mdah, &vg->fid->metadata_areas) {
		mda = lvm_list_item(mdah, struct metadata_area);
		failed = 0;
		if (mda->ops->vg_commit &&
		    !mda->ops->vg_commit(vg->fid, vg, mda)) {
			STACK;
			failed = 1;
		}
		/* Update cache first time we succeed */

/* Don't commit any pending changes */
int vg_revert(struct volume_group *vg)
{
	struct lvm_list *mdah;
	struct metadata_area *mda;

	lvm_list_iterate(mdah, &vg->fid->metadata_areas) {
		mda = lvm_list_item(mdah, struct metadata_area);
		if (mda->ops->vg_revert &&
		    !mda->ops->vg_revert(vg->fid, vg, mda)) {
			STACK;
		}
	}


static struct volume_group *_vg_read_orphans(struct cmd_context *cmd)
{
	struct lvmcache_vginfo *vginfo;
	struct lvm_list *ih;
	struct device *dev;
	struct pv_list *pvl;
	struct volume_group *vg;
	struct physical_volume *pv;

	if (!(vginfo = vginfo_from_vgname(ORPHAN))) {
		STACK;
		return NULL;
	}


		log_error("vg allocation failed");
		return NULL;
	}
	lvm_list_init(&vg->pvs);
	lvm_list_init(&vg->lvs);
	lvm_list_init(&vg->snapshots);
	lvm_list_init(&vg->tags);
	vg->cmd = cmd;
	if (!(vg->name = pool_strdup(cmd->mem, ORPHAN))) {
		log_error("vg name allocation failed");
		return NULL;
	}

	lvm_list_iterate(ih, &vginfo->infos) {
		dev = lvm_list_item(ih, struct lvmcache_info)->dev;
		if (!(pv = pv_read(cmd, dev_name(dev), NULL, NULL))) {
			continue;
		}

			return NULL;
		}
		pvl->pv = pv;
		lvm_list_add(&vg->pvs, &pvl->list);
		vg->pv_count++;
	}


	struct format_instance *fid;
	const struct format_type *fmt;
	struct volume_group *vg, *correct_vg = NULL;
	struct lvm_list *mdah;
	struct metadata_area *mda;
	int inconsistent = 0;


		lvmcache_label_scan(cmd, 0);
		if (!(fmt = fmt_from_vgname(vgname))) {
			if (memlock()) {
				STACK;
				return NULL;
			}
			lvmcache_label_scan(cmd, 1);
			if (!(fmt = fmt_from_vgname(vgname))) {
				STACK;
				return NULL;
			}
		}

	}

	/* Ensure contents of all metadata areas match - else do recovery */
	lvm_list_iterate(mdah, &fid->metadata_areas) {
		mda = lvm_list_item(mdah, struct metadata_area);
		if (!(vg = mda->ops->vg_read(fid, vgname, mda))) {
			inconsistent = 1;
			continue;


	/* Failed to find VG */
	if (!correct_vg) {
		STACK;
		return NULL;
	}


struct volume_group *vg_read_by_vgid(struct cmd_context *cmd, const char *vgid)
{
	const char *vgname;
	struct lvm_list *vgnames, *slh;
	struct volume_group *vg;
	struct lvmcache_vginfo *vginfo;
	int consistent = 0;

		return NULL;
	}

	lvm_list_iterate(slh, vgnames) {
		vgname = lvm_list_item(slh, struct str_list)->str;
		if (!vgname || !*vgname)
			continue;	// FIXME Unnecessary? 
		consistent = 0;


/* FIXME Use label functions instead of PV functions */
struct physical_volume *pv_read(struct cmd_context *cmd, const char *pv_name,
				struct lvm_list *mdas, uint64_t *label_sector)
{
	struct physical_volume *pv;
	struct label *label;

	struct device *dev;

	if (!(dev = dev_cache_get(pv_name, cmd->filter))) {
		STACK;
		return 0;
	}


		return 0;
	}

	lvm_list_init(&pv->tags);

	/* FIXME Move more common code up here */
	if (!(info->fmt->ops->pv_read(info->fmt, pv_name, pv, mdas))) {

}

/* May return empty list */
struct lvm_list *get_vgs(struct cmd_context *cmd, int full_scan)
{
	return lvmcache_get_vgnames(cmd, full_scan);
}

struct lvm_list *get_pvs(struct cmd_context *cmd)
{
	struct lvm_list *results;
	const char *vgname;
	struct lvm_list *pvh, *tmp;
	struct lvm_list *vgnames, *slh;
	struct volume_group *vg;
	int consistent = 0;
	int old_partial;

		return NULL;
	}

	lvm_list_init(results);

	/* Get list of VGs */
	if (!(vgnames = get_vgs(cmd, 0))) {

	old_pvmove = pvmove_mode();
	init_partial(1);
	init_pvmove(1);
	lvm_list_iterate(slh, vgnames) {
		vgname = lvm_list_item(slh, struct str_list)->str;
		if (!vgname)
			continue;	/* FIXME Unnecessary? */
		consistent = 0;
		if (!(vg = vg_read(cmd, vgname, &consistent))) {
			STACK;
			continue;
		}
		if (!consistent)

				  vgname);

		/* Move PVs onto results list */
		lvm_list_iterate_safe(pvh, tmp, &vg->pvs) {
			lvm_list_add(results, pvh);
		}
	}
	init_pvmove(old_pvmove);

}

int pv_write(struct cmd_context *cmd, struct physical_volume *pv,
	     struct lvm_list *mdas, int64_t label_sector)
{
	if (!pv->fmt->ops->pv_write) {
		log_error("Format does not support writing physical volumes");

	}

	if (!pv->fmt->ops->pv_write(pv->fmt, pv, mdas, label_sector)) {
		STACK;
		return 0;
	}





struct labeller;

struct format_type {
	struct lvm_list list;
	struct cmd_context *cmd;
	struct format_handler *ops;
	struct labeller *labeller;

	uint32_t pe_count;
	uint32_t pe_alloc_count;

	struct lvm_list tags;
};

struct metadata_area;

};

struct metadata_area {
	struct lvm_list list;
	struct metadata_area_ops *ops;
	void *metadata_locn;
};

struct format_instance {
	const struct format_type *fmt;
	struct lvm_list metadata_areas;	/* e.g. metadata locations */
};

struct volume_group {


	/* physical volumes */
	uint32_t pv_count;
	struct lvm_list pvs;

	/* logical volumes */
	uint32_t lv_count;
	struct lvm_list lvs;

	/* snapshots */
	uint32_t snapshot_count;
	struct lvm_list snapshots;

	struct lvm_list tags;
};

struct lv_segment {
	struct lvm_list list;
	struct logical_volume *lv;

	segment_type_t type;

	uint32_t chunk_size;
	uint32_t extents_moved;

	struct lvm_list tags;

	/* There will be one area for each stripe */
	struct {

	uint64_t size;
	uint32_t le_count;

	struct lvm_list segments;
	struct lvm_list tags;
};

struct snapshot {

};

struct name_list {
	struct lvm_list list;
	char *name;
};

struct alloc_area {
	struct lvm_list list;
	uint32_t start;		/* PEs */
	uint32_t count;		/* PEs */
};

struct pv_list {
	struct lvm_list list;
	struct physical_volume *pv;
	struct lvm_list *mdas;	/* Metadata areas */
	struct lvm_list *alloc_areas;	/* Areas we may allocate from */
};

struct lv_list {
	struct lvm_list list;
	struct logical_volume *lv;
};

struct snapshot_list {
	struct lvm_list list;

	struct snapshot *snapshot;
};

struct mda_list {
	struct lvm_list list;
	struct device_area mda;
};


	 * Return PV with given path.
	 */
	int (*pv_read) (const struct format_type * fmt, const char *pv_name,
			struct physical_volume * pv, struct lvm_list * mdas);

	/*
	 * Tweak an already filled out a pv ready for importing into a

			 uint64_t pe_start, uint32_t extent_count,
			 uint32_t extent_size,
			 int pvmetadatacopies,
			 uint64_t pvmetadatasize, struct lvm_list * mdas,
			 struct physical_volume * pv, struct volume_group * vg);

	/*

	 * pv->vg_name must be null.
	 */
	int (*pv_write) (const struct format_type * fmt,
			 struct physical_volume * pv, struct lvm_list * mdas,
			 int64_t label_sector);

	/*

			     int *consistent);
struct volume_group *vg_read_by_vgid(struct cmd_context *cmd, const char *vgid);
struct physical_volume *pv_read(struct cmd_context *cmd, const char *pv_name,
				struct lvm_list *mdas, uint64_t *label_sector);
struct lvm_list *get_pvs(struct cmd_context *cmd);

/* Set full_scan to 1 to re-read every (filtered) device label */
struct lvm_list *get_vgs(struct cmd_context *cmd, int full_scan);

int pv_write(struct cmd_context *cmd, struct physical_volume *pv,
	     struct lvm_list *mdas, int64_t label_sector);

/* pe_start and pe_end relate to any existing data so that new metadata
 * areas can avoid overlap */

				  uint32_t existing_extent_count,
				  uint32_t existing_extent_size,
				  int pvmetadatacopies,
				  uint64_t pvmetadatasize, struct lvm_list *mdas);

struct volume_group *vg_create(struct cmd_context *cmd, const char *name,
			       uint32_t extent_size, uint32_t max_pv,

				 uint32_t stripe_size,
				 uint32_t extents,
				 struct volume_group *vg,
				 struct lvm_list *allocatable_pvs);

struct logical_volume *lv_create_empty(struct format_instance *fi,
				       const char *name,

	      struct logical_volume *lv,
	      uint32_t stripes,
	      uint32_t stripe_size,
	      uint32_t extents, struct lvm_list *allocatable_pvs);

int lv_extend_mirror(struct format_instance *fid,
		     struct logical_volume *lv,
		     struct physical_volume *mirrored_pv,
		     uint32_t mirrored_pe,
		     uint32_t extents, struct lvm_list *allocatable_pvs,
		     uint32_t status);

/* lv must be part of vg->lvs */


struct snapshot *find_cow(const struct logical_volume *lv);
struct snapshot *find_origin(const struct logical_volume *lv);
struct lvm_list *find_snapshots(const struct logical_volume *lv);

int vg_add_snapshot(struct logical_volume *origin,
		    struct logical_volume *cow,

			  struct logical_volume *lv_mirr,
			  struct physical_volume *pv,
			  struct logical_volume *lv,
			  struct lvm_list *allocatable_pvs,
			  struct lvm_list *lvs_changed);
int remove_pvmove_mirrors(struct volume_group *vg,
			  struct logical_volume *lv_mirr);
struct logical_volume *find_pvmove_lv(struct volume_group *vg,

struct physical_volume *get_pvmove_pv_from_lv_mirr(struct logical_volume
						   *lv_mirr);
float pvmove_percent(struct logical_volume *lv_mirr);
struct lvm_list *lvs_using_lv(struct cmd_context *cmd, struct volume_group *vg,
			  struct logical_volume *lv);

uint32_t find_free_lvnum(struct logical_volume *lv);




			  struct logical_volume *lv_mirr,
			  struct physical_volume *pv,
			  struct logical_volume *lv,
			  struct lvm_list *allocatable_pvs,
			  struct lvm_list *lvs_changed)
{
	struct lvm_list *segh;
	struct lv_segment *seg;
	struct lv_list *lvl;
	int lv_used = 0;
	uint32_t s, start_le, extent_count = 0u;

	lvm_list_iterate(segh, &lv->segments) {
		seg = lvm_list_item(segh, struct lv_segment);
		for (s = 0; s < seg->area_count; s++) {
			if (seg->area[s].type != AREA_PV ||
			    seg->area[s].u.pv.pv->dev != pv->dev)

					return 0;
				}
				lvl->lv = lv;
				lvm_list_add(lvs_changed, &lvl->list);
				lv_used = 1;
			}


int remove_pvmove_mirrors(struct volume_group *vg,
			  struct logical_volume *lv_mirr)
{
	struct lvm_list *lvh, *segh;
	struct logical_volume *lv1;
	struct lv_segment *seg, *mir_seg;
	uint32_t s, c;

	lvm_list_iterate(lvh, &vg->lvs) {
		lv1 = lvm_list_item(lvh, struct lv_list)->lv;
		if (lv1 == lv_mirr)
			continue;

		lvm_list_iterate(segh, &lv1->segments) {
			seg = lvm_list_item(segh, struct lv_segment);
			for (s = 0; s < seg->area_count; s++) {
				if (seg->area[s].type != AREA_LV ||
				    seg->area[s].u.lv.lv != lv_mirr)

struct physical_volume *get_pvmove_pv_from_lv_mirr(struct logical_volume
						   *lv_mirr)
{
	struct lvm_list *segh;
	struct lv_segment *seg;

	lvm_list_iterate(segh, &lv_mirr->segments) {
		seg = lvm_list_item(segh, struct lv_segment);
		if (seg->type != SEG_MIRRORED)
			continue;
		if (seg->area[0].type != AREA_PV)


struct physical_volume *get_pvmove_pv_from_lv(struct logical_volume *lv)
{
	struct lvm_list *segh;
	struct lv_segment *seg;
	uint32_t s;

	lvm_list_iterate(segh, &lv->segments) {
		seg = lvm_list_item(segh, struct lv_segment);
		for (s = 0; s < seg->area_count; s++) {
			if (seg->area[s].type != AREA_LV)
				continue;

struct logical_volume *find_pvmove_lv(struct volume_group *vg,
				      struct device *dev)
{
	struct lvm_list *lvh, *segh;
	struct logical_volume *lv;
	struct lv_segment *seg;

	/* Loop through all LVs */
	lvm_list_iterate(lvh, &vg->lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;

		if (!(lv->status & PVMOVE))
			continue;

		lvm_list_iterate(segh, &lv->segments) {
			seg = lvm_list_item(segh, struct lv_segment);
			if (seg->area[0].type != AREA_PV)
				continue;
			if (seg->area[0].u.pv.pv->dev != dev)

	return NULL;
}

struct lvm_list *lvs_using_lv(struct cmd_context *cmd, struct volume_group *vg,
			  struct logical_volume *lv)
{
	struct lvm_list *lvh, *segh, *lvs;
	struct logical_volume *lv1;
	struct lv_list *lvl;
	struct lv_segment *seg;

		return NULL;
	}

	lvm_list_init(lvs);

	/* Loop through all LVs except the one supplied */
	lvm_list_iterate(lvh, &vg->lvs) {
		lv1 = lvm_list_item(lvh, struct lv_list)->lv;
		if (lv1 == lv)
			continue;

		lvm_list_iterate(segh, &lv1->segments) {
			seg = lvm_list_item(segh, struct lv_segment);
			for (s = 0; s < seg->area_count; s++) {
				if (seg->area[s].type != AREA_LV ||
				    seg->area[s].u.lv.lv != lv)

					return NULL;
				}
				lvl->lv = lv1;
				lvm_list_add(lvs, &lvl->list);
				goto next_lv;
			}
		}

float pvmove_percent(struct logical_volume *lv_mirr)
{
	uint32_t numerator = 0u, denominator = 0u;
	struct lvm_list *segh;
	struct lv_segment *seg;

	lvm_list_iterate(segh, &lv_mirr->segments) {
		seg = lvm_list_item(segh, struct lv_segment);
		if (!(seg->status & PVMOVE))
			continue;





#include "pv_map.h"
#include "hash.h"

static int _create_maps(struct pool *mem, struct lvm_list *pvs, struct lvm_list *maps)
{
	struct lvm_list *tmp;
	struct pv_map *pvm;
	struct pv_list *pvl;

	lvm_list_iterate(tmp, pvs) {
		pvl = lvm_list_item(tmp, struct pv_list);

		if (!(pvl->pv->status & ALLOCATABLE_PV))
			continue;

		if (!(pvm = pool_zalloc(mem, sizeof(*pvm)))) {
			STACK;
			return 0;
		}

		pvm->pvl = pvl;
		if (!(pvm->allocated_extents =
		      bitset_create(mem, pvl->pv->pe_count))) {
			STACK;
			return 0;
		}

		lvm_list_init(&pvm->areas);
		lvm_list_add(maps, &pvm->list);
	}

	return 1;

	return 1;
}

static int _fill_bitsets(struct volume_group *vg, struct lvm_list *maps)
{
	struct lvm_list *lvh, *pvmh, *segh;
	struct logical_volume *lv;
	struct pv_map *pvm;
	uint32_t s, pe;

	}

	/* populate the hash table */
	lvm_list_iterate(pvmh, maps) {
		pvm = lvm_list_item(pvmh, struct pv_map);
		if (!hash_insert(hash, dev_name(pvm->pvl->pv->dev), pvm)) {
			STACK;
			goto out;
		}
	}

	/* iterate through all the lv's setting bit's for used pe's */
	lvm_list_iterate(lvh, &vg->lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;

		lvm_list_iterate(segh, &lv->segments) {
			seg = lvm_list_item(segh, struct lv_segment);

			for (s = 0u; s < seg->area_count; s++) {
				for (pe = 0u; pe < seg->area_len; pe++) {

							 seg->area[s].u.pv.pv,
							 seg->area[s].u.pv.pe
							 + pe)) {
						STACK;
						goto out;
					}
				}

/*
 * Areas are maintained in size order.
 */
static void _insert_area(struct lvm_list *head, struct pv_area *a)
{
	struct lvm_list *pvah;
	struct pv_area *pva = NULL;

	if (lvm_list_empty(head)) {
		lvm_list_add(head, &a->list);
		return;
	}

	lvm_list_iterate(pvah, head) {
		pva = lvm_list_item(pvah, struct pv_area);

		if (pva->count < a->count)
			break;
	}

	lvm_list_add_h(&pva->list, &a->list);
}

static int _create_single_area(struct pool *mem, struct pv_map *pvm,

		e++;

	if (!(pva = pool_zalloc(mem, sizeof(*pva)))) {
		STACK;
		return 0;
	}


	pe = start;
	while (pe <= end)
		if (!_create_single_area(mem, pvm, end, &pe)) {
			STACK;
			return 0;
		}



static int _create_allocatable_areas(struct pool *mem, struct pv_map *pvm)
{
	struct lvm_list *alloc_areas, *aah;
	struct alloc_area *aa;

	alloc_areas = pvm->pvl->alloc_areas;

	if (alloc_areas) {
		lvm_list_iterate(aah, alloc_areas) {
			aa = lvm_list_item(aah, struct alloc_area);
			if (!_create_areas(mem, pvm, aa->start, aa->count)) {
				STACK;
				return 0;
			}


		/* Use whole PV */
		if (!_create_areas(mem, pvm, UINT32_C(0),
				   pvm->pvl->pv->pe_count)) {
			STACK;
			return 0;
		}
	}

	return 1;
}

static int _create_all_areas(struct pool *mem, struct lvm_list *maps,
			     struct lvm_list *pvs)
{
	struct lvm_list *tmp;
	struct pv_map *pvm;

	lvm_list_iterate(tmp, maps) {
		pvm = lvm_list_item(tmp, struct pv_map);

		if (!_create_allocatable_areas(mem, pvm)) {
			STACK;
			return 0;
		}
	}

	return 1;
}

struct lvm_list *create_pv_maps(struct pool *mem, struct volume_group *vg,
			    struct lvm_list *pvs)
{
	struct lvm_list *maps = pool_zalloc(mem, sizeof(*maps));

	if (!maps) {
		STACK;
		return NULL;
	}

	lvm_list_init(maps);

	if (!_create_maps(mem, pvs, maps)) {
		log_error("Couldn't create physical volume maps in %s",


void consume_pv_area(struct pv_area *pva, uint32_t to_go)
{
	lvm_list_del(&pva->list);

	assert(to_go <= pva->count);





	uint32_t start;
	uint32_t count;

	struct lvm_list list;
};

struct pv_map {
	struct pv_list *pvl;
	bitset_t allocated_extents;
	struct lvm_list areas;

	struct lvm_list list;
};

struct lvm_list *create_pv_maps(struct pool *mem,
			    struct volume_group *vg, struct lvm_list *pvs);

void consume_pv_area(struct pv_area *area, uint32_t to_go);






int lv_is_origin(const struct logical_volume *lv)
{
	struct lvm_list *slh;
	struct snapshot *s;

	lvm_list_iterate(slh, &lv->vg->snapshots) {
		s = lvm_list_item(slh, struct snapshot_list)->snapshot;
		if (s->origin == lv)
			return 1;
	}


int lv_is_cow(const struct logical_volume *lv)
{
	struct lvm_list *slh;
	struct snapshot *s;

	lvm_list_iterate(slh, &lv->vg->snapshots) {
		s = lvm_list_item(slh, struct snapshot_list)->snapshot;
		if (s->cow == lv)
			return 1;
	}


struct snapshot *find_origin(const struct logical_volume *lv)
{
	struct lvm_list *slh;
	struct snapshot *s;

	lvm_list_iterate(slh, &lv->vg->snapshots) {
		s = lvm_list_item(slh, struct snapshot_list)->snapshot;
		if (s->origin == lv)
			return s;
	}


struct snapshot *find_cow(const struct logical_volume *lv)
{
	struct lvm_list *slh;
	struct snapshot *s;

	lvm_list_iterate(slh, &lv->vg->snapshots) {
		s = lvm_list_item(slh, struct snapshot_list)->snapshot;
		if (s->cow == lv)
			return s;
	}

	return NULL;
}

struct lvm_list *find_snapshots(const struct logical_volume *lv)
{
	struct lvm_list *slh;
	struct lvm_list *snaplist;
	struct snapshot *s;
	struct snapshot_list *newsl;
	struct pool *mem = lv->vg->cmd->mem;

		return NULL;
	}

	lvm_list_init(snaplist);

	lvm_list_iterate(slh, &lv->vg->snapshots) {
		s = lvm_list_item(slh, struct snapshot_list)->snapshot;
		if (!(s->origin == lv))
			continue;
		if (!(newsl = pool_alloc(mem, sizeof(*newsl)))) {

			return NULL;
		}
		newsl->snapshot = s;
		lvm_list_add(snaplist, &newsl->list);
	}

	return snaplist;

	}

	if (!(s = pool_alloc(mem, sizeof(*s)))) {
		STACK;
		return 0;
	}


	}

	if (!(sl = pool_alloc(mem, sizeof(*sl)))) {
		STACK;
		pool_free(mem, s);
		return 0;
	}

	cow->status &= ~VISIBLE_LV;
	sl->snapshot = s;
	lvm_list_add(&origin->vg->snapshots, &sl->list);
	origin->vg->snapshot_count++;

	return 1;


int vg_remove_snapshot(struct volume_group *vg, struct logical_volume *cow)
{
	struct lvm_list *slh;
	struct snapshot_list *sl;

	lvm_list_iterate(slh, &vg->snapshots) {
		sl = lvm_list_item(slh, struct snapshot_list);

		if (sl->snapshot->cow == cow) {
			lvm_list_del(slh);
			vg->snapshot_count--;
			return 1;
		}




	struct state_queue *r = pool_alloc(mem, sizeof(*r));

	if (!r) {
		STACK;
		return NULL;
	}


	bitset_t bs = bitset_create(m->scratch, m->num_nodes), dfa_bits;

	if (!tt) {
		STACK;
		return 0;
	}

	if (!bs) {
		STACK;
		return 0;
	}


	struct matcher *m;

	if (!scratch) {
		STACK;
		return NULL;
	}

	if (!(m = pool_alloc(mem, sizeof(*m)))) {
		STACK;
		return NULL;
	}


	ptr = all = pool_alloc(scratch, len + 1);

	if (!all) {
		STACK;
		goto bad;
	}


	m->nodes = pool_alloc(scratch, sizeof(*m->nodes) * m->num_nodes);

	if (!m->nodes) {
		STACK;
		goto bad;
	}





	switch (ps->type) {
	case 0:
		if (!(n = _node(ps->mem, CHARSET, NULL, NULL))) {
			STACK;
			return NULL;
		}


		}

		if (!n) {
			STACK;
			return NULL;
		}


		return l;

	if (!(n = _node(ps->mem, CAT, l, r)))
		STACK;

	return n;
}

	}

	if (!(n = _node(ps->mem, OR, l, r)))
		STACK;

	return n;
}

	struct parse_sp *ps = pool_zalloc(mem, sizeof(*ps));

	if (!ps) {
		STACK;
		return NULL;
	}


Lines 88-94 Link Here

(-)LVM2.2.00.15.orig/lib/regex/ttree.c (-2 / +2 lines)
88		88
89	while (count--) {	89	while (count--) {
90	if (!(*c = _node(tt->mem, k))) {	90	if (!(*c = _node(tt->mem, k))) {
91	stack;	91	STACK;
92	return 0;	92	return 0;
93	}	93	}
94		94
Lines 108-114 Link Here
108	struct ttree *tt;	108	struct ttree *tt;
109		109
110	if (!(tt = pool_zalloc(mem, sizeof(*tt)))) {	110	if (!(tt = pool_zalloc(mem, sizeof(*tt)))) {
111	stack;	111	STACK;
112	return NULL;	112	return NULL;
113	}	113	}
114		114




	uint32_t keys_count;

	/* Ordered list of fields needed for this report */
	struct lvm_list field_props;

	/* Rows of report data */
	struct lvm_list rows;
};

/* 

#define FLD_DESCENDING	0x00000080

struct field_properties {
	struct lvm_list list;
	uint32_t field_num;
	uint32_t sort_posn;
	int width;

 * Report data
 */
struct field {
	struct lvm_list list;
	struct field_properties *props;

	const char *report_string;	/* Formatted ready for display */

};

struct row {
	struct lvm_list list;
	struct report_handle *rh;
	struct lvm_list fields;	/* Fields in display order */
	struct field *(*sort_fields)[];	/* Fields in sort order */
};


static int _tags_disp(struct report_handle *rh, struct field *field,
		      const void *data)
{
	const struct lvm_list *tags = (const struct lvm_list *) data;
	struct str_list *sl;

	if (!pool_begin_object(rh->mem, 256)) {

		return 0;
	}

	lvm_list_iterate_items(sl, tags) {
		if (!pool_grow_object(rh->mem, sl->str, strlen(sl->str)) ||
		    (sl->list.n != tags && !pool_grow_object(rh->mem, ",", 1))) {
			log_error("pool_grow_object failed");

{
	const struct logical_volume *lv = (const struct logical_volume *) data;
	const char *name;
	struct lvm_list *segh;
	struct lv_segment *seg;

	lvm_list_iterate(segh, &lv->segments) {
		seg = lvm_list_item(segh, struct lv_segment);
		if (!(seg->status & PVMOVE))
			continue;
		name = dev_name(seg->area[0].u.pv.pv->dev);

	uint64_t *sortval;

	if (!*(disp = display_size(rh->cmd, (uint64_t) size / 2, SIZE_UNIT))) {
		STACK;
		return 0;
	}


	uint64_t *sortval;

	if (!*(disp = display_size(rh->cmd, size / 2, SIZE_UNIT))) {
		STACK;
		return 0;
	}


	}

	if (!id_write_format((const struct id *) data, repstr, 40)) {
		STACK;
		return 0;
	}


	const struct logical_volume *lv = (const struct logical_volume *) data;
	uint32_t count;

	count = lvm_list_size(&lv->segments);

	return _uint32_disp(rh, field, &count);
}

			    && !strncmp(field, "snap_percent", len))
				fp->flags |= FLD_HIDDEN;

			lvm_list_add(&rh->field_props, &fp->list);
			return 1;
		}
	}

static int _add_sort_key(struct report_handle *rh, uint32_t field_num,
			 uint32_t flags)
{
	struct lvm_list *fh;
	struct field_properties *fp, *found = NULL;

	lvm_list_iterate(fh, &rh->field_props) {
		fp = lvm_list_item(fh, struct field_properties);

		if (fp->field_num == field_num) {
			found = fp;

		found->width = _fields[field_num].width;
		found->flags = _fields[field_num].flags | FLD_HIDDEN;

		lvm_list_add(&rh->field_props, &found->list);
	}

	if (found->flags & FLD_SORT_KEY) {

	if (headings)
		rh->flags |= RH_HEADINGS;

	lvm_list_init(&rh->field_props);
	lvm_list_init(&rh->rows);

	switch (rh->type) {
	case PVS:

		  struct lv_segment *seg)
{
	struct report_handle *rh = handle;
	struct lvm_list *fh;
	struct field_properties *fp;
	struct row *row;
	struct field *field;

		return 0;
	}

	lvm_list_init(&row->fields);
	lvm_list_add(&rh->rows, &row->list);

	/* For each field to be displayed, call its report_fn */
	lvm_list_iterate(fh, &rh->field_props) {
		fp = lvm_list_item(fh, struct field_properties);

		if (!(field = pool_zalloc(rh->mem, sizeof(*field)))) {
			log_error("struct field allocation failed");

		    (field->props->flags & FLD_SORT_KEY)) {
			(*row->sort_fields)[field->props->sort_posn] = field;
		}
		lvm_list_add(&row->fields, &field->list);
	}

	if (!(rh->flags & RH_BUFFERED))

static int _report_headings(void *handle)
{
	struct report_handle *rh = handle;
	struct lvm_list *fh;
	struct field_properties *fp;

	if (rh->flags & RH_HEADINGS_PRINTED)

		goto out;

	/* First heading line */
	lvm_list_iterate(fh, &rh->field_props) {
		fp = lvm_list_item(fh, struct field_properties);
		if (fp->flags & FLD_HIDDEN)
			continue;
		if (rh->flags & RH_ALIGNED)

			       _fields[fp->field_num].heading);
		else
			printf("%s", _fields[fp->field_num].heading);
		if (!lvm_list_end(&rh->field_props, fh))
			printf("%s", rh->separator);
	}
	printf("\n");

static int _sort_rows(struct report_handle *rh)
{
	struct row *(*rows)[];
	struct lvm_list *rowh;
	uint32_t count = 0;
	struct row *row;

	if (!(rows = pool_alloc(rh->mem, sizeof(**rows) *
				lvm_list_size(&rh->rows)))) {
		log_error("sort array allocation failed");
		return 0;
	}

	lvm_list_iterate(rowh, &rh->rows) {
		row = lvm_list_item(rowh, struct row);
		(*rows)[count++] = row;
	}

	qsort(rows, count, sizeof(**rows), _row_compare);

	lvm_list_init(&rh->rows);
	while (count--)
		lvm_list_add_h(&rh->rows, &(*rows)[count]->list);

	return 1;
}

int report_output(void *handle)
{
	struct report_handle *rh = handle;
	struct lvm_list *fh, *rowh, *ftmp, *rtmp;
	struct row *row = NULL;
	struct field *field;

	if (lvm_list_empty(&rh->rows))
		return 1;

	/* Sort rows */

		_report_headings(rh);

	/* Print and clear buffer */
	lvm_list_iterate_safe(rowh, rtmp, &rh->rows) {
		row = lvm_list_item(rowh, struct row);
		lvm_list_iterate_safe(fh, ftmp, &row->fields) {
			field = lvm_list_item(fh, struct field);
			if (field->props->flags & FLD_HIDDEN)
				continue;
			if (!(rh->flags & RH_ALIGNED))

				printf("%*.*s", field->props->width,
				       field->props->width,
				       field->report_string);
			if (!lvm_list_end(&row->fields, fh))
				printf("%s", rh->separator);
			lvm_list_del(&field->list);
		}
		printf("\n");
		lvm_list_del(&row->list);
	}

	if (row)

Lines 24-30 Link Here

(-)LVM2.2.00.15.orig/test/device/dev_cache_t.c (-3 / +3 lines)
24	int i;	24	int i;
25	struct device *dev;	25	struct device *dev;
26	struct dev_iter *iter;	26	struct dev_iter *iter;
27	struct list_head *tmp;	27	struct lvm_list_head *tmp;
28	struct str_list *sl;	28	struct str_list *sl;
29		29
30	if (argc < 2) {	30	if (argc < 2) {
Lines 55-62 Link Here
55	while ((dev = dev_iter_get(iter))) {	55	while ((dev = dev_iter_get(iter))) {
56	printf("%s", dev->name);	56	printf("%s", dev->name);
57		57
58	list_for_each(tmp, &dev->aliases) {	58	lvm_list_for_each(tmp, &dev->aliases) {
59	sl = list_entry(tmp, struct str_list, list);	59	sl = lvm_list_entry(tmp, struct str_list, list);
60	printf(", %s", sl->str);	60	printf(", %s", sl->str);
61	}	61	}
62	printf("\n");	62	printf("\n");

Lines 25-31 Link Here

(-)LVM2.2.00.15.orig/test/format1/get_pvs_t.c (-3 / +3 lines)
25	int main(int argc, char **argv)	25	int main(int argc, char **argv)
26	{	26	{
27	struct io_space *ios;	27	struct io_space *ios;
28	struct list_head pvs, tmp;	28	struct lvm_list_head pvs, tmp;
29	struct pool *mem;	29	struct pool *mem;
30		30
31	init_log(stderr);	31	init_log(stderr);
Lines 60-67 Link Here
60	exit(1);	60	exit(1);
61	}	61	}
62		62
63	list_for_each(tmp, pvs) {	63	lvm_list_for_each(tmp, pvs) {
64	struct pv_list *pvl = list_entry(tmp, struct pv_list, list);	64	struct pv_list *pvl = lvm_list_entry(tmp, struct pv_list, list);
65	dump_pv(&pvl->pv, stdout);	65	dump_pv(&pvl->pv, stdout);
66	}	66	}
67		67

Lines 25-31 Link Here

(-)LVM2.2.00.15.orig/test/format1/get_vgs_t.c (-1 / +1 lines)
25	int main(int argc, char **argv)	25	int main(int argc, char **argv)
26	{	26	{
27	struct io_space *ios;	27	struct io_space *ios;
28	struct list_head *vgs;	28	struct lvm_list_head *vgs;
29	struct pool *mem;	29	struct pool *mem;
30		30
31	init_log(stderr);	31	init_log(stderr);





void dump_vg(struct volume_group *vg, FILE *fp)
{
	struct lvm_list_head *tmp;

	fprintf(fp, "volume_group {\n");
	fprintf(fp, "\tname = '%s'\n", vg->name);

	fprintf(fp, "\tlv_count = %d\n", vg->lv_count);
	fprintf(fp, "}\n\n");

	lvm_list_for_each(tmp, &vg->pvs) {
		struct pv_list *pvl = lvm_list_entry(tmp, struct pv_list, list);
		dump_pv(&pvl->pv, fp);
	}

	lvm_list_for_each(tmp, &vg->lvs) {
		struct lv_list *lvl = lvm_list_entry(tmp, struct lv_list, list);
		dump_lv(&lvl->lv, fp);
	}
}

void dump_vg_names(struct lvm_list_head *vg_names, FILE *fp)
{
	struct lvm_list_head *tmp;
	struct name_list *nl;

	lvm_list_for_each(tmp, vg_names) {
		nl = lvm_list_entry(tmp, struct name_list, list);
		fprintf(fp, "%s\n", nl->name);
	}
}




	char *buffer;

	if (!(buffer = pool_zalloc(mem, strlen(line) + 32))) {
		STACK;
		return NULL;
	}

	if (snprintf(buffer, len,
		     "Created %s executing '%s'",
		     before ? "*before*" : "*after*", line) < 0) {
		STACK;
		return NULL;
	}


	char *desc;

	if (!(desc = _build_desc(vg->cmd->mem, vg->cmd->cmd_line, 1))) {
		STACK;
		return 0;
	}


	char *desc;

	if (!(desc = _build_desc(vg->cmd->mem, vg->cmd->cmd_line, 0))) {
		STACK;
		return 0;
	}


		return NULL;
	}

	lvm_list_iterate_items(mda, &tf->metadata_areas) {
		if (!(vg = mda->ops->vg_read(tf, vg_name, mda)))
			STACK;
		break;
	}


	}

	/* Add any metadata areas on the PVs */
	lvm_list_iterate_items(pvl, &vg->pvs) {
		pv = pvl->pv;
		if (!(info = info_from_pvid(pv->dev->pvid))) {
			log_error("PV %s missing from cache",

	}

	if (!vg_write(vg) || !vg_commit(vg)) {
		STACK;
		return 0;
	}


	 * Read in the volume group from the text file.
	 */
	if (!(vg = backup_read_vg(cmd, vg_name, file))) {
		STACK;
		return 0;
	}


	}

	/* Write and commit the metadata area */
	lvm_list_iterate_items(mda, &tf->metadata_areas) {
		if (!(r = mda->ops->vg_write(tf, vg, mda))) {
			STACK;
			continue;
		}
		if (mda->ops->vg_commit &&
		    !(r = mda->ops->vg_commit(tf, vg, mda))) {
			STACK;
		}
	}






	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
	if (!vg_write(lv->vg)) {
		STACK;
		return 0;
	}



	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
	if (!vg_write(lv->vg)) {
		STACK;
		return 0;
	}



	/* No need to suspend LV for this change */
	if (!vg_commit(lv->vg)) {
		STACK;
		return 0;
	}



	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
	if (!vg_write(lv->vg)) {
		STACK;
		return 0;
	}



	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
	if (!vg_write(lv->vg)) {
		STACK;
		return 0;
	}



	log_very_verbose("Updating logical volume \"%s\" on disk(s)", lv->name);
	if (!vg_write(lv->vg)) {
		STACK;
		return 0;
	}



	/* No need to suspend LV for this change */
	if (!vg_commit(lv->vg)) {
		STACK;
		return 0;
	}





	alloc_policy_t alloc = ALLOC_DEFAULT;
	struct volume_group *vg;
	struct logical_volume *lv, *org = NULL;
	struct lvm_list *pvh;
	const char *tag;
	int consistent = 1;


	if (lp->pv_count) {
		if (!(pvh = create_pv_list(cmd->mem, vg,
					   lp->pv_count, lp->pvs))) {
			STACK;
			return 0;
		}
	} else


	/* store vg on disk(s) */
	if (!vg_write(vg)) {
		STACK;
		return 0;
	}

	backup(vg);

	if (!vg_commit(vg)) {
		STACK;
		return 0;
	}


	}

	if (!_lvcreate(cmd, &lp)) {
		STACK;
		goto out;
	}


Lines 91-97 Link Here

(-)LVM2.2.00.15.orig/tools/lvmcmdline.c (-2 / +2 lines)
91		91
92	format = a->value;	92	format = a->value;
93		93
94	list_iterate_items(fmt, &cmd->formats) {	94	lvm_list_iterate_items(fmt, &cmd->formats) {
95	if (!strcasecmp(fmt->name, format) \|\|	95	if (!strcasecmp(fmt->name, format) \|\|
96	!strcasecmp(fmt->name + 3, format) \|\|	96	!strcasecmp(fmt->name + 3, format) \|\|
97	(fmt->alias && !strcasecmp(fmt->alias, format))) {	97	(fmt->alias && !strcasecmp(fmt->alias, format))) {
Lines 911-917 Link Here
911	struct cmd_context *cmd;	911	struct cmd_context *cmd;
912		912
913	if (!(cmd = create_toolcontext(&the_args[0]))) {	913	if (!(cmd = create_toolcontext(&the_args[0]))) {
914	stack;	914	STACK;
915	return NULL;	915	return NULL;
916	}	916	}
917		917

Lines 71-77 Link Here

(-)LVM2.2.00.15.orig/tools/lvremove.c (-1 / +1 lines)
71	if (lv_is_cow(lv)) {	71	if (lv_is_cow(lv)) {
72	log_verbose("Removing snapshot %s", lv->name);	72	log_verbose("Removing snapshot %s", lv->name);
73	if (!vg_remove_snapshot(lv->vg, lv)) {	73	if (!vg_remove_snapshot(lv->vg, lv)) {
74	stack;	74	STACK;
75	return ECMD_FAILED;	75	return ECMD_FAILED;
76	}	76	}
77	}	77	}




	}

	if (!archive(lv->vg)) {
		STACK;
		goto error;
	}



	log_verbose("Writing out updated volume group");
	if (!vg_write(vg)) {
		STACK;
		goto error;
	}



	if (!lock_vol(cmd, lv->lvid.s, LCK_LV_SUSPEND | LCK_HOLD |
		      LCK_NONBLOCK)) {
		STACK;
		goto error;
	}

	if (!vg_commit(vg)) {
		STACK;
		unlock_lv(cmd, lv->lvid.s);
		goto error;
	}




	const char *vg_name;
	char *st, *lock_lvid;
	const char *cmd_name;
	struct lvm_list *pvh;
	struct lv_list *lvl;
	int opt = 0;
	int consistent = 1;


	/* If extending, find stripes, stripesize & size of last segment */
	if (extents > lv->le_count && !(stripes == 1 || (stripes > 1 && ssize))) {
		lvm_list_iterate_items(seg, &lv->segments) {
			if (seg->type != SEG_STRIPED)
				continue;


			log_error("Ignoring stripes and stripesize arguments "
				  "when reducing");

		lvm_list_iterate_items(seg, &lv->segments) {
			seg_extents = seg->len;

			if (seg->type == SEG_STRIPED) {

	if (resize == LV_EXTEND) {
		if (!(pvh = argc ? create_pv_list(cmd->mem, vg, argc - opt,
						  argv + opt) : &vg->pvs)) {
			STACK;
			goto error;
		}



	/* store vg on disk(s) */
	if (!vg_write(vg)) {
		STACK;
		goto error;
	}


	}

	if (!vg_commit(vg)) {
		STACK;
		unlock_lv(cmd, lock_lvid);
		goto error;
	}




{
	struct volume_group *vg = NULL;
	struct pv_list *pvl;
	struct lvm_list mdas;
	uint64_t sector;

	const char *pv_name = dev_name(pv->dev);

	char *pv_name;

	struct pv_list *pvl;
	struct lvm_list *pvslist;
	struct lvm_list mdas;

	lvm_list_init(&mdas);

	if (arg_count(cmd, allocatable_ARG) + arg_count(cmd, addtag_ARG) +
	    arg_count(cmd, deltag_ARG) + arg_count(cmd, uuid_ARG) != 1) {

			return ECMD_FAILED;
		}

		lvm_list_iterate_items(pvl, pvslist) {
			total++;
			done += _pvchange_single(cmd, pvl->pv, NULL);
		}

Lines 76-82 Link Here

(-)LVM2.2.00.15.orig/tools/pvcreate.c (-2 / +2 lines)
76	const char *uuid = NULL;	76	const char *uuid = NULL;
77	uint64_t size = 0;	77	uint64_t size = 0;
78	struct device *dev;	78	struct device *dev;
79	struct list mdas;	79	struct lvm_list mdas;
80	int pvmetadatacopies;	80	int pvmetadatacopies;
81	uint64_t pvmetadatasize;	81	uint64_t pvmetadatasize;
82	struct volume_group *vg;	82	struct volume_group *vg;
Lines 153-159 Link Here
153	goto error;	153	goto error;
154	}	154	}
155		155
156	list_init(&mdas);	156	lvm_list_init(&mdas);
157	if (!(pv = pv_create(cmd->fmt, dev, idp, size, pe_start,	157	if (!(pv = pv_create(cmd->fmt, dev, idp, size, pe_start,
158	extent_count, extent_size,	158	extent_count, extent_size,
159	pvmetadatacopies, pvmetadatasize, &mdas))) {	159	pvmetadatacopies, pvmetadatasize, &mdas))) {




}

/* Create list of PVs for allocation of replacement extents */
static struct lvm_list *_get_allocatable_pvs(struct cmd_context *cmd, int argc,
					 char **argv, struct volume_group *vg,
					 struct physical_volume *pv)
{
	struct lvm_list *allocatable_pvs, *pvht, *pvh;
	struct pv_list *pvl;

	if (argc) {
		if (!(allocatable_pvs = create_pv_list(cmd->mem, vg, argc,
						       argv))) {
			STACK;
			return NULL;
		}
	} else {
		if (!(allocatable_pvs = clone_pv_list(cmd->mem, &vg->pvs))) {
			STACK;
			return NULL;
		}
	}

	/* Don't allocate onto the PV we're clearing! */
	/* Remove PV if full */
	lvm_list_iterate_safe(pvh, pvht, allocatable_pvs) {
		pvl = lvm_list_item(pvh, struct pv_list);
		if ((pvl->pv->dev == pv->dev) ||
		    (pvl->pv->pe_count == pvl->pv->pe_alloc_count))
			    lvm_list_del(&pvl->list);
	}

	if (lvm_list_empty(allocatable_pvs)) {
		log_error("No extents available for allocation");
		return NULL;
	}

						struct volume_group *vg,
						struct physical_volume *pv,
						const char *lv_name,
						struct lvm_list *allocatable_pvs,
						struct lvm_list **lvs_changed)
{
	struct logical_volume *lv_mirr, *lv;
	struct lv_list *lvl;

		return NULL;
	}

	lvm_list_init(*lvs_changed);

	/* Find segments to be moved and set up mirrors */
	lvm_list_iterate_items(lvl, &vg->lvs) {
		lv = lvl->lv;
		if ((lv == lv_mirr) || (lv_name && strcmp(lv->name, lv_name)))
			continue;

		}
		if (!insert_pvmove_mirrors(cmd, lv_mirr, pv, lv,
					   allocatable_pvs, *lvs_changed)) {
			STACK;
			return NULL;
		}
	}


static int _update_metadata(struct cmd_context *cmd, struct volume_group *vg,
			    struct logical_volume *lv_mirr,
			    struct lvm_list *lvs_changed, int first_time)
{
	log_verbose("Updating volume group metadata");
	if (!vg_write(vg)) {

	backup(vg);

	if (!lock_lvs(cmd, lvs_changed, LCK_LV_SUSPEND | LCK_HOLD)) {
		STACK;
		return 0;
	}

	if (!first_time) {
		if (!lock_vol(cmd, lv_mirr->lvid.s, LCK_LV_SUSPEND | LCK_HOLD)) {
			STACK;
			unlock_lvs(cmd, lvs_changed);
			vg_revert(vg);
			return 0;

{
	const char *lv_name = NULL;
	struct volume_group *vg;
	struct lvm_list *allocatable_pvs;
	struct lvm_list *lvs_changed;
	struct physical_volume *pv;
	struct logical_volume *lv_mirr;
	int first_time = 1;

	/* Find PV (in VG) */
	if (!(pv = _find_pv_by_name(cmd, pv_name))) {
		STACK;
		return EINVALID_CMD_LINE;
	}

	if (arg_count(cmd, name_ARG)) {
		if (!(lv_name = _extract_lvname(cmd, pv->vg_name,
						arg_value(cmd, name_ARG)))) {
			STACK;
			return EINVALID_CMD_LINE;
		}
	}

	log_verbose("Finding volume group \"%s\"", pv->vg_name);

	if (!(vg = _get_vg(cmd, pv->vg_name))) {
		STACK;
		return ECMD_FAILED;
	}



		if (!(allocatable_pvs = _get_allocatable_pvs(cmd, argc, argv,
							     vg, pv))) {
			STACK;
			unlock_vg(cmd, pv->vg_name);
			return ECMD_FAILED;
		}

		if (!archive(vg)) {
			unlock_vg(cmd, pv->vg_name);
			STACK;
			return ECMD_FAILED;
		}

		if (!(lv_mirr = _set_up_pvmove_lv(cmd, vg, pv, lv_name,
						  allocatable_pvs,
						  &lvs_changed))) {
			STACK;
			unlock_vg(cmd, pv->vg_name);
			return ECMD_FAILED;
		}
	}

	if (!lock_lvs(cmd, lvs_changed, LCK_LV_ACTIVATE)) {
		STACK;
		unlock_vg(cmd, pv->vg_name);
		return ECMD_FAILED;
	}

	if (first_time) {
		if (!_update_metadata
		    (cmd, vg, lv_mirr, lvs_changed, first_time)) {
			STACK;
			unlock_vg(cmd, pv->vg_name);
			return ECMD_FAILED;
		}


static int _finish_pvmove(struct cmd_context *cmd, struct volume_group *vg,
			  struct logical_volume *lv_mirr,
			  struct lvm_list *lvs_changed)
{
	int r = 1;


				const char *pv_name, struct pvmove_parms *parms,
				int *finished)
{
	struct lvm_list *lvs_changed;
	float segment_percent = 0.0, overall_percent = 0.0;
	uint32_t event_nr = 0;


		return ECMD_FAILED;
	}

	lvm_list_iterate_items(lvl, &vg->lvs) {
		lv_mirr = lvl->lv;
		if (!(lv_mirr->status & PVMOVE))
			continue;

		if (!arg_count(cmd, abort_ARG) &&
		    (ret = _set_up_pvmove(cmd, pv_name, argc, argv)) !=
		     ECMD_PROCESSED) {
			STACK;
			return ret;
		}
	}





	if (arg_count(cmd, uuid_ARG)) {
		if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
			STACK;
			return;
		}


	int new_pvs_found = 0;
	int pvs_found = 0;

	struct lvm_list *pvslist;
	struct pv_list *pvl;
	struct physical_volume *pv;


		return ECMD_FAILED;

	/* eliminate exported/new if required */
	lvm_list_iterate_items(pvl, pvslist) {
		pv = pvl->pv;

		if ((arg_count(cmd, exported_ARG)
		     && !(pv->status & EXPORTED_VG))
		    || (arg_count(cmd, novolumegroup_ARG) && (*pv->vg_name))) {
			lvm_list_del(&pvl->list);
			continue;
		}



	/* find maximum pv name length */
	pv_max_name_len = vg_max_name_len = 0;
	lvm_list_iterate_items(pvl, pvslist) {
		pv = pvl->pv;
		len = strlen(dev_name(pv->dev));
		if (pv_max_name_len < len)

	pv_max_name_len += 2;
	vg_max_name_len += 2;

	lvm_list_iterate_items(pvl, pvslist)
	    _pvscan_display_single(cmd, pvl->pv, NULL);

	if (!pvs_found) {




#include <sys/stat.h>

int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
			  struct lvm_list *arg_lvnames, struct lvm_list *tags,
			  void *handle,
			  int (*process_single) (struct cmd_context * cmd,
						 struct logical_volume * lv,

		return ECMD_FAILED;
	}

	if (tags && !lvm_list_empty(tags))
		tags_supplied = 1;

	if (arg_lvnames && !lvm_list_empty(arg_lvnames))
		lvargs_supplied = 1;

	/* Process all LVs in this VG if no restrictions given */

	    str_list_match_list(tags, &vg->tags))
		process_all = 1;

	lvm_list_iterate_items(lvl, &vg->lvs) {
		/* Should we process this LV? */
		if (process_all)
			process_lv = 1;

	int ret = 0;
	int consistent;

	struct lvm_list *slh, *tags_arg;
	struct lvm_list *vgnames;		/* VGs to process */
	struct str_list *sll;
	struct volume_group *vg;
	struct lvm_list tags, lvnames;
	struct lvm_list arg_lvnames;	/* Cmdline vgname or vgname/lvname */
	char *vglv;
	size_t vglv_sz;

	const char *vgname;

	lvm_list_init(&tags);
	lvm_list_init(&arg_lvnames);

	if (argc) {
		struct lvm_list arg_vgnames;

		log_verbose("Using logical volume(s) on command line");
		lvm_list_init(&arg_vgnames);

		for (; opt < argc; opt++) {
			const char *lv_name = argv[opt];

		vgnames = &arg_vgnames;
	} 

	if (!argc || !lvm_list_empty(&tags)) {
		log_verbose("Finding all logical volumes");
		if (!(vgnames = get_vgs(cmd, 0)) || lvm_list_empty(vgnames)) {
			log_error("No volume groups found");
			return ECMD_FAILED;
		}
	}

	lvm_list_iterate(slh, vgnames) {
		vgname = lvm_list_item(slh, struct str_list)->str;
		if (!vgname || !*vgname)
			continue;	/* FIXME Unnecessary? */
		if (!lock_vol(cmd, vgname, lock_type)) {

		}

		tags_arg = &tags;
		lvm_list_init(&lvnames);	/* LVs to be processed in this VG */
		lvm_list_iterate_items(sll, &arg_lvnames) {
			const char *vg_name = sll->str;
			const char *lv_name = strchr(vg_name, '/');

			if ((!lv_name && !strcmp(vg_name, vgname))) {
				/* Process all LVs in this VG */
				tags_arg = NULL;
				lvm_list_init(&lvnames);
				break;
			} else if (!strncmp(vg_name, vgname, strlen(vgname)) &&
				   strlen(vgname) == lv_name - vg_name) {

	int ret_max = 0;
	int ret;

	lvm_list_iterate_items(seg, &lv->segments) {
		ret = process_single(cmd, seg, handle);
		if (ret > ret_max)
			ret_max = ret;

}

static int _process_one_vg(struct cmd_context *cmd, const char *vg_name,
			   struct lvm_list *tags, struct lvm_list *arg_vgnames,
			   int lock_type, int consistent, void *handle,
			   int ret_max,
			   int (*process_single) (struct cmd_context * cmd,

	log_verbose("Finding volume group \"%s\"", vg_name);
	vg = vg_read(cmd, vg_name, &consistent);

	if (!lvm_list_empty(tags)) {
		/* Only process if a tag matches or it's on arg_vgnames */
		if (!str_list_match_item(arg_vgnames, vg_name) &&
		    !str_list_match_list(tags, &vg->tags)) {

	int ret_max = 0;

	struct str_list *sl;
	struct lvm_list *vgnames;
	struct lvm_list arg_vgnames, tags;

	const char *vg_name;
	char *dev_dir = cmd->dev_dir;

	lvm_list_init(&tags);
	lvm_list_init(&arg_vgnames);

	if (argc) {
		log_verbose("Using volume group(s) on command line");

		vgnames = &arg_vgnames;
	}

	if (!argc || !lvm_list_empty(&tags)) {
		log_verbose("Finding all volume groups");
		if (!(vgnames = get_vgs(cmd, 0)) || lvm_list_empty(vgnames)) {
			log_error("No volume groups found");
			return ECMD_FAILED;
		}
	}

	lvm_list_iterate_items(sl, vgnames) {
		vg_name = sl->str;
		if (!vg_name || !*vg_name)
			continue;	/* FIXME Unnecessary? */

}

int process_each_pv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
			  struct lvm_list *tags, void *handle,
			  int (*process_single) (struct cmd_context * cmd,
						 struct volume_group * vg,
						 struct physical_volume * pv,

	int ret = 0;
	struct pv_list *pvl;

	lvm_list_iterate_items(pvl, &vg->pvs) {
		if (tags && !lvm_list_empty(tags) &&
		    !str_list_match_list(tags, &pvl->pv->tags))
			continue;
		if ((ret = process_single(cmd, vg, pvl->pv, handle)) > ret_max)


	struct pv_list *pvl;
	struct physical_volume *pv;
	struct lvm_list *pvslist, *vgnames;
	struct lvm_list tags;
	struct str_list *sll;
	char *tagname;
	int consistent = 1;

	lvm_list_init(&tags);

	if (argc) {
		log_verbose("Using physical volume(s) on command line");

			if (ret > ret_max)
				ret_max = ret;
		}
		if (!lvm_list_empty(&tags) && (vgnames = get_vgs(cmd, 0)) &&
		    !lvm_list_empty(vgnames)) {
			lvm_list_iterate_items(sll, vgnames) {
				vg = vg_read(cmd, sll->str, &consistent);
				if (!consistent)
					continue;

			if (!(pvslist = get_pvs(cmd)))
				return ECMD_FAILED;

			lvm_list_iterate_items(pvl, pvslist) {
				ret = process_single(cmd, NULL, pvl->pv,
						     handle);
				if (ret > ret_max)

	return pool_strdup(cmd->mem, vg_path);
}

static int _add_alloc_area(struct pool *mem, struct lvm_list *alloc_areas,
			   uint32_t start, uint32_t count)
{
	struct alloc_area *aa;

		  start, count);

	/* Ensure no overlap with existing areas */
	lvm_list_iterate_items(aa, alloc_areas) {
		if (((start < aa->start) && (start + count - 1 >= aa->start)) ||
		    ((start >= aa->start) &&
		     (aa->start + aa->count - 1) >= start)) {


	aa->start = start;
	aa->count = count;
	lvm_list_add(alloc_areas, &aa->list);

	return 1;
}

static int _parse_pes(struct pool *mem, char *c, struct lvm_list *alloc_areas,
		      uint32_t size)
{
	char *endptr;

	/* Default to whole PV */
	if (!c) {
		if (!_add_alloc_area(mem, alloc_areas, UINT32_C(0), size)) {
			STACK;
			return 0;
		}
		return 1;

		}

		if (!_add_alloc_area(mem, alloc_areas, start, end - start + 1)) {
			STACK;
			return 0;
		}


}

static void _create_pv_entry(struct pool *mem, struct pv_list *pvl,
			     char *colon, struct lvm_list *r)
{
	const char *pvname;
	struct pv_list *new_pvl;
	struct lvm_list *alloc_areas;

	pvname = dev_name(pvl->pv->dev);
	if (!(pvl->pv->status & ALLOCATABLE_PV)) {

		log_error("Allocation of alloc_areas list failed");
		return;
	}
	lvm_list_init(alloc_areas);

	/* Specify which physical extents may be used for allocation */
	if (!_parse_pes(mem, colon, alloc_areas, pvl->pv->pe_count)) {
		STACK;
		return;
	}
	new_pvl->alloc_areas = alloc_areas;

	lvm_list_add(r, &new_pvl->list);
}

struct lvm_list *create_pv_list(struct pool *mem,
			    struct volume_group *vg, int argc, char **argv)
{
	struct lvm_list *r;
	struct pv_list *pvl;
	struct lvm_list tags, arg_pvnames;
	const char *pvname = NULL; 
	char *colon, *tagname;
	int i;

		log_error("Allocation of list failed");
		return NULL;
	}
	lvm_list_init(r);

	lvm_list_init(&tags);
	lvm_list_init(&arg_pvnames);

	for (i = 0; i < argc; i++) {
		if (*argv[i] == '@') {

				log_error("Skipping invalid tag %s", tagname);
				continue;
			}
			lvm_list_iterate_items(pvl, &vg->pvs) {
				if (str_list_match_item(&pvl->pv->tags,
				    tagname)) {
					_create_pv_entry(mem, pvl, NULL, r);

		_create_pv_entry(mem, pvl, colon, r);
	}

	if (lvm_list_empty(r))
		log_error("No specified PVs have space available");

	return lvm_list_empty(r) ? NULL : r;
}




struct lvm_list *clone_pv_list(struct pool *mem, struct lvm_list *pvsl)
{
	struct lvm_list *r;
	struct pv_list *pvl, *new_pvl;

	/* Build up list of PVs */

		log_error("Allocation of list failed");
		return NULL;
	}
	lvm_list_init(r);

	lvm_list_iterate_items(pvl, pvsl) {
		if (!(new_pvl = pool_zalloc(mem, sizeof(*new_pvl)))) {
			log_error("Unable to allocate physical volume list.");
			return NULL;
		}

		memcpy(new_pvl, pvl, sizeof(*new_pvl));
		lvm_list_add(r, &new_pvl->list);
	}

	return r;




						      void *handle));

int process_each_pv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
			  struct lvm_list *tags, void *handle,
			  int (*process_single) (struct cmd_context * cmd,
						 struct volume_group * vg,
						 struct physical_volume * pv,
						 void *handle));

int process_each_lv_in_vg(struct cmd_context *cmd, struct volume_group *vg,
			  struct lvm_list *arg_lvnames, struct lvm_list *tags,
			  void *handle,
			  int (*process_single) (struct cmd_context * cmd,
						 struct logical_volume * lv,

 * Builds a list of pv's from the names in argv.  Used in
 * lvcreate/extend.
 */
struct lvm_list *create_pv_list(struct pool *mem,
			    struct volume_group *vg, int argc, char **argv);

struct lvm_list *clone_pv_list(struct pool *mem, struct lvm_list *pvs);

#endif




		if (!consistent) {
			log_error("No backup taken: specify filename with -f "
				  "to backup an inconsistent VG");
			STACK;
			return ECMD_FAILED;
		}

		/* just use the normal backup code */
		backup_enable(1);	/* force a backup */
		if (!backup(vg)) {
			STACK;
			return ECMD_FAILED;
		}
	}

Lines 23-29 Link Here

(-)LVM2.2.00.15.orig/tools/vgchange.c (-2 / +2 lines)
23	struct physical_volume *pv;	23	struct physical_volume *pv;
24	int count = 0;	24	int count = 0;
25		25
26	list_iterate_items(lvl, &vg->lvs) {	26	lvm_list_iterate_items(lvl, &vg->lvs) {
27	lv = lvl->lv;	27	lv = lvl->lv;
28		28
29	/* Only request activation of snapshot origin devices */	29	/* Only request activation of snapshot origin devices */
Lines 214-220 Link Here
214		214
215	id_create(&vg->id);	215	id_create(&vg->id);
216		216
217	list_iterate_items(lvl, &vg->lvs) {	217	lvm_list_iterate_items(lvl, &vg->lvs) {
218	memcpy(&lvl->lv->lvid, &vg->id, sizeof(vg->id));	218	memcpy(&lvl->lv->lvid, &vg->id, sizeof(vg->id));
219	}	219	}
220		220




	struct logical_volume *lv;
	struct lv_list *lvl;
	uint64_t size = 0;
	struct lvm_list mdas;
	int pvmetadatacopies = 0;
	uint64_t pvmetadatasize = 0;
	uint64_t pe_end = 0, pe_start = 0;


	/* Attempt to change any LVIDs that are too big */
	if (cmd->fmt->features & FMT_RESTRICTED_LVIDS) {
		lvm_list_iterate_items(lvl, &vg->lvs) {
			lv = lvl->lv;
			if (lvnum_from_lvid(&lv->lvid) < MAX_RESTRICTED_LVS)
				continue;

	if (active)
		return ECMD_FAILED;

	lvm_list_iterate_items(pvl, &vg->pvs) {
		existing_pv = pvl->pv;

		pe_start = existing_pv->pe_start;
		pe_end = existing_pv->pe_count * existing_pv->pe_size
		    + pe_start - 1;

		lvm_list_init(&mdas);
		if (!(pv = pv_create(cmd->fmt, existing_pv->dev,
				     &existing_pv->id, size,
				     pe_start, existing_pv->pe_count,




	}

	/* Check no conflicts with LV names */
	lvm_list_iterate_items(lvl1, &vg_to->lvs) {
		char *name1 = lvl1->lv->name;

		lvm_list_iterate_items(lvl2, &vg_from->lvs) {
			char *name2 = lvl2->lv->name;

			if (!strcmp(name1, name2)) {

		goto error;

	/* Merge volume groups */
	while (!lvm_list_empty(&vg_from->pvs)) {
		struct lvm_list *pvh = vg_from->pvs.n;
		struct physical_volume *pv;

		lvm_list_del(pvh);
		lvm_list_add(&vg_to->pvs, pvh);

		pv = lvm_list_item(pvh, struct pv_list)->pv;
		pv->vg_name = pool_strdup(cmd->mem, vg_to->name);
	}
	vg_to->pv_count += vg_from->pv_count;

	while (!lvm_list_empty(&vg_from->lvs)) {
		struct lvm_list *lvh = vg_from->lvs.n;

		lvm_list_del(lvh);
		lvm_list_add(&vg_to->lvs, lvh);
	}

	while (!lvm_list_empty(&vg_from->fid->metadata_areas)) {
		struct lvm_list *mdah = vg_from->fid->metadata_areas.n;

		lvm_list_del(mdah);
		lvm_list_add(&vg_to->fid->metadata_areas, mdah);
	}

	vg_to->lv_count += vg_from->lv_count;




	}

	if (!id_write_format(&pvl->pv->id, uuid, sizeof(uuid))) {
		STACK;
		return 0;
	}


	vg->extent_count -= pvl->pv->pe_count;
	vg->pv_count--;

	lvm_list_del(&pvl->list);

	return 1;
}

{
	struct snapshot *snap;
	struct snapshot_list *snl;
	struct lvm_list *snaplist;

	log_verbose("%s/%s has missing extents: removing (including "
		    "dependencies)", lv->vg->name, lv->name);


	/* Remove snapshot dependencies */
	if (!(snaplist = find_snapshots(lv))) {
		STACK;
		return 0;
	}
	/* List may be empty */
	lvm_list_iterate_items(snl, snaplist) {
		*list_unsafe = 1;	/* May remove caller's lvht! */
		snap = snl->snapshot;
		if (!vg_remove_snapshot(lv->vg, snap->cow)) {
			STACK;
			return 0;
		}
		log_verbose("Removing LV %s from VG %s", snap->cow->name,
			    lv->vg->name);
		if (!lv_remove(lv->vg, snap->cow)) {
			STACK;
			return 0;
		}
	}

	/* Remove the LV itself */
	log_verbose("Removing LV %s from VG %s", lv->name, lv->vg->name);
	if (!lv_remove(lv->vg, lv)) {
		STACK;
		return 0;
	}



static int _make_vg_consistent(struct cmd_context *cmd, struct volume_group *vg)
{
	struct lvm_list *pvh, *pvht;
	struct lvm_list *lvh, *lvht;
	struct pv_list *pvl;
	struct logical_volume *lv;
	struct physical_volume *pv;

      restart_loop:
	list_unsafe = 0;	/* Set if we delete a different list-member */

	lvm_list_iterate_safe(lvh, lvht, &vg->lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;

		/* Are any segments of this LV on missing PVs? */
		lvm_list_iterate_items(seg, &lv->segments) {
			for (s = 0; s < seg->area_count; s++) {
				if (seg->area[s].type != AREA_PV)
					continue;

				pv = seg->area[s].u.pv.pv;
				if (!pv || !pv->dev) {
					if (!_remove_lv(cmd, lv, &list_unsafe)) {
						STACK;
						return 0;
					}
					if (list_unsafe)

	}

	/* Remove missing PVs */
	lvm_list_iterate_safe(pvh, pvht, &vg->pvs) {
		pvl = lvm_list_item(pvh, struct pv_list);
		if (pvl->pv->dev)
			continue;
		if (!_remove_pv(vg, pvl)) {
			STACK;
			return 0;
		}
	}

	log_verbose("Removing \"%s\" from volume group \"%s\"", name, vg->name);

	if (pvl)
		lvm_list_del(&pvl->list);

	pv->vg_name = ORPHAN;
	vg->pv_count--;

Lines 54-60 Link Here

(-)LVM2.2.00.15.orig/tools/vgremove.c (-1 / +1 lines)
54	}	54	}
55		55
56	/* init physical volumes */	56	/* init physical volumes */
57	list_iterate_items(pvl, &vg->pvs) {	57	lvm_list_iterate_items(pvl, &vg->pvs) {
58	pv = pvl->pv;	58	pv = pvl->pv;
59	log_verbose("Removing physical volume \"%s\" from "	59	log_verbose("Removing physical volume \"%s\" from "
60	"volume group \"%s\"", dev_name(pv->dev), vg_name);	60	"volume group \"%s\"", dev_name(pv->dev), vg_name);




		return 0;
	}

	lvm_list_del(&pvl->list);
	lvm_list_add(&vg_to->pvs, &pvl->list);

	vg_from->pv_count--;
	vg_to->pv_count++;

	pv = lvm_list_item(pvl, struct pv_list)->pv;

	vg_from->extent_count -= pv->pe_count;
	vg_to->extent_count += pv->pe_count;


static int _move_lvs(struct volume_group *vg_from, struct volume_group *vg_to)
{
	struct lvm_list *lvh, *lvht;
	struct logical_volume *lv;
	struct lv_segment *seg;
	struct physical_volume *pv;
	struct volume_group *vg_with;
	unsigned int s;

	lvm_list_iterate_safe(lvh, lvht, &vg_from->lvs) {
		lv = lvm_list_item(lvh, struct lv_list)->lv;

		/* Ensure all the PVs used by this LV remain in the same */
		/* VG as each other */
		vg_with = NULL;
		lvm_list_iterate_items(seg, &lv->segments) {
			for (s = 0; s < seg->area_count; s++) {
				/* FIXME Check AREA_LV too */
				if (seg->area[s].type != AREA_PV)

			continue;

		/* Move this LV */
		lvm_list_del(lvh);
		lvm_list_add(&vg_to->lvs, lvh);

		vg_from->lv_count--;
		vg_to->lv_count++;

{
	struct lv_list *lvl;

	lvm_list_iterate_items(lvl, &vg->lvs)
		if (lv == lvl->lv)
			 return 1;


static int _move_snapshots(struct volume_group *vg_from,
			   struct volume_group *vg_to)
{
	struct lvm_list *slh, *slth;
	struct snapshot *snap;
	int cow_from, origin_from;

	lvm_list_iterate_safe(slh, slth, &vg_from->snapshots) {
		snap = lvm_list_item(slh, struct snapshot_list)->snapshot;
		cow_from = _lv_is_in_vg(vg_from, snap->cow);
		origin_from = _lv_is_in_vg(vg_from, snap->origin);
		if (cow_from && origin_from)

		vg_from->snapshot_count--;
		vg_to->snapshot_count++;

		lvm_list_del(slh);
		lvm_list_add(&vg_to->snapshots, slh);
	}

	return 1;

Return to bug 56873

Lines 180-186 Link Here

(-)LVM2.2.00.15.orig/lib/activate/activate.c (-29 / +29 lines)
180		180
181	if (!(cn = find_config_node(cmd->cft->root, "activation/volume_list"))) {	181	if (!(cn = find_config_node(cmd->cft->root, "activation/volume_list"))) {
182	/* If no hosts tags defined, activate */	182	/* If no hosts tags defined, activate */
183	if (list_empty(&cmd->tags))	183	if (lvm_list_empty(&cmd->tags))
184	return 1;	184	return 1;
185		185
186	/* If any host tag matches any LV or VG tag, activate */	186	/* If any host tag matches any LV or VG tag, activate */
Lines 270-276 Link Here
270		270
271	log_very_verbose("Getting driver version");	271	log_very_verbose("Getting driver version");
272	if (!(dmt = dm_task_create(DM_DEVICE_VERSION))) {	272	if (!(dmt = dm_task_create(DM_DEVICE_VERSION))) {
273	stack;	273	STACK;
274	return 0;	274	return 0;
275	}	275	}
276		276
Lines 299-305 Link Here
299		299
300	log_very_verbose("Getting target version for %s", target_name);	300	log_very_verbose("Getting target version for %s", target_name);
301	if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS))) {	301	if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS))) {
302	stack;	302	STACK;
303	return 0;	303	return 0;
304	}	304	}
305		305
Lines 342-353 Link Here
342	return 0;	342	return 0;
343		343
344	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {	344	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
345	stack;	345	STACK;
346	return 0;	346	return 0;
347	}	347	}
348		348
349	if (!(r = dev_manager_info(dm, lv, mknodes, &dminfo)))	349	if (!(r = dev_manager_info(dm, lv, mknodes, &dminfo)))
350	stack;	350	STACK;
351		351
352	info->exists = dminfo.exists;	352	info->exists = dminfo.exists;
353	info->suspended = dminfo.suspended;	353	info->suspended = dminfo.suspended;
Lines 388-399 Link Here
388	return 0;	388	return 0;
389		389
390	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {	390	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
391	stack;	391	STACK;
392	return 0;	392	return 0;
393	}	393	}
394		394
395	if (!(r = dev_manager_snapshot_percent(dm, lv, percent)))	395	if (!(r = dev_manager_snapshot_percent(dm, lv, percent)))
396	stack;	396	STACK;
397		397
398	dev_manager_destroy(dm);	398	dev_manager_destroy(dm);
399		399
Lines 412-418 Link Here
412	return 0;	412	return 0;
413		413
414	if (!lv_info(lv, &info)) {	414	if (!lv_info(lv, &info)) {
415	stack;	415	STACK;
416	return 0;	416	return 0;
417	}	417	}
418		418
Lines 420-431 Link Here
420	return 0;	420	return 0;
421		421
422	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {	422	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
423	stack;	423	STACK;
424	return 0;	424	return 0;
425	}	425	}
426		426
427	if (!(r = dev_manager_mirror_percent(dm, lv, wait, percent, event_nr)))	427	if (!(r = dev_manager_mirror_percent(dm, lv, wait, percent, event_nr)))
428	stack;	428	STACK;
429		429
430	dev_manager_destroy(dm);	430	dev_manager_destroy(dm);
431		431
Lines 437-443 Link Here
437	struct lvinfo info;	437	struct lvinfo info;
438		438
439	if (!lv_info(lv, &info)) {	439	if (!lv_info(lv, &info)) {
440	stack;	440	STACK;
441	return -1;	441	return -1;
442	}	442	}
443		443
Lines 449-455 Link Here
449	struct lvinfo info;	449	struct lvinfo info;
450		450
451	if (!lv_info(lv, &info)) {	451	if (!lv_info(lv, &info)) {
452	stack;	452	STACK;
453	return -1;	453	return -1;
454	}	454	}
455		455
Lines 463-474 Link Here
463	struct dev_manager *dm;	463	struct dev_manager *dm;
464		464
465	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {	465	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
466	stack;	466	STACK;
467	return 0;	467	return 0;
468	}	468	}
469		469
470	if (!(r = dev_manager_activate(dm, lv)))	470	if (!(r = dev_manager_activate(dm, lv)))
471	stack;	471	STACK;
472		472
473	dev_manager_destroy(dm);	473	dev_manager_destroy(dm);
474	return r;	474	return r;
Lines 480-491 Link Here
480	struct dev_manager *dm;	480	struct dev_manager *dm;
481		481
482	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {	482	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
483	stack;	483	STACK;
484	return 0;	484	return 0;
485	}	485	}
486		486
487	if (!(r = dev_manager_deactivate(dm, lv)))	487	if (!(r = dev_manager_deactivate(dm, lv)))
488	stack;	488	STACK;
489		489
490	dev_manager_destroy(dm);	490	dev_manager_destroy(dm);
491	return r;	491	return r;
Lines 497-508 Link Here
497	struct dev_manager *dm;	497	struct dev_manager *dm;
498		498
499	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {	499	if (!(dm = dev_manager_create(lv->vg->name, lv->vg->cmd->cft))) {
500	stack;	500	STACK;
501	return 0;	501	return 0;
502	}	502	}
503		503
504	if (!(r = dev_manager_suspend(dm, lv)))	504	if (!(r = dev_manager_suspend(dm, lv)))
505	stack;	505	STACK;
506		506
507	dev_manager_destroy(dm);	507	dev_manager_destroy(dm);
508	return r;	508	return r;
Lines 514-528 Link Here
514	*/	514	*/
515	int lvs_in_vg_activated(struct volume_group *vg)	515	int lvs_in_vg_activated(struct volume_group *vg)
516	{	516	{
517	struct list *lvh;	517	struct lvm_list *lvh;
518	struct logical_volume *lv;	518	struct logical_volume *lv;
519	int count = 0;	519	int count = 0;
520		520
521	if (!activation())	521	if (!activation())
522	return 0;	522	return 0;
523		523
524	list_iterate(lvh, &vg->lvs) {	524	lvm_list_iterate(lvh, &vg->lvs) {
525	lv = list_item(lvh, struct lv_list)->lv;	525	lv = lvm_list_item(lvh, struct lv_list)->lv;
526	count += (_lv_active(lv) == 1);	526	count += (_lv_active(lv) == 1);
527	}	527	}
528		528
Lines 531-545 Link Here
531		531
532	int lvs_in_vg_opened(struct volume_group *vg)	532	int lvs_in_vg_opened(struct volume_group *vg)
533	{	533	{
534	struct list *lvh;	534	struct lvm_list *lvh;
535	struct logical_volume *lv;	535	struct logical_volume *lv;
536	int count = 0;	536	int count = 0;
537		537
538	if (!activation())	538	if (!activation())
539	return 0;	539	return 0;
540		540
541	list_iterate(lvh, &vg->lvs) {	541	lvm_list_iterate(lvh, &vg->lvs) {
542	lv = list_item(lvh, struct lv_list)->lv;	542	lv = lvm_list_item(lvh, struct lv_list)->lv;
543	count += (_lv_open_count(lv) > 0);	543	count += (_lv_open_count(lv) > 0);
544	}	544	}
545		545
Lines 564-570 Link Here
564	}	564	}
565		565
566	if (!lv_info(lv, &info)) {	566	if (!lv_info(lv, &info)) {
567	stack;	567	STACK;
568	return 0;	568	return 0;
569	}	569	}
570		570
Lines 610-616 Link Here
610	}	610	}
611		611
612	if (!lv_info(lv, &info)) {	612	if (!lv_info(lv, &info)) {
613	stack;	613	STACK;
614	return 0;	614	return 0;
615	}	615	}
616		616
Lines 655-661 Link Here
655	}	655	}
656		656
657	if (!lv_info(lv, &info)) {	657	if (!lv_info(lv, &info)) {
658	stack;	658	STACK;
659	return 0;	659	return 0;
660	}	660	}
661		661
Lines 724-730 Link Here
724	}	724	}
725		725
726	if (!lv_info(lv, &info)) {	726	if (!lv_info(lv, &info)) {
727	stack;	727	STACK;
728	return 0;	728	return 0;
729	}	729	}
730		730
Lines 763-769 Link Here
763	}	763	}
764		764
765	if (!_lv_info(lv, 1, &info)) {	765	if (!_lv_info(lv, 1, &info)) {
766	stack;	766	STACK;
767	return 0;	767	return 0;
768	}	768	}
769		769

Lines 231-254 Link Here

(-)LVM2.2.00.15.orig/lib/activate/fs.c (-11 / +11 lines)
231	case FS_ADD:	231	case FS_ADD:
232	if (!_mk_dir(dev_dir, vg_name) \|\|	232	if (!_mk_dir(dev_dir, vg_name) \|\|
233	!_mk_link(dev_dir, vg_name, lv_name, dev)) {	233	!_mk_link(dev_dir, vg_name, lv_name, dev)) {
234	stack;	234	STACK;
235	return 0;	235	return 0;
236	}	236	}
237	break;	237	break;
238	case FS_DEL:	238	case FS_DEL:
239	if (!_rm_link(dev_dir, vg_name, lv_name) \|\|	239	if (!_rm_link(dev_dir, vg_name, lv_name) \|\|
240	!_rm_dir(dev_dir, vg_name)) {	240	!_rm_dir(dev_dir, vg_name)) {
241	stack;	241	STACK;
242	return 0;	242	return 0;
243	}	243	}
244	break;	244	break;
245	/* FIXME Use rename() */	245	/* FIXME Use rename() */
246	case FS_RENAME:	246	case FS_RENAME:
247	if (old_lv_name && !_rm_link(dev_dir, vg_name, old_lv_name))	247	if (old_lv_name && !_rm_link(dev_dir, vg_name, old_lv_name))
248	stack;	248	STACK;
249		249
250	if (!_mk_link(dev_dir, vg_name, lv_name, dev))	250	if (!_mk_link(dev_dir, vg_name, lv_name, dev))
251	stack;	251	STACK;
252	}	252	}
253		253
254	return 1;	254	return 1;
Lines 257-263 Link Here
257	static LIST_INIT(_fs_ops);	257	static LIST_INIT(_fs_ops);
258		258
259	struct fs_op_parms {	259	struct fs_op_parms {
260	struct list list;	260	struct lvm_list list;
261	fs_op_t type;	261	fs_op_t type;
262	char *dev_dir;	262	char *dev_dir;
263	char *vg_name;	263	char *vg_name;
Lines 297-317 Link Here
297	_store_str(&pos, &fsp->dev, dev);	297	_store_str(&pos, &fsp->dev, dev);
298	_store_str(&pos, &fsp->old_lv_name, old_lv_name);	298	_store_str(&pos, &fsp->old_lv_name, old_lv_name);
299		299
300	list_add(&_fs_ops, &fsp->list);	300	lvm_list_add(&_fs_ops, &fsp->list);
301		301
302	return 1;	302	return 1;
303	}	303	}
304		304
305	static void _pop_fs_ops(void)	305	static void _pop_fs_ops(void)
306	{	306	{
307	struct list fsph, fspht;	307	struct lvm_list fsph, fspht;
308	struct fs_op_parms *fsp;	308	struct fs_op_parms *fsp;
309		309
310	list_iterate_safe(fsph, fspht, &_fs_ops) {	310	lvm_list_iterate_safe(fsph, fspht, &_fs_ops) {
311	fsp = list_item(fsph, struct fs_op_parms);	311	fsp = lvm_list_item(fsph, struct fs_op_parms);
312	_do_fs_op(fsp->type, fsp->dev_dir, fsp->vg_name, fsp->lv_name,	312	_do_fs_op(fsp->type, fsp->dev_dir, fsp->vg_name, fsp->lv_name,
313	fsp->dev, fsp->old_lv_name);	313	fsp->dev, fsp->old_lv_name);
314	list_del(&fsp->list);	314	lvm_list_del(&fsp->list);
315	dbg_free(fsp);	315	dbg_free(fsp);
316	}	316	}
317	}	317	}
Lines 322-328 Link Here
322	if (memlock()) {	322	if (memlock()) {
323	if (!_stack_fs_op(type, dev_dir, vg_name, lv_name, dev,	323	if (!_stack_fs_op(type, dev_dir, vg_name, lv_name, dev,
324	old_lv_name)) {	324	old_lv_name)) {
325	stack;	325	STACK;
326	return 0;	326	return 0;
327	}	327	}
328	return 1;	328	return 1;

Lines 28-40 Link Here

(-)LVM2.2.00.15.orig/lib/cache/lvmcache.c (-27 / +27 lines)
28	static struct hash_table *_vgid_hash = NULL;	28	static struct hash_table *_vgid_hash = NULL;
29	static struct hash_table *_vgname_hash = NULL;	29	static struct hash_table *_vgname_hash = NULL;
30	static struct hash_table *_lock_hash = NULL;	30	static struct hash_table *_lock_hash = NULL;
31	static struct list _vginfos;	31	static struct lvm_list _vginfos;
32	static int _has_scanned = 0;	32	static int _has_scanned = 0;
33	static int _vgs_locked = 0;	33	static int _vgs_locked = 0;
34		34
35	int lvmcache_init(void)	35	int lvmcache_init(void)
36	{	36	{
37	list_init(&_vginfos);	37	lvm_list_init(&_vginfos);
38		38
39	if (!(_vgname_hash = hash_create(128)))	39	if (!(_vgname_hash = hash_create(128)))
40	return 0;	40	return 0;
Lines 166-172 Link Here
166	struct label *label;	166	struct label *label;
167	struct dev_iter *iter;	167	struct dev_iter *iter;
168	struct device *dev;	168	struct device *dev;
169	struct list *fmth;	169	struct lvm_list *fmth;
170	struct format_type *fmt;	170	struct format_type *fmt;
171		171
172	static int _scanning_in_progress = 0;	172	static int _scanning_in_progress = 0;
Lines 201-208 Link Here
201	_has_scanned = 1;	201	_has_scanned = 1;
202		202
203	/* Perform any format-specific scanning e.g. text files */	203	/* Perform any format-specific scanning e.g. text files */
204	list_iterate(fmth, &cmd->formats) {	204	lvm_list_iterate(fmth, &cmd->formats) {
205	fmt = list_item(fmth, struct format_type);	205	fmt = lvm_list_item(fmth, struct format_type);
206	if (fmt->ops->scan && !fmt->ops->scan(fmt))	206	if (fmt->ops->scan && !fmt->ops->scan(fmt))
207	goto out;	207	goto out;
208	}	208	}
Lines 215-223 Link Here
215	return r;	215	return r;
216	}	216	}
217		217
218	struct list lvmcache_get_vgnames(struct cmd_context cmd, int full_scan)	218	struct lvm_list lvmcache_get_vgnames(struct cmd_context cmd, int full_scan)
219	{	219	{
220	struct list *vgnames;	220	struct lvm_list *vgnames;
221	struct lvmcache_vginfo *vgi;	221	struct lvmcache_vginfo *vgi;
222		222
223	lvmcache_label_scan(cmd, full_scan);	223	lvmcache_label_scan(cmd, full_scan);
Lines 227-233 Link Here
227	return NULL;	227	return NULL;
228	}	228	}
229		229
230	list_iterate_items(vgi, &_vginfos) {	230	lvm_list_iterate_items(vgi, &_vginfos) {
231	if (!str_list_add(cmd->mem, vgnames,	231	if (!str_list_add(cmd->mem, vgnames,
232	pool_strdup(cmd->mem, vgi->vgname))) {	232	pool_strdup(cmd->mem, vgi->vgname))) {
233	log_error("strlist allocation failed");	233	log_error("strlist allocation failed");
Lines 282-299 Link Here
282		282
283	static void _drop_vginfo(struct lvmcache_info *info)	283	static void _drop_vginfo(struct lvmcache_info *info)
284	{	284	{
285	if (!list_empty(&info->list)) {	285	if (!lvm_list_empty(&info->list)) {
286	list_del(&info->list);	286	lvm_list_del(&info->list);
287	list_init(&info->list);	287	lvm_list_init(&info->list);
288	}	288	}
289		289
290	if (info->vginfo && list_empty(&info->vginfo->infos)) {	290	if (info->vginfo && lvm_list_empty(&info->vginfo->infos)) {
291	hash_remove(_vgname_hash, info->vginfo->vgname);	291	hash_remove(_vgname_hash, info->vginfo->vgname);
292	if (info->vginfo->vgname)	292	if (info->vginfo->vgname)
293	dbg_free(info->vginfo->vgname);	293	dbg_free(info->vginfo->vgname);
294	if (*info->vginfo->vgid)	294	if (*info->vginfo->vgid)
295	hash_remove(_vgid_hash, info->vginfo->vgid);	295	hash_remove(_vgid_hash, info->vginfo->vgid);
296	list_del(&info->vginfo->list);	296	lvm_list_del(&info->vginfo->list);
297	dbg_free(info->vginfo);	297	dbg_free(info->vginfo);
298	}	298	}
299		299
Lines 382-388 Link Here
382	log_error("cache vgname alloc failed for %s", vgname);	382	log_error("cache vgname alloc failed for %s", vgname);
383	return 0;	383	return 0;
384	}	384	}
385	list_init(&vginfo->infos);	385	lvm_list_init(&vginfo->infos);
386	if (!hash_insert(_vgname_hash, vginfo->vgname, vginfo)) {	386	if (!hash_insert(_vgname_hash, vginfo->vgname, vginfo)) {
387	log_error("cache_update: vg hash insertion failed: %s",	387	log_error("cache_update: vg hash insertion failed: %s",
388	vginfo->vgname);	388	vginfo->vgname);
Lines 392-404 Link Here
392	}	392	}
393	/* Ensure orphans appear last on list_iterate */	393	/* Ensure orphans appear last on list_iterate */
394	if (!*vgname)	394	if (!*vgname)
395	list_add(&_vginfos, &vginfo->list);	395	lvm_list_add(&_vginfos, &vginfo->list);
396	else	396	else
397	list_add_h(&_vginfos, &vginfo->list);	397	lvm_list_add_h(&_vginfos, &vginfo->list);
398	}	398	}
399		399
400	info->vginfo = vginfo;	400	info->vginfo = vginfo;
401	list_add(&vginfo->infos, &info->list);	401	lvm_list_add(&vginfo->infos, &info->list);
402		402
403	/* FIXME Check consistency of list! */	403	/* FIXME Check consistency of list! */
404	vginfo->fmt = info->fmt;	404	vginfo->fmt = info->fmt;
Lines 408-414 Link Here
408		408
409	int lvmcache_update_vg(struct volume_group *vg)	409	int lvmcache_update_vg(struct volume_group *vg)
410	{	410	{
411	struct list *pvh;	411	struct lvm_list *pvh;
412	struct physical_volume *pv;	412	struct physical_volume *pv;
413	struct lvmcache_info *info;	413	struct lvmcache_info *info;
414	char pvid_s[ID_LEN + 1];	414	char pvid_s[ID_LEN + 1];
Lines 416-423 Link Here
416		416
417	pvid_s[sizeof(pvid_s) - 1] = '\0';	417	pvid_s[sizeof(pvid_s) - 1] = '\0';
418		418
419	list_iterate(pvh, &vg->pvs) {	419	lvm_list_iterate(pvh, &vg->pvs) {
420	pv = list_item(pvh, struct pv_list)->pv;	420	pv = lvm_list_item(pvh, struct pv_list)->pv;
421	strncpy(pvid_s, (char *) &pv->id, sizeof(pvid_s) - 1);	421	strncpy(pvid_s, (char *) &pv->id, sizeof(pvid_s) - 1);
422	/* FIXME Could pv->dev->pvid ever be different? */	422	/* FIXME Could pv->dev->pvid ever be different? */
423	if ((info = info_from_pvid(pvid_s))) {	423	if ((info = info_from_pvid(pvid_s))) {
Lines 451-457 Link Here
451	if (!(existing = info_from_pvid(pvid_s)) &&	451	if (!(existing = info_from_pvid(pvid_s)) &&
452	!(existing = info_from_pvid(dev->pvid))) {	452	!(existing = info_from_pvid(dev->pvid))) {
453	if (!(label = label_create(labeller))) {	453	if (!(label = label_create(labeller))) {
454	stack;	454	STACK;
455	return NULL;	455	return NULL;
456	}	456	}
457	if (!(info = dbg_malloc(sizeof(*info)))) {	457	if (!(info = dbg_malloc(sizeof(*info)))) {
Lines 463-469 Link Here
463		463
464	label->info = info;	464	label->info = info;
465	info->label = label;	465	info->label = label;
466	list_init(&info->list);	466	lvm_list_init(&info->list);
467	info->dev = dev;	467	info->dev = dev;
468	} else {	468	} else {
469	if (existing->dev != dev) {	469	if (existing->dev != dev) {
Lines 492-498 Link Here
492	label_destroy(info->label);	492	label_destroy(info->label);
493	if (!(info->label = label_create(labeller))) {	493	if (!(info->label = label_create(labeller))) {
494	/* FIXME leaves info without label! */	494	/* FIXME leaves info without label! */
495	stack;	495	STACK;
496	return NULL;	496	return NULL;
497	}	497	}
498	info->label->info = info;	498	info->label->info = info;
Lines 523-537 Link Here
523		523
524	if (!_lvmcache_update_vgid(info, vgid))	524	if (!_lvmcache_update_vgid(info, vgid))
525	/* Non-critical */	525	/* Non-critical */
526	stack;	526	STACK;
527		527
528	return info;	528	return info;
529	}	529	}
530		530
531	static void _lvmcache_destroy_entry(struct lvmcache_info *info)	531	static void _lvmcache_destroy_entry(struct lvmcache_info *info)
532	{	532	{
533	if (!list_empty(&info->list))	533	if (!lvm_list_empty(&info->list))
534	list_del(&info->list);	534	lvm_list_del(&info->list);
535	strcpy(info->dev->pvid, "");	535	strcpy(info->dev->pvid, "");
536	label_destroy(info->label);	536	label_destroy(info->label);
537	dbg_free(info);	537	dbg_free(info);
Lines 577-581 Link Here
577	_lock_hash = NULL;	577	_lock_hash = NULL;
578	}	578	}
579		579
580	list_init(&_vginfos);	580	lvm_list_init(&_vginfos);
581	}	581	}

Lines 205-211 Link Here

(-)LVM2.2.00.15.orig/lib/commands/toolcontext.c (-19 / +19 lines)
205	char config_file[PATH_MAX] = "";	205	char config_file[PATH_MAX] = "";
206		206
207	if (!(cmd->cft = create_config_tree())) {	207	if (!(cmd->cft = create_config_tree())) {
208	stack;	208	STACK;
209	return 0;	209	return 0;
210	}	210	}
211		211
Lines 244-250 Link Here
244	struct config_value *cv;	244	struct config_value *cv;
245		245
246	if (!dev_cache_init()) {	246	if (!dev_cache_init()) {
247	stack;	247	STACK;
248	return 0;	248	return 0;
249	}	249	}
250		250
Lines 381-387 Link Here
381	const char *format;	381	const char *format;
382		382
383	struct format_type *fmt;	383	struct format_type *fmt;
384	struct list *fmth;	384	struct lvm_list *fmth;
385		385
386	#ifdef HAVE_LIBDL	386	#ifdef HAVE_LIBDL
387	struct config_node *cn;	387	struct config_node *cn;
Lines 393-399 Link Here
393	if (!(fmt = init_lvm1_format(cmd)))	393	if (!(fmt = init_lvm1_format(cmd)))
394	return 0;	394	return 0;
395	fmt->library = NULL;	395	fmt->library = NULL;
396	list_add(&cmd->formats, &fmt->list);	396	lvm_list_add(&cmd->formats, &fmt->list);
397	#endif	397	#endif
398		398
399	#ifdef HAVE_LIBDL	399	#ifdef HAVE_LIBDL
Lines 412-418 Link Here
412	}	412	}
413	if (!(lib = load_shared_library(cmd->cft, cv->v.str,	413	if (!(lib = load_shared_library(cmd->cft, cv->v.str,
414	"format"))) {	414	"format"))) {
415	stack;	415	STACK;
416	return 0;	416	return 0;
417	}	417	}
418		418
Lines 426-432 Link Here
426	if (!(fmt = init_format_fn(cmd)))	426	if (!(fmt = init_format_fn(cmd)))
427	return 0;	427	return 0;
428	fmt->library = lib;	428	fmt->library = lib;
429	list_add(&cmd->formats, &fmt->list);	429	lvm_list_add(&cmd->formats, &fmt->list);
430	}	430	}
431	}	431	}
432	#endif	432	#endif
Lines 434-448 Link Here
434	if (!(fmt = create_text_format(cmd)))	434	if (!(fmt = create_text_format(cmd)))
435	return 0;	435	return 0;
436	fmt->library = NULL;	436	fmt->library = NULL;
437	list_add(&cmd->formats, &fmt->list);	437	lvm_list_add(&cmd->formats, &fmt->list);
438		438
439	cmd->fmt_backup = fmt;	439	cmd->fmt_backup = fmt;
440		440
441	format = find_config_str(cmd->cft->root, "global/format",	441	format = find_config_str(cmd->cft->root, "global/format",
442	DEFAULT_FORMAT);	442	DEFAULT_FORMAT);
443		443
444	list_iterate(fmth, &cmd->formats) {	444	lvm_list_iterate(fmth, &cmd->formats) {
445	fmt = list_item(fmth, struct format_type);	445	fmt = lvm_list_item(fmth, struct format_type);
446	if (!strcasecmp(fmt->name, format) \|\|	446	if (!strcasecmp(fmt->name, format) \|\|
447	(fmt->alias && !strcasecmp(fmt->alias, format))) {	447	(fmt->alias && !strcasecmp(fmt->alias, format))) {
448	cmd->default_settings.fmt = fmt;	448	cmd->default_settings.fmt = fmt;
Lines 530-536 Link Here
530	const char *tag;	530	const char *tag;
531	int passes;	531	int passes;
532		532
533	list_init(&cmd->tags);	533	lvm_list_init(&cmd->tags);
534		534
535	if (!(tn = find_config_node(cmd->cft->root, "tags")) \|\|	535	if (!(tn = find_config_node(cmd->cft->root, "tags")) \|\|
536	!tn->child) {	536	!tn->child) {
Lines 542-548 Link Here
542	DEFAULT_HOSTTAGS)) {	542	DEFAULT_HOSTTAGS)) {
543	/* FIXME Strip out invalid chars: only A-Za-z0-9_+.- */	543	/* FIXME Strip out invalid chars: only A-Za-z0-9_+.- */
544	if (!_set_tag(cmd, cmd->hostname)) {	544	if (!_set_tag(cmd, cmd->hostname)) {
545	stack;	545	STACK;
546	return 0;	546	return 0;
547	}	547	}
548	}	548	}
Lines 560-573 Link Here
560	if (cn->child) {	560	if (cn->child) {
561	passes = 0;	561	passes = 0;
562	if (!_check_host_filters(cmd, cn->child, &passes)) {	562	if (!_check_host_filters(cmd, cn->child, &passes)) {
563	stack;	563	STACK;
564	return 0;	564	return 0;
565	}	565	}
566	if (!passes)	566	if (!passes)
567	continue;	567	continue;
568	}	568	}
569	if (!_set_tag(cmd, tag)) {	569	if (!_set_tag(cmd, tag)) {
570	stack;	570	STACK;
571	return 0;	571	return 0;
572	}	572	}
573	}	573	}
Lines 599-605 Link Here
599	}	599	}
600	memset(cmd, 0, sizeof(*cmd));	600	memset(cmd, 0, sizeof(*cmd));
601	cmd->args = the_args;	601	cmd->args = the_args;
602	list_init(&cmd->formats);	602	lvm_list_init(&cmd->formats);
603		603
604	strcpy(cmd->sys_dir, DEFAULT_SYS_DIR);	604	strcpy(cmd->sys_dir, DEFAULT_SYS_DIR);
605		605
Lines 664-678 Link Here
664	return 1;	664	return 1;
665	}	665	}
666		666
667	static void _destroy_formats(struct list *formats)	667	static void _destroy_formats(struct lvm_list *formats)
668	{	668	{
669	struct list fmtl, tmp;	669	struct lvm_list fmtl, tmp;
670	struct format_type *fmt;	670	struct format_type *fmt;
671	void *lib;	671	void *lib;
672		672
673	list_iterate_safe(fmtl, tmp, formats) {	673	lvm_list_iterate_safe(fmtl, tmp, formats) {
674	fmt = list_item(fmtl, struct format_type);	674	fmt = lvm_list_item(fmtl, struct format_type);
675	list_del(&fmt->list);	675	lvm_list_del(&fmt->list);
676	lib = fmt->library;	676	lib = fmt->library;
677	fmt->ops->destroy(fmt);	677	fmt->ops->destroy(fmt);
678	#ifdef HAVE_LIBDL	678	#ifdef HAVE_LIBDL

Lines 99-110 Link Here

(-)LVM2.2.00.15.orig/lib/config/config.c (-17 / +17 lines)
99	struct pool mem = pool_create(10 1024);	99	struct pool mem = pool_create(10 1024);
100		100
101	if (!mem) {	101	if (!mem) {
102	stack;	102	STACK;
103	return 0;	103	return 0;
104	}	104	}
105		105
106	if (!(c = pool_alloc(mem, sizeof(*c)))) {	106	if (!(c = pool_alloc(mem, sizeof(*c)))) {
107	stack;	107	STACK;
108	pool_destroy(mem);	108	pool_destroy(mem);
109	return 0;	109	return 0;
110	}	110	}
Lines 132-138 Link Here
132	off_t mmap_offset = 0;	132	off_t mmap_offset = 0;
133		133
134	if (!(p = pool_alloc(c->mem, sizeof(*p)))) {	134	if (!(p = pool_alloc(c->mem, sizeof(*p)))) {
135	stack;	135	STACK;
136	return 0;	136	return 0;
137	}	137	}
138	p->mem = c->mem;	138	p->mem = c->mem;
Lines 153-159 Link Here
153	p->fb = p->fb + mmap_offset;	153	p->fb = p->fb + mmap_offset;
154	} else {	154	} else {
155	if (!(p->fb = dbg_malloc(size + size2))) {	155	if (!(p->fb = dbg_malloc(size + size2))) {
156	stack;	156	STACK;
157	return 0;	157	return 0;
158	}	158	}
159	if (!dev_read(dev, (uint64_t) offset, size, p->fb)) {	159	if (!dev_read(dev, (uint64_t) offset, size, p->fb)) {
Lines 184-190 Link Here
184	p->line = 1;	184	p->line = 1;
185	_get_token(p, TOK_SECTION_E);	185	_get_token(p, TOK_SECTION_E);
186	if (!(cft->root = _file(p))) {	186	if (!(cft->root = _file(p))) {
187	stack;	187	STACK;
188	goto out;	188	goto out;
189	}	189	}
190		190
Lines 227-238 Link Here
227	}	227	}
228		228
229	if (!(dev = dev_create_file(file, NULL, NULL))) {	229	if (!(dev = dev_create_file(file, NULL, NULL))) {
230	stack;	230	STACK;
231	return 0;	231	return 0;
232	}	232	}
233		233
234	if (!dev_open_flags(dev, O_RDONLY, 0, 0)) {	234	if (!dev_open_flags(dev, O_RDONLY, 0, 0)) {
235	stack;	235	STACK;
236	return 0;	236	return 0;
237	}	237	}
238		238
Lines 300-311 Link Here
300	}	300	}
301		301
302	if (!(dev = dev_create_file(c->filename, NULL, NULL))) {	302	if (!(dev = dev_create_file(c->filename, NULL, NULL))) {
303	stack;	303	STACK;
304	return 0;	304	return 0;
305	}	305	}
306		306
307	if (!dev_open_flags(dev, O_RDONLY, 0, 0)) {	307	if (!dev_open_flags(dev, O_RDONLY, 0, 0)) {
308	stack;	308	STACK;
309	return 0;	309	return 0;
310	}	310	}
311		311
Lines 426-432 Link Here
426	struct config_node root = NULL, n, *l = NULL;	426	struct config_node root = NULL, n, *l = NULL;
427	while (p->t != TOK_EOF) {	427	while (p->t != TOK_EOF) {
428	if (!(n = _section(p))) {	428	if (!(n = _section(p))) {
429	stack;	429	STACK;
430	return 0;	430	return 0;
431	}	431	}
432		432
Lines 444-455 Link Here
444	/* IDENTIFIER '{' VALUE* '}' */	444	/* IDENTIFIER '{' VALUE* '}' */
445	struct config_node root, n, *l = NULL;	445	struct config_node root, n, *l = NULL;
446	if (!(root = _create_node(p))) {	446	if (!(root = _create_node(p))) {
447	stack;	447	STACK;
448	return 0;	448	return 0;
449	}	449	}
450		450
451	if (!(root->key = _dup_tok(p))) {	451	if (!(root->key = _dup_tok(p))) {
452	stack;	452	STACK;
453	return 0;	453	return 0;
454	}	454	}
455		455
Lines 459-465 Link Here
459	match(TOK_SECTION_B);	459	match(TOK_SECTION_B);
460	while (p->t != TOK_SECTION_E) {	460	while (p->t != TOK_SECTION_E) {
461	if (!(n = _section(p))) {	461	if (!(n = _section(p))) {
462	stack;	462	STACK;
463	return 0;	463	return 0;
464	}	464	}
465		465
Lines 473-479 Link Here
473	} else {	473	} else {
474	match(TOK_EQ);	474	match(TOK_EQ);
475	if (!(root->v = _value(p))) {	475	if (!(root->v = _value(p))) {
476	stack;	476	STACK;
477	return 0;	477	return 0;
478	}	478	}
479	}	479	}
Lines 489-495 Link Here
489	match(TOK_ARRAY_B);	489	match(TOK_ARRAY_B);
490	while (p->t != TOK_ARRAY_E) {	490	while (p->t != TOK_ARRAY_E) {
491	if (!(l = _type(p))) {	491	if (!(l = _type(p))) {
492	stack;	492	STACK;
493	return 0;	493	return 0;
494	}	494	}
495		495
Lines 545-551 Link Here
545		545
546	p->tb++, p->te--; /* strip "'s */	546	p->tb++, p->te--; /* strip "'s */
547	if (!(v->v.str = _dup_tok(p))) {	547	if (!(v->v.str = _dup_tok(p))) {
548	stack;	548	STACK;
549	return 0;	549	return 0;
550	}	550	}
551	p->te++;	551	p->te++;
Lines 728-734 Link Here
728	size_t len = p->te - p->tb;	728	size_t len = p->te - p->tb;
729	char *str = pool_alloc(p->mem, len + 1);	729	char *str = pool_alloc(p->mem, len + 1);
730	if (!str) {	730	if (!str) {
731	stack;	731	STACK;
732	return 0;	732	return 0;
733	}	733	}
734	strncpy(str, p->tb, len);	734	strncpy(str, p->tb, len);

Lines 31-47 Link Here

(-)LVM2.2.00.15.orig/lib/cache/lvmcache.h (-6 / +6 lines)
31	/* Eventual replacement for struct physical_volume perhaps? */	31	/* Eventual replacement for struct physical_volume perhaps? */
32		32
33	struct lvmcache_vginfo {	33	struct lvmcache_vginfo {
34	struct list list; /* Join these vginfos together */	34	struct lvm_list list; /* Join these vginfos together */
35	struct list infos; /* List head for lvmcache_infos */	35	struct lvm_list infos; /* List head for lvmcache_infos */
36	char vgname; / "" == orphan */	36	char vgname; / "" == orphan */
37	char vgid[ID_LEN + 1];	37	char vgid[ID_LEN + 1];
38	const struct format_type *fmt;	38	const struct format_type *fmt;
39	};	39	};
40		40
41	struct lvmcache_info {	41	struct lvmcache_info {
42	struct list list; /* Join VG members together */	42	struct lvm_list list; /* Join VG members together */
43	struct list mdas; /* list head for metadata areas */	43	struct lvm_list mdas; /* list head for metadata areas */
44	struct list das; /* list head for data areas */	44	struct lvm_list das; /* list head for data areas */
45	struct lvmcache_vginfo vginfo; / NULL == unknown */	45	struct lvmcache_vginfo vginfo; / NULL == unknown */
46	struct label *label;	46	struct label *label;
47	const struct format_type *fmt;	47	const struct format_type *fmt;
Lines 79-84 Link Here
79		79
80	/* Returns list of struct str_lists containing pool-allocated copy of vgnames */	80	/* Returns list of struct str_lists containing pool-allocated copy of vgnames */
81	/* Set full_scan to 1 to reread every filtered device label */	81	/* Set full_scan to 1 to reread every filtered device label */
82	struct list lvmcache_get_vgnames(struct cmd_context cmd, int full_scan);	82	struct lvm_list lvmcache_get_vgnames(struct cmd_context cmd, int full_scan);
83		83
84	#endif	84	#endif

Lines 18-35 Link Here

(-)LVM2.2.00.15.orig/lib/datastruct/list.h (-24 / +24 lines)
18		18
19	#include <assert.h>	19	#include <assert.h>
20		20
21	struct list {	21	struct lvm_list {
22	struct list n, p;	22	struct lvm_list n, p;
23	};	23	};
24		24
25	#define LIST_INIT(name) struct list name = { &(name), &(name) }	25	#define LIST_INIT(name) struct lvm_list name = { &(name), &(name) }
26		26
27	static inline void list_init(struct list *head)	27	static inline void lvm_list_init(struct lvm_list *head)
28	{	28	{
29	head->n = head->p = head;	29	head->n = head->p = head;
30	}	30	}
31		31
32	static inline void list_add(struct list head, struct list elem)	32	static inline void lvm_list_add(struct lvm_list head, struct lvm_list elem)
33	{	33	{
34	assert(head->n);	34	assert(head->n);
35		35
Lines 40-46 Link Here
40	head->p = elem;	40	head->p = elem;
41	}	41	}
42		42
43	static inline void list_add_h(struct list head, struct list elem)	43	static inline void lvm_list_add_h(struct lvm_list head, struct lvm_list elem)
44	{	44	{
45	assert(head->n);	45	assert(head->n);
46		46
Lines 51-109 Link Here
51	head->n = elem;	51	head->n = elem;
52	}	52	}
53		53
54	static inline void list_del(struct list *elem)	54	static inline void lvm_list_del(struct lvm_list *elem)
55	{	55	{
56	elem->n->p = elem->p;	56	elem->n->p = elem->p;
57	elem->p->n = elem->n;	57	elem->p->n = elem->n;
58	}	58	}
59		59
60	static inline int list_empty(struct list *head)	60	static inline int lvm_list_empty(struct lvm_list *head)
61	{	61	{
62	return head->n == head;	62	return head->n == head;
63	}	63	}
64		64
65	static inline int list_end(struct list head, struct list elem)	65	static inline int lvm_list_end(struct lvm_list head, struct lvm_list elem)
66	{	66	{
67	return elem->n == head;	67	return elem->n == head;
68	}	68	}
69		69
70	static inline struct list list_next(struct list head, struct list *elem)	70	static inline struct lvm_list lvm_list_next(struct lvm_list head, struct lvm_list *elem)
71	{	71	{
72	return (list_end(head, elem) ? NULL : elem->n);	72	return (lvm_list_end(head, elem) ? NULL : elem->n);
73	}	73	}
74		74
75	#define list_item(v, t) \	75	#define lvm_list_item(v, t) \
76	((t )((uintptr_t)(v) - (uintptr_t)&((t ) 0)->list))	76	((t )((uintptr_t)(v) - (uintptr_t)&((t ) 0)->list))
77		77
78	#define list_struct_base(v, t, h) \	78	#define lvm_list_struct_base(v, t, h) \
79	((t )((uintptr_t)(v) - (uintptr_t)&((t ) 0)->h))	79	((t )((uintptr_t)(v) - (uintptr_t)&((t ) 0)->h))
80		80
81	/* Given a known element in a known structure, locate another */	81	/* Given a known element in a known structure, locate another */
82	#define struct_field(v, t, e, f) \	82	#define struct_field(v, t, e, f) \
83	(((t )((uintptr_t)(v) - (uintptr_t)&((t ) 0)->e))->f)	83	(((t )((uintptr_t)(v) - (uintptr_t)&((t ) 0)->e))->f)
84		84
85	/* Given a known element in a known structure, locate the list head */	85	/* Given a known element in a known structure, locate the lvm_list head */
86	#define list_head(v, t, e) struct_field(v, t, e, list)	86	#define lvm_list_head(v, t, e) struct_field(v, t, e, lvm_list)
87		87
88	#define list_iterate(v, head) \	88	#define lvm_list_iterate(v, head) \
89	for (v = (head)->n; v != head; v = v->n)	89	for (v = (head)->n; v != head; v = v->n)
90		90
91	#define list_uniterate(v, head, start) \	91	#define lvm_list_uniterate(v, head, start) \
92	for (v = (start)->p; v != head; v = v->p)	92	for (v = (start)->p; v != head; v = v->p)
93		93
94	#define list_iterate_safe(v, t, head) \	94	#define lvm_list_iterate_safe(v, t, head) \
95	for (v = (head)->n, t = v->n; v != head; v = t, t = v->n)	95	for (v = (head)->n, t = v->n; v != head; v = t, t = v->n)
96		96
97	#define list_iterate_items(v, head) \	97	#define lvm_list_iterate_items(v, head) \
98	for (v = list_item((head)->n, typeof(*v)); &v->list != (head); \	98	for (v = lvm_list_item((head)->n, typeof(*v)); &v->list != (head); \
99	v = list_item(v->list.n, typeof(*v)))	99	v = lvm_list_item(v->list.n, typeof(*v)))
100		100
101	static inline unsigned int list_size(const struct list *head)	101	static inline unsigned int lvm_list_size(const struct lvm_list *head)
102	{	102	{
103	unsigned int s = 0;	103	unsigned int s = 0;
104	const struct list *v;	104	const struct lvm_list *v;
105		105
106	list_iterate(v, head)	106	lvm_list_iterate(v, head)
107	s++;	107	s++;
108		108
109	return s;	109	return s;

Lines 16-41 Link Here

(-)LVM2.2.00.15.orig/lib/datastruct/str_list.c (-25 / +25 lines)
16	#include "lib.h"	16	#include "lib.h"
17	#include "str_list.h"	17	#include "str_list.h"
18		18
19	struct list str_list_create(struct pool mem)	19	struct lvm_list str_list_create(struct pool mem)
20	{	20	{
21	struct list *sl;	21	struct lvm_list *sl;
22		22
23	if (!(sl = pool_alloc(mem, sizeof(struct list)))) {	23	if (!(sl = pool_alloc(mem, sizeof(struct lvm_list)))) {
24	stack;	24	STACK;
25	return NULL;	25	return NULL;
26	}	26	}
27		27
28	list_init(sl);	28	lvm_list_init(sl);
29		29
30	return sl;	30	return sl;
31	}	31	}
32		32
33	int str_list_add(struct pool mem, struct list sll, const char *str)	33	int str_list_add(struct pool mem, struct lvm_list sll, const char *str)
34	{	34	{
35	struct str_list *sln;	35	struct str_list *sln;
36		36
37	if (!str) {	37	if (!str) {
38	stack;	38	STACK;
39	return 0;	39	return 0;
40	}	40	}
41		41
Lines 44-80 Link Here
44	return 1;	44	return 1;
45		45
46	if (!(sln = pool_alloc(mem, sizeof(*sln)))) {	46	if (!(sln = pool_alloc(mem, sizeof(*sln)))) {
47	stack;	47	STACK;
48	return 0;	48	return 0;
49	}	49	}
50		50
51	sln->str = str;	51	sln->str = str;
52	list_add(sll, &sln->list);	52	lvm_list_add(sll, &sln->list);
53		53
54	return 1;	54	return 1;
55	}	55	}
56		56
57	int str_list_del(struct list sll, const char str)	57	int str_list_del(struct lvm_list sll, const char str)
58	{	58	{
59	struct list slh, slht;	59	struct lvm_list slh, slht;
60		60
61	list_iterate_safe(slh, slht, sll) {	61	lvm_list_iterate_safe(slh, slht, sll) {
62	if (!strcmp(str, list_item(slh, struct str_list)->str))	62	if (!strcmp(str, lvm_list_item(slh, struct str_list)->str))
63	list_del(slh);	63	lvm_list_del(slh);
64	}	64	}
65		65
66	return 1;	66	return 1;
67	}	67	}
68		68
69	int str_list_dup(struct pool mem, struct list sllnew, struct list *sllold)	69	int str_list_dup(struct pool mem, struct lvm_list sllnew, struct lvm_list *sllold)
70	{	70	{
71	struct str_list *sl;	71	struct str_list *sl;
72		72
73	list_init(sllnew);	73	lvm_list_init(sllnew);
74		74
75	list_iterate_items(sl, sllold) {	75	lvm_list_iterate_items(sl, sllold) {
76	if (!str_list_add(mem, sllnew, strdup(sl->str))) {	76	if (!str_list_add(mem, sllnew, strdup(sl->str))) {
77	stack;	77	STACK;
78	return 0;	78	return 0;
79	}	79	}
80	}	80	}
Lines 85-95 Link Here
85	/*	85	/*
86	* Is item on list?	86	* Is item on list?
87	*/	87	*/
88	int str_list_match_item(struct list sll, const char str)	88	int str_list_match_item(struct lvm_list sll, const char str)
89	{	89	{
90	struct str_list *sl;	90	struct str_list *sl;
91		91
92	list_iterate_items(sl, sll)	92	lvm_list_iterate_items(sl, sll)
93	if (!strcmp(str, sl->str))	93	if (!strcmp(str, sl->str))
94	return 1;	94	return 1;
95		95
Lines 99-109 Link Here
99	/*	99	/*
100	* Is at least one item on both lists?	100	* Is at least one item on both lists?
101	*/	101	*/
102	int str_list_match_list(struct list sll, struct list sll2)	102	int str_list_match_list(struct lvm_list sll, struct lvm_list sll2)
103	{	103	{
104	struct str_list *sl;	104	struct str_list *sl;
105		105
106	list_iterate_items(sl, sll)	106	lvm_list_iterate_items(sl, sll)
107	if (str_list_match_item(sll2, sl->str))	107	if (str_list_match_item(sll2, sl->str))
108	return 1;	108	return 1;
109		109
Lines 113-126 Link Here
113	/*	113	/*
114	* Do both lists contain the same set of items?	114	* Do both lists contain the same set of items?
115	*/	115	*/
116	int str_list_lists_equal(struct list sll, struct list sll2)	116	int str_list_lists_equal(struct lvm_list sll, struct lvm_list sll2)
117	{	117	{
118	struct str_list *sl;	118	struct str_list *sl;
119		119
120	if (list_size(sll) != list_size(sll2))	120	if (lvm_list_size(sll) != lvm_list_size(sll2))
121	return 0;	121	return 0;
122		122
123	list_iterate_items(sl, sll)	123	lvm_list_iterate_items(sl, sll)
124	if (!str_list_match_item(sll2, sl->str))	124	if (!str_list_match_item(sll2, sl->str))
125	return 0;	125	return 0;
126		126

Lines 18-29 Link Here

(-)LVM2.2.00.15.orig/lib/datastruct/str_list.h (-7 / +7 lines)
18		18
19	#include "pool.h"	19	#include "pool.h"
20		20
21	struct list str_list_create(struct pool mem);	21	struct lvm_list str_list_create(struct pool mem);
22	int str_list_add(struct pool mem, struct list sll, const char *str);	22	int str_list_add(struct pool mem, struct lvm_list sll, const char *str);
23	int str_list_del(struct list sll, const char str);	23	int str_list_del(struct lvm_list sll, const char str);
24	int str_list_match_item(struct list sll, const char str);	24	int str_list_match_item(struct lvm_list sll, const char str);
25	int str_list_match_list(struct list sll, struct list sll2);	25	int str_list_match_list(struct lvm_list sll, struct lvm_list sll2);
26	int str_list_lists_equal(struct list sll, struct list sll2);	26	int str_list_lists_equal(struct lvm_list sll, struct lvm_list sll2);
27	int str_list_dup(struct pool mem, struct list sllnew, struct list *sllold);	27	int str_list_dup(struct pool mem, struct lvm_list sllnew, struct lvm_list *sllold);
28		28
29	#endif	29	#endif

Lines 32-38 Link Here

(-)LVM2.2.00.15.orig/lib/device/dev-cache.c (-31 / +31 lines)
32	};	32	};
33		33
34	struct dir_list {	34	struct dir_list {
35	struct list list;	35	struct lvm_list list;
36	char dir[0];	36	char dir[0];
37	};	37	};
38		38
Lines 42-48 Link Here
42	struct btree *devices;	42	struct btree *devices;
43		43
44	int has_scanned;	44	int has_scanned;
45	struct list dirs;	45	struct lvm_list dirs;
46		46
47	} _cache;	47	} _cache;
48		48
Lines 76-89 Link Here
76	dev->flags = DEV_REGULAR;	76	dev->flags = DEV_REGULAR;
77	if (allocate)	77	if (allocate)
78	dev->flags \|= DEV_ALLOCED;	78	dev->flags \|= DEV_ALLOCED;
79	list_init(&dev->aliases);	79	lvm_list_init(&dev->aliases);
80	list_add(&dev->aliases, &alias->list);	80	lvm_list_add(&dev->aliases, &alias->list);
81	dev->end = UINT64_C(0);	81	dev->end = UINT64_C(0);
82	dev->dev = 0;	82	dev->dev = 0;
83	dev->fd = -1;	83	dev->fd = -1;
84	dev->open_count = 0;	84	dev->open_count = 0;
85	memset(dev->pvid, 0, sizeof(dev->pvid));	85	memset(dev->pvid, 0, sizeof(dev->pvid));
86	list_init(&dev->open_list);	86	lvm_list_init(&dev->open_list);
87		87
88	return dev;	88	return dev;
89	}	89	}
Lines 97-109 Link Here
97	return NULL;	97	return NULL;
98	}	98	}
99	dev->flags = 0;	99	dev->flags = 0;
100	list_init(&dev->aliases);	100	lvm_list_init(&dev->aliases);
101	dev->dev = d;	101	dev->dev = d;
102	dev->fd = -1;	102	dev->fd = -1;
103	dev->open_count = 0;	103	dev->open_count = 0;
104	dev->end = UINT64_C(0);	104	dev->end = UINT64_C(0);
105	memset(dev->pvid, 0, sizeof(dev->pvid));	105	memset(dev->pvid, 0, sizeof(dev->pvid));
106	list_init(&dev->open_list);	106	lvm_list_init(&dev->open_list);
107		107
108	return dev;	108	return dev;
109	}	109	}
Lines 172-201 Link Here
172	static int _add_alias(struct device dev, const char path)	172	static int _add_alias(struct device dev, const char path)
173	{	173	{
174	struct str_list sl = _alloc(sizeof(sl));	174	struct str_list sl = _alloc(sizeof(sl));
175	struct list *ah;	175	struct lvm_list *ah;
176	const char *oldpath;	176	const char *oldpath;
177	int prefer_old = 1;	177	int prefer_old = 1;
178		178
179	if (!sl) {	179	if (!sl) {
180	stack;	180	STACK;
181	return 0;	181	return 0;
182	}	182	}
183		183
184	/* Is name already there? */	184	/* Is name already there? */
185	list_iterate(ah, &dev->aliases) {	185	lvm_list_iterate(ah, &dev->aliases) {
186	if (!strcmp(list_item(ah, struct str_list)->str, path)) {	186	if (!strcmp(lvm_list_item(ah, struct str_list)->str, path)) {
187	stack;	187	STACK;
188	return 1;	188	return 1;
189	}	189	}
190	}	190	}
191		191
192	if (!(sl->str = pool_strdup(_cache.mem, path))) {	192	if (!(sl->str = pool_strdup(_cache.mem, path))) {
193	stack;	193	STACK;
194	return 0;	194	return 0;
195	}	195	}
196		196
197	if (!list_empty(&dev->aliases)) {	197	if (!lvm_list_empty(&dev->aliases)) {
198	oldpath = list_item(dev->aliases.n, struct str_list)->str;	198	oldpath = lvm_list_item(dev->aliases.n, struct str_list)->str;
199	prefer_old = _compare_paths(path, oldpath);	199	prefer_old = _compare_paths(path, oldpath);
200	log_debug("%s: Aliased to %s in device cache%s",	200	log_debug("%s: Aliased to %s in device cache%s",
201	path, oldpath, prefer_old ? "" : " (preferred name)");	201	path, oldpath, prefer_old ? "" : " (preferred name)");
Lines 204-212 Link Here
204	log_debug("%s: Added to device cache", path);	204	log_debug("%s: Added to device cache", path);
205		205
206	if (prefer_old)	206	if (prefer_old)
207	list_add(&dev->aliases, &sl->list);	207	lvm_list_add(&dev->aliases, &sl->list);
208	else	208	else
209	list_add_h(&dev->aliases, &sl->list);	209	lvm_list_add_h(&dev->aliases, &sl->list);
210		210
211	return 1;	211	return 1;
212	}	212	}
Lines 224-230 Link Here
224	(uint32_t) d))) {	224	(uint32_t) d))) {
225	/* create new device */	225	/* create new device */
226	if (!(dev = _dev_create(d))) {	226	if (!(dev = _dev_create(d))) {
227	stack;	227	STACK;
228	return 0;	228	return 0;
229	}	229	}
230		230
Lines 295-301 Link Here
295	}	295	}
296		296
297	if (!(path = _join(dir, dirent[n]->d_name))) {	297	if (!(path = _join(dir, dirent[n]->d_name))) {
298	stack;	298	STACK;
299	return 0;	299	return 0;
300	}	300	}
301		301
Lines 343-349 Link Here
343	}	343	}
344		344
345	if (!_insert_dev(path, info.st_rdev)) {	345	if (!_insert_dev(path, info.st_rdev)) {
346	stack;	346	STACK;
347	return 0;	347	return 0;
348	}	348	}
349		349
Lines 355-367 Link Here
355		355
356	static void _full_scan(void)	356	static void _full_scan(void)
357	{	357	{
358	struct list *dh;	358	struct lvm_list *dh;
359		359
360	if (_cache.has_scanned)	360	if (_cache.has_scanned)
361	return;	361	return;
362		362
363	list_iterate(dh, &_cache.dirs) {	363	lvm_list_iterate(dh, &_cache.dirs) {
364	struct dir_list *dl = list_item(dh, struct dir_list);	364	struct dir_list *dl = lvm_list_item(dh, struct dir_list);
365	_insert_dir(dl->dir);	365	_insert_dir(dl->dir);
366	};	366	};
367		367
Lines 388-399 Link Here
388	_cache.names = NULL;	388	_cache.names = NULL;
389		389
390	if (!(_cache.mem = pool_create(10 * 1024))) {	390	if (!(_cache.mem = pool_create(10 * 1024))) {
391	stack;	391	STACK;
392	return 0;	392	return 0;
393	}	393	}
394		394
395	if (!(_cache.names = hash_create(128))) {	395	if (!(_cache.names = hash_create(128))) {
396	stack;	396	STACK;
397	pool_destroy(_cache.mem);	397	pool_destroy(_cache.mem);
398	_cache.mem = 0;	398	_cache.mem = 0;
399	return 0;	399	return 0;
Lines 404-410 Link Here
404	goto bad;	404	goto bad;
405	}	405	}
406		406
407	list_init(&_cache.dirs);	407	lvm_list_init(&_cache.dirs);
408		408
409	return 1;	409	return 1;
410		410
Lines 441-447 Link Here
441		441
442	_cache.devices = NULL;	442	_cache.devices = NULL;
443	_cache.has_scanned = 0;	443	_cache.has_scanned = 0;
444	list_init(&_cache.dirs);	444	lvm_list_init(&_cache.dirs);
445	}	445	}
446		446
447	int dev_cache_add_dir(const char *path)	447	int dev_cache_add_dir(const char *path)
Lines 466-472 Link Here
466	}	466	}
467		467
468	strcpy(dl->dir, path);	468	strcpy(dl->dir, path);
469	list_add(&_cache.dirs, &dl->list);	469	lvm_list_add(&_cache.dirs, &dl->list);
470	return 1;	470	return 1;
471	}	471	}
472		472
Lines 480-486 Link Here
480	const char *name;	480	const char *name;
481	int r;	481	int r;
482		482
483	while ((r = stat(name = list_item(dev->aliases.n,	483	while ((r = stat(name = lvm_list_item(dev->aliases.n,
484	struct str_list)->str, &buf)) \|\|	484	struct str_list)->str, &buf)) \|\|
485	(buf.st_rdev != dev->dev)) {	485	(buf.st_rdev != dev->dev)) {
486	if (r < 0) {	486	if (r < 0) {
Lines 504-511 Link Here
504	/* Leave list alone if there isn't an alternative name */	504	/* Leave list alone if there isn't an alternative name */
505	/* so dev_name will always find something to return. */	505	/* so dev_name will always find something to return. */
506	/* Otherwise add the name to the correct device. */	506	/* Otherwise add the name to the correct device. */
507	if (list_size(&dev->aliases) > 1) {	507	if (lvm_list_size(&dev->aliases) > 1) {
508	list_del(dev->aliases.n);	508	lvm_list_del(dev->aliases.n);
509	if (!r)	509	if (!r)
510	_insert(name, 0);	510	_insert(name, 0);
511	continue;	511	continue;

Lines 157-163 Link Here

(-)LVM2.2.00.15.orig/lib/device/dev-io.c (-11 / +11 lines)
157		157
158	if (!(where->dev->flags & DEV_REGULAR) &&	158	if (!(where->dev->flags & DEV_REGULAR) &&
159	!_get_block_size(where->dev, &block_size)) {	159	!_get_block_size(where->dev, &block_size)) {
160	stack;	160	STACK;
161	return 0;	161	return 0;
162	}	162	}
163		163
Lines 187-193 Link Here
187	/* channel the io through the bounce buffer */	187	/* channel the io through the bounce buffer */
188	if (!_io(&widened, bounce, 0)) {	188	if (!_io(&widened, bounce, 0)) {
189	if (!should_write) {	189	if (!should_write) {
190	stack;	190	STACK;
191	return 0;	191	return 0;
192	}	192	}
193	/* FIXME pre-extend the file */	193	/* FIXME pre-extend the file */
Lines 285-291 Link Here
285	if (dev->flags & DEV_REGULAR)	285	if (dev->flags & DEV_REGULAR)
286	name = dev_name(dev);	286	name = dev_name(dev);
287	else if (!(name = dev_name_confirmed(dev, quiet))) {	287	else if (!(name = dev_name_confirmed(dev, quiet))) {
288	stack;	288	STACK;
289	return 0;	289	return 0;
290	}	290	}
291		291
Lines 325-331 Link Here
325	dev->end = lseek(dev->fd, (off_t) 0, SEEK_END);	325	dev->end = lseek(dev->fd, (off_t) 0, SEEK_END);
326	}	326	}
327		327
328	list_add(&_open_devices, &dev->open_list);	328	lvm_list_add(&_open_devices, &dev->open_list);
329	log_debug("Opened %s", dev_name(dev));	329	log_debug("Opened %s", dev_name(dev));
330		330
331	return 1;	331	return 1;
Lines 354-365 Link Here
354	if (close(dev->fd))	354	if (close(dev->fd))
355	log_sys_error("close", dev_name(dev));	355	log_sys_error("close", dev_name(dev));
356	dev->fd = -1;	356	dev->fd = -1;
357	list_del(&dev->open_list);	357	lvm_list_del(&dev->open_list);
358		358
359	log_debug("Closed %s", dev_name(dev));	359	log_debug("Closed %s", dev_name(dev));
360		360
361	if (dev->flags & DEV_ALLOCED) {	361	if (dev->flags & DEV_ALLOCED) {
362	dbg_free((void *) list_item(dev->aliases.n, struct str_list)->	362	dbg_free((void *) lvm_list_item(dev->aliases.n, struct str_list)->
363	str);	363	str);
364	dbg_free(dev->aliases.n);	364	dbg_free(dev->aliases.n);
365	dbg_free(dev);	365	dbg_free(dev);
Lines 398-408 Link Here
398		398
399	void dev_close_all(void)	399	void dev_close_all(void)
400	{	400	{
401	struct list doh, doht;	401	struct lvm_list doh, doht;
402	struct device *dev;	402	struct device *dev;
403		403
404	list_iterate_safe(doh, doht, &_open_devices) {	404	lvm_list_iterate_safe(doh, doht, &_open_devices) {
405	dev = list_struct_base(doh, struct device, open_list);	405	dev = lvm_list_struct_base(doh, struct device, open_list);
406	if (dev->open_count < 1)	406	if (dev->open_count < 1)
407	_close(dev);	407	_close(dev);
408	}	408	}
Lines 465-471 Link Here
465	char buffer[4096];	465	char buffer[4096];
466		466
467	if (!dev_open(dev)) {	467	if (!dev_open(dev)) {
468	stack;	468	STACK;
469	return 0;	469	return 0;
470	}	470	}
471		471
Lines 493-499 Link Here
493	dev->flags \|= DEV_ACCESSED_W;	493	dev->flags \|= DEV_ACCESSED_W;
494		494
495	if (!dev_close(dev))	495	if (!dev_close(dev))
496	stack;	496	STACK;
497		497
498	/* FIXME: Always display error */	498	/* FIXME: Always display error */
499	return (len == 0);	499	return (len == 0);

Lines 28-34 Link Here

(-)LVM2.2.00.15.orig/lib/device/device.h (-4 / +4 lines)
28	* pointer comparisons are valid.	28	* pointer comparisons are valid.
29	*/	29	*/
30	struct device {	30	struct device {
31	struct list aliases; /* struct str_list from lvm-types.h */	31	struct lvm_list aliases; /* struct str_list from lvm-types.h */
32	dev_t dev;	32	dev_t dev;
33		33
34	/* private */	34	/* private */
Lines 36-48 Link Here
36	int open_count;	36	int open_count;
37	uint32_t flags;	37	uint32_t flags;
38	uint64_t end;	38	uint64_t end;
39	struct list open_list;	39	struct lvm_list open_list;
40		40
41	char pvid[ID_LEN + 1];	41	char pvid[ID_LEN + 1];
42	};	42	};
43		43
44	struct device_list {	44	struct device_list {
45	struct list list;	45	struct lvm_list list;
46	struct device *dev;	46	struct device *dev;
47	};	47	};
48		48
Lines 82-88 Link Here
82		82
83	static inline const char dev_name(const struct device dev)	83	static inline const char dev_name(const struct device dev)
84	{	84	{
85	return (dev) ? list_item(dev->aliases.n, struct str_list)->str :	85	return (dev) ? lvm_list_item(dev->aliases.n, struct str_list)->str :
86	"unknown device";	86	"unknown device";
87	}	87	}
88		88

Lines 224-230 Link Here

(-)LVM2.2.00.15.orig/lib/display/display.c (-16 / +16 lines)
224	return;	224	return;
225		225
226	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {	226	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
227	stack;	227	STACK;
228	return;	228	return;
229	}	229	}
230		230
Lines 255-261 Link Here
255	return;	255	return;
256		256
257	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {	257	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
258	stack;	258	STACK;
259	return;	259	return;
260	}	260	}
261		261
Lines 313-319 Link Here
313	return 0;	313	return 0;
314		314
315	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {	315	if (!id_write_format(&pv->id, uuid, sizeof(uuid))) {
316	stack;	316	STACK;
317	return 0;	317	return 0;
318	}	318	}
319		319
Lines 356-366 Link Here
356	int inkernel, snap_active;	356	int inkernel, snap_active;
357	char uuid[64];	357	char uuid[64];
358	struct snapshot *snap = NULL;	358	struct snapshot *snap = NULL;
359	struct list slh, snaplist;	359	struct lvm_list slh, snaplist;
360	float snap_percent; /* fused, fsize; */	360	float snap_percent; /* fused, fsize; */
361		361
362	if (!id_write_format(&lv->lvid.id[1], uuid, sizeof(uuid))) {	362	if (!id_write_format(&lv->lvid.id[1], uuid, sizeof(uuid))) {
363	stack;	363	STACK;
364	return 0;	364	return 0;
365	}	365	}
366		366
Lines 381-388 Link Here
381	log_print("LV snapshot status source of");	381	log_print("LV snapshot status source of");
382		382
383	snaplist = find_snapshots(lv);	383	snaplist = find_snapshots(lv);
384	list_iterate(slh, snaplist) {	384	lvm_list_iterate(slh, snaplist) {
385	snap = list_item(slh, struct snapshot_list)->snapshot;	385	snap = lvm_list_item(slh, struct snapshot_list)->snapshot;
386	snap_active = lv_snapshot_percent(snap->cow,	386	snap_active = lv_snapshot_percent(snap->cow,
387	&snap_percent);	387	&snap_percent);
388	if (!snap_active \|\| snap_percent < 0 \|\|	388	if (!snap_active \|\| snap_percent < 0 \|\|
Lines 429-435 Link Here
429	log_print("Allocated LE %u", lv->allocated_le);	429	log_print("Allocated LE %u", lv->allocated_le);
430	**********/	430	**********/
431		431
432	log_print("Segments %u", list_size(&lv->segments));	432	log_print("Segments %u", lvm_list_size(&lv->segments));
433		433
434	/********* FIXME Stripes & stripesize for each segment	434	/********* FIXME Stripes & stripesize for each segment
435	log_print("Stripe size (KByte) %u", lv->stripesize / 2);	435	log_print("Stripe size (KByte) %u", lv->stripesize / 2);
Lines 507-519 Link Here
507	int lvdisplay_segments(struct logical_volume *lv)	507	int lvdisplay_segments(struct logical_volume *lv)
508	{	508	{
509	uint32_t s;	509	uint32_t s;
510	struct list *segh;	510	struct lvm_list *segh;
511	struct lv_segment *seg;	511	struct lv_segment *seg;
512		512
513	log_print("--- Segments ---");	513	log_print("--- Segments ---");
514		514
515	list_iterate(segh, &lv->segments) {	515	lvm_list_iterate(segh, &lv->segments) {
516	seg = list_item(segh, struct lv_segment);	516	seg = lvm_list_item(segh, struct lv_segment);
517		517
518	log_print("Logical extent %u to %u:",	518	log_print("Logical extent %u to %u:",
519	seg->le, seg->le + seg->len - 1);	519	seg->le, seg->le + seg->len - 1);
Lines 570-576 Link Here
570	char uuid[64];	570	char uuid[64];
571		571
572	if (vg->status & PARTIAL_VG)	572	if (vg->status & PARTIAL_VG)
573	active_pvs = list_size(&vg->pvs);	573	active_pvs = lvm_list_size(&vg->pvs);
574	else	574	else
575	active_pvs = vg->pv_count;	575	active_pvs = vg->pv_count;
576		576
Lines 580-586 Link Here
580	log_print("Format %s", vg->fid->fmt->name);	580	log_print("Format %s", vg->fid->fmt->name);
581	if (vg->fid->fmt->features & FMT_MDAS) {	581	if (vg->fid->fmt->features & FMT_MDAS) {
582	log_print("Metadata Areas %d",	582	log_print("Metadata Areas %d",
583	list_size(&vg->fid->metadata_areas));	583	lvm_list_size(&vg->fid->metadata_areas));
584	log_print("Metadata Sequence No %d", vg->seqno);	584	log_print("Metadata Sequence No %d", vg->seqno);
585	}	585	}
586	access = vg->status & (LVM_READ \| LVM_WRITE);	586	access = vg->status & (LVM_READ \| LVM_WRITE);
Lines 642-648 Link Here
642	2), SIZE_SHORT));	642	2), SIZE_SHORT));
643		643
644	if (!id_write_format(&vg->id, uuid, sizeof(uuid))) {	644	if (!id_write_format(&vg->id, uuid, sizeof(uuid))) {
645	stack;	645	STACK;
646	return;	646	return;
647	}	647	}
648		648
Lines 659-665 Link Here
659	char uuid[64];	659	char uuid[64];
660		660
661	if (vg->status & PARTIAL_VG)	661	if (vg->status & PARTIAL_VG)
662	active_pvs = list_size(&vg->pvs);	662	active_pvs = lvm_list_size(&vg->pvs);
663	else	663	else
664	active_pvs = vg->pv_count;	664	active_pvs = vg->pv_count;
665		665
Lines 678-684 Link Here
678	}	678	}
679		679
680	if (!id_write_format(&vg->id, uuid, sizeof(uuid))) {	680	if (!id_write_format(&vg->id, uuid, sizeof(uuid))) {
681	stack;	681	STACK;
682	return;	682	return;
683	}	683	}
684		684

Lines 32-38 Link Here

(-)LVM2.2.00.15.orig/lib/filters/filter-md.c (-4 / +4 lines)
32	uint32_t md_magic;	32	uint32_t md_magic;
33		33
34	if (!dev_get_size(dev, &size)) {	34	if (!dev_get_size(dev, &size)) {
35	stack;	35	STACK;
36	return 0;	36	return 0;
37	}	37	}
38		38
Lines 44-50 Link Here
44	return 1;	44	return 1;
45		45
46	if (!dev_open(dev)) {	46	if (!dev_open(dev)) {
47	stack;	47	STACK;
48	return 0;	48	return 0;
49	}	49	}
50		50
Lines 56-68 Link Here
56	log_debug("%s: Skipping md component device",	56	log_debug("%s: Skipping md component device",
57	dev_name(dev));	57	dev_name(dev));
58	if (!dev_close(dev))	58	if (!dev_close(dev))
59	stack;	59	STACK;
60	return 0;	60	return 0;
61	}	61	}
62	}	62	}
63		63
64	if (!dev_close(dev))	64	if (!dev_close(dev))
65	stack;	65	STACK;
66		66
67	return 1;	67	return 1;
68	}	68	}

Lines 42-48 Link Here

(-)LVM2.2.00.15.orig/lib/filters/filter-persistent.c (-9 / +9 lines)
42	hash_destroy(pf->devices);	42	hash_destroy(pf->devices);
43		43
44	if (!(pf->devices = hash_create(128))) {	44	if (!(pf->devices = hash_create(128))) {
45	stack;	45	STACK;
46	return 0;	46	return 0;
47	}	47	}
48		48
Lines 100-111 Link Here
100	struct config_tree *cft;	100	struct config_tree *cft;
101		101
102	if (!(cft = create_config_tree())) {	102	if (!(cft = create_config_tree())) {
103	stack;	103	STACK;
104	return 0;	104	return 0;
105	}	105	}
106		106
107	if (!read_config_file(cft, pf->file)) {	107	if (!read_config_file(cft, pf->file)) {
108	stack;	108	STACK;
109	goto out;	109	goto out;
110	}	110	}
111		111
Lines 202-215 Link Here
202	struct pfilter pf = (struct pfilter ) f->private;	202	struct pfilter pf = (struct pfilter ) f->private;
203	void *l = hash_lookup(pf->devices, dev_name(dev));	203	void *l = hash_lookup(pf->devices, dev_name(dev));
204	struct str_list *sl;	204	struct str_list *sl;
205	struct list *ah;	205	struct lvm_list *ah;
206		206
207	if (!l) {	207	if (!l) {
208	l = pf->real->passes_filter(pf->real, dev) ?	208	l = pf->real->passes_filter(pf->real, dev) ?
209	PF_GOOD_DEVICE : PF_BAD_DEVICE;	209	PF_GOOD_DEVICE : PF_BAD_DEVICE;
210		210
211	list_iterate(ah, &dev->aliases) {	211	lvm_list_iterate(ah, &dev->aliases) {
212	sl = list_item(ah, struct str_list);	212	sl = lvm_list_item(ah, struct str_list);
213	hash_insert(pf->devices, sl->str, l);	213	hash_insert(pf->devices, sl->str, l);
214	}	214	}
215	}	215	}
Lines 239-251 Link Here
239	struct dev_filter *f = NULL;	239	struct dev_filter *f = NULL;
240		240
241	if (!(pf = dbg_malloc(sizeof(*pf)))) {	241	if (!(pf = dbg_malloc(sizeof(*pf)))) {
242	stack;	242	STACK;
243	return NULL;	243	return NULL;
244	}	244	}
245	memset(pf, 0, sizeof(*pf));	245	memset(pf, 0, sizeof(*pf));
246		246
247	if (!(pf->file = dbg_malloc(strlen(file) + 1))) {	247	if (!(pf->file = dbg_malloc(strlen(file) + 1))) {
248	stack;	248	STACK;
249	goto bad;	249	goto bad;
250	}	250	}
251	strcpy(pf->file, file);	251	strcpy(pf->file, file);
Lines 257-263 Link Here
257	}	257	}
258		258
259	if (!(f = dbg_malloc(sizeof(*f)))) {	259	if (!(f = dbg_malloc(sizeof(*f)))) {
260	stack;	260	STACK;
261	goto bad;	261	goto bad;
262	}	262	}
263		263

Lines 75-81 Link Here

(-)LVM2.2.00.15.orig/lib/filters/filter-regex.c (-13 / +13 lines)
75	* copy the regex	75	* copy the regex
76	*/	76	*/
77	if (!(r = pool_strdup(mem, pat))) {	77	if (!(r = pool_strdup(mem, pat))) {
78	stack;	78	STACK;
79	return 0;	79	return 0;
80	}	80	}
81		81
Lines 102-108 Link Here
102	int i, r = 0;	102	int i, r = 0;
103		103
104	if (!(scratch = pool_create(1024))) {	104	if (!(scratch = pool_create(1024))) {
105	stack;	105	STACK;
106	return 0;	106	return 0;
107	}	107	}
108		108
Lines 123-129 Link Here
123	* allocate space for them	123	* allocate space for them
124	*/	124	*/
125	if (!(regex = pool_alloc(scratch, sizeof(regex) count))) {	125	if (!(regex = pool_alloc(scratch, sizeof(regex) count))) {
126	stack;	126	STACK;
127	goto out;	127	goto out;
128	}	128	}
129		129
Lines 148-154 Link Here
148	*/	148	*/
149	if (!(rf->engine = matcher_create(rf->mem, (const char **) regex,	149	if (!(rf->engine = matcher_create(rf->mem, (const char **) regex,
150	count)))	150	count)))
151	stack;	151	STACK;
152	r = 1;	152	r = 1;
153		153
154	out:	154	out:
Lines 158-170 Link Here
158		158
159	static int _accept_p(struct dev_filter f, struct device dev)	159	static int _accept_p(struct dev_filter f, struct device dev)
160	{	160	{
161	struct list *ah;	161	struct lvm_list *ah;
162	int m, first = 1, rejected = 0;	162	int m, first = 1, rejected = 0;
163	struct rfilter rf = (struct rfilter ) f->private;	163	struct rfilter rf = (struct rfilter ) f->private;
164	struct str_list *sl;	164	struct str_list *sl;
165		165
166	list_iterate(ah, &dev->aliases) {	166	lvm_list_iterate(ah, &dev->aliases) {
167	sl = list_item(ah, struct str_list);	167	sl = lvm_list_item(ah, struct str_list);
168	m = matcher_run(rf->engine, sl->str);	168	m = matcher_run(rf->engine, sl->str);
169		169
170	if (m >= 0) {	170	if (m >= 0) {
Lines 173-180 Link Here
173	if (!first) {	173	if (!first) {
174	log_debug("%s: New preferred name",	174	log_debug("%s: New preferred name",
175	sl->str);	175	sl->str);
176	list_del(&sl->list);	176	lvm_list_del(&sl->list);
177	list_add_h(&dev->aliases, &sl->list);	177	lvm_list_add_h(&dev->aliases, &sl->list);
178	}	178	}
179		179
180	return 1;	180	return 1;
Lines 206-229 Link Here
206	struct dev_filter *f;	206	struct dev_filter *f;
207		207
208	if (!mem) {	208	if (!mem) {
209	stack;	209	STACK;
210	return NULL;	210	return NULL;
211	}	211	}
212		212
213	if (!(rf = pool_alloc(mem, sizeof(*rf)))) {	213	if (!(rf = pool_alloc(mem, sizeof(*rf)))) {
214	stack;	214	STACK;
215	goto bad;	215	goto bad;
216	}	216	}
217		217
218	rf->mem = mem;	218	rf->mem = mem;
219		219
220	if (!_build_matcher(rf, patterns)) {	220	if (!_build_matcher(rf, patterns)) {
221	stack;	221	STACK;
222	goto bad;	222	goto bad;
223	}	223	}
224		224
225	if (!(f = pool_zalloc(mem, sizeof(*f)))) {	225	if (!(f = pool_zalloc(mem, sizeof(*f)))) {
226	stack;	226	STACK;
227	goto bad;	227	goto bad;
228	}	228	}
229		229

Lines 22-28 Link Here

(-)LVM2.2.00.15.orig/lib/format1/disk-rep.c (-36 / +36 lines)
22		22
23	#include <fcntl.h>	23	#include <fcntl.h>
24		24
25	#define fail do {stack; return 0;} while(0)	25	#define fail do {STACK; return 0;} while(0)
26	#define xx16(v) disk->v = xlate16(disk->v)	26	#define xx16(v) disk->v = xlate16(disk->v)
27	#define xx32(v) disk->v = xlate32(disk->v)	27	#define xx32(v) disk->v = xlate32(disk->v)
28	#define xx64(v) disk->v = xlate64(disk->v)	28	#define xx64(v) disk->v = xlate64(disk->v)
Lines 210-216 Link Here
210	memcpy(ul->uuid, buffer, NAME_LEN);	210	memcpy(ul->uuid, buffer, NAME_LEN);
211	ul->uuid[NAME_LEN - 1] = '\0';	211	ul->uuid[NAME_LEN - 1] = '\0';
212		212
213	list_add(&data->uuids, &ul->list);	213	lvm_list_add(&data->uuids, &ul->list);
214		214
215	pos += NAME_LEN;	215	pos += NAME_LEN;
216	num_read++;	216	num_read++;
Lines 245-251 Link Here
245	continue;	245	continue;
246		246
247	read++;	247	read++;
248	list_add(&data->lvds, &ll->list);	248	lvm_list_add(&data->lvds, &ll->list);
249	}	249	}
250		250
251	return 1;	251	return 1;
Lines 298-314 Link Here
298	struct lvmcache_info *info;	298	struct lvmcache_info *info;
299		299
300	if (!dl) {	300	if (!dl) {
301	stack;	301	STACK;
302	return NULL;	302	return NULL;
303	}	303	}
304		304
305	dl->dev = dev;	305	dl->dev = dev;
306	dl->mem = mem;	306	dl->mem = mem;
307	list_init(&dl->uuids);	307	lvm_list_init(&dl->uuids);
308	list_init(&dl->lvds);	308	lvm_list_init(&dl->lvds);
309		309
310	if (!_read_pvd(dev, &dl->pvd)) {	310	if (!_read_pvd(dev, &dl->pvd)) {
311	stack;	311	STACK;
312	goto bad;	312	goto bad;
313	}	313	}
314		314
Lines 317-326 Link Here
317		317
318	if (!(info = lvmcache_add(fmt->labeller, dl->pvd.pv_uuid, dev,	318	if (!(info = lvmcache_add(fmt->labeller, dl->pvd.pv_uuid, dev,
319	dl->pvd.vg_name, NULL)))	319	dl->pvd.vg_name, NULL)))
320	stack;	320	STACK;
321	else {	321	else {
322	info->device_size = xlate32(dl->pvd.pv_size) << SECTOR_SHIFT;	322	info->device_size = xlate32(dl->pvd.pv_size) << SECTOR_SHIFT;
323	list_init(&info->mdas);	323	lvm_list_init(&info->mdas);
324	info->status &= ~CACHE_INVALID;	324	info->status &= ~CACHE_INVALID;
325	}	325	}
326		326
Lines 382-406 Link Here
382	struct disk_list *r;	382	struct disk_list *r;
383		383
384	if (!dev_open(dev)) {	384	if (!dev_open(dev)) {
385	stack;	385	STACK;
386	return NULL;	386	return NULL;
387	}	387	}
388		388
389	r = __read_disk(fmt, dev, mem, vg_name);	389	r = __read_disk(fmt, dev, mem, vg_name);
390		390
391	if (!dev_close(dev))	391	if (!dev_close(dev))
392	stack;	392	STACK;
393		393
394	return r;	394	return r;
395	}	395	}
396		396
397	static void _add_pv_to_list(struct list head, struct disk_list data)	397	static void _add_pv_to_list(struct lvm_list head, struct disk_list data)
398	{	398	{
399	struct list *pvdh;	399	struct lvm_list *pvdh;
400	struct pv_disk *pvd;	400	struct pv_disk *pvd;
401		401
402	list_iterate(pvdh, head) {	402	lvm_list_iterate(pvdh, head) {
403	pvd = &list_item(pvdh, struct disk_list)->pvd;	403	pvd = &lvm_list_item(pvdh, struct disk_list)->pvd;
404	if (!strncmp(data->pvd.pv_uuid, pvd->pv_uuid,	404	if (!strncmp(data->pvd.pv_uuid, pvd->pv_uuid,
405	sizeof(pvd->pv_uuid))) {	405	sizeof(pvd->pv_uuid))) {
406	if (MAJOR(data->dev->dev) != md_major()) {	406	if (MAJOR(data->dev->dev) != md_major()) {
Lines 411-421 Link Here
411	}	411	}
412	log_very_verbose("Duplicate PV %s - using md %s",	412	log_very_verbose("Duplicate PV %s - using md %s",
413	pvd->pv_uuid, dev_name(data->dev));	413	pvd->pv_uuid, dev_name(data->dev));
414	list_del(pvdh);	414	lvm_list_del(pvdh);
415	break;	415	break;
416	}	416	}
417	}	417	}
418	list_add(head, &data->list);	418	lvm_list_add(head, &data->list);
419	}	419	}
420		420
421	/*	421	/*
Lines 425-443 Link Here
425	*/	425	*/
426	int read_pvs_in_vg(const struct format_type fmt, const char vg_name,	426	int read_pvs_in_vg(const struct format_type fmt, const char vg_name,
427	struct dev_filter filter, struct pool mem,	427	struct dev_filter filter, struct pool mem,
428	struct list *head)	428	struct lvm_list *head)
429	{	429	{
430	struct dev_iter *iter;	430	struct dev_iter *iter;
431	struct device *dev;	431	struct device *dev;
432	struct disk_list *data = NULL;	432	struct disk_list *data = NULL;
433	struct list *vgih;	433	struct lvm_list *vgih;
434	struct lvmcache_vginfo *vginfo;	434	struct lvmcache_vginfo *vginfo;
435		435
436	/* Fast path if we already saw this VG and cached the list of PVs */	436	/* Fast path if we already saw this VG and cached the list of PVs */
437	if (vg_name && (vginfo = vginfo_from_vgname(vg_name)) &&	437	if (vg_name && (vginfo = vginfo_from_vgname(vg_name)) &&
438	vginfo->infos.n) {	438	vginfo->infos.n) {
439	list_iterate(vgih, &vginfo->infos) {	439	lvm_list_iterate(vgih, &vginfo->infos) {
440	dev = list_item(vgih, struct lvmcache_info)->dev;	440	dev = lvm_list_item(vgih, struct lvmcache_info)->dev;
441	if (dev && !(data = read_disk(fmt, dev, mem, vg_name)))	441	if (dev && !(data = read_disk(fmt, dev, mem, vg_name)))
442	break;	442	break;
443	_add_pv_to_list(head, data);	443	_add_pv_to_list(head, data);
Lines 446-456 Link Here
446	/* Did we find the whole VG? */	446	/* Did we find the whole VG? */
447	if (!vg_name \|\| !*vg_name \|\|	447	if (!vg_name \|\| !*vg_name \|\|
448	(data && *data->pvd.vg_name &&	448	(data && *data->pvd.vg_name &&
449	list_size(head) == data->vgd.pv_cur))	449	lvm_list_size(head) == data->vgd.pv_cur))
450	return 1;	450	return 1;
451		451
452	/* Failed */	452	/* Failed */
453	list_init(head);	453	lvm_list_init(head);
454	/* vgcache_del(vg_name); */	454	/* vgcache_del(vg_name); */
455	}	455	}
456		456
Lines 467-473 Link Here
467	}	467	}
468	dev_iter_destroy(iter);	468	dev_iter_destroy(iter);
469		469
470	if (list_empty(head))	470	if (lvm_list_empty(head))
471	return 0;	471	return 0;
472		472
473	return 1;	473	return 1;
Lines 490-507 Link Here
490	static int _write_uuids(struct disk_list *data)	490	static int _write_uuids(struct disk_list *data)
491	{	491	{
492	struct uuid_list *ul;	492	struct uuid_list *ul;
493	struct list *uh;	493	struct lvm_list *uh;
494	uint64_t pos = data->pvd.pv_uuidlist_on_disk.base;	494	uint64_t pos = data->pvd.pv_uuidlist_on_disk.base;
495	uint64_t end = pos + data->pvd.pv_uuidlist_on_disk.size;	495	uint64_t end = pos + data->pvd.pv_uuidlist_on_disk.size;
496		496
497	list_iterate(uh, &data->uuids) {	497	lvm_list_iterate(uh, &data->uuids) {
498	if (pos >= end) {	498	if (pos >= end) {
499	log_error("Too many uuids to fit on %s",	499	log_error("Too many uuids to fit on %s",
500	dev_name(data->dev));	500	dev_name(data->dev));
501	return 0;	501	return 0;
502	}	502	}
503		503
504	ul = list_item(uh, struct uuid_list);	504	ul = lvm_list_item(uh, struct uuid_list);
505	if (!dev_write(data->dev, pos, NAME_LEN, ul->uuid))	505	if (!dev_write(data->dev, pos, NAME_LEN, ul->uuid))
506	fail;	506	fail;
507		507
Lines 524-530 Link Here
524		524
525	static int _write_lvs(struct disk_list *data)	525	static int _write_lvs(struct disk_list *data)
526	{	526	{
527	struct list *lvh;	527	struct lvm_list *lvh;
528	uint64_t pos, offset;	528	uint64_t pos, offset;
529		529
530	pos = data->pvd.lv_on_disk.base;	530	pos = data->pvd.lv_on_disk.base;
Lines 535-542 Link Here
535	return 0;	535	return 0;
536	}	536	}
537		537
538	list_iterate(lvh, &data->lvds) {	538	lvm_list_iterate(lvh, &data->lvds) {
539	struct lvd_list *ll = list_item(lvh, struct lvd_list);	539	struct lvd_list *ll = lvm_list_item(lvh, struct lvd_list);
540		540
541	offset = sizeof(struct lv_disk) * ll->lvd.lv_number;	541	offset = sizeof(struct lv_disk) * ll->lvd.lv_number;
542	if (offset + sizeof(struct lv_disk) > data->pvd.lv_on_disk.size) {	542	if (offset + sizeof(struct lv_disk) > data->pvd.lv_on_disk.size) {
Lines 657-670 Link Here
657	int r;	657	int r;
658		658
659	if (!dev_open(data->dev)) {	659	if (!dev_open(data->dev)) {
660	stack;	660	STACK;
661	return 0;	661	return 0;
662	}	662	}
663		663
664	r = __write_all_pvd(fmt, data);	664	r = __write_all_pvd(fmt, data);
665		665
666	if (!dev_close(data->dev))	666	if (!dev_close(data->dev))
667	stack;	667	STACK;
668		668
669	return r;	669	return r;
670	}	670	}
Lines 674-686 Link Here
674	* little sanity checking, so make sure correct	674	* little sanity checking, so make sure correct
675	* data is passed to here.	675	* data is passed to here.
676	*/	676	*/
677	int write_disks(const struct format_type fmt, struct list pvs)	677	int write_disks(const struct format_type fmt, struct lvm_list pvs)
678	{	678	{
679	struct list *pvh;	679	struct lvm_list *pvh;
680	struct disk_list *dl;	680	struct disk_list *dl;
681		681
682	list_iterate(pvh, pvs) {	682	lvm_list_iterate(pvh, pvs) {
683	dl = list_item(pvh, struct disk_list);	683	dl = lvm_list_item(pvh, struct disk_list);
684	if (!(_write_all_pvd(fmt, dl)))	684	if (!(_write_all_pvd(fmt, dl)))
685	fail;	685	fail;
686		686

Lines 28-36 Link Here

(-)LVM2.2.00.15.orig/lib/format1/format1.c (-59 / +59 lines)
28	#define FMT_LVM1_NAME "lvm1"	28	#define FMT_LVM1_NAME "lvm1"
29		29
30	/* VG consistency checks */	30	/* VG consistency checks */
31	static int _check_vgs(struct list pvs, int partial)	31	static int _check_vgs(struct lvm_list pvs, int partial)
32	{	32	{
33	struct list pvh, t;	33	struct lvm_list pvh, t;
34	struct disk_list *dl = NULL;	34	struct disk_list *dl = NULL;
35	struct disk_list *first = NULL;	35	struct disk_list *first = NULL;
36		36
Lines 45-52 Link Here
45	* This means an active VG won't be affected if disks are inserted	45	* This means an active VG won't be affected if disks are inserted
46	* bearing an exported VG with the same name.	46	* bearing an exported VG with the same name.
47	*/	47	*/
48	list_iterate(pvh, pvs) {	48	lvm_list_iterate(pvh, pvs) {
49	dl = list_item(pvh, struct disk_list);	49	dl = lvm_list_item(pvh, struct disk_list);
50		50
51	if (first_time) {	51	if (first_time) {
52	exported = dl->pvd.pv_status & VG_EXPORTED;	52	exported = dl->pvd.pv_status & VG_EXPORTED;
Lines 56-73 Link Here
56		56
57	if (exported != (dl->pvd.pv_status & VG_EXPORTED)) {	57	if (exported != (dl->pvd.pv_status & VG_EXPORTED)) {
58	/* Remove exported PVs */	58	/* Remove exported PVs */
59	list_iterate_safe(pvh, t, pvs) {	59	lvm_list_iterate_safe(pvh, t, pvs) {
60	dl = list_item(pvh, struct disk_list);	60	dl = lvm_list_item(pvh, struct disk_list);
61	if (dl->pvd.pv_status & VG_EXPORTED)	61	if (dl->pvd.pv_status & VG_EXPORTED)
62	list_del(pvh);	62	lvm_list_del(pvh);
63	}	63	}
64	break;	64	break;
65	}	65	}
66	}	66	}
67		67
68	/* Remove any PVs with VG structs that differ from the first */	68	/* Remove any PVs with VG structs that differ from the first */
69	list_iterate_safe(pvh, t, pvs) {	69	lvm_list_iterate_safe(pvh, t, pvs) {
70	dl = list_item(pvh, struct disk_list);	70	dl = lvm_list_item(pvh, struct disk_list);
71		71
72	if (!first)	72	if (!first)
73	first = dl;	73	first = dl;
Lines 104-110 Link Here
104	dl->vgd.vgda, dl->vgd.pe_size,	104	dl->vgd.vgda, dl->vgd.pe_size,
105	dl->vgd.pe_total, dl->vgd.pe_allocated,	105	dl->vgd.pe_total, dl->vgd.pe_allocated,
106	dl->vgd.pvg_total);	106	dl->vgd.pvg_total);
107	list_del(pvh);	107	lvm_list_del(pvh);
108	if (partial_mode()) {	108	if (partial_mode()) {
109	*partial = 1;	109	*partial = 1;
110	continue;	110	continue;
Lines 127-133 Link Here
127	}	127	}
128		128
129	static struct volume_group _build_vg(struct format_instance fid,	129	static struct volume_group _build_vg(struct format_instance fid,
130	struct list *pvs)	130	struct lvm_list *pvs)
131	{	131	{
132	struct pool *mem = fid->fmt->cmd->mem;	132	struct pool *mem = fid->fmt->cmd->mem;
133	struct volume_group vg = pool_alloc(mem, sizeof(vg));	133	struct volume_group vg = pool_alloc(mem, sizeof(vg));
Lines 137-143 Link Here
137	if (!vg)	137	if (!vg)
138	goto bad;	138	goto bad;
139		139
140	if (list_empty(pvs))	140	if (lvm_list_empty(pvs))
141	goto bad;	141	goto bad;
142		142
143	memset(vg, 0, sizeof(*vg));	143	memset(vg, 0, sizeof(*vg));
Lines 145-159 Link Here
145	vg->cmd = fid->fmt->cmd;	145	vg->cmd = fid->fmt->cmd;
146	vg->fid = fid;	146	vg->fid = fid;
147	vg->seqno = 0;	147	vg->seqno = 0;
148	list_init(&vg->pvs);	148	lvm_list_init(&vg->pvs);
149	list_init(&vg->lvs);	149	lvm_list_init(&vg->lvs);
150	list_init(&vg->snapshots);	150	lvm_list_init(&vg->snapshots);
151	list_init(&vg->tags);	151	lvm_list_init(&vg->tags);
152		152
153	if (!_check_vgs(pvs, &partial))	153	if (!_check_vgs(pvs, &partial))
154	goto bad;	154	goto bad;
155		155
156	dl = list_item(pvs->n, struct disk_list);	156	dl = lvm_list_item(pvs->n, struct disk_list);
157		157
158	if (!import_vg(mem, vg, dl, partial))	158	if (!import_vg(mem, vg, dl, partial))
159	goto bad;	159	goto bad;
Lines 173-179 Link Here
173	return vg;	173	return vg;
174		174
175	bad:	175	bad:
176	stack;	176	STACK;
177	pool_free(mem, vg);	177	pool_free(mem, vg);
178	return NULL;	178	return NULL;
179	}	179	}
Lines 183-194 Link Here
183	struct metadata_area *mda)	183	struct metadata_area *mda)
184	{	184	{
185	struct pool mem = pool_create(1024 10);	185	struct pool mem = pool_create(1024 10);
186	struct list pvs;	186	struct lvm_list pvs;
187	struct volume_group *vg = NULL;	187	struct volume_group *vg = NULL;
188	list_init(&pvs);	188	lvm_list_init(&pvs);
189		189
190	if (!mem) {	190	if (!mem) {
191	stack;	191	STACK;
192	return NULL;	192	return NULL;
193	}	193	}
194		194
Lines 197-208 Link Here
197		197
198	if (!read_pvs_in_vg	198	if (!read_pvs_in_vg
199	(fid->fmt, vg_name, fid->fmt->cmd->filter, mem, &pvs)) {	199	(fid->fmt, vg_name, fid->fmt->cmd->filter, mem, &pvs)) {
200	stack;	200	STACK;
201	goto bad;	201	goto bad;
202	}	202	}
203		203
204	if (!(vg = _build_vg(fid, &pvs))) {	204	if (!(vg = _build_vg(fid, &pvs))) {
205	stack;	205	STACK;
206	goto bad;	206	goto bad;
207	}	207	}
208		208
Lines 219-239 Link Here
219	struct disk_list dl = pool_alloc(mem, sizeof(dl));	219	struct disk_list dl = pool_alloc(mem, sizeof(dl));
220		220
221	if (!dl) {	221	if (!dl) {
222	stack;	222	STACK;
223	return NULL;	223	return NULL;
224	}	224	}
225		225
226	dl->mem = mem;	226	dl->mem = mem;
227	dl->dev = pv->dev;	227	dl->dev = pv->dev;
228		228
229	list_init(&dl->uuids);	229	lvm_list_init(&dl->uuids);
230	list_init(&dl->lvds);	230	lvm_list_init(&dl->lvds);
231		231
232	if (!export_pv(fid->fmt->cmd, mem, vg, &dl->pvd, pv) \|\|	232	if (!export_pv(fid->fmt->cmd, mem, vg, &dl->pvd, pv) \|\|
233	!export_vg(&dl->vgd, vg) \|\|	233	!export_vg(&dl->vgd, vg) \|\|
234	!export_uuids(dl, vg) \|\|	234	!export_uuids(dl, vg) \|\|
235	!export_lvs(dl, vg, pv, dev_dir) \|\| !calculate_layout(dl)) {	235	!export_lvs(dl, vg, pv, dev_dir) \|\| !calculate_layout(dl)) {
236	stack;	236	STACK;
237	pool_free(mem, dl);	237	pool_free(mem, dl);
238	return NULL;	238	return NULL;
239	}	239	}
Lines 243-271 Link Here
243		243
244	static int _flatten_vg(struct format_instance fid, struct pool mem,	244	static int _flatten_vg(struct format_instance fid, struct pool mem,
245	struct volume_group *vg,	245	struct volume_group *vg,
246	struct list pvds, const char dev_dir,	246	struct lvm_list pvds, const char dev_dir,
247	struct dev_filter *filter)	247	struct dev_filter *filter)
248	{	248	{
249	struct list *pvh;	249	struct lvm_list *pvh;
250	struct pv_list *pvl;	250	struct pv_list *pvl;
251	struct disk_list *data;	251	struct disk_list *data;
252		252
253	list_iterate(pvh, &vg->pvs) {	253	lvm_list_iterate(pvh, &vg->pvs) {
254	pvl = list_item(pvh, struct pv_list);	254	pvl = lvm_list_item(pvh, struct pv_list);
255		255
256	if (!(data = _flatten_pv(fid, mem, vg, pvl->pv, dev_dir))) {	256	if (!(data = _flatten_pv(fid, mem, vg, pvl->pv, dev_dir))) {
257	stack;	257	STACK;
258	return 0;	258	return 0;
259	}	259	}
260		260
261	list_add(pvds, &data->list);	261	lvm_list_add(pvds, &data->list);
262	}	262	}
263		263
264	export_numbers(pvds, vg);	264	export_numbers(pvds, vg);
265	export_pv_act(pvds);	265	export_pv_act(pvds);
266		266
267	if (!export_vg_number(fid, pvds, vg->name, filter)) {	267	if (!export_vg_number(fid, pvds, vg->name, filter)) {
268	stack;	268	STACK;
269	return 0;	269	return 0;
270	}	270	}
271		271
Lines 276-290 Link Here
276	struct metadata_area *mda)	276	struct metadata_area *mda)
277	{	277	{
278	struct pool mem = pool_create(1024 10);	278	struct pool mem = pool_create(1024 10);
279	struct list pvds;	279	struct lvm_list pvds;
280	int r = 0;	280	int r = 0;
281		281
282	if (!mem) {	282	if (!mem) {
283	stack;	283	STACK;
284	return 0;	284	return 0;
285	}	285	}
286		286
287	list_init(&pvds);	287	lvm_list_init(&pvds);
288		288
289	r = (_flatten_vg(fid, mem, vg, &pvds, fid->fmt->cmd->dev_dir,	289	r = (_flatten_vg(fid, mem, vg, &pvds, fid->fmt->cmd->dev_dir,
290	fid->fmt->cmd->filter) &&	290	fid->fmt->cmd->filter) &&
Lines 296-302 Link Here
296	}	296	}
297		297
298	static int _pv_read(const struct format_type fmt, const char pv_name,	298	static int _pv_read(const struct format_type fmt, const char pv_name,
299	struct physical_volume pv, struct list mdas)	299	struct physical_volume pv, struct lvm_list mdas)
300	{	300	{
301	struct pool *mem = pool_create(1024);	301	struct pool *mem = pool_create(1024);
302	struct disk_list *dl;	302	struct disk_list *dl;
Lines 306-327 Link Here
306	log_very_verbose("Reading physical volume data %s from disk", pv_name);	306	log_very_verbose("Reading physical volume data %s from disk", pv_name);
307		307
308	if (!mem) {	308	if (!mem) {
309	stack;	309	STACK;
310	return 0;	310	return 0;
311	}	311	}
312		312
313	if (!(dev = dev_cache_get(pv_name, fmt->cmd->filter))) {	313	if (!(dev = dev_cache_get(pv_name, fmt->cmd->filter))) {
314	stack;	314	STACK;
315	goto out;	315	goto out;
316	}	316	}
317		317
318	if (!(dl = read_disk(fmt, dev, mem, NULL))) {	318	if (!(dl = read_disk(fmt, dev, mem, NULL))) {
319	stack;	319	STACK;
320	goto out;	320	goto out;
321	}	321	}
322		322
323	if (!import_pv(fmt->cmd->mem, dl->dev, NULL, pv, &dl->pvd)) {	323	if (!import_pv(fmt->cmd->mem, dl->dev, NULL, pv, &dl->pvd)) {
324	stack;	324	STACK;
325	goto out;	325	goto out;
326	}	326	}
327		327
Lines 338-344 Link Here
338	uint64_t pe_start, uint32_t extent_count,	338	uint64_t pe_start, uint32_t extent_count,
339	uint32_t extent_size,	339	uint32_t extent_size,
340	int pvmetadatacopies,	340	int pvmetadatacopies,
341	uint64_t pvmetadatasize, struct list *mdas,	341	uint64_t pvmetadatasize, struct lvm_list *mdas,
342	struct physical_volume pv, struct volume_group vg)	342	struct physical_volume pv, struct volume_group vg)
343	{	343	{
344	if (pv->size > MAX_PV_SIZE)	344	if (pv->size > MAX_PV_SIZE)
Lines 358-364 Link Here
358	* This works out pe_start and pe_count.	358	* This works out pe_start and pe_count.
359	*/	359	*/
360	if (!calculate_extent_count(pv, extent_size, extent_count, pe_start)) {	360	if (!calculate_extent_count(pv, extent_size, extent_count, pe_start)) {
361	stack;	361	STACK;
362	return 0;	362	return 0;
363	}	363	}
364		364
Lines 395-439 Link Here
395	}	395	}
396		396
397	static int _pv_write(const struct format_type fmt, struct physical_volume pv,	397	static int _pv_write(const struct format_type fmt, struct physical_volume pv,
398	struct list *mdas, int64_t sector)	398	struct lvm_list *mdas, int64_t sector)
399	{	399	{
400	struct pool *mem;	400	struct pool *mem;
401	struct disk_list *dl;	401	struct disk_list *dl;
402	struct list pvs;	402	struct lvm_list pvs;
403	struct label *label;	403	struct label *label;
404	struct lvmcache_info *info;	404	struct lvmcache_info *info;
405		405
406	if (!(info = lvmcache_add(fmt->labeller, (char *) &pv->id, pv->dev,	406	if (!(info = lvmcache_add(fmt->labeller, (char *) &pv->id, pv->dev,
407	pv->vg_name, NULL))) {	407	pv->vg_name, NULL))) {
408	stack;	408	STACK;
409	return 0;	409	return 0;
410	}	410	}
411	label = info->label;	411	label = info->label;
412	info->device_size = pv->size << SECTOR_SHIFT;	412	info->device_size = pv->size << SECTOR_SHIFT;
413	info->fmt = fmt;	413	info->fmt = fmt;
414		414
415	list_init(&info->mdas);	415	lvm_list_init(&info->mdas);
416		416
417	list_init(&pvs);	417	lvm_list_init(&pvs);
418		418
419	/* Ensure any residual PE structure is gone */	419	/* Ensure any residual PE structure is gone */
420	pv->pe_size = pv->pe_count = 0;	420	pv->pe_size = pv->pe_count = 0;
421	pv->pe_start = PE_ALIGN;	421	pv->pe_start = PE_ALIGN;
422		422
423	if (!(mem = pool_create(1024))) {	423	if (!(mem = pool_create(1024))) {
424	stack;	424	STACK;
425	return 0;	425	return 0;
426	}	426	}
427		427
428	if (!(dl = pool_alloc(mem, sizeof(*dl)))) {	428	if (!(dl = pool_alloc(mem, sizeof(*dl)))) {
429	stack;	429	STACK;
430	goto bad;	430	goto bad;
431	}	431	}
432	dl->mem = mem;	432	dl->mem = mem;
433	dl->dev = pv->dev;	433	dl->dev = pv->dev;
434		434
435	if (!export_pv(fmt->cmd, mem, NULL, &dl->pvd, pv)) {	435	if (!export_pv(fmt->cmd, mem, NULL, &dl->pvd, pv)) {
436	stack;	436	STACK;
437	goto bad;	437	goto bad;
438	}	438	}
439		439
Lines 443-451 Link Here
443	dl->pvd.pv_on_disk.size = PV_SIZE;	443	dl->pvd.pv_on_disk.size = PV_SIZE;
444	dl->pvd.pe_on_disk.base = PE_ALIGN << SECTOR_SHIFT;	444	dl->pvd.pe_on_disk.base = PE_ALIGN << SECTOR_SHIFT;
445		445
446	list_add(&pvs, &dl->list);	446	lvm_list_add(&pvs, &dl->list);
447	if (!write_disks(fmt, &pvs)) {	447	if (!write_disks(fmt, &pvs)) {
448	stack;	448	STACK;
449	goto bad;	449	goto bad;
450	}	450	}
451		451
Lines 508-530 Link Here
508	struct metadata_area *mda;	508	struct metadata_area *mda;
509		509
510	if (!(fid = pool_alloc(fmt->cmd->mem, sizeof(*fid)))) {	510	if (!(fid = pool_alloc(fmt->cmd->mem, sizeof(*fid)))) {
511	stack;	511	STACK;
512	return NULL;	512	return NULL;
513	}	513	}
514		514
515	fid->fmt = fmt;	515	fid->fmt = fmt;
516	list_init(&fid->metadata_areas);	516	lvm_list_init(&fid->metadata_areas);
517		517
518	/* Define a NULL metadata area */	518	/* Define a NULL metadata area */
519	if (!(mda = pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {	519	if (!(mda = pool_alloc(fmt->cmd->mem, sizeof(*mda)))) {
520	stack;	520	STACK;
521	pool_free(fmt->cmd->mem, fid);	521	pool_free(fmt->cmd->mem, fid);
522	return NULL;	522	return NULL;
523	}	523	}
524		524
525	mda->ops = &_metadata_format1_ops;	525	mda->ops = &_metadata_format1_ops;
526	mda->metadata_locn = NULL;	526	mda->metadata_locn = NULL;
527	list_add(&fid->metadata_areas, &mda->list);	527	lvm_list_add(&fid->metadata_areas, &mda->list);
528		528
529	return fid;	529	return fid;
530	}	530	}
Lines 560-566 Link Here
560	struct format_type fmt = dbg_malloc(sizeof(fmt));	560	struct format_type fmt = dbg_malloc(sizeof(fmt));
561		561
562	if (!fmt) {	562	if (!fmt) {
563	stack;	563	STACK;
564	return NULL;	564	return NULL;
565	}	565	}
566		566

Lines 57-63 Link Here

(-)LVM2.2.00.15.orig/lib/format1/import-export.c (-76 / +76 lines)
57		57
58	pv->dev = dev;	58	pv->dev = dev;
59	if (!(pv->vg_name = pool_strdup(mem, pvd->vg_name))) {	59	if (!(pv->vg_name = pool_strdup(mem, pvd->vg_name))) {
60	stack;	60	STACK;
61	return 0;	61	return 0;
62	}	62	}
63		63
Lines 87-93 Link Here
87	pv->pe_count = pvd->pe_total;	87	pv->pe_count = pvd->pe_total;
88	pv->pe_alloc_count = pvd->pe_allocated;	88	pv->pe_alloc_count = pvd->pe_allocated;
89		89
90	list_init(&pv->tags);	90	lvm_list_init(&pv->tags);
91		91
92	return 1;	92	return 1;
93	}	93	}
Lines 117-123 Link Here
117	memcpy(pvd->pv_uuid, pv->id.uuid, ID_LEN);	117	memcpy(pvd->pv_uuid, pv->id.uuid, ID_LEN);
118		118
119	if (!_check_vg_name(pv->vg_name)) {	119	if (!_check_vg_name(pv->vg_name)) {
120	stack;	120	STACK;
121	return 0;	121	return 0;
122	}	122	}
123		123
Lines 137-143 Link Here
137	strncmp(vg->system_id, EXPORTED_TAG,	137	strncmp(vg->system_id, EXPORTED_TAG,
138	sizeof(EXPORTED_TAG) - 1)) {	138	sizeof(EXPORTED_TAG) - 1)) {
139	if (!_system_id(cmd, pvd->system_id, EXPORTED_TAG)) {	139	if (!_system_id(cmd, pvd->system_id, EXPORTED_TAG)) {
140	stack;	140	STACK;
141	return 0;	141	return 0;
142	}	142	}
143	}	143	}
Lines 154-160 Link Here
154	if (vg && !(vg->status & EXPORTED_VG) && *vg->system_id &&	154	if (vg && !(vg->status & EXPORTED_VG) && *vg->system_id &&
155	!strncmp(vg->system_id, EXPORTED_TAG, sizeof(EXPORTED_TAG) - 1)) {	155	!strncmp(vg->system_id, EXPORTED_TAG, sizeof(EXPORTED_TAG) - 1)) {
156	if (!_system_id(cmd, pvd->system_id, IMPORTED_TAG)) {	156	if (!_system_id(cmd, pvd->system_id, IMPORTED_TAG)) {
157	stack;	157	STACK;
158	return 0;	158	return 0;
159	}	159	}
160	}	160	}
Lines 162-168 Link Here
162	/* Generate system_id if PV is in VG */	162	/* Generate system_id if PV is in VG */
163	if (!pvd->system_id \|\| !*pvd->system_id)	163	if (!pvd->system_id \|\| !*pvd->system_id)
164	if (!_system_id(cmd, pvd->system_id, "")) {	164	if (!_system_id(cmd, pvd->system_id, "")) {
165	stack;	165	STACK;
166	return 0;	166	return 0;
167	}	167	}
168		168
Lines 197-213 Link Here
197	memcpy(vg->id.uuid, vgd->vg_uuid, ID_LEN);	197	memcpy(vg->id.uuid, vgd->vg_uuid, ID_LEN);
198		198
199	if (!_check_vg_name(dl->pvd.vg_name)) {	199	if (!_check_vg_name(dl->pvd.vg_name)) {
200	stack;	200	STACK;
201	return 0;	201	return 0;
202	}	202	}
203		203
204	if (!(vg->name = pool_strdup(mem, dl->pvd.vg_name))) {	204	if (!(vg->name = pool_strdup(mem, dl->pvd.vg_name))) {
205	stack;	205	STACK;
206	return 0;	206	return 0;
207	}	207	}
208		208
209	if (!(vg->system_id = pool_alloc(mem, NAME_LEN))) {	209	if (!(vg->system_id = pool_alloc(mem, NAME_LEN))) {
210	stack;	210	STACK;
211	return 0;	211	return 0;
212	}	212	}
213		213
Lines 284-290 Link Here
284	lvid_from_lvnum(&lv->lvid, &lv->vg->id, lvd->lv_number);	284	lvid_from_lvnum(&lv->lvid, &lv->vg->id, lvd->lv_number);
285		285
286	if (!(lv->name = _create_lv_name(mem, lvd->lv_name))) {	286	if (!(lv->name = _create_lv_name(mem, lvd->lv_name))) {
287	stack;	287	STACK;
288	return 0;	288	return 0;
289	}	289	}
290		290
Lines 321-328 Link Here
321	lv->size = lvd->lv_size;	321	lv->size = lvd->lv_size;
322	lv->le_count = lvd->lv_allocated_le;	322	lv->le_count = lvd->lv_allocated_le;
323		323
324	list_init(&lv->segments);	324	lvm_list_init(&lv->segments);
325	list_init(&lv->tags);	325	lvm_list_init(&lv->tags);
326		326
327	return 1;	327	return 1;
328	}	328	}
Lines 354-362 Link Here
354		354
355	lvd->lv_read_ahead = lv->read_ahead;	355	lvd->lv_read_ahead = lv->read_ahead;
356	lvd->lv_stripes =	356	lvd->lv_stripes =
357	list_item(lv->segments.n, struct lv_segment)->area_count;	357	lvm_list_item(lv->segments.n, struct lv_segment)->area_count;
358	lvd->lv_stripesize =	358	lvd->lv_stripesize =
359	list_item(lv->segments.n, struct lv_segment)->stripe_size;	359	lvm_list_item(lv->segments.n, struct lv_segment)->stripe_size;
360		360
361	lvd->lv_size = lv->size;	361	lvd->lv_size = lv->size;
362	lvd->lv_allocated_le = lv->le_count;	362	lvd->lv_allocated_le = lv->le_count;
Lines 371-383 Link Here
371	int export_extents(struct disk_list *dl, uint32_t lv_num,	371	int export_extents(struct disk_list *dl, uint32_t lv_num,
372	struct logical_volume lv, struct physical_volume pv)	372	struct logical_volume lv, struct physical_volume pv)
373	{	373	{
374	struct list *segh;	374	struct lvm_list *segh;
375	struct pe_disk *ped;	375	struct pe_disk *ped;
376	struct lv_segment *seg;	376	struct lv_segment *seg;
377	uint32_t pe, s;	377	uint32_t pe, s;
378		378
379	list_iterate(segh, &lv->segments) {	379	lvm_list_iterate(segh, &lv->segments) {
380	seg = list_item(segh, struct lv_segment);	380	seg = lvm_list_item(segh, struct lv_segment);
381		381
382	for (s = 0; s < seg->area_count; s++) {	382	for (s = 0; s < seg->area_count; s++) {
383	if (seg->type != SEG_STRIPED) {	383	if (seg->type != SEG_STRIPED) {
Lines 407-436 Link Here
407		407
408	int import_pvs(const struct format_type fmt, struct pool mem,	408	int import_pvs(const struct format_type fmt, struct pool mem,
409	struct volume_group *vg,	409	struct volume_group *vg,
410	struct list pvds, struct list results, int *count)	410	struct lvm_list pvds, struct lvm_list results, int *count)
411	{	411	{
412	struct list *pvdh;	412	struct lvm_list *pvdh;
413	struct disk_list *dl;	413	struct disk_list *dl;
414	struct pv_list *pvl;	414	struct pv_list *pvl;
415		415
416	*count = 0;	416	*count = 0;
417	list_iterate(pvdh, pvds) {	417	lvm_list_iterate(pvdh, pvds) {
418		418
419	dl = list_item(pvdh, struct disk_list);	419	dl = lvm_list_item(pvdh, struct disk_list);
420		420
421	if (!(pvl = pool_zalloc(mem, sizeof(*pvl))) \|\|	421	if (!(pvl = pool_zalloc(mem, sizeof(*pvl))) \|\|
422	!(pvl->pv = pool_alloc(mem, sizeof(*pvl->pv)))) {	422	!(pvl->pv = pool_alloc(mem, sizeof(*pvl->pv)))) {
423	stack;	423	STACK;
424	return 0;	424	return 0;
425	}	425	}
426		426
427	if (!import_pv(mem, dl->dev, vg, pvl->pv, &dl->pvd)) {	427	if (!import_pv(mem, dl->dev, vg, pvl->pv, &dl->pvd)) {
428	stack;	428	STACK;
429	return 0;	429	return 0;
430	}	430	}
431		431
432	pvl->pv->fmt = fmt;	432	pvl->pv->fmt = fmt;
433	list_add(results, &pvl->list);	433	lvm_list_add(results, &pvl->list);
434	(*count)++;	434	(*count)++;
435	}	435	}
436		436
Lines 446-484 Link Here
446		446
447	if (!(ll = pool_zalloc(mem, sizeof(*ll))) \|\|	447	if (!(ll = pool_zalloc(mem, sizeof(*ll))) \|\|
448	!(ll->lv = pool_zalloc(mem, sizeof(*ll->lv)))) {	448	!(ll->lv = pool_zalloc(mem, sizeof(*ll->lv)))) {
449	stack;	449	STACK;
450	return NULL;	450	return NULL;
451	}	451	}
452	lv = ll->lv;	452	lv = ll->lv;
453	lv->vg = vg;	453	lv->vg = vg;
454		454
455	if (!import_lv(mem, lv, lvd)) {	455	if (!import_lv(mem, lv, lvd)) {
456	stack;	456	STACK;
457	return NULL;	457	return NULL;
458	}	458	}
459		459
460	list_add(&vg->lvs, &ll->list);	460	lvm_list_add(&vg->lvs, &ll->list);
461	vg->lv_count++;	461	vg->lv_count++;
462		462
463	return lv;	463	return lv;
464	}	464	}
465		465
466	int import_lvs(struct pool mem, struct volume_group vg, struct list *pvds)	466	int import_lvs(struct pool mem, struct volume_group vg, struct lvm_list *pvds)
467	{	467	{
468	struct disk_list *dl;	468	struct disk_list *dl;
469	struct lvd_list *ll;	469	struct lvd_list *ll;
470	struct lv_disk *lvd;	470	struct lv_disk *lvd;
471	struct list pvdh, lvdh;	471	struct lvm_list pvdh, lvdh;
472		472
473	list_iterate(pvdh, pvds) {	473	lvm_list_iterate(pvdh, pvds) {
474	dl = list_item(pvdh, struct disk_list);	474	dl = lvm_list_item(pvdh, struct disk_list);
475	list_iterate(lvdh, &dl->lvds) {	475	lvm_list_iterate(lvdh, &dl->lvds) {
476	ll = list_item(lvdh, struct lvd_list);	476	ll = lvm_list_item(lvdh, struct lvd_list);
477	lvd = &ll->lvd;	477	lvd = &ll->lvd;
478		478
479	if (!find_lv(vg, lvd->lv_name) &&	479	if (!find_lv(vg, lvd->lv_name) &&
480	!_add_lv(mem, vg, lvd)) {	480	!_add_lv(mem, vg, lvd)) {
481	stack;	481	STACK;
482	return 0;	482	return 0;
483	}	483	}
484	}	484	}
Lines 492-498 Link Here
492	struct physical_volume pv, const char dev_dir)	492	struct physical_volume pv, const char dev_dir)
493	{	493	{
494	int r = 0;	494	int r = 0;
495	struct list lvh, sh;	495	struct lvm_list lvh, sh;
496	struct lv_list *ll;	496	struct lv_list *ll;
497	struct lvd_list *lvdl;	497	struct lvd_list *lvdl;
498	size_t len;	498	size_t len;
Lines 500-511 Link Here
500	struct hash_table *lvd_hash;	500	struct hash_table *lvd_hash;
501		501
502	if (!_check_vg_name(vg->name)) {	502	if (!_check_vg_name(vg->name)) {
503	stack;	503	STACK;
504	return 0;	504	return 0;
505	}	505	}
506		506
507	if (!(lvd_hash = hash_create(32))) {	507	if (!(lvd_hash = hash_create(32))) {
508	stack;	508	STACK;
509	return 0;	509	return 0;
510	}	510	}
511		511
Lines 514-528 Link Here
514	*/	514	*/
515	len = sizeof(struct pe_disk) * dl->pvd.pe_total;	515	len = sizeof(struct pe_disk) * dl->pvd.pe_total;
516	if (!(dl->extents = pool_alloc(dl->mem, len))) {	516	if (!(dl->extents = pool_alloc(dl->mem, len))) {
517	stack;	517	STACK;
518	goto out;	518	goto out;
519	}	519	}
520	memset(dl->extents, 0, len);	520	memset(dl->extents, 0, len);
521		521
522	list_iterate(lvh, &vg->lvs) {	522	lvm_list_iterate(lvh, &vg->lvs) {
523	ll = list_item(lvh, struct lv_list);	523	ll = lvm_list_item(lvh, struct lv_list);
524	if (!(lvdl = pool_alloc(dl->mem, sizeof(*lvdl)))) {	524	if (!(lvdl = pool_alloc(dl->mem, sizeof(*lvdl)))) {
525	stack;	525	STACK;
526	goto out;	526	goto out;
527	}	527	}
528		528
Lines 533-548 Link Here
533	lvdl->lvd.lv_number = lv_num;	533	lvdl->lvd.lv_number = lv_num;
534		534
535	if (!hash_insert(lvd_hash, ll->lv->name, &lvdl->lvd)) {	535	if (!hash_insert(lvd_hash, ll->lv->name, &lvdl->lvd)) {
536	stack;	536	STACK;
537	goto out;	537	goto out;
538	}	538	}
539		539
540	if (!export_extents(dl, lv_num + 1, ll->lv, pv)) {	540	if (!export_extents(dl, lv_num + 1, ll->lv, pv)) {
541	stack;	541	STACK;
542	goto out;	542	goto out;
543	}	543	}
544		544
545	list_add(&dl->lvds, &lvdl->list);	545	lvm_list_add(&dl->lvds, &lvdl->list);
546	dl->pvd.lv_cur++;	546	dl->pvd.lv_cur++;
547	}	547	}
548		548
Lines 550-558 Link Here
550	* Now we need to run through the snapshots, exporting	550	* Now we need to run through the snapshots, exporting
551	* the SNAPSHOT_ORG flags etc.	551	* the SNAPSHOT_ORG flags etc.
552	*/	552	*/
553	list_iterate(sh, &vg->snapshots) {	553	lvm_list_iterate(sh, &vg->snapshots) {
554	struct lv_disk org, cow;	554	struct lv_disk org, cow;
555	struct snapshot *s = list_item(sh,	555	struct snapshot *s = lvm_list_item(sh,
556	struct snapshot_list)->snapshot;	556	struct snapshot_list)->snapshot;
557		557
558	if (!(org = hash_lookup(lvd_hash, s->origin->name))) {	558	if (!(org = hash_lookup(lvd_hash, s->origin->name))) {
Lines 584-593 Link Here
584	* FIXME: More inefficient code.	584	* FIXME: More inefficient code.
585	*/	585	*/
586	int import_snapshots(struct pool mem, struct volume_group vg,	586	int import_snapshots(struct pool mem, struct volume_group vg,
587	struct list *pvds)	587	struct lvm_list *pvds)
588	{	588	{
589	struct logical_volume *lvs[MAX_LV];	589	struct logical_volume *lvs[MAX_LV];
590	struct list pvdh, lvdh;	590	struct lvm_list pvdh, lvdh;
591	struct disk_list *dl;	591	struct disk_list *dl;
592	struct lv_disk *lvd;	592	struct lv_disk *lvd;
593	int lvnum;	593	int lvnum;
Lines 595-605 Link Here
595		595
596	/* build an index of lv numbers */	596	/* build an index of lv numbers */
597	memset(lvs, 0, sizeof(lvs));	597	memset(lvs, 0, sizeof(lvs));
598	list_iterate(pvdh, pvds) {	598	lvm_list_iterate(pvdh, pvds) {
599	dl = list_item(pvdh, struct disk_list);	599	dl = lvm_list_item(pvdh, struct disk_list);
600		600
601	list_iterate(lvdh, &dl->lvds) {	601	lvm_list_iterate(lvdh, &dl->lvds) {
602	lvd = &(list_item(lvdh, struct lvd_list)->lvd);	602	lvd = &(lvm_list_item(lvdh, struct lvd_list)->lvd);
603		603
604	lvnum = lvd->lv_number;	604	lvnum = lvd->lv_number;
605		605
Lines 621-631 Link Here
621	/*	621	/*
622	* Now iterate through yet again adding the snapshots.	622	* Now iterate through yet again adding the snapshots.
623	*/	623	*/
624	list_iterate(pvdh, pvds) {	624	lvm_list_iterate(pvdh, pvds) {
625	dl = list_item(pvdh, struct disk_list);	625	dl = lvm_list_item(pvdh, struct disk_list);
626		626
627	list_iterate(lvdh, &dl->lvds) {	627	lvm_list_iterate(lvdh, &dl->lvds) {
628	lvd = &(list_item(lvdh, struct lvd_list)->lvd);	628	lvd = &(lvm_list_item(lvdh, struct lvd_list)->lvd);
629		629
630	if (!(lvd->lv_access & LV_SNAPSHOT))	630	if (!(lvd->lv_access & LV_SNAPSHOT))
631	continue;	631	continue;
Lines 658-676 Link Here
658	{	658	{
659	struct uuid_list *ul;	659	struct uuid_list *ul;
660	struct pv_list *pvl;	660	struct pv_list *pvl;
661	struct list *pvh;	661	struct lvm_list *pvh;
662		662
663	list_iterate(pvh, &vg->pvs) {	663	lvm_list_iterate(pvh, &vg->pvs) {
664	pvl = list_item(pvh, struct pv_list);	664	pvl = lvm_list_item(pvh, struct pv_list);
665	if (!(ul = pool_alloc(dl->mem, sizeof(*ul)))) {	665	if (!(ul = pool_alloc(dl->mem, sizeof(*ul)))) {
666	stack;	666	STACK;
667	return 0;	667	return 0;
668	}	668	}
669		669
670	memset(ul->uuid, 0, sizeof(ul->uuid));	670	memset(ul->uuid, 0, sizeof(ul->uuid));
671	memcpy(ul->uuid, pvl->pv->id.uuid, ID_LEN);	671	memcpy(ul->uuid, pvl->pv->id.uuid, ID_LEN);
672		672
673	list_add(&dl->uuids, &ul->list);	673	lvm_list_add(&dl->uuids, &ul->list);
674	}	674	}
675	return 1;	675	return 1;
676	}	676	}
Lines 679-692 Link Here
679	* This calculates the nasty pv_number field	679	* This calculates the nasty pv_number field
680	* used by LVM1.	680	* used by LVM1.
681	*/	681	*/
682	void export_numbers(struct list pvds, struct volume_group vg)	682	void export_numbers(struct lvm_list pvds, struct volume_group vg)
683	{	683	{
684	struct list *pvdh;	684	struct lvm_list *pvdh;
685	struct disk_list *dl;	685	struct disk_list *dl;
686	int pv_num = 1;	686	int pv_num = 1;
687		687
688	list_iterate(pvdh, pvds) {	688	lvm_list_iterate(pvdh, pvds) {
689	dl = list_item(pvdh, struct disk_list);	689	dl = lvm_list_item(pvdh, struct disk_list);
690	dl->pvd.pv_number = pv_num++;	690	dl->pvd.pv_number = pv_num++;
691	}	691	}
692	}	692	}
Lines 694-731 Link Here
694	/*	694	/*
695	* Calculate vg_disk->pv_act.	695	* Calculate vg_disk->pv_act.
696	*/	696	*/
697	void export_pv_act(struct list *pvds)	697	void export_pv_act(struct lvm_list *pvds)
698	{	698	{
699	struct list *pvdh;	699	struct lvm_list *pvdh;
700	struct disk_list *dl;	700	struct disk_list *dl;
701	int act = 0;	701	int act = 0;
702		702
703	list_iterate(pvdh, pvds) {	703	lvm_list_iterate(pvdh, pvds) {
704	dl = list_item(pvdh, struct disk_list);	704	dl = lvm_list_item(pvdh, struct disk_list);
705	if (dl->pvd.pv_status & PV_ACTIVE)	705	if (dl->pvd.pv_status & PV_ACTIVE)
706	act++;	706	act++;
707	}	707	}
708		708
709	list_iterate(pvdh, pvds) {	709	lvm_list_iterate(pvdh, pvds) {
710	dl = list_item(pvdh, struct disk_list);	710	dl = lvm_list_item(pvdh, struct disk_list);
711	dl->vgd.pv_act = act;	711	dl->vgd.pv_act = act;
712	}	712	}
713	}	713	}
714		714
715	int export_vg_number(struct format_instance fid, struct list pvds,	715	int export_vg_number(struct format_instance fid, struct lvm_list pvds,
716	const char vg_name, struct dev_filter filter)	716	const char vg_name, struct dev_filter filter)
717	{	717	{
718	struct list *pvdh;	718	struct lvm_list *pvdh;
719	struct disk_list *dl;	719	struct disk_list *dl;
720	int vg_num;	720	int vg_num;
721		721
722	if (!get_free_vg_number(fid, filter, vg_name, &vg_num)) {	722	if (!get_free_vg_number(fid, filter, vg_name, &vg_num)) {
723	stack;	723	STACK;
724	return 0;	724	return 0;
725	}	725	}
726		726
727	list_iterate(pvdh, pvds) {	727	lvm_list_iterate(pvdh, pvds) {
728	dl = list_item(pvdh, struct disk_list);	728	dl = lvm_list_item(pvdh, struct disk_list);
729	dl->vgd.vg_number = vg_num;	729	dl->vgd.vg_number = vg_num;
730	}	730	}
731		731

Lines 46-52 Link Here

(-)LVM2.2.00.15.orig/lib/format1/import-extents.c (-22 / +22 lines)
46	struct volume_group *vg)	46	struct volume_group *vg)
47	{	47	{
48	struct hash_table *maps = hash_create(32);	48	struct hash_table *maps = hash_create(32);
49	struct list *llh;	49	struct lvm_list *llh;
50	struct lv_list *ll;	50	struct lv_list *ll;
51	struct lv_map *lvm;	51	struct lv_map *lvm;
52		52
Lines 56-78 Link Here
56	return NULL;	56	return NULL;
57	}	57	}
58		58
59	list_iterate(llh, &vg->lvs) {	59	lvm_list_iterate(llh, &vg->lvs) {
60	ll = list_item(llh, struct lv_list);	60	ll = lvm_list_item(llh, struct lv_list);
61		61
62	if (!(lvm = pool_alloc(mem, sizeof(*lvm)))) {	62	if (!(lvm = pool_alloc(mem, sizeof(*lvm)))) {
63	stack;	63	STACK;
64	goto bad;	64	goto bad;
65	}	65	}
66		66
67	lvm->lv = ll->lv;	67	lvm->lv = ll->lv;
68	if (!(lvm->map = pool_zalloc(mem, sizeof(*lvm->map)	68	if (!(lvm->map = pool_zalloc(mem, sizeof(*lvm->map)
69	* ll->lv->le_count))) {	69	* ll->lv->le_count))) {
70	stack;	70	STACK;
71	goto bad;	71	goto bad;
72	}	72	}
73		73
74	if (!hash_insert(maps, ll->lv->name, lvm)) {	74	if (!hash_insert(maps, ll->lv->name, lvm)) {
75	stack;	75	STACK;
76	goto bad;	76	goto bad;
77	}	77	}
78	}	78	}
Lines 87-98 Link Here
87	static int _fill_lv_array(struct lv_map **lvs,	87	static int _fill_lv_array(struct lv_map **lvs,
88	struct hash_table maps, struct disk_list dl)	88	struct hash_table maps, struct disk_list dl)
89	{	89	{
90	struct list *lvh;	90	struct lvm_list *lvh;
91	struct lv_map *lvm;	91	struct lv_map *lvm;
92		92
93	memset(lvs, 0, sizeof(lvs) MAX_LV);	93	memset(lvs, 0, sizeof(lvs) MAX_LV);
94	list_iterate(lvh, &dl->lvds) {	94	lvm_list_iterate(lvh, &dl->lvds) {
95	struct lvd_list *ll = list_item(lvh, struct lvd_list);	95	struct lvd_list *ll = lvm_list_item(lvh, struct lvd_list);
96		96
97	if (!(lvm = hash_lookup(maps, strrchr(ll->lvd.lv_name, '/')	97	if (!(lvm = hash_lookup(maps, strrchr(ll->lvd.lv_name, '/')
98	+ 1))) {	98	+ 1))) {
Lines 112-134 Link Here
112	}	112	}
113		113
114	static int _fill_maps(struct hash_table maps, struct volume_group vg,	114	static int _fill_maps(struct hash_table maps, struct volume_group vg,
115	struct list *pvds)	115	struct lvm_list *pvds)
116	{	116	{
117	struct list *pvdh;	117	struct lvm_list *pvdh;
118	struct disk_list *dl;	118	struct disk_list *dl;
119	struct physical_volume *pv;	119	struct physical_volume *pv;
120	struct lv_map lvms[MAX_LV], lvm;	120	struct lv_map lvms[MAX_LV], lvm;
121	struct pe_disk *e;	121	struct pe_disk *e;
122	uint32_t i, lv_num, le;	122	uint32_t i, lv_num, le;
123		123
124	list_iterate(pvdh, pvds) {	124	lvm_list_iterate(pvdh, pvds) {
125	dl = list_item(pvdh, struct disk_list);	125	dl = lvm_list_item(pvdh, struct disk_list);
126	pv = find_pv(vg, dl->dev);	126	pv = find_pv(vg, dl->dev);
127	e = dl->extents;	127	e = dl->extents;
128		128
129	/* build an array of lv's for this pv */	129	/* build an array of lv's for this pv */
130	if (!_fill_lv_array(lvms, maps, dl)) {	130	if (!_fill_lv_array(lvms, maps, dl)) {
131	stack;	131	STACK;
132	return 0;	132	return 0;
133	}	133	}
134		134
Lines 194-200 Link Here
194	lvm = (struct lv_map *) hash_get_data(maps, n);	194	lvm = (struct lv_map *) hash_get_data(maps, n);
195		195
196	if (!_check_single_map(lvm)) {	196	if (!_check_single_map(lvm)) {
197	stack;	197	STACK;
198	return 0;	198	return 0;
199	}	199	}
200	}	200	}
Lines 231-237 Link Here
231		231
232	le += seg->len;	232	le += seg->len;
233		233
234	list_add(&lvm->lv->segments, &seg->list);	234	lvm_list_add(&lvm->lv->segments, &seg->list);
235	}	235	}
236		236
237	return 1;	237	return 1;
Lines 274-280 Link Here
274		274
275	while (le < len) {	275	while (le < len) {
276	if (!(seg = alloc_lv_segment(mem, lvm->stripes))) {	276	if (!(seg = alloc_lv_segment(mem, lvm->stripes))) {
277	stack;	277	STACK;
278	return 0;	278	return 0;
279	}	279	}
280		280
Lines 306-312 Link Here
306	le += seg->len;	306	le += seg->len;
307	seg->len *= seg->area_count;	307	seg->len *= seg->area_count;
308		308
309	list_add(&lvm->lv->segments, &seg->list);	309	lvm_list_add(&lvm->lv->segments, &seg->list);
310	}	310	}
311		311
312	return 1;	312	return 1;
Lines 326-332 Link Here
326	for (n = hash_get_first(maps); n; n = hash_get_next(maps, n)) {	326	for (n = hash_get_first(maps); n; n = hash_get_next(maps, n)) {
327	lvm = (struct lv_map *) hash_get_data(maps, n);	327	lvm = (struct lv_map *) hash_get_data(maps, n);
328	if (!_build_segments(mem, lvm)) {	328	if (!_build_segments(mem, lvm)) {
329	stack;	329	STACK;
330	return 0;	330	return 0;
331	}	331	}
332	}	332	}
Lines 334-347 Link Here
334	return 1;	334	return 1;
335	}	335	}
336		336
337	int import_extents(struct pool mem, struct volume_group vg, struct list *pvds)	337	int import_extents(struct pool mem, struct volume_group vg, struct lvm_list *pvds)
338	{	338	{
339	int r = 0;	339	int r = 0;
340	struct pool scratch = pool_create(10 1024);	340	struct pool scratch = pool_create(10 1024);
341	struct hash_table *maps;	341	struct hash_table *maps;
342		342
343	if (!scratch) {	343	if (!scratch) {
344	stack;	344	STACK;
345	return 0;	345	return 0;
346	}	346	}
347		347
Lines 356-362 Link Here
356	}	356	}
357		357
358	if (!_check_maps_are_complete(maps) && !(vg->status & PARTIAL_VG)) {	358	if (!_check_maps_are_complete(maps) && !(vg->status & PARTIAL_VG)) {
359	stack;	359	STACK;
360	goto out;	360	goto out;
361	}	361	}
362		362

Lines 62-74 Link Here

(-)LVM2.2.00.15.orig/lib/format1/lvm1-label.c (-2 / +2 lines)
62		62
63	munge_exported_vg(pvd);	63	munge_exported_vg(pvd);
64	if (!(info = lvmcache_add(l, pvd->pv_uuid, dev, pvd->vg_name, NULL))) {	64	if (!(info = lvmcache_add(l, pvd->pv_uuid, dev, pvd->vg_name, NULL))) {
65	stack;	65	STACK;
66	return 0;	66	return 0;
67	}	67	}
68	*label = info->label;	68	*label = info->label;
69		69
70	info->device_size = xlate32(pvd->pv_size) << SECTOR_SHIFT;	70	info->device_size = xlate32(pvd->pv_size) << SECTOR_SHIFT;
71	list_init(&info->mdas);	71	lvm_list_init(&info->mdas);
72		72
73	info->status &= ~CACHE_INVALID;	73	info->status &= ~CACHE_INVALID;
74		74

Lines 27-54 Link Here

(-)LVM2.2.00.15.orig/lib/format1/vg_number.c (-7 / +7 lines)
27	int get_free_vg_number(struct format_instance fid, struct dev_filter filter,	27	int get_free_vg_number(struct format_instance fid, struct dev_filter filter,
28	const char candidate_vg, int result)	28	const char candidate_vg, int result)
29	{	29	{
30	struct list *pvh;	30	struct lvm_list *pvh;
31	struct list all_pvs;	31	struct lvm_list all_pvs;
32	struct disk_list *dl;	32	struct disk_list *dl;
33	struct pool mem = pool_create(10 1024);	33	struct pool mem = pool_create(10 1024);
34	int numbers[MAX_VG], i, r = 0;	34	int numbers[MAX_VG], i, r = 0;
35		35
36	list_init(&all_pvs);	36	lvm_list_init(&all_pvs);
37		37
38	if (!mem) {	38	if (!mem) {
39	stack;	39	STACK;
40	return 0;	40	return 0;
41	}	41	}
42		42
43	if (!read_pvs_in_vg(fid->fmt, NULL, filter, mem, &all_pvs)) {	43	if (!read_pvs_in_vg(fid->fmt, NULL, filter, mem, &all_pvs)) {
44	stack;	44	STACK;
45	goto out;	45	goto out;
46	}	46	}
47		47
48	memset(numbers, 0, sizeof(numbers));	48	memset(numbers, 0, sizeof(numbers));
49		49
50	list_iterate(pvh, &all_pvs) {	50	lvm_list_iterate(pvh, &all_pvs) {
51	dl = list_item(pvh, struct disk_list);	51	dl = lvm_list_item(pvh, struct disk_list);
52	if (!*dl->pvd.vg_name \|\| !strcmp(dl->pvd.vg_name, candidate_vg))	52	if (!*dl->pvd.vg_name \|\| !strcmp(dl->pvd.vg_name, candidate_vg))
53	continue;	53	continue;
54		54

Lines 50-56 Link Here

(-)LVM2.2.00.15.orig/lib/format_text/archive.c (-29 / +29 lines)
50	* with the least recent at the head.	50	* with the least recent at the head.
51	*/	51	*/
52	struct archive_file {	52	struct archive_file {
53	struct list list;	53	struct lvm_list list;
54		54
55	char *path;	55	char *path;
56	int index;	56	int index;
Lines 89-115 Link Here
89	return 1;	89	return 1;
90	}	90	}
91		91
92	static void _insert_file(struct list head, struct archive_file b)	92	static void _insert_file(struct lvm_list head, struct archive_file b)
93	{	93	{
94	struct list *bh;	94	struct lvm_list *bh;
95	struct archive_file *bf = NULL;	95	struct archive_file *bf = NULL;
96		96
97	if (list_empty(head)) {	97	if (lvm_list_empty(head)) {
98	list_add(head, &b->list);	98	lvm_list_add(head, &b->list);
99	return;	99	return;
100	}	100	}
101		101
102	/* index increases through list */	102	/* index increases through list */
103	list_iterate(bh, head) {	103	lvm_list_iterate(bh, head) {
104	bf = list_item(bh, struct archive_file);	104	bf = lvm_list_item(bh, struct archive_file);
105		105
106	if (bf->index > b->index) {	106	if (bf->index > b->index) {
107	list_add(&bf->list, &b->list);	107	lvm_list_add(&bf->list, &b->list);
108	return;	108	return;
109	}	109	}
110	}	110	}
111		111
112	list_add_h(&bf->list, &b->list);	112	lvm_list_add_h(&bf->list, &b->list);
113	}	113	}
114		114
115	static char _join(struct pool mem, const char dir, const char name)	115	static char _join(struct pool mem, const char dir, const char name)
Lines 119-125 Link Here
119	!pool_grow_object(mem, "/", 1) \|\|	119	!pool_grow_object(mem, "/", 1) \|\|
120	!pool_grow_object(mem, name, strlen(name)) \|\|	120	!pool_grow_object(mem, name, strlen(name)) \|\|
121	!pool_grow_object(mem, "\0", 1)) {	121	!pool_grow_object(mem, "\0", 1)) {
122	stack;	122	STACK;
123	return NULL;	123	return NULL;
124	}	124	}
125		125
Lines 129-149 Link Here
129	/*	129	/*
130	* Returns a list of archive_files.	130	* Returns a list of archive_files.
131	*/	131	*/
132	static struct list _scan_archive(struct pool mem,	132	static struct lvm_list _scan_archive(struct pool mem,
133	const char vgname, const char dir)	133	const char vgname, const char dir)
134	{	134	{
135	int i, count, ix;	135	int i, count, ix;
136	char vgname_found[64], *path;	136	char vgname_found[64], *path;
137	struct dirent **dirent;	137	struct dirent **dirent;
138	struct archive_file *af;	138	struct archive_file *af;
139	struct list *results;	139	struct lvm_list *results;
140		140
141	if (!(results = pool_alloc(mem, sizeof(*results)))) {	141	if (!(results = pool_alloc(mem, sizeof(*results)))) {
142	stack;	142	STACK;
143	return NULL;	143	return NULL;
144	}	144	}
145		145
146	list_init(results);	146	lvm_list_init(results);
147		147
148	/* Sort fails beyond 5-digit indexes */	148	/* Sort fails beyond 5-digit indexes */
149	if ((count = scandir(dir, &dirent, NULL, alphasort)) < 0) {	149	if ((count = scandir(dir, &dirent, NULL, alphasort)) < 0) {
Lines 166-172 Link Here
166	continue;	166	continue;
167		167
168	if (!(path = _join(mem, dir, dirent[i]->d_name))) {	168	if (!(path = _join(mem, dir, dirent[i]->d_name))) {
169	stack;	169	STACK;
170	goto out;	170	goto out;
171	}	171	}
172		172
Lines 196-205 Link Here
196	return results;	196	return results;
197	}	197	}
198		198
199	static void _remove_expired(struct list *archives, uint32_t archives_size,	199	static void _remove_expired(struct lvm_list *archives, uint32_t archives_size,
200	uint32_t retain_days, uint32_t min_archive)	200	uint32_t retain_days, uint32_t min_archive)
201	{	201	{
202	struct list *bh;	202	struct lvm_list *bh;
203	struct archive_file *bf;	203	struct archive_file *bf;
204	struct stat sb;	204	struct stat sb;
205	time_t retain_time;	205	time_t retain_time;
Lines 213-220 Link Here
213	retain_time = time(NULL) - (time_t) retain_days *SECS_PER_DAY;	213	retain_time = time(NULL) - (time_t) retain_days *SECS_PER_DAY;
214		214
215	/* Assume list is ordered oldest first (by index) */	215	/* Assume list is ordered oldest first (by index) */
216	list_iterate(bh, archives) {	216	lvm_list_iterate(bh, archives) {
217	bf = list_item(bh, struct archive_file);	217	bf = lvm_list_item(bh, struct archive_file);
218		218
219	/* Get the mtime of the file and unlink if too old */	219	/* Get the mtime of the file and unlink if too old */
220	if (stat(bf->path, &sb)) {	220	if (stat(bf->path, &sb)) {
Lines 244-250 Link Here
244	struct archive_file *last;	244	struct archive_file *last;
245	FILE *fp = NULL;	245	FILE *fp = NULL;
246	char temp_file[PATH_MAX], archive_name[PATH_MAX];	246	char temp_file[PATH_MAX], archive_name[PATH_MAX];
247	struct list *archives;	247	struct lvm_list *archives;
248		248
249	/*	249	/*
250	* Write the vg out to a temporary file.	250	* Write the vg out to a temporary file.
Lines 261-267 Link Here
261	}	261	}
262		262
263	if (!text_vg_export_file(vg, desc, fp)) {	263	if (!text_vg_export_file(vg, desc, fp)) {
264	stack;	264	STACK;
265	fclose(fp);	265	fclose(fp);
266	return 0;	266	return 0;
267	}	267	}
Lines 276-285 Link Here
276	return 0;	276	return 0;
277	}	277	}
278		278
279	if (list_empty(archives))	279	if (lvm_list_empty(archives))
280	ix = 0;	280	ix = 0;
281	else {	281	else {
282	last = list_item(archives->p, struct archive_file);	282	last = lvm_list_item(archives->p, struct archive_file);
283	ix = last->index + 1;	283	ix = last->index + 1;
284	}	284	}
285		285
Lines 299-305 Link Here
299	if (!renamed)	299	if (!renamed)
300	log_error("Archive rename failed for %s", temp_file);	300	log_error("Archive rename failed for %s", temp_file);
301		301
302	_remove_expired(archives, list_size(archives) + renamed, retain_days,	302	_remove_expired(archives, lvm_list_size(archives) + renamed, retain_days,
303	min_archive);	303	min_archive);
304		304
305	return 1;	305	return 1;
Lines 344-350 Link Here
344		344
345	int archive_list(struct cmd_context cmd, const char dir, const char *vgname)	345	int archive_list(struct cmd_context cmd, const char dir, const char *vgname)
346	{	346	{
347	struct list archives, ah;	347	struct lvm_list archives, ah;
348	struct archive_file *af;	348	struct archive_file *af;
349		349
350	if (!(archives = _scan_archive(cmd->mem, vgname, dir))) {	350	if (!(archives = _scan_archive(cmd->mem, vgname, dir))) {
Lines 352-362 Link Here
352	return 0;	352	return 0;
353	}	353	}
354		354
355	if (list_empty(archives))	355	if (lvm_list_empty(archives))
356	log_print("No archives found in %s.", dir);	356	log_print("No archives found in %s.", dir);
357		357
358	list_iterate(ah, archives) {	358	lvm_list_iterate(ah, archives) {
359	af = list_item(ah, struct archive_file);	359	af = lvm_list_item(ah, struct archive_file);
360		360
361	_display_archive(cmd, af);	361	_display_archive(cmd, af);
362	}	362	}
Lines 371-377 Link Here
371	struct archive_file af;	371	struct archive_file af;
372		372
373	if (!(af.path = _join(cmd->mem, dir, vgname))) {	373	if (!(af.path = _join(cmd->mem, dir, vgname))) {
374	stack;	374	STACK;
375	return 0;	375	return 0;
376	}	376	}
377		377

Lines 253-259 Link Here

(-)LVM2.2.00.15.orig/lib/format_text/export.c (-54 / +54 lines)
253	return r;	253	return r;
254	}	254	}
255		255
256	#define _outf(args...) do {if (!_out(args)) {stack; return 0;}} while (0)	256	#define _outf(args...) do {if (!_out(args)) {STACK; return 0;}} while (0)
257		257
258	static int _print_header(struct formatter *f,	258	static int _print_header(struct formatter *f,
259	struct volume_group vg, const char desc)	259	struct volume_group vg, const char desc)
Lines 282-288 Link Here
282	char buffer[4096];	282	char buffer[4096];
283		283
284	if (!id_write_format(&vg->id, buffer, sizeof(buffer))) {	284	if (!id_write_format(&vg->id, buffer, sizeof(buffer))) {
285	stack;	285	STACK;
286	return 0;	286	return 0;
287	}	287	}
288		288
Lines 291-304 Link Here
291	_outf(f, "seqno = %u", vg->seqno);	291	_outf(f, "seqno = %u", vg->seqno);
292		292
293	if (!print_flags(vg->status, VG_FLAGS, buffer, sizeof(buffer))) {	293	if (!print_flags(vg->status, VG_FLAGS, buffer, sizeof(buffer))) {
294	stack;	294	STACK;
295	return 0;	295	return 0;
296	}	296	}
297	_outf(f, "status = %s", buffer);	297	_outf(f, "status = %s", buffer);
298		298
299	if (!list_empty(&vg->tags)) {	299	if (!lvm_list_empty(&vg->tags)) {
300	if (!print_tags(&vg->tags, buffer, sizeof(buffer))) {	300	if (!print_tags(&vg->tags, buffer, sizeof(buffer))) {
301	stack;	301	STACK;
302	return 0;	302	return 0;
303	}	303	}
304	_outf(f, "tags = %s", buffer);	304	_outf(f, "tags = %s", buffer);
Lines 309-315 Link Here
309		309
310	if (!_out_size(f, (uint64_t) vg->extent_size, "extent_size = %u",	310	if (!_out_size(f, (uint64_t) vg->extent_size, "extent_size = %u",
311	vg->extent_size)) {	311	vg->extent_size)) {
312	stack;	312	STACK;
313	return 0;	313	return 0;
314	}	314	}
315	_outf(f, "max_lv = %u", vg->max_lv);	315	_outf(f, "max_lv = %u", vg->max_lv);
Lines 331-337 Link Here
331		331
332	static int _print_pvs(struct formatter f, struct volume_group vg)	332	static int _print_pvs(struct formatter f, struct volume_group vg)
333	{	333	{
334	struct list *pvh;	334	struct lvm_list *pvh;
335	struct physical_volume *pv;	335	struct physical_volume *pv;
336	char buffer[4096];	336	char buffer[4096];
337	const char *name;	337	const char *name;
Lines 339-349 Link Here
339	_outf(f, "physical_volumes {");	339	_outf(f, "physical_volumes {");
340	_inc_indent(f);	340	_inc_indent(f);
341		341
342	list_iterate(pvh, &vg->pvs) {	342	lvm_list_iterate(pvh, &vg->pvs) {
343	pv = list_item(pvh, struct pv_list)->pv;	343	pv = lvm_list_item(pvh, struct pv_list)->pv;
344		344
345	if (!(name = _get_pv_name(f, pv))) {	345	if (!(name = _get_pv_name(f, pv))) {
346	stack;	346	STACK;
347	return 0;	347	return 0;
348	}	348	}
349		349
Lines 352-377 Link Here
352	_inc_indent(f);	352	_inc_indent(f);
353		353
354	if (!id_write_format(&pv->id, buffer, sizeof(buffer))) {	354	if (!id_write_format(&pv->id, buffer, sizeof(buffer))) {
355	stack;	355	STACK;
356	return 0;	356	return 0;
357	}	357	}
358		358
359	_outf(f, "id = \"%s\"", buffer);	359	_outf(f, "id = \"%s\"", buffer);
360	if (!_out_hint(f, "device = \"%s\"", dev_name(pv->dev))) {	360	if (!_out_hint(f, "device = \"%s\"", dev_name(pv->dev))) {
361	stack;	361	STACK;
362	return 0;	362	return 0;
363	}	363	}
364	f->nl(f);	364	f->nl(f);
365		365
366	if (!print_flags(pv->status, PV_FLAGS, buffer, sizeof(buffer))) {	366	if (!print_flags(pv->status, PV_FLAGS, buffer, sizeof(buffer))) {
367	stack;	367	STACK;
368	return 0;	368	return 0;
369	}	369	}
370	_outf(f, "status = %s", buffer);	370	_outf(f, "status = %s", buffer);
371		371
372	if (!list_empty(&pv->tags)) {	372	if (!lvm_list_empty(&pv->tags)) {
373	if (!print_tags(&pv->tags, buffer, sizeof(buffer))) {	373	if (!print_tags(&pv->tags, buffer, sizeof(buffer))) {
374	stack;	374	STACK;
375	return 0;	375	return 0;
376	}	376	}
377	_outf(f, "tags = %s", buffer);	377	_outf(f, "tags = %s", buffer);
Lines 380-386 Link Here
380	_outf(f, "pe_start = %" PRIu64, pv->pe_start);	380	_outf(f, "pe_start = %" PRIu64, pv->pe_start);
381	if (!_out_size(f, vg->extent_size * (uint64_t) pv->pe_count,	381	if (!_out_size(f, vg->extent_size * (uint64_t) pv->pe_count,
382	"pe_count = %u", pv->pe_count)) {	382	"pe_count = %u", pv->pe_count)) {
383	stack;	383	STACK;
384	return 0;	384	return 0;
385	}	385	}
386		386
Lines 407-422 Link Here
407	_outf(f, "start_extent = %u", seg->le);	407	_outf(f, "start_extent = %u", seg->le);
408	if (!_out_size(f, (uint64_t) seg->len * vg->extent_size,	408	if (!_out_size(f, (uint64_t) seg->len * vg->extent_size,
409	"extent_count = %u", seg->len)) {	409	"extent_count = %u", seg->len)) {
410	stack;	410	STACK;
411	return 0;	411	return 0;
412	}	412	}
413		413
414	f->nl(f);	414	f->nl(f);
415	_outf(f, "type = \"%s\"", get_segtype_string(seg->type));	415	_outf(f, "type = \"%s\"", get_segtype_string(seg->type));
416		416
417	if (!list_empty(&seg->tags)) {	417	if (!lvm_list_empty(&seg->tags)) {
418	if (!print_tags(&seg->tags, buffer, sizeof(buffer))) {	418	if (!print_tags(&seg->tags, buffer, sizeof(buffer))) {
419	stack;	419	STACK;
420	return 0;	420	return 0;
421	}	421	}
422	_outf(f, "tags = %s", buffer);	422	_outf(f, "tags = %s", buffer);
Lines 453-459 Link Here
453	case AREA_PV:	453	case AREA_PV:
454	if (!(name = _get_pv_name(f, seg->	454	if (!(name = _get_pv_name(f, seg->
455	area[s].u.pv.pv))) {	455	area[s].u.pv.pv))) {
456	stack;	456	STACK;
457	return 0;	457	return 0;
458	}	458	}
459		459
Lines 483-491 Link Here
483	static int _count_segments(struct logical_volume *lv)	483	static int _count_segments(struct logical_volume *lv)
484	{	484	{
485	int r = 0;	485	int r = 0;
486	struct list *segh;	486	struct lvm_list *segh;
487		487
488	list_iterate(segh, &lv->segments)	488	lvm_list_iterate(segh, &lv->segments)
489	r++;	489	r++;
490		490
491	return r;	491	return r;
Lines 503-516 Link Here
503	_inc_indent(f);	503	_inc_indent(f);
504		504
505	if (!id_write_format(&snap->id, buffer, sizeof(buffer))) {	505	if (!id_write_format(&snap->id, buffer, sizeof(buffer))) {
506	stack;	506	STACK;
507	return 0;	507	return 0;
508	}	508	}
509		509
510	_outf(f, "id = \"%s\"", buffer);	510	_outf(f, "id = \"%s\"", buffer);
511	if (!print_flags(LVM_READ \| LVM_WRITE \| VISIBLE_LV, LV_FLAGS,	511	if (!print_flags(LVM_READ \| LVM_WRITE \| VISIBLE_LV, LV_FLAGS,
512	buffer, sizeof(buffer))) {	512	buffer, sizeof(buffer))) {
513	stack;	513	STACK;
514	return 0;	514	return 0;
515	}	515	}
516		516
Lines 527-536 Link Here
527	seg.chunk_size = snap->chunk_size;	527	seg.chunk_size = snap->chunk_size;
528		528
529	/* Can't tag a snapshot independently of its origin */	529	/* Can't tag a snapshot independently of its origin */
530	list_init(&seg.tags);	530	lvm_list_init(&seg.tags);
531		531
532	if (!_print_segment(f, snap->origin->vg, 1, &seg)) {	532	if (!_print_segment(f, snap->origin->vg, 1, &seg)) {
533	stack;	533	STACK;
534	return 0;	534	return 0;
535	}	535	}
536		536
Lines 542-556 Link Here
542		542
543	static int _print_snapshots(struct formatter f, struct volume_group vg)	543	static int _print_snapshots(struct formatter f, struct volume_group vg)
544	{	544	{
545	struct list *sh;	545	struct lvm_list *sh;
546	struct snapshot *s;	546	struct snapshot *s;
547	unsigned int count = 0;	547	unsigned int count = 0;
548		548
549	list_iterate(sh, &vg->snapshots) {	549	lvm_list_iterate(sh, &vg->snapshots) {
550	s = list_item(sh, struct snapshot_list)->snapshot;	550	s = lvm_list_item(sh, struct snapshot_list)->snapshot;
551		551
552	if (!_print_snapshot(f, s, count++)) {	552	if (!_print_snapshot(f, s, count++)) {
553	stack;	553	STACK;
554	return 0;	554	return 0;
555	}	555	}
556	}	556	}
Lines 560-566 Link Here
560		560
561	static int _print_lvs(struct formatter f, struct volume_group vg)	561	static int _print_lvs(struct formatter f, struct volume_group vg)
562	{	562	{
563	struct list *lvh;	563	struct lvm_list *lvh;
564	struct logical_volume *lv;	564	struct logical_volume *lv;
565	struct lv_segment *seg;	565	struct lv_segment *seg;
566	char buffer[4096];	566	char buffer[4096];
Lines 569-582 Link Here
569	/*	569	/*
570	* Don't bother with an lv section if there are no lvs.	570	* Don't bother with an lv section if there are no lvs.
571	*/	571	*/
572	if (list_empty(&vg->lvs))	572	if (lvm_list_empty(&vg->lvs))
573	return 1;	573	return 1;
574		574
575	_outf(f, "logical_volumes {");	575	_outf(f, "logical_volumes {");
576	_inc_indent(f);	576	_inc_indent(f);
577		577
578	list_iterate(lvh, &vg->lvs) {	578	lvm_list_iterate(lvh, &vg->lvs) {
579	lv = list_item(lvh, struct lv_list)->lv;	579	lv = lvm_list_item(lvh, struct lv_list)->lv;
580		580
581	f->nl(f);	581	f->nl(f);
582	_outf(f, "%s {", lv->name);	582	_outf(f, "%s {", lv->name);
Lines 584-604 Link Here
584		584
585	/* FIXME: Write full lvid */	585	/* FIXME: Write full lvid */
586	if (!id_write_format(&lv->lvid.id[1], buffer, sizeof(buffer))) {	586	if (!id_write_format(&lv->lvid.id[1], buffer, sizeof(buffer))) {
587	stack;	587	STACK;
588	return 0;	588	return 0;
589	}	589	}
590		590
591	_outf(f, "id = \"%s\"", buffer);	591	_outf(f, "id = \"%s\"", buffer);
592		592
593	if (!print_flags(lv->status, LV_FLAGS, buffer, sizeof(buffer))) {	593	if (!print_flags(lv->status, LV_FLAGS, buffer, sizeof(buffer))) {
594	stack;	594	STACK;
595	return 0;	595	return 0;
596	}	596	}
597	_outf(f, "status = %s", buffer);	597	_outf(f, "status = %s", buffer);
598		598
599	if (!list_empty(&lv->tags)) {	599	if (!lvm_list_empty(&lv->tags)) {
600	if (!print_tags(&lv->tags, buffer, sizeof(buffer))) {	600	if (!print_tags(&lv->tags, buffer, sizeof(buffer))) {
601	stack;	601	STACK;
602	return 0;	602	return 0;
603	}	603	}
604	_outf(f, "tags = %s", buffer);	604	_outf(f, "tags = %s", buffer);
Lines 617-625 Link Here
617	f->nl(f);	617	f->nl(f);
618		618
619	seg_count = 1;	619	seg_count = 1;
620	list_iterate_items(seg, &lv->segments) {	620	lvm_list_iterate_items(seg, &lv->segments) {
621	if (!_print_segment(f, vg, seg_count++, seg)) {	621	if (!_print_segment(f, vg, seg_count++, seg)) {
622	stack;	622	STACK;
623	return 0;	623	return 0;
624	}	624	}
625	}	625	}
Lines 629-635 Link Here
629	}	629	}
630		630
631	if (!_print_snapshots(f, vg)) {	631	if (!_print_snapshots(f, vg)) {
632	stack;	632	STACK;
633	return 0;	633	return 0;
634	}	634	}
635		635
Lines 647-682 Link Here
647	static int _build_pv_names(struct formatter f, struct volume_group vg)	647	static int _build_pv_names(struct formatter f, struct volume_group vg)
648	{	648	{
649	int count = 0;	649	int count = 0;
650	struct list *pvh;	650	struct lvm_list *pvh;
651	struct physical_volume *pv;	651	struct physical_volume *pv;
652	char buffer[32], *name;	652	char buffer[32], *name;
653		653
654	if (!(f->mem = pool_create(512))) {	654	if (!(f->mem = pool_create(512))) {
655	stack;	655	STACK;
656	goto bad;	656	goto bad;
657	}	657	}
658		658
659	if (!(f->pv_names = hash_create(128))) {	659	if (!(f->pv_names = hash_create(128))) {
660	stack;	660	STACK;
661	goto bad;	661	goto bad;
662	}	662	}
663		663
664	list_iterate(pvh, &vg->pvs) {	664	lvm_list_iterate(pvh, &vg->pvs) {
665	pv = list_item(pvh, struct pv_list)->pv;	665	pv = lvm_list_item(pvh, struct pv_list)->pv;
666		666
667	/* FIXME But skip if there's already an LV called pv%d ! */	667	/* FIXME But skip if there's already an LV called pv%d ! */
668	if (lvm_snprintf(buffer, sizeof(buffer), "pv%d", count++) < 0) {	668	if (lvm_snprintf(buffer, sizeof(buffer), "pv%d", count++) < 0) {
669	stack;	669	STACK;
670	goto bad;	670	goto bad;
671	}	671	}
672		672
673	if (!(name = pool_strdup(f->mem, buffer))) {	673	if (!(name = pool_strdup(f->mem, buffer))) {
674	stack;	674	STACK;
675	goto bad;	675	goto bad;
676	}	676	}
677		677
678	if (!hash_insert(f->pv_names, dev_name(pv->dev), name)) {	678	if (!hash_insert(f->pv_names, dev_name(pv->dev), name)) {
679	stack;	679	STACK;
680	goto bad;	680	goto bad;
681	}	681	}
682	}	682	}
Lines 699-708 Link Here
699	int r = 0;	699	int r = 0;
700		700
701	if (!_build_pv_names(f, vg)) {	701	if (!_build_pv_names(f, vg)) {
702	stack;	702	STACK;
703	goto out;	703	goto out;
704	}	704	}
705	#define fail do {stack; goto out;} while(0)	705	#define fail do {STACK; goto out;} while(0)
706		706
707	if (f->header && !_print_header(f, vg, desc))	707	if (f->header && !_print_header(f, vg, desc))
708	fail;	708	fail;
Lines 751-757 Link Here
751	_init();	751	_init();
752		752
753	if (!(f = dbg_malloc(sizeof(*f)))) {	753	if (!(f = dbg_malloc(sizeof(*f)))) {
754	stack;	754	STACK;
755	return 0;	755	return 0;
756	}	756	}
757		757
Lines 779-785 Link Here
779	_init();	779	_init();
780		780
781	if (!(f = dbg_malloc(sizeof(*f)))) {	781	if (!(f = dbg_malloc(sizeof(*f)))) {
782	stack;	782	STACK;
783	return 0;	783	return 0;
784	}	784	}
785		785
Lines 792-798 Link Here
792	f->nl = &_nl_raw;	792	f->nl = &_nl_raw;
793		793
794	if (!_text_vg_export(f, vg, desc)) {	794	if (!_text_vg_export(f, vg, desc)) {
795	stack;	795	STACK;
796	r = 0;	796	r = 0;
797	goto out;	797	goto out;
798	}	798	}

Lines 47-59 Link Here

(-)LVM2.2.00.15.orig/lib/format_text/format-text.h (-4 / +4 lines)
47		47
48	int pvhdr_read(struct device dev, char buf);	48	int pvhdr_read(struct device dev, char buf);
49		49
50	int add_da(const struct format_type fmt, struct pool mem, struct list *das,	50	int add_da(const struct format_type fmt, struct pool mem, struct lvm_list *das,
51	uint64_t start, uint64_t size);	51	uint64_t start, uint64_t size);
52	void del_das(struct list *das);	52	void del_das(struct lvm_list *das);
53		53
54	int add_mda(const struct format_type fmt, struct pool mem, struct list *mdas,	54	int add_mda(const struct format_type fmt, struct pool mem, struct lvm_list *mdas,
55	struct device *dev, uint64_t start, uint64_t size);	55	struct device *dev, uint64_t start, uint64_t size);
56	void del_mdas(struct list *mdas);	56	void del_mdas(struct lvm_list *mdas);
57		57
58	int vgname_from_mda(const struct format_type fmt, struct device_area dev_area,	58	int vgname_from_mda(const struct format_type fmt, struct device_area dev_area,
59	char *buf, uint32_t size);	59	char *buf, uint32_t size);

Lines 20-59 Link Here

(-)LVM2.2.00.15.orig/lib/format_text/tags.c (-8 / +8 lines)
20	#include "str_list.h"	20	#include "str_list.h"
21	#include "lvm-string.h"	21	#include "lvm-string.h"
22		22
23	int print_tags(struct list tags, char buffer, size_t size)	23	int print_tags(struct lvm_list tags, char buffer, size_t size)
24	{	24	{
25	struct str_list *sl;	25	struct str_list *sl;
26	int first = 1;	26	int first = 1;
27		27
28	if (!emit_to_buffer(&buffer, &size, "[")) {	28	if (!emit_to_buffer(&buffer, &size, "[")) {
29	stack;	29	STACK;
30	return 0;	30	return 0;
31	}	31	}
32		32
33	list_iterate_items(sl, tags) {	33	lvm_list_iterate_items(sl, tags) {
34	if (!first) {	34	if (!first) {
35	if (!emit_to_buffer(&buffer, &size, ", ")) {	35	if (!emit_to_buffer(&buffer, &size, ", ")) {
36	stack;	36	STACK;
37	return 0;	37	return 0;
38	}	38	}
39	} else	39	} else
40	first = 0;	40	first = 0;
41		41
42	if (!emit_to_buffer(&buffer, &size, "\"%s\"", sl->str)) {	42	if (!emit_to_buffer(&buffer, &size, "\"%s\"", sl->str)) {
43	stack;	43	STACK;
44	return 0;	44	return 0;
45	}	45	}
46	}	46	}
47		47
48	if (!emit_to_buffer(&buffer, &size, "]")) {	48	if (!emit_to_buffer(&buffer, &size, "]")) {
49	stack;	49	STACK;
50	return 0;	50	return 0;
51	}	51	}
52		52
53	return 1;	53	return 1;
54	}	54	}
55		55
56	int read_tags(struct pool mem, struct list tags, struct config_value *cv)	56	int read_tags(struct pool mem, struct lvm_list tags, struct config_value *cv)
57	{	57	{
58	if (cv->type == CFG_EMPTY_ARRAY)	58	if (cv->type == CFG_EMPTY_ARRAY)
59	return 1;	59	return 1;
Lines 65-71 Link Here
65	}	65	}
66		66
67	if (!str_list_add(mem, tags, pool_strdup(mem, cv->v.str))) {	67	if (!str_list_add(mem, tags, pool_strdup(mem, cv->v.str))) {
68	stack;	68	STACK;
69	return 0;	69	return 0;
70	}	70	}
71		71

Lines 38-44 Link Here

(-)LVM2.2.00.15.orig/lib/format_text/text_label.c (-24 / +24 lines)
38	struct pv_header *pvhdr;	38	struct pv_header *pvhdr;
39	struct lvmcache_info *info;	39	struct lvmcache_info *info;
40	struct disk_locn *pvh_dlocn_xl;	40	struct disk_locn *pvh_dlocn_xl;
41	struct list mdash, dash;	41	struct lvm_list mdash, dash;
42	struct metadata_area *mda;	42	struct metadata_area *mda;
43	struct mda_context *mdac;	43	struct mda_context *mdac;
44	struct data_area_list *da;	44	struct data_area_list *da;
Lines 56-63 Link Here
56	pvh_dlocn_xl = &pvhdr->disk_areas_xl[0];	56	pvh_dlocn_xl = &pvhdr->disk_areas_xl[0];
57		57
58	/* List of data areas (holding PEs) */	58	/* List of data areas (holding PEs) */
59	list_iterate(dash, &info->das) {	59	lvm_list_iterate(dash, &info->das) {
60	da = list_item(dash, struct data_area_list);	60	da = lvm_list_item(dash, struct data_area_list);
61		61
62	pvh_dlocn_xl->offset = xlate64(da->disk_locn.offset);	62	pvh_dlocn_xl->offset = xlate64(da->disk_locn.offset);
63	pvh_dlocn_xl->size = xlate64(da->disk_locn.size);	63	pvh_dlocn_xl->size = xlate64(da->disk_locn.size);
Lines 70-77 Link Here
70	pvh_dlocn_xl++;	70	pvh_dlocn_xl++;
71		71
72	/* List of metadata area header locations */	72	/* List of metadata area header locations */
73	list_iterate(mdash, &info->mdas) {	73	lvm_list_iterate(mdash, &info->mdas) {
74	mda = list_item(mdash, struct metadata_area);	74	mda = lvm_list_item(mdash, struct metadata_area);
75	mdac = (struct mda_context *) mda->metadata_locn;	75	mdac = (struct mda_context *) mda->metadata_locn;
76		76
77	if (mdac->area.dev != info->dev)	77	if (mdac->area.dev != info->dev)
Lines 89-95 Link Here
89	return 1;	89	return 1;
90	}	90	}
91		91
92	int add_da(const struct format_type fmt, struct pool mem, struct list *das,	92	int add_da(const struct format_type fmt, struct pool mem, struct lvm_list *das,
93	uint64_t start, uint64_t size)	93	uint64_t start, uint64_t size)
94	{	94	{
95	struct data_area_list *dal;	95	struct data_area_list *dal;
Lines 109-132 Link Here
109	dal->disk_locn.offset = start;	109	dal->disk_locn.offset = start;
110	dal->disk_locn.size = size;	110	dal->disk_locn.size = size;
111		111
112	list_add(das, &dal->list);	112	lvm_list_add(das, &dal->list);
113		113
114	return 1;	114	return 1;
115	}	115	}
116		116
117	void del_das(struct list *das)	117	void del_das(struct lvm_list *das)
118	{	118	{
119	struct list dah, tmp;	119	struct lvm_list dah, tmp;
120	struct data_area_list *da;	120	struct data_area_list *da;
121		121
122	list_iterate_safe(dah, tmp, das) {	122	lvm_list_iterate_safe(dah, tmp, das) {
123	da = list_item(dah, struct data_area_list);	123	da = lvm_list_item(dah, struct data_area_list);
124	list_del(&da->list);	124	lvm_list_del(&da->list);
125	dbg_free(da);	125	dbg_free(da);
126	}	126	}
127	}	127	}
128		128
129	int add_mda(const struct format_type fmt, struct pool mem, struct list *mdas,	129	int add_mda(const struct format_type fmt, struct pool mem, struct lvm_list *mdas,
130	struct device *dev, uint64_t start, uint64_t size)	130	struct device *dev, uint64_t start, uint64_t size)
131	{	131	{
132	/* FIXME List size restricted by pv_header SECTOR_SIZE */	132	/* FIXME List size restricted by pv_header SECTOR_SIZE */
Lines 165-183 Link Here
165	mdac->area.size = size;	165	mdac->area.size = size;
166	memset(&mdac->rlocn, 0, sizeof(mdac->rlocn));	166	memset(&mdac->rlocn, 0, sizeof(mdac->rlocn));
167		167
168	list_add(mdas, &mdal->list);	168	lvm_list_add(mdas, &mdal->list);
169	return 1;	169	return 1;
170	}	170	}
171		171
172	void del_mdas(struct list *mdas)	172	void del_mdas(struct lvm_list *mdas)
173	{	173	{
174	struct list mdah, tmp;	174	struct lvm_list mdah, tmp;
175	struct metadata_area *mda;	175	struct metadata_area *mda;
176		176
177	list_iterate_safe(mdah, tmp, mdas) {	177	lvm_list_iterate_safe(mdah, tmp, mdas) {
178	mda = list_item(mdah, struct metadata_area);	178	mda = lvm_list_item(mdah, struct metadata_area);
179	dbg_free(mda->metadata_locn);	179	dbg_free(mda->metadata_locn);
180	list_del(&mda->list);	180	lvm_list_del(&mda->list);
181	dbg_free(mda);	181	dbg_free(mda);
182	}	182	}
183	}	183	}
Lines 197-203 Link Here
197	struct lvmcache_info *info;	197	struct lvmcache_info *info;
198	struct disk_locn *dlocn_xl;	198	struct disk_locn *dlocn_xl;
199	uint64_t offset;	199	uint64_t offset;
200	struct list *mdah;	200	struct lvm_list *mdah;
201	struct metadata_area *mda;	201	struct metadata_area *mda;
202	char vgnamebuf[NAME_LEN + 2];	202	char vgnamebuf[NAME_LEN + 2];
203	struct mda_context *mdac;	203	struct mda_context *mdac;
Lines 212-222 Link Here
212		212
213	if (info->das.n)	213	if (info->das.n)
214	del_das(&info->das);	214	del_das(&info->das);
215	list_init(&info->das);	215	lvm_list_init(&info->das);
216		216
217	if (info->mdas.n)	217	if (info->mdas.n)
218	del_mdas(&info->mdas);	218	del_mdas(&info->mdas);
219	list_init(&info->mdas);	219	lvm_list_init(&info->mdas);
220		220
221	/* Data areas holding the PEs */	221	/* Data areas holding the PEs */
222	dlocn_xl = pvhdr->disk_areas_xl;	222	dlocn_xl = pvhdr->disk_areas_xl;
Lines 234-241 Link Here
234	dlocn_xl++;	234	dlocn_xl++;
235	}	235	}
236		236
237	list_iterate(mdah, &info->mdas) {	237	lvm_list_iterate(mdah, &info->mdas) {
238	mda = list_item(mdah, struct metadata_area);	238	mda = lvm_list_item(mdah, struct metadata_area);
239	mdac = (struct mda_context *) mda->metadata_locn;	239	mdac = (struct mda_context *) mda->metadata_locn;
240	if (vgname_from_mda(info->fmt, &mdac->area, vgnamebuf,	240	if (vgname_from_mda(info->fmt, &mdac->area, vgnamebuf,
241	sizeof(vgnamebuf))) {	241	sizeof(vgnamebuf))) {

Lines 30-42 Link Here

(-)LVM2.2.00.15.orig/lib/label/label.c (-25 / +25 lines)
30	* Internal labeller struct.	30	* Internal labeller struct.
31	*/	31	*/
32	struct labeller_i {	32	struct labeller_i {
33	struct list list;	33	struct lvm_list list;
34		34
35	struct labeller *l;	35	struct labeller *l;
36	char name[0];	36	char name[0];
37	};	37	};
38		38
39	static struct list _labellers;	39	static struct lvm_list _labellers;
40		40
41	static struct labeller_i _alloc_li(const char name, struct labeller *l)	41	static struct labeller_i _alloc_li(const char name, struct labeller *l)
42	{	42	{
Lines 63-80 Link Here
63		63
64	int label_init(void)	64	int label_init(void)
65	{	65	{
66	list_init(&_labellers);	66	lvm_list_init(&_labellers);
67	return 1;	67	return 1;
68	}	68	}
69		69
70	void label_exit(void)	70	void label_exit(void)
71	{	71	{
72	struct list c, n;	72	struct lvm_list c, n;
73	struct labeller_i *li;	73	struct labeller_i *li;
74		74
75	for (c = _labellers.n; c != &_labellers; c = n) {	75	for (c = _labellers.n; c != &_labellers; c = n) {
76	n = c->n;	76	n = c->n;
77	li = list_item(c, struct labeller_i);	77	li = lvm_list_item(c, struct labeller_i);
78	li->l->ops->destroy(li->l);	78	li->l->ops->destroy(li->l);
79	_free_li(li);	79	_free_li(li);
80	}	80	}
Lines 85-105 Link Here
85	struct labeller_i *li;	85	struct labeller_i *li;
86		86
87	if (!(li = _alloc_li(name, handler))) {	87	if (!(li = _alloc_li(name, handler))) {
88	stack;	88	STACK;
89	return 0;	89	return 0;
90	}	90	}
91		91
92	list_add(&_labellers, &li->list);	92	lvm_list_add(&_labellers, &li->list);
93	return 1;	93	return 1;
94	}	94	}
95		95
96	struct labeller label_get_handler(const char name)	96	struct labeller label_get_handler(const char name)
97	{	97	{
98	struct list *lih;	98	struct lvm_list *lih;
99	struct labeller_i *li;	99	struct labeller_i *li;
100		100
101	list_iterate(lih, &_labellers) {	101	lvm_list_iterate(lih, &_labellers) {
102	li = list_item(lih, struct labeller_i);	102	li = lvm_list_item(lih, struct labeller_i);
103	if (!strcmp(li->name, name))	103	if (!strcmp(li->name, name))
104	return li->l;	104	return li->l;
105	}	105	}
Lines 110-116 Link Here
110	static struct labeller _find_labeller(struct device dev, char *buf,	110	static struct labeller _find_labeller(struct device dev, char *buf,
111	uint64_t *label_sector)	111	uint64_t *label_sector)
112	{	112	{
113	struct list *lih;	113	struct lvm_list *lih;
114	struct labeller_i *li;	114	struct labeller_i *li;
115	struct labeller *r = NULL;	115	struct labeller *r = NULL;
116	struct label_header *lh;	116	struct label_header *lh;
Lines 119-125 Link Here
119	char readbuf[LABEL_SCAN_SIZE];	119	char readbuf[LABEL_SCAN_SIZE];
120		120
121	if (!dev_open(dev)) {	121	if (!dev_open(dev)) {
122	stack;	122	STACK;
123	return NULL;	123	return NULL;
124	}	124	}
125		125
Lines 158-165 Link Here
158	continue;	158	continue;
159	}	159	}
160		160
161	list_iterate(lih, &_labellers) {	161	lvm_list_iterate(lih, &_labellers) {
162	li = list_item(lih, struct labeller_i);	162	li = lvm_list_item(lih, struct labeller_i);
163	if (li->l->ops->can_handle(li->l, (char *) lh, sector)) {	163	if (li->l->ops->can_handle(li->l, (char *) lh, sector)) {
164	log_very_verbose("%s: %s label detected",	164	log_very_verbose("%s: %s label detected",
165	dev_name(dev), li->name);	165	dev_name(dev), li->name);
Lines 184-190 Link Here
184		184
185	out:	185	out:
186	if (!dev_close(dev))	186	if (!dev_close(dev))
187	stack;	187	STACK;
188		188
189	return r;	189	return r;
190	}	190	}
Lines 197-203 Link Here
197	int r = 1;	197	int r = 1;
198	uint64_t sector;	198	uint64_t sector;
199	int wipe;	199	int wipe;
200	struct list *lih;	200	struct lvm_list *lih;
201	struct labeller_i *li;	201	struct labeller_i *li;
202	struct label_header *lh;	202	struct label_header *lh;
203		203
Lines 206-212 Link Here
206	log_very_verbose("Scanning for labels to wipe from %s", dev_name(dev));	206	log_very_verbose("Scanning for labels to wipe from %s", dev_name(dev));
207		207
208	if (!dev_open(dev)) {	208	if (!dev_open(dev)) {
209	stack;	209	STACK;
210	return 0;	210	return 0;
211	}	211	}
212		212
Lines 233-240 Link Here
233	if (xlate64(lh->sector_xl) == sector)	233	if (xlate64(lh->sector_xl) == sector)
234	wipe = 1;	234	wipe = 1;
235	} else {	235	} else {
236	list_iterate(lih, &_labellers) {	236	lvm_list_iterate(lih, &_labellers) {
237	li = list_item(lih, struct labeller_i);	237	li = lvm_list_item(lih, struct labeller_i);
238	if (li->l->ops->can_handle(li->l, (char *) lh,	238	if (li->l->ops->can_handle(li->l, (char *) lh,
239	sector)) {	239	sector)) {
240	wipe = 1;	240	wipe = 1;
Lines 258-264 Link Here
258		258
259	out:	259	out:
260	if (!dev_close(dev))	260	if (!dev_close(dev))
261	stack;	261	STACK;
262		262
263	return r;	263	return r;
264	}	264	}
Lines 272-278 Link Here
272	int r;	272	int r;
273		273
274	if (!(l = _find_labeller(dev, buf, &sector))) {	274	if (!(l = _find_labeller(dev, buf, &sector))) {
275	stack;	275	STACK;
276	return 0;	276	return 0;
277	}	277	}
278		278
Lines 307-313 Link Here
307	lh->offset_xl = xlate32(sizeof(*lh));	307	lh->offset_xl = xlate32(sizeof(*lh));
308		308
309	if (!label->labeller->ops->write(label, buf)) {	309	if (!label->labeller->ops->write(label, buf)) {
310	stack;	310	STACK;
311	return 0;	311	return 0;
312	}	312	}
313		313
Lines 315-321 Link Here
315	((void ) &lh->offset_xl - (void ) lh)));	315	((void ) &lh->offset_xl - (void ) lh)));
316		316
317	if (!dev_open(dev)) {	317	if (!dev_open(dev)) {
318	stack;	318	STACK;
319	return 0;	319	return 0;
320	}	320	}
321		321
Lines 327-333 Link Here
327	}	327	}
328		328
329	if (!dev_close(dev))	329	if (!dev_close(dev))
330	stack;	330	STACK;
331		331
332	return r;	332	return r;
333	}	333	}
Lines 339-345 Link Here
339	uint64_t sector;	339	uint64_t sector;
340		340
341	if (!(l = _find_labeller(dev, buf, &sector))) {	341	if (!(l = _find_labeller(dev, buf, &sector))) {
342	stack;	342	STACK;
343	return 0;	343	return 0;
344	}	344	}
345		345

Lines 31-42 Link Here

(-)LVM2.2.00.15.orig/lib/locking/file_locking.c (-8 / +8 lines)
31	#include <signal.h>	31	#include <signal.h>
32		32
33	struct lock_list {	33	struct lock_list {
34	struct list list;	34	struct lvm_list list;
35	int lf;	35	int lf;
36	char *res;	36	char *res;
37	};	37	};
38		38
39	static struct list _lock_list;	39	static struct lvm_list _lock_list;
40	static char _lock_dir[NAME_LEN];	40	static char _lock_dir[NAME_LEN];
41		41
42	static sig_t _oldhandler;	42	static sig_t _oldhandler;
Lines 46-60 Link Here
46	static int _release_lock(const char *file, int unlock)	46	static int _release_lock(const char *file, int unlock)
47	{	47	{
48	struct lock_list *ll;	48	struct lock_list *ll;
49	struct list llh, llt;	49	struct lvm_list llh, llt;
50		50
51	struct stat buf1, buf2;	51	struct stat buf1, buf2;
52		52
53	list_iterate_safe(llh, llt, &_lock_list) {	53	lvm_list_iterate_safe(llh, llt, &_lock_list) {
54	ll = list_item(llh, struct lock_list);	54	ll = lvm_list_item(llh, struct lock_list);
55		55
56	if (!file \|\| !strcmp(ll->res, file)) {	56	if (!file \|\| !strcmp(ll->res, file)) {
57	list_del(llh);	57	lvm_list_del(llh);
58	if (unlock) {	58	if (unlock) {
59	log_very_verbose("Unlocking %s", ll->res);	59	log_very_verbose("Unlocking %s", ll->res);
60	if (flock(ll->lf, LOCK_NB \| LOCK_UN))	60	if (flock(ll->lf, LOCK_NB \| LOCK_UN))
Lines 189-195 Link Here
189	break;	189	break;
190	} while (!(flags & LCK_NONBLOCK));	190	} while (!(flags & LCK_NONBLOCK));
191		191
192	list_add(&_lock_list, &ll->list);	192	lvm_list_add(&_lock_list, &ll->list);
193	return 1;	193	return 1;
194		194
195	err:	195	err:
Lines 279-285 Link Here
279	if ((access(_lock_dir, R_OK \| W_OK \| X_OK) == -1) && (errno == EROFS))	279	if ((access(_lock_dir, R_OK \| W_OK \| X_OK) == -1) && (errno == EROFS))
280	return 0;	280	return 0;
281		281
282	list_init(&_lock_list);	282	lvm_list_init(&_lock_list);
283		283
284	if (sigfillset(&_intsigset) \|\| sigfillset(&_fullsigset)) {	284	if (sigfillset(&_intsigset) \|\| sigfillset(&_fullsigset)) {
285	log_sys_error("sigfillset", "init_file_locking");	285	log_sys_error("sigfillset", "init_file_locking");

Lines 252-264 Link Here

(-)LVM2.2.00.15.orig/lib/locking/locking.c (-10 / +10 lines)
252	}	252	}
253		253
254	/* Unlock list of LVs */	254	/* Unlock list of LVs */
255	int unlock_lvs(struct cmd_context cmd, struct list lvs)	255	int unlock_lvs(struct cmd_context cmd, struct lvm_list lvs)
256	{	256	{
257	struct list *lvh;	257	struct lvm_list *lvh;
258	struct logical_volume *lv;	258	struct logical_volume *lv;
259		259
260	list_iterate(lvh, lvs) {	260	lvm_list_iterate(lvh, lvs) {
261	lv = list_item(lvh, struct lv_list)->lv;	261	lv = lvm_list_item(lvh, struct lv_list)->lv;
262	unlock_lv(cmd, lv->lvid.s);	262	unlock_lv(cmd, lv->lvid.s);
263	}	263	}
264		264
Lines 266-282 Link Here
266	}	266	}
267		267
268	/* Lock a list of LVs */	268	/* Lock a list of LVs */
269	int lock_lvs(struct cmd_context cmd, struct list lvs, int flags)	269	int lock_lvs(struct cmd_context cmd, struct lvm_list lvs, int flags)
270	{	270	{
271	struct list *lvh;	271	struct lvm_list *lvh;
272	struct logical_volume *lv;	272	struct logical_volume *lv;
273		273
274	list_iterate(lvh, lvs) {	274	lvm_list_iterate(lvh, lvs) {
275	lv = list_item(lvh, struct lv_list)->lv;	275	lv = lvm_list_item(lvh, struct lv_list)->lv;
276	if (!lock_vol(cmd, lv->lvid.s, flags)) {	276	if (!lock_vol(cmd, lv->lvid.s, flags)) {
277	log_error("Failed to suspend %s", lv->name);	277	log_error("Failed to suspend %s", lv->name);
278	list_uniterate(lvh, lvs, lvh) {	278	lvm_list_uniterate(lvh, lvs, lvh) {
279	lv = list_item(lvh, struct lv_list)->lv;	279	lv = lvm_list_item(lvh, struct lv_list)->lv;
280	unlock_lv(cmd, lv->lvid.s);	280	unlock_lv(cmd, lv->lvid.s);
281	}	281	}
282		282

Lines 65-75 Link Here

(-)LVM2.2.00.15.orig/lib/metadata/lv_manip.c (-68 / +68 lines)
65	uint32_t len = sizeof(seg) + (num_areas sizeof(seg->area[0]));	65	uint32_t len = sizeof(seg) + (num_areas sizeof(seg->area[0]));
66		66
67	if (!(seg = pool_zalloc(mem, len))) {	67	if (!(seg = pool_zalloc(mem, len))) {
68	stack;	68	STACK;
69	return NULL;	69	return NULL;
70	}	70	}
71		71
72	list_init(&seg->tags);	72	lvm_list_init(&seg->tags);
73		73
74	return seg;	74	return seg;
75	}	75	}
Lines 114-120 Link Here
114	consume_pv_area(pva, area_len);	114	consume_pv_area(pva, area_len);
115	}	115	}
116		116
117	list_add(&lv->segments, &seg->list);	117	lvm_list_add(&lv->segments, &seg->list);
118	*ix += seg->len;	118	*ix += seg->len;
119	return 1;	119	return 1;
120	}	120	}
Lines 134-144 Link Here
134	}	134	}
135		135
136	static int _alloc_parallel(struct logical_volume *lv,	136	static int _alloc_parallel(struct logical_volume *lv,
137	struct list *pvms, uint32_t allocated,	137	struct lvm_list *pvms, uint32_t allocated,
138	uint32_t stripes, uint32_t stripe_size)	138	uint32_t stripes, uint32_t stripe_size)
139	{	139	{
140	int r = 0;	140	int r = 0;
141	struct list *pvmh;	141	struct lvm_list *pvmh;
142	struct pv_area **areas;	142	struct pv_area **areas;
143	unsigned int pv_count = 0, ix;	143	unsigned int pv_count = 0, ix;
144	struct pv_map *pvm;	144	struct pv_map *pvm;
Lines 147-153 Link Here
147		147
148	area_count = stripes;	148	area_count = stripes;
149		149
150	list_iterate(pvmh, pvms)	150	lvm_list_iterate(pvmh, pvms)
151	pv_count++;	151	pv_count++;
152		152
153	/* allocate an array of pv_areas, one candidate per pv */	153	/* allocate an array of pv_areas, one candidate per pv */
Lines 160-172 Link Here
160	while (allocated != lv->le_count) {	160	while (allocated != lv->le_count) {
161		161
162	ix = 0;	162	ix = 0;
163	list_iterate(pvmh, pvms) {	163	lvm_list_iterate(pvmh, pvms) {
164	pvm = list_item(pvmh, struct pv_map);	164	pvm = lvm_list_item(pvmh, struct pv_map);
165		165
166	if (list_empty(&pvm->areas))	166	if (lvm_list_empty(&pvm->areas))
167	continue;	167	continue;
168		168
169	areas[ix++] = list_item(pvm->areas.n, struct pv_area);	169	areas[ix++] = lvm_list_item(pvm->areas.n, struct pv_area);
170	}	170	}
171		171
172	if (ix < area_count) {	172	if (ix < area_count) {
Lines 181-187 Link Here
181		181
182	if (!_alloc_parallel_area(lv, area_count, stripe_size, areas,	182	if (!_alloc_parallel_area(lv, area_count, stripe_size, areas,
183	&allocated)) {	183	&allocated)) {
184	stack;	184	STACK;
185	goto out;	185	goto out;
186	}	186	}
187	}	187	}
Lines 225-231 Link Here
225	seg->area[0].u.pv.pv = map->pvl->pv;	225	seg->area[0].u.pv.pv = map->pvl->pv;
226	seg->area[0].u.pv.pe = pva->start;	226	seg->area[0].u.pv.pe = pva->start;
227		227
228	list_add(&lv->segments, &seg->list);	228	lvm_list_add(&lv->segments, &seg->list);
229		229
230	consume_pv_area(pva, count);	230	consume_pv_area(pva, count);
231	*ix += count;	231	*ix += count;
Lines 266-272 Link Here
266	seg->area[1].type = AREA_PV;	266	seg->area[1].type = AREA_PV;
267	seg->area[1].u.pv.pv = map->pvl->pv;	267	seg->area[1].u.pv.pv = map->pvl->pv;
268	seg->area[1].u.pv.pe = pva->start;	268	seg->area[1].u.pv.pe = pva->start;
269	list_add(&lv->segments, &seg->list);	269	lvm_list_add(&lv->segments, &seg->list);
270		270
271	consume_pv_area(pva, count);	271	consume_pv_area(pva, count);
272	*ix += count;	272	*ix += count;
Lines 283-307 Link Here
283	* FIXME: subsequent lvextends may not be contiguous.	283	* FIXME: subsequent lvextends may not be contiguous.
284	*/	284	*/
285	static int _alloc_contiguous(struct logical_volume *lv,	285	static int _alloc_contiguous(struct logical_volume *lv,
286	struct list *pvms, uint32_t allocated)	286	struct lvm_list *pvms, uint32_t allocated)
287	{	287	{
288	struct list *tmp1;	288	struct lvm_list *tmp1;
289	struct pv_map *pvm;	289	struct pv_map *pvm;
290	struct pv_area *pva;	290	struct pv_area *pva;
291		291
292	list_iterate(tmp1, pvms) {	292	lvm_list_iterate(tmp1, pvms) {
293	pvm = list_item(tmp1, struct pv_map);	293	pvm = lvm_list_item(tmp1, struct pv_map);
294		294
295	if (list_empty(&pvm->areas))	295	if (lvm_list_empty(&pvm->areas))
296	continue;	296	continue;
297		297
298	/* first item in the list is the biggest */	298	/* first item in the list is the biggest */
299	pva = list_item(pvm->areas.n, struct pv_area);	299	pva = lvm_list_item(pvm->areas.n, struct pv_area);
300	if (pva->count < lv->le_count)	300	if (pva->count < lv->le_count)
301	continue;	301	continue;
302		302
303	if (!_alloc_linear_area(lv, &allocated, pvm, pva)) {	303	if (!_alloc_linear_area(lv, &allocated, pvm, pva)) {
304	stack;	304	STACK;
305	return 0;	305	return 0;
306	}	306	}
307		307
Lines 320-343 Link Here
320		320
321	/* FIXME Contiguous depends on segment (i.e. stripe) not LV */	321	/* FIXME Contiguous depends on segment (i.e. stripe) not LV */
322	static int _alloc_mirrored(struct logical_volume *lv,	322	static int _alloc_mirrored(struct logical_volume *lv,
323	struct list *pvms, uint32_t allocated,	323	struct lvm_list *pvms, uint32_t allocated,
324	struct physical_volume *mirrored_pv,	324	struct physical_volume *mirrored_pv,
325	uint32_t mirrored_pe)	325	uint32_t mirrored_pe)
326	{	326	{
327	struct list *tmp1;	327	struct lvm_list *tmp1;
328	struct pv_map *pvm;	328	struct pv_map *pvm;
329	struct pv_area *pva;	329	struct pv_area *pva;
330	uint32_t max_found = 0;	330	uint32_t max_found = 0;
331		331
332	/* Try each PV in turn */	332	/* Try each PV in turn */
333	list_iterate(tmp1, pvms) {	333	lvm_list_iterate(tmp1, pvms) {
334	pvm = list_item(tmp1, struct pv_map);	334	pvm = lvm_list_item(tmp1, struct pv_map);
335		335
336	if (list_empty(&pvm->areas))	336	if (lvm_list_empty(&pvm->areas))
337	continue;	337	continue;
338		338
339	/* first item in the list is the biggest */	339	/* first item in the list is the biggest */
340	pva = list_item(pvm->areas.n, struct pv_area);	340	pva = lvm_list_item(pvm->areas.n, struct pv_area);
341	if (pva->count < lv->le_count - allocated) {	341	if (pva->count < lv->le_count - allocated) {
342	max_found = pva->count;	342	max_found = pva->count;
343	continue;	343	continue;
Lines 345-351 Link Here
345		345
346	if (!_alloc_mirrored_area(lv, &allocated, pvm, pva,	346	if (!_alloc_mirrored_area(lv, &allocated, pvm, pva,
347	mirrored_pv, mirrored_pe)) {	347	mirrored_pv, mirrored_pe)) {
348	stack;	348	STACK;
349	return 0;	349	return 0;
350	}	350	}
351		351
Lines 367-383 Link Here
367	* is full.	367	* is full.
368	*/	368	*/
369	static int _alloc_next_free(struct logical_volume *lv,	369	static int _alloc_next_free(struct logical_volume *lv,
370	struct list *pvms, uint32_t allocated)	370	struct lvm_list *pvms, uint32_t allocated)
371	{	371	{
372	struct list tmp1, tmp2;	372	struct lvm_list tmp1, tmp2;
373	struct pv_map *pvm;	373	struct pv_map *pvm;
374	struct pv_area *pva;	374	struct pv_area *pva;
375		375
376	list_iterate(tmp1, pvms) {	376	lvm_list_iterate(tmp1, pvms) {
377	pvm = list_item(tmp1, struct pv_map);	377	pvm = lvm_list_item(tmp1, struct pv_map);
378		378
379	list_iterate(tmp2, &pvm->areas) {	379	lvm_list_iterate(tmp2, &pvm->areas) {
380	pva = list_item(tmp2, struct pv_area);	380	pva = lvm_list_item(tmp2, struct pv_area);
381	if (!_alloc_linear_area(lv, &allocated, pvm, pva) \|\|	381	if (!_alloc_linear_area(lv, &allocated, pvm, pva) \|\|
382	(allocated == lv->le_count))	382	(allocated == lv->le_count))
383	goto done;	383	goto done;
Lines 399-416 Link Here
399	* Chooses a correct allocation policy.	399	* Chooses a correct allocation policy.
400	*/	400	*/
401	static int _allocate(struct volume_group vg, struct logical_volume lv,	401	static int _allocate(struct volume_group vg, struct logical_volume lv,
402	struct list *allocatable_pvs, uint32_t allocated,	402	struct lvm_list *allocatable_pvs, uint32_t allocated,
403	uint32_t stripes, uint32_t stripe_size,	403	uint32_t stripes, uint32_t stripe_size,
404	struct physical_volume *mirrored_pv, uint32_t mirrored_pe,	404	struct physical_volume *mirrored_pv, uint32_t mirrored_pe,
405	uint32_t status)	405	uint32_t status)
406	{	406	{
407	int r = 0;	407	int r = 0;
408	struct pool *scratch;	408	struct pool *scratch;
409	struct list pvms, old_tail = lv->segments.p, *segh;	409	struct lvm_list pvms, old_tail = lv->segments.p, *segh;
410	struct lv_segment *seg;	410	struct lv_segment *seg;
411		411
412	if (!(scratch = pool_create(1024))) {	412	if (!(scratch = pool_create(1024))) {
413	stack;	413	STACK;
414	return 0;	414	return 0;
415	}	415	}
416		416
Lines 446-452 Link Here
446	* counts in pv's.	446	* counts in pv's.
447	*/	447	*/
448	for (segh = lv->segments.p; segh != old_tail; segh = segh->p) {	448	for (segh = lv->segments.p; segh != old_tail; segh = segh->p) {
449	seg = list_item(segh, struct lv_segment);	449	seg = lvm_list_item(segh, struct lv_segment);
450	_get_extents(seg);	450	_get_extents(seg);
451	seg->status = status;	451	seg->status = status;
452	}	452	}
Lines 466-477 Link Here
466	static char _generate_lv_name(struct volume_group vg, const char *format,	466	static char _generate_lv_name(struct volume_group vg, const char *format,
467	char *buffer, size_t len)	467	char *buffer, size_t len)
468	{	468	{
469	struct list *lvh;	469	struct lvm_list *lvh;
470	struct logical_volume *lv;	470	struct logical_volume *lv;
471	int high = -1, i;	471	int high = -1, i;
472		472
473	list_iterate(lvh, &vg->lvs) {	473	lvm_list_iterate(lvh, &vg->lvs) {
474	lv = (list_item(lvh, struct lv_list)->lv);	474	lv = (lvm_list_item(lvh, struct lv_list)->lv);
475		475
476	if (sscanf(lv->name, format, &i) != 1)	476	if (sscanf(lv->name, format, &i) != 1)
477	continue;	477	continue;
Lines 538-555 Link Here
538	lv->minor = -1;	538	lv->minor = -1;
539	lv->size = UINT64_C(0);	539	lv->size = UINT64_C(0);
540	lv->le_count = 0;	540	lv->le_count = 0;
541	list_init(&lv->segments);	541	lvm_list_init(&lv->segments);
542	list_init(&lv->tags);	542	lvm_list_init(&lv->tags);
543		543
544	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {	544	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {
545	stack;	545	STACK;
546	if (ll)	546	if (ll)
547	pool_free(cmd->mem, ll);	547	pool_free(cmd->mem, ll);
548	return NULL;	548	return NULL;
549	}	549	}
550		550
551	vg->lv_count++;	551	vg->lv_count++;
552	list_add(&vg->lvs, &ll->list);	552	lvm_list_add(&vg->lvs, &ll->list);
553		553
554	return lv;	554	return lv;
555	}	555	}
Lines 562-568 Link Here
562	uint32_t stripe_size,	562	uint32_t stripe_size,
563	uint32_t extents,	563	uint32_t extents,
564	struct volume_group *vg,	564	struct volume_group *vg,
565	struct list *allocatable_pvs)	565	struct lvm_list *allocatable_pvs)
566	{	566	{
567	struct logical_volume *lv;	567	struct logical_volume *lv;
568		568
Lines 578-592 Link Here
578	return NULL;	578	return NULL;
579	}	579	}
580		580
581	if (stripes > list_size(allocatable_pvs)) {	581	if (stripes > lvm_list_size(allocatable_pvs)) {
582	log_error("Number of stripes (%u) must not exceed "	582	log_error("Number of stripes (%u) must not exceed "
583	"number of physical volumes (%d)", stripes,	583	"number of physical volumes (%d)", stripes,
584	list_size(allocatable_pvs));	584	lvm_list_size(allocatable_pvs));
585	return NULL;	585	return NULL;
586	}	586	}
587		587
588	if (!(lv = lv_create_empty(fi, name, "lvol%d", status, alloc, vg))) {	588	if (!(lv = lv_create_empty(fi, name, "lvol%d", status, alloc, vg))) {
589	stack;	589	STACK;
590	return NULL;	590	return NULL;
591	}	591	}
592		592
Lines 595-606 Link Here
595		595
596	if (!_allocate(vg, lv, allocatable_pvs, 0u, stripes, stripe_size,	596	if (!_allocate(vg, lv, allocatable_pvs, 0u, stripes, stripe_size,
597	NULL, 0u, 0u)) {	597	NULL, 0u, 0u)) {
598	stack;	598	STACK;
599	return NULL;	599	return NULL;
600	}	600	}
601		601
602	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {	602	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {
603	stack;	603	STACK;
604	return NULL;	604	return NULL;
605	}	605	}
606		606
Lines 610-629 Link Here
610	int lv_reduce(struct format_instance *fi,	610	int lv_reduce(struct format_instance *fi,
611	struct logical_volume *lv, uint32_t extents)	611	struct logical_volume *lv, uint32_t extents)
612	{	612	{
613	struct list *segh;	613	struct lvm_list *segh;
614	struct lv_segment *seg;	614	struct lv_segment *seg;
615	uint32_t count = extents;	615	uint32_t count = extents;
616	int striped;	616	int striped;
617		617
618	for (segh = lv->segments.p;	618	for (segh = lv->segments.p;
619	(segh != &lv->segments) && count; segh = segh->p) {	619	(segh != &lv->segments) && count; segh = segh->p) {
620	seg = list_item(segh, struct lv_segment);	620	seg = lvm_list_item(segh, struct lv_segment);
621		621
622	if (seg->len <= count) {	622	if (seg->len <= count) {
623	/* remove this segment completely */	623	/* remove this segment completely */
624	count -= seg->len;	624	count -= seg->len;
625	_put_extents(seg);	625	_put_extents(seg);
626	list_del(segh);	626	lvm_list_del(segh);
627	} else {	627	} else {
628	/* reduce this segment */	628	/* reduce this segment */
629	_put_extents(seg);	629	_put_extents(seg);
Lines 648-654 Link Here
648	lv->vg->free_count += extents;	648	lv->vg->free_count += extents;
649		649
650	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {	650	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {
651	stack;	651	STACK;
652	return 0;	652	return 0;
653	}	653	}
654		654
Lines 658-664 Link Here
658	int lv_extend(struct format_instance *fi,	658	int lv_extend(struct format_instance *fi,
659	struct logical_volume *lv,	659	struct logical_volume *lv,
660	uint32_t stripes, uint32_t stripe_size,	660	uint32_t stripes, uint32_t stripe_size,
661	uint32_t extents, struct list *allocatable_pvs)	661	uint32_t extents, struct lvm_list *allocatable_pvs)
662	{	662	{
663	uint32_t old_le_count = lv->le_count;	663	uint32_t old_le_count = lv->le_count;
664	uint64_t old_size = lv->size;	664	uint64_t old_size = lv->size;
Lines 670-676 Link Here
670	stripes, stripe_size, NULL, 0u, 0u)) {	670	stripes, stripe_size, NULL, 0u, 0u)) {
671	lv->le_count = old_le_count;	671	lv->le_count = old_le_count;
672	lv->size = old_size;	672	lv->size = old_size;
673	stack;	673	STACK;
674	return 0;	674	return 0;
675	}	675	}
676		676
Lines 681-687 Link Here
681	}	681	}
682		682
683	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {	683	if (fi->fmt->ops->lv_setup && !fi->fmt->ops->lv_setup(fi, lv)) {
684	stack;	684	STACK;
685	return 0;	685	return 0;
686	}	686	}
687		687
Lines 692-698 Link Here
692	struct logical_volume *lv,	692	struct logical_volume *lv,
693	struct physical_volume *mirrored_pv,	693	struct physical_volume *mirrored_pv,
694	uint32_t mirrored_pe,	694	uint32_t mirrored_pe,
695	uint32_t extents, struct list *allocatable_pvs,	695	uint32_t extents, struct lvm_list *allocatable_pvs,
696	uint32_t status)	696	uint32_t status)
697	{	697	{
698	uint32_t old_le_count = lv->le_count;	698	uint32_t old_le_count = lv->le_count;
Lines 705-716 Link Here
705	1, extents, mirrored_pv, mirrored_pe, status)) {	705	1, extents, mirrored_pv, mirrored_pe, status)) {
706	lv->le_count = old_le_count;	706	lv->le_count = old_le_count;
707	lv->size = old_size;	707	lv->size = old_size;
708	stack;	708	STACK;
709	return 0;	709	return 0;
710	}	710	}
711		711
712	if (fid->fmt->ops->lv_setup && !fid->fmt->ops->lv_setup(fid, lv)) {	712	if (fid->fmt->ops->lv_setup && !fid->fmt->ops->lv_setup(fid, lv)) {
713	stack;	713	STACK;
714	return 0;	714	return 0;
715	}	715	}
716		716
Lines 719-741 Link Here
719		719
720	int lv_remove(struct volume_group vg, struct logical_volume lv)	720	int lv_remove(struct volume_group vg, struct logical_volume lv)
721	{	721	{
722	struct list *segh;	722	struct lvm_list *segh;
723	struct lv_list *lvl;	723	struct lv_list *lvl;
724		724
725	/* find the lv list */	725	/* find the lv list */
726	if (!(lvl = find_lv_in_vg(vg, lv->name))) {	726	if (!(lvl = find_lv_in_vg(vg, lv->name))) {
727	stack;	727	STACK;
728	return 0;	728	return 0;
729	}	729	}
730		730
731	/* iterate through the lv's segments freeing off the pe's */	731	/* iterate through the lv's segments freeing off the pe's */
732	list_iterate(segh, &lv->segments)	732	lvm_list_iterate(segh, &lv->segments)
733	_put_extents(list_item(segh, struct lv_segment));	733	_put_extents(lvm_list_item(segh, struct lv_segment));
734		734
735	vg->lv_count--;	735	vg->lv_count--;
736	vg->free_count += lv->le_count;	736	vg->free_count += lv->le_count;
737		737
738	list_del(&lvl->list);	738	lvm_list_del(&lvl->list);
739		739
740	return 1;	740	return 1;
741	}	741	}
Lines 744-757 Link Here
744	{	744	{
745	int lvnum_used[MAX_RESTRICTED_LVS + 1];	745	int lvnum_used[MAX_RESTRICTED_LVS + 1];
746	uint32_t i = 0;	746	uint32_t i = 0;
747	struct list *lvh;	747	struct lvm_list *lvh;
748	struct lv_list *lvl;	748	struct lv_list *lvl;
749	int lvnum;	749	int lvnum;
750		750
751	memset(&lvnum_used, 0, sizeof(lvnum_used));	751	memset(&lvnum_used, 0, sizeof(lvnum_used));
752		752
753	list_iterate(lvh, &lv->vg->lvs) {	753	lvm_list_iterate(lvh, &lv->vg->lvs) {
754	lvl = list_item(lvh, struct lv_list);	754	lvl = lvm_list_item(lvh, struct lv_list);
755	lvnum = lvnum_from_lvid(&lvl->lv->lvid);	755	lvnum = lvnum_from_lvid(&lvl->lv->lvid);
756	if (lvnum <= MAX_RESTRICTED_LVS)	756	if (lvnum <= MAX_RESTRICTED_LVS)
757	lvnum_used[lvnum] = 1;	757	lvnum_used[lvnum] = 1;

Lines 76-89 Link Here

(-)LVM2.2.00.15.orig/lib/metadata/merge.c (-7 / +7 lines)
76		76
77	int lv_merge_segments(struct logical_volume *lv)	77	int lv_merge_segments(struct logical_volume *lv)
78	{	78	{
79	struct list segh, t;	79	struct lvm_list segh, t;
80	struct lv_segment current, prev = NULL;	80	struct lv_segment current, prev = NULL;
81		81
82	list_iterate_safe(segh, t, &lv->segments) {	82	lvm_list_iterate_safe(segh, t, &lv->segments) {
83	current = list_item(segh, struct lv_segment);	83	current = lvm_list_item(segh, struct lv_segment);
84		84
85	if (_merge(prev, current))	85	if (_merge(prev, current))
86	list_del(&current->list);	86	lvm_list_del(&current->list);
87	else	87	else
88	prev = current;	88	prev = current;
89	}	89	}
Lines 100-106 Link Here
100	uint32_t le = 0;	100	uint32_t le = 0;
101	unsigned seg_count = 0;	101	unsigned seg_count = 0;
102		102
103	list_iterate_items(seg, &lv->segments) {	103	lvm_list_iterate_items(seg, &lv->segments) {
104	seg_count++;	104	seg_count++;
105	if (seg->le != le) {	105	if (seg->le != le) {
106	log_error("LV %s invalid: segment %u should begin at "	106	log_error("LV %s invalid: segment %u should begin at "
Lines 176-182 Link Here
176	seg->area_len = offset;	176	seg->area_len = offset;
177		177
178	/* Add split off segment to the list _after_ the original one */	178	/* Add split off segment to the list _after_ the original one */
179	list_add_h(&seg->list, &split_seg->list);	179	lvm_list_add_h(&seg->list, &split_seg->list);
180		180
181	return 1;	181	return 1;
182	}	182	}
Lines 199-205 Link Here
199	return 1;	199	return 1;
200		200
201	if (!_lv_split_segment(lv, seg, le)) {	201	if (!_lv_split_segment(lv, seg, le)) {
202	stack;	202	STACK;
203	return 0;	203	return 0;
204	}	204	}
205		205

Lines 89-95 Link Here

(-)LVM2.2.00.15.orig/lib/metadata/metadata.h (-35 / +35 lines)
89	struct labeller;	89	struct labeller;
90		90
91	struct format_type {	91	struct format_type {
92	struct list list;	92	struct lvm_list list;
93	struct cmd_context *cmd;	93	struct cmd_context *cmd;
94	struct format_handler *ops;	94	struct format_handler *ops;
95	struct labeller *labeller;	95	struct labeller *labeller;
Lines 115-121 Link Here
115	uint32_t pe_count;	115	uint32_t pe_count;
116	uint32_t pe_alloc_count;	116	uint32_t pe_alloc_count;
117		117
118	struct list tags;	118	struct lvm_list tags;
119	};	119	};
120		120
121	struct metadata_area;	121	struct metadata_area;
Lines 151-164 Link Here
151	};	151	};
152		152
153	struct metadata_area {	153	struct metadata_area {
154	struct list list;	154	struct lvm_list list;
155	struct metadata_area_ops *ops;	155	struct metadata_area_ops *ops;
156	void *metadata_locn;	156	void *metadata_locn;
157	};	157	};
158		158
159	struct format_instance {	159	struct format_instance {
160	const struct format_type *fmt;	160	const struct format_type *fmt;
161	struct list metadata_areas; /* e.g. metadata locations */	161	struct lvm_list metadata_areas; /* e.g. metadata locations */
162	};	162	};
163		163
164	struct volume_group {	164	struct volume_group {
Lines 181-201 Link Here
181		181
182	/* physical volumes */	182	/* physical volumes */
183	uint32_t pv_count;	183	uint32_t pv_count;
184	struct list pvs;	184	struct lvm_list pvs;
185		185
186	/* logical volumes */	186	/* logical volumes */
187	uint32_t lv_count;	187	uint32_t lv_count;
188	struct list lvs;	188	struct lvm_list lvs;
189		189
190	/* snapshots */	190	/* snapshots */
191	uint32_t snapshot_count;	191	uint32_t snapshot_count;
192	struct list snapshots;	192	struct lvm_list snapshots;
193		193
194	struct list tags;	194	struct lvm_list tags;
195	};	195	};
196		196
197	struct lv_segment {	197	struct lv_segment {
198	struct list list;	198	struct lvm_list list;
199	struct logical_volume *lv;	199	struct logical_volume *lv;
200		200
201	segment_type_t type;	201	segment_type_t type;
Lines 213-219 Link Here
213	uint32_t chunk_size;	213	uint32_t chunk_size;
214	uint32_t extents_moved;	214	uint32_t extents_moved;
215		215
216	struct list tags;	216	struct lvm_list tags;
217		217
218	/* There will be one area for each stripe */	218	/* There will be one area for each stripe */
219	struct {	219	struct {
Lines 246-253 Link Here
246	uint64_t size;	246	uint64_t size;
247	uint32_t le_count;	247	uint32_t le_count;
248		248
249	struct list segments;	249	struct lvm_list segments;
250	struct list tags;	250	struct lvm_list tags;
251	};	251	};
252		252
253	struct snapshot {	253	struct snapshot {
Lines 261-296 Link Here
261	};	261	};
262		262
263	struct name_list {	263	struct name_list {
264	struct list list;	264	struct lvm_list list;
265	char *name;	265	char *name;
266	};	266	};
267		267
268	struct alloc_area {	268	struct alloc_area {
269	struct list list;	269	struct lvm_list list;
270	uint32_t start; /* PEs */	270	uint32_t start; /* PEs */
271	uint32_t count; /* PEs */	271	uint32_t count; /* PEs */
272	};	272	};
273		273
274	struct pv_list {	274	struct pv_list {
275	struct list list;	275	struct lvm_list list;
276	struct physical_volume *pv;	276	struct physical_volume *pv;
277	struct list mdas; / Metadata areas */	277	struct lvm_list mdas; / Metadata areas */
278	struct list alloc_areas; / Areas we may allocate from */	278	struct lvm_list alloc_areas; / Areas we may allocate from */
279	};	279	};
280		280
281	struct lv_list {	281	struct lv_list {
282	struct list list;	282	struct lvm_list list;
283	struct logical_volume *lv;	283	struct logical_volume *lv;
284	};	284	};
285		285
286	struct snapshot_list {	286	struct snapshot_list {
287	struct list list;	287	struct lvm_list list;
288		288
289	struct snapshot *snapshot;	289	struct snapshot *snapshot;
290	};	290	};
291		291
292	struct mda_list {	292	struct mda_list {
293	struct list list;	293	struct lvm_list list;
294	struct device_area mda;	294	struct device_area mda;
295	};	295	};
296		296
Lines 307-313 Link Here
307	* Return PV with given path.	307	* Return PV with given path.
308	*/	308	*/
309	int (pv_read) (const struct format_type fmt, const char *pv_name,	309	int (pv_read) (const struct format_type fmt, const char *pv_name,
310	struct physical_volume * pv, struct list * mdas);	310	struct physical_volume * pv, struct lvm_list * mdas);
311		311
312	/*	312	/*
313	* Tweak an already filled out a pv ready for importing into a	313	* Tweak an already filled out a pv ready for importing into a
Lines 317-323 Link Here
317	uint64_t pe_start, uint32_t extent_count,	317	uint64_t pe_start, uint32_t extent_count,
318	uint32_t extent_size,	318	uint32_t extent_size,
319	int pvmetadatacopies,	319	int pvmetadatacopies,
320	uint64_t pvmetadatasize, struct list * mdas,	320	uint64_t pvmetadatasize, struct lvm_list * mdas,
321	struct physical_volume * pv, struct volume_group * vg);	321	struct physical_volume * pv, struct volume_group * vg);
322		322
323	/*	323	/*
Lines 325-331 Link Here
325	* pv->vg_name must be null.	325	* pv->vg_name must be null.
326	*/	326	*/
327	int (pv_write) (const struct format_type fmt,	327	int (pv_write) (const struct format_type fmt,
328	struct physical_volume * pv, struct list * mdas,	328	struct physical_volume * pv, struct lvm_list * mdas,
329	int64_t label_sector);	329	int64_t label_sector);
330		330
331	/*	331	/*
Lines 369-382 Link Here
369	int *consistent);	369	int *consistent);
370	struct volume_group vg_read_by_vgid(struct cmd_context cmd, const char *vgid);	370	struct volume_group vg_read_by_vgid(struct cmd_context cmd, const char *vgid);
371	struct physical_volume pv_read(struct cmd_context cmd, const char *pv_name,	371	struct physical_volume pv_read(struct cmd_context cmd, const char *pv_name,
372	struct list mdas, uint64_t label_sector);	372	struct lvm_list mdas, uint64_t label_sector);
373	struct list get_pvs(struct cmd_context cmd);	373	struct lvm_list get_pvs(struct cmd_context cmd);
374		374
375	/* Set full_scan to 1 to re-read every (filtered) device label */	375	/* Set full_scan to 1 to re-read every (filtered) device label */
376	struct list get_vgs(struct cmd_context cmd, int full_scan);	376	struct lvm_list get_vgs(struct cmd_context cmd, int full_scan);
377		377
378	int pv_write(struct cmd_context cmd, struct physical_volume pv,	378	int pv_write(struct cmd_context cmd, struct physical_volume pv,
379	struct list *mdas, int64_t label_sector);	379	struct lvm_list *mdas, int64_t label_sector);
380		380
381	/* pe_start and pe_end relate to any existing data so that new metadata	381	/* pe_start and pe_end relate to any existing data so that new metadata
382	* areas can avoid overlap */	382	* areas can avoid overlap */
Lines 388-394 Link Here
388	uint32_t existing_extent_count,	388	uint32_t existing_extent_count,
389	uint32_t existing_extent_size,	389	uint32_t existing_extent_size,
390	int pvmetadatacopies,	390	int pvmetadatacopies,
391	uint64_t pvmetadatasize, struct list *mdas);	391	uint64_t pvmetadatasize, struct lvm_list *mdas);
392		392
393	struct volume_group vg_create(struct cmd_context cmd, const char *name,	393	struct volume_group vg_create(struct cmd_context cmd, const char *name,
394	uint32_t extent_size, uint32_t max_pv,	394	uint32_t extent_size, uint32_t max_pv,
Lines 411-417 Link Here
411	uint32_t stripe_size,	411	uint32_t stripe_size,
412	uint32_t extents,	412	uint32_t extents,
413	struct volume_group *vg,	413	struct volume_group *vg,
414	struct list *allocatable_pvs);	414	struct lvm_list *allocatable_pvs);
415		415
416	struct logical_volume lv_create_empty(struct format_instance fi,	416	struct logical_volume lv_create_empty(struct format_instance fi,
417	const char *name,	417	const char *name,
Lines 428-440 Link Here
428	struct logical_volume *lv,	428	struct logical_volume *lv,
429	uint32_t stripes,	429	uint32_t stripes,
430	uint32_t stripe_size,	430	uint32_t stripe_size,
431	uint32_t extents, struct list *allocatable_pvs);	431	uint32_t extents, struct lvm_list *allocatable_pvs);
432		432
433	int lv_extend_mirror(struct format_instance *fid,	433	int lv_extend_mirror(struct format_instance *fid,
434	struct logical_volume *lv,	434	struct logical_volume *lv,
435	struct physical_volume *mirrored_pv,	435	struct physical_volume *mirrored_pv,
436	uint32_t mirrored_pe,	436	uint32_t mirrored_pe,
437	uint32_t extents, struct list *allocatable_pvs,	437	uint32_t extents, struct lvm_list *allocatable_pvs,
438	uint32_t status);	438	uint32_t status);
439		439
440	/* lv must be part of vg->lvs */	440	/* lv must be part of vg->lvs */
Lines 502-508 Link Here
502		502
503	struct snapshot find_cow(const struct logical_volume lv);	503	struct snapshot find_cow(const struct logical_volume lv);
504	struct snapshot find_origin(const struct logical_volume lv);	504	struct snapshot find_origin(const struct logical_volume lv);
505	struct list find_snapshots(const struct logical_volume lv);	505	struct lvm_list find_snapshots(const struct logical_volume lv);
506		506
507	int vg_add_snapshot(struct logical_volume *origin,	507	int vg_add_snapshot(struct logical_volume *origin,
508	struct logical_volume *cow,	508	struct logical_volume *cow,
Lines 517-524 Link Here
517	struct logical_volume *lv_mirr,	517	struct logical_volume *lv_mirr,
518	struct physical_volume *pv,	518	struct physical_volume *pv,
519	struct logical_volume *lv,	519	struct logical_volume *lv,
520	struct list *allocatable_pvs,	520	struct lvm_list *allocatable_pvs,
521	struct list *lvs_changed);	521	struct lvm_list *lvs_changed);
522	int remove_pvmove_mirrors(struct volume_group *vg,	522	int remove_pvmove_mirrors(struct volume_group *vg,
523	struct logical_volume *lv_mirr);	523	struct logical_volume *lv_mirr);
524	struct logical_volume find_pvmove_lv(struct volume_group vg,	524	struct logical_volume find_pvmove_lv(struct volume_group vg,
Lines 527-533 Link Here
527	struct physical_volume *get_pvmove_pv_from_lv_mirr(struct logical_volume	527	struct physical_volume *get_pvmove_pv_from_lv_mirr(struct logical_volume
528	*lv_mirr);	528	*lv_mirr);
529	float pvmove_percent(struct logical_volume *lv_mirr);	529	float pvmove_percent(struct logical_volume *lv_mirr);
530	struct list lvs_using_lv(struct cmd_context cmd, struct volume_group *vg,	530	struct lvm_list lvs_using_lv(struct cmd_context cmd, struct volume_group *vg,
531	struct logical_volume *lv);	531	struct logical_volume *lv);
532		532
533	uint32_t find_free_lvnum(struct logical_volume *lv);	533	uint32_t find_free_lvnum(struct logical_volume *lv);

Lines 25-41 Link Here

(-)LVM2.2.00.15.orig/lib/metadata/mirror.c (-33 / +33 lines)
25	struct logical_volume *lv_mirr,	25	struct logical_volume *lv_mirr,
26	struct physical_volume *pv,	26	struct physical_volume *pv,
27	struct logical_volume *lv,	27	struct logical_volume *lv,
28	struct list *allocatable_pvs,	28	struct lvm_list *allocatable_pvs,
29	struct list *lvs_changed)	29	struct lvm_list *lvs_changed)
30	{	30	{
31	struct list *segh;	31	struct lvm_list *segh;
32	struct lv_segment *seg;	32	struct lv_segment *seg;
33	struct lv_list *lvl;	33	struct lv_list *lvl;
34	int lv_used = 0;	34	int lv_used = 0;
35	uint32_t s, start_le, extent_count = 0u;	35	uint32_t s, start_le, extent_count = 0u;
36		36
37	list_iterate(segh, &lv->segments) {	37	lvm_list_iterate(segh, &lv->segments) {
38	seg = list_item(segh, struct lv_segment);	38	seg = lvm_list_item(segh, struct lv_segment);
39	for (s = 0; s < seg->area_count; s++) {	39	for (s = 0; s < seg->area_count; s++) {
40	if (seg->area[s].type != AREA_PV \|\|	40	if (seg->area[s].type != AREA_PV \|\|
41	seg->area[s].u.pv.pv->dev != pv->dev)	41	seg->area[s].u.pv.pv->dev != pv->dev)
Lines 47-53 Link Here
47	return 0;	47	return 0;
48	}	48	}
49	lvl->lv = lv;	49	lvl->lv = lv;
50	list_add(lvs_changed, &lvl->list);	50	lvm_list_add(lvs_changed, &lvl->list);
51	lv_used = 1;	51	lv_used = 1;
52	}	52	}
53		53
Lines 80-97 Link Here
80	int remove_pvmove_mirrors(struct volume_group *vg,	80	int remove_pvmove_mirrors(struct volume_group *vg,
81	struct logical_volume *lv_mirr)	81	struct logical_volume *lv_mirr)
82	{	82	{
83	struct list lvh, segh;	83	struct lvm_list lvh, segh;
84	struct logical_volume *lv1;	84	struct logical_volume *lv1;
85	struct lv_segment seg, mir_seg;	85	struct lv_segment seg, mir_seg;
86	uint32_t s, c;	86	uint32_t s, c;
87		87
88	list_iterate(lvh, &vg->lvs) {	88	lvm_list_iterate(lvh, &vg->lvs) {
89	lv1 = list_item(lvh, struct lv_list)->lv;	89	lv1 = lvm_list_item(lvh, struct lv_list)->lv;
90	if (lv1 == lv_mirr)	90	if (lv1 == lv_mirr)
91	continue;	91	continue;
92		92
93	list_iterate(segh, &lv1->segments) {	93	lvm_list_iterate(segh, &lv1->segments) {
94	seg = list_item(segh, struct lv_segment);	94	seg = lvm_list_item(segh, struct lv_segment);
95	for (s = 0; s < seg->area_count; s++) {	95	for (s = 0; s < seg->area_count; s++) {
96	if (seg->area[s].type != AREA_LV \|\|	96	if (seg->area[s].type != AREA_LV \|\|
97	seg->area[s].u.lv.lv != lv_mirr)	97	seg->area[s].u.lv.lv != lv_mirr)
Lines 136-146 Link Here
136	struct physical_volume *get_pvmove_pv_from_lv_mirr(struct logical_volume	136	struct physical_volume *get_pvmove_pv_from_lv_mirr(struct logical_volume
137	*lv_mirr)	137	*lv_mirr)
138	{	138	{
139	struct list *segh;	139	struct lvm_list *segh;
140	struct lv_segment *seg;	140	struct lv_segment *seg;
141		141
142	list_iterate(segh, &lv_mirr->segments) {	142	lvm_list_iterate(segh, &lv_mirr->segments) {
143	seg = list_item(segh, struct lv_segment);	143	seg = lvm_list_item(segh, struct lv_segment);
144	if (seg->type != SEG_MIRRORED)	144	if (seg->type != SEG_MIRRORED)
145	continue;	145	continue;
146	if (seg->area[0].type != AREA_PV)	146	if (seg->area[0].type != AREA_PV)
Lines 153-164 Link Here
153		153
154	struct physical_volume get_pvmove_pv_from_lv(struct logical_volume lv)	154	struct physical_volume get_pvmove_pv_from_lv(struct logical_volume lv)
155	{	155	{
156	struct list *segh;	156	struct lvm_list *segh;
157	struct lv_segment *seg;	157	struct lv_segment *seg;
158	uint32_t s;	158	uint32_t s;
159		159
160	list_iterate(segh, &lv->segments) {	160	lvm_list_iterate(segh, &lv->segments) {
161	seg = list_item(segh, struct lv_segment);	161	seg = lvm_list_item(segh, struct lv_segment);
162	for (s = 0; s < seg->area_count; s++) {	162	for (s = 0; s < seg->area_count; s++) {
163	if (seg->area[s].type != AREA_LV)	163	if (seg->area[s].type != AREA_LV)
164	continue;	164	continue;
Lines 172-190 Link Here
172	struct logical_volume find_pvmove_lv(struct volume_group vg,	172	struct logical_volume find_pvmove_lv(struct volume_group vg,
173	struct device *dev)	173	struct device *dev)
174	{	174	{
175	struct list lvh, segh;	175	struct lvm_list lvh, segh;
176	struct logical_volume *lv;	176	struct logical_volume *lv;
177	struct lv_segment *seg;	177	struct lv_segment *seg;
178		178
179	/* Loop through all LVs */	179	/* Loop through all LVs */
180	list_iterate(lvh, &vg->lvs) {	180	lvm_list_iterate(lvh, &vg->lvs) {
181	lv = list_item(lvh, struct lv_list)->lv;	181	lv = lvm_list_item(lvh, struct lv_list)->lv;
182		182
183	if (!(lv->status & PVMOVE))	183	if (!(lv->status & PVMOVE))
184	continue;	184	continue;
185		185
186	list_iterate(segh, &lv->segments) {	186	lvm_list_iterate(segh, &lv->segments) {
187	seg = list_item(segh, struct lv_segment);	187	seg = lvm_list_item(segh, struct lv_segment);
188	if (seg->area[0].type != AREA_PV)	188	if (seg->area[0].type != AREA_PV)
189	continue;	189	continue;
190	if (seg->area[0].u.pv.pv->dev != dev)	190	if (seg->area[0].u.pv.pv->dev != dev)
Lines 196-205 Link Here
196	return NULL;	196	return NULL;
197	}	197	}
198		198
199	struct list lvs_using_lv(struct cmd_context cmd, struct volume_group *vg,	199	struct lvm_list lvs_using_lv(struct cmd_context cmd, struct volume_group *vg,
200	struct logical_volume *lv)	200	struct logical_volume *lv)
201	{	201	{
202	struct list lvh, segh, *lvs;	202	struct lvm_list lvh, segh, *lvs;
203	struct logical_volume *lv1;	203	struct logical_volume *lv1;
204	struct lv_list *lvl;	204	struct lv_list *lvl;
205	struct lv_segment *seg;	205	struct lv_segment *seg;
Lines 210-225 Link Here
210	return NULL;	210	return NULL;
211	}	211	}
212		212
213	list_init(lvs);	213	lvm_list_init(lvs);
214		214
215	/* Loop through all LVs except the one supplied */	215	/* Loop through all LVs except the one supplied */
216	list_iterate(lvh, &vg->lvs) {	216	lvm_list_iterate(lvh, &vg->lvs) {
217	lv1 = list_item(lvh, struct lv_list)->lv;	217	lv1 = lvm_list_item(lvh, struct lv_list)->lv;
218	if (lv1 == lv)	218	if (lv1 == lv)
219	continue;	219	continue;
220		220
221	list_iterate(segh, &lv1->segments) {	221	lvm_list_iterate(segh, &lv1->segments) {
222	seg = list_item(segh, struct lv_segment);	222	seg = lvm_list_item(segh, struct lv_segment);
223	for (s = 0; s < seg->area_count; s++) {	223	for (s = 0; s < seg->area_count; s++) {
224	if (seg->area[s].type != AREA_LV \|\|	224	if (seg->area[s].type != AREA_LV \|\|
225	seg->area[s].u.lv.lv != lv)	225	seg->area[s].u.lv.lv != lv)
Lines 229-235 Link Here
229	return NULL;	229	return NULL;
230	}	230	}
231	lvl->lv = lv1;	231	lvl->lv = lv1;
232	list_add(lvs, &lvl->list);	232	lvm_list_add(lvs, &lvl->list);
233	goto next_lv;	233	goto next_lv;
234	}	234	}
235	}	235	}
Lines 243-253 Link Here
243	float pvmove_percent(struct logical_volume *lv_mirr)	243	float pvmove_percent(struct logical_volume *lv_mirr)
244	{	244	{
245	uint32_t numerator = 0u, denominator = 0u;	245	uint32_t numerator = 0u, denominator = 0u;
246	struct list *segh;	246	struct lvm_list *segh;
247	struct lv_segment *seg;	247	struct lv_segment *seg;
248		248
249	list_iterate(segh, &lv_mirr->segments) {	249	lvm_list_iterate(segh, &lv_mirr->segments) {
250	seg = list_item(segh, struct lv_segment);	250	seg = lvm_list_item(segh, struct lv_segment);
251	if (!(seg->status & PVMOVE))	251	if (!(seg->status & PVMOVE))
252	continue;	252	continue;
253		253

Lines 17-48 Link Here

(-)LVM2.2.00.15.orig/lib/metadata/pv_map.c (-44 / +44 lines)
17	#include "pv_map.h"	17	#include "pv_map.h"
18	#include "hash.h"	18	#include "hash.h"
19		19
20	static int _create_maps(struct pool mem, struct list pvs, struct list *maps)	20	static int _create_maps(struct pool mem, struct lvm_list pvs, struct lvm_list *maps)
21	{	21	{
22	struct list *tmp;	22	struct lvm_list *tmp;
23	struct pv_map *pvm;	23	struct pv_map *pvm;
24	struct pv_list *pvl;	24	struct pv_list *pvl;
25		25
26	list_iterate(tmp, pvs) {	26	lvm_list_iterate(tmp, pvs) {
27	pvl = list_item(tmp, struct pv_list);	27	pvl = lvm_list_item(tmp, struct pv_list);
28		28
29	if (!(pvl->pv->status & ALLOCATABLE_PV))	29	if (!(pvl->pv->status & ALLOCATABLE_PV))
30	continue;	30	continue;
31		31
32	if (!(pvm = pool_zalloc(mem, sizeof(*pvm)))) {	32	if (!(pvm = pool_zalloc(mem, sizeof(*pvm)))) {
33	stack;	33	STACK;
34	return 0;	34	return 0;
35	}	35	}
36		36
37	pvm->pvl = pvl;	37	pvm->pvl = pvl;
38	if (!(pvm->allocated_extents =	38	if (!(pvm->allocated_extents =
39	bitset_create(mem, pvl->pv->pe_count))) {	39	bitset_create(mem, pvl->pv->pe_count))) {
40	stack;	40	STACK;
41	return 0;	41	return 0;
42	}	42	}
43		43
44	list_init(&pvm->areas);	44	lvm_list_init(&pvm->areas);
45	list_add(maps, &pvm->list);	45	lvm_list_add(maps, &pvm->list);
46	}	46	}
47		47
48	return 1;	48	return 1;
Lines 73-81 Link Here
73	return 1;	73	return 1;
74	}	74	}
75		75
76	static int _fill_bitsets(struct volume_group vg, struct list maps)	76	static int _fill_bitsets(struct volume_group vg, struct lvm_list maps)
77	{	77	{
78	struct list lvh, pvmh, *segh;	78	struct lvm_list lvh, pvmh, *segh;
79	struct logical_volume *lv;	79	struct logical_volume *lv;
80	struct pv_map *pvm;	80	struct pv_map *pvm;
81	uint32_t s, pe;	81	uint32_t s, pe;
Lines 89-108 Link Here
89	}	89	}
90		90
91	/* populate the hash table */	91	/* populate the hash table */
92	list_iterate(pvmh, maps) {	92	lvm_list_iterate(pvmh, maps) {
93	pvm = list_item(pvmh, struct pv_map);	93	pvm = lvm_list_item(pvmh, struct pv_map);
94	if (!hash_insert(hash, dev_name(pvm->pvl->pv->dev), pvm)) {	94	if (!hash_insert(hash, dev_name(pvm->pvl->pv->dev), pvm)) {
95	stack;	95	STACK;
96	goto out;	96	goto out;
97	}	97	}
98	}	98	}
99		99
100	/* iterate through all the lv's setting bit's for used pe's */	100	/* iterate through all the lv's setting bit's for used pe's */
101	list_iterate(lvh, &vg->lvs) {	101	lvm_list_iterate(lvh, &vg->lvs) {
102	lv = list_item(lvh, struct lv_list)->lv;	102	lv = lvm_list_item(lvh, struct lv_list)->lv;
103		103
104	list_iterate(segh, &lv->segments) {	104	lvm_list_iterate(segh, &lv->segments) {
105	seg = list_item(segh, struct lv_segment);	105	seg = lvm_list_item(segh, struct lv_segment);
106		106
107	for (s = 0u; s < seg->area_count; s++) {	107	for (s = 0u; s < seg->area_count; s++) {
108	for (pe = 0u; pe < seg->area_len; pe++) {	108	for (pe = 0u; pe < seg->area_len; pe++) {
Lines 112-118 Link Here
112	seg->area[s].u.pv.pv,	112	seg->area[s].u.pv.pv,
113	seg->area[s].u.pv.pe	113	seg->area[s].u.pv.pe
114	+ pe)) {	114	+ pe)) {
115	stack;	115	STACK;
116	goto out;	116	goto out;
117	}	117	}
118	}	118	}
Lines 129-152 Link Here
129	/*	129	/*
130	* Areas are maintained in size order.	130	* Areas are maintained in size order.
131	*/	131	*/
132	static void _insert_area(struct list head, struct pv_area a)	132	static void _insert_area(struct lvm_list head, struct pv_area a)
133	{	133	{
134	struct list *pvah;	134	struct lvm_list *pvah;
135	struct pv_area *pva = NULL;	135	struct pv_area *pva = NULL;
136		136
137	if (list_empty(head)) {	137	if (lvm_list_empty(head)) {
138	list_add(head, &a->list);	138	lvm_list_add(head, &a->list);
139	return;	139	return;
140	}	140	}
141		141
142	list_iterate(pvah, head) {	142	lvm_list_iterate(pvah, head) {
143	pva = list_item(pvah, struct pv_area);	143	pva = lvm_list_item(pvah, struct pv_area);
144		144
145	if (pva->count < a->count)	145	if (pva->count < a->count)
146	break;	146	break;
147	}	147	}
148		148
149	list_add_h(&pva->list, &a->list);	149	lvm_list_add_h(&pva->list, &a->list);
150	}	150	}
151		151
152	static int _create_single_area(struct pool mem, struct pv_map pvm,	152	static int _create_single_area(struct pool mem, struct pv_map pvm,
Lines 169-175 Link Here
169	e++;	169	e++;
170		170
171	if (!(pva = pool_zalloc(mem, sizeof(*pva)))) {	171	if (!(pva = pool_zalloc(mem, sizeof(*pva)))) {
172	stack;	172	STACK;
173	return 0;	173	return 0;
174	}	174	}
175		175
Lines 196-202 Link Here
196	pe = start;	196	pe = start;
197	while (pe <= end)	197	while (pe <= end)
198	if (!_create_single_area(mem, pvm, end, &pe)) {	198	if (!_create_single_area(mem, pvm, end, &pe)) {
199	stack;	199	STACK;
200	return 0;	200	return 0;
201	}	201	}
202		202
Lines 205-220 Link Here
205		205
206	static int _create_allocatable_areas(struct pool mem, struct pv_map pvm)	206	static int _create_allocatable_areas(struct pool mem, struct pv_map pvm)
207	{	207	{
208	struct list alloc_areas, aah;	208	struct lvm_list alloc_areas, aah;
209	struct alloc_area *aa;	209	struct alloc_area *aa;
210		210
211	alloc_areas = pvm->pvl->alloc_areas;	211	alloc_areas = pvm->pvl->alloc_areas;
212		212
213	if (alloc_areas) {	213	if (alloc_areas) {
214	list_iterate(aah, alloc_areas) {	214	lvm_list_iterate(aah, alloc_areas) {
215	aa = list_item(aah, struct alloc_area);	215	aa = lvm_list_item(aah, struct alloc_area);
216	if (!_create_areas(mem, pvm, aa->start, aa->count)) {	216	if (!_create_areas(mem, pvm, aa->start, aa->count)) {
217	stack;	217	STACK;
218	return 0;	218	return 0;
219	}	219	}
220		220
Lines 223-229 Link Here
223	/* Use whole PV */	223	/* Use whole PV */
224	if (!_create_areas(mem, pvm, UINT32_C(0),	224	if (!_create_areas(mem, pvm, UINT32_C(0),
225	pvm->pvl->pv->pe_count)) {	225	pvm->pvl->pv->pe_count)) {
226	stack;	226	STACK;
227	return 0;	227	return 0;
228	}	228	}
229	}	229	}
Lines 231-247 Link Here
231	return 1;	231	return 1;
232	}	232	}
233		233
234	static int _create_all_areas(struct pool mem, struct list maps,	234	static int _create_all_areas(struct pool mem, struct lvm_list maps,
235	struct list *pvs)	235	struct lvm_list *pvs)
236	{	236	{
237	struct list *tmp;	237	struct lvm_list *tmp;
238	struct pv_map *pvm;	238	struct pv_map *pvm;
239		239
240	list_iterate(tmp, maps) {	240	lvm_list_iterate(tmp, maps) {
241	pvm = list_item(tmp, struct pv_map);	241	pvm = lvm_list_item(tmp, struct pv_map);
242		242
243	if (!_create_allocatable_areas(mem, pvm)) {	243	if (!_create_allocatable_areas(mem, pvm)) {
244	stack;	244	STACK;
245	return 0;	245	return 0;
246	}	246	}
247	}	247	}
Lines 249-265 Link Here
249	return 1;	249	return 1;
250	}	250	}
251		251
252	struct list create_pv_maps(struct pool mem, struct volume_group *vg,	252	struct lvm_list create_pv_maps(struct pool mem, struct volume_group *vg,
253	struct list *pvs)	253	struct lvm_list *pvs)
254	{	254	{
255	struct list maps = pool_zalloc(mem, sizeof(maps));	255	struct lvm_list maps = pool_zalloc(mem, sizeof(maps));
256		256
257	if (!maps) {	257	if (!maps) {
258	stack;	258	STACK;
259	return NULL;	259	return NULL;
260	}	260	}
261		261
262	list_init(maps);	262	lvm_list_init(maps);
263		263
264	if (!_create_maps(mem, pvs, maps)) {	264	if (!_create_maps(mem, pvs, maps)) {
265	log_error("Couldn't create physical volume maps in %s",	265	log_error("Couldn't create physical volume maps in %s",
Lines 287-293 Link Here
287		287
288	void consume_pv_area(struct pv_area *pva, uint32_t to_go)	288	void consume_pv_area(struct pv_area *pva, uint32_t to_go)
289	{	289	{
290	list_del(&pva->list);	290	lvm_list_del(&pva->list);
291		291
292	assert(to_go <= pva->count);	292	assert(to_go <= pva->count);
293		293