xref: /dragonfly/sys/kern/kern_module.c (revision 4a65f651) 
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.16 2008/06/07 11:44:04 mneumann 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_BOOT2_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 	module_unload(mod);	/* ignore error */
113 	module_release(mod);
114 	kprintf("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 	kprintf("module_register: module %s already exists!\n", data->name);
128 	return EEXIST;
129     }
130     namelen = strlen(data->name) + 1;
131     newmod = (module_t) kmalloc(sizeof(struct module) + namelen,
132 			       M_MODULE, M_WAITOK);
133 
134     newmod->refs = 1;
135     newmod->id = nextid++;
136     newmod->name = (char *) (newmod + 1);
137     strcpy(newmod->name, data->name);
138     newmod->handler = data->evhand ? data->evhand : modevent_nop;
139     newmod->arg = data->priv;
140     bzero(&newmod->data, sizeof(newmod->data));
141     TAILQ_INSERT_TAIL(&modules, newmod, link);
142 
143     if (container == NULL)
144 	container = linker_current_file;
145     if (container)
146 	TAILQ_INSERT_TAIL(&container->modules, newmod, flink);
147     newmod->file = container;
148 
149     return 0;
150 }
151 
152 void
153 module_reference(module_t mod)
154 {
155     MOD_DPF(REFS, ("module_reference: before, refs=%d\n", mod->refs));
156 
157     mod->refs++;
158 }
159 
160 /*
161  * module_release()
162  *
163  *	Release ref on the module and return the new reference count.  If 0
164  *	is returned, the module has been removed from its list and freed.
165  */
166 int
167 module_release(module_t mod)
168 {
169     int rc;
170 
171     if (mod->refs <= 0)
172 	panic("module_release: bad reference count");
173 
174     MOD_DPF(REFS, ("module_release: before, refs=%d\n", mod->refs));
175 
176     rc = --mod->refs;
177     if (rc == 0) {
178 	TAILQ_REMOVE(&modules, mod, link);
179 	if (mod->file) {
180 	    TAILQ_REMOVE(&mod->file->modules, mod, flink);
181 	}
182 	kfree(mod, M_MODULE);
183     }
184     return(rc);
185 }
186 
187 module_t
188 module_lookupbyname(const char* name)
189 {
190     module_t mod;
191 
192     for (mod = TAILQ_FIRST(&modules); mod; mod = TAILQ_NEXT(mod, link)) {
193 	if (!strcmp(mod->name, name))
194 	    return mod;
195     }
196 
197     return NULL;
198 }
199 
200 module_t
201 module_lookupbyid(int modid)
202 {
203     module_t mod;
204 
205     for (mod = TAILQ_FIRST(&modules); mod; mod = TAILQ_NEXT(mod, link)) {
206 	if (mod->id == modid)
207 	    return mod;
208     }
209 
210     return NULL;
211 }
212 
213 int
214 module_unload(module_t mod)
215 {
216     int error;
217 
218     error = MOD_EVENT(mod, MOD_UNLOAD);
219     /*sync_devs();*/
220     return (error);
221 }
222 
223 int
224 module_getid(module_t mod)
225 {
226     return mod->id;
227 }
228 
229 module_t
230 module_getfnext(module_t mod)
231 {
232     return TAILQ_NEXT(mod, flink);
233 }
234 
235 void
236 module_setspecific(module_t mod, modspecific_t *datap)
237 {
238     mod->data = *datap;
239 }
240 
241 /*
242  * Syscalls.
243  */
244 int
245 sys_modnext(struct modnext_args *uap)
246 {
247     module_t mod;
248 
249     uap->sysmsg_result = -1;
250     if (uap->modid == 0) {
251 	mod = TAILQ_FIRST(&modules);
252 	if (mod) {
253 	    uap->sysmsg_result = mod->id;
254 	    return 0;
255 	} else
256 	    return ENOENT;
257     }
258 
259     mod = module_lookupbyid(uap->modid);
260     if (!mod)
261 	return ENOENT;
262 
263     if (TAILQ_NEXT(mod, link))
264 	uap->sysmsg_result = TAILQ_NEXT(mod, link)->id;
265     else
266 	uap->sysmsg_result = 0;
267     return 0;
268 }
269 
270 int
271 sys_modfnext(struct modfnext_args *uap)
272 {
273     module_t mod;
274 
275     uap->sysmsg_result = -1;
276 
277     mod = module_lookupbyid(uap->modid);
278     if (!mod)
279 	return ENOENT;
280 
281     if (TAILQ_NEXT(mod, flink))
282 	uap->sysmsg_result = TAILQ_NEXT(mod, flink)->id;
283     else
284 	uap->sysmsg_result = 0;
285     return 0;
286 }
287 
288 struct module_stat_v1 {
289     int		version;	/* set to sizeof(struct module_stat) */
290     char	name[MAXMODNAME];
291     int		refs;
292     int		id;
293 };
294 
295 int
296 sys_modstat(struct modstat_args *uap)
297 {
298     module_t mod;
299     int error = 0;
300     int namelen;
301     int version;
302     struct module_stat* stat;
303 
304     mod = module_lookupbyid(uap->modid);
305     if (!mod)
306 	return ENOENT;
307 
308     stat = uap->stat;
309 
310     /*
311      * Check the version of the user's structure.
312      */
313     if ((error = copyin(&stat->version, &version, sizeof(version))) != 0)
314 	goto out;
315     if (version != sizeof(struct module_stat_v1)
316 	&& version != sizeof(struct module_stat)) {
317 	error = EINVAL;
318 	goto out;
319     }
320 
321     namelen = strlen(mod->name) + 1;
322     if (namelen > MAXMODNAME)
323 	namelen = MAXMODNAME;
324     if ((error = copyout(mod->name, &stat->name[0], namelen)) != 0)
325 	goto out;
326 
327     if ((error = copyout(&mod->refs, &stat->refs, sizeof(int))) != 0)
328 	goto out;
329     if ((error = copyout(&mod->id, &stat->id, sizeof(int))) != 0)
330 	goto out;
331 
332     /*
333      * >v1 stat includes module data.
334      */
335     if (version == sizeof(struct module_stat)) {
336 	if ((error = copyout(&mod->data, &stat->data, sizeof(mod->data))) != 0)
337 	    goto out;
338     }
339 
340     uap->sysmsg_result = 0;
341 
342 out:
343     return error;
344 }
345 
346 int
347 sys_modfind(struct modfind_args *uap)
348 {
349     int error = 0;
350     char name[MAXMODNAME];
351     module_t mod;
352 
353     if ((error = copyinstr(uap->name, name, sizeof name, 0)) != 0)
354 	goto out;
355 
356     mod = module_lookupbyname(name);
357     if (!mod)
358 	error = ENOENT;
359     else
360 	uap->sysmsg_result = mod->id;
361 
362 out:
363     return error;
364 }
365