URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [kernel/] [module.c] - Blame information for rev 1767

Go to most recent revision | Details | Compare with Previous | View Log

#include <linux/errno.h>
#include <linux/kernel.h>
#include <asm/segment.h>
#include <linux/mm.h>           /* defines GFP_KERNEL */
#include <linux/string.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/malloc.h>
#include <linux/config.h>
#include <asm/pgtable.h>
/*
 * Originally by Anonymous (as far as I know...)
 * Linux version by Bas Laarhoven <bas@vimec.nl>
 * 0.99.14 version by Jon Tombs <jon@gtex02.us.es>,
 *
 * Heavily modified by Bjorn Ekwall <bj0rn@blox.se> May 1994 (C)
 * This source is covered by the GNU GPL, the same as all kernel sources.
 *
 * Features:
 *      - Supports stacked modules (removable only of there are no dependents).
 *      - Supports table of symbols defined by the modules.
 *      - Supports /proc/ksyms, showing value, name and owner of all
 *        the symbols defined by all modules (in stack order).
 *      - Added module dependencies information into /proc/modules
 *      - Supports redefines of all symbols, for streams-like behaviour.
 *      - Compatible with older versions of insmod.
 *
 * New addition in December 1994: (Bjorn Ekwall, idea from Jacques Gelinas)
 *      - Externally callable function:
 *
 *              "int register_symtab(struct symbol_table *)"
 *
 *        This function can be called from within the kernel,
 *        and ALSO from loadable modules.
 *        The goal is to assist in modularizing the kernel even more,
 *        and finally: reducing the number of entries in ksyms.c
 *        since every subsystem should now be able to decide and
 *        control exactly what symbols it wants to export, locally!
 *
 * On 1-Aug-95:  <Matti.Aarnio@utu.fi>  altered code to use same style as
 *               do  /proc/net/XXX  "files".  Namely allow more than 4kB
 *               (or what the block size is) output.
 *
 *      - Use dummy syscall functions for users who disable all
 *        module support. Similar to kernel/sys.c (Paul Gortmaker)
 */
 
#ifdef CONFIG_MODULES           /* a *big* #ifdef block... */
 
static struct module kernel_module;
static struct module *module_list = &kernel_module;
 
static int freeing_modules; /* true if some modules are marked for deletion */
 
static struct module *find_module( const char *name);
static int get_mod_name( char *user_name, char *buf);
static int free_modules( void);
 
extern struct symbol_table symbol_table; /* in kernel/ksyms.c */
 
/*
 * Called at boot time
 */
void init_modules(void) {
        struct internal_symbol *sym;
        int i;
 
        for (i = 0, sym = symbol_table.symbol; sym->name; ++sym, ++i)
                ;
        symbol_table.n_symbols = i;
 
        kernel_module.symtab = &symbol_table;
        kernel_module.state = MOD_RUNNING; /* Hah! */
        kernel_module.name = "";
}
 
/*
 * Allocate space for a module.
 */
asmlinkage unsigned long
sys_create_module(char *module_name, unsigned long size)
{
        struct module *mp;
        void* addr;
        int error;
        int npages;
        int sspace = sizeof(struct module) + MOD_MAX_NAME;
        char name[MOD_MAX_NAME];
 
        if (!suser() || securelevel > 0)
                return -EPERM;
        if (module_name == NULL || size == 0)
                return -EINVAL;
        if ((error = get_mod_name(module_name, name)) != 0)
                return error;
        if (find_module(name) != NULL) {
                return -EEXIST;
        }
 
        if ((mp = (struct module*) kmalloc(sspace, GFP_KERNEL)) == NULL) {
                return -ENOMEM;
        }
        strcpy((char *)(mp + 1), name); /* why not? */
 
        npages = (size + sizeof (long) + PAGE_SIZE - 1) / PAGE_SIZE;
        if ((addr = vmalloc(npages * PAGE_SIZE)) == 0) {
                kfree_s(mp, sspace);
                return -ENOMEM;
        }
 
        mp->next = module_list;
        mp->ref = NULL;
        mp->symtab = NULL;
        mp->name = (char *)(mp + 1);
        mp->size = npages;
        mp->addr = addr;
        mp->state = MOD_UNINITIALIZED;
        mp->cleanup = NULL;
 
        * (long *) addr = 0;     /* set use count to zero */
        module_list = mp;       /* link it in */
 
        pr_debug("module `%s' (%lu pages @ 0x%08lx) created\n",
                mp->name, (unsigned long) mp->size, (unsigned long) mp->addr);
        return (unsigned long) addr;
}
 
/*
 * Initialize a module.
 */
asmlinkage int
sys_init_module(char *module_name, char *code, unsigned codesize,
                struct mod_routines *routines,
                struct symbol_table *symtab)
{
        struct module *mp;
        struct symbol_table *newtab;
        char name[MOD_MAX_NAME];
        int error;
        struct mod_routines rt;
 
        if (!suser() || securelevel > 0)
                return -EPERM;
 
#ifdef __i386__
        /* A little bit of protection... we "know" where the user stack is... */
 
        if (symtab && ((unsigned long)symtab > 0xb0000000)) {
                printk(KERN_WARNING "warning: you are using an old insmod, no symbols will be inserted!\n");
                symtab = NULL;
        }
#endif
        if ((error = get_mod_name(module_name, name)) != 0)
                return error;
        pr_debug("initializing module `%s', %d (0x%x) bytes\n",
                name, codesize, codesize);
        memcpy_fromfs(&rt, routines, sizeof rt);
        if ((mp = find_module(name)) == NULL)
                return -ENOENT;
        if (codesize & MOD_AUTOCLEAN) {
                /*
                 * set autoclean marker from codesize...
                 * set usage count to "zero"
                 */
                codesize &= ~MOD_AUTOCLEAN;
                GET_USE_COUNT(mp) = MOD_AUTOCLEAN;
        }
        if ((codesize + sizeof (long) + PAGE_SIZE - 1) / PAGE_SIZE > mp->size)
                return -EINVAL;
        memcpy_fromfs((char *)mp->addr + sizeof (long), code, codesize);
        memset((char *)mp->addr + sizeof (long) + codesize, 0,
                mp->size * PAGE_SIZE - (codesize + sizeof (long)));
        pr_debug("module init entry = 0x%08lx, cleanup entry = 0x%08lx\n",
                (unsigned long) rt.init, (unsigned long) rt.cleanup);
        mp->cleanup = rt.cleanup;
 
        /* update kernel symbol table */
        if (symtab) { /* symtab == NULL means no new entries to handle */
                struct internal_symbol *sym;
                struct module_ref *ref;
                int size;
                int i;
                int legal_start;
 
                if ((error = verify_area(VERIFY_READ, &symtab->size, sizeof(symtab->size))))
                        return error;
                size = get_user(&symtab->size);
 
                if ((newtab = (struct symbol_table*) kmalloc(size, GFP_KERNEL)) == NULL) {
                        return -ENOMEM;
                }
 
                if ((error = verify_area(VERIFY_READ, symtab, size))) {
                        kfree_s(newtab, size);
                        return error;
                }
                memcpy_fromfs((char *)(newtab), symtab, size);
 
                /* sanity check */
                legal_start = sizeof(struct symbol_table) +
                        newtab->n_symbols * sizeof(struct internal_symbol) +
                        newtab->n_refs * sizeof(struct module_ref);
 
                if ((newtab->n_symbols < 0) || (newtab->n_refs < 0) || (legal_start > size)) {
                        printk(KERN_WARNING "Rejecting illegal symbol table (n_symbols=%d,n_refs=%d)\n",
                               newtab->n_symbols, newtab->n_refs);
                        kfree_s(newtab, size);
                        return -EINVAL;
                }
 
                /* relocate name pointers, index referred from start of table */
                for (sym = &(newtab->symbol[0]), i = 0; i < newtab->n_symbols; ++sym, ++i) {
                        if ((unsigned long)sym->name < legal_start || size <= (unsigned long)sym->name) {
                                printk(KERN_WARNING "Rejecting illegal symbol table\n");
                                kfree_s(newtab, size);
                                return -EINVAL;
                        }
                        /* else */
                        sym->name += (long)newtab;
                }
                mp->symtab = newtab;
 
                /* Update module references.
                 * On entry, from "insmod", ref->module points to
                 * the referenced module!
                 * Now it will point to the current module instead!
                 * The ref structure becomes the first link in the linked
                 * list of references to the referenced module.
                 * Also, "sym" from above, points to the first ref entry!!!
                 */
                for (ref = (struct module_ref *)sym, i = 0;
                        i < newtab->n_refs; ++ref, ++i) {
 
                        /* Check for valid reference */
                        struct module *link = module_list;
                        while (link && (ref->module != link))
                                link = link->next;
 
                        if (link == (struct module *)0) {
                                printk(KERN_WARNING "Non-module reference! Rejected!\n");
                                return -EINVAL;
                        }
 
                        ref->next = ref->module->ref;
                        ref->module->ref = ref;
                        ref->module = mp;
                }
        }
 
        flush_pages_to_ram((unsigned long)mp->addr,
                           (codesize+sizeof(long)+PAGE_SIZE-1)/PAGE_SIZE);
 
        GET_USE_COUNT(mp) += 1;
        if ((*rt.init)() != 0) {
                GET_USE_COUNT(mp) = 0;
                return -EBUSY;
        }
        GET_USE_COUNT(mp) -= 1;
        mp->state = MOD_RUNNING;
 
        return 0;
}
 
asmlinkage int
sys_delete_module(char *module_name)
{
        struct module *mp;
        char name[MOD_MAX_NAME];
        int error;
 
        if (!suser() || securelevel > 0)
                return -EPERM;
        /* else */
        if (module_name != NULL) {
                if ((error = get_mod_name(module_name, name)) != 0)
                        return error;
                if ((mp = find_module(name)) == NULL)
                        return -ENOENT;
                if ((mp->ref != NULL) ||
                    ((GET_USE_COUNT(mp) & ~(MOD_AUTOCLEAN | MOD_VISITED)) != 0))
                        return -EBUSY;
                GET_USE_COUNT(mp) &= ~(MOD_AUTOCLEAN | MOD_VISITED);
                if (mp->state == MOD_RUNNING)
                        (*mp->cleanup)();
                mp->state = MOD_DELETED;
                free_modules();
        }
        /* for automatic reaping */
        else {
                struct module *mp_next;
                for (mp = module_list; mp != &kernel_module; mp = mp_next) {
                        mp_next = mp->next;
                        if ((mp->ref == NULL) && (mp->state == MOD_RUNNING) &&
                            ((GET_USE_COUNT(mp) & ~MOD_VISITED) == MOD_AUTOCLEAN)) {
                                if ((GET_USE_COUNT(mp) & MOD_VISITED)) {
                                        /* Don't reap until one "cycle" after last _use_ */
                                        GET_USE_COUNT(mp) &= ~MOD_VISITED;
                                }
                                else {
                                        GET_USE_COUNT(mp) &= ~(MOD_AUTOCLEAN | MOD_VISITED);
                                        (*mp->cleanup)();
                                        mp->state = MOD_DELETED;
                                        free_modules();
                                }
                        }
                }
        }
        return 0;
}
 
 
/*
 * Copy the kernel symbol table to user space.  If the argument is null,
 * just return the size of the table.
 *
 * Note that the transient module symbols are copied _first_,
 * in lifo order!!!
 *
 * The symbols to "insmod" are according to the "old" format: struct kernel_sym,
 * which is actually quite handy for this purpose.
 * Note that insmod inserts a struct symbol_table later on...
 * (as that format is quite handy for the kernel...)
 *
 * For every module, the first (pseudo)symbol copied is the module name
 * and the address of the module struct.
 * This lets "insmod" keep track of references, and build the array of
 * struct module_refs in the symbol table.
 * The format of the module name is "#module", so that "insmod" can easily
 * notice when a module name comes along. Also, this will make it possible
 * to use old versions of "insmod", albeit with reduced functionality...
 * The "kernel" module has an empty name.
 */
asmlinkage int
sys_get_kernel_syms(struct kernel_sym *table)
{
        struct internal_symbol *from;
        struct kernel_sym isym;
        struct kernel_sym *to;
        struct module *mp = module_list;
        int i;
        int nmodsyms = 0;
 
        for (mp = module_list; mp; mp = mp->next) {
                if (mp->symtab && mp->symtab->n_symbols) {
                        /* include the count for the module name! */
                        nmodsyms += mp->symtab->n_symbols + 1;
                }
                else
                        /* include the count for the module name! */
                        nmodsyms += 1; /* return modules without symbols too */
        }
 
        if (table != NULL) {
                to = table;
 
                if ((i = verify_area(VERIFY_WRITE, to, nmodsyms * sizeof(*table))))
                        return i;
 
                /* copy all module symbols first (always LIFO order) */
                for (mp = module_list; mp; mp = mp->next) {
                        if (mp->state == MOD_RUNNING) {
                                /* magic: write module info as a pseudo symbol */
                                isym.value = (unsigned long)mp;
                                sprintf(isym.name, "#%s", mp->name);
                                memcpy_tofs(to, &isym, sizeof isym);
                                ++to;
 
                                if (mp->symtab != NULL) {
                                        for (i = mp->symtab->n_symbols,
                                                from = mp->symtab->symbol;
                                                i > 0; --i, ++from, ++to) {
 
                                                isym.value = (unsigned long)from->addr;
                                                strncpy(isym.name, from->name, sizeof isym.name);
                                                memcpy_tofs(to, &isym, sizeof isym);
                                        }
                                }
                        }
                }
        }
 
        return nmodsyms;
}
 
 
/*
 * Copy the name of a module from user space.
 */
int
get_mod_name(char *user_name, char *buf)
{
        int i;
 
        i = 0;
        for (i = 0 ; (buf[i] = get_user(user_name + i)) != '\0' ; ) {
                if (++i >= MOD_MAX_NAME)
                        return -E2BIG;
        }
        return 0;
}
 
 
/*
 * Look for a module by name, ignoring modules marked for deletion.
 */
struct module *
find_module( const char *name)
{
        struct module *mp;
 
        for (mp = module_list ; mp ; mp = mp->next) {
                if (mp->state == MOD_DELETED)
                        continue;
                if (!strcmp(mp->name, name))
                        break;
        }
        return mp;
}
 
static void
drop_refs(struct module *mp)
{
        struct module *step;
        struct module_ref *prev;
        struct module_ref *ref;
 
        for (step = module_list; step; step = step->next) {
                for (prev = ref = step->ref; ref; ref = prev->next) {
                        if (ref->module == mp) {
                                if (ref == step->ref)
                                        step->ref = ref->next;
                                else
                                        prev->next = ref->next;
                                break; /* every module only references once! */
                        }
                        else
                                prev = ref;
                }
        }
}
 
/*
 * Try to free modules which have been marked for deletion.  Returns nonzero
 * if a module was actually freed.
 */
int
free_modules( void)
{
        struct module *mp;
        struct module **mpp;
        int did_deletion;
 
        did_deletion = 0;
        freeing_modules = 0;
        mpp = &module_list;
        while ((mp = *mpp) != NULL) {
                if (mp->state != MOD_DELETED) {
                        mpp = &mp->next;
                } else {
                        if ((GET_USE_COUNT(mp) != 0) || (mp->ref != NULL)) {
                                freeing_modules = 1;
                                mpp = &mp->next;
                        } else {        /* delete it */
                                *mpp = mp->next;
                                if (mp->symtab) {
                                        if (mp->symtab->n_refs)
                                                drop_refs(mp);
                                        if (mp->symtab->size)
                                                kfree_s(mp->symtab, mp->symtab->size);
                                }
                                vfree(mp->addr);
                                kfree_s(mp, sizeof(struct module) + MOD_MAX_NAME);
                                did_deletion = 1;
                        }
                }
        }
        return did_deletion;
}
 
 
/*
 * Called by the /proc file system to return a current list of modules.
 */
int get_module_list(char *buf)
{
        char *p;
        const char *q;
        int i;
        struct module *mp;
        struct module_ref *ref;
        char size[32];
 
        p = buf;
        /* Do not show the kernel pseudo module */
        for (mp = module_list ; mp && mp->next; mp = mp->next) {
                if (p - buf > 4096 - 100)
                        break;                  /* avoid overflowing buffer */
                q = mp->name;
                if (*q == '\0' && mp->size == 0 && mp->ref == NULL)
                        continue; /* don't list modules for kernel syms */
                i = 20;
                while (*q) {
                        *p++ = *q++;
                        i--;
                }
                sprintf(size, "%d", mp->size);
                i -= strlen(size);
                if (i <= 0)
                        i = 1;
                while (--i >= 0)
                        *p++ = ' ';
                q = size;
                while (*q)
                        *p++ = *q++;
                if (mp->state == MOD_UNINITIALIZED)
                        q = "  (uninitialized)";
                else if (mp->state == MOD_RUNNING)
                        q = "";
                else if (mp->state == MOD_DELETED)
                        q = "  (deleted)";
                else
                        q = "  (bad state)";
                while (*q)
                        *p++ = *q++;
 
                *p++ = '\t';
                if ((ref = mp->ref) != NULL) {
                        *p++ = '[';
                        for (; ref; ref = ref->next) {
                                q = ref->module->name;
                                while (*q)
                                        *p++ = *q++;
                                if (ref->next)
                                        *p++ = ' ';
                        }
                        *p++ = ']';
                }
                if (mp->state == MOD_RUNNING) {
                        sprintf(size,"\t%ld%s",
                                GET_USE_COUNT(mp) & ~(MOD_AUTOCLEAN | MOD_VISITED),
                                ((GET_USE_COUNT(mp) & MOD_AUTOCLEAN)?
                                        " (autoclean)":""));
                        q = size;
                        while (*q)
                                *p++ = *q++;
                }
                *p++ = '\n';
        }
        return p - buf;
}
 
 
/*
 * Called by the /proc file system to return a current list of ksyms.
 */
int get_ksyms_list(char *buf, char **start, off_t offset, int length)
{
        struct module *mp;
        struct internal_symbol *sym;
        int i;
        char *p = buf;
        int len     = 0; /* code from  net/ipv4/proc.c */
        off_t pos   = 0;
        off_t begin = 0;
 
        for (mp = module_list; mp; mp = mp->next) {
                if ((mp->state == MOD_RUNNING) &&
                    (mp->symtab != NULL) &&
                    (mp->symtab->n_symbols > 0)) {
                        for (i = mp->symtab->n_symbols,
                                sym = mp->symtab->symbol;
                                i > 0; --i, ++sym) {
 
                                p = buf + len;
                                if (mp->name[0]) {
                                        len += sprintf(p, "%08lx %s\t[%s]\n",
                                                       (long)sym->addr,
                                                       sym->name, mp->name);
                                } else {
                                        len += sprintf(p, "%08lx %s\n",
                                                       (long)sym->addr,
                                                       sym->name);
                                }
                                pos = begin + len;
                                if (pos < offset) {
                                        len   = 0;
                                        begin = pos;
                                }
                                pos = begin + len;
                                if (pos > offset+length)
                                        goto leave_the_loop;
                        }
                }
        }
    leave_the_loop:
        *start = buf + (offset - begin);
        len -= (offset - begin);
        if (len > length)
                len = length;
        return len;
}
 
/*
 * Gets the address for a symbol in the given module.  If modname is
 * NULL, it looks for the name in any registered symbol table.  If the
 * modname is an empty string, it looks for the symbol in kernel exported
 * symbol tables.
 */
void *get_module_symbol(char *modname, char *symname)
{
        struct module *mp;
        struct internal_symbol *sym;
        int i;
 
        for (mp = module_list; mp; mp = mp->next) {
                if (((modname == NULL) || (strcmp(mp->name, modname) == 0)) &&
                        (mp->state == MOD_RUNNING) &&
                    (mp->symtab != NULL) &&
                    (mp->symtab->n_symbols > 0)) {
                        for (i = mp->symtab->n_symbols,
                                sym = mp->symtab->symbol;
                                i > 0; --i, ++sym) {
 
                                if (strcmp(sym->name, symname) == 0) {
                                        return sym->addr;
                                }
                        }
                }
        }
        return NULL;
}
 
/*
 * Rules:
 * - The new symbol table should be statically allocated, or else you _have_
 *   to set the "size" field of the struct to the number of bytes allocated.
 *
 * - The strings that name the symbols will not be copied, maybe the pointers
 *
 * - For a loadable module, the function should only be called in the
 *   context of init_module
 *
 * Those are the only restrictions! (apart from not being reentrant...)
 *
 * If you want to remove a symbol table for a loadable module,
 * the call looks like: "register_symtab(0)".
 *
 * The look of the code is mostly dictated by the format of
 * the frozen struct symbol_table, due to compatibility demands.
 */
#define INTSIZ sizeof(struct internal_symbol)
#define REFSIZ sizeof(struct module_ref)
#define SYMSIZ sizeof(struct symbol_table)
#define MODSIZ sizeof(struct module)
static struct symbol_table nulltab;
 
int
register_symtab_from(struct symbol_table *intab, long *from)
{
        struct module *mp;
        struct module *link;
        struct symbol_table *oldtab;
        struct symbol_table *newtab;
        struct module_ref *newref;
        int size;
 
        if (intab && (intab->n_symbols == 0)) {
                struct internal_symbol *sym;
                /* How many symbols, really? */
 
                for (sym = intab->symbol; sym->name; ++sym)
                        intab->n_symbols +=1;
        }
 
        for (mp = module_list; mp != &kernel_module; mp = mp->next) {
                /*
                 * "from" points to "mod_use_count_" (== start of module)
                 * or is == 0 if called from a non-module
                 */
                if ((unsigned long)(mp->addr) == (unsigned long)from)
                        break;
        }
 
        if (mp == &kernel_module) {
                /* Aha! Called from an "internal" module */
                if (!intab)
                        return 0; /* or -ESILLY_PROGRAMMER :-) */
 
                /* create a pseudo module! */
                if (!(mp = (struct module*) kmalloc(MODSIZ, GFP_KERNEL))) {
                        /* panic time! */
                        printk(KERN_ERR "Out of memory for new symbol table!\n");
                        return -ENOMEM;
                }
                /* else  OK */
                memset(mp, 0, MODSIZ);
                mp->state = MOD_RUNNING; /* Since it is resident... */
                mp->name = ""; /* This is still the "kernel" symbol table! */
                mp->symtab = intab;
 
                /* link it in _after_ the resident symbol table */
                mp->next = kernel_module.next;
                kernel_module.next = mp;
 
                return 0;
        }
 
        /* else ******** Called from a loadable module **********/
 
        /*
         * This call should _only_ be done in the context of the
         * call to  init_module  i.e. when loading the module!!
         * Or else...
         */
 
        /* Any table there before? */
        if ((oldtab = mp->symtab) == (struct symbol_table*)0) {
                /* No, just insert it! */
                mp->symtab = intab;
                return 0;
        }
 
        /* else  ****** we have to replace the module symbol table ******/
 
        if (oldtab->n_refs == 0) { /* no problems! */
                mp->symtab = intab;
                /* if the old table was kmalloc-ed, drop it */
                if (oldtab->size > 0)
                        kfree_s(oldtab, oldtab->size);
 
                return 0;
        }
 
        /* else */
        /***** The module references other modules... insmod said so! *****/
        /* We have to allocate a new symbol table, or we lose them! */
        if (intab == (struct symbol_table*)0)
                intab = &nulltab; /* easier code with zeroes in place */
 
        /* the input symbol table space does not include the string table */
        /* (it does for symbol tables that insmod creates) */
 
        if (!(newtab = (struct symbol_table*)kmalloc(
                size = SYMSIZ + intab->n_symbols * INTSIZ +
                        oldtab->n_refs * REFSIZ,
                GFP_KERNEL))) {
                /* panic time! */
                printk(KERN_ERR "Out of memory for new symbol table!\n");
                return -ENOMEM;
        }
 
        /* copy up to, and including, the new symbols */
        memcpy(newtab, intab, SYMSIZ + intab->n_symbols * INTSIZ);
 
        newtab->size = size;
        newtab->n_refs = oldtab->n_refs;
 
        /* copy references */
        memcpy( ((char *)newtab) + SYMSIZ + intab->n_symbols * INTSIZ,
                ((char *)oldtab) + SYMSIZ + oldtab->n_symbols * INTSIZ,
                oldtab->n_refs * REFSIZ);
 
        /* relink references from the old table to the new one */
 
        /* pointer to the first reference entry in newtab! Really! */
        newref = (struct module_ref*) &(newtab->symbol[newtab->n_symbols]);
 
        /* check for reference links from previous modules */
        for (   link = module_list;
                link && (link != &kernel_module);
                link = link->next) {
 
                if (link->ref && (link->ref->module == mp))
                        link->ref = newref++;
        }
 
        mp->symtab = newtab;
 
        /* all references (if any) have been handled */
 
        /* if the old table was kmalloc-ed, drop it */
        if (oldtab->size > 0)
                kfree_s(oldtab, oldtab->size);
 
        return 0;
}
 
#else           /* CONFIG_MODULES */
 
/* Dummy syscalls for people who don't want modules */
 
asmlinkage unsigned long sys_create_module(void)
{
        return -ENOSYS;
}
 
asmlinkage int sys_init_module(void)
{
        return -ENOSYS;
}
 
asmlinkage int sys_delete_module(void)
{
        return -ENOSYS;
}
 
asmlinkage int sys_get_kernel_syms(void)
{
        return -ENOSYS;
}
 
int register_symtab_from(struct symbol_table *intab, long *from)
{
        return 0;
}
 
#endif  /* CONFIG_MODULES */
 
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [kernel/] [module.c] - Blame information for rev 1767

Line No.	Rev	Author	Line
1	199	simons	`#include <linux/errno.h>`
2			`#include <linux/kernel.h>`
3			`#include <asm/segment.h>`
4			`#include <linux/mm.h> /* defines GFP_KERNEL */`
5			`#include <linux/string.h>`
6			`#include <linux/module.h>`
7			`#include <linux/sched.h>`
8			`#include <linux/malloc.h>`
9			`#include <linux/config.h>`
10			`#include <asm/pgtable.h>`
11			`/*`
12			`* Originally by Anonymous (as far as I know...)`
13			`* Linux version by Bas Laarhoven <bas@vimec.nl>`
14			`* 0.99.14 version by Jon Tombs <jon@gtex02.us.es>,`
15			`*`
16			`* Heavily modified by Bjorn Ekwall <bj0rn@blox.se> May 1994 (C)`
17			`* This source is covered by the GNU GPL, the same as all kernel sources.`
18			`*`
19			`* Features:`
20			`* - Supports stacked modules (removable only of there are no dependents).`
21			`* - Supports table of symbols defined by the modules.`
22			`* - Supports /proc/ksyms, showing value, name and owner of all`
23			`* the symbols defined by all modules (in stack order).`
24			`* - Added module dependencies information into /proc/modules`
25			`* - Supports redefines of all symbols, for streams-like behaviour.`
26			`* - Compatible with older versions of insmod.`
27			`*`
28			`* New addition in December 1994: (Bjorn Ekwall, idea from Jacques Gelinas)`
29			`* - Externally callable function:`
30			`*`
31			`* "int register_symtab(struct symbol_table *)"`
32			`*`
33			`* This function can be called from within the kernel,`
34			`* and ALSO from loadable modules.`
35			`* The goal is to assist in modularizing the kernel even more,`
36			`* and finally: reducing the number of entries in ksyms.c`
37			`* since every subsystem should now be able to decide and`
38			`* control exactly what symbols it wants to export, locally!`
39			`*`
40			`* On 1-Aug-95: <Matti.Aarnio@utu.fi> altered code to use same style as`