# User devmapper section

# This allows us to use a device-mapper device directly as a disk

# without the need for loopback

# Be careful not to specify any targets that are created by evms

# This can be useful for any devices created via dmraid or other means

# In order for this to work "dm*" has to be in the list of includes

devmapper {

	# This needs to be set to yes to enable

	#dm_user = yes

	# List of targets to discover as disks

	# These are the target names as seen with "dmsetup ls"

	# only specific targets can be used

	# we need to avoid evms created targets

	#dm_user_targets = [ raid1_device raid0_device ]

}

# EVMS Configuration file

# This file is a useable sample.

# Its location should be /etc/evms.conf

# It contains the default values which will be used in the absence of a

# configuration file or the absence of a configuration option being set.

# Global engine section

engine {

	mode		= readwrite

	# Possible values for debug_level in order are: critical, serious,

	# error, warning, default, details, entry_exit, debug, extra, everything

	#

	# The default value is "default".  Only log entries designated at the

	# debug_level or at a more severe level than the debug_level will be

	# printed to the log.  Thus, a debug_level of "default" will also log

	# critical, serious, error, and warning messages.  "critical" will

	# produce the smallest log, and "everything" will produce the largest

	# log.

	debug_level	= default

	log_file	= /var/log/evms-engine.log

	# Include microseconds in the log timestamps.  Default is "no".

#	log_usec	= yes

	# Include process IDs in the timestamps for log entries.  Default is

	# "no", unless the Engine is running in a clustered environment, in

	# which case PIDs are always included, since the Engine will have

	# several threads running.

#	log_pid		= yes

	# Open the log file with O_SYNC so that all writes to the log file

	# are guaranteed to be on the disk rather than just in cache.

	# Default is "no".

#	sync_log	= no

	# The directory where EVMS puts its metadata backup files.

	metadata_backup_dir	= /var/evms/metadata_backups

	# Save a backup of the metadata after each successful save of a

	# configuration change

#	auto_metadata_backup	= yes

}

# Settings if the Engine is opened in daemon mode

daemon {

	debug_level	= default	# Same settings as available for

					# engine.debug_level

	log_file	= /var/log/evms-daemon.log

	# Include microseconds in the log timestamps.  Default is "no".

#	log_usec	= yes

	# Include process IDs in the timestamps for log entries.  Default is

	# "no", unless the Engine is running in a clustered environment, in

	# which case PIDs are always included, since the Engine will have

	# several threads running.

#	log_pid		= yes

	# Open the log file with O_SYNC so that all writes to the log file

	# are guaranteed to be on the disk rather than just in cache.

	# Default is "no".

#	sync_log	= no

}

# Clustering section

clustering {

	# The number of seconds the engine/daemon should wait for a valid

	# cluster membership to show up.

	membership_timeout = 10

}

# Activation section

#

# Use this section to tell EVMS which volumes and objects should be activated.

activate {

	# Names of volumes and objects that should be activated.

	#

	# Names can be specified using "*", "?", and "[...]" notations.

	include = [ * ]

	# Names of volumes and objects that should not be activated.

	#

	# Names can be specified using "*", "?", and "[...]" notations.

	exclude = [ ]

}

# Local disk manager sections

# Use this section to tell EVMS where to look for devices and which devices to

# include or exclude on a system without sysfs (i.e., 2.4 kernels). If you are

# using a 2.6 kernel, you'll likely want to see the "sysfs_devices" section

# instead of this one.

legacy_devices {

	# "scan" is the location of the dev node tree.

	scan = /dev

	# "directories" is any directories under the "scan" directory you want

	# searched recursively. On systems running devfs without devfsd, the

	# default settings will find all IDE and SCSI disks.

	directories = [ ide scsi dasd ]

	# "include" are the block devices found in the dev tree that you want

	# EVMS to use as disks.  By default, this will search for traditional

	# style device names (e.g., hda, sdb).  If you know the exact disks that

	# your system uses, you can specify them here to cut down on unnecessary

	# searching.

	#

	# If you are running devfs with devfsd, the default settings will find

	# the old-style names (eg. hda). If you wish to use the new-style names

	# (eg. ide/host0/bus0/target0/lun0/disc), simply remove "sd?" and "hd?"

	# from the list below. If you are running devfs without devfsd, the

	# new-style names will be used.

	#

	# Block device names can be specified using "*", "?", and "[...]"

	# notations.

	include = [ hd? sd? dasd? disc ]

	# "exclude" are the block devices found in the dev tree that you don't

	# want EVMS to use as disks.  Entries here will override any possible

	# matches from the "include" setting.  Thus, if you specify "hd?" in

	# "include", and "hdc" in "exclude", EVMS will examine all IDE disks

	# except hdc.

	#

	# Block device names can be specified using "*", "?", and "[...]"

	# notations.

	exclude = [ ]

	# "max_open_disks" is the maximum number of disks that EVMS will have

	# open file-descriptors for while the engine is running. The allowable

	# range is 1 to 1024, and the default value is 64.

#	max_open_disks = 64

}

# Use this section to tell EVMS where to look for devices and which devices to

# include or exclude on a system with sysfs (i.e., 2.5 and later kernels).

sysfs_devices {

	# "include" are the block devices found in the /sys/block/

	# directory that you want EVMS to use as disks.

	#

	# Block device names can be specified using "*", "?", and "[...]"

	# notations.

	include = [ * ]

	# "exclude" are the block devices found in the /sys/block/

	# directory that you don't want EVMS to use as disks.  Entries here

	# will override any possible matches from the "include" setting.

	#

	# Block device names can be specified using "*", "?", and "[...]"

	# notations.

	exclude = [ ]

	# "max_open_disks" is the maximum number of disks that EVMS will have

	# open file-descriptors for while the engine is running. The allowable

	# range is 1 to 1024, and the default value is 64.

#	max_open_disks = 64

	# "ignore_sysfs" will tell the disk plugin to ignore the sysfs_devices

	# section, and fall back to the legacy_devices section, even if sysfs

	# is available. The default is "no", which should be fine for almost

	# all users.

#	ignore_sysfs = no

}

# Cluster Segment Manager (CSM) section

csm {

	# Set admin_mode to yes when you wish to force the CSM to discover

	# objects from all cluster containers, allowing you to perform

	# configuration and maintenance.  Setting admin_mode to yes will cause

	# the CSM to ignore container ownership which will allow you to

	# configure storage in a maintenance mode.

	#

	# The default is no.

#	admin_mode = yes

}

# Multipath section

#

# Use this section to tell EVMS which paths in a multipath device should be

# treated only as "backup" paths. These paths will be activated in the kernel

# in a separate priority-group, and will only be used when all of the "normal"

# paths have failed.

#

# Each entry in this section should be the name of a multipath device on your

# system. The value for each entry should be the names of the child objects

# which should be treated as "backup" paths. Child objects which should be

# treated as "active" paths should not be listed here.

#

# Do not use any wildcard characters in this section.

multipath {

#	md/md0 = [ hdc ]

#	mp/lvm/vg1-pv1 = [ hdd ]

}

# LVM2 plugin section.

lvm2 {

	# Should the LVM2 plugin prompt you for confirmation when it finds

	# LVM2 metadata on an object, but the object does not pass the

	# necessary size checks? If yes, it will ask you if the object is

	# really an LVM2 PV. If no, it will assume the object is not a PV.

	#

	# If you have used EVMS to create an LVM2 container on top of an

	# MD Software-RAID region, you'll most likely want to set this

	# parameter to no.

	#

	# The default is yes.

	device_size_prompt = yes

}

	/* skip the options for core based on num_opts */

	for (i = 0; i < num_opts; i++) {

		params = next_token(params);

	}

	/* get the number of mirrors */

	rc = sscanf(params, "%u", &mirror->num_mirrors);

	if (rc != 1) {

		rc = EINVAL;

		goto out;

	}

out:

		rc=0;

 * check_user_devicemapper

 *

 * Check if this disk is a User created DM device.

 **/

static int check_user_devicemapper(storage_object_t * disk)

{

	dm_device_list_t * dm_list, * dm_entry;

	dm_target_t * targets = NULL;

	local_disk_t * ld = disk->private_data;

	int rc = 0, dm_user_targets_count = 0, i, dmup_len;

	boolean user_dm_enable;

	const char * const * dm_user_targets;

	char * dm_user_prefix = "dm/";

	LOG_ENTRY();

	/* Get the list of active DM devices. */

	dm_list = get_dm_device_list();

	if (!dm_list) {

		LOG_WARNING("Cannot get list of DM devices.\n");

		goto out;

	}

	/* Search the DM list for an entry that matches this disk. */

	dm_entry = find_disk_in_dm_devices(disk, dm_list);

	if (!dm_entry) {

		LOG_DEBUG("Disk %s is not a DM device.\n", disk->name);

		goto out;

	}

	user_dm_enable = FALSE;

	EngFncs->get_config_bool("devmapper.dm_user", &user_dm_enable);

	EngFncs->get_config_string_array("devmapper.dm_user_targets",

					 &dm_user_targets_count, &dm_user_targets);

	if (user_dm_enable == FALSE) {

		LOG_DEBUG("devmapper.dm_user not enabled.\n");

		rc = EINVAL;

		goto out;

	}

	/* search the named targets in the config for the DM name*/

	user_dm_enable = FALSE;

	for (i = 0; i < dm_user_targets_count; i++) {		

		if (strncmp(dm_user_targets[i], dm_entry->name, EVMS_NAME_SIZE) == 0) {

			user_dm_enable = TRUE;

		}

	}

	if (user_dm_enable == FALSE) {

		LOG_DEBUG("%s not found in devmapper.dm_user_targets.\n", dm_entry->name);

		rc = EINVAL;

		goto out;

	}

	/* Get the DM mapping for this disk. */

	/* we can use this in the future if we need to, and it's good to check */

	strncpy(disk->name, dm_entry->name, EVMS_NAME_SIZE);

	rc = EngFncs->dm_get_targets(disk, &targets);

	if (rc) {

		LOG_ERROR("Error getting DM mapping for disk %s.\n", disk->name);

		goto out;

	}

	/* Copy the DM name to this disk. */

	dmup_len = strlen(dm_user_prefix);

	LOG_DEBUG("Changing disk name from %s to %s%s.\n",

		  disk->name, dm_user_prefix ,dm_entry->name);

	strncpy(disk->name, dm_user_prefix, dmup_len);

	strncpy((disk->name)+dmup_len, dm_entry->name, EVMS_NAME_SIZE-dmup_len);

	/* Reject all multipath devices that

	 * were created by other EVMS plugins.

	 */

	rc = check_multipath_name(disk);

	if (rc) {

		LOG_DEBUG("Multipath disk %s belongs to another EVMS plugin.\n",

			  disk->name);

		goto out;

	}

	ld->flags |= LD_FLAG_USERDM;

out:

	/*EngFncs->dm_deallocate_targets(targets); */

	LOG_EXIT_INT(rc);

	return rc;

}

/**

		ld->flags & LD_FLAG_USERDM ||

		/* Check for User created DM devices. */

		rc = check_user_devicemapper(&working_disk);

		if (rc) {

			close_dev(&working_disk);

			continue;

		}

/*

 *   (C) Copyright IBM Corp. 2001, 2003

 *

 *   This program is free software;  you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation; either version 2 of the License, or

 *   (at your option) any later version.

 *

 *   This program is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See

 *   the GNU General Public License for more details.

 *

 *   You should have received a copy of the GNU General Public License

 *   along with this program;  if not, write to the Free Software

 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 *

 * Local Disk Manager plugin.

 */

#define _GNU_SOURCE

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <fcntl.h>

#include <mntent.h>

#include <dirent.h>

#include <unistd.h>

#include <sys/ioctl.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <errno.h>

#include <glob.h>

#include <malloc.h>

#include <wait.h>

#include <plugin.h>

#include <ldm_funcs.h>

#include "localdskmgr.h"

#include "cache.h"

#include "info.h"

engine_functions_t * EngFncs = NULL;

char * base_directory = NULL;

int    base_directory_len;

char * sysfs_mount_point;

const char * scan;

const char * const * directories;

int directories_count;

const char * const * includes;

int include_count;

const char * const default_legacy_includes[] = {

	"sd?",

	"hd?",

	"dasd?"

};

const char * const default_sysfs_includes[] = {

	"*?",

};

const char * const * excludes;

int exclude_count;

glob_t dev_names_glob;

int glob_flags;

static char pattern[PATH_MAX];

static dm_device_list_t * dm_devices = NULL;

static list_anchor_t multipath_children = NULL;

/* Global list for keeping track of open file-handles. On systems with

 * a large number of disks, we don't want to keep open file-handles to

 * every disk, or the process may run out of available file-handles.

 */

static list_anchor_t file_handles = NULL;

u_int32_t num_file_handles = 0;

#define DEFAULT_FILE_HANDLES 64

#define MAX_FILE_HANDLES 1024

static void close_dev(storage_object_t * disk);

/**

 * round_down

 * @value:	Value (in sectors) to be rounded down.

 * @boundary:	Boundary (in bytes) to round-down to.

 *

 * Given a value, round it down to be a multiple of the specified boundary size.

 **/

static inline sector_count_t round_down(sector_count_t value,

					u_int32_t boundary)

{

	sector_count_t boundary_in_vsectors = ((sector_count_t)boundary) >>

					      EVMS_VSECTOR_SIZE_SHIFT;

	return (boundary > EVMS_VSECTOR_SIZE) ?

	       (value & ~(boundary_in_vsectors - 1)) : value;

}

/**

 * round_up

 * @value:	Value (in sectors) to be rounded up.

 * @boundary:	Boundary (in bytes) to round-up to.

 *

 * Given a value, round it up to be a multiple of the specified boundary size.

 **/

static inline sector_count_t round_up(sector_count_t value,

				      u_int32_t boundary)

{

	sector_count_t boundary_in_vsectors = ((sector_count_t)boundary) >>

					      EVMS_VSECTOR_SIZE_SHIFT;

	sector_count_t temp_value = value + boundary_in_vsectors - 1;

	return (boundary > EVMS_VSECTOR_SIZE) ?

	       (temp_value & ~(boundary_in_vsectors - 1)) : value;

}

/**

 * drbd_active

 *

 * Is the drbd driver running? If so, the nbd driver cannot also be running,

 * since they use the same major-number.

 **/

static int drbd_active = -1;

static boolean is_drbd_active(void)

{

	struct stat st;

	int rc;

	LOG_ENTRY();

	if (drbd_active == -1) {

		rc = stat("/proc/drbd", &st);

		if (rc) {

			drbd_active = FALSE;

		} else {

			drbd_active = TRUE;

		}

	}

	LOG_EXIT_BOOL(drbd_active);

	return drbd_active;

}

static boolean search_mount_records(FILE * records,

				    char * fs_name,

				    char ** mount_name)

{

	boolean found = FALSE;

	struct mntent * mount_entry;

	LOG_ENTRY();

	while (!found && (mount_entry = getmntent(records)) != NULL) {

		if (strcmp(mount_entry->mnt_type, fs_name) == 0) {

			found = TRUE;

			if (mount_name) {

				*mount_name = strdup(mount_entry->mnt_dir);

			}

		}

	}

	LOG_EXIT_BOOL(found);

	return found;

}

/**

 * where_is_sysfs

 *

 * Is sysfs mounted. If so, return the mount point. The caller must free the

 * returned string.

 **/

static boolean where_is_sysfs(char ** mount_name)

{

	boolean found = FALSE;

	FILE * mount_records;

	LOG_ENTRY();

	if (mount_name) {

		*mount_name = NULL;

	}

	mount_records = setmntent(MOUNTED, "r");

	if (mount_records) {

		LOG_DEBUG("Searching for sysfs in %s.\n", MOUNTED);

		found = search_mount_records(mount_records, "sysfs", mount_name);

		endmntent(mount_records);

	}

	if (!found) {

		mount_records = setmntent("/proc/mounts", "r");

		if (mount_records) {

			LOG_DEBUG("Searching for sysfs in /proc/mounts.\n");

			found = search_mount_records(mount_records, "sysfs", mount_name);

			endmntent(mount_records);

		}

	}

	LOG_EXIT_BOOL(found);

	return found;

}

static void get_legacy_config()

{

	LOG_ENTRY();

	scan = "/dev/";

	EngFncs->get_config_string("legacy_devices.scan", &scan);

	directories_count = 0;

	directories = NULL;

	EngFncs->get_config_string_array("legacy_devices.directories",

					 &directories_count, &directories);

	include_count = 0;

	includes = NULL;

	EngFncs->get_config_string_array("legacy_devices.include",

					 &include_count, &includes);

	if (includes == NULL) {

		includes = default_legacy_includes;

		include_count = sizeof(default_legacy_includes) /

				sizeof(default_legacy_includes[0]);

	}

	exclude_count = 0;

	excludes = NULL;

	EngFncs->get_config_string_array("legacy_devices.exclude",

					 &exclude_count, &excludes);

	EngFncs->get_config_uint32("legacy_devices.max_open_disks",

				   &num_file_handles);

	LOG_EXIT_VOID();

}

static void get_sysfs_config()

{

	boolean ignore_sysfs = FALSE;

	LOG_ENTRY();

	EngFncs->get_config_bool("sysfs_devices.ignore_sysfs", &ignore_sysfs);

	if (ignore_sysfs) {

		/* Fall back to the legacy_devices section

		 * if the config file says to ignore sysfs.

		 */

		free(sysfs_mount_point);

		sysfs_mount_point = NULL;

		get_legacy_config();

		LOG_EXIT_VOID();

		return;

	}

	include_count = 0;

	includes = NULL;

	EngFncs->get_config_string_array("sysfs_devices.include",

					 &include_count, &includes);

	if (includes == NULL) {

		includes = default_sysfs_includes;

		include_count = sizeof(default_sysfs_includes) /

				sizeof(default_sysfs_includes[0]);

	}

	exclude_count = 0;

	excludes = NULL;

	EngFncs->get_config_string_array("sysfs_devices.exclude",

					 &exclude_count, &excludes);

	EngFncs->get_config_uint32("sysfs_devices.max_open_disks",

				   &num_file_handles);

	LOG_EXIT_VOID();

}

/**

 * file_handle_cleanup

 *

 * Delete the list of file-handle tracking structures.

 **/

static void file_handle_cleanup(void)

{

	file_handle_t *handle;

	list_element_t iter;

	LOG_ENTRY();

	LIST_FOR_EACH(file_handles, iter, handle) {

		EngFncs->engine_free(handle);

	}

	EngFncs->destroy_list(file_handles);

	file_handles = NULL;

	LOG_EXIT_VOID();

}

/**

 * file_handle_setup

 *

 * Create and initialize MAX_FILE_HANDLES entries on the file_handles list.

 **/

static int file_handle_setup(void)

{

	file_handle_t *handle;

	u_int32_t i;

	int rc = 0;

	LOG_ENTRY();

	/* Make sure the number of entries in the

	 * file-handles list will be reasonable.

	 */

	if (num_file_handles == 0) {

		num_file_handles = DEFAULT_FILE_HANDLES;

	} else if (num_file_handles > MAX_FILE_HANDLES) {

		num_file_handles = MAX_FILE_HANDLES;

	}

	LOG_DEBUG("Allocating %u entries in the file-handles list.\n",

		  num_file_handles);

	file_handles = EngFncs->allocate_list();

	if (!file_handles) {

		rc = ENOMEM;

		goto out;

	}

	for (i = 0; i < num_file_handles; i++) {

		handle = EngFncs->engine_alloc(sizeof(*handle));

		if (!handle) {

			file_handle_cleanup();

			rc = ENOMEM;

			break;

		}

		handle->elem = EngFncs->insert_thing(file_handles, handle,

						     INSERT_AFTER, NULL);

	}

out:

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * file_handle_release

 *

 * Release this file-handle back to the pool of available handles. Move it

 * to the start of the list so it will be quicker to find on the next search.

 **/

static void file_handle_release(file_handle_t *handle)

{

	LOG_ENTRY();

	handle->disk = NULL;

	EngFncs->remove_element(handle->elem);

	EngFncs->insert_element(file_handles, handle->elem, INSERT_BEFORE, NULL);

	LOG_EXIT_VOID();

}

/**

 * file_handle_make_last

 *

 * Move this file-handle to the end of the list so it will be the least likely

 * to be "stolen".

 **/

static void file_handle_make_last(file_handle_t *handle)

{

	LOG_ENTRY();

	EngFncs->remove_element(handle->elem);

	EngFncs->insert_element(file_handles, handle->elem, INSERT_AFTER, NULL);

	LOG_EXIT_VOID();

}

/**

 * file_handle_find_free

 *

 * Search the file-handles list for an unused entry and assign it to this disk.

 **/

static file_handle_t *file_handle_find_free(void)

{

	file_handle_t *handle;

	list_element_t iter;

	LOG_ENTRY();

	LIST_FOR_EACH(file_handles, iter, handle) {

		if (!handle->disk) {

			break;

		}

	}

	LOG_EXIT_PTR(handle);

	return handle;

}

/**

 * file_handle_steal_first

 *

 * "Steal" the first file-handle on the list, forceably close the disk that

 * currently owns it, and assign it to the new disk.

 **/

static file_handle_t *file_handle_steal_first(void)

{

	file_handle_t *handle;

	LOG_ENTRY();

	handle = EngFncs->first_thing(file_handles, NULL);

	if (handle->disk) {

		LOG_DEBUG("Stealing file-handle from disk %s.\n",

			  handle->disk->name);

		close_dev(handle->disk);

	}

	LOG_EXIT_PTR(handle);

	return handle;

}

/**

 * file_handle_get

 *

 * Get a file-handle for this disk. First search the list for an used one. If

 * we can't find one, simply "steal" the first one on the list.

 **/

static file_handle_t *file_handle_get(void)

{

	file_handle_t *handle;

	LOG_ENTRY();

	handle = file_handle_find_free();

	if (!handle) {

		handle = file_handle_steal_first();

	}

	LOG_EXIT_PTR(handle);

	return handle;

}

static int LD_setup(engine_functions_t * engine_function_table)

{

	int rc;

	/* save info we get from the engine */

	EngFncs = engine_function_table;

	LOG_ENTRY();

	if (where_is_sysfs(&sysfs_mount_point)) {

		get_sysfs_config();

	} else {

		get_legacy_config();

	}

	rc = file_handle_setup();

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * open_dev

 *

 * Open the specified disk. Use O_DIRECT to avoid caching. Use O_SYNC in case

 * the kernel does not honor O_DIRECT. Use the Engine's service so we

 * automatically get a dev-node in the /dev/evms/.nodes/ tree. Record the

 * file handle in the disk's private data.

 **/

static int open_dev(storage_object_t * disk)

{

	local_disk_t * ld = disk->private_data;

	int rc = 0;

	LOG_ENTRY();

	if (ld->fd <= 0) {

		ld->file_handle = file_handle_get();

		ld->file_handle->disk = disk;

		ld->fd = EngFncs->open_object(disk, O_RDWR | O_DIRECT | O_SYNC);

		if (ld->fd < 0) {

			rc = - ld->fd;

			file_handle_release(ld->file_handle);

			ld->file_handle = NULL;

			LOG_DEBUG("Error opening disk %s: %d: %s\n",

				  disk->name, rc, strerror(rc));

		}

	}

	if (!rc) {

		file_handle_make_last(ld->file_handle);

	}

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * close_dev

 *

 * Close the disk and clear the file handle.

 **/

static void close_dev(storage_object_t * disk)

{

	local_disk_t * ld = disk->private_data;

	int rc;

	LOG_ENTRY();

	if (ld->fd >= 0) {

		rc = EngFncs->close_object(disk, ld->fd);

		file_handle_release(ld->file_handle);

		ld->file_handle = NULL;

		ld->fd = -1;

	}

	LOG_EXIT_VOID();

}

/**

 * LD_cleanup

 *

 * Find any disks and close the device that was opended during discovery.

 **/

static void LD_cleanup(void)

{

	storage_object_t * disk;

	list_anchor_t disk_list;

	list_element_t disk_list_itr;

	int rc;

	LOG_ENTRY();

	/* Get a list of disks that are managed by this plug-in. */

	rc = EngFncs->get_object_list(DISK, 0, my_plugin_record,

				      NULL, 0, &disk_list);

	if (!rc) {

		/* Close any dev handles that might be open. */

		LIST_FOR_EACH(disk_list, disk_list_itr, disk) {

			close_dev(disk);

			EngFncs->engine_free(disk->private_data);

		}

		EngFncs->destroy_list(disk_list);

	}

	destroy_cache();

	file_handle_cleanup();

	if (base_directory) {

		free(base_directory);

		base_directory = NULL;

	}

	if (sysfs_mount_point) {

		free(sysfs_mount_point);

		sysfs_mount_point = NULL;

	}

	LOG_EXIT_VOID();

}

static void filter_out_excludes(char * pattern, int path_len, int new_globs_index)

{

	int rc;

	int i;

	glob_t exclude_glob = {0};

	LOG_ENTRY();

	for (i = 0; i < exclude_count; i++) {

		strcpy(pattern + path_len, excludes[i]);

		rc = glob(pattern, glob_flags, NULL, &exclude_glob);

		if (rc == 0) {

			glob_flags |= GLOB_APPEND;

		} else {

			if (rc != GLOB_NOMATCH) {

				LOG_WARNING("glob() of pattern %s failed with error %s\n", pattern,

					    (rc == GLOB_NOSPACE) ? "GLOB_NOSPACE" :

					    (rc == GLOB_ABEND) ? "GLOB_ABEND" :

					    "(unknown)");

			}

		}

	}

	for (i = 0; i < exclude_glob.gl_pathc; i++) {

		int j;

		for (j = new_globs_index; j < dev_names_glob.gl_pathc; j++) {

			if (strcmp(exclude_glob.gl_pathv[i], dev_names_glob.gl_pathv[j]) == 0) {

				int k;

				LOG_DEBUG("Removing %s.\n", dev_names_glob.gl_pathv[j]);

				free(dev_names_glob.gl_pathv[j]);

				/* Scoot up all following entries. */

				for (k = j+1; k < dev_names_glob.gl_pathc; k++) {

					dev_names_glob.gl_pathv[k-1] = dev_names_glob.gl_pathv[k];

				}

				dev_names_glob.gl_pathc--;

				break;

			}

		}

	}

	if (exclude_glob.gl_pathc >= 0) {

		globfree(&exclude_glob);

	}

	LOG_EXIT_VOID();

}

static void filter_out_non_block_devices(int new_globs_index)

{

	int i;

	struct stat statbuf;

	int status;

	LOG_ENTRY();

	i = new_globs_index;

	while (i < dev_names_glob.gl_pathc) {

		status = stat(dev_names_glob.gl_pathv[i], &statbuf);

		if (status == 0) {

			if (!S_ISBLK(statbuf.st_mode)) {

				int j;

				LOG_DEBUG("Removing %s.\n", dev_names_glob.gl_pathv[i]);

				free(dev_names_glob.gl_pathv[i]);

				/* Scoot up all following entries. */

				for (j = i+1; j < dev_names_glob.gl_pathc; j++) {

					dev_names_glob.gl_pathv[j-1] = dev_names_glob.gl_pathv[j];

				}

				dev_names_glob.gl_pathc--;

				dev_names_glob.gl_pathv[dev_names_glob.gl_pathc] = NULL;

				/* Leave "i" as it is so we check the new

				 * entry at the current index.

				 */

				continue;

			}

		} else {

			LOG_WARNING("stat(%s) failed with error code %d: %s\n", dev_names_glob.gl_pathv[i], errno, strerror(errno));

		}

		i++;

	}

	LOG_EXIT_VOID();

}

static void get_dev_names(const char * dir)

{

	int rc;

	int i;

	int path_len;

	int new_globs_index;

	LOG_ENTRY();

	LOG_DEBUG("Get device names in directory %s\n", dir);

	strcpy(pattern, dir);

	path_len = strlen(pattern);

	if (pattern[path_len-1] != '/') {

		pattern[path_len] = '/';

		pattern[path_len+1] = '\0';

		path_len++;

	}

	new_globs_index = dev_names_glob.gl_pathc;

	for (i = 0; i < include_count; i++) {

		strcpy(pattern + path_len, includes[i]);

		rc = glob(pattern, glob_flags, NULL, &dev_names_glob);

		if (rc == 0) {

			glob_flags |= GLOB_APPEND;

		} else {

			if (rc != GLOB_NOMATCH) {

				LOG_WARNING("glob() of pattern %s failed with error %s\n", pattern,

					    (rc == GLOB_NOSPACE) ? "GLOB_NOSPACE" :

					    (rc == GLOB_ABEND) ? "GLOB_ABEND" :

					    "(unknown)");

			}

		}

	}

	filter_out_excludes(pattern, path_len, new_globs_index);

	if (sysfs_mount_point == NULL) {

		filter_out_non_block_devices(new_globs_index);

	}

	LOG_EXIT_VOID();

}

static char dir_pattern[PATH_MAX];

static void process_dir(char * name)

{

	int i;

	glob_t dirs_glob;

	LOG_ENTRY();

	/* Process entries in this directory. */

	get_dev_names(name);

	/* Get a list of this directory's subdirectories. */

	strcpy(dir_pattern, name);

	strcat(dir_pattern, "*/");

	if (glob(dir_pattern, 0, NULL, &dirs_glob) == 0) {

		/* Process the subdirectories. */

		for (i = 0; i < dirs_glob.gl_pathc; i++) {

			int status;

			struct stat statbuf;

			status = stat(dirs_glob.gl_pathv[i], &statbuf);

			if (status == 0) {

				if (S_ISDIR(statbuf.st_mode)) {

					process_dir(dirs_glob.gl_pathv[i]);

				}

			}

		}

		globfree(&dirs_glob);

	}

	LOG_EXIT_VOID();

}

static char dir_path[PATH_MAX];

static void get_legacy_devs()

{

	int base_len, i;

	char * pch;

	LOG_ENTRY();

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

	glob_flags = 0;

	/* Make sure the user-specified directory ends with a '/'. */

	base_len = strlen(scan);

	if (scan[base_len-1] != '/') {

		pch = malloc(base_len + 2);

		if (pch) {

			strcpy(pch, scan);

			strcpy(pch + base_len, "/");

			scan = pch;

			base_len += 2;

		}

	}

	base_directory = strdup(scan);

	base_directory_len = strlen(base_directory);

	/* Always find devices in the base directory. */

	get_dev_names(base_directory);

	/* Recursively search any subdirectories the user specified. */

	strcpy(dir_path, base_directory);

	for (i = 0; i < directories_count; i++) {

		int len;

		strcpy(dir_path + base_directory_len, directories[i]);

		len = strlen(dir_path);

		if (dir_path[len-1] != '/') {

			strcpy(dir_path + len, "/");

		}

		process_dir(dir_path);

	}

	LOG_EXIT_VOID();

}

static void get_sysfs_devs()

{

	LOG_ENTRY();

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

	glob_flags = 0;

	strcpy(dir_path, sysfs_mount_point);

	strcat(dir_path, "/block/");

	base_directory = strdup(dir_path);

	base_directory_len = strlen(base_directory);

	LOG_DEBUG("Scanning %s\n", dir_path);

	get_dev_names(dir_path);

	LOG_EXIT_VOID();

}

/**

 * get_sysfs_size

 * @full_name:	Full path-name to the disk device-node.

 * @p_size:	Return pointer to the disk's size (in sectors).

 *

 * Use sysfs to get the size (in sectors) of the specified disk.

 **/

static int get_sysfs_size(char * full_name, u_int64_t * p_size)

{

	int rc = 0;

	int fd;

	char * size_file = malloc(strlen(full_name) + 6);

	char size_str[24];

	LOG_ENTRY();

	if (size_file != NULL) {

		strcpy(size_file, full_name);

		strcat(size_file, "/size");

		fd = open(size_file, O_RDONLY);

		if (fd > 0) {

			int bytes_read;

			bytes_read = read(fd, size_str, 24);

			if (bytes_read > 0) {

				/* Size is already in sectors. */

				*p_size = strtoull(size_str, NULL, 10);

			} else {

				if (bytes_read == 0) {

					LOG_ERROR("No bytes read from %s.\n", size_file);

				}

				rc = errno;

				LOG_ERROR("read() returned error %d: %s\n", rc, strerror(rc));

			}

			close(fd);

		} else {

			rc = errno;

			LOG_ERROR("open(%s) returned error %d: %s\n", size_file, rc, strerror(rc));

		}

		free(size_file);

	}

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * get_legacy_size

 * @full_name:	Full path-name to the disk device-node.

 * @p_size:	Return pointer to the disk's size (in sectors).

 *

 * Use the BLKGETSIZE64 ioctl to get the size (in sectors) of the

 * specified disk.

 **/

static int get_legacy_size(char * full_name, u_int64_t * p_size)

{

	int rc = 0;

	int fd;

	LOG_ENTRY();

	fd = open(full_name, O_RDONLY);

	if (fd > 0) {

		/* Ioctl to get size. (returns bytes) */

		rc = ioctl(fd, BLKGETSIZE64, p_size);

		if (rc == 0) {

			*p_size >>= EVMS_VSECTOR_SIZE_SHIFT;

			*p_size &= ~1;

		} else {

			rc = errno;

			LOG_DETAILS("ioctl to get the size returned error code "

				    "%d: %s.\n", rc, strerror(rc));

		}

		close(fd);

	} else {

		rc = errno;

		LOG_DETAILS("open(%s) returned error %d: %s\n",

			    full_name, rc, strerror(rc));

	}

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * get_disk_size

 * @full_name:	Full path-name to the device node.

 * @disk:	Pointer to the disk object.

 *

 * Get the size of the disk, and check that it is non-zero.

 **/

static int get_disk_size(char * full_name, storage_object_t * disk)

{

	int rc;

	LOG_ENTRY();

	if (sysfs_mount_point) {

		rc = get_sysfs_size(full_name, &disk->size);

	} else {

		rc = get_legacy_size(full_name, &disk->size);

	}

	if (disk->size == 0) {

		LOG_DEBUG("Disk %s has zero-size. Not a valid disk.\n",

			  disk->name);

		rc = EINVAL;

	} else if (disk->dev_major == NBD_MAJOR &&

		   ! is_drbd_active()) {

		/* YUCK!!! Uninitialized NBD devices report a size anyway.

		 * DRBD (which shares the same major) behaves correctly.

		 */

		if (EngFncs->is_2_4_kernel()) {

			if (disk->size == NBD_DEF_SIZE_2_4) {

				LOG_DEBUG("Disk %s appears to be an uninitialized NBD "

					  "device.\n", disk->name);

				rc = EINVAL;

			}

		} else {

			if (disk->size == NBD_DEF_SIZE_2_6) {

				LOG_DEBUG("Disk %s appears to be an uninitialized NBD "

					  "device.\n", disk->name);

				rc = EINVAL;

			}

		}

	}

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * get_sysfs_major_minor

 * @full_name:	Full path-name to the disk device-node.

 * @p_major:	Return pointer to the disk's major-number.

 * @p_minor:	Return pointer to the disk's minor-number.

 *

 * Use sysfs to get the device-number for the specified disk.

 **/

static int get_sysfs_major_minor(char * full_name,

				 u_int32_t * p_major,

				 u_int32_t * p_minor)

{

	int rc = 0;

	int fd;

	char * dev_file = malloc(strlen(full_name) + 5);

	char dev_str[16];

	dev_t dev;

	LOG_ENTRY();

	if (dev_file != NULL) {

		strcpy(dev_file, full_name);

		strcat(dev_file, "/dev");

		fd = open(dev_file, O_RDONLY);

		if (fd > 0) {

			int bytes_read;

			bytes_read = read(fd, dev_str, 16);

			if (bytes_read > 0) {

				rc = sscanf(dev_str, "%u:%u", p_major, p_minor);

				if (rc != 2) {

					dev = strtoul(dev_str, NULL, 16);

					*p_major = major(dev);

					*p_minor = minor(dev);

				}

				rc = 0;

			} else {

				if (bytes_read == 0) {

					LOG_ERROR("No bytes read from %s.\n", dev_file);

				}

				rc = errno;

				LOG_ERROR("read() returned error %d: %s\n", rc, strerror(rc));

			}

			close(fd);

		} else {

			rc = errno;

			LOG_ERROR("open(%s) returned error %d: %s\n", dev_file, rc, strerror(rc));

		}

	}

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * get_legacy_major_minor

 * @full_name:	Full path-name to the disk device-node.

 * @p_major:	Return pointer to the disk's major-number.

 * @p_minor:	Return pointer to the disk's minor-number.

 *

 * Use stat to get the device-number for the specified disk.

 **/

static int get_legacy_major_minor(char * full_name,

				  u_int32_t * p_major,

				  u_int32_t * p_minor)

{

	int rc = 0;

	struct stat statbuf;

	LOG_ENTRY();

	rc = stat(full_name, &statbuf);

	if (rc == 0) {

		*p_major = major(statbuf.st_rdev);

		*p_minor = minor(statbuf.st_rdev);

	} else {

		rc = errno;

		LOG_ERROR("stat(%s) returned error code %d: %s\n",

			  full_name, rc, strerror(rc));

	}

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * check_for_duplicate_dev

 *

 * Search the current output list for the device-number of the specified disk.

 * Each device-number should only be discovered once.

 **/

static int check_for_duplicate_dev(storage_object_t * new_disk,

				   list_anchor_t output_list)

{

	storage_object_t * disk;

	list_element_t itr;

	LOG_ENTRY();

	LIST_FOR_EACH(output_list, itr, disk) {

		if (disk->dev_major == new_disk->dev_major &&

		    disk->dev_minor == new_disk->dev_minor) {

			LOG_WARNING("Current disk %s has device-number %x:%x, which"

				    "is a duplicate of disk %s. Ignoring %s.\n",

				    new_disk->name, new_disk->dev_major,

				    new_disk->dev_minor, disk->name, new_disk->name);

			LOG_EXIT_INT(EINVAL);

			return EINVAL;

		}

	}

	LOG_EXIT_INT(0);

	return 0;

}

/**

 * get_disk_devnum

 * @full_name:	Full path-name to the disk device-node.

 * @disk:	Pointer to the disk object.

 * @output_list:Current list of discovered disks.

 *

 * Get the device-number for the specified disk. Check that the device-number

 * is allowed, and that it isn't a duplicate of an already-discovered disk.

 **/

static int get_disk_devnum(char * full_name,

			   storage_object_t * disk,

			   list_anchor_t output_list)

{

	int rc;

	LOG_ENTRY();

	if (sysfs_mount_point) {

		rc = get_sysfs_major_minor(full_name, &disk->dev_major,

					   &disk->dev_minor);

	} else {

		rc = get_legacy_major_minor(full_name, &disk->dev_major,

					    &disk->dev_minor);

	}

	if (rc) {

		goto out;

	}

	/* Exclude floppy, md, and lvm1 devices. */

	if (disk->dev_major == FLOPPY_MAJOR ||

	    disk->dev_major == MD_MAJOR ||

	    disk->dev_major == LVM_MAJOR) {

		LOG_DEBUG("Disk %s has a disallowed major number: %d.\n",

			  disk->name, disk->dev_major);

		rc = EINVAL;

		goto out;

	}

	/* Only discover a given device-number once. */

	rc = check_for_duplicate_dev(disk, output_list);

out:

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * get_dm_device_list

 *

 * Get the list of current DM devices (if we haven't gotten it previously).

 **/

static dm_device_list_t * get_dm_device_list(void)

{

	int rc;

	LOG_ENTRY();

	if (!dm_devices) {

		rc = EngFncs->dm_get_devices(&dm_devices);

		if (rc) {

			LOG_ERROR("Error calling dm_get_devices.\n");

		}

	}

	LOG_EXIT_PTR(dm_devices);

	return dm_devices;

}

/**

 * find_disk_in_dm_devices

 *

 * Search the DM devices list for an entry with the same major:minor

 * as this disk.

 **/

static dm_device_list_t * find_disk_in_dm_devices(storage_object_t * disk,

						  dm_device_list_t * dm_list)

{

	dm_device_list_t * dm_entry;

	LOG_ENTRY();

	for (dm_entry = dm_list; dm_entry; dm_entry = dm_entry->next) {

		if (dm_entry->dev_major == disk->dev_major &&

		    dm_entry->dev_minor == disk->dev_minor) {

			goto out;

		}

	}

out:

	LOG_EXIT_PTR(dm_entry);

	return dm_entry;

}

/**

 * check_multipath_name

 *

 * Other EVMS plugins can create multipath devices. We *don't* want to

 * recognize those devices as disks. So check the name that we got from

 * DM to see if it uses the naming format of the EVMS multipath plugins.

 **/

static int check_multipath_name(storage_object_t *disk)

{

	int rc;

	LOG_ENTRY();

	/* Multipath-segment-manager devices start with "mp/". */

	rc = strncmp(disk->name, "mp/", 3);

	if (rc) {

		/* MD-multipath devices start with "md/". */

		rc = strncmp(disk->name, "md/", 3);

	}

	rc = rc ? 0 : EINVAL;

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * update_multipath_child_list

 *

 * Search the multipath target info for all the child devices. Add these

 * devices to the global list so we can filter these out at the end of

 * discovery. That way we won't discover both the multipath devices and

 * their component disks, which would lead to duplicate discoveries in the

 * higher levels.

 *

 * Use a temporary list to build up the list of children for this multipath.

 * Then append this list to the global one once we've collected all the

 * children. This will prevent hitting an error part way through processing

 * the list of child devices, which could leave the global list in an

 * inconsistent state.

 **/

static int update_multipath_child_list(dm_target_t * targets)

{

	dm_target_multipath_t * mp = targets->data.multipath;

	dm_priority_group_t * pg;

	dm_path_t * path;

	dm_device_t * device;

	list_anchor_t children = NULL;

	list_element_t itr1, itr2;

	int i, j, rc = 0;

	LOG_ENTRY();

	/* Allocate the global child list if it doesn't exist yet. */

	if (!multipath_children) {

		multipath_children = EngFncs->allocate_list();

		if (!multipath_children) {

			LOG_ERROR("Error allocating multipath_children list.\n");

			rc = ENOMEM;

			goto out;

		}

	}

	/* Allocate a temporary list. */

	children = EngFncs->allocate_list();

	if (!children) {

		LOG_ERROR("Error allocating temporary child list.\n");

		rc = ENOMEM;

		goto out;

	}

	/* For each priority group in the multipath. */

	for (i = 0; i < mp->num_groups; i++) {

		pg = mp->group + i;

		/* For each path in the priority group. */

		for (j = 0; j < pg->num_paths; j++) {

			path = pg->path + j;

			device = EngFncs->engine_alloc(sizeof(*device));

			if (!device) {

				LOG_ERROR("Error allocating device structure "

					  "for path %d:%d.\n",

					  path->device.major, path->device.minor);

				rc = ENOMEM;

				goto out;

			}

			device->major = path->device.major;

			device->minor = path->device.minor;

			/* Add this path's device to the temporary list. */

			itr1 = EngFncs->insert_thing(children, device,

						     INSERT_AFTER, NULL);

			if (!itr1) {

				LOG_ERROR("Error adding device %d:%d to the "

					  "temporary child list.\n",

					  device->major, device->minor);

				rc = ENOMEM;

				goto out;

			}

		}

	}

out:

	if (!rc) {

		/* Success. Append the temporary list to the global list. */

		rc = EngFncs->merge_lists(multipath_children, children, NULL, NULL);

		if (rc) {

			LOG_ERROR("Error merging temporary list with "

				  "multipath_children list.\n");

		}

	}

	if (rc) {

		/* Some error occurred. Delete the temporary

		 * list and all of it's devices.

		 */

		if (children) {

			LIST_FOR_EACH_SAFE(children, itr1, itr2, device) {

				EngFncs->delete_element(itr1);

				EngFncs->engine_free(device);

			}

		}

	}

	if (children) {

		EngFncs->destroy_list(children);

	}

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * check_multipath

 *

 * Check if this disk is a DM multipath device.

 **/

static int check_multipath(storage_object_t * disk)

{

	dm_device_list_t * dm_list, * dm_entry;

	dm_target_t * targets = NULL;

	local_disk_t * ld = disk->private_data;

	int rc = 0;

	LOG_ENTRY();

	/* Get the list of active DM devices. */

	dm_list = get_dm_device_list();

	if (!dm_list) {

		LOG_WARNING("Cannot get list of DM devices.\n");

		goto out;

	}

	/* Search the DM list for an entry that matches this disk. */

	dm_entry = find_disk_in_dm_devices(disk, dm_list);

	if (!dm_entry) {

		LOG_DEBUG("Disk %s is not a DM device.\n", disk->name);

		goto out;

	}

	/* Copy the DM name to this disk. */

	LOG_DEBUG("Changing disk name from %s to %s.\n",

		  disk->name, dm_entry->name);

	strncpy(disk->name, dm_entry->name, EVMS_NAME_SIZE);

	/* Get the DM mapping for this disk. */

	rc = EngFncs->dm_get_targets(disk, &targets);

	if (rc) {

		LOG_ERROR("Error getting DM mapping for disk %s.\n", disk->name);

		goto out;

	}

	/* Reject all non-multipath devices. */

	if (targets->type != DM_TARGET_MULTIPATH) {

		LOG_DEBUG("Disk %s is not a multipath device.\n", disk->name);

		rc = EINVAL;

		goto out;

	}

	/* Reject all multipath devices that

	 * were created by other EVMS plugins.

	 */

	rc = check_multipath_name(disk);

	if (rc) {

		LOG_DEBUG("Multipath disk %s belongs to another EVMS plugin.\n",

			  disk->name);

		goto out;

	}

	rc = update_multipath_child_list(targets);

	if (rc) {

		LOG_DEBUG("Error building list of children of "

			  "multipath disk %s.\n", disk->name);

		goto out;

	}

	ld->flags |= LD_FLAG_MULTIPATH;

out:

	EngFncs->dm_deallocate_targets(targets);

	LOG_EXIT_INT(rc);

	return rc;

}

/**

 * remove_multipath_children

 *

 * Compare the multipath_children list with the discovery output list. Any

 * disks on the multipath_children list must be removed from the output list.

 **/

static void remove_multipath_children(list_anchor_t multipath_children,

				      list_anchor_t output_list)

{

	list_element_t itr1, itr2, itr3;

	storage_object_t * disk;

	dm_device_t * child;

	LOG_ENTRY();

	LIST_FOR_EACH(multipath_children, itr3, child) {

		LIST_FOR_EACH_SAFE(output_list, itr1, itr2, disk) {

			if (child->major == disk->dev_major &&

			    child->minor == disk->dev_minor) {

				EngFncs->delete_element(itr1);

				close_dev(disk);

				EngFncs->engine_free(disk->private_data);

				disk->flags &= ~SOFLAG_ACTIVE;

				EngFncs->free_logical_disk(disk);

			}

		}

	}

	LOG_EXIT_VOID();

}

/**

 * get_geometry

 *

 * Use the HDIO_GETGEO_BIG or HDIO_GETGEO ioctl to get the disk's geometry.

 * Check that the geometry is valid for a disk.

 **/

static int get_geometry(storage_object_t * disk)

{

	struct hd_big_geometry big_geometry;

	struct hd_geometry geometry;