Remove some uses of the SCARG macro.
[dragonfly.git] / sys / kern / kern_module.c
1 /*-
2  * Copyright (c) 1997 Doug Rabson
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/kern/kern_module.c,v 1.21 1999/11/08 06:53:30 peter Exp $
27  * $DragonFly: src/sys/kern/kern_module.c,v 1.9 2005/03/29 00:35:55 drhodus Exp $
28  */
29
30 #include <sys/param.h>
31 #include <sys/kernel.h>
32 #include <sys/systm.h>
33 #include <sys/eventhandler.h>
34 #include <sys/malloc.h>
35 #include <sys/sysproto.h>
36 #include <sys/sysent.h>
37 #include <sys/module.h>
38 #include <sys/linker.h>
39 #include <sys/proc.h>
40
41 MALLOC_DEFINE(M_MODULE, "module", "module data structures");
42
43 typedef TAILQ_HEAD(, module) modulelist_t;
44 struct module {
45     TAILQ_ENTRY(module) link;           /* chain together all modules */
46     TAILQ_ENTRY(module) flink;          /* all modules in a file */
47     struct linker_file* file;           /* file which contains this module */
48     int                 refs;           /* reference count */
49     int                 id;             /* unique id number */
50     char                *name;          /* module name */
51     modeventhand_t      handler;        /* event handler */
52     void                *arg;           /* argument for handler */
53     modspecific_t       data;           /* module specific data */
54 };
55
56 #define MOD_EVENT(mod, type) (mod)->handler((mod), (type), (mod)->arg)
57
58 static modulelist_t modules;
59 static int nextid = 1;
60
61 static void module_shutdown(void*, int);
62
63 static int
64 modevent_nop(module_t mod, int what, void* arg)
65 {
66         return 0;
67 }
68
69
70 static void
71 module_init(void* arg)
72 {
73     TAILQ_INIT(&modules);
74     EVENTHANDLER_REGISTER(shutdown_post_sync, module_shutdown, NULL,
75                           SHUTDOWN_PRI_DEFAULT);
76 }
77
78 SYSINIT(module, SI_SUB_KLD, SI_ORDER_FIRST, module_init, 0);
79
80 static void
81 module_shutdown(void* arg1, int arg2)
82 {
83     module_t mod;
84
85     for (mod = TAILQ_FIRST(&modules); mod; mod = TAILQ_NEXT(mod, link))
86         MOD_EVENT(mod, MOD_SHUTDOWN);
87 }
88
89 void
90 module_register_init(const void *arg)
91 {
92     const moduledata_t* data = (const moduledata_t*) arg;
93     int error;
94     module_t mod;
95
96     mod = module_lookupbyname(data->name);
97     if (mod == NULL) {
98 #if 0
99         panic("module_register_init: module named %s not found", data->name);
100 #else
101         /* temporary kludge until kernel `file' attachment registers modules */
102         error = module_register(data, linker_kernel_file);
103         if (error)
104             panic("module_register_init: register of module failed! %d", error);
105         mod = module_lookupbyname(data->name);
106         if (mod == NULL)
107             panic("module_register_init: module STILL not found!");
108 #endif
109     }
110     error = MOD_EVENT(mod, MOD_LOAD);
111     if (error) {
112         MOD_EVENT(mod, MOD_UNLOAD);
113         module_release(mod);
114         printf("module_register_init: MOD_LOAD (%s, %lx, %p) error %d\n",
115                data->name, (u_long)(uintfptr_t)data->evhand, data->priv, error);
116     }
117 }
118
119 int
120 module_register(const moduledata_t *data, linker_file_t container)
121 {
122     size_t namelen;
123     module_t newmod;
124
125     newmod = module_lookupbyname(data->name);
126     if (newmod != NULL) {
127         printf("module_register: module %s already exists!\n", data->name);
128         return EEXIST;
129     }
130     namelen = strlen(data->name) + 1;
131     newmod = (module_t) malloc(sizeof(struct module) + namelen,
132                                M_MODULE, M_WAITOK);
133     if (newmod == 0)
134         return ENOMEM;
135
136     newmod->refs = 1;
137     newmod->id = nextid++;
138     newmod->name = (char *) (newmod + 1);
139     strcpy(newmod->name, data->name);
140     newmod->handler = data->evhand ? data->evhand : modevent_nop;
141     newmod->arg = data->priv;
142     bzero(&newmod->data, sizeof(newmod->data));
143     TAILQ_INSERT_TAIL(&modules, newmod, link);
144
145     if (container == NULL)
146         container = linker_current_file;
147     if (container)
148         TAILQ_INSERT_TAIL(&container->modules, newmod, flink);
149     newmod->file = container;
150
151     return 0;
152 }
153
154 void
155 module_reference(module_t mod)
156 {
157     MOD_DPF(REFS, ("module_reference: before, refs=%d\n", mod->refs));
158
159     mod->refs++;
160 }
161
162 /*
163  * module_release()
164  *
165  *      Release ref on the module and return the new reference count.  If 0
166  *      is returned, the module has been removed from its list and freed.
167  */
168 int
169 module_release(module_t mod)
170 {
171     int rc;
172
173     if (mod->refs <= 0)
174         panic("module_release: bad reference count");
175
176     MOD_DPF(REFS, ("module_release: before, refs=%d\n", mod->refs));
177
178     rc = --mod->refs;
179     if (rc == 0) {
180         TAILQ_REMOVE(&modules, mod, link);
181         if (mod->file) {
182             TAILQ_REMOVE(&mod->file->modules, mod, flink);
183         }
184         free(mod, M_MODULE);
185     }
186     return(rc);
187 }
188
189 module_t
190 module_lookupbyname(const char* name)
191 {
192     module_t mod;
193
194     for (mod = TAILQ_FIRST(&modules); mod; mod = TAILQ_NEXT(mod, link)) {
195         if (!strcmp(mod->name, name))
196             return mod;
197     }
198
199     return 0;
200 }
201
202 module_t
203 module_lookupbyid(int modid)
204 {
205     module_t mod;
206
207     for (mod = TAILQ_FIRST(&modules); mod; mod = TAILQ_NEXT(mod, link)) {
208         if (mod->id == modid)
209             return mod;
210     }
211
212     return 0;
213 }
214
215 int
216 module_unload(module_t mod)
217 {
218     return MOD_EVENT(mod, MOD_UNLOAD);
219 }
220
221 int
222 module_getid(module_t mod)
223 {
224     return mod->id;
225 }
226
227 module_t
228 module_getfnext(module_t mod)
229 {
230     return TAILQ_NEXT(mod, flink);
231 }
232
233 void
234 module_setspecific(module_t mod, modspecific_t *datap)
235 {
236     mod->data = *datap;
237 }
238
239 /*
240  * Syscalls.
241  */
242 int
243 modnext(struct modnext_args *uap)
244 {
245     module_t mod;
246
247     uap->sysmsg_result = -1;
248     if (uap->modid == 0) {
249         mod = TAILQ_FIRST(&modules);
250         if (mod) {
251             uap->sysmsg_result = mod->id;
252             return 0;
253         } else
254             return ENOENT;
255     }
256
257     mod = module_lookupbyid(uap->modid);
258     if (!mod)
259         return ENOENT;
260
261     if (TAILQ_NEXT(mod, link))
262         uap->sysmsg_result = TAILQ_NEXT(mod, link)->id;
263     else
264         uap->sysmsg_result = 0;
265     return 0;
266 }
267
268 int
269 modfnext(struct modfnext_args *uap)
270 {
271     module_t mod;
272
273     uap->sysmsg_result = -1;
274
275     mod = module_lookupbyid(uap->modid);
276     if (!mod)
277         return ENOENT;
278
279     if (TAILQ_NEXT(mod, flink))
280         uap->sysmsg_result = TAILQ_NEXT(mod, flink)->id;
281     else
282         uap->sysmsg_result = 0;
283     return 0;
284 }
285
286 struct module_stat_v1 {
287     int         version;        /* set to sizeof(struct module_stat) */
288     char        name[MAXMODNAME];
289     int         refs;
290     int         id;
291 };
292
293 int
294 modstat(struct modstat_args *uap)
295 {
296     module_t mod;
297     int error = 0;
298     int namelen;
299     int version;
300     struct module_stat* stat;
301
302     mod = module_lookupbyid(uap->modid);
303     if (!mod)
304         return ENOENT;
305
306     stat = uap->stat;
307
308     /*
309      * Check the version of the user's structure.
310      */
311     if ((error = copyin(&stat->version, &version, sizeof(version))) != 0)
312         goto out;
313     if (version != sizeof(struct module_stat_v1)
314         && version != sizeof(struct module_stat)) {
315         error = EINVAL;
316         goto out;
317     }
318
319     namelen = strlen(mod->name) + 1;
320     if (namelen > MAXMODNAME)
321         namelen = MAXMODNAME;
322     if ((error = copyout(mod->name, &stat->name[0], namelen)) != 0)
323         goto out;
324
325     if ((error = copyout(&mod->refs, &stat->refs, sizeof(int))) != 0)
326         goto out;
327     if ((error = copyout(&mod->id, &stat->id, sizeof(int))) != 0)
328         goto out;
329
330     /*
331      * >v1 stat includes module data.
332      */
333     if (version == sizeof(struct module_stat)) {
334         if ((error = copyout(&mod->data, &stat->data, sizeof(mod->data))) != 0)
335             goto out;
336     }
337
338     uap->sysmsg_result = 0;
339
340 out:
341     return error;
342 }
343
344 int
345 modfind(struct modfind_args *uap)
346 {
347     int error = 0;
348     char name[MAXMODNAME];
349     module_t mod;
350
351     if ((error = copyinstr(uap->name, name, sizeof name, 0)) != 0)
352         goto out;
353
354     mod = module_lookupbyname(name);
355     if (!mod)
356         error = ENOENT;
357     else
358         uap->sysmsg_result = mod->id;
359
360 out:
361     return error;
362 }