mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-11-27 08:00:11 +00:00
Code Issues Releases Activity
main
freebsd/sys/kern/kern_module.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

570 lines
13 KiB
C
Raw Permalink 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
/*-
spdx: The BSD-2-Clause-FreeBSD identifier is obsolete, drop -FreeBSD The SPDX folks have obsoleted the BSD-2-Clause-FreeBSD identifier. Catch up to that fact and revert to their recommended match of BSD-2-Clause. Discussed with: pfg MFC After: 3 days Sponsored by: Netflix
2023-05-10 15:40:58 +00:00
* SPDX-License-Identifier: BSD-2-Clause
sys/kern: adoption of SPDX licensing ID tags. Mainly focus on files that use BSD 2-Clause license, however the tool I was using misidentified many licenses so this was mostly a manual - error prone - task. The Software Package Data Exchange (SPDX) group provides a specification to make it easier for automated tools to detect and summarize well known opensource licenses. We are gradually adopting the specification, noting that the tags are considered only advisory and do not, in any way, superceed or replace the license texts.
2017-11-27 15:20:12 +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
* 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.
*/
#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
Implement a new generic mechanism for attaching handler functions to events, in order to pave the way for removing a number of the ad-hoc implementations currently in use. Retire the at_shutdown family of functions and replace them with new event handler lists. Rework kern_shutdown.c to take greater advantage of the use of event handlers. Reviewed by: green
1999-08-21 06:24:40 +00:00
#include <sys/eventhandler.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/malloc.h>
#include <sys/sysproto.h>
#include <sys/sysent.h>
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
#include <sys/proc.h>
Giant Pushdown. Saved the worst P4 tree breakage for last. reboot() getpriority() setpriority() rtprio() osetrlimit() ogetrlimit() setrlimit() getrlimit() getrusage() getpid() getppid() getpgrp() getpgid() getsid() getgid() getegid() getgroups() setsid() setpgid() setuid() seteuid() setgid() setegid() setgroups() setreuid() setregid() setresuid() setresgid() getresuid() getresgid () __setugid() getlogin() setlogin() modnext() modfnext() modstat() modfind() kldload() kldunload() kldfind() kldnext() kldstat() kldfirstmod() kldsym() getdtablesize() dup2() dup() fcntl() close() ofstat() fstat() nfsstat() fpathconf() flock()
2001-09-01 19:04:37 +00:00
#include <sys/lock.h>
#include <sys/mutex.h>
Don't bother calling the module event handlers from module_shutdown() in the shutdown_final state if the RB_NOSYNC flag is set. The specific motivation in this case is that a system panic in an interrupt context results in a call to module_shutdown(), which calls g_modevent(), which calls g_malloc(..., M_WAITOK), which results in a second panic. While g_modevent() could be fixed to not call malloc() for MOD_SHUTDOWN events (which it doesn't handle in any case), it is probably also a good idea to entirely skip the execution of the module shutdown handlers after a panic. This may be a MFC candidate for RELENG_5.
2004-08-20 21:47:48 +00:00
#include <sys/reboot.h>
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
#include <sys/sx.h>
#include <sys/module.h>
#include <sys/linker.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
Staticize some malloc M_ instances.
2000-12-08 20:09:00 +00:00
static MALLOC_DEFINE(M_MODULE, "module", "module data structures");
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 module {
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
TAILQ_ENTRY(module) link; /* chain together all modules */
TAILQ_ENTRY(module) flink; /* all modules in a file */
struct linker_file *file; /* file which contains this module */
int refs; /* reference count */
int id; /* unique id number */
char *name; /* module name */
modeventhand_t handler; /* event handler */
void *arg; /* argument for handler */
modspecific_t data; /* module specific data */
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
};
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
#define MOD_EVENT(mod, type) (mod)->handler((mod), (type), (mod)->arg)
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
Style fix. Sponsored by: Sandvine Incorporated Requested by: jhb Reviewed by: jhb MFC after: 1 week X-MFC: 215544
2010-11-22 15:28:54 +00:00
static TAILQ_HEAD(modulelist, module) modules;
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
struct sx modules_sx;
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 nextid = 1;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
static void module_shutdown(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
A hack basically.. We have a bunch of code that used to call devsw_module_handler() indirectly and not use the chain arguments. To eliminate this indirection via that function (which does nothing now) without duplicating a modevent handler into all the routines that don't presently have one, supply a NOP (do nothing, return OK) routine which is functionally equivalent to what's there now. This is a hack and is still wrong, because there doesn't appear to be anything to reclaim resources on an unload of a module with one of these in it. I'm not sure whether to make the NOP handler refuse a MOD_UNLOAD event or what.
1999-11-08 06:53:30 +00:00
static int
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
modevent_nop(module_t mod, int what, void *arg)
A hack basically.. We have a bunch of code that used to call devsw_module_handler() indirectly and not use the chain arguments. To eliminate this indirection via that function (which does nothing now) without duplicating a modevent handler into all the routines that don't presently have one, supply a NOP (do nothing, return OK) routine which is functionally equivalent to what's there now. This is a hack and is still wrong, because there doesn't appear to be anything to reclaim resources on an unload of a module with one of these in it. I'm not sure whether to make the NOP handler refuse a MOD_UNLOAD event or what.
1999-11-08 06:53:30 +00:00
{
A module with no modevent function gets modevent_nop() as default. Until now the function has just returned zero for any event, but that is downright wrong for MOD_UNLOAD and not very useful for any future events we add where it may be crucial to be able to tell if the event was unhandled or successful. Change the function to return as follows: MOD_LOAD -> 0 MOD_UNLOAD -> EBUSY anything else -> EOPNOTSUPP
2004-07-14 22:37:36 +00:00
switch(what) {
case MOD_LOAD:
return (0);
case MOD_UNLOAD:
return (EBUSY);
default:
return (EOPNOTSUPP);
}
A hack basically.. We have a bunch of code that used to call devsw_module_handler() indirectly and not use the chain arguments. To eliminate this indirection via that function (which does nothing now) without duplicating a modevent handler into all the routines that don't presently have one, supply a NOP (do nothing, return OK) routine which is functionally equivalent to what's there now. This is a hack and is still wrong, because there doesn't appear to be anything to reclaim resources on an unload of a module with one of these in it. I'm not sure whether to make the NOP handler refuse a MOD_UNLOAD event or what.
1999-11-08 06:53:30 +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 void
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_init(void *arg)
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
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
sx_init(&modules_sx, "module subsystem sx lock");
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
TAILQ_INIT(&modules);
Move the MOD_SHUTDOWN event from shutdown_post_sync to shutdown_final, so that entities that want to use the post_sync hook to write stuff to devices and other tidy-up can do so before the device tree is shot down. eg: da doing a SYNC_CACHE etc. This should get crashdumps working on mpt devices again, and stops the ia64 boxes locking up on regular shutdown when da tries to issue the scsi commands to mpt. Obtained from: njl, gibbs
2003-01-07 22:24:13 +00:00
EVENTHANDLER_REGISTER(shutdown_final, module_shutdown, NULL,
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
SHUTDOWN_PRI_DEFAULT);
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 NULL for SYSINIT's last arg, which is a pointer type Sponsored by: The FreeBSD Foundation
2018-05-18 17:58:09 +00:00
SYSINIT(module, SI_SUB_KLD, SI_ORDER_FIRST, module_init, 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
static void
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_shutdown(void *arg1, int arg2)
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
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_t mod;
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 bother calling the module event handlers from module_shutdown() in the shutdown_final state if the RB_NOSYNC flag is set. The specific motivation in this case is that a system panic in an interrupt context results in a call to module_shutdown(), which calls g_modevent(), which calls g_malloc(..., M_WAITOK), which results in a second panic. While g_modevent() could be fixed to not call malloc() for MOD_SHUTDOWN events (which it doesn't handle in any case), it is probably also a good idea to entirely skip the execution of the module shutdown handlers after a panic. This may be a MFC candidate for RELENG_5.
2004-08-20 21:47:48 +00:00
if (arg2 & RB_NOSYNC)
return;
Address a problem I missed in removing Giant from the kernel linker. Not all of the module event handlers are MP safe yet, so always acquire Giant for now when invoking module event handlers. Eventually we can add an MPSAFE flag or some such and add appropriate locking to all module event handlers.
2006-06-26 18:34:45 +00:00
mtx_lock(&Giant);
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SLOCK;
Style fix. Sponsored by: Sandvine Incorporated Requested by: jhb Reviewed by: jhb MFC after: 1 week X-MFC: 215544
2010-11-22 15:28:54 +00:00
TAILQ_FOREACH_REVERSE(mod, &modules, modulelist, link)
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
MOD_EVENT(mod, MOD_SHUTDOWN);
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SUNLOCK;
Address a problem I missed in removing Giant from the kernel linker. Not all of the module event handlers are MP safe yet, so always acquire Giant for now when invoking module event handlers. Eventually we can add an MPSAFE flag or some such and add appropriate locking to all module event handlers.
2006-06-26 18:34:45 +00:00
mtx_unlock(&Giant);
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
}
void
More -Wall / -Wcast-qual cleanup. Also, EXEC_SET can't use C_DECLARE_MODULE due to the linker_file_sysinit() function making modifications to the data.
1999-01-29 08:36:45 +00:00
module_register_init(const void *arg)
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
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
const moduledata_t *data = (const moduledata_t *)arg;
int error;
module_t mod;
Address a problem I missed in removing Giant from the kernel linker. Not all of the module event handlers are MP safe yet, so always acquire Giant for now when invoking module event handlers. Eventually we can add an MPSAFE flag or some such and add appropriate locking to all module event handlers.
2006-06-26 18:34:45 +00:00
mtx_lock(&Giant);
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SLOCK;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
mod = module_lookupbyname(data->name);
if (mod == NULL)
- Whitespace fixup left over from previous commit. - Remove bogus cast. Submitted by: bde
2002-02-22 13:33:10 +00:00
panic("module_register_init: module named %s not found\n",
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
data->name);
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SUNLOCK;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
error = MOD_EVENT(mod, MOD_LOAD);
if (error) {
MOD_EVENT(mod, MOD_UNLOAD);
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_XLOCK;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_release(mod);
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_XUNLOCK;
Fix a warning. Do not assume pointer == long.
2002-02-26 00:55:27 +00:00
printf("module_register_init: MOD_LOAD (%s, %p, %p) error"
" %d\n", data->name, (void *)data->evhand, data->priv,
- Whitespace fixup left over from previous commit. - Remove bogus cast. Submitted by: bde
2002-02-22 13:33:10 +00:00
error);
When the SYSINIT() to load a module invokes the MOD_LOAD event successfully, move that module to the head of the associated linker file's list of modules. The end result is that once all the modules are loaded, they are sorted in the reverse of their load order. This causes the kernel linker to invoke the MOD_QUIESCE and MOD_UNLOAD events in the reverse of the order that MOD_LOAD was invoked. This means that the ordering of MOD_LOAD events that is set by the SI_* paramters to DECLARE_MODULE() are now honored in the same order they would be for SYSUNINIT() for the MOD_QUIESCE and MOD_UNLOAD events. MFC after: 1 month
2008-12-05 16:47:30 +00:00
} else {
MOD_XLOCK;
if (mod->file) {
/*
Fix a typo.
2012-08-22 20:01:57 +00:00
* Once a module is successfully loaded, move
When the SYSINIT() to load a module invokes the MOD_LOAD event successfully, move that module to the head of the associated linker file's list of modules. The end result is that once all the modules are loaded, they are sorted in the reverse of their load order. This causes the kernel linker to invoke the MOD_QUIESCE and MOD_UNLOAD events in the reverse of the order that MOD_LOAD was invoked. This means that the ordering of MOD_LOAD events that is set by the SI_* paramters to DECLARE_MODULE() are now honored in the same order they would be for SYSUNINIT() for the MOD_QUIESCE and MOD_UNLOAD events. MFC after: 1 month
2008-12-05 16:47:30 +00:00
* it to the head of the module list for this
* linker file. This resorts the list so that
* when the kernel linker iterates over the
* modules to unload them, it will unload them
* in the reverse order they were loaded.
*/
TAILQ_REMOVE(&mod->file->modules, mod, flink);
TAILQ_INSERT_HEAD(&mod->file->modules, mod, flink);
}
MOD_XUNLOCK;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
}
Address a problem I missed in removing Giant from the kernel linker. Not all of the module event handlers are MP safe yet, so always acquire Giant for now when invoking module event handlers. Eventually we can add an MPSAFE flag or some such and add appropriate locking to all module event handlers.
2006-06-26 18:34:45 +00:00
mtx_unlock(&Giant);
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
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
module_register(const moduledata_t *data, linker_file_t container)
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
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
size_t namelen;
module_t newmod;
o Expand an exclusive lock scope to prevent a race between two simultaneous module_register(). Original work done by: Alex Lyashkov Reviewed by: jhb MFC after: 2 weeks
2006-06-15 08:53:09 +00:00
MOD_XLOCK;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
newmod = module_lookupbyname(data->name);
if (newmod != NULL) {
o Expand an exclusive lock scope to prevent a race between two simultaneous module_register(). Original work done by: Alex Lyashkov Reviewed by: jhb MFC after: 2 weeks
2006-06-15 08:53:09 +00:00
MOD_XUNLOCK;
Provide better debug message on kernel module name clash. Reviewed by: kib@ MFC after: 1 month Sponsored by: The FreeBSD Foundation
2015-10-10 09:21:55 +00:00
printf("%s: cannot register %s from %s; already loaded from %s\n",
__func__, data->name, container->filename, newmod->file->filename);
- Fix style further by adding parentheses around return values so that they look like: return (val); instead of: return val;
2002-02-20 16:05:30 +00:00
return (EEXIST);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
}
namelen = strlen(data->name) + 1;
Back out M_* changes, per decision of the TRB. Approved by: trb
2003-02-19 05:47:46 +00:00
newmod = malloc(sizeof(struct module) + namelen, M_MODULE, M_WAITOK);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
newmod->refs = 1;
newmod->id = nextid++;
newmod->name = (char *)(newmod + 1);
strcpy(newmod->name, data->name);
newmod->handler = data->evhand ? data->evhand : modevent_nop;
newmod->arg = data->priv;
bzero(&newmod->data, sizeof(newmod->data));
TAILQ_INSERT_TAIL(&modules, newmod, link);
if (container)
TAILQ_INSERT_TAIL(&container->modules, newmod, flink);
newmod->file = container;
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_XUNLOCK;
- Fix style further by adding parentheses around return values so that they look like: return (val); instead of: return val;
2002-02-20 16:05:30 +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
}
void
module_reference(module_t mod)
{
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_XLOCK_ASSERT;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
MOD_DPF(REFS, ("module_reference: before, refs=%d\n", mod->refs));
mod->refs++;
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
}
void
module_release(module_t mod)
{
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_XLOCK_ASSERT;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
if (mod->refs <= 0)
panic("module_release: bad reference count");
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
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
MOD_DPF(REFS, ("module_release: before, refs=%d\n", mod->refs));
kern: clean up empty lines in .c and .h files
2020-09-01 22:12:32 +00:00
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
mod->refs--;
if (mod->refs == 0) {
TAILQ_REMOVE(&modules, mod, link);
if (mod->file)
TAILQ_REMOVE(&mod->file->modules, mod, flink);
free(mod, M_MODULE);
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
}
}
module_t
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_lookupbyname(const char *name)
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
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_t mod;
int err;
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
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_LOCK_ASSERT;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
TAILQ_FOREACH(mod, &modules, link) {
err = strcmp(mod->name, name);
if (err == 0)
- Fix style further by adding parentheses around return values so that they look like: return (val); instead of: return val;
2002-02-20 16:05:30 +00:00
return (mod);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
}
- Fix style further by adding parentheses around return values so that they look like: return (val); instead of: return val;
2002-02-20 16:05:30 +00:00
return (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
}
module_t
module_lookupbyid(int modid)
{
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
module_t mod;
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
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_LOCK_ASSERT;
TAILQ_FOREACH(mod, &modules, link)
if (mod->id == modid)
return(mod);
return (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
}
int
- Invoke MOD_QUIESCE on all modules in a linker file (kld) before unloading any modules. As a result, if any module veto's an unload request via MOD_QUIESCE, the entire set of modules for that linker file will remain loaded and active now rather than leaving the kld in a weird state where some modules are loaded and some are unloaded. - This also moves the logic for handling the "forced" unload flag out of kern_module.c and into kern_linker.c which is a bit cleaner. - Add a module_name() routine that returns the name of a module and use that instead of printing pointer values in debug messages when a module fails MOD_QUIESCE or MOD_UNLOAD. MFC after: 1 month
2008-12-05 13:40:25 +00:00
module_quiesce(module_t mod)
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
{
Give kldunload a -f(orce) argument. Add a MOD_QUIESCE event for modules. This should return error (EBUSY) of the module is in use. MOD_UNLOAD should now only fail if it is impossible (as opposed to inconvenient) to unload the module. Valid reasons are memory references into the module which cannot be tracked down and eliminated. When kldunloading, we abandon if MOD_UNLOAD fails, and if -force is not given, MOD_QUIESCE failing will also prevent the unload. For backwards compatibility, we treat EOPNOTSUPP from MOD_QUIESCE as success. Document that modules should return EOPNOTSUPP for unknown events.
2004-07-13 19:36:59 +00:00
int error;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
Address a problem I missed in removing Giant from the kernel linker. Not all of the module event handlers are MP safe yet, so always acquire Giant for now when invoking module event handlers. Eventually we can add an MPSAFE flag or some such and add appropriate locking to all module event handlers.
2006-06-26 18:34:45 +00:00
mtx_lock(&Giant);
Give kldunload a -f(orce) argument. Add a MOD_QUIESCE event for modules. This should return error (EBUSY) of the module is in use. MOD_UNLOAD should now only fail if it is impossible (as opposed to inconvenient) to unload the module. Valid reasons are memory references into the module which cannot be tracked down and eliminated. When kldunloading, we abandon if MOD_UNLOAD fails, and if -force is not given, MOD_QUIESCE failing will also prevent the unload. For backwards compatibility, we treat EOPNOTSUPP from MOD_QUIESCE as success. Document that modules should return EOPNOTSUPP for unknown events.
2004-07-13 19:36:59 +00:00
error = MOD_EVENT(mod, MOD_QUIESCE);
- Invoke MOD_QUIESCE on all modules in a linker file (kld) before unloading any modules. As a result, if any module veto's an unload request via MOD_QUIESCE, the entire set of modules for that linker file will remain loaded and active now rather than leaving the kld in a weird state where some modules are loaded and some are unloaded. - This also moves the logic for handling the "forced" unload flag out of kern_module.c and into kern_linker.c which is a bit cleaner. - Add a module_name() routine that returns the name of a module and use that instead of printing pointer values in debug messages when a module fails MOD_QUIESCE or MOD_UNLOAD. MFC after: 1 month
2008-12-05 13:40:25 +00:00
mtx_unlock(&Giant);
Do a pass over all modules in the kernel and make them return EOPNOTSUPP for unknown events. A number of modules return EINVAL in this instance, and I have left those alone for now and instead taught MOD_QUIESCE to accept this as "didn't do anything".
2004-07-15 08:26:07 +00:00
if (error == EOPNOTSUPP || error == EINVAL)
Give kldunload a -f(orce) argument. Add a MOD_QUIESCE event for modules. This should return error (EBUSY) of the module is in use. MOD_UNLOAD should now only fail if it is impossible (as opposed to inconvenient) to unload the module. Valid reasons are memory references into the module which cannot be tracked down and eliminated. When kldunloading, we abandon if MOD_UNLOAD fails, and if -force is not given, MOD_QUIESCE failing will also prevent the unload. For backwards compatibility, we treat EOPNOTSUPP from MOD_QUIESCE as success. Document that modules should return EOPNOTSUPP for unknown events.
2004-07-13 19:36:59 +00:00
error = 0;
- Invoke MOD_QUIESCE on all modules in a linker file (kld) before unloading any modules. As a result, if any module veto's an unload request via MOD_QUIESCE, the entire set of modules for that linker file will remain loaded and active now rather than leaving the kld in a weird state where some modules are loaded and some are unloaded. - This also moves the logic for handling the "forced" unload flag out of kern_module.c and into kern_linker.c which is a bit cleaner. - Add a module_name() routine that returns the name of a module and use that instead of printing pointer values in debug messages when a module fails MOD_QUIESCE or MOD_UNLOAD. MFC after: 1 month
2008-12-05 13:40:25 +00:00
return (error);
}
int
module_unload(module_t mod)
{
int error;
mtx_lock(&Giant);
error = MOD_EVENT(mod, MOD_UNLOAD);
Address a problem I missed in removing Giant from the kernel linker. Not all of the module event handlers are MP safe yet, so always acquire Giant for now when invoking module event handlers. Eventually we can add an MPSAFE flag or some such and add appropriate locking to all module event handlers.
2006-06-26 18:34:45 +00:00
mtx_unlock(&Giant);
return (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
}
int
module_getid(module_t mod)
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_LOCK_ASSERT;
- Fix style further by adding parentheses around return values so that they look like: return (val); instead of: return val;
2002-02-20 16:05:30 +00:00
return (mod->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
}
module_t
module_getfnext(module_t mod)
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_LOCK_ASSERT;
- Fix style further by adding parentheses around return values so that they look like: return (val); instead of: return val;
2002-02-20 16:05:30 +00:00
return (TAILQ_NEXT(mod, flink));
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
}
- Invoke MOD_QUIESCE on all modules in a linker file (kld) before unloading any modules. As a result, if any module veto's an unload request via MOD_QUIESCE, the entire set of modules for that linker file will remain loaded and active now rather than leaving the kld in a weird state where some modules are loaded and some are unloaded. - This also moves the logic for handling the "forced" unload flag out of kern_module.c and into kern_linker.c which is a bit cleaner. - Add a module_name() routine that returns the name of a module and use that instead of printing pointer values in debug messages when a module fails MOD_QUIESCE or MOD_UNLOAD. MFC after: 1 month
2008-12-05 13:40:25 +00:00
const char *
module_getname(module_t mod)
{
MOD_LOCK_ASSERT;
return (mod->name);
}
Implement a mechanism for a module to report a small amount of module specific data back to the user via kldstat(2). Use that mechanism in the syscall handler to report the syscall number used.
1999-01-09 14:59:50 +00:00
void
module_setspecific(module_t mod, modspecific_t *datap)
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_XLOCK_ASSERT;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
mod->data = *datap;
Implement a mechanism for a module to report a small amount of module specific data back to the user via kldstat(2). Use that mechanism in the syscall handler to report the syscall number used.
1999-01-09 14:59:50 +00:00
}
Add a new module_file() function that returns the linker_file_t associated with a given module_t. I use this in some the MOD_LOAD event handler for some test kernel modules to ask the kernel linker to look up the linker sets in my test modules. (I use linker sets to generate the list of possible events that I then signal to execute via a sysctl. On non-amd64, ld(8) would resolve the entire linker set, but on amd64 I have to ask the kernel linker to do it for me, and having the kernel linker do it works on all archs.)
2006-04-17 19:44:44 +00:00
linker_file_t
module_file(module_t mod)
{
return (mod->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
/*
* Syscalls.
*/
int
In order to maximize the re-usability of kernel code in user space this patch modifies makesyscalls.sh to prefix all of the non-compatibility calls (e.g. not linux_, freebsd32_) with sys_ and updates the kernel entry points and all places in the code that use them. It also fixes an additional name space collision between the kernel function psignal and the libc function of the same name by renaming the kernel psignal kern_psignal(). By introducing this change now we will ease future MFCs that change syscalls. Reviewed by: rwatson Approved by: re (bz)
2011-09-16 13:58:51 +00:00
sys_modnext(struct thread *td, struct modnext_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
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_t mod;
int error = 0;
td->td_retval[0] = -1;
- Remove Giant acquisition from modevent(), modfnext(), modstat() and modfind(). Giant is no longer needed by these functions for safe execution. Reviewed by: jhb
2002-06-26 00:31:44 +00:00
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SLOCK;
SCARGS removal take II.
2002-12-14 01:56:26 +00:00
if (uap->modid == 0) {
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
mod = TAILQ_FIRST(&modules);
if (mod)
td->td_retval[0] = mod->id;
else
error = ENOENT;
goto done2;
}
SCARGS removal take II.
2002-12-14 01:56:26 +00:00
mod = module_lookupbyid(uap->modid);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
if (mod == NULL) {
error = ENOENT;
goto done2;
}
if (TAILQ_NEXT(mod, link))
td->td_retval[0] = TAILQ_NEXT(mod, link)->id;
Giant Pushdown. Saved the worst P4 tree breakage for last. reboot() getpriority() setpriority() rtprio() osetrlimit() ogetrlimit() setrlimit() getrlimit() getrusage() getpid() getppid() getpgrp() getpgid() getsid() getgid() getegid() getgroups() setsid() setpgid() setuid() seteuid() setgid() setegid() setgroups() setreuid() setregid() setresuid() setresgid() getresuid() getresgid () __setugid() getlogin() setlogin() modnext() modfnext() modstat() modfind() kldload() kldunload() kldfind() kldnext() kldstat() kldfirstmod() kldsym() getdtablesize() dup2() dup() fcntl() close() ofstat() fstat() nfsstat() fpathconf() flock()
2001-09-01 19:04:37 +00:00
else
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
td->td_retval[0] = 0;
Giant Pushdown. Saved the worst P4 tree breakage for last. reboot() getpriority() setpriority() rtprio() osetrlimit() ogetrlimit() setrlimit() getrlimit() getrusage() getpid() getppid() getpgrp() getpgid() getsid() getgid() getegid() getgroups() setsid() setpgid() setuid() seteuid() setgid() setegid() setgroups() setreuid() setregid() setresuid() setresgid() getresuid() getresgid () __setugid() getlogin() setlogin() modnext() modfnext() modstat() modfind() kldload() kldunload() kldfind() kldnext() kldstat() kldfirstmod() kldsym() getdtablesize() dup2() dup() fcntl() close() ofstat() fstat() nfsstat() fpathconf() flock()
2001-09-01 19:04:37 +00:00
done2:
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SUNLOCK;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
return (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
}
int
In order to maximize the re-usability of kernel code in user space this patch modifies makesyscalls.sh to prefix all of the non-compatibility calls (e.g. not linux_, freebsd32_) with sys_ and updates the kernel entry points and all places in the code that use them. It also fixes an additional name space collision between the kernel function psignal and the libc function of the same name by renaming the kernel psignal kern_psignal(). By introducing this change now we will ease future MFCs that change syscalls. Reviewed by: rwatson Approved by: re (bz)
2011-09-16 13:58:51 +00:00
sys_modfnext(struct thread *td, struct modfnext_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
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_t mod;
int error;
td->td_retval[0] = -1;
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SLOCK;
SCARGS removal take II.
2002-12-14 01:56:26 +00:00
mod = module_lookupbyid(uap->modid);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
if (mod == NULL) {
error = ENOENT;
} else {
error = 0;
if (TAILQ_NEXT(mod, flink))
td->td_retval[0] = TAILQ_NEXT(mod, flink)->id;
else
td->td_retval[0] = 0;
}
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SUNLOCK;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
return (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
}
Implement a mechanism for a module to report a small amount of module specific data back to the user via kldstat(2). Use that mechanism in the syscall handler to report the syscall number used.
1999-01-09 14:59:50 +00:00
struct module_stat_v1 {
- Whitespace fixup left over from previous commit. - Remove bogus cast. Submitted by: bde
2002-02-22 13:33:10 +00:00
int version; /* set to sizeof(struct module_stat) */
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
char name[MAXMODNAMEV1V2];
- Whitespace fixup left over from previous commit. - Remove bogus cast. Submitted by: bde
2002-02-22 13:33:10 +00:00
int refs;
int id;
Implement a mechanism for a module to report a small amount of module specific data back to the user via kldstat(2). Use that mechanism in the syscall handler to report the syscall number used.
1999-01-09 14:59:50 +00:00
};
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
struct module_stat_v2 {
int version; /* set to sizeof(struct module_stat) */
char name[MAXMODNAMEV1V2];
int refs;
int id;
modspecific_t data;
};
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
In order to maximize the re-usability of kernel code in user space this patch modifies makesyscalls.sh to prefix all of the non-compatibility calls (e.g. not linux_, freebsd32_) with sys_ and updates the kernel entry points and all places in the code that use them. It also fixes an additional name space collision between the kernel function psignal and the libc function of the same name by renaming the kernel psignal kern_psignal(). By introducing this change now we will ease future MFCs that change syscalls. Reviewed by: rwatson Approved by: re (bz)
2011-09-16 13:58:51 +00:00
sys_modstat(struct thread *td, struct modstat_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
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_t mod;
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
modspecific_t data;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
int error = 0;
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
int id, namelen, refs, version;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
struct module_stat *stat;
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
struct module_stat_v2 *stat_v2;
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
char *name;
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
bool is_v1v2;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SLOCK;
SCARGS removal take II.
2002-12-14 01:56:26 +00:00
mod = module_lookupbyid(uap->modid);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
if (mod == NULL) {
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SUNLOCK;
- Remove Giant acquisition from modevent(), modfnext(), modstat() and modfind(). Giant is no longer needed by these functions for safe execution. Reviewed by: jhb
2002-06-26 00:31:44 +00:00
return (ENOENT);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
}
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
id = mod->id;
refs = mod->refs;
name = mod->name;
data = mod->data;
MOD_SUNLOCK;
SCARGS removal take II.
2002-12-14 01:56:26 +00:00
stat = uap->stat;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
/*
* Check the version of the user's structure.
*/
if ((error = copyin(&stat->version, &version, sizeof(version))) != 0)
- Remove Giant acquisition from modevent(), modfnext(), modstat() and modfind(). Giant is no longer needed by these functions for safe execution. Reviewed by: jhb
2002-06-26 00:31:44 +00:00
return (error);
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
is_v1v2 = (version == sizeof(struct module_stat_v1) ||
version == sizeof(struct module_stat_v2));
if (!is_v1v2 && version != sizeof(struct module_stat))
- Remove Giant acquisition from modevent(), modfnext(), modstat() and modfind(). Giant is no longer needed by these functions for safe execution. Reviewed by: jhb
2002-06-26 00:31:44 +00:00
return (EINVAL);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
namelen = strlen(mod->name) + 1;
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
if (is_v1v2 && namelen > MAXMODNAMEV1V2)
namelen = MAXMODNAMEV1V2;
else if (namelen > MAXMODNAMEV3)
namelen = MAXMODNAMEV3;
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
if ((error = copyout(name, &stat->name[0], namelen)) != 0)
- Remove Giant acquisition from modevent(), modfnext(), modstat() and modfind(). Giant is no longer needed by these functions for safe execution. Reviewed by: jhb
2002-06-26 00:31:44 +00:00
return (error);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
/* Extending MAXMODNAME gives an offset change for v3. */
if (is_v1v2) {
stat_v2 = (struct module_stat_v2 *)stat;
if ((error = copyout(&refs, &stat_v2->refs, sizeof(int))) != 0)
return (error);
if ((error = copyout(&id, &stat_v2->id, sizeof(int))) != 0)
return (error);
} else {
if ((error = copyout(&refs, &stat->refs, sizeof(int))) != 0)
return (error);
if ((error = copyout(&id, &stat->id, sizeof(int))) != 0)
return (error);
}
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
/*
* >v1 stat includes module data.
*/
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
if (version == sizeof(struct module_stat_v2)) {
if ((error = copyout(&data, &stat_v2->data,
sizeof(data))) != 0)
return (error);
} else if (version == sizeof(struct module_stat)) {
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
if ((error = copyout(&data, &stat->data,
sizeof(data))) != 0)
- Remove Giant acquisition from modevent(), modfnext(), modstat() and modfind(). Giant is no longer needed by these functions for safe execution. Reviewed by: jhb
2002-06-26 00:31:44 +00:00
return (error);
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
}
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
td->td_retval[0] = 0;
- Fix style further by adding parentheses around return values so that they look like: return (val); instead of: return val;
2002-02-20 16:05:30 +00:00
return (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
}
int
In order to maximize the re-usability of kernel code in user space this patch modifies makesyscalls.sh to prefix all of the non-compatibility calls (e.g. not linux_, freebsd32_) with sys_ and updates the kernel entry points and all places in the code that use them. It also fixes an additional name space collision between the kernel function psignal and the libc function of the same name by renaming the kernel psignal kern_psignal(). By introducing this change now we will ease future MFCs that change syscalls. Reviewed by: rwatson Approved by: re (bz)
2011-09-16 13:58:51 +00:00
sys_modfind(struct thread *td, struct modfind_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
{
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
int error = 0;
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
char name[MAXMODNAMEV3];
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
module_t mod;
SCARGS removal take II.
2002-12-14 01:56:26 +00:00
if ((error = copyinstr(uap->name, name, sizeof name, 0)) != 0)
- Remove Giant acquisition from modevent(), modfnext(), modstat() and modfind(). Giant is no longer needed by these functions for safe execution. Reviewed by: jhb
2002-06-26 00:31:44 +00:00
return (error);
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
MOD_SLOCK;
- Style.9 formatting fix; this commit is mostly white space related with the next commit actually doing the: return val; -> return (val); changes. This commit was done in preparation for getting ``struct modules'' locked down. Reviewed by: bde Approved by: dfr
2002-02-20 14:30:02 +00:00
mod = module_lookupbyname(name);
if (mod == NULL)
error = ENOENT;
else
- Lock down the ``module'' structure by adding an SX lock that is used by all the global bits of ``module'' data. This commit adds a few generic macros, MOD_SLOCK, MOD_XLOCK, etc., that are meant to be used as ways of accessing the SX lock. It is also the first step in helping to lock down the kernel linker and module systems. Reviewed by: jhb, jake, smp@
2002-03-18 07:45:30 +00:00
td->td_retval[0] = module_getid(mod);
MOD_SUNLOCK;
- Fix style further by adding parentheses around return values so that they look like: return (val); instead of: return val;
2002-02-20 16:05:30 +00:00
return (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
}
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
Add an automatic kernel module version dependency to prevent loading modules using invalid ABI versions (e.g. a 7.x module with an 8.x kernel) for a given kernel: - Add a 'kernel' module version whose value is __FreeBSD_version. - Add a version dependency on 'kernel' in every module that has an acceptable version range of __FreeBSD_version up to the end of the branch __FreeBSD_version is part of. E.g. a module compiled on 701000 would work on kernels with versions between 701000 and 799999 inclusive. Discussed on: arch@ MFC after: 1 week
2008-02-13 21:34:06 +00:00
MODULE_VERSION(kernel, __FreeBSD_version);
Provide groundwork for 32-bit binary compatibility on non-x86 platforms, for upcoming 64-bit PowerPC and MIPS support. This renames the COMPAT_IA32 option to COMPAT_FREEBSD32, removes some IA32-specific code from MI parts of the kernel and enhances the freebsd32 compatibility code to support big-endian platforms. Reviewed by: kib, jhb
2010-03-11 14:49:06 +00:00
#ifdef COMPAT_FREEBSD32
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
#include <sys/mount.h>
Move several data structure definitions out of freebsd32_misc.c and into freebsd32.h instead. MFC after: 1 week
2007-12-06 23:11:27 +00:00
#include <sys/socket.h>
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
#include <compat/freebsd32/freebsd32_util.h>
#include <compat/freebsd32/freebsd32.h>
#include <compat/freebsd32/freebsd32_proto.h>
typedef union modspecific32 {
int intval;
Use ISO C99 integer types in sys/kern where possible. There are only about 100 occurences of the BSD-specific u_int*_t datatypes in sys/kern. The ISO C99 integer types are used here more often.
2010-06-21 09:55:56 +00:00
uint32_t uintval;
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
int longval;
Use ISO C99 integer types in sys/kern where possible. There are only about 100 occurences of the BSD-specific u_int*_t datatypes in sys/kern. The ISO C99 integer types are used here more often.
2010-06-21 09:55:56 +00:00
uint32_t ulongval;
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
} modspecific32_t;
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
struct module_stat32_v2 {
int version;
char name[MAXMODNAMEV1V2];
int refs;
int id;
modspecific32_t data;
};
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
struct module_stat32 {
int version;
char name[MAXMODNAME];
int refs;
int id;
modspecific32_t data;
};
int
freebsd32_modstat(struct thread *td, struct freebsd32_modstat_args *uap)
{
module_t mod;
modspecific32_t data32;
int error = 0;
int id, namelen, refs, version;
struct module_stat32 *stat32;
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
struct module_stat32_v2 *stat32_v2;
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
char *name;
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
bool is_v1v2;
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
MOD_SLOCK;
mod = module_lookupbyid(uap->modid);
if (mod == NULL) {
MOD_SUNLOCK;
return (ENOENT);
}
id = mod->id;
refs = mod->refs;
name = mod->name;
modules: fix freebsd32_modstat on big endian platforms The layout of modspecific_t on both little endian and big endian are as follows: |0|1|2|3|4|5|6|7| +-------+-------+ |uintval| | +-------+-------+ |ulongval | +-------+-------+ For the following code snippet: CP(mod->data, data32, longval); CP(mod->data, data32, ulongval); It only takes care of little endian platforms that it truncates the highest 32bit automatically. However on big endian platforms it takes the highest 32bit instead. This eventually returns a garbage syscall number to the 32bit userland. Since modspecific_t's usage currently is for the use of syscall modules, we only initialize modspecific32_t with uintval. Now on both BE and LE 64-bit platforms it always pick up the first 4 bytes. Sponsored by: Juniper Networks, Inc. Reviewed by: markj Differential Revision: https://reviews.freebsd.org/D40814 MFC after: 1 week
2023-07-07 04:21:01 +00:00
_Static_assert(sizeof(data32) == sizeof(data32.uintval),
"bad modspecific32_t size");
Swap the arguments for CP so we copy the correct source and destination.
2005-02-18 22:14:40 +00:00
CP(mod->data, data32, uintval);
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
MOD_SUNLOCK;
stat32 = uap->stat;
if ((error = copyin(&stat32->version, &version, sizeof(version))) != 0)
return (error);
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
is_v1v2 = (version == sizeof(struct module_stat_v1) ||
version == sizeof(struct module_stat32_v2));
if (!is_v1v2 && version != sizeof(struct module_stat32))
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
return (EINVAL);
namelen = strlen(mod->name) + 1;
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
if (is_v1v2 && namelen > MAXMODNAMEV1V2)
namelen = MAXMODNAMEV1V2;
else if (namelen > MAXMODNAMEV3)
namelen = MAXMODNAMEV3;
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
if ((error = copyout(name, &stat32->name[0], namelen)) != 0)
return (error);
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
/* Extending MAXMODNAME gives an offset change for v3. */
if (is_v1v2) {
stat32_v2 = (struct module_stat32_v2 *)stat32;
if ((error = copyout(&refs, &stat32_v2->refs, sizeof(int))) != 0)
return (error);
if ((error = copyout(&id, &stat32_v2->id, sizeof(int))) != 0)
return (error);
} else {
if ((error = copyout(&refs, &stat32->refs, sizeof(int))) != 0)
return (error);
if ((error = copyout(&id, &stat32->id, sizeof(int))) != 0)
return (error);
}
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
/*
* >v1 stat includes module data.
*/
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
if (version == sizeof(struct module_stat32_v2)) {
if ((error = copyout(&data32, &stat32_v2->data,
sizeof(data32))) != 0)
return (error);
} else if (version == sizeof(struct module_stat32)) {
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
if ((error = copyout(&data32, &stat32->data,
sizeof(data32))) != 0)
return (error);
modules: increase MAXMODNAME and provide backward compat With various firmware files used by graphics and wireless drivers we are exceeding the current 32 character module name (file path in kldxref) length. In order to overcome this issue bump it to the maximum path length for the next version. To be able to MFC provide backward compat support for another version of the struct as the offsets for the second half change due to the array size increase. MAXMODNAME being defined to MAXPATHLEN needs param.h to be included first. With only 7 modules (or LinuxKPI module.h) not doing that adjust them rather than including param.h in module.h [1]. Reported by: Greg V (greg unrelenting.technology) Sponsored by: The FreeBSD Foundation Suggested by: imp [1] MFC after: 10 days Reviewed by: imp (and others to different level) Differential Revision: https://reviews.freebsd.org/D32383
2021-11-17 19:35:46 +00:00
}
Add a 32bit syscall wrapper for modstat Obtained from: Yahoo!
2005-01-19 17:53:06 +00:00
td->td_retval[0] = 0;
return (error);
}
#endif
Reference in New Issue Copy Permalink