RepoMirrors/crash
1
0
Fork 0
mirror of https://github.com/crash-utility/crash synced 2024-12-13 12:44:34 +00:00
Code Issues Packages Projects Releases Wiki Activity
005eb9e502
crash/extensions.c
Dave Anderson 03e3937ec7 Initial commit: crash-7.0.4
2014-01-28 16:46:11 -05:00

560 lines
13 KiB
C
Raw Blame History

/* extensions.c - core analysis suite
*
* Copyright (C) 2001, 2002 Mission Critical Linux, Inc.
* Copyright (C) 2002-2013 David Anderson
* Copyright (C) 2002-2013 Red Hat, Inc. All rights reserved.
*
* 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.
*/
#include "defs.h"
#include <dlfcn.h>
static int in_extensions_library(char *, char *);
static char *get_extensions_directory(char *);
#define DUMP_EXTENSIONS (0)
#define LOAD_EXTENSION (1)
#define UNLOAD_EXTENSION (2)
/*
* Load, unload, or list the extension libaries.
*/
void
cmd_extend(void)
{
int c;
int flag;
flag = DUMP_EXTENSIONS;
while ((c = getopt(argcnt, args, "lu")) != EOF) {
switch(c)
{
case 'l':
if (flag & UNLOAD_EXTENSION) {
error(INFO,
"-l and -u are mutually exclusive\n");
argerrs++;
} else
flag |= LOAD_EXTENSION;
break;
case 'u':
if (flag & LOAD_EXTENSION) {
error(INFO,
"-u and -l are mutually exclusive\n");
argerrs++;
} else
flag |= UNLOAD_EXTENSION;
break;
default:
argerrs++;
break;
}
}
if (argerrs)
cmd_usage(pc->curcmd, SYNOPSIS);
switch (flag)
{
case DUMP_EXTENSIONS:
if (!args[optind]) {
dump_extension_table(!VERBOSE);
return;
}
/* FALLTHROUGH */
case LOAD_EXTENSION:
if (!args[optind]) {
error(INFO,
"-l requires one or more extension library arguments\n");
cmd_usage(pc->curcmd, SYNOPSIS);
break;
}
while (args[optind]) {
load_extension(args[optind]);
optind++;
}
break;
case UNLOAD_EXTENSION:
if (!args[optind]) {
unload_extension(NULL);
break;
}
while (args[optind]) {
unload_extension(args[optind]);
optind++;
}
break;
}
}
/*
* List all extension libaries and their commands in either the extend
* command format or for "help -e" (verbose).
*/
void
dump_extension_table(int verbose)
{
int i;
struct extension_table *ext;
struct command_table_entry *cp;
char buf[BUFSIZE];
int longest, others;
if (!extension_table)
return;
if (verbose) {
for (ext = extension_table; ext; ext = ext->next) {
fprintf(fp, " filename: %s\n", ext->filename);
fprintf(fp, " handle: %lx\n", (ulong)ext->handle);
fprintf(fp, " flags: %lx (", ext->flags);
others = 0;
if (ext->flags & REGISTERED)
fprintf(fp, "%sREGISTERED", others++ ?
"|" : "");
fprintf(fp, ")\n");
fprintf(fp, " next: %lx\n", (ulong)ext->next);
fprintf(fp, " prev: %lx\n", (ulong)ext->prev);
for (i = 0, cp = ext->command_table; cp->name; cp++, i++) {
fprintf(fp, "command_table[%d]: %lx\n", i, (ulong)cp);
fprintf(fp, " name: %s\n", cp->name);
fprintf(fp, " func: %lx\n", (ulong)cp->func);
fprintf(fp, " help_data: %lx\n", (ulong)cp->help_data);
fprintf(fp, " flags: %lx (", cp->flags);
others = 0;
if (cp->flags & CLEANUP)
fprintf(fp, "%sCLEANUP", others++ ? "|" : "");
if (cp->flags & REFRESH_TASK_TABLE)
fprintf(fp, "%sREFRESH_TASK_TABLE", others++ ? "|" : "");
if (cp->flags & HIDDEN_COMMAND)
fprintf(fp, "%sHIDDEN_COMMAND", others++ ? "|" : "");
fprintf(fp, ")\n");
}
if (ext->next)
fprintf(fp, "\n");
}
return;
}
/*
* Print them out in the order they were loaded.
*/
for (longest = 0, ext = extension_table; ext; ext = ext->next) {
if (strlen(ext->filename) > longest)
longest = strlen(ext->filename);
}
fprintf(fp, "%s COMMANDS\n",
mkstring(buf, longest, LJUST, "SHARED OBJECT"));
longest = MAX(longest, strlen("SHARED OBJECT"));
for (ext = extension_table; ext; ext = ext->next)
if (ext->next == NULL)
break;
do {
fprintf(fp, "%s ",
mkstring(buf, longest, LJUST, ext->filename));
for (cp = ext->command_table; cp->name; cp++)
fprintf(fp, "%s ", cp->name);
fprintf(fp, "\n");
} while ((ext = ext->prev));
}
/*
* Load an extension library.
*/
void
load_extension(char *lib)
{
struct extension_table *ext, *curext;
char buf[BUFSIZE];
size_t size;
char *env;
int env_len;
if ((env = getenv("CRASH_EXTENSIONS")))
env_len = strlen(env)+1;
else
env_len = 0;
size = sizeof(struct extension_table) + strlen(lib) +
MAX(env_len, strlen("/usr/lib64/crash/extensions/")) + 1;
if ((ext = (struct extension_table *)malloc(size)) == NULL)
error(FATAL, "cannot malloc extension_table space.");
BZERO(ext, size);
ext->filename = (char *)((ulong)ext + sizeof(struct extension_table));
/*
* If the library is not specified by an absolute pathname, dlopen()
* does not look in the current directory, so modify the filename.
* If it's not in the current directory, check the extensions library
* directory.
*/
if ((*lib != '.') && (*lib != '/')) {
if (file_exists(lib, NULL))
sprintf(ext->filename, "./%s", lib);
else if (in_extensions_library(lib, buf))
strcpy(ext->filename, buf);
else {
error(INFO, "%s: %s\n", lib, strerror(ENXIO));
free(ext);
return;
}
} else
strcpy(ext->filename, lib);
if (!is_shared_object(ext->filename)) {
error(INFO, "%s: not an ELF format object file\n",
ext->filename);
free(ext);
return;
}
for (curext = extension_table; curext; curext = curext->next) {
if (same_file(curext->filename, ext->filename)) {
fprintf(fp, "%s: shared object already loaded\n",
ext->filename);
free(ext);
return;
}
}
/*
* register_extension() will be called by the shared object's
* _init() function before dlopen() returns below.
*/
pc->curext = ext;
ext->handle = dlopen(ext->filename, RTLD_NOW|RTLD_GLOBAL);
if (!ext->handle) {
strcpy(buf, dlerror());
error(INFO, "%s\n", buf);
if (strstr(buf, "undefined symbol: register_extension")) {
error(INFO, "%s may be statically linked: ",
pc->program_name);
fprintf(fp, "recompile without the -static flag\n");
}
free(ext);
return;
}
if (!(ext->flags & REGISTERED)) {
dlclose(ext->handle);
if (ext->flags & (DUPLICATE_COMMAND_NAME | NO_MINIMAL_COMMANDS))
error(INFO,
"%s: shared object unloaded\n", ext->filename);
else
error(INFO,
"%s: no commands registered: shared object unloaded\n",
ext->filename);
free(ext);
return;
}
fprintf(fp, "%s: shared object loaded\n", ext->filename);
/*
* Put new libraries at the head of the list.
*/
if (extension_table) {
extension_table->prev = ext;
ext->next = extension_table;
}
extension_table = ext;
help_init();
}
/*
* Check the extensions library directories.
*/
static int
in_extensions_library(char *lib, char *buf)
{
char *env;
if ((env = getenv("CRASH_EXTENSIONS"))) {
sprintf(buf, "%s%s%s", env,
LASTCHAR(env) == '/' ? "" : "/",
lib);
if (file_exists(buf, NULL))
return TRUE;
}
if (BITS64()) {
sprintf(buf, "/usr/lib64/crash/extensions/%s", lib);
if (file_exists(buf, NULL))
return TRUE;
}
sprintf(buf, "/usr/lib/crash/extensions/%s", lib);
if (file_exists(buf, NULL))
return TRUE;
sprintf(buf, "./extensions/%s", lib);
if (file_exists(buf, NULL))
return TRUE;
return FALSE;
}
/*
* Look for an extensions directory using the proper order.
*/
static char *
get_extensions_directory(char *dirbuf)
{
char *env;
if ((env = getenv("CRASH_EXTENSIONS"))) {
if (is_directory(env)) {
strcpy(dirbuf, env);
return dirbuf;
}
}
if (BITS64()) {
sprintf(dirbuf, "/usr/lib64/crash/extensions");
if (is_directory(dirbuf))
return dirbuf;
}
sprintf(dirbuf, "/usr/lib/crash/extensions");
if (is_directory(dirbuf))
return dirbuf;
sprintf(dirbuf, "./extensions");
if (is_directory(dirbuf))
return dirbuf;
return NULL;
}
void
preload_extensions(void)
{
DIR *dirp;
struct dirent *dp;
char dirbuf[BUFSIZE];
char filename[BUFSIZE];
int found;
if (!get_extensions_directory(dirbuf))
return;
dirp = opendir(dirbuf);
if (!dirp) {
error(INFO, "%s: %s\n", dirbuf, strerror(errno));
return;
}
pc->curcmd = pc->program_name;
for (found = 0, dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
sprintf(filename, "%s%s%s", dirbuf,
LASTCHAR(dirbuf) == '/' ? "" : "/",
dp->d_name);
if (!is_shared_object(filename))
continue;
found++;
load_extension(dp->d_name);
}
closedir(dirp);
if (found)
fprintf(fp, "\n");
else
error(NOTE,
"%s: no extension modules found in directory\n\n",
dirbuf);
}
/*
* Unload all, or as specified, extension libraries.
*/
void
unload_extension(char *lib)
{
struct extension_table *ext;
int found;
char buf[BUFSIZE];
if (!lib) {
while (extension_table) {
ext = extension_table;
if (dlclose(ext->handle))
error(FATAL,
"dlclose: %s: shared object not open\n",
ext->filename);
fprintf(fp, "%s: shared object unloaded\n",
ext->filename);
extension_table = ext->next;
free(ext);
}
help_init();
return;
}
if ((*lib != '.') && (*lib != '/')) {
if (!file_exists(lib, NULL) &&
in_extensions_library(lib, buf))
lib = buf;
}
if (!file_exists(lib, NULL)) {
error(INFO, "%s: %s\n", lib, strerror(ENXIO));
return;
}
for (ext = extension_table, found = FALSE; ext; ext = ext->next) {
if (same_file(lib, ext->filename)) {
found = TRUE;
if (dlclose(ext->handle))
error(INFO,
"dlclose: %s: shared object not open\n",
ext->filename);
else {
fprintf(fp, "%s: shared object unloaded\n",
ext->filename);
if (extension_table == ext) { /* first */
extension_table = ext->next;
if (ext->next)
ext->next->prev = NULL;
} else if (ext->next == NULL) /* last */
ext->prev->next = NULL;
else { /* middle */
ext->prev->next = ext->next;
ext->next->prev = ext->prev;
}
free(ext);
help_init();
break;
}
}
else if (STREQ(basename(lib), basename(ext->filename))) {
error(INFO, "%s and %s are different object files\n",
lib, ext->filename);
found = TRUE;
}
}
if (!found)
error(INFO, "%s: not loaded\n", lib);
}
/*
* Register the command_table as long as there are no command namespace
* clashes with the currently-existing command set. Also delete any aliases
* that clash, giving the registered command name priority.
*
* This function is called from the shared object's _init() function
* before the dlopen() call returns back to load_extension() above.
* The mark of approval for load_extension() is the setting of the
* REGISTERED bit in the "current" extension_table structure flags.
*/
void
register_extension(struct command_table_entry *command_table)
{
struct command_table_entry *cp;
pc->curext->flags |= NO_MINIMAL_COMMANDS;
for (cp = command_table; cp->name; cp++) {
if (get_command_table_entry(cp->name)) {
error(INFO,
"%s: \"%s\" is a duplicate of a currently-existing command\n",
pc->curext->filename, cp->name);
pc->curext->flags |= DUPLICATE_COMMAND_NAME;
return;
}
if (cp->flags & MINIMAL)
pc->curext->flags &= ~NO_MINIMAL_COMMANDS;
}
if ((pc->flags & MINIMAL_MODE) && (pc->curext->flags & NO_MINIMAL_COMMANDS)) {
error(INFO,
"%s: does not contain any commands which support minimal mode\n",
pc->curext->filename);
return;
}
if (pc->flags & MINIMAL_MODE) {
for (cp = command_table; cp->name; cp++) {
if (!(cp->flags & MINIMAL)) {
error(WARNING,
"%s: command \"%s\" does not support minimal mode\n",
pc->curext->filename, cp->name);
}
}
}
for (cp = command_table; cp->name; cp++) {
if (is_alias(cp->name)) {
error(INFO,
"alias \"%s\" deleted: name clash with extension command\n",
cp->name);
deallocate_alias(cp->name);
}
}
pc->curext->command_table = command_table;
pc->curext->flags |= REGISTERED; /* Mark of approval */
}
/*
* Hooks for sial.
*/
unsigned long
get_curtask(void)
{
return CURRENT_TASK();
}
char *
crash_global_cmd(void)
{
return pc->curcmd;
}
struct command_table_entry *
crash_cmd_table(void)
{
return pc->cmd_table;
}
Reference in New Issue View Git Blame Copy Permalink