arti/irix-657m-src
1
0
Fork 0
Code Activity
Files
8fc8fa80899c66937979cd5b807766a40b74cd13
irix-657m-src/eoe/cmd/ml/ml.c
calmsacibis995 8fc8fa8089 Source code upload
2022-09-29 17:59:04 +03:00

1120 lines
24 KiB
C
Raw Blame History

#include <getopt.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <syslog.h>
#include <malloc.h>
#include <stdlib.h>
#include <bstring.h>
#include <sys/types.h>
#include <sys/fcntl.h>
#include <sys/syssgi.h>
#include <sys/param.h>
#include <sys/conf.h>
#include <sys/fstyp.h>
#include <sys/mload.h>
/*
* ml - module loader
*/
/*
* load, unload, register, unregister
* [ld, unld, reg, unreg]
*/
static int mlist(int, char **);
static int mload(int, char **);
static int munload(int, char **);
static int mreg(int, char **);
static int munreg(int, char **);
static int mdebug(int, char **);
static void musage(void);
static void mlistusage(void);
static void mldregusage(void);
static void mldusage(void);
static void mregusage(void);
static void munldregusage(void);
static void mdebugusage(void);
struct acttab {
char *name;
int nlen;
int (*func)(int, char **);
void (*usage)(void);
} act[] = {
{"list", 4, mlist, mlistusage},
{"ld", 2, mload, mldusage},
{"unld", 4, munload, munldregusage},
{"load", 4, mload, 0},
{"unload", 6, munload, 0},
{"reg", 3, mreg, mregusage},
{"unreg", 5, munreg, munldregusage},
{"debug", 5, mdebug, mdebugusage},
};
static int loadmodule(int, int, char *, char *, void *, int, int);
static int unloadmodule(int, long);
static void prmodule(mod_info_t *);
static char *ml_err(int);
#ifdef DEBUG
static int prinfo(int, char *, char *, int);
#endif
#define DPRINTF printf
char *cmdname, *actname;
#define uprintf(x) fprintf(stderr, "usage: %s %s %s\n", cmdname, actname, x);
int majors[DRV_MAXMAJORS];
int nmajors = 0;
int
main(int argc, char **argv)
{
int i, rv;
if (syssgi (SGI_MCONFIG, CF_LIST, 0) < 0) {
fprintf (stderr, "Module loader not enabled.\n");
exit (-1);
}
if (argc == 1) {
mlist(--argc, ++argv);
exit(0);
}
opterr = 0;
cmdname = *argv;
--argc;
++argv;
for (i = 0; i < sizeof(act)/sizeof(struct acttab); i++)
if (!strncmp (*argv, act[i].name, act[i].nlen)) {
actname = act[i].name;
rv = (*act[i].func)(argc, argv);
exit(rv);
}
musage();
return -1;
}
void
musage(void)
{
int i;
for (i = 0; i < sizeof(act)/sizeof(struct acttab); i++) {
actname = act[i].name;
if (*act[i].usage)
(*act[i].usage)();
}
}
/************************************************************************
*
* debug
*
*/
static void
mdebugusage(void)
{
uprintf ("[-s|v|n]");
}
int
mdebug(int argc, char **argv)
{
int i, num = 0;
if (getuid() != 0 && geteuid() != 0) {
fprintf (stderr, "Sorry, must be superuser to run %s %s.\n",
cmdname, actname);
return -1;
}
if (argc != 2) {
mdebugusage();
return -1;
} else while ((i = getopt(argc, argv, "svn")) != GETOPTDONE) {
switch (i) {
case 's': num = 0; break; /* silent */
case 'v': num = 1; break; /* verbose */
case 'n': num = 0xdead; break; /* no loading allowed */
case '?':
default: mlistusage(); return -1;
}
}
syssgi (SGI_MCONFIG, CF_DEBUG, num);
return 0;
}
/************************************************************************
*
* list
*
*/
static void
mlistusage(void)
{
uprintf ("[-r|l|b]");
}
int
mlist(int argc, char **argv)
{
int size, i, modcnt;
mod_info_t *mod, *modspc;
int reg = 0, load = 0, both = 0;
if (!argc || argc == 1)
reg = load = both = 1;
else while ((i = getopt(argc, argv, "rlb")) != GETOPTDONE) {
switch (i) {
case 'r': reg = 1; break;
case 'l': load = 1; break;
case 'b': both = 1; break;
case '?': mlistusage(); return -1;
}
}
if (!(size = (int)syssgi (SGI_MCONFIG, CF_LIST, 0))) {
printf ("No modules loaded or registered.\n");
return -1;
}
modspc = (mod_info_t *)malloc(size);
if (!modspc) {
printf ("No memory for module list.\n");
return -1;
}
if (syssgi (SGI_MCONFIG, CF_LIST, modspc, size) != size) {
printf ("Error copying module list.\n");
return -1;
}
if (modspc->m_cfg_version != M_CFG_CURRENT_VERSION) {
printf ("Version mismatch with kernel\n");
return -1;
}
if (load) {
printf ("\nLoaded Modules:\n");
modcnt = 0;
for (mod = modspc, i = 0; i < size/sizeof(mod_info_t); ++i, ++mod) {
if ((mod->m_flags & (M_REGISTERED|M_LOADED)) != M_LOADED)
continue;
modcnt++;
prmodule(mod);
}
if (!modcnt)
printf ("None.\n");
printf ("\n");
}
if (reg) {
printf ("\nRegistered Modules:\n");
modcnt = 0;
for (mod = modspc, i = 0; i < size/sizeof(mod_info_t); ++i, ++mod) {
if ((mod->m_flags & (M_REGISTERED|M_LOADED)) != M_REGISTERED)
continue;
modcnt++;
prmodule(mod);
}
if (!modcnt)
printf ("None.\n");
printf ("\n");
}
if (both) {
printf ("\nRegistered and Currently Loaded Modules:\n");
modcnt = 0;
for (mod = modspc, i = 0; i < size/sizeof(mod_info_t); ++i, ++mod) {
if ((mod->m_flags & (M_REGISTERED|M_LOADED))
!= (M_REGISTERED|M_LOADED))
continue;
modcnt++;
prmodule(mod);
}
if (!modcnt)
printf ("None.\n");
}
return 0;
}
/************************************************************************
*
* load/register
*
*/
static void
mldusage(void)
{
uprintf ("[-v] [-d] -[c|b|B|f] modulename -p prefix [-s majornumber majornumber ...] -t autounload_delay");
uprintf ("[-v] [-d] -m modulename -p prefix [-a streams_module_name] -t autounload_delay");
uprintf ("[-v] [-d] -j modulename -p prefix [-a file_system_name]");
uprintf ("[-v] [-d] -l libname");
uprintf ("[-v] -r rtsymtabname [-u] [-t autounload_delay]");
uprintf ("[-v] [-d] -i idbgname -p prefix");
}
static void
mregusage(void)
{
uprintf ("[-v] [-d] -[c|b|B|f] modulename -p prefix [-s majornumber majornumber ...] -t autounload_delay");
uprintf ("[-v] [-d] -m modulename -p prefix [-a streams_module_name] -t autounload_delay");
}
static void
mldregusage(void)
{
mldusage(); mregusage();
}
static int
mloadreg(int command, int argc, char **argv)
{
int c;
char *fname = 0, *prefix = 0, *fmname = 0;
int chardev=0, blockdev=0, fundrv=0, funmod=0, fsys=0, enet=0, other=0, bothdev=0;
int timeout=M_UNLDDEFAULT;
int idbgmod=0;
int libmod=0;
int symtabmod=0;
int devflag, type, id;
int verbose = 0;
int symdebug = 0;
int nmajorany = 0;
int unixsymtab = 0;
int i;
mod_streams_t str;
mod_driver_t drv;
mod_idbg_t idbg;
mod_lib_t lib;
mod_symtab_t symtab;
mod_fsys_t fs;
mod_enet_t e;
void *mdata;
if (getuid() != 0 && geteuid() != 0) {
fprintf (stderr, "Sorry, must be superuser to run %s %s.\n",
cmdname, actname);
return -1;
}
while ((c = getopt(argc, argv, "uvdp:s:n:a:c:b:B:f:m:j:e:o:i:l:t:r:")) != GETOPTDONE) {
switch (c) {
case 'c': chardev = 1; fname = optarg; break;
case 'b': bothdev = 1; fname = optarg; break;
case 'B': blockdev = 1; fname = optarg; break;
case 'f': fundrv = 1; fname = optarg; break;
case 'm': funmod = 1; fname = optarg; break;
case 'i': idbgmod = 1; fname = optarg; break;
case 'l': libmod = 1; fname = optarg; break;
case 'r': symtabmod = 1; fname = optarg; break;
case 'j': fsys = 1; fname = optarg; break;
case 'e': enet = 1; fname = optarg; break;
case 'o': other = 1; break;
case 'v': verbose = 1; break;
case 'd': symdebug = 1; break;
case 'p': prefix = optarg; break;
case 'u': unixsymtab = 1; break;
case 's':
for (;;) {
majors[nmajors++] = (int)atol(optarg);
if (nmajors > DRV_MAXMAJORS) {
fprintf (stderr,
"Too many major numbers specified.\n");
return -1;
}
if (optind >= argc || *argv[optind] == '-')
break;
optarg = argv[optind++];
}
break;
case 'n':
nmajorany = (int)atol(optarg);
if ((nmajorany + nmajors) > DRV_MAXMAJORS) {
fprintf (stderr, "Too many major numbers specified.\n");
return -1;
}
for (i=0; i < nmajorany; i++) {
majors[nmajors++] = MAJOR_ANY;
}
break;
case 'a': fmname = optarg; break;
case 't': timeout = (int)atol(optarg); break;
case '?': mldregusage(); return -1;
}
}
if (chardev + bothdev + blockdev + fundrv + funmod + fsys +
idbgmod + libmod + symtabmod + enet + other != 1) {
mldregusage();
return -1;
}
if (idbgmod && !prefix) {
mldregusage();
return -1;
}
if (libmod && !prefix)
prefix = "lib";
if (symtabmod && !prefix)
prefix = "symtab";
if (!fname || !prefix) {
mldregusage();
return -1;
}
if (libmod && !fname) {
mldregusage();
return -1;
}
type = M_DRIVER;
if (chardev)
devflag = MDRV_CHAR;
else if (blockdev)
devflag = MDRV_BLOCK;
else if (bothdev)
devflag = MDRV_CHAR|MDRV_BLOCK;
else if (fundrv)
devflag = MDRV_STREAM;
else if (funmod)
type = M_STREAMS;
else if (fsys)
type = M_FILESYS;
else if (enet)
type = M_ENET;
else if (idbgmod)
type = M_IDBG;
else if (libmod)
type = M_LIB;
else if (symtabmod)
type = M_SYMTAB;
else if (other)
type = M_OTHER;
switch (type) {
case M_DRIVER:
drv.d_edtp = 0; /*XXXkevinm*/
drv.d_cpulock = 0; /*XXXkevinm*/
drv.d_type = devflag;
for (i=0; i<nmajors; i++)
drv.d_majors[i] = majors[i];
drv.d_nmajors = nmajors;
mdata = &drv;
break;
case M_STREAMS:
str.s_name[0] = 0;
if (!fmname || !fmname[0]) {
int i;
char *base;
/* Get the fmodsw name from the file name */
if ((base = strrchr(fname, '/')) == NULL)
base = fname;
else
base++;
for (i = 0; i < FMNAMESZ + 1; ++i) {
str.s_name[i] = base[i];
if (!strncmp (&base[i],".o", 2))
str.s_name[i] = '\0';
if (str.s_name[i] == '\0')
break;
}
} else {
strncpy (str.s_name, fmname, FMNAMESZ+1);
}
if (str.s_name[0] == 0) {
mldregusage();
return -1;
}
mdata = &str;
break;
case M_IDBG:
idbg.i_value = 0;
mdata = &idbg;
break;
case M_LIB:
lib.id = 0;
mdata = &lib;
break;
case M_SYMTAB:
symtab.id = 0;
mdata = &symtab;
strcpy (symtab.symtab_name, prefix);
if (unixsymtab || strstr(fname, "unix"))
symtab.type = M_UNIXSYMTAB;
else
symtab.type = 0;
break;
case M_FILESYS:
fs.vsw_name[0] = 0;
if (!fmname || !fmname[0]) {
int i;
char *base;
/* Get the vfssw name from the file name */
if ((base = strrchr(fname, '/')) == NULL)
base = fname;
else
base++;
for (i = 0; i < FSTYPSZ + 1; ++i) {
fs.vsw_name[i] = base[i];
if (!strncmp (&base[i],".o", 2))
fs.vsw_name[i] = '\0';
if (fs.vsw_name[i] == '\0')
break;
}
} else {
strncpy (fs.vsw_name, fmname, FSTYPSZ+1);
}
if (fs.vsw_name[0] == 0) {
mldregusage();
return -1;
}
mdata = &fs;
break;
case M_ENET:
e.id = 0;
e.e_edtp = 0; /* XXX */
mdata = &e;
break;
case M_OTHER:
/*XXXkevinm*/
fprintf (stderr, "Other module type not allowed yet.\n"); return -1;
}
/* Change relative pathnames to absolute
*/
if (*fname != '/') {
char *cwd;
if ((cwd = getcwd((char *)NULL, MAXPATHLEN)) == NULL) {
fprintf (stderr, "Pathname not found.\n");
return -1;
}
if (strlen(cwd) + strlen(fname) + 2 > MAXPATHLEN) {
fprintf (stderr, "Pathname is too long.\n");
return -1;
}
sprintf(cwd + strlen(cwd), "/%s", fname);
fname = cwd;
}
#ifdef DEBUG
prinfo(type, fname, prefix, devflag);
#endif
if ((id = loadmodule (command, type, fname, prefix, mdata, timeout, symdebug)) < 0) {
fprintf (stderr, "Error %s module %s: %s.\n",
command == CF_LOAD ? "loading" : "registering", prefix,
ml_err(errno));
return -1;
} else {
openlog("lboot", LOG_ODELAY, LOG_AUTH);
syslog (LOG_NOTICE, "Module %s dynamically %s.\n",
fname,
((command == CF_LOAD) ? "loaded" : "registered"));
}
if (verbose)
printf ("Module id is %d.\n", id);
return 0;
}
static int
mload(int argc, char **argv)
{
return mloadreg(CF_LOAD, argc, argv);
}
static int
mreg(int argc, char **argv)
{
return mloadreg(CF_REGISTER, argc, argv);
}
/************************************************************************
*
* unload/unregister
*
*/
static void
munldregusage(void)
{
uprintf ("[-v] id [id id ...]");
}
static int
munloadreg(int command, int argc, char **argv)
{
long id;
int errcount = 0;
int verbose = 0;
if (getuid() != 0 && geteuid() != 0) {
fprintf (stderr, "Sorry, must be superuser to run %s %s.\n",
cmdname, actname);
return -1;
}
--argc;
++argv;
if (!argc) {
munldregusage();
return -1;
}
if (!strncmp(*argv, "-v", 2)) {
--argc;
++argv;
verbose = 1;
if (!argc) {
munldregusage();
return -1;
}
}
while (argc--) {
id = (int)atol(*argv++);
if (unloadmodule(command, id) < 0) {
errcount++;
fprintf (stderr, "Error %s module %d: %s.\n",
command == CF_UNLOAD ? "unloading" : "unregistering", id,
ml_err(errno));
} else if (verbose)
printf ("Module %d %s.\n", id,
command == CF_UNLOAD ? "unloaded" : "unregistered");
}
return errcount ? -1 : 0;
}
static int
munload(int argc, char **argv)
{
return munloadreg(CF_UNLOAD, argc, argv);
}
static int
munreg(int argc, char **argv)
{
return munloadreg(CF_UNREGISTER, argc, argv);
}
/************************************************************************
*
* utilities
*
*/
static int
loadmodule(int command, int type, char *fname, char *prefix, void *mdata, int timeout, int symdebug)
{
cfg_desc_t descriptor, *desc = &descriptor;
int rv;
bzero (desc, sizeof(*desc));
desc->m_data = mdata;
desc->m_fname = fname;
desc->m_type = type;
if (command == CF_REGISTER ||
(command == CF_LOAD && type == M_SYMTAB && timeout != M_UNLDDEFAULT))
desc->m_delay = timeout;
else
desc->m_delay = M_NOUNLD;
if (symdebug)
desc->m_flags = M_SYMDEBUG;
else
desc->m_flags = 0;
desc->m_cfg_version = M_CFG_CURRENT_VERSION;
strncpy (desc->m_prefix, prefix, M_PREFIXLEN);
rv = (int)syssgi (SGI_MCONFIG, command, desc);
if (rv)
return -1;
return (int)desc->m_id;
}
static int
unloadmodule(int command, long id)
{
return (int)syssgi (SGI_MCONFIG, command, id);
}
static void
prmodule(mod_info_t *mod)
{
int i;
printf ("Id: %d\t", mod->m_id);
switch (mod->m_type) {
case M_DRIVER:
if (mod->m_driver.d_type == MDRV_CHAR)
printf ("Character ");
else if (mod->m_driver.d_type == MDRV_BLOCK)
printf ("Block ");
else if (mod->m_driver.d_type == (MDRV_BLOCK|MDRV_CHAR))
printf ("Character/Block ");
else if (mod->m_driver.d_type == MDRV_STREAM)
printf ("Streams ");
else
printf ("Unknown ");
printf ("device driver: prefix %s, ", mod->m_prefix);
for (i=0; i<mod->m_driver.d_nmajors; i++)
printf ("major %d, ", mod->m_driver.d_majors[i]);
if (mod->m_delay != M_NOUNLD) {
printf ("unload delay %d minutes, ", mod->m_delay);
} else
printf ("no auto-unload, ");
printf ("filename %s\n", mod->m_fname);
break;
case M_STREAMS:
printf ("Streams module: ");
printf ("prefix %s, fmodsw name %s, ", mod->m_prefix,
mod->m_stream.s_name);
if (mod->m_delay != M_NOUNLD) {
printf ("unload delay %d minutes, ", mod->m_delay);
} else
printf ("no auto-unload, ");
printf ("filename %s\n", mod->m_fname);
break;
case M_IDBG:
printf ("Idbg module: filename %s\n", mod->m_fname);
break;
case M_LIB:
printf ("Library module: filename %s\n", mod->m_fname);
break;
case M_SYMTAB:
printf ("Symbol Table module: ");
if (mod->m_delay != M_NOUNLD) {
printf ("unload delay %d minutes, ", mod->m_delay);
} else
printf ("no auto-unload, ");
printf ("filename %s\n", mod->m_fname);
break;
case M_FILESYS:
printf ("File system: filename %s \n", mod->m_fname);
break;
case M_ENET:
printf ("Ethernet module: ");
printf ("prefix %s, filename %s\n", mod->m_prefix, mod->m_fname);
case M_OTHER:
printf ("Other module\n");
break;
default:
printf ("Unknown module type\n");
break;
}
}
static char *
ml_err(int error)
{
switch (error) {
case EPERM:
return ("Must be super-user to use this command");
case MERR_ENOENT:
return ("No such file or directory");
case MERR_ENAMETOOLONG:
return ("Path name too long");
case MERR_VREG:
return ("File not a regular file");
case EIO:
return ("I/O error");
case ENXIO:
return ("No such device or address");
case MERR_VOP_OPEN:
return ("VOP_OPEN failed");
case MERR_VOP_CLOSE:
return ("VOP_CLOSE failed");
case MERR_COPY:
return ("Copyin/copyout failed");
case MERR_BADMAGIC:
return ("Object file format not ELF");
case MERR_BADFH:
return ("Error reading file header");
case MERR_BADAH:
return ("Error reading a.out header");
case MERR_BADSH:
return ("Error reading section header");
case MERR_BADTEXT:
return ("Error reading text section");
case EBUSY:
return ("Device busy");
case MERR_BADDATA:
return ("Error reading data section");
case MERR_BADREL:
return ("Error reading relocation records");
case MERR_BADSYMHEAD:
return ("Error reading symbol header");
case MERR_BADEXSTR:
return ("Error reading external string table");
case MERR_BADEXSYM:
return ("Error reading external symbol table");
case MERR_NOSEC:
return ("Missing text, data and bss sections");
case MERR_NOSTRTAB:
return ("No string table found for object");
case MERR_NOSYMS:
return ("No symbols found for object");
case MERR_BADARCH:
return ("Bad EF_MIPS_ARCH arch type");
case MERR_SHSTR:
return ("Error reading section header string table");
case MERR_SYMTAB:
return ("Error reading section symbol table");
case MERR_STRTAB:
return ("Error reading section string table");
case MERR_NOTEXT:
return ("No text or textrel section found in object");
case MERR_SHNDX:
return ("Bad section index");
case MERR_UNKNOWN_CFCMD:
return ("Unknown syssgi command");
case MERR_UNKNOWN_SYMCMD:
return ("Unknown syssgi sym command");
case MERR_FINDADDR:
return ("Address not found in symbol tables");
case MERR_FINDNAME:
return ("Name not found in symbol tables");
case MERR_SYMEFAULT:
return ("Address fault on sym command");
case MERR_NOELF:
return ("Dynamically loadable ELF modules not supported");
case MERR_UNSUPPORTED:
return ("Feature unsupported");
case MERR_LOADOFF:
return ("Dynamic loading turned off");
case MERR_BADID:
return ("Module id not found");
case MERR_NOTLOADED:
return ("Module not loaded");
case MERR_NOTREGED:
return ("Module not registered");
case MERR_OPENBUSY:
return ("Can not open, device busy");
case MERR_UNLOADBUSY:
return ("Can not unload module, device busy");
case MERR_UNREGBUSY:
return ("Can not unregister module, device busy");
case MERR_ILLDRVTYPE:
return ("Illegal driver type");
case MERR_NOMAJOR:
return ("No major passed in cfg information");
case MERR_NOMAJORS:
return ("Out of major numbers");
case MERR_ILLMAJOR:
return ("Illegal major number");
case MERR_MAJORUSED:
return ("Major number already in use");
case MERR_SWTCHFULL:
return ("Switch table is full");
case MERR_UNLDFAIL:
return ("Unload function failed");
case MERR_DOLD:
return ("D_OLD drivers not supported as loadable modules");
case MERR_NODEVFLAG:
return ("No xxxdevflag found");
case MERR_NOINFO:
return ("No xxxinfo found");
case MERR_NOOPEN:
return ("No xxxopen found");
case MERR_NOCLOSE:
return ("No xxxclose found");
case MERR_NOMMAP:
return ("No xxxmmap found");
case MERR_NOSTRAT:
return ("No xxxstrategy found");
case MERR_NOSIZE:
return ("No xxxsize found");
case MERR_NOUNLD:
return ("No xxxunload found");
case MERR_NOVFSOPS:
return ("No xxxvfsops found");
case MERR_NOVNODEOPS:
return ("No xxxvnodops found");
case MERR_NOINIT:
return ("No xxxinit found");
case MERR_NOINTR:
return ("No xxxintr found");
case MERR_NOEDTINIT:
return ("No xxxedtinit found");
case MERR_NOSTRNAME:
return ("Stream name missing");
case MERR_STRDUP:
return ("Duplicate streams name");
case MERR_NOPREFIX:
return ("No prefix sent in cfg information");
case MERR_NOMODTYPE:
return ("No module type sent in descriptor");
case MERR_BADMODTYPE:
return ("Bad module type sent in descriptor");
case MERR_BADCFGVERSION:
return ("Lboot version out of date with kernel version");
case MERR_BADVERSION:
return ("Module version out of date with kernel version");
case MERR_NOVERSION:
return ("Module version string is missing");
case MERR_BADLINK:
return ("Can't resolve all symbols in object");
case MERR_BADJMP:
return ("Address outside of jal range - compile with -jalr");
case MERR_BADRTYPE:
return ("Bad relocation type");
case MERR_GP:
return ("GP section unsupported - compile with -G0");
case MERR_BADSC:
return ("Unexpected storage class encountered");
case MERR_REFHI:
return ("Unexpected REFHI relocation type");
case MERR_NORRECS:
return ("No relocation records found in object");
case MERR_SCNDATA:
return ("Bad data section encountered in object");
case MERR_COMMON:
return ("Common storage class in object not supported");
case MERR_JMP256:
return ("Can't relocate j in a 256MB boundary - compile with -jalr");
case MERR_LIBUNLD:
return ("Library modules can not be unloaded");
case MERR_LIBREG:
return ("Library modules can not be registered/unregistered");
case MERR_NOLIBIDS:
return ("Out of library module ids");
case MERR_IDBG:
return ("Idbg.o module already loaded or statically linked into kernel");
case MERR_IDBGREG:
return ("The idbg.o module can not be registered/unregistered");
case MERR_NOENETIDS:
return ("Out of ethernet module ids");
case MERR_ENETREG:
return ("Ethernet modules can not be registered");
case MERR_ENETUNREG:
return ("Ethernet modules can not be unregistered");
case MERR_ENETUNLOAD:
return ("Ethernet modules can not be unloaded");
case MERR_NOFSYSNAME:
return ("No filesystem name specified");
case MERR_DUPFSYS:
return ("filesystem already exists in vfssw table");
case MERR_VECINUSE:
return ("Interrupt vector in use");
case MERR_BADADAP:
return ("No adapter found");
case MERR_NOEDTDATA:
return ("No edt data for ethernet driver");
case MERR_ELF64:
return ("A 64bit kernel requires a 64bit loadable module");
case MERR_ELF32:
return ("A 32bit kernel requires a 32bit loadable module");
case MERR_ELFN32:
return ("An N32 kernel requires an N32 loadable module");
case MERR_ELF64COFF:
return ("A 64bit kernel requires a 64bit ELF loadable module");
case MERR_ET_REL:
return ("Loadable modules must be built as relocatable");
case MERR_SYMTABREG:
return ("Can not reg/unreg a symbol table module");
case MERR_NOSYMTABIDS:
return ("Out of symbol table module ids");
case MERR_NOSYMTAB:
return ("No symbol table found in object");
case MERR_DUPSYMTAB:
return ("Symbol table for this filename already exists");
case MERR_NOSYMTABAVAIL:
return ("No runtime symbol table available for running kernel");
case MERR_SYMTABMISMATCH:
return ("Symbol table does not match running kernel");
case MERR_NOIDBG:
return ("Idbg.o must be loaded before xxxidbg.o modules");
case MERR_UNREGFAIL:
return ("xxxunreg failed");
default:
return ("Error unknown");
}
}
#ifdef DEBUG
static int
prinfo(int type, char *fname, char *prefix, int devflag)
{
printf ("module type is ");
switch (type) {
case M_DRIVER: printf ("DRIVER\n"); break;
case M_STREAMS: printf ("STREAM\n"); break;
case M_IDBG: printf ("IDBG\n"); break;
case M_LIB: printf ("LIB\n"); break;
case M_SYMTAB: printf ("SYMTAB\n"); break;
case M_FILESYS: printf ("FILESYS\n"); break;
case M_ENET: printf("ENET\n"); break;
case M_OTHER: printf ("OTHER\n"); break;
default: printf ("UNKNOWN\n"); break;
}
printf ("file name is %s\n", fname);
printf ("prefix is %s\n", prefix);
if (type == M_DRIVER) {
printf ("device driver type is ");
switch (devflag) {
case MDRV_CHAR: printf ("CHAR\n"); break;
case MDRV_CHAR|MDRV_BLOCK: printf ("CHAR/BLOCK\n"); break;
case MDRV_BLOCK: printf ("BLOCK\n"); break;
case MDRV_STREAM: printf ("MDRV_STREAM\n"); break;
default: printf ("OTHER\n"); break;
}
}
return (0);
}
#endif /* DEBUG */
View Git Blame Copy Permalink