d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
5e20c11f19
freebsd-dev/sys/kern/link_aout.c

591 lines
15 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
/*-
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
* Copyright (c) 1997-2000 Doug Rabson
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
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
$Id$ -> $FreeBSD$
1999-08-28 01:08:13 +00:00
* $FreeBSD$
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 the conditionaal so that we only build this on i386 instead of trying to build it on all non-alpha arches.
2000-09-29 13:32:24 +00:00
#ifdef __i386__
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
Make ELF kernels build again.
1998-08-16 04:19:03 +00:00
#define FREEBSD_AOUT 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
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/proc.h>
#include <sys/namei.h>
#include <sys/fcntl.h>
#include <sys/vnode.h>
#include <sys/linker.h>
Add enough include files to make this actually compile on an a.out system.
1999-05-15 23:18:32 +00:00
Introduce NDFREE (and remove VOP_ABORTOP)
1999-12-15 23:02:35 +00:00
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
#include "linker_if.h"
Add enough include files to make this actually compile on an a.out system.
1999-05-15 23:18:32 +00:00
#ifndef __ELF__
#include <vm/vm.h>
#include <vm/pmap.h>
#include <machine/vmparam.h>
#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
#include <a.out.h>
#include <link.h>
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
typedef struct aout_file {
struct linker_file lf; /* Common fields */
int preloaded; /* Was this pre-loader */
char* address; /* Load address */
struct _dynamic* dynamic; /* Symbol table etc. */
} *aout_file_t;
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
static int link_aout_link_preload(linker_class_t lc,
const char* modname, linker_file_t*);
static int link_aout_link_preload_finish(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
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
static int link_aout_load_file(linker_class_t lc, const char*, 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
static int link_aout_lookup_symbol(linker_file_t, const char*,
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-28 00:57:57 +00:00
c_linker_sym_t*);
static int link_aout_symbol_values(linker_file_t file, 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);
static int link_aout_search_symbol(linker_file_t lf, caddr_t value,
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-28 00:57:57 +00:00
c_linker_sym_t* sym, long* diffp);
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
static void link_aout_unload_file(linker_file_t);
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
static void link_aout_unload_preload(linker_file_t);
With this commit, I hereby pronounce gensetdefs past its use-by date. Replace the a.out emulation of 'struct linker_set' with something a little more flexible. <sys/linker_set.h> now provides macros for accessing elements and completely hides the implementation. The linker_set.h macros have been on the back burner in various forms since 1998 and has ideas and code from Mike Smith (SET_FOREACH()), John Polstra (ELF clue) and myself (cleaned up API and the conversion of the rest of the kernel to use it). The macros declare a strongly typed set. They return elements with the type that you declare the set with, rather than a generic void *. For ELF, we use the magic ld symbols (__start_<setname> and __stop_<setname>). Thanks to Richard Henderson <rth@redhat.com> for the trick about how to force ld to provide them for kld's. For a.out, we use the old linker_set struct. NOTE: the item lists are no longer null terminated. This is why the code impact is high in certain areas. The runtime linker has a new method to find the linker set boundaries depending on which backend format is in use. linker sets are still module/kld unfriendly and should never be used for anything that may be modular one day. Reviewed by: eivind
2001-06-13 10:58:39 +00:00
static int link_aout_lookup_set(linker_file_t, const char*,
void ***, void ***, int*);
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
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
static kobj_method_t link_aout_methods[] = {
KOBJMETHOD(linker_lookup_symbol, link_aout_lookup_symbol),
KOBJMETHOD(linker_symbol_values, link_aout_symbol_values),
KOBJMETHOD(linker_search_symbol, link_aout_search_symbol),
KOBJMETHOD(linker_unload, link_aout_unload_file),
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
KOBJMETHOD(linker_load_file, link_aout_load_file),
KOBJMETHOD(linker_link_preload, link_aout_link_preload),
KOBJMETHOD(linker_link_preload_finish, link_aout_link_preload_finish),
With this commit, I hereby pronounce gensetdefs past its use-by date. Replace the a.out emulation of 'struct linker_set' with something a little more flexible. <sys/linker_set.h> now provides macros for accessing elements and completely hides the implementation. The linker_set.h macros have been on the back burner in various forms since 1998 and has ideas and code from Mike Smith (SET_FOREACH()), John Polstra (ELF clue) and myself (cleaned up API and the conversion of the rest of the kernel to use it). The macros declare a strongly typed set. They return elements with the type that you declare the set with, rather than a generic void *. For ELF, we use the magic ld symbols (__start_<setname> and __stop_<setname>). Thanks to Richard Henderson <rth@redhat.com> for the trick about how to force ld to provide them for kld's. For a.out, we use the old linker_set struct. NOTE: the item lists are no longer null terminated. This is why the code impact is high in certain areas. The runtime linker has a new method to find the linker set boundaries depending on which backend format is in use. linker sets are still module/kld unfriendly and should never be used for anything that may be modular one day. Reviewed by: eivind
2001-06-13 10:58:39 +00:00
KOBJMETHOD(linker_lookup_set, link_aout_lookup_set),
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
{ 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
};
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
static struct linker_class link_aout_class = {
"a.out", link_aout_methods, sizeof(struct aout_file)
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23: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
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
static int relocate_file(aout_file_t af);
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
/*
* The kernel symbol table starts here.
*/
Manually add an extra _ to _DYNAMIC since it is provided by ld, not gcc. Make the rest compile.
2001-02-25 07:25:05 +00:00
extern struct _dynamic __DYNAMIC;
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 void
link_aout_init(void* arg)
{
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
#ifndef __ELF__
Manually add an extra _ to _DYNAMIC since it is provided by ld, not gcc. Make the rest compile.
2001-02-25 07:25:05 +00:00
struct _dynamic* dp = &__DYNAMIC;
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
#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
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
linker_add_class(&link_aout_class);
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
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
#ifndef __ELF__
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 (dp) {
aout_file_t af;
linker_kernel_file =
Manually add an extra _ to _DYNAMIC since it is provided by ld, not gcc. Make the rest compile.
2001-02-25 07:25:05 +00:00
linker_make_file(kernelname, &link_aout_class);
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 (linker_kernel_file == NULL)
panic("link_aout_init: Can't create linker structures for kernel");
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
af = (aout_file_t) linker_kernel_file;
af->address = 0;
af->dynamic = dp;
Use KERNBASE for the load address of the kernel rather than magic constants as it seems to work.. (at least on i386/elf).
1999-05-08 13:03:49 +00:00
linker_kernel_file->address = (caddr_t) KERNBASE;
linker_kernel_file->size = -(long)linker_kernel_file->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
}
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
#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
}
Initialize the a.out kld loader after elf, so that elf gets first shot at a kldload attempt.
1998-11-03 14:25:21 +00:00
SYSINIT(link_aout, SI_SUB_KLD, SI_ORDER_THIRD, link_aout_init, 0);
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
static int
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
link_aout_link_preload(linker_class_t lc,
const char* filename, linker_file_t* result)
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
{
caddr_t modptr, baseptr;
char *type;
struct exec *ehdr;
aout_file_t af;
linker_file_t lf;
/* Look to see if we have the module preloaded. */
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
modptr = preload_search_by_name(filename);
if (modptr == NULL)
return ENOENT;
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
if (((type = (char *)preload_search_info(modptr, MODINFO_TYPE)) == NULL) ||
strcmp(type, "a.out module") ||
((baseptr = preload_search_info(modptr, MODINFO_ADDR)) == NULL) ||
((ehdr = (struct exec *)preload_search_info(modptr, MODINFO_METADATA | MODINFOMD_AOUTEXEC)) == NULL))
return(0); /* we can't handle this */
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
/* Register with kld */
lf = linker_make_file(filename, &link_aout_class);
if (lf == NULL) {
return(ENOMEM);
}
af = (aout_file_t) lf;
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
/* Looks like we can handle this one */
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
filename = preload_search_info(modptr, MODINFO_NAME);
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
af->preloaded = 1;
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
af->address = baseptr;
/* Assume _DYNAMIC is the first data item. */
af->dynamic = (struct _dynamic*)(af->address + ehdr->a_text);
if (af->dynamic->d_version != LD_VERSION_BSD) {
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
linker_file_unload(lf);
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
return(0); /* we can't handle this */
}
af->dynamic->d_un.d_sdt = (struct section_dispatch_table *)
((char *)af->dynamic->d_un.d_sdt + (vm_offset_t)af->address);
lf->address = af->address;
lf->size = ehdr->a_text + ehdr->a_data + ehdr->a_bss;
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
*result = lf;
return(0);
}
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
static int
link_aout_link_preload_finish(linker_file_t lf)
{
aout_file_t af;
int error;
af = (aout_file_t) lf;
error = relocate_file(af);
if (error) {
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
linker_file_unload(lf);
return(error);
}
return(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
make a couple functions static... also change module_register_static to module_register_init as this function initalizes the module for both dynamic and static modules...
1997-10-24 05:29:07 +00:00
static int
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
link_aout_load_file(linker_class_t lc, const char* filename, linker_file_t* result)
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
{
struct nameidata nd;
KSE Milestone 2 Note ALL MODULES MUST BE RECOMPILED make the kernel aware that there are smaller units of scheduling than the process. (but only allow one thread per process at this time). This is functionally equivalent to teh previousl -current except that there is a thread associated with each process. Sorry john! (your next MFC will be a doosie!) Reviewed by: peter@freebsd.org, dillon@freebsd.org X-MFC after: ha ha ha ha
2001-09-12 08:38:13 +00:00
struct thread *td = curthread; /* XXX */
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 error = 0;
Move the truncation code out of vn_open and into the open system call after the acquisition of any advisory locks. This fix corrects a case in which a process tries to open a file with a non-blocking exclusive lock. Even if it fails to get the lock it would still truncate the file even though its open failed. With this change, the truncation is done only after the lock is successfully acquired. Obtained from: BSD/OS
2000-07-04 03:34:11 +00:00
int resid, flags;
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
struct exec header;
aout_file_t af;
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
linker_file_t 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
KSE Milestone 2 Note ALL MODULES MUST BE RECOMPILED make the kernel aware that there are smaller units of scheduling than the process. (but only allow one thread per process at this time). This is functionally equivalent to teh previousl -current except that there is a thread associated with each process. Sorry john! (your next MFC will be a doosie!) Reviewed by: peter@freebsd.org, dillon@freebsd.org X-MFC after: ha ha ha ha
2001-09-12 08:38:13 +00:00
NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, td);
Move the truncation code out of vn_open and into the open system call after the acquisition of any advisory locks. This fix corrects a case in which a process tries to open a file with a non-blocking exclusive lock. Even if it fails to get the lock it would still truncate the file even though its open failed. With this change, the truncation is done only after the lock is successfully acquired. Obtained from: BSD/OS
2000-07-04 03:34:11 +00:00
flags = FREAD;
error = vn_open(&nd, &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
if (error)
return error;
Introduce NDFREE (and remove VOP_ABORTOP)
1999-12-15 23:02:35 +00:00
NDFREE(&nd, NDF_ONLY_PNBUF);
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
/*
* Read the a.out header from the file.
*/
error = vn_rdwr(UIO_READ, nd.ni_vp, (void*) &header, sizeof header, 0,
Simple p_ucred -> td_ucred changes to start using the per-thread ucred reference.
2002-02-27 18:32:23 +00:00
UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, &resid, td);
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 (error)
goto out;
if (N_BADMAG(header) || !(N_GETFLAG(header) & EX_DYNAMIC))
goto out;
/*
* We have an a.out file, so make some space to read it in.
*/
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
lf = linker_make_file(filename, &link_aout_class);
if (lf == NULL) {
error = ENOMEM;
goto out;
}
af = (aout_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
af->address = malloc(header.a_text + header.a_data + header.a_bss,
M_LINKER, M_WAITOK);
/*
* Read the text and data sections and zero the bss.
*/
error = vn_rdwr(UIO_READ, nd.ni_vp, (void*) af->address,
header.a_text + header.a_data, 0,
Simple p_ucred -> td_ucred changes to start using the per-thread ucred reference.
2002-02-27 18:32:23 +00:00
UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, &resid, td);
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 (error)
goto out;
bzero(af->address + header.a_text + header.a_data, header.a_bss);
/*
* Assume _DYNAMIC is the first data item.
*/
af->dynamic = (struct _dynamic*) (af->address + header.a_text);
if (af->dynamic->d_version != LD_VERSION_BSD) {
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
error = ENOEXEC;
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 depend on gcc's feature of casting lvalues.
1998-07-07 04:36:23 +00:00
af->dynamic->d_un.d_sdt = (struct section_dispatch_table *)
((char *)af->dynamic->d_un.d_sdt + (vm_offset_t)af->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
lf->address = af->address;
lf->size = header.a_text + header.a_data + header.a_bss;
Fix a number of misspellings of "dependency" and "dependencies" in comments and function names. PR: kern/8589 Submitted by: Rajesh Vaidheeswarran <rv@fore.com>
2001-11-16 21:08:40 +00:00
error = linker_load_dependencies(lf);
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
if (error)
goto out;
error = relocate_file(af);
if (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
goto out;
*result = lf;
out:
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
if (error && lf)
linker_file_unload(lf);
KSE Milestone 2 Note ALL MODULES MUST BE RECOMPILED make the kernel aware that there are smaller units of scheduling than the process. (but only allow one thread per process at this time). This is functionally equivalent to teh previousl -current except that there is a thread associated with each process. Sorry john! (your next MFC will be a doosie!) Reviewed by: peter@freebsd.org, dillon@freebsd.org X-MFC after: ha ha ha ha
2001-09-12 08:38:13 +00:00
VOP_UNLOCK(nd.ni_vp, 0, td);
Simple p_ucred -> td_ucred changes to start using the per-thread ucred reference.
2002-02-27 18:32:23 +00:00
vn_close(nd.ni_vp, FREAD, td->td_ucred, td);
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;
}
make a couple functions static... also change module_register_static to module_register_init as this function initalizes the module for both dynamic and static modules...
1997-10-24 05:29:07 +00:00
static void
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
link_aout_unload_file(linker_file_t file)
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
{
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
aout_file_t af = (aout_file_t) file;
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
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
if (af->preloaded) {
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
link_aout_unload_preload(file);
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
return;
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
}
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
if (af->address)
free(af->address, 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
}
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
static void
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
link_aout_unload_preload(linker_file_t file)
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
{
if (file->filename)
preload_delete_name(file->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
/*
* XXX i386 dependant.
*/
static long
read_relocation(struct relocation_info* r, char* addr)
{
int length = r->r_length;
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +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
if (length == 0)
return *(u_char*) addr;
else if (length == 1)
return *(u_short*) addr;
else if (length == 2)
return *(u_int*) addr;
else
printf("link_aout: unsupported relocation size %d\n", r->r_length);
return 0;
}
static void
write_relocation(struct relocation_info* r, char* addr, long value)
{
int length = r->r_length;
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +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
if (length == 0)
*(u_char*) addr = value;
else if (length == 1)
*(u_short*) addr = value;
else if (length == 2)
*(u_int*) addr = value;
else
printf("link_aout: unsupported relocation size %d\n", r->r_length);
}
First round implementation of a fine grain enhanced module to module version dependency system. This isn't quite finished, but it is at a useful stage to do a functional checkpoint. Highlights: - version and dependency metadata is gathered via linker sets, so things are handled the same for static kernels and code built to live in a kld. - The dependencies are at module level (versus at file level). - Dependencies determine kld symbol search order - this means that you cannot link against symbols in another file unless you depend on it. This is so that you cannot accidently unload the target out from underneath the ones referencing it. - It is flexible enough that we can put tags in #include files and macros so that we can get decent hooks for enforcing recompiles on incompatable ABI changes. eg: if we change struct proc, we could force a recompile for all kld's that reference the proc struct. - Tangled dependency references at boot time are sorted. Files are relocated once all their dependencies are already relocated. Caveats: - Loader support is incomplete, but has been worked on seperately. - Actual enforcement of the version number tags is not active yet - just the module dependencies are live. The actual structure of versioning hasn't been agreed on yet. (eg: major.minor, or whatever) - There is some backwards compatability for old modules without metadata but I'm not sure how good it is. This is based on work originally done by Boris Popov (bp@freebsd.org), but I'm not sure he'd recognize much of it now. Don't blame him. :-) Also, ideas have been borrowed from Mike Smith.
2000-04-29 13:19:31 +00:00
#define AOUT_RELOC(af, type, off) (type*) ((af)->address + (off))
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 int
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
relocate_file(aout_file_t af)
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
{
struct relocation_info* rel;
struct relocation_info* erel;
struct relocation_info* r;
struct nzlist* symbolbase;
char* stringbase;
struct nzlist* np;
char* sym;
long relocation;
rel = AOUT_RELOC(af, struct relocation_info, LD_REL(af->dynamic));
erel = AOUT_RELOC(af, struct relocation_info,
LD_REL(af->dynamic) + LD_RELSZ(af->dynamic));
symbolbase = AOUT_RELOC(af, struct nzlist, LD_SYMBOL(af->dynamic));
stringbase = AOUT_RELOC(af, char, LD_STRINGS(af->dynamic));
for (r = rel; r < erel; r++) {
char* addr;
if (r->r_address == 0)
break;
addr = AOUT_RELOC(af, char, r->r_address);
if (r->r_extern) {
np = &symbolbase[r->r_symbolnum];
sym = &stringbase[np->nz_strx];
if (sym[0] != '_') {
printf("link_aout: bad symbol name %s\n", sym);
relocation = 0;
} else
Cast pointers to uintptr_t/intptr_t instead of to u_long/long, respectively. Most of the longs should probably have been u_longs, but this changes is just to prevent warnings about casts between pointers and integers of different sizes, not to fix poorly chosen types.
1998-07-15 02:32:35 +00:00
relocation = (intptr_t)
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
linker_file_lookup_symbol(&af->lf, sym + 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
np->nz_type != (N_SETV+N_EXT));
if (!relocation) {
printf("link_aout: symbol %s not found\n", sym);
return ENOENT;
}
relocation += read_relocation(r, addr);
if (r->r_jmptable) {
printf("link_aout: can't cope with jump table relocations\n");
continue;
}
if (r->r_pcrel)
Cast pointers to uintptr_t/intptr_t instead of to u_long/long, respectively. Most of the longs should probably have been u_longs, but this changes is just to prevent warnings about casts between pointers and integers of different sizes, not to fix poorly chosen types.
1998-07-15 02:32:35 +00:00
relocation -= (intptr_t) af->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 (r->r_copy) {
printf("link_aout: can't cope with copy relocations\n");
continue;
}
write_relocation(r, addr, relocation);
} else {
write_relocation(r, addr,
Cast pointers to uintptr_t/intptr_t instead of to u_long/long, respectively. Most of the longs should probably have been u_longs, but this changes is just to prevent warnings about casts between pointers and integers of different sizes, not to fix poorly chosen types.
1998-07-15 02:32:35 +00:00
(intptr_t)(read_relocation(r, addr) + af->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 0;
}
static long
symbol_hash_value(aout_file_t af, const char* name)
{
long hashval;
const char* p;
hashval = '_'; /* fake a starting '_' for C symbols */
for (p = name; *p; p++)
hashval = (hashval << 1) + *p;
return (hashval & 0x7fffffff) % LD_BUCKETS(af->dynamic);
}
int
link_aout_lookup_symbol(linker_file_t file, const char* name,
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-28 00:57:57 +00:00
c_linker_sym_t* sym)
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
{
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
aout_file_t af = (aout_file_t) file;
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
long hashval;
struct rrs_hash* hashbase;
struct nzlist* symbolbase;
char* stringbase;
struct rrs_hash* hp;
struct nzlist* np;
char* cp;
if (LD_BUCKETS(af->dynamic) == 0)
Change incorrect NULLs to 0s
1999-12-21 11:14:12 +00:00
return 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
hashbase = AOUT_RELOC(af, struct rrs_hash, LD_HASH(af->dynamic));
symbolbase = AOUT_RELOC(af, struct nzlist, LD_SYMBOL(af->dynamic));
stringbase = AOUT_RELOC(af, char, LD_STRINGS(af->dynamic));
restart:
hashval = symbol_hash_value(af, name);
hp = &hashbase[hashval];
if (hp->rh_symbolnum == -1)
return ENOENT;
while (hp) {
np = (struct nzlist *) &symbolbase[hp->rh_symbolnum];
cp = stringbase + np->nz_strx;
/*
* Note: we fake the leading '_' for C symbols.
*/
if (cp[0] == '_' && !strcmp(cp + 1, name))
break;
if (hp->rh_next == 0)
hp = NULL;
else
hp = &hashbase[hp->rh_next];
}
if (hp == NULL)
/*
* Not found.
*/
return ENOENT;
/*
* Check for an aliased symbol, whatever that is.
*/
if (np->nz_type == N_INDR+N_EXT) {
name = stringbase + (++np)->nz_strx + 1; /* +1 for '_' */
goto restart;
}
/*
* Check this is an actual definition of the symbol.
*/
if (np->nz_value == 0)
return ENOENT;
if (np->nz_type == N_UNDF+N_EXT && np->nz_value != 0) {
if (np->nz_other == AUX_FUNC)
/* weak function */
return ENOENT;
}
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
*sym = (linker_sym_t) np;
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;
}
This commit fixes various 64bit portability problems required for FreeBSD/alpha. The most significant item is to change the command argument to ioctl functions from int to u_long. This change brings us inline with various other BSD versions. Driver writers may like to use (__FreeBSD_version == 300003) to detect this change. The prototype FreeBSD/alpha machdep will follow in a couple of days time.
1998-06-07 17:13:14 +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
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
static int
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-28 00:57:57 +00:00
link_aout_symbol_values(linker_file_t file, 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)
{
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
aout_file_t af = (aout_file_t) file;
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-28 00:57:57 +00:00
const struct nzlist* np = (const struct nzlist*) 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
char* stringbase;
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
long numsym = LD_STABSZ(af->dynamic) / sizeof(struct nzlist);
struct nzlist *symbase;
/* Is it one of ours? It could be another module... */
symbase = AOUT_RELOC(af, struct nzlist, LD_SYMBOL(af->dynamic));
if (np < symbase)
return ENOENT;
if ((np - symbase) > numsym)
return ENOENT;
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
stringbase = AOUT_RELOC(af, char, LD_STRINGS(af->dynamic));
symval->name = stringbase + np->nz_strx + 1; /* +1 for '_' */
if (np->nz_type == N_UNDF+N_EXT && np->nz_value != 0) {
symval->value = 0;
symval->size = np->nz_value;
} else {
symval->value = AOUT_RELOC(af, char, np->nz_value);
symval->size = np->nz_size;
}
Updates for KLD backends. - symbol_values checks that the symbol is indeed belonging to the correct symbol and string table pairs before looking up. (since there could be many pairs, and KLD/DDB need to find out). - different ops for files versus preload modules - the unload mechanism is different. (a preloaded module has to be deleted on unload since the in-core image is tainted by relocation and variables used) - Do not build an a.out kernel module if we're running on an elf kernel. :-) Note that it should theoretically be possible to mix a.out and elf KLD modules providing -mno-underscores was used to compile it, or some other symbol conversion takes place. - Support preload modules (even though /boot/loader doesn't yet) - Search the module path when loading files.
1998-10-09 23:49:28 +00:00
return 0;
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
}
static int
link_aout_search_symbol(linker_file_t lf, caddr_t value,
Fix warnings in preparation for adding -Wall -Wcast-qual to the kernel compile
1999-01-28 00:57:57 +00:00
c_linker_sym_t* sym, long* diffp)
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
{
* Rewrite to use kobj(9) instead of hard-coded function tables. * Report link errors to stdout with uprintf() so that the user can see what went wrong (PR kern/9214). * Add support code to allow module symbols to be loaded into GDB using the debugger's "sharedlibrary" command.
2000-04-24 17:08:04 +00:00
aout_file_t af = (aout_file_t) lf;
Use [u]intptr_t instead of [u_]long for casts between pointers and integers. Don't forget to cast to (void *) as well.
1998-08-16 01:21:52 +00:00
u_long off = (uintptr_t) (void *) 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
u_long diff = off;
Fixed a cast of a pointer to an integer of a possibly different size. Fixed casts of non-`void *' pointers to uintptr_t. Fixed related style bugs. This file uses perfectly non-KNF formatting for casts.
1999-12-24 15:33:36 +00:00
u_long sp_nz_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
struct nzlist* sp;
struct nzlist* ep;
struct nzlist* best = 0;
for (sp = AOUT_RELOC(af, struct nzlist, LD_SYMBOL(af->dynamic)),
ep = (struct nzlist *) ((caddr_t) sp + LD_STABSZ(af->dynamic));
sp < ep; sp++) {
if (sp->nz_name == 0)
continue;
Fixed a cast of a pointer to an integer of a possibly different size. Fixed casts of non-`void *' pointers to uintptr_t. Fixed related style bugs. This file uses perfectly non-KNF formatting for casts.
1999-12-24 15:33:36 +00:00
sp_nz_value = sp->nz_value + (uintptr_t) (void *) af->address;
Take a shot at implementing the fix for PR 15014 for the a.out kernel linker as well. PR: 15014 Submitted by: Vladimir N. Silyaev <vns@delta.odessa.ua>
1999-11-28 12:06:29 +00:00
if (off >= sp_nz_value) {
if (off - sp_nz_value < diff) {
diff = off - sp_nz_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
best = sp;
if (diff == 0)
break;
Take a shot at implementing the fix for PR 15014 for the a.out kernel linker as well. PR: 15014 Submitted by: Vladimir N. Silyaev <vns@delta.odessa.ua>
1999-11-28 12:06:29 +00:00
} else if (off - sp_nz_value == diff) {
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
best = sp;
}
}
}
if (best == 0)
*diffp = off;
else
*diffp = diff;
*sym = (linker_sym_t) best;
return 0;
}
With this commit, I hereby pronounce gensetdefs past its use-by date. Replace the a.out emulation of 'struct linker_set' with something a little more flexible. <sys/linker_set.h> now provides macros for accessing elements and completely hides the implementation. The linker_set.h macros have been on the back burner in various forms since 1998 and has ideas and code from Mike Smith (SET_FOREACH()), John Polstra (ELF clue) and myself (cleaned up API and the conversion of the rest of the kernel to use it). The macros declare a strongly typed set. They return elements with the type that you declare the set with, rather than a generic void *. For ELF, we use the magic ld symbols (__start_<setname> and __stop_<setname>). Thanks to Richard Henderson <rth@redhat.com> for the trick about how to force ld to provide them for kld's. For a.out, we use the old linker_set struct. NOTE: the item lists are no longer null terminated. This is why the code impact is high in certain areas. The runtime linker has a new method to find the linker set boundaries depending on which backend format is in use. linker sets are still module/kld unfriendly and should never be used for anything that may be modular one day. Reviewed by: eivind
2001-06-13 10:58:39 +00:00
/*
* Look up a linker set on an a.out + gnu LD system.
*/
struct generic_linker_set {
int ls_length;
void *ls_items[1];
};
static int
link_aout_lookup_set(linker_file_t lf, const char *name,
void ***startp, void ***stopp, int *countp)
{
c_linker_sym_t sym;
linker_symval_t symval;
void **start, **stop;
int error, count;
struct generic_linker_set *setp;
error = link_aout_lookup_symbol(lf, name, &sym);
if (error)
return error;
link_aout_symbol_values(lf, sym, &symval);
if (symval.value == 0)
return ESRCH;
setp = (struct generic_linker_set *)symval.value;
count = setp->ls_length;
start = &setp->ls_items[0];
stop = &setp->ls_items[count];
if (startp)
*startp = start;
if (stopp)
*stopp = stop;
if (countp)
*countp = count;
return 0;
}
Since we used '#ifdef __i386__', don't close with '#endif /* !__alpha__ */'
2001-11-24 10:11:14 +00:00
#endif /* __i386__ */
Reference in New Issue Copy Permalink