freebsd-src/sys/boot/common/module.c
Daniel C. Sobral 08c9325cb2 Fix a number of memory leaks and other memory-related disorders.
Also, unbreak the breakage introduced at the last revision of module.c.
This changes the semantics of mod_searchfile() (and mod_searchmodule())
to make the caller's responsibility freeing the buffer returned. This
is different from other functions in loader's code, and was done as a
fix for kern/9631. If someone wants to revert this to the original
behavior, don't forget to fix kern/9631 in another way.

This should also fix bin/10462, which was introduced as a result of the
first try at kern/9631 (module.c last revision).

PR:		bin/10462
Submitted by:	Takanori Saneto <sanewo@ba2.so-net.ne.jp>
1999-03-08 10:32:39 +00:00

574 lines
14 KiB
C

/*-
* Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id: module.c,v 1.8 1999/02/22 13:12:37 dcs Exp $
*/
/*
* module function dispatcher, support, etc.
*/
#include <stand.h>
#include <string.h>
#include <sys/param.h>
#include <sys/linker.h>
#include "bootstrap.h"
static struct loaded_module *mod_loadmodule(char *name, int argc, char *argv[]);
static char *mod_searchdep(struct loaded_module *mp);
static char *mod_searchfile(char *name);
static char *mod_searchmodule(char *name);
static void mod_append(struct loaded_module *mp);
/* load address should be tweaked by first module loaded (kernel) */
static vm_offset_t loadaddr = 0;
static char *default_searchpath ="/;/boot;/modules";
struct loaded_module *loaded_modules = NULL;
/*
* load an object, either a disk file or code module.
*
* To load a file, the syntax is:
*
* load -t <type> <path>
*
* code modules are loaded as:
*
* load <path> <options>
*/
COMMAND_SET(load, "load", "load a kernel or module", command_load);
static int
command_load(int argc, char *argv[])
{
char *typestr;
int dofile, ch;
dofile = 0;
optind = 1;
optreset = 1;
typestr = NULL;
while ((ch = getopt(argc, argv, "t:")) != -1) {
switch(ch) {
case 't':
typestr = optarg;
dofile = 1;
break;
case '?':
default:
/* getopt has already reported an error */
return(CMD_OK);
}
}
argv += (optind - 1);
argc -= (optind - 1);
/*
* Request to load a raw file?
*/
if (dofile) {
if ((typestr == NULL) || (*typestr == 0)) {
command_errmsg = "invalid load type";
return(CMD_ERROR);
}
return(mod_loadobj(typestr, argv[1]));
}
/*
* Looks like a request for a module.
*/
return(mod_load(argv[1], argc - 2, argv + 2));
}
COMMAND_SET(unload, "unload", "unload all modules", command_unload);
static int
command_unload(int argc, char *argv[])
{
struct loaded_module *mp;
while (loaded_modules != NULL) {
mp = loaded_modules;
loaded_modules = loaded_modules->m_next;
mod_discard(mp);
}
loadaddr = 0;
return(CMD_OK);
}
COMMAND_SET(lsmod, "lsmod", "list loaded modules", command_lsmod);
static int
command_lsmod(int argc, char *argv[])
{
struct loaded_module *am;
struct module_metadata *md;
char lbuf[80];
int ch, verbose;
verbose = 0;
optind = 1;
optreset = 1;
while ((ch = getopt(argc, argv, "v")) != -1) {
switch(ch) {
case 'v':
verbose = 1;
break;
case '?':
default:
/* getopt has already reported an error */
return(CMD_OK);
}
}
pager_open();
for (am = loaded_modules; (am != NULL); am = am->m_next) {
sprintf(lbuf, " %p: %s (%s, 0x%lx)\n",
(void *) am->m_addr, am->m_name, am->m_type, (long) am->m_size);
pager_output(lbuf);
if (am->m_args != NULL) {
pager_output(" args: ");
pager_output(am->m_args);
pager_output("\n");
}
if (verbose)
/* XXX could add some formatting smarts here to display some better */
for (md = am->m_metadata; md != NULL; md = md->md_next) {
sprintf(lbuf, " 0x%04x, 0x%lx\n", md->md_type, (long) md->md_size);
pager_output(lbuf);
}
}
pager_close();
return(CMD_OK);
}
/*
* We've been asked to load (name) and give it (argc),(argv).
* Start by trying to load it, and then attempt to load all of its
* dependancies. If we fail at any point, throw them all away and
* fail the entire load.
*
* XXX if a depended-on module requires arguments, it must be loaded
* explicitly first.
*/
int
mod_load(char *name, int argc, char *argv[])
{
struct loaded_module *last_mod, *base_mod, *mp;
char *dep_name;
/* remember previous last module on chain */
for (last_mod = loaded_modules;
(last_mod != NULL) && (last_mod->m_next != NULL);
last_mod = last_mod->m_next)
;
/*
* Load the first module; note that it's the only one that gets
* arguments explicitly.
*/
if ((base_mod = mod_loadmodule(name, argc, argv)) == NULL)
return(CMD_ERROR);
/*
* Look for dependancies.
*/
while ((dep_name = mod_searchdep(base_mod)) != NULL) {
printf("loading required module '%s'\n", dep_name);
if ((mp = mod_loadmodule(dep_name, 0, NULL)) == NULL) {
/* Load failed; discard everything */
while (base_mod != NULL) {
mp = base_mod;
base_mod = base_mod->m_next;
mod_discard(mp);
}
last_mod->m_next = NULL;
loadaddr = last_mod->m_addr + last_mod->m_size;
/* error message already set by mod_loadmodule */
return(CMD_ERROR);
}
}
return(CMD_OK);
}
/*
* We've been asked to load (name) as (type), so just suck it in,
* no arguments or anything.
*/
int
mod_loadobj(char *type, char *name)
{
struct loaded_module *mp;
char *cp;
int fd, got;
vm_offset_t laddr;
/* We can't load first */
if ((mod_findmodule(NULL, NULL)) == NULL) {
command_errmsg = "can't load file before kernel";
return(CMD_ERROR);
}
/* locate the file on the load path */
cp = mod_searchfile(name);
if (cp == NULL) {
sprintf(command_errbuf, "can't find '%s'", name);
return(CMD_ERROR);
}
name = cp;
if ((fd = open(name, O_RDONLY)) < 0) {
sprintf(command_errbuf, "can't open '%s': %s", name, strerror(errno));
free(name);
return(CMD_ERROR);
}
laddr = loadaddr;
for (;;) {
/* read in 4k chunks; size is not really important */
got = archsw.arch_readin(fd, laddr, 4096);
if (got == 0) /* end of file */
break;
if (got < 0) { /* error */
sprintf(command_errbuf, "error reading '%s': %s", name, strerror(errno));
free(name);
return(CMD_ERROR);
}
laddr += got;
}
/* Looks OK so far; create & populate control structure */
mp = malloc(sizeof(struct loaded_module));
mp->m_name = name;
mp->m_type = strdup(type);
mp->m_args = NULL;
mp->m_metadata = NULL;
mp->m_loader = -1;
mp->m_addr = loadaddr;
mp->m_size = laddr - loadaddr;
/* recognise space consumption */
loadaddr = laddr;
/* Add to the list of loaded modules */
mod_append(mp);
return(CMD_OK);
}
/*
* Load the module (name), pass it (argc),(argv).
* Don't do any dependancy checking.
*/
static struct loaded_module *
mod_loadmodule(char *name, int argc, char *argv[])
{
struct loaded_module *mp;
int i, err;
char *cp;
/* locate the module on the search path */
cp = mod_searchmodule(name);
if (cp == NULL) {
sprintf(command_errbuf, "can't find '%s'", name);
return(NULL);
}
name = cp;
err = 0;
for (i = 0, mp = NULL; (module_formats[i] != NULL) && (mp == NULL); i++) {
if ((err = (module_formats[i]->l_load)(name, loadaddr, &mp)) != 0) {
/* Unknown to this handler? */
if (err == EFTYPE)
continue;
/* Fatal error */
sprintf(command_errbuf, "can't load module '%s': %s", name, strerror(err));
free(name);
return(NULL);
} else {
/* Load was OK, set args */
mp->m_args = unargv(argc, argv);
/* where can we put the next one? */
loadaddr = mp->m_addr + mp->m_size;
/* remember the loader */
mp->m_loader = i;
/* Add to the list of loaded modules */
mod_append(mp);
break;
}
}
if (err == EFTYPE)
sprintf(command_errbuf, "don't know how to load module '%s'", name);
free(name);
return(mp);
}
/*
* Search the modules from (mp) onwards, and return the name of the
* first unresolved dependancy, or NULL if none were found.
*/
static char *
mod_searchdep(struct loaded_module *mp)
{
char *deps;
size_t deplen;
struct module_metadata *md;
struct loaded_module *dmp;
int dindex;
for (; mp != NULL; mp = mp->m_next) {
/*
* Get KLD module data
*/
deps = NULL;
deplen = 0;
if ((md = mod_findmetadata(mp, MODINFOMD_DEPLIST)) != NULL) {
deps = (char *)md->md_data;
deplen = md->md_size;
}
if (deps != NULL && deplen > 0) {
/* Iterate over dependancies */
dindex = 0;
while (dindex < deplen) {
/*
* Look for a module matching the dependancy; if we don't have it,
* we need it.
*/
if ((dmp = mod_findmodule(&deps[dindex], NULL)) == NULL)
return(&deps[dindex]);
dindex += strlen(&deps[dindex]) + 1;
}
}
}
return(NULL);
}
/*
* Find a module matching (name) and (type).
* NULL may be passed as a wildcard to either.
*/
struct loaded_module *
mod_findmodule(char *name, char *type)
{
struct loaded_module *mp;
for (mp = loaded_modules; mp != NULL; mp = mp->m_next) {
if (((name == NULL) || !strcmp(name, mp->m_name)) &&
((type == NULL) || !strcmp(type, mp->m_type)))
break;
}
return(mp);
}
/*
* Make a copy of (size) bytes of data from (p), and associate them as
* metadata of (type) to the module (mp).
*/
void
mod_addmetadata(struct loaded_module *mp, int type, size_t size, void *p)
{
struct module_metadata *md;
md = malloc(sizeof(struct module_metadata) + size);
md->md_size = size;
md->md_type = type;
bcopy(p, md->md_data, size);
md->md_next = mp->m_metadata;
mp->m_metadata = md;
}
/*
* Find a metadata object of (type) associated with the module
* (mp)
*/
struct module_metadata *
mod_findmetadata(struct loaded_module *mp, int type)
{
struct module_metadata *md;
for (md = mp->m_metadata; md != NULL; md = md->md_next)
if (md->md_type == type)
break;
return(md);
}
/*
* Attempt to find the file (name) on the module searchpath.
* If (name) is qualified in any way, we simply check it and
* return it or NULL. If it is not qualified, then we attempt
* to construct a path using entries in the environment variable
* module_path.
*
* The path we return a pointer to need never be freed, as we manage
* it internally.
*/
static char *
mod_searchfile(char *name)
{
char *result;
char *path, *sp;
const char *cp;
struct stat sb;
/* Don't look for nothing */
if (name == NULL)
return(name);
if (*name == 0)
return(strdup(name));
/*
* See if there's a device on the front, or a directory name.
*/
archsw.arch_getdev(NULL, name, &cp);
if ((cp != name) || (strchr(name, '/') != NULL)) {
/* Qualified, so just see if it exists */
if (stat(name, &sb) == 0)
return(strdup(name));
return(NULL);
}
/*
* Get the module path
*/
if ((cp = getenv("module_path")) == NULL)
cp = default_searchpath;
sp = path = strdup(cp);
/*
* Traverse the path, splitting off ';'-delimited components.
*/
result = NULL;
while((cp = strsep(&path, ";")) != NULL) {
result = malloc(strlen(cp) + strlen(name) + 5);
strcpy(result, cp);
if (cp[strlen(cp) - 1] != '/')
strcat(result, "/");
strcat(result, name);
/* printf("search '%s'\n", result); */
if ((stat(result, &sb) == 0) &&
S_ISREG(sb.st_mode))
break;
free(result);
result = NULL;
}
free(sp);
return(result);
}
/*
* Attempt to locate the file containing the module (name)
*/
static char *
mod_searchmodule(char *name)
{
char *tn, *result;
/* Look for (name).ko */
tn = malloc(strlen(name) + 3 + 1);
strcpy(tn, name);
strcat(tn, ".ko");
result = mod_searchfile(tn);
free(tn);
/* Look for just (name) (useful for finding kernels) */
if (result == NULL)
result = mod_searchfile(name);
return(result);
}
/*
* Throw a module away
*/
void
mod_discard(struct loaded_module *mp)
{
struct module_metadata *md;
if (mp != NULL) {
while (mp->m_metadata != NULL) {
md = mp->m_metadata;
mp->m_metadata = mp->m_metadata->md_next;
free(md);
}
if (mp->m_name != NULL)
free(mp->m_name);
if (mp->m_type != NULL)
free(mp->m_type);
if (mp->m_args != NULL)
free(mp->m_args);
free(mp);
}
}
/*
* Allocate a new module; must be used instead of malloc()
* to ensure safe initialisation.
*/
struct loaded_module *
mod_allocmodule(void)
{
struct loaded_module *mp;
if ((mp = malloc(sizeof(struct loaded_module))) != NULL) {
bzero(mp, sizeof(struct loaded_module));
}
return(mp);
}
/*
* Add a module to the chain
*/
static void
mod_append(struct loaded_module *mp)
{
struct loaded_module *cm;
/* Append to list of loaded modules */
mp->m_next = NULL;
if (loaded_modules == NULL) {
loaded_modules = mp;
} else {
for (cm = loaded_modules; cm->m_next != NULL; cm = cm->m_next)
;
cm->m_next = mp;
}
}