xref: /onnv-gate/usr/src/cmd/modload/add_drv.c (revision 10842:e5e88c478ff5)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <libelf.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/buf.h>
#include <wait.h>
#include <unistd.h>
#include <libintl.h>
#include <sys/modctl.h>
#include <sys/systeminfo.h>
#include <string.h>
#include <limits.h>
#include <locale.h>
#include <ftw.h>
#include <sys/sunddi.h>
#include <libdevinfo.h>
#include <sys/sysmacros.h>
#include <fcntl.h>
#include <zone.h>
#include "addrem.h"
#include "errmsg.h"
#include "plcysubr.h"

/*
 * globals needed for libdevinfo - there is no way to pass
 * private data to the find routine.
 */
struct dev_list {
	int clone;
	char *dev_name;
	char *driver_name;
	struct dev_list *next;
};

static char *kelf_desc = NULL;
static int kelf_type = ELFCLASSNONE;

static char *new_drv;
static struct dev_list *conflict_lst = NULL;

static int module_not_found(char *, char *, int, char **, int *);
static void usage();
static int update_minor_perm(char *, char *);
static int devfs_update_minor_perm(char *, char *);
static int update_driver_classes(char *, char *);
static int drv_name_conflict(di_node_t);
static int devfs_node(di_node_t node, void *arg);
static int drv_name_match(char *, int, char *, char *);
static void print_drv_conflict_info(int);
static void check_dev_dir(int);
static int dev_node(const char *, const struct stat *, int, struct FTW *);
static void free_conflict_list(struct dev_list *);
static int clone(di_node_t node);
static int elf_type(char *, char **, int *);
static int correct_location(char *, char **, int *);
static int isaspec_drvmod_discovery();
static void remove_slashes(char *);
static int update_extra_privs(char *, char *privlist);
static int ignore_root_basedir();

int
main(int argc, char *argv[])
{
	int opt;
	major_t major_num;
	char driver_name[FILENAME_MAX + 1];
	int driver_name_size = sizeof (driver_name);
	char path_driver_name[MAXPATHLEN];
	int path_driver_name_size = sizeof (path_driver_name);
	char *perms = NULL;
	char *aliases = NULL;
	char *classes = NULL;
	char *policy = NULL;
	char *priv = NULL;
	int noload_flag = 0;
	int verbose_flag = 0;
	int force_flag = 0;
	int update_only = 0;
	int i_flag = 0;
	int c_flag = 0;
	int m_flag = 0;
	int cleanup_flag = 0;
	int server = 0;
	char *basedir = NULL;
	int is_unique;
	char *slash;
	int conflict;
	di_node_t root_node;	/* for device tree snapshot */
	char *drvelf_desc = NULL;
	int drvelf_type = ELFCLASSNONE;
	int config_flags;

	moddir = NULL;

	(void) setlocale(LC_ALL, "");
#if	!defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
#define	TEXT_DOMAIN "SYS_TEST"	/* Use this only if it weren't */
#endif
	(void) textdomain(TEXT_DOMAIN);

	/*  must be run by root */

	if (geteuid() != 0) {
		(void) fprintf(stderr, gettext(ERR_NOT_ROOT));
		exit(1);
	}

	while ((opt = getopt(argc, argv, "vfm:ni:b:c:p:P:u")) != EOF) {
		switch (opt) {
		case 'm' :
			m_flag = 1;
			perms = optarg;
			break;
		case 'f':
			force_flag++;
			break;
		case 'v':
			verbose_flag++;
			break;
		case 'n':
			noload_flag++;
			break;
		case 'i' :
			i_flag = 1;
			aliases = optarg;
			if (check_space_within_quote(aliases) == ERROR) {
				(void) fprintf(stderr, gettext(ERR_NO_SPACE),
				    aliases);
				exit(1);
			}
			break;
		case 'b' :
			server = 1;
			basedir = optarg;
			if (strcmp(basedir, "/") == 0 &&
			    ignore_root_basedir()) {
				server = 0;
				basedir = NULL;
			}
			break;
		case 'c':
			c_flag = 1;
			classes = optarg;
			break;
		case 'p':
			policy = optarg;
			break;
		case 'P':
			priv = optarg;
			break;
		case 'u':
			/*
			 * Update binding files and kernel but
			 * do not load or configure devices.
			 */
			update_only = 1;
			break;
		case '?' :
		default:
			usage();
			exit(1);
		}
	}


	if (argv[optind] != NULL) {
		if (strlcpy(driver_name, argv[optind], driver_name_size) >=
		    driver_name_size) {
			(void) fprintf(stderr, gettext(ERR_DRVNAME_TOO_LONG),
			    driver_name_size, argv[optind]);
			exit(1);
		}

		/*
		 * check for extra args
		 */
		if ((optind + 1) != argc) {
			usage();
			exit(1);
		}

	} else {
		usage();
		exit(1);
	}

	if (getzoneid() != GLOBAL_ZONEID) {
		(void) fprintf(stderr, gettext(ERR_NOT_GLOBAL_ZONE));
		exit(1);
	}

	/*
	 * Fail if add_drv was invoked with a pathname prepended to the
	 * driver_name argument.
	 *
	 * Check driver_name for any '/'s. If found, we assume that caller
	 * is trying to specify a pathname.
	 */

	slash = strchr(driver_name, '/');
	if (slash) {
		remove_slashes(driver_name);

		/* extract module name out of path */
		slash = strrchr(driver_name, '/');

		if (slash != NULL) {
			(void) fprintf(stderr, gettext(ERR_PATH_SPEC),
			    driver_name);
			(void) fprintf(stderr, gettext(ERR_INSTALL_FAIL),
			    ++slash);
			exit(1);
		}
	}
	new_drv = driver_name;

	/* set up add_drv filenames */
	if ((build_filenames(basedir)) == ERROR) {
		exit(1);
	}

	/* must be only running version of add_drv/rem_drv */
	enter_lock();

	if ((check_perms_aliases(m_flag, i_flag)) == ERROR)
		err_exit();

	if ((check_name_to_major(R_OK | W_OK)) == ERROR)
		err_exit();

	/*
	 * check validity of options
	 */
	if (m_flag) {
		if ((check_perm_opts(perms)) == ERROR) {
			usage();
			err_exit();
		}
	}

	if (i_flag) {
		if (aliases != NULL)
			if ((aliases_unique(aliases)) == ERROR)
				err_exit();
	}

	/* -u and -n/-b are mutually exclusive */
	if (update_only && (noload_flag || server)) {
		usage();
		err_exit();
	}

	/* update kernel unless -b or -n */
	if (noload_flag == 0 && server == 0 &&
	    priv != NULL && check_priv_entry(priv, 1) != 0)
		err_exit();

	if (policy != NULL &&
	    (policy = check_plcy_entry(policy, driver_name, B_FALSE)) == NULL) {
		err_exit();
	}

	if ((unique_driver_name(driver_name, name_to_major,
	    &is_unique)) == ERROR)
		err_exit();

	if (is_unique == NOT_UNIQUE) {
		(void) fprintf(stderr, gettext(ERR_NOT_UNIQUE), driver_name);
		err_exit();
	}

	if (noload_flag == 0 && server == 0) {
		if (elf_type("/dev/ksyms", &kelf_desc, &kelf_type) == ERROR) {
			(void) fprintf(stderr, gettext(ERR_KERNEL_ISA));
			err_exit();
		}

		if (module_not_found(driver_name, path_driver_name,
		    path_driver_name_size, &drvelf_desc, &drvelf_type) ==
		    ERROR) {
			(void) fprintf(stderr, gettext(ERR_NOMOD), driver_name);
			err_exit();
		}

		/*
		 * If the driver location is incorrect but the kernel and driver
		 * are of the same ISA, suggest a fix.  If the driver location
		 * is incorrect and the ISA's mismatch, notify the user that
		 * this driver can not be loaded on this kernel.  In both cases,
		 * do not attempt to load the driver module.
		 */

		if (correct_location(path_driver_name, &drvelf_desc,
		    (&drvelf_type)) == ERROR) {
			noload_flag = 1;
			if (kelf_type == drvelf_type) {
				(void) fprintf(stderr,
				    gettext(ERR_SOL_LOCATION), driver_name,
				    driver_name);
			} else {
				(void) fprintf(stderr,
				    gettext(ERR_NOT_LOADABLE),
				    drvelf_desc, driver_name, kelf_desc);
			}

		/*
		 * The driver location is correct.  Verify that the kernel ISA
		 * and driver ISA match.  If they do not match, produce an error
		 * message and do not attempt to load the module.
		 */

		} else if (kelf_type != drvelf_type) {
			noload_flag = 1;
			(void) fprintf(stderr, gettext(ERR_ISA_MISMATCH),
			    kelf_desc, driver_name, drvelf_desc);
			(void) fprintf(stderr, gettext(ERR_NOT_LOADABLE),
			    drvelf_desc, driver_name, kelf_desc);
		}


		/*
		 * Check for a more specific driver conflict - see
		 * PSARC/1995/239
		 * Note that drv_name_conflict() can return -1 for error
		 * or 1 for a conflict.  Since the default is to fail unless
		 * the -f flag is specified, we don't bother to differentiate.
		 */
		if ((root_node = di_init("/", DINFOSUBTREE | DINFOMINOR))
		    == DI_NODE_NIL) {
			(void) fprintf(stderr, gettext(ERR_DEVTREE));
			conflict = -1;
		} else {
			conflict = drv_name_conflict(root_node);
			di_fini(root_node);
		}

		if (conflict) {
			/*
			 * if the force flag is not set, we fail here
			 */
			if (!force_flag) {
				(void) fprintf(stderr,
				    gettext(ERR_INSTALL_FAIL), driver_name);
				(void) fprintf(stderr, "Device managed by "
				    "another driver.\n");
				if (verbose_flag)
					print_drv_conflict_info(force_flag);
				err_exit();
			}
			/*
			 * The force flag was specified so we print warnings
			 * and install the driver anyways
			 */
			if (verbose_flag)
				print_drv_conflict_info(force_flag);
			free_conflict_list(conflict_lst);
		}
	}

	if ((update_name_to_major(driver_name, &major_num, server)) == ERROR) {
		err_exit();
	}

	cleanup_flag |= CLEAN_NAM_MAJ;


	if (m_flag) {
		cleanup_flag |= CLEAN_MINOR_PERM;
		if (update_minor_perm(driver_name, perms) == ERROR) {
			remove_entry(cleanup_flag, driver_name);
			err_exit();
		}
	}

	if (i_flag) {
		cleanup_flag |= CLEAN_DRV_ALIAS;
		if (update_driver_aliases(driver_name, aliases) == ERROR) {
			remove_entry(cleanup_flag, driver_name);
			err_exit();

		}
	}

	if (c_flag) {
		cleanup_flag |= CLEAN_DRV_CLASSES;
		if (update_driver_classes(driver_name, classes) == ERROR) {
			remove_entry(cleanup_flag, driver_name);
			err_exit();

		}
	}

	if (priv != NULL) {
		cleanup_flag |= CLEAN_DRV_PRIV;
		if (update_extra_privs(driver_name, priv) == ERROR) {
			remove_entry(cleanup_flag, driver_name);
			err_exit();
		}
	}

	if (policy != NULL) {
		cleanup_flag |= CLEAN_DEV_POLICY;
		if (update_device_policy(device_policy, policy, B_FALSE)
		    == ERROR) {
			remove_entry(cleanup_flag, driver_name);
			err_exit();
		}
	}

	if (noload_flag || server) {
		(void) fprintf(stderr, gettext(BOOT_CLIENT));
	} else {
		/*
		 * paranoia - if we crash whilst configuring the driver
		 * this might avert possible file corruption.
		 */
		sync();

		config_flags = 0;
		if (verbose_flag)
			config_flags |= CONFIG_DRV_VERBOSE;
		if (update_only)
			config_flags |= CONFIG_DRV_UPDATE_ONLY;

		if (config_driver(driver_name, major_num, aliases, classes,
		    cleanup_flag, config_flags) == ERROR) {
			err_exit();
		}
		if (m_flag) {
			if (devfs_update_minor_perm(basedir,
			    driver_name) == ERROR) {
				err_exit();
			}
		}
		if (update_only) {
			(void) fprintf(stderr, gettext(INFO_UPDATE_ONLY),
			    driver_name);
		} else if (noload_flag) {
			(void) fprintf(stderr, gettext(ERR_CONFIG_NOLOAD),
			    driver_name);
		} else {
			load_driver(driver_name, verbose_flag);
		}
	}

	if (create_reconfig(basedir) == ERROR)
		(void) fprintf(stderr, gettext(ERR_CREATE_RECONFIG));

	cleanup_moddir();
	exit_unlock();

	if (verbose_flag) {
		(void) fprintf(stderr, gettext(DRIVER_INSTALLED), driver_name);
	}

	return (NOERR);
}

/*
 *	Searches for the driver module along the module path (returned
 *	from modctl) and returns a string (in drv_path) representing the path
 *	where drv_name was found.  ERROR is returned if function is unable
 *	to locate drv_name.
 */
int
module_not_found(char *drv_name, char *drv_path, int drv_path_size,
    char **drvelf_desc, int *drvelf_type_ptr)
{
	struct stat buf;
	char data [MAXMODPATHS];
	char pathsave [MAXMODPATHS];
	char *next = data;
	struct drvmod_dir *curdir = NULL;
	char foundpath[MAXPATHLEN];

	if (modctl(MODGETPATH, NULL, data) != 0) {
		(void) fprintf(stderr, gettext(ERR_MODPATH));
		return (ERROR);
	}
	(void) strcpy(pathsave, data);
	next = strtok(data, MOD_SEP);

	if (isaspec_drvmod_discovery() == ERROR)
		err_exit();

	curdir = moddir;
	while (curdir != NULL) {
		while (next != NULL) {
			(void) snprintf(foundpath, sizeof (foundpath),
			    "%s/drv/%s/%s", next, curdir->direc, drv_name);
			if ((stat(foundpath, &buf) == 0) &&
			    ((buf.st_mode & S_IFMT) == S_IFREG)) {
				if (elf_type(foundpath, drvelf_desc,
				    drvelf_type_ptr) == ERROR) {
					(void) fprintf(stderr,
					    gettext(ERR_INSTALL_FAIL),
					    drv_name);
					err_exit();
				}
				remove_slashes(foundpath);

				if (strlcpy(drv_path, foundpath, drv_path_size)
				    >= drv_path_size) {
					return (ERROR);
				}

				return (NOERR);
			}
			next = strtok((char *)NULL, MOD_SEP);
		}
		(void) strcpy(data, pathsave);
		next = strtok(data, MOD_SEP);
		curdir = curdir->next;
	}

	return (ERROR);
}

static void
usage()
{
	(void) fprintf(stderr, gettext(USAGE));
}

static int
update_driver_classes(
	char *driver_name,
	char *classes)
{
	/* make call to update the classes file */
	return (append_to_file(driver_name, classes, driver_classes,
	    ' ', "\t", 0));
}

static int
update_minor_perm(
	char *driver_name,
	char *perm_list)
{
	return (append_to_minor_perm(driver_name, perm_list, minor_perm));
}


/*
 * Complete the minor perm update by communicating the minor perm
 * data to the kernel.  This information is used by devfs to ensure
 * that devices always have the correct permissions when attached.
 * The minor perm file must be updated and the driver configured
 * in the system for this step to complete correctly.
 */
static int
devfs_update_minor_perm(
	char *basedir,
	char *driver_name)
{
	int rval = 0;

	if (basedir == NULL || (strcmp(basedir, "/") == 0)) {
		if (devfs_add_minor_perm(driver_name,
		    log_minorperm_error) != 0) {
			(void) fprintf(stderr,
			    gettext(ERR_UPDATE_PERM), driver_name);
		}
	}
	return (rval);
}

static int
update_extra_privs(
	char *driver_name,
	char *privlist)
{
	return (append_to_file(driver_name, privlist, extra_privs,
	    ',', ":", 0));
}

/*
 * Check to see if the driver we are adding is a more specific
 * driver for a device already attached to a less specific driver.
 * In other words, see if this driver comes earlier on the compatible
 * list of a device already attached to another driver.
 * If so, the new node will not be created (since the device is
 * already attached) but when the system reboots, it will attach to
 * the new driver but not have a node - we need to warn the user
 * if this is the case.
 */
static int
drv_name_conflict(di_node_t root_node)
{
	/*
	 * walk the device tree checking each node
	 */
	if (di_walk_node(root_node, DI_WALK_SIBFIRST, NULL, devfs_node) == -1) {
		free_conflict_list(conflict_lst);
		conflict_lst = (struct dev_list *)NULL;
		(void) fprintf(stderr, gettext(ERR_DEVTREE));
		return (-1);
	}

	if (conflict_lst == NULL)
		/* no conflicts found */
		return (0);
	else
		/* conflicts! */
		return (1);
}

/*
 * called via di_walk_node().
 * called for each node in the device tree.  We skip nodes that:
 *	1. are not hw nodes (since they cannot have generic names)
 *	2. that do not have a compatible property
 *	3. whose node name = binding name.
 *	4. nexus nodes - the name of a generic nexus node would
 *	not be affected by a driver change.
 * Otherwise, we parse the compatible property, if we find a
 * match with the new driver before we find a match with the
 * current driver, then we have a conflict and we save the
 * node away.
 */
/*ARGSUSED*/
static int
devfs_node(di_node_t node, void *arg)
{
	char *binding_name, *node_name, *compat_names, *devfsnm;
	struct dev_list *new_entry;
	char strbuf[MAXPATHLEN];
	int n_names;

	/*
	 * if there is no compatible property, we don't
	 * have to worry about any conflicts.
	 */
	if ((n_names = di_compatible_names(node, &compat_names)) <= 0)
		return (DI_WALK_CONTINUE);

	/*
	 * if the binding name and the node name match, then
	 * either no driver existed that could be bound to this node,
	 * or the driver name is the same as the node name.
	 */
	binding_name = di_binding_name(node);
	node_name = di_node_name(node);
	if ((binding_name == NULL) || (strcmp(node_name, binding_name) == 0))
		return (DI_WALK_CONTINUE);

	/*
	 * we can skip nexus drivers since they do not
	 * have major/minor number info encoded in their
	 * /devices name and therefore won't change.
	 */
	if (di_driver_ops(node) & DI_BUS_OPS)
		return (DI_WALK_CONTINUE);

	/*
	 * check for conflicts
	 * If we do find that the new driver is a more specific driver
	 * than the driver already attached to the device, we'll save
	 * away the node name for processing later.
	 */
	if (drv_name_match(compat_names, n_names, binding_name, new_drv)) {
		devfsnm = di_devfs_path(node);
		(void) snprintf(strbuf, sizeof (strbuf),
		    "%s%s", DEVFS_ROOT, devfsnm);
		di_devfs_path_free(devfsnm);
		new_entry = (struct dev_list *)calloc(1,
		    sizeof (struct dev_list));
		if (new_entry == (struct dev_list *)NULL) {
			(void) fprintf(stderr, gettext(ERR_NO_MEM));
			err_exit();
		}
		/* save the /devices name */
		if ((new_entry->dev_name = strdup(strbuf)) == NULL) {
			(void) fprintf(stderr, gettext(ERR_NO_MEM));
			free(new_entry);
			err_exit();
		}
		/* save the driver name */
		if ((new_entry->driver_name = strdup(di_driver_name(node)))
		    == NULL) {
			(void) fprintf(stderr, gettext(ERR_NO_MEM));
			free(new_entry->dev_name);
			free(new_entry);
			err_exit();
		}
		/* check to see if this is a clone device */
		if (clone(node))
			new_entry->clone = 1;

		/* add it to the list */
		new_entry->next = conflict_lst;
		conflict_lst = new_entry;
	}

	return (DI_WALK_CONTINUE);
}

static int
clone(di_node_t node)
{
	di_minor_t minor = DI_MINOR_NIL;

	while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {
		if (di_minor_type(minor) == DDM_ALIAS)
			return (1);
	}
	return (0);
}
/*
 * check to see if the new_name shows up on the compat list before
 * the cur_name (driver currently attached to the device).
 */
static int
drv_name_match(char *compat_names, int n_names, char *cur_name, char *new_name)
{
	int i, ret = 0;

	if (strcmp(cur_name, new_name) == 0)
		return (0);

	/* parse the coompatible list */
	for (i = 0; i < n_names; i++) {
		if (strcmp(compat_names, new_name) == 0) {
			ret = 1;
			break;
		}
		if (strcmp(compat_names, cur_name) == 0) {
			break;
		}
		compat_names += strlen(compat_names) + 1;
	}
	return (ret);
}

/*
 * A more specific driver is being added for a device already attached
 * to a less specific driver.  Print out a general warning and if
 * the force flag was passed in, give the user a hint as to what
 * nodes may be affected in /devices and /dev
 */
static void
print_drv_conflict_info(int force)
{
	struct dev_list *ptr;

	if (conflict_lst == NULL)
		return;
	if (force) {
		(void) fprintf(stderr,
		    "\nA reconfiguration boot must be performed to "
		    "complete the\n");
		(void) fprintf(stderr, "installation of this driver.\n");
	}

	if (force) {
		(void) fprintf(stderr,
		    "\nThe following entries in /devices will be "
		    "affected:\n\n");
	} else {
		(void) fprintf(stderr,
		    "\nDriver installation failed because the following\n");
		(void) fprintf(stderr,
		    "entries in /devices would be affected:\n\n");
	}

	ptr = conflict_lst;
	while (ptr != NULL) {
		(void) fprintf(stderr, "\t%s", ptr->dev_name);
		if (ptr->clone)
			(void) fprintf(stderr, " (clone device)\n");
		else
			(void) fprintf(stderr, "[:*]\n");
		(void) fprintf(stderr, "\t(Device currently managed by driver "
		    "\"%s\")\n\n", ptr->driver_name);
		ptr = ptr->next;
	}
	check_dev_dir(force);
}

/*
 * use nftw to walk through /dev looking for links that match
 * an entry in the conflict list.
 */
static void
check_dev_dir(int force)
{
	int  walk_flags = FTW_PHYS | FTW_MOUNT;
	int ft_depth = 15;

	if (force) {
		(void) fprintf(stderr, "\nThe following entries in /dev will "
		    "be affected:\n\n");
	} else {
		(void) fprintf(stderr, "\nThe following entries in /dev would "
		    "be affected:\n\n");
	}

	(void) nftw("/dev", dev_node, ft_depth, walk_flags);

	(void) fprintf(stderr, "\n");
}

/*
 * checks a /dev link to see if it matches any of the conlficting
 * /devices nodes in conflict_lst.
 */
/*ARGSUSED1*/
static int
dev_node(const char *node, const struct stat *node_stat, int flags,
	struct FTW *ftw_info)
{
	char linkbuf[MAXPATHLEN];
	struct dev_list *ptr;

	if (readlink(node, linkbuf, MAXPATHLEN) == -1)
		return (0);

	ptr = conflict_lst;

	while (ptr != NULL) {
		if (strstr(linkbuf, ptr->dev_name) != NULL)
			(void) fprintf(stderr, "\t%s\n", node);
		ptr = ptr->next;
	}
	return (0);
}


static void
free_conflict_list(struct dev_list *list)
{
	struct dev_list *save;

	/* free up any dev_list structs we allocated. */
	while (list != NULL) {
		save = list;
		list = list->next;
		free(save->dev_name);
		free(save);
	}
}

int
elf_type(char *file, char **elfdesc, int *elf_type_ptr)
{
	int fd;
	Elf *elf;
	char *ident;

	if ((fd = open(file, O_RDONLY)) < 0) {
		(void) fprintf(stderr, gettext(ERR_CANNOT_OPEN), file,
		    strerror(errno));
		return (ERROR);
	}
	if (elf_version(EV_CURRENT) == EV_NONE) {
		(void) fprintf(stderr, gettext(ERR_ELF_VERSION),
		    elf_errmsg(-1));
		(void) close(fd);
		return (ERROR);
	}
	elf = elf_begin(fd, ELF_C_READ, NULL);
	if (elf_kind(elf) != ELF_K_ELF) {
		(void) fprintf(stderr, gettext(ERR_ELF_KIND), file);
		(void) elf_end(elf);
		(void) close(fd);
		return (ERROR);
	}
	ident = elf_getident(elf, 0);
	if (ident[EI_CLASS] == ELFCLASS32) {
		*elfdesc = "32";
		*elf_type_ptr = ELFCLASS32;
	} else if (ident[EI_CLASS] == ELFCLASS64) {
		*elfdesc = "64";
		*elf_type_ptr = ELFCLASS64;
	} else {
		*elfdesc = "none";
		*elf_type_ptr = ELFCLASSNONE;
	}
	(void) elf_end(elf);
	(void) close(fd);
	return (NOERR);
}

int
correct_location(char *drv_path, char **drvelf_desc, int *drvelf_type_ptr)
{

	char copy_drv_path[MAXPATHLEN];
	char *token = copy_drv_path;

	(void) strcpy(copy_drv_path, drv_path);

	if (elf_type(drv_path, drvelf_desc, drvelf_type_ptr) == ERROR) {
		err_exit();
	}
	token = strtok(copy_drv_path, DIR_SEP);
	while (token != NULL) {
		if (strcmp("drv", token) == 0) {
			token = strtok((char *)NULL, DIR_SEP);
			if (strcmp(DRVDIR64, token) == 0) {
				if (*drvelf_type_ptr == ELFCLASS64)
					return (NOERR);
				(void) fprintf(stderr, gettext(ERR_LOCATION),
				    *drvelf_desc, drv_path);
				return (ERROR);
			} else {
				if (*drvelf_type_ptr == ELFCLASS32)
					return (NOERR);
				(void) fprintf(stderr, gettext(ERR_LOCATION),
				    *drvelf_desc, drv_path);
				return (ERROR);
			}
		} else {
			token = strtok((char *)NULL, DIR_SEP);
		}
	}
	return (ERROR);
}

/*
 * Creates a two-element linked list of isa-specific subdirectories to
 * search for each driver, which is is used by the function
 * module_not_found() to convert the isa-independent modpath into an
 * isa-specific path .  The list is ordered depending on the machine
 * architecture and instruction set architecture, corresponding to the
 * order in which module_not_found() will search for the driver.  This
 * routine relies on an architecture not having more than two
 * sub-architectures (e.g., sparc/sparcv9 or i386/amd64).
 */
int
isaspec_drvmod_discovery()
{
	char arch[SYS_NMLN];

	moddir = (struct drvmod_dir *)calloc(1, sizeof (struct drvmod_dir));
	if (moddir == NULL) {
		(void) fprintf(stderr, gettext(ERR_NO_MEM));
		return (ERROR);
	}

	if (sysinfo(SI_ARCHITECTURE, arch, sizeof (arch)) == -1) {
		(void) fprintf(stderr, gettext(ERR_SYSINFO_ARCH));
		return (ERROR);
	}

	if (strcmp(arch, "sparc") == 0 || strcmp(arch, "i386") == 0) {
		moddir->next = (struct drvmod_dir *)
		    calloc(1, sizeof (struct drvmod_dir));
		if (moddir->next == NULL) {
			(void) fprintf(stderr, gettext(ERR_NO_MEM));
			return (ERROR);
		}
		if (kelf_type == ELFCLASS64) {
			(void) strcpy(moddir->direc, DRVDIR64);
			(void) strcpy(moddir->next->direc, "");
		} else {
			(void) strcpy(moddir->direc, "");
			(void) strcpy(moddir->next->direc, DRVDIR64);
		}
		moddir->next->next = NULL;
		return (NOERR);
	} else {
		(void) fprintf(stderr, gettext(ERR_ARCH_NOT_SUPPORTED), arch);
		return (ERROR);
	}
}

void
remove_slashes(char *path)
{
	char *slash = path;
	char *remain_str;
	int pathlen;

	while ((slash = strchr(slash, '/')) != NULL) {
		remain_str = ++slash;
		while (*remain_str == '/')
			++remain_str;
		if (slash != remain_str)
			(void) strcpy(slash, remain_str);
	}

	pathlen = strlen(path);
	if ((pathlen > 1) && path[pathlen - 1] == '/')
		path[pathlen - 1] = '\0';
}

/*
 * This is for ITU floppies to add packages to the miniroot
 */
static int
ignore_root_basedir(void)
{
	struct stat statbuf;

	return (stat("/ADD_DRV_IGNORE_ROOT_BASEDIR", &statbuf) == 0);
}