d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d4ebee28d2
freebsd-skq/sys/kern/kern_linker.c

1037 lines
25 KiB
C
Raw Normal View History

This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
/*-
* Copyright (c) 1997 Doug Rabson
* 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.
*
Slight reorganization of kernel thread/process creation. Instead of using SYSINIT_KT() etc (which is a static, compile-time procedure), use a NetBSD-style kthread_create() interface. kproc_start is still available as a SYSINIT() hook. This allowed simplification of chunks of the sysinit code in the process. This kthread_create() is our old kproc_start internals, with the SYSINIT_KT fork hooks grafted in and tweaked to work the same as the NetBSD one. One thing I'd like to do shortly is get rid of nfsiod as a user initiated process. It makes sense for the nfs client code to create them on the fly as needed up to a user settable limit. This means that nfsiod doesn't need to be in /sbin and is always "available". This is a fair bit easier to do outside of the SYSINIT_KT() framework.
1999-07-01 13:21:46 +00:00
* $Id: kern_linker.c,v 1.33 1999/06/30 15:33:35 peter Exp $
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
*/
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
#include "opt_ddb.h"
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/sysproto.h>
#include <sys/sysent.h>
#include <sys/proc.h>
#include <sys/lock.h>
#include <machine/cpu.h>
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
#include <machine/bootinfo.h>
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
#include <sys/module.h>
#include <sys/linker.h>
We have had support for running the kernel daemons as threads for quite a while, but forgot to do so. For now, this code supports most daemons running as kernel threads in UP kernels, and as full processes in SMP. We will soon be able to run them as threads in SMP, but not yet.
1997-12-12 04:00:59 +00:00
#include <sys/unistd.h>
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
#include <sys/fcntl.h>
#include <sys/libkern.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/sysctl.h>
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
Define the kld_debug variable if KLD_DEBUG is enabled
1998-11-06 15:10:17 +00:00
#ifdef KLD_DEBUG
int kld_debug = 0;
#endif
Use a real malloc type for M_LINKER instead of #defining it as M_TEMP. Fixed a comment.
1998-01-01 08:56:24 +00:00
MALLOC_DEFINE(M_LINKER, "kld", "kernel linker");
Fixed a sloppy common-style definitions.
1997-11-20 20:07:59 +00:00
linker_file_t linker_current_file;
The handle for the kernel is common. With this fix, ELF kernels can load a.out kld modules, and a.out kernels can load ELF kld modules.
1998-11-04 15:20:58 +00:00
linker_file_t linker_kernel_file;
Fixed a sloppy common-style definitions.
1997-11-20 20:07:59 +00:00
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
static struct lock lock; /* lock for the file list */
static linker_class_list_t classes;
static linker_file_list_t files;
static int next_file_id = 1;
static void
linker_init(void* arg)
{
lockinit(&lock, PVM, "klink", 0, 0);
TAILQ_INIT(&classes);
TAILQ_INIT(&files);
}
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
SYSINIT(linker, SI_SUB_KLD, SI_ORDER_FIRST, linker_init, 0);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
int
linker_add_class(const char* desc, void* priv,
struct linker_class_ops* ops)
{
linker_class_t lc;
lc = malloc(sizeof(struct linker_class), M_LINKER, M_NOWAIT);
if (!lc)
return ENOMEM;
- bzero() after malloc(). This is especially obvious when kern_malloc is compiled with DIAGNOSTIC. - Don't break from the preload module processing loop prematurely.
1998-10-15 17:12:12 +00:00
bzero(lc, sizeof(*lc));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
lc->desc = desc;
lc->priv = priv;
lc->ops = ops;
TAILQ_INSERT_HEAD(&classes, lc, link);
return 0;
}
static void
linker_file_sysinit(linker_file_t lf)
{
struct linker_set* sysinits;
struct sysinit** sipp;
struct sysinit** xipp;
struct sysinit* save;
First stages of a module dependency cleanup. This part fixes a particularly annoying hack, namely having the linker bash the moduledata to set the container pointer, preventing it being const. In the process, a stack of warnings were fixed and will probably allow a revisit of the const C_SYSINIT() changes. This explicitly registers modules in files or preload areas with the module system first, and let them initialize via SYSINIT/DECLARE_MODULE later in their SI_ORDER_xxx order. The kludge of finding the containing file is no longer needed since the registration of modules onto the modules list is done in the context of initializing the linker file.
1999-05-08 13:01:59 +00:00
const moduledata_t *moddata;
int error;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
KLD_DPF(FILE, ("linker_file_sysinit: calling SYSINITs for %s\n",
lf->filename));
sysinits = (struct linker_set*)
linker_file_lookup_symbol(lf, "sysinit_set", 0);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
KLD_DPF(FILE, ("linker_file_sysinit: SYSINITs %p\n", sysinits));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
if (!sysinits)
return;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
/* HACK ALERT! */
for (sipp = (struct sysinit **)sysinits->ls_items; *sipp; sipp++) {
if ((*sipp)->func == module_register_init) {
moddata = (*sipp)->udata;
First stages of a module dependency cleanup. This part fixes a particularly annoying hack, namely having the linker bash the moduledata to set the container pointer, preventing it being const. In the process, a stack of warnings were fixed and will probably allow a revisit of the const C_SYSINIT() changes. This explicitly registers modules in files or preload areas with the module system first, and let them initialize via SYSINIT/DECLARE_MODULE later in their SI_ORDER_xxx order. The kludge of finding the containing file is no longer needed since the registration of modules onto the modules list is done in the context of initializing the linker file.
1999-05-08 13:01:59 +00:00
error = module_register(moddata, lf);
if (error)
printf("linker_file_sysinit \"%s\" failed to register! %d\n",
lf->filename, error);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
}
}
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
/*
* Perform a bubble sort of the system initialization objects by
* their subsystem (primary key) and order (secondary key).
*
* Since some things care about execution order, this is the
* operation which ensures continued function.
*/
Arrange for unload-time linker set hooks to be called. While cut/pasting some code, I changed the original to be consistant with the rest of the file rather than duplicating the problems.
1998-11-10 08:49:28 +00:00
for (sipp = (struct sysinit **)sysinits->ls_items; *sipp; sipp++) {
for (xipp = sipp + 1; *xipp; xipp++) {
if ((*sipp)->subsystem <= (*xipp)->subsystem ||
((*sipp)->subsystem == (*xipp)->subsystem &&
(*sipp)->order <= (*xipp)->order))
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
continue; /* skip*/
save = *sipp;
*sipp = *xipp;
*xipp = save;
}
}
/*
* Traverse the (now) ordered list of system initialization tasks.
* Perform each task, and continue on to the next task.
*/
Arrange for unload-time linker set hooks to be called. While cut/pasting some code, I changed the original to be consistant with the rest of the file rather than duplicating the problems.
1998-11-10 08:49:28 +00:00
for (sipp = (struct sysinit **)sysinits->ls_items; *sipp; sipp++) {
if ((*sipp)->subsystem == SI_SUB_DUMMY)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
continue; /* skip dummy task(s)*/
Slight reorganization of kernel thread/process creation. Instead of using SYSINIT_KT() etc (which is a static, compile-time procedure), use a NetBSD-style kthread_create() interface. kproc_start is still available as a SYSINIT() hook. This allowed simplification of chunks of the sysinit code in the process. This kthread_create() is our old kproc_start internals, with the SYSINIT_KT fork hooks grafted in and tweaked to work the same as the NetBSD one. One thing I'd like to do shortly is get rid of nfsiod as a user initiated process. It makes sense for the nfs client code to create them on the fly as needed up to a user settable limit. This means that nfsiod doesn't need to be in /sbin and is always "available". This is a fair bit easier to do outside of the SYSINIT_KT() framework.
1999-07-01 13:21:46 +00:00
/* Call function */
(*((*sipp)->func))((*sipp)->udata);
Arrange for unload-time linker set hooks to be called. While cut/pasting some code, I changed the original to be consistant with the rest of the file rather than duplicating the problems.
1998-11-10 08:49:28 +00:00
}
}
static void
linker_file_sysuninit(linker_file_t lf)
{
struct linker_set* sysuninits;
struct sysinit** sipp;
struct sysinit** xipp;
struct sysinit* save;
KLD_DPF(FILE, ("linker_file_sysuninit: calling SYSUNINITs for %s\n",
lf->filename));
sysuninits = (struct linker_set*)
linker_file_lookup_symbol(lf, "sysuninit_set", 0);
KLD_DPF(FILE, ("linker_file_sysuninit: SYSUNINITs %p\n", sysuninits));
if (!sysuninits)
return;
/*
* Perform a reverse bubble sort of the system initialization objects
* by their subsystem (primary key) and order (secondary key).
*
* Since some things care about execution order, this is the
* operation which ensures continued function.
*/
for (sipp = (struct sysinit **)sysuninits->ls_items; *sipp; sipp++) {
for (xipp = sipp + 1; *xipp; xipp++) {
if ((*sipp)->subsystem >= (*xipp)->subsystem ||
((*sipp)->subsystem == (*xipp)->subsystem &&
(*sipp)->order >= (*xipp)->order))
continue; /* skip*/
save = *sipp;
*sipp = *xipp;
*xipp = save;
}
}
/*
* Traverse the (now) ordered list of system initialization tasks.
* Perform each task, and continue on to the next task.
*/
for (sipp = (struct sysinit **)sysuninits->ls_items; *sipp; sipp++) {
if ((*sipp)->subsystem == SI_SUB_DUMMY)
continue; /* skip dummy task(s)*/
Slight reorganization of kernel thread/process creation. Instead of using SYSINIT_KT() etc (which is a static, compile-time procedure), use a NetBSD-style kthread_create() interface. kproc_start is still available as a SYSINIT() hook. This allowed simplification of chunks of the sysinit code in the process. This kthread_create() is our old kproc_start internals, with the SYSINIT_KT fork hooks grafted in and tweaked to work the same as the NetBSD one. One thing I'd like to do shortly is get rid of nfsiod as a user initiated process. It makes sense for the nfs client code to create them on the fly as needed up to a user settable limit. This means that nfsiod doesn't need to be in /sbin and is always "available". This is a fair bit easier to do outside of the SYSINIT_KT() framework.
1999-07-01 13:21:46 +00:00
/* Call function */
(*((*sipp)->func))((*sipp)->udata);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
}
}
* Change sysctl from using linker_set to construct its tree using SLISTs. This makes it possible to change the sysctl tree at runtime. * Change KLD to find and register any sysctl nodes contained in the loaded file and to unregister them when the file is unloaded. Reviewed by: Archie Cobbs <archie@whistle.com>, Peter Wemm <peter@netplex.com.au> (well they looked at it anyway)
1999-02-16 10:49:55 +00:00
static void
linker_file_register_sysctls(linker_file_t lf)
{
struct linker_set* sysctls;
KLD_DPF(FILE, ("linker_file_register_sysctls: registering SYSCTLs for %s\n",
lf->filename));
sysctls = (struct linker_set*)
linker_file_lookup_symbol(lf, "sysctl_set", 0);
KLD_DPF(FILE, ("linker_file_register_sysctls: SYSCTLs %p\n", sysctls));
if (!sysctls)
return;
sysctl_register_set(sysctls);
}
static void
linker_file_unregister_sysctls(linker_file_t lf)
{
struct linker_set* sysctls;
KLD_DPF(FILE, ("linker_file_unregister_sysctls: registering SYSCTLs for %s\n",
lf->filename));
sysctls = (struct linker_set*)
linker_file_lookup_symbol(lf, "sysctl_set", 0);
KLD_DPF(FILE, ("linker_file_unregister_sysctls: SYSCTLs %p\n", sysctls));
if (!sysctls)
return;
sysctl_unregister_set(sysctls);
}
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
int
linker_load_file(const char* filename, linker_file_t* result)
{
linker_class_t lc;
linker_file_t lf;
Try and clean up the multiple formal loading support a bit, based on suggestions from Greg Lehey some time ago. In the face of multiple potential file formats, try and give a more sensible error than just ENOEXEC. XXX a good case can be made that the loading process is wrong - the linker should locate the file first (using the search paths etc), then run the loaders to see if they recognize it. While the present system allows for the possibility of different search paths for different formats, we do not use it and it just makes things more complicated than they need to be.
1999-01-17 17:58:52 +00:00
int foundfile, error = 0;
Have the in-kernel linker try a default extension of .ko. This means that "kldload nfs" works. We use the same default extension in the /boot/loader system.
1998-11-03 14:27:05 +00:00
char *koname = NULL;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
lf = linker_find_file_by_name(filename);
if (lf) {
KLD_DPF(FILE, ("linker_load_file: file %s is already loaded, incrementing refs\n", filename));
*result = lf;
lf->refs++;
goto out;
}
Have the in-kernel linker try a default extension of .ko. This means that "kldload nfs" works. We use the same default extension in the /boot/loader system.
1998-11-03 14:27:05 +00:00
koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
if (koname == NULL) {
error = ENOMEM;
goto out;
}
sprintf(koname, "%s.ko", filename);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
lf = NULL;
Try and clean up the multiple formal loading support a bit, based on suggestions from Greg Lehey some time ago. In the face of multiple potential file formats, try and give a more sensible error than just ENOEXEC. XXX a good case can be made that the loading process is wrong - the linker should locate the file first (using the search paths etc), then run the loaders to see if they recognize it. While the present system allows for the possibility of different search paths for different formats, we do not use it and it just makes things more complicated than they need to be.
1999-01-17 17:58:52 +00:00
foundfile = 0;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
for (lc = TAILQ_FIRST(&classes); lc; lc = TAILQ_NEXT(lc, link)) {
KLD_DPF(FILE, ("linker_load_file: trying to load %s as %s\n",
filename, lc->desc));
Try and clean up the multiple formal loading support a bit, based on suggestions from Greg Lehey some time ago. In the face of multiple potential file formats, try and give a more sensible error than just ENOEXEC. XXX a good case can be made that the loading process is wrong - the linker should locate the file first (using the search paths etc), then run the loaders to see if they recognize it. While the present system allows for the possibility of different search paths for different formats, we do not use it and it just makes things more complicated than they need to be.
1999-01-17 17:58:52 +00:00
error = lc->ops->load_file(koname, &lf); /* First with .ko */
if (lf == NULL && error == ENOENT)
error = lc->ops->load_file(filename, &lf); /* Then try without */
/*
* If we got something other than ENOENT, then it exists but we cannot
* load it for some other reason.
*/
if (error != ENOENT)
foundfile = 1;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
if (lf) {
* Change sysctl from using linker_set to construct its tree using SLISTs. This makes it possible to change the sysctl tree at runtime. * Change KLD to find and register any sysctl nodes contained in the loaded file and to unregister them when the file is unloaded. Reviewed by: Archie Cobbs <archie@whistle.com>, Peter Wemm <peter@netplex.com.au> (well they looked at it anyway)
1999-02-16 10:49:55 +00:00
linker_file_register_sysctls(lf);
* Register sysctl nodes before running sysinits when loading files and unregister them after sysuninits when unloading. * Add code to vfs_register() to set the oid number of vfs sysctls to the type number of the filesystem. Reviewed by: bde
1999-03-07 16:06:41 +00:00
linker_file_sysinit(lf);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
*result = lf;
Have the in-kernel linker try a default extension of .ko. This means that "kldload nfs" works. We use the same default extension in the /boot/loader system.
1998-11-03 14:27:05 +00:00
error = 0;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
}
}
Try and clean up the multiple formal loading support a bit, based on suggestions from Greg Lehey some time ago. In the face of multiple potential file formats, try and give a more sensible error than just ENOEXEC. XXX a good case can be made that the loading process is wrong - the linker should locate the file first (using the search paths etc), then run the loaders to see if they recognize it. While the present system allows for the possibility of different search paths for different formats, we do not use it and it just makes things more complicated than they need to be.
1999-01-17 17:58:52 +00:00
/*
* Less than ideal, but tells the user whether it failed to load or
* the module was not found.
*/
if (foundfile)
error = ENOEXEC; /* Format not recognised (or unloadable) */
else
error = ENOENT; /* Nothing found */
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
out:
Have the in-kernel linker try a default extension of .ko. This means that "kldload nfs" works. We use the same default extension in the /boot/loader system.
1998-11-03 14:27:05 +00:00
if (koname)
free(koname, M_LINKER);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return error;
}
linker_file_t
linker_find_file_by_name(const char* filename)
{
linker_file_t lf = 0;
Have the in-kernel linker try a default extension of .ko. This means that "kldload nfs" works. We use the same default extension in the /boot/loader system.
1998-11-03 14:27:05 +00:00
char *koname;
koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
if (koname == NULL)
goto out;
sprintf(koname, "%s.ko", filename);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
lockmgr(&lock, LK_SHARED, 0, curproc);
Have the in-kernel linker try a default extension of .ko. This means that "kldload nfs" works. We use the same default extension in the /boot/loader system.
1998-11-03 14:27:05 +00:00
for (lf = TAILQ_FIRST(&files); lf; lf = TAILQ_NEXT(lf, link)) {
if (!strcmp(lf->filename, koname))
break;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
if (!strcmp(lf->filename, filename))
break;
Have the in-kernel linker try a default extension of .ko. This means that "kldload nfs" works. We use the same default extension in the /boot/loader system.
1998-11-03 14:27:05 +00:00
}
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
lockmgr(&lock, LK_RELEASE, 0, curproc);
Have the in-kernel linker try a default extension of .ko. This means that "kldload nfs" works. We use the same default extension in the /boot/loader system.
1998-11-03 14:27:05 +00:00
out:
if (koname)
free(koname, M_LINKER);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return lf;
}
linker_file_t
linker_find_file_by_id(int fileid)
{
linker_file_t lf = 0;
lockmgr(&lock, LK_SHARED, 0, curproc);
for (lf = TAILQ_FIRST(&files); lf; lf = TAILQ_NEXT(lf, link))
if (lf->id == fileid)
break;
lockmgr(&lock, LK_RELEASE, 0, curproc);
return lf;
}
linker_file_t
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
linker_make_file(const char* pathname, void* priv, struct linker_file_ops* ops)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
{
linker_file_t lf = 0;
int namelen;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
const char *filename;
filename = rindex(pathname, '/');
if (filename && filename[1])
filename++;
else
filename = pathname;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename));
LK_RETRY is a vn_lock() flag, not one for lockmgr().
1999-04-06 03:02:11 +00:00
lockmgr(&lock, LK_EXCLUSIVE, 0, curproc);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
namelen = strlen(filename) + 1;
lf = malloc(sizeof(struct linker_file) + namelen, M_LINKER, M_WAITOK);
if (!lf)
goto out;
- bzero() after malloc(). This is especially obvious when kern_malloc is compiled with DIAGNOSTIC. - Don't break from the preload module processing loop prematurely.
1998-10-15 17:12:12 +00:00
bzero(lf, sizeof(*lf));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
lf->refs = 1;
lf->userrefs = 0;
Don't try to call SYSUNINIT functions if there was a link error. Reviewed by: Peter Wemm <peter@netplex.com.au>
1999-01-25 08:42:24 +00:00
lf->flags = 0;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
lf->filename = (char*) (lf + 1);
strcpy(lf->filename, filename);
lf->id = next_file_id++;
lf->ndeps = 0;
lf->deps = NULL;
STAILQ_INIT(&lf->common);
TAILQ_INIT(&lf->modules);
lf->priv = priv;
lf->ops = ops;
TAILQ_INSERT_TAIL(&files, lf, link);
out:
lockmgr(&lock, LK_RELEASE, 0, curproc);
return lf;
}
int
linker_file_unload(linker_file_t file)
{
module_t mod, next;
struct common_symbol* cp;
int error = 0;
int i;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
KLD_DPF(FILE, ("linker_file_unload: lf->refs=%d\n", file->refs));
LK_RETRY is a vn_lock() flag, not one for lockmgr().
1999-04-06 03:02:11 +00:00
lockmgr(&lock, LK_EXCLUSIVE, 0, curproc);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
if (file->refs == 1) {
KLD_DPF(FILE, ("linker_file_unload: file is unloading, informing modules\n"));
/*
* Inform any modules associated with this file.
*/
for (mod = TAILQ_FIRST(&file->modules); mod; mod = next) {
next = module_getfnext(mod);
/*
* Give the module a chance to veto the unload.
*/
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = module_unload(mod)) != 0) {
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
KLD_DPF(FILE, ("linker_file_unload: module %x vetoes unload\n",
mod));
lockmgr(&lock, LK_RELEASE, 0, curproc);
goto out;
}
module_release(mod);
}
}
file->refs--;
if (file->refs > 0) {
lockmgr(&lock, LK_RELEASE, 0, curproc);
goto out;
}
Don't try to call SYSUNINIT functions if there was a link error. Reviewed by: Peter Wemm <peter@netplex.com.au>
1999-01-25 08:42:24 +00:00
/* Don't try to run SYSUNINITs if we are unloaded due to a link error */
* Change sysctl from using linker_set to construct its tree using SLISTs. This makes it possible to change the sysctl tree at runtime. * Change KLD to find and register any sysctl nodes contained in the loaded file and to unregister them when the file is unloaded. Reviewed by: Archie Cobbs <archie@whistle.com>, Peter Wemm <peter@netplex.com.au> (well they looked at it anyway)
1999-02-16 10:49:55 +00:00
if (file->flags & LINKER_FILE_LINKED) {
Don't try to call SYSUNINIT functions if there was a link error. Reviewed by: Peter Wemm <peter@netplex.com.au>
1999-01-25 08:42:24 +00:00
linker_file_sysuninit(file);
* Change sysctl from using linker_set to construct its tree using SLISTs. This makes it possible to change the sysctl tree at runtime. * Change KLD to find and register any sysctl nodes contained in the loaded file and to unregister them when the file is unloaded. Reviewed by: Archie Cobbs <archie@whistle.com>, Peter Wemm <peter@netplex.com.au> (well they looked at it anyway)
1999-02-16 10:49:55 +00:00
linker_file_unregister_sysctls(file);
}
Arrange for unload-time linker set hooks to be called. While cut/pasting some code, I changed the original to be consistant with the rest of the file rather than duplicating the problems.
1998-11-10 08:49:28 +00:00
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
TAILQ_REMOVE(&files, file, link);
lockmgr(&lock, LK_RELEASE, 0, curproc);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
for (i = 0; i < file->ndeps; i++)
linker_file_unload(file->deps[i]);
free(file->deps, M_LINKER);
for (cp = STAILQ_FIRST(&file->common); cp;
cp = STAILQ_FIRST(&file->common)) {
STAILQ_REMOVE(&file->common, cp, common_symbol, link);
free(cp, M_LINKER);
}
file->ops->unload(file);
free(file, M_LINKER);
out:
return error;
}
int
linker_file_add_dependancy(linker_file_t file, linker_file_t dep)
{
linker_file_t* newdeps;
newdeps = malloc((file->ndeps + 1) * sizeof(linker_file_t*),
M_LINKER, M_WAITOK);
if (newdeps == NULL)
return ENOMEM;
- bzero() after malloc(). This is especially obvious when kern_malloc is compiled with DIAGNOSTIC. - Don't break from the preload module processing loop prematurely.
1998-10-15 17:12:12 +00:00
bzero(newdeps, (file->ndeps + 1) * sizeof(linker_file_t*));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
if (file->deps) {
bcopy(file->deps, newdeps, file->ndeps * sizeof(linker_file_t*));
free(file->deps, M_LINKER);
}
file->deps = newdeps;
file->deps[file->ndeps] = dep;
file->ndeps++;
return 0;
}
caddr_t
linker_file_lookup_symbol(linker_file_t file, const char* name, int deps)
{
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile. This commit includes significant work to proper handle const arguments for the DDB symbol routines.
1999-01-27 23:45:44 +00:00
c_linker_sym_t sym;
Modify the internal interfaces to the kernel linker to make it possible for DDB to use its symbol tables.
1998-08-12 08:44:21 +00:00
linker_symval_t symval;
Relax linkage symbol scope restrictions to be more compatable with that of shared libraries.
1999-01-19 22:26:46 +00:00
linker_file_t lf;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
caddr_t address;
size_t common_size = 0;
int i;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
KLD_DPF(SYM, ("linker_file_lookup_symbol: file=%x, name=%s, deps=%d\n",
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
file, name, deps));
Modify the internal interfaces to the kernel linker to make it possible for DDB to use its symbol tables.
1998-08-12 08:44:21 +00:00
if (file->ops->lookup_symbol(file, name, &sym) == 0) {
file->ops->symbol_values(file, sym, &symval);
if (symval.value == 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
/*
* For commons, first look them up in the dependancies and
* only allocate space if not found there.
*/
Modify the internal interfaces to the kernel linker to make it possible for DDB to use its symbol tables.
1998-08-12 08:44:21 +00:00
common_size = symval.size;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
else {
KLD_DPF(SYM, ("linker_file_lookup_symbol: symbol.value=%x\n", symval.value));
Modify the internal interfaces to the kernel linker to make it possible for DDB to use its symbol tables.
1998-08-12 08:44:21 +00:00
return symval.value;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
}
Modify the internal interfaces to the kernel linker to make it possible for DDB to use its symbol tables.
1998-08-12 08:44:21 +00:00
}
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
Relax linkage symbol scope restrictions to be more compatable with that of shared libraries.
1999-01-19 22:26:46 +00:00
if (deps) {
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
for (i = 0; i < file->ndeps; i++) {
address = linker_file_lookup_symbol(file->deps[i], name, 0);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
if (address) {
KLD_DPF(SYM, ("linker_file_lookup_symbol: deps value=%x\n", address));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return address;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
}
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
}
Relax linkage symbol scope restrictions to be more compatable with that of shared libraries.
1999-01-19 22:26:46 +00:00
/* If we have not found it in the dependencies, search globally */
for (lf = TAILQ_FIRST(&files); lf; lf = TAILQ_NEXT(lf, link)) {
/* But skip the current file if it's on the list */
if (lf == file)
continue;
/* And skip the files we searched above */
for (i = 0; i < file->ndeps; i++)
if (lf == file->deps[i])
break;
if (i < file->ndeps)
continue;
address = linker_file_lookup_symbol(lf, name, 0);
if (address) {
KLD_DPF(SYM, ("linker_file_lookup_symbol: global value=%x\n", address));
return address;
}
}
}
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
if (common_size > 0) {
/*
* This is a common symbol which was not found in the
* dependancies. We maintain a simple common symbol table in
* the file object.
*/
struct common_symbol* cp;
for (cp = STAILQ_FIRST(&file->common); cp;
cp = STAILQ_NEXT(cp, link))
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
if (!strcmp(cp->name, name)) {
KLD_DPF(SYM, ("linker_file_lookup_symbol: old common value=%x\n", cp->address));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return cp->address;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
}
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
/*
* Round the symbol size up to align.
*/
common_size = (common_size + sizeof(int) - 1) & -sizeof(int);
cp = malloc(sizeof(struct common_symbol)
+ common_size
+ strlen(name) + 1,
M_LINKER, M_WAITOK);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
if (!cp) {
KLD_DPF(SYM, ("linker_file_lookup_symbol: nomem\n"));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return 0;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
}
- bzero() after malloc(). This is especially obvious when kern_malloc is compiled with DIAGNOSTIC. - Don't break from the preload module processing loop prematurely.
1998-10-15 17:12:12 +00:00
bzero(cp, sizeof(struct common_symbol) + common_size + strlen(name)+ 1);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
cp->address = (caddr_t) (cp + 1);
cp->name = cp->address + common_size;
strcpy(cp->name, name);
bzero(cp->address, common_size);
STAILQ_INSERT_TAIL(&file->common, cp, link);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
KLD_DPF(SYM, ("linker_file_lookup_symbol: new common value=%x\n", cp->address));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return cp->address;
}
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
KLD_DPF(SYM, ("linker_file_lookup_symbol: fail\n"));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return 0;
}
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
#ifdef DDB
/*
* DDB Helpers. DDB has to look across multiple files with their own
* symbol tables and string tables.
*
* Note that we do not obey list locking protocols here. We really don't
* need DDB to hang because somebody's got the lock held. We'll take the
* chance that the files list is inconsistant instead.
*/
int
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile. This commit includes significant work to proper handle const arguments for the DDB symbol routines.
1999-01-27 23:45:44 +00:00
linker_ddb_lookup(const char *symstr, c_linker_sym_t *sym)
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
{
linker_file_t lf;
for (lf = TAILQ_FIRST(&files); lf; lf = TAILQ_NEXT(lf, link)) {
if (lf->ops->lookup_symbol(lf, symstr, sym) == 0)
return 0;
}
return ENOENT;
}
int
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile. This commit includes significant work to proper handle const arguments for the DDB symbol routines.
1999-01-27 23:45:44 +00:00
linker_ddb_search_symbol(caddr_t value, c_linker_sym_t *sym, long *diffp)
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
{
linker_file_t lf;
u_long off = (u_long)value;
u_long diff, bestdiff;
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile. This commit includes significant work to proper handle const arguments for the DDB symbol routines.
1999-01-27 23:45:44 +00:00
c_linker_sym_t best;
c_linker_sym_t es;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
best = 0;
bestdiff = off;
for (lf = TAILQ_FIRST(&files); lf; lf = TAILQ_NEXT(lf, link)) {
if (lf->ops->search_symbol(lf, value, &es, &diff) != 0)
continue;
if (es != 0 && diff < bestdiff) {
best = es;
bestdiff = diff;
}
if (bestdiff == 0)
break;
}
if (best) {
*sym = best;
*diffp = bestdiff;
return 0;
} else {
*sym = 0;
*diffp = off;
return ENOENT;
}
}
int
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile. This commit includes significant work to proper handle const arguments for the DDB symbol routines.
1999-01-27 23:45:44 +00:00
linker_ddb_symbol_values(c_linker_sym_t sym, linker_symval_t *symval)
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
{
linker_file_t lf;
for (lf = TAILQ_FIRST(&files); lf; lf = TAILQ_NEXT(lf, link)) {
if (lf->ops->symbol_values(lf, sym, symval) == 0)
return 0;
}
return ENOENT;
}
#endif
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
/*
* Syscalls.
*/
int
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
kldload(struct proc* p, struct kldload_args* uap)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
{
Don't allow more than one module with the same name to be loaded. Make kldfind ignore the path when searching for a loaded module. Submitted by: John Birrell (jb@freebsd.org)
1999-01-05 20:24:28 +00:00
char* filename = NULL, *modulename;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
linker_file_t lf;
int error = 0;
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = -1;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
if (securelevel > 0)
return EPERM;
Suser() simplification: 1: s/suser/suser_xxx/ 2: Add new function: suser(struct proc *), prototyped in <sys/proc.h>. 3: s/suser_xxx(\([a-zA-Z0-9_]*\)->p_ucred, \&\1->p_acflag)/suser(\1)/ The remaining suser_xxx() calls will be scrutinized and dealt with later. There may be some unneeded #include <sys/cred.h>, but they are left as an exercise for Bruce. More changes to the suser() API will come along with the "jail" code.
1999-04-27 11:18:52 +00:00
if ((error = suser(p)) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return error;
filename = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyinstr(SCARG(uap, file), filename, MAXPATHLEN, NULL)) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
Don't allow more than one module with the same name to be loaded. Make kldfind ignore the path when searching for a loaded module. Submitted by: John Birrell (jb@freebsd.org)
1999-01-05 20:24:28 +00:00
/* Can't load more than one module with the same name */
modulename = rindex(filename, '/');
if (modulename == NULL)
modulename = filename;
A correction to the code which attempts to prevent the same module being loaded twice. It used rindex() to strip the pathname but failed to account for the fact that rindex() will return a pointer to the '/', not the first character of the filename. Submitted by: Nick Hibma <hibma@skylink.it>
1999-02-20 21:22:00 +00:00
else
modulename++;
Don't allow more than one module with the same name to be loaded. Make kldfind ignore the path when searching for a loaded module. Submitted by: John Birrell (jb@freebsd.org)
1999-01-05 20:24:28 +00:00
if (linker_find_file_by_name(modulename)) {
error = EEXIST;
goto out;
}
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = linker_load_file(filename, &lf)) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
lf->userrefs++;
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = lf->id;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
out:
if (filename)
free(filename, M_TEMP);
return error;
}
int
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
kldunload(struct proc* p, struct kldunload_args* uap)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
{
linker_file_t lf;
int error = 0;
if (securelevel > 0)
return EPERM;
Suser() simplification: 1: s/suser/suser_xxx/ 2: Add new function: suser(struct proc *), prototyped in <sys/proc.h>. 3: s/suser_xxx(\([a-zA-Z0-9_]*\)->p_ucred, \&\1->p_acflag)/suser(\1)/ The remaining suser_xxx() calls will be scrutinized and dealt with later. There may be some unneeded #include <sys/cred.h>, but they are left as an exercise for Bruce. More changes to the suser() API will come along with the "jail" code.
1999-04-27 11:18:52 +00:00
if ((error = suser(p)) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return error;
lf = linker_find_file_by_id(SCARG(uap, fileid));
if (lf) {
KLD_DPF(FILE, ("kldunload: lf->userrefs=%d\n", lf->userrefs));
if (lf->userrefs == 0) {
Update userref handling after discussion with submitter of previous patch. lf can't be dereferenced after the unload attempt, in case it was freed. Instead, decrement first and back it out if the unload failed. This should be relatively immune to races caused by the user since the userref count will be zero for the duration of the actual unloading and will stop further kldunload attempts. Submitted by: Ustimenko Semen <semen@iclub.nsu.ru>
1999-01-23 03:45:22 +00:00
printf("linkerunload: attempt to unload file that was loaded by the kernel\n");
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
error = EBUSY;
goto out;
}
Update userref handling after discussion with submitter of previous patch. lf can't be dereferenced after the unload attempt, in case it was freed. Instead, decrement first and back it out if the unload failed. This should be relatively immune to races caused by the user since the userref count will be zero for the duration of the actual unloading and will stop further kldunload attempts. Submitted by: Ustimenko Semen <semen@iclub.nsu.ru>
1999-01-23 03:45:22 +00:00
lf->userrefs--;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
error = linker_file_unload(lf);
Don't decrement userrefs unless the file was actually was unloaded. Submitted by: Ustimenko Semen <semen@iclub.nsu.ru>
1999-01-19 16:26:32 +00:00
if (error)
Update userref handling after discussion with submitter of previous patch. lf can't be dereferenced after the unload attempt, in case it was freed. Instead, decrement first and back it out if the unload failed. This should be relatively immune to races caused by the user since the userref count will be zero for the duration of the actual unloading and will stop further kldunload attempts. Submitted by: Ustimenko Semen <semen@iclub.nsu.ru>
1999-01-23 03:45:22 +00:00
lf->userrefs++;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
} else
error = ENOENT;
out:
return error;
}
int
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
kldfind(struct proc* p, struct kldfind_args* uap)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
{
Don't allow more than one module with the same name to be loaded. Make kldfind ignore the path when searching for a loaded module. Submitted by: John Birrell (jb@freebsd.org)
1999-01-05 20:24:28 +00:00
char* filename = NULL, *modulename;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
linker_file_t lf;
int error = 0;
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = -1;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
filename = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyinstr(SCARG(uap, file), filename, MAXPATHLEN, NULL)) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
Don't allow more than one module with the same name to be loaded. Make kldfind ignore the path when searching for a loaded module. Submitted by: John Birrell (jb@freebsd.org)
1999-01-05 20:24:28 +00:00
modulename = rindex(filename, '/');
if (modulename == NULL)
modulename = filename;
lf = linker_find_file_by_name(modulename);
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
if (lf)
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = lf->id;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
else
error = ENOENT;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
out:
if (filename)
free(filename, M_TEMP);
return error;
}
int
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
kldnext(struct proc* p, struct kldnext_args* uap)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
{
linker_file_t lf;
int error = 0;
if (SCARG(uap, fileid) == 0) {
if (TAILQ_FIRST(&files))
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = TAILQ_FIRST(&files)->id;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
else
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = 0;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
return 0;
}
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
lf = linker_find_file_by_id(SCARG(uap, fileid));
if (lf) {
if (TAILQ_NEXT(lf, link))
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = TAILQ_NEXT(lf, link)->id;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
else
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = 0;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
} else
error = ENOENT;
return error;
}
int
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
kldstat(struct proc* p, struct kldstat_args* uap)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
{
linker_file_t lf;
int error = 0;
int version;
struct kld_file_stat* stat;
int namelen;
lf = linker_find_file_by_id(SCARG(uap, fileid));
if (!lf) {
error = ENOENT;
goto out;
}
stat = SCARG(uap, stat);
/*
* Check the version of the user's structure.
*/
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyin(&stat->version, &version, sizeof(version))) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
if (version != sizeof(struct kld_file_stat)) {
error = EINVAL;
goto out;
}
namelen = strlen(lf->filename) + 1;
if (namelen > MAXPATHLEN)
namelen = MAXPATHLEN;
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyout(lf->filename, &stat->name[0], namelen)) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyout(&lf->refs, &stat->refs, sizeof(int))) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyout(&lf->id, &stat->id, sizeof(int))) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyout(&lf->address, &stat->address, sizeof(caddr_t))) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyout(&lf->size, &stat->size, sizeof(size_t))) != 0)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
goto out;
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = 0;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
out:
return error;
}
int
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
kldfirstmod(struct proc* p, struct kldfirstmod_args* uap)
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
{
linker_file_t lf;
int error = 0;
lf = linker_find_file_by_id(SCARG(uap, fileid));
if (lf) {
if (TAILQ_FIRST(&lf->modules))
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = module_getid(TAILQ_FIRST(&lf->modules));
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
else
Move the "retval" (3rd) parameter from all syscall functions and put it in struct proc instead. This fixes a boatload of compiler warning, and removes a lot of cruft from the sources. I have not removed the /*ARGSUSED*/, they will require some looking at. libkvm, ps and other userland struct proc frobbing programs will need recompiled.
1997-11-06 19:29:57 +00:00
p->p_retval[0] = 0;
This is the kernel linker. To use it, you will first need to apply the patches in freefall:/home/dfr/ld.diffs to your ld sources and set BINFORMAT to aoutkld when linking the kernel. Library changes and userland utilities will appear in a later commit.
1997-05-07 16:05:47 +00:00
} else
error = ENOENT;
return error;
}
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
kldsym(2) prototype implementation
1998-11-11 13:04:40 +00:00
int
kldsym(struct proc *p, struct kldsym_args *uap)
{
char *symstr = NULL;
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile. This commit includes significant work to proper handle const arguments for the DDB symbol routines.
1999-01-27 23:45:44 +00:00
c_linker_sym_t sym;
kldsym(2) prototype implementation
1998-11-11 13:04:40 +00:00
linker_symval_t symval;
linker_file_t lf;
struct kld_sym_lookup lookup;
int error = 0;
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyin(SCARG(uap, data), &lookup, sizeof(lookup))) != 0)
kldsym(2) prototype implementation
1998-11-11 13:04:40 +00:00
goto out;
if (lookup.version != sizeof(lookup) || SCARG(uap, cmd) != KLDSYM_LOOKUP) {
error = EINVAL;
goto out;
}
symstr = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-27 21:50:00 +00:00
if ((error = copyinstr(lookup.symname, symstr, MAXPATHLEN, NULL)) != 0)
kldsym(2) prototype implementation
1998-11-11 13:04:40 +00:00
goto out;
if (SCARG(uap, fileid) != 0) {
lf = linker_find_file_by_id(SCARG(uap, fileid));
if (lf == NULL) {
error = ENOENT;
goto out;
}
if (lf->ops->lookup_symbol(lf, symstr, &sym) == 0 &&
lf->ops->symbol_values(lf, sym, &symval) == 0) {
lookup.symvalue = (u_long)symval.value;
lookup.symsize = symval.size;
error = copyout(&lookup, SCARG(uap, data), sizeof(lookup));
} else
error = ENOENT;
} else {
for (lf = TAILQ_FIRST(&files); lf; lf = TAILQ_NEXT(lf, link)) {
if (lf->ops->lookup_symbol(lf, symstr, &sym) == 0 &&
lf->ops->symbol_values(lf, sym, &symval) == 0) {
lookup.symvalue = (u_long)symval.value;
lookup.symsize = symval.size;
error = copyout(&lookup, SCARG(uap, data), sizeof(lookup));
break;
}
}
if (!lf)
error = ENOENT;
}
out:
if (symstr)
free(symstr, M_TEMP);
return error;
}
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
/*
* Preloaded module support
*/
static void
linker_preload(void* arg)
{
caddr_t modptr;
char *modname;
Display module type as well as module name when we find one preloaded.
1998-10-10 02:29:07 +00:00
char *modtype;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
linker_file_t lf;
linker_class_t lc;
int error;
struct linker_set *sysinits;
struct sysinit **sipp;
First stages of a module dependency cleanup. This part fixes a particularly annoying hack, namely having the linker bash the moduledata to set the container pointer, preventing it being const. In the process, a stack of warnings were fixed and will probably allow a revisit of the const C_SYSINIT() changes. This explicitly registers modules in files or preload areas with the module system first, and let them initialize via SYSINIT/DECLARE_MODULE later in their SI_ORDER_xxx order. The kludge of finding the containing file is no longer needed since the registration of modules onto the modules list is done in the context of initializing the linker file.
1999-05-08 13:01:59 +00:00
const moduledata_t *moddata;
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
modptr = NULL;
while ((modptr = preload_search_next_name(modptr)) != NULL) {
modname = (char *)preload_search_info(modptr, MODINFO_NAME);
Display module type as well as module name when we find one preloaded.
1998-10-10 02:29:07 +00:00
modtype = (char *)preload_search_info(modptr, MODINFO_TYPE);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
if (modname == NULL) {
Don't put 0x in front of %p, it does it already. Submitted by: Brian Feldman <green@janus.syracuse.net>
1998-10-24 18:35:09 +00:00
printf("Preloaded module at %p does not have a name!\n", modptr);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
continue;
}
Display module type as well as module name when we find one preloaded.
1998-10-10 02:29:07 +00:00
if (modtype == NULL) {
Don't put 0x in front of %p, it does it already. Submitted by: Brian Feldman <green@janus.syracuse.net>
1998-10-24 18:35:09 +00:00
printf("Preloaded module at %p does not have a type!\n", modptr);
Display module type as well as module name when we find one preloaded.
1998-10-10 02:29:07 +00:00
continue;
}
Don't put 0x in front of %p, it does it already. Submitted by: Brian Feldman <green@janus.syracuse.net>
1998-10-24 18:35:09 +00:00
printf("Preloaded %s \"%s\" at %p.\n", modtype, modname, modptr);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
lf = linker_find_file_by_name(modname);
if (lf) {
lf->userrefs++;
continue;
}
lf = NULL;
for (lc = TAILQ_FIRST(&classes); lc; lc = TAILQ_NEXT(lc, link)) {
error = lc->ops->load_file(modname, &lf);
if (error) {
lf = NULL;
break;
}
}
if (lf) {
lf->userrefs++;
sysinits = (struct linker_set*)
linker_file_lookup_symbol(lf, "sysinit_set", 0);
if (sysinits) {
/* HACK ALERT!
* This is to set the sysinit moduledata so that the module
* can attach itself to the correct containing file.
* The sysinit could be run at *any* time.
*/
for (sipp = (struct sysinit **)sysinits->ls_items; *sipp; sipp++) {
if ((*sipp)->func == module_register_init) {
moddata = (*sipp)->udata;
First stages of a module dependency cleanup. This part fixes a particularly annoying hack, namely having the linker bash the moduledata to set the container pointer, preventing it being const. In the process, a stack of warnings were fixed and will probably allow a revisit of the const C_SYSINIT() changes. This explicitly registers modules in files or preload areas with the module system first, and let them initialize via SYSINIT/DECLARE_MODULE later in their SI_ORDER_xxx order. The kludge of finding the containing file is no longer needed since the registration of modules onto the modules list is done in the context of initializing the linker file.
1999-05-08 13:01:59 +00:00
error = module_register(moddata, lf);
if (error)
printf("Preloaded %s \"%s\" failed to register: %d\n",
modtype, modname, error);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
}
}
sysinit_add((struct sysinit **)sysinits->ls_items);
}
* Change sysctl from using linker_set to construct its tree using SLISTs. This makes it possible to change the sysctl tree at runtime. * Change KLD to find and register any sysctl nodes contained in the loaded file and to unregister them when the file is unloaded. Reviewed by: Archie Cobbs <archie@whistle.com>, Peter Wemm <peter@netplex.com.au> (well they looked at it anyway)
1999-02-16 10:49:55 +00:00
linker_file_register_sysctls(lf);
Use Mike Smith's linker module search path code. Implement preloading in a fairly MI way, assuming the information is prepared. DDB interface helpers.. Provide some support for db_kld.c so that we don't have to export too much detail. Debugging and cosmetic nits left in from development.. The other half of the containing file hack so modules can associate themselves with their "file".
1998-10-10 00:07:53 +00:00
}
}
}
SYSINIT(preload, SI_SUB_KLD, SI_ORDER_MIDDLE, linker_preload, 0);
/*
* Search for a not-loaded module by name.
*
* Modules may be found in the following locations:
*
* - preloaded (result is just the module name)
* - on disk (result is full path to module)
*
* If the module name is qualified in any way (contains path, etc.)
* the we simply return a copy of it.
*
* The search path can be manipulated via sysctl. Note that we use the ';'
* character as a separator to be consistent with the bootloader.
*/
static char linker_path[MAXPATHLEN + 1] = "/;/boot/;/modules/";
SYSCTL_STRING(_kern, OID_AUTO, module_path, CTLFLAG_RW, linker_path,
sizeof(linker_path), "module load search path");
static char *
linker_strdup(const char *str)
{
char *result;
if ((result = malloc((strlen(str) + 1), M_LINKER, M_WAITOK)) != NULL)
strcpy(result, str);
return(result);
}
char *
linker_search_path(const char *name)
{
struct nameidata nd;
struct proc *p = curproc; /* XXX */
char *cp, *ep, *result;
int error;
enum vtype type;
/* qualified at all? */
if (index(name, '/'))
return(linker_strdup(name));
/* traverse the linker path */
cp = linker_path;
for (;;) {
/* find the end of this component */
for (ep = cp; (*ep != 0) && (*ep != ';'); ep++)
;
result = malloc((strlen(name) + (ep - cp) + 1), M_LINKER, M_WAITOK);
if (result == NULL) /* actually ENOMEM */
return(NULL);
strncpy(result, cp, ep - cp);
strcpy(result + (ep - cp), name);
/*
* Attempt to open the file, and return the path if we succeed and it's
* a regular file.
*/
NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, result, p);
error = vn_open(&nd, FREAD, 0);
if (error == 0) {
type = nd.ni_vp->v_type;
VOP_UNLOCK(nd.ni_vp, 0, p);
vn_close(nd.ni_vp, FREAD, p->p_ucred, p);
if (type == VREG)
return(result);
}
free(result, M_LINKER);
if (*ep == 0)
break;
cp = ep + 1;
}
return(NULL);
}
Reference in New Issue Copy Permalink