lvm2/lib/config/config.c

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


#include "lib.h"

#include "config.h"
#include "crc.h"
#include "device.h"
#include "str_list.h"
#include "toolcontext.h"
#include "lvm-file.h"
#include "memlock.h"

#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>
#include <ctype.h>
#include <math.h>
#include <float.h>

static const char *_config_source_names[] = {
	[CONFIG_UNDEFINED] = "undefined",
	[CONFIG_FILE] = "file",
	[CONFIG_MERGED_FILES] = "merged files",
	[CONFIG_STRING] = "string",
	[CONFIG_PROFILE_COMMAND] = "command profile",
	[CONFIG_PROFILE_METADATA] = "metadata profile",
	[CONFIG_FILE_SPECIAL] = "special purpose"
};

struct config_file {
	off_t st_size;
	char *filename;
	int exists;
	int keep_open;
	struct device *dev;
};

struct config_source {
	config_source_t type;
	struct timespec timestamp;
	union {
		struct config_file *file;
		struct config_file *profile;
	} source;
	struct cft_check_handle *check_handle;
};

/*
 * Map each ID to respective definition of the configuration item.
 */
static struct cfg_def_item _cfg_def_items[CFG_COUNT + 1] = {
#define cfg_section(id, name, parent, flags, since_version, deprecated_since_version, deprecation_comment, comment) {id, parent, name, CFG_TYPE_SECTION, {0}, (flags), since_version, {0}, deprecated_since_version, deprecation_comment, comment},
#define cfg(id, name, parent, flags, type, default_value, since_version, unconfigured_value, deprecated_since_version, deprecation_comment, comment) {id, parent, name, type, {.v_##type = (default_value)}, (flags), since_version, {.v_UNCONFIGURED = (unconfigured_value)}, deprecated_since_version, deprecation_comment, comment},
#define cfg_runtime(id, name, parent, flags, type, since_version, deprecated_since_version, deprecation_comment, comment) {id, parent, name, type, {.fn_##type = get_default_##id}, (flags) | CFG_DEFAULT_RUN_TIME, since_version, {.fn_UNCONFIGURED = get_default_unconfigured_##id}, deprecated_since_version, (deprecation_comment), comment},
#define cfg_array(id, name, parent, flags, types, default_value, since_version, unconfigured_value, deprecated_since_version, deprecation_comment, comment) {id, parent, name, CFG_TYPE_ARRAY | (types), {.v_CFG_TYPE_STRING = (default_value)}, (flags), (since_version), {.v_UNCONFIGURED = (unconfigured_value)}, deprecated_since_version, deprecation_comment, comment},
#define cfg_array_runtime(id, name, parent, flags, types, since_version, deprecated_since_version, deprecation_comment, comment) {id, parent, name, CFG_TYPE_ARRAY | (types), {.fn_CFG_TYPE_STRING = get_default_##id}, (flags) | CFG_DEFAULT_RUN_TIME, (since_version), {.fn_UNCONFIGURED = get_default_unconfigured_##id}, deprecated_since_version, deprecation_comment, comment},
#include "config_settings.h"
#undef cfg_section
#undef cfg
#undef cfg_runtime
#undef cfg_array
#undef cfg_array_runtime
};

config_source_t config_get_source_type(struct dm_config_tree *cft)
{
	struct config_source *cs = dm_config_get_custom(cft);
	return cs ? cs->type : CONFIG_UNDEFINED;
}

static inline int _is_profile_based_config_source(config_source_t source)
{
	return (source == CONFIG_PROFILE_COMMAND) ||
	       (source == CONFIG_PROFILE_METADATA);
}

static inline int _is_file_based_config_source(config_source_t source)
{
	return (source == CONFIG_FILE) ||
	       (source == CONFIG_FILE_SPECIAL) ||
	       _is_profile_based_config_source(source);
}

/*
 * public interface
 */
struct dm_config_tree *config_open(config_source_t source,
				   const char *filename,
				   int keep_open)
{
	struct dm_config_tree *cft = dm_config_create();
	struct config_source *cs;
	struct config_file *cf;

	if (!cft)
		return NULL;

	if (!(cs = dm_pool_zalloc(cft->mem, sizeof(struct config_source)))) {
		log_error("Failed to allocate config source.");
		goto fail;
	}

	if (_is_file_based_config_source(source)) {
		if (!(cf = dm_pool_zalloc(cft->mem, sizeof(struct config_file)))) {
			log_error("Failed to allocate config file.");
			goto fail;
		}

		cf->keep_open = keep_open;
		if (filename &&
		    !(cf->filename = dm_pool_strdup(cft->mem, filename))) {
			log_error("Failed to duplicate filename.");
			goto fail;
		}

		cs->source.file = cf;
	}

	cs->type = source;
	dm_config_set_custom(cft, cs);
	return cft;
fail:
	dm_config_destroy(cft);
	return NULL;
}

/*
 * Doesn't populate filename if the file is empty.
 */
int config_file_check(struct dm_config_tree *cft, const char **filename, struct stat *info)
{
	struct config_source *cs = dm_config_get_custom(cft);
	struct config_file *cf;
	struct stat _info;

	if (!_is_file_based_config_source(cs->type)) {
		log_error(INTERNAL_ERROR "config_file_check: expected file, special file or "
					 "profile config source, found %s config source.",
					 _config_source_names[cs->type]);
		return 0;
	}

	if (!info)
		info = &_info;

	cf = cs->source.file;

	if (stat(cf->filename, info)) {
		log_sys_error("stat", cf->filename);
		cf->exists = 0;
		return 0;
	}

	if (!S_ISREG(info->st_mode)) {
		log_error("%s is not a regular file", cf->filename);
		cf->exists = 0;
		return 0;
	}

	lvm_stat_ctim(&cs->timestamp, info);
	cf->exists = 1;
	cf->st_size = info->st_size;

	if (info->st_size == 0)
		log_verbose("%s is empty", cf->filename);
	else if (filename)
		*filename = cf->filename;

	return 1;
}

/*
 * Return 1 if config files ought to be reloaded
 */
int config_file_changed(struct dm_config_tree *cft)
{
	struct config_source *cs = dm_config_get_custom(cft);
	struct config_file *cf;
	struct stat info;
	struct timespec ts;

	if (cs->type != CONFIG_FILE) {
		log_error(INTERNAL_ERROR "config_file_changed: expected file config source, "
					 "found %s config source.", _config_source_names[cs->type]);
		return 0;
	}

	cf = cs->source.file;

	if (!cf->filename)
		return 0;

	if (stat(cf->filename, &info) == -1) {
		/* Ignore a deleted config file: still use original data */
		if (errno == ENOENT) {
			if (!cf->exists)
				return 0;
			log_very_verbose("Config file %s has disappeared!",
					 cf->filename);
			goto reload;
		}
		log_sys_error("stat", cf->filename);
		log_error("Failed to reload configuration files");
		return 0;
	}

	if (!S_ISREG(info.st_mode)) {
		log_error("Configuration file %s is not a regular file",
			  cf->filename);
		goto reload;
	}

	/* Unchanged? */
	lvm_stat_ctim(&ts, &info);
	if ((timespeccmp(&cs->timestamp, &ts, ==)) &&
	    cf->st_size == info.st_size)
		return 0;

      reload:
	log_verbose("Detected config file change to %s", cf->filename);
	return 1;
}

void config_destroy(struct dm_config_tree *cft)
{
	struct config_source *cs;
	struct config_file *cf;

	if (!cft)
		return;

	cs = dm_config_get_custom(cft);

	if (_is_file_based_config_source(cs->type)) {
		cf = cs->source.file;
		if (cf && cf->dev)
			if (!dev_close(cf->dev))
				stack;
	}

	dm_config_destroy(cft);
}

struct dm_config_tree *config_file_open_and_read(const char *config_file,
						 config_source_t source,
						 struct cmd_context *cmd)
{
	struct dm_config_tree *cft;
	struct stat info;

	if (!(cft = config_open(source, config_file, 0))) {
		log_error("config_tree allocation failed");
		return NULL;
	}

	/* Is there a config file? */
	if (stat(config_file, &info) == -1) {
		/* Profile file must be present! */
		if (errno == ENOENT && (!_is_profile_based_config_source(source)))
			return cft;
		log_sys_error("stat", config_file);
		goto bad;
	}

	log_very_verbose("Loading config file: %s", config_file);
	if (!config_file_read(cft)) {
		log_error("Failed to load config file %s", config_file);
		goto bad;
	}

	return cft;
bad:
	config_destroy(cft);
	return NULL;
}

struct dm_config_tree *get_config_tree_by_source(struct cmd_context *cmd,
						 config_source_t source)
{
	struct dm_config_tree *cft = cmd->cft;
	struct config_source *cs;

	while (cft) {
		cs = dm_config_get_custom(cft);
		if (cs && cs->type == source)
			return cft;
		cft = cft->cascade;
	}

	return NULL;
}

/*
 * Returns config tree if it was removed.
 */
struct dm_config_tree *remove_config_tree_by_source(struct cmd_context *cmd,
						    config_source_t source)
{
	struct dm_config_tree *previous_cft = NULL;
	struct dm_config_tree *cft = cmd->cft;
	struct config_source *cs;

	while (cft) {
		cs = dm_config_get_custom(cft);
		if (cs && (cs->type == source)) {
			if (previous_cft) {
				previous_cft->cascade = cft->cascade;
				cmd->cft = previous_cft;
			} else
				cmd->cft = cft->cascade;
			cft->cascade = NULL;
			break;
		}
		previous_cft = cft;
		cft = cft->cascade;
	}

	return cft;
}

struct cft_check_handle *get_config_tree_check_handle(struct cmd_context *cmd,
						      struct dm_config_tree *cft)
{
	struct config_source *cs;

	if (!(cs = dm_config_get_custom(cft)))
		return NULL;

	if (cs->check_handle)
		goto out;

	/*
	 * Attach config check handle to all config types but
	 * CONFIG_FILE_SPECIAL - this one uses its own check
	 * methods and the cft_check_handle is not applicable here.
	 */
	if (cs->type != CONFIG_FILE_SPECIAL) {
		if (!(cs->check_handle = dm_pool_zalloc(cft->mem, sizeof(*cs->check_handle)))) {
			log_error("Failed to allocate configuration check handle.");
			return NULL;
		}
		cs->check_handle->cft = cft;
		cs->check_handle->cmd = cmd;
	}
out:
	return cs->check_handle;
}


int override_config_tree_from_string(struct cmd_context *cmd,
				     const char *config_settings)
{
	struct dm_config_tree *cft_new;
	struct config_source *cs = dm_config_get_custom(cmd->cft);

	/*
	 * Follow this sequence:
	 * CONFIG_STRING -> CONFIG_PROFILE_COMMAND -> CONFIG_PROFILE_METADATA -> CONFIG_FILE/CONFIG_MERGED_FILES
	 */

	if (cs->type == CONFIG_STRING) {
		log_error(INTERNAL_ERROR "override_config_tree_from_string: "
			  "config cascade already contains a string config.");
		return 0;
	}

	if (!(cft_new = dm_config_from_string(config_settings))) {
		log_error("Failed to set overridden configuration entries.");
		return 0;
	}

	if (cmd->is_interactive &&
	    !config_force_check(cmd, CONFIG_STRING, cft_new)) {
		log_error("Ignoring invalid configuration string.");
		dm_config_destroy(cft_new);
		return 0;
	}

	if (!(cs = dm_pool_zalloc(cft_new->mem, sizeof(struct config_source)))) {
		log_error("Failed to allocate config source.");
		dm_config_destroy(cft_new);
		return 0;
	}

	cs->type = CONFIG_STRING;
	dm_config_set_custom(cft_new, cs);

	cmd->cft = dm_config_insert_cascaded_tree(cft_new, cmd->cft);

	return 1;
}

static int _override_config_tree_from_command_profile(struct cmd_context *cmd,
						      struct profile *profile)
{
	struct dm_config_tree *cft = cmd->cft, *cft_previous = NULL;
	struct config_source *cs = dm_config_get_custom(cft);

	if (cs->type == CONFIG_STRING) {
		cft_previous = cft;
		cft = cft->cascade;
		cs = dm_config_get_custom(cft);
	}

	if (cs->type == CONFIG_PROFILE_COMMAND) {
		log_error(INTERNAL_ERROR "_override_config_tree_from_command_profile: "
				"config cascade already contains a command profile config.");
		return 0;
	}

	if (cft_previous)
		dm_config_insert_cascaded_tree(cft_previous, profile->cft);
	else
		cmd->cft = profile->cft;

	dm_config_insert_cascaded_tree(profile->cft, cft);

	return 1;
}

static int _override_config_tree_from_metadata_profile(struct cmd_context *cmd,
						       struct profile *profile)
{
	struct dm_config_tree *cft = cmd->cft, *cft_previous = NULL;
	struct config_source *cs = dm_config_get_custom(cft);

	if (cs->type == CONFIG_STRING) {
		cft_previous = cft;
		cft = cft->cascade;
	}

	if (cs->type == CONFIG_PROFILE_COMMAND) {
		cft_previous = cft;
		cft = cft->cascade;
	}

	cs = dm_config_get_custom(cft);

	if (cs->type == CONFIG_PROFILE_METADATA) {
		log_error(INTERNAL_ERROR "_override_config_tree_from_metadata_profile: "
				"config cascade already contains a metadata profile config.");
		return 0;
	}

	if (cft_previous)
		dm_config_insert_cascaded_tree(cft_previous, profile->cft);
	else
		cmd->cft = profile->cft;

	dm_config_insert_cascaded_tree(profile->cft, cft);

	return 1;
}

int override_config_tree_from_profile(struct cmd_context *cmd,
				      struct profile *profile)
{
	/*
	 * Follow this sequence:
	 * CONFIG_STRING -> CONFIG_PROFILE_COMMAND -> CONFIG_PROFILE_METADATA -> CONFIG_FILE/CONFIG_MERGED_FILES
	 */

	if (!profile->cft && !load_profile(cmd, profile))
		return_0;

	if (profile->source == CONFIG_PROFILE_COMMAND)
		return _override_config_tree_from_command_profile(cmd, profile);

	if (profile->source == CONFIG_PROFILE_METADATA)
		return _override_config_tree_from_metadata_profile(cmd, profile);

	log_error(INTERNAL_ERROR "override_config_tree_from_profile: incorrect profile source type");
	return 0;
}

/*
 * When checksum_only is set, the checksum of buffer is only matched
 * and function avoids parsing of mda into config tree which
 * remains unmodified and should not be used.
 */
int config_file_read_fd(struct dm_config_tree *cft, struct device *dev, dev_io_reason_t reason,
			off_t offset, size_t size, off_t offset2, size_t size2,
			checksum_fn_t checksum_fn, uint32_t checksum,
			int checksum_only, int no_dup_node_check)
{
	char *fb, *fe;
	int r = 0;
	int use_mmap = 1;
	off_t mmap_offset = 0;
	char *buf = NULL;
	struct config_source *cs = dm_config_get_custom(cft);

	if (!_is_file_based_config_source(cs->type)) {
		log_error(INTERNAL_ERROR "config_file_read_fd: expected file, special file "
					 "or profile config source, found %s config source.",
					 _config_source_names[cs->type]);
		return 0;
	}

	/* Only use mmap with regular files */
	if (!(dev->flags & DEV_REGULAR) || size2)
		use_mmap = 0;

	if (use_mmap) {
		mmap_offset = offset % lvm_getpagesize();
		/* memory map the file */
		fb = mmap((caddr_t) 0, size + mmap_offset, PROT_READ,
			  MAP_PRIVATE, dev_fd(dev), offset - mmap_offset);
		if (fb == (caddr_t) (-1)) {
			log_sys_error("mmap", dev_name(dev));
			goto out;
		}
		fb = fb + mmap_offset;
	} else {
		if (!(buf = dm_malloc(size + size2))) {
			log_error("Failed to allocate circular buffer.");
			return 0;
		}
		if (!dev_read_circular(dev, (uint64_t) offset, size,
				       (uint64_t) offset2, size2, reason, buf)) {
			goto out;
		}
		fb = buf;
	}

	if (checksum_fn && checksum !=
	    (checksum_fn(checksum_fn(INITIAL_CRC, (const uint8_t *)fb, size),
			 (const uint8_t *)(fb + size), size2))) {
		log_error("%s: Checksum error at offset %" PRIu64, dev_name(dev), (uint64_t) offset);
		goto out;
	}

	if (!checksum_only) {
		fe = fb + size + size2;
		if (no_dup_node_check) {
			if (!dm_config_parse_without_dup_node_check(cft, fb, fe))
				goto_out;
		} else {
			if (!dm_config_parse(cft, fb, fe))
				goto_out;
		}
	}

	r = 1;

      out:
	if (!use_mmap)
		dm_free(buf);
	else {
		/* unmap the file */
		if (munmap(fb - mmap_offset, size + mmap_offset)) {
			log_sys_error("munmap", dev_name(dev));