1 #include <linux/config.h>
3 #include <linux/module.h>
4 #include <asm/uaccess.h>
5 #include <linux/vmalloc.h>
6 #include <linux/smp_lock.h>
7 #include <asm/pgalloc.h>
8 #include <linux/init.h>
11 * Originally by Anonymous (as far as I know...)
12 * Linux version by Bas Laarhoven <bas@vimec.nl>
13 * 0.99.14 version by Jon Tombs <jon@gtex02.us.es>,
14 * Heavily modified by Bjorn Ekwall <bj0rn@blox.se> May 1994 (C)
15 * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
16 * Add MOD_INITIALIZING Keith Owens <kaos@ocs.com.au> Nov 1999
18 * This source is covered by the GNU GPL, the same as all kernel sources.
21 #ifdef CONFIG_MODULES /* a *big* #ifdef block... */
23 extern struct module_symbol __start___ksymtab
[];
24 extern struct module_symbol __stop___ksymtab
[];
26 extern const struct exception_table_entry __start___ex_table
[];
27 extern const struct exception_table_entry __stop___ex_table
[];
29 static struct module kernel_module
=
31 sizeof(struct module
), /* size_of_struct */
35 {ATOMIC_INIT(1)}, /* usecount */
36 MOD_RUNNING
, /* flags */
37 0, /* nsyms -- to filled in in init_modules */
39 __start___ksymtab
, /* syms */
44 __start___ex_table
, /* ex_table_start */
45 __stop___ex_table
, /* ex_table_end */
49 struct module
*module_list
= &kernel_module
;
51 static long get_mod_name(const char *user_name
, char **buf
);
52 static void put_mod_name(char *buf
);
53 static struct module
*find_module(const char *name
);
54 static void free_module(struct module
*, int tag_freed
);
61 void __init
init_modules(void)
63 kernel_module
.nsyms
= __stop___ksymtab
- __start___ksymtab
;
66 __asm__("stq $29,%0" : "=m"(kernel_module
.gp
));
71 * Copy the name of a module from user space.
75 get_mod_name(const char *user_name
, char **buf
)
80 page
= __get_free_page(GFP_KERNEL
);
84 retval
= strncpy_from_user((char *)page
, user_name
, PAGE_SIZE
);
86 if (retval
< PAGE_SIZE
) {
90 retval
= -ENAMETOOLONG
;
99 put_mod_name(char *buf
)
101 free_page((unsigned long)buf
);
105 * Allocate space for a module.
108 asmlinkage
unsigned long
109 sys_create_module(const char *name_user
, size_t size
)
115 if (!capable(CAP_SYS_MODULE
))
118 if ((namelen
= get_mod_name(name_user
, &name
)) < 0) {
122 if (size
< sizeof(struct module
)+namelen
) {
126 if (find_module(name
) != NULL
) {
130 if ((mod
= (struct module
*)module_map(size
)) == NULL
) {
135 memset(mod
, 0, sizeof(*mod
));
136 mod
->size_of_struct
= sizeof(*mod
);
137 mod
->next
= module_list
;
138 mod
->name
= (char *)(mod
+ 1);
140 memcpy((char*)(mod
+1), name
, namelen
+1);
144 module_list
= mod
; /* link it in */
156 * Initialize a module.
160 sys_init_module(const char *name_user
, struct module
*mod_user
)
162 struct module mod_tmp
, *mod
;
164 long namelen
, n_namelen
, i
, error
;
165 unsigned long mod_user_size
;
166 struct module_ref
*dep
;
168 if (!capable(CAP_SYS_MODULE
))
171 if ((namelen
= get_mod_name(name_user
, &name
)) < 0) {
175 if ((mod
= find_module(name
)) == NULL
) {
180 /* Check module header size. We allow a bit of slop over the
181 size we are familiar with to cope with a version of insmod
182 for a newer kernel. But don't over do it. */
183 if ((error
= get_user(mod_user_size
, &mod_user
->size_of_struct
)) != 0)
185 if (mod_user_size
< (unsigned long)&((struct module
*)0L)->persist_start
186 || mod_user_size
> sizeof(struct module
) + 16*sizeof(void*)) {
187 printk(KERN_ERR
"init_module: Invalid module header size.\n"
188 KERN_ERR
"A new version of the modutils is likely "
194 /* Hold the current contents while we play with the user's idea
198 error
= copy_from_user(mod
, mod_user
, sizeof(struct module
));
204 /* Sanity check the size of the module. */
207 if (mod
->size
> mod_tmp
.size
) {
208 printk(KERN_ERR
"init_module: Size of initialized module "
209 "exceeds size of created module.\n");
213 /* Make sure all interesting pointers are sane. */
215 #define bound(p, n, m) ((unsigned long)(p) >= (unsigned long)(m+1) && \
216 (unsigned long)((p)+(n)) <= (unsigned long)(m) + (m)->size)
218 if (!bound(mod
->name
, namelen
, mod
)) {
219 printk(KERN_ERR
"init_module: mod->name out of bounds.\n");
222 if (mod
->nsyms
&& !bound(mod
->syms
, mod
->nsyms
, mod
)) {
223 printk(KERN_ERR
"init_module: mod->syms out of bounds.\n");
226 if (mod
->ndeps
&& !bound(mod
->deps
, mod
->ndeps
, mod
)) {
227 printk(KERN_ERR
"init_module: mod->deps out of bounds.\n");
230 if (mod
->init
&& !bound(mod
->init
, 0, mod
)) {
231 printk(KERN_ERR
"init_module: mod->init out of bounds.\n");
234 if (mod
->cleanup
&& !bound(mod
->cleanup
, 0, mod
)) {
235 printk(KERN_ERR
"init_module: mod->cleanup out of bounds.\n");
238 if (mod
->ex_table_start
> mod
->ex_table_end
239 || (mod
->ex_table_start
&&
240 !((unsigned long)mod
->ex_table_start
>= (unsigned long)(mod
+1)
241 && ((unsigned long)mod
->ex_table_end
242 < (unsigned long)mod
+ mod
->size
)))
243 || (((unsigned long)mod
->ex_table_start
244 - (unsigned long)mod
->ex_table_end
)
245 % sizeof(struct exception_table_entry
))) {
246 printk(KERN_ERR
"init_module: mod->ex_table_* invalid.\n");
249 if (mod
->flags
& ~MOD_AUTOCLEAN
) {
250 printk(KERN_ERR
"init_module: mod->flags invalid.\n");
254 if (!bound(mod
->gp
- 0x8000, 0, mod
)) {
255 printk(KERN_ERR
"init_module: mod->gp out of bounds.\n");
259 if (mod_member_present(mod
, can_unload
)
260 && mod
->can_unload
&& !bound(mod
->can_unload
, 0, mod
)) {
261 printk(KERN_ERR
"init_module: mod->can_unload out of bounds.\n");
267 /* Check that the user isn't doing something silly with the name. */
269 if ((n_namelen
= get_mod_name(mod
->name
- (unsigned long)mod
270 + (unsigned long)mod_user
,
275 if (namelen
!= n_namelen
|| strcmp(n_name
, mod_tmp
.name
) != 0) {
276 printk(KERN_ERR
"init_module: changed module name to "
278 n_name
, mod_tmp
.name
);
282 /* Ok, that's about all the sanity we can stomach; copy the rest. */
284 if (copy_from_user(mod
+1, mod_user
+1, mod
->size
-sizeof(*mod
))) {
289 /* On some machines it is necessary to do something here
290 to make the I and D caches consistent. */
291 flush_icache_range((unsigned long)mod
, (unsigned long)mod
+ mod
->size
);
293 /* Update module references. */
294 mod
->next
= mod_tmp
.next
;
296 for (i
= 0, dep
= mod
->deps
; i
< mod
->ndeps
; ++i
, ++dep
) {
297 struct module
*o
, *d
= dep
->dep
;
299 /* Make sure the indicated dependencies are really modules. */
301 printk(KERN_ERR
"init_module: self-referential "
302 "dependency in mod->deps.\n");
306 for (o
= module_list
; o
!= &kernel_module
; o
= o
->next
)
307 if (o
== d
) goto found_dep
;
309 printk(KERN_ERR
"init_module: found dependency that is "
310 "(no longer?) a module.\n");
315 dep
->next_ref
= d
->refs
;
317 /* Being referenced by a dependent module counts as a
318 use as far as kmod is concerned. */
319 d
->flags
|= MOD_USED_ONCE
;
322 /* Free our temporary memory. */
323 put_mod_name(n_name
);
326 /* Initialize the module. */
327 mod
->flags
|= MOD_INITIALIZING
;
328 atomic_set(&mod
->uc
.usecount
,1);
329 if (mod
->init
&& (error
= mod
->init()) != 0) {
330 atomic_set(&mod
->uc
.usecount
,0);
331 mod
->flags
&= ~MOD_INITIALIZING
;
332 if (error
> 0) /* Buggy module */
336 atomic_dec(&mod
->uc
.usecount
);
338 /* And set it running. */
339 mod
->flags
= (mod
->flags
| MOD_RUNNING
) & ~MOD_INITIALIZING
;
344 put_mod_name(n_name
);
354 static spinlock_t unload_lock
= SPIN_LOCK_UNLOCKED
;
355 int try_inc_mod_count(struct module
*mod
)
359 spin_lock(&unload_lock
);
360 if (mod
->flags
& MOD_DELETED
)
363 __MOD_INC_USE_COUNT(mod
);
364 spin_unlock(&unload_lock
);
370 sys_delete_module(const char *name_user
)
372 struct module
*mod
, *next
;
375 int something_changed
;
377 if (!capable(CAP_SYS_MODULE
))
382 if ((error
= get_mod_name(name_user
, &name
)) < 0)
390 if ((mod
= find_module(name
)) == NULL
) {
396 if (mod
->refs
!= NULL
)
399 spin_lock(&unload_lock
);
400 if (!__MOD_IN_USE(mod
)) {
401 mod
->flags
|= MOD_DELETED
;
402 spin_unlock(&unload_lock
);
406 spin_unlock(&unload_lock
);
411 /* Do automatic reaping */
413 something_changed
= 0;
414 for (mod
= module_list
; mod
!= &kernel_module
; mod
= next
) {
416 spin_lock(&unload_lock
);
417 if (mod
->refs
== NULL
418 && (mod
->flags
& MOD_AUTOCLEAN
)
419 && (mod
->flags
& MOD_RUNNING
)
420 && !(mod
->flags
& MOD_DELETED
)
421 && (mod
->flags
& MOD_USED_ONCE
)
422 && !__MOD_IN_USE(mod
)) {
423 if ((mod
->flags
& MOD_VISITED
)
424 && !(mod
->flags
& MOD_JUST_FREED
)) {
425 spin_unlock(&unload_lock
);
426 mod
->flags
&= ~MOD_VISITED
;
428 mod
->flags
|= MOD_DELETED
;
429 spin_unlock(&unload_lock
);
431 something_changed
= 1;
434 spin_unlock(&unload_lock
);
437 if (something_changed
)
439 for (mod
= module_list
; mod
!= &kernel_module
; mod
= mod
->next
)
440 mod
->flags
&= ~MOD_JUST_FREED
;
447 /* Query various bits about modules. */
450 qm_modules(char *buf
, size_t bufsize
, size_t *ret
)
453 size_t nmod
, space
, len
;
457 for (mod
=module_list
; mod
!= &kernel_module
; mod
=mod
->next
, ++nmod
) {
458 len
= strlen(mod
->name
)+1;
460 goto calc_space_needed
;
461 if (copy_to_user(buf
, mod
->name
, len
))
468 if (put_user(nmod
, ret
))
475 while ((mod
= mod
->next
) != &kernel_module
)
476 space
+= strlen(mod
->name
)+1;
478 if (put_user(space
, ret
))
485 qm_deps(struct module
*mod
, char *buf
, size_t bufsize
, size_t *ret
)
487 size_t i
, space
, len
;
489 if (mod
== &kernel_module
)
491 if (!MOD_CAN_QUERY(mod
))
492 if (put_user(0, ret
))
498 for (i
= 0; i
< mod
->ndeps
; ++i
) {
499 const char *dep_name
= mod
->deps
[i
].dep
->name
;
501 len
= strlen(dep_name
)+1;
503 goto calc_space_needed
;
504 if (copy_to_user(buf
, dep_name
, len
))
511 if (put_user(i
, ret
))
518 while (++i
< mod
->ndeps
)
519 space
+= strlen(mod
->deps
[i
].dep
->name
)+1;
521 if (put_user(space
, ret
))
528 qm_refs(struct module
*mod
, char *buf
, size_t bufsize
, size_t *ret
)
530 size_t nrefs
, space
, len
;
531 struct module_ref
*ref
;
533 if (mod
== &kernel_module
)
535 if (!MOD_CAN_QUERY(mod
))
536 if (put_user(0, ret
))
542 for (nrefs
= 0, ref
= mod
->refs
; ref
; ++nrefs
, ref
= ref
->next_ref
) {
543 const char *ref_name
= ref
->ref
->name
;
545 len
= strlen(ref_name
)+1;
547 goto calc_space_needed
;
548 if (copy_to_user(buf
, ref_name
, len
))
555 if (put_user(nrefs
, ret
))
562 while ((ref
= ref
->next_ref
) != NULL
)
563 space
+= strlen(ref
->ref
->name
)+1;
565 if (put_user(space
, ret
))
572 qm_symbols(struct module
*mod
, char *buf
, size_t bufsize
, size_t *ret
)
574 size_t i
, space
, len
;
575 struct module_symbol
*s
;
579 if (!MOD_CAN_QUERY(mod
))
580 if (put_user(0, ret
))
585 space
= mod
->nsyms
* 2*sizeof(void *);
591 goto calc_space_needed
;
593 if (!access_ok(VERIFY_WRITE
, buf
, space
))
597 vals
= (unsigned long *)buf
;
600 for (; i
< mod
->nsyms
; ++i
, ++s
, vals
+= 2) {
601 len
= strlen(s
->name
)+1;
603 goto calc_space_needed
;
605 if (copy_to_user(strings
, s
->name
, len
)
606 || __put_user(s
->value
, vals
+0)
607 || __put_user(space
, vals
+1))
615 if (put_user(i
, ret
))
621 for (; i
< mod
->nsyms
; ++i
, ++s
)
622 space
+= strlen(s
->name
)+1;
624 if (put_user(space
, ret
))
631 qm_info(struct module
*mod
, char *buf
, size_t bufsize
, size_t *ret
)
635 if (mod
== &kernel_module
)
638 if (sizeof(struct module_info
) <= bufsize
) {
639 struct module_info info
;
640 info
.addr
= (unsigned long)mod
;
641 info
.size
= mod
->size
;
642 info
.flags
= mod
->flags
;
643 info
.usecount
= (mod_member_present(mod
, can_unload
)
644 && mod
->can_unload
? -1 : atomic_read(&mod
->uc
.usecount
));
646 if (copy_to_user(buf
, &info
, sizeof(struct module_info
)))
651 if (put_user(sizeof(struct module_info
), ret
))
658 sys_query_module(const char *name_user
, int which
, char *buf
, size_t bufsize
,
665 if (name_user
== NULL
)
666 mod
= &kernel_module
;
671 if ((namelen
= get_mod_name(name_user
, &name
)) < 0) {
677 mod
= &kernel_module
;
678 else if ((mod
= find_module(name
)) == NULL
) {
691 err
= qm_modules(buf
, bufsize
, ret
);
694 err
= qm_deps(mod
, buf
, bufsize
, ret
);
697 err
= qm_refs(mod
, buf
, bufsize
, ret
);
700 err
= qm_symbols(mod
, buf
, bufsize
, ret
);
703 err
= qm_info(mod
, buf
, bufsize
, ret
);
715 * Copy the kernel symbol table to user space. If the argument is
716 * NULL, just return the size of the table.
718 * This call is obsolete. New programs should use query_module+QM_SYMBOLS
719 * which does not arbitrarily limit the length of symbols.
723 sys_get_kernel_syms(struct kernel_sym
*table
)
727 struct kernel_sym ksym
;
730 for (mod
= module_list
, i
= 0; mod
; mod
= mod
->next
) {
731 /* include the count for the module name! */
738 /* So that we don't give the user our stack content */
739 memset (&ksym
, 0, sizeof (ksym
));
741 for (mod
= module_list
, i
= 0; mod
; mod
= mod
->next
) {
742 struct module_symbol
*msym
;
745 if (!MOD_CAN_QUERY(mod
))
748 /* magic: write module info as a pseudo symbol */
749 ksym
.value
= (unsigned long)mod
;
751 strncpy(ksym
.name
+1, mod
->name
, sizeof(ksym
.name
)-1);
752 ksym
.name
[sizeof(ksym
.name
)-1] = '\0';
754 if (copy_to_user(table
, &ksym
, sizeof(ksym
)) != 0)
761 for (j
= 0, msym
= mod
->syms
; j
< mod
->nsyms
; ++j
, ++msym
) {
762 ksym
.value
= msym
->value
;
763 strncpy(ksym
.name
, msym
->name
, sizeof(ksym
.name
));
764 ksym
.name
[sizeof(ksym
.name
)-1] = '\0';
766 if (copy_to_user(table
, &ksym
, sizeof(ksym
)) != 0)
777 * Look for a module by name, ignoring modules marked for deletion.
780 static struct module
*
781 find_module(const char *name
)
785 for (mod
= module_list
; mod
; mod
= mod
->next
) {
786 if (mod
->flags
& MOD_DELETED
)
788 if (!strcmp(mod
->name
, name
))
796 * Free the given module.
800 free_module(struct module
*mod
, int tag_freed
)
802 struct module_ref
*dep
;
805 /* Let the module clean up. */
807 if (mod
->flags
& MOD_RUNNING
)
811 mod
->flags
&= ~MOD_RUNNING
;
814 /* Remove the module from the dependency lists. */
816 for (i
= 0, dep
= mod
->deps
; i
< mod
->ndeps
; ++i
, ++dep
) {
817 struct module_ref
**pp
;
818 for (pp
= &dep
->dep
->refs
; *pp
!= dep
; pp
= &(*pp
)->next_ref
)
821 if (tag_freed
&& dep
->dep
->refs
== NULL
)
822 dep
->dep
->flags
|= MOD_JUST_FREED
;
825 /* And from the main module list. */
827 if (mod
== module_list
) {
828 module_list
= mod
->next
;
831 for (p
= module_list
; p
->next
!= mod
; p
= p
->next
)
836 /* And free the memory. */
842 * Called by the /proc file system to return a current list of modules.
845 int get_module_list(char *p
)
847 size_t left
= PAGE_SIZE
;
850 struct module_ref
*ref
;
852 for (mod
= module_list
; mod
!= &kernel_module
; mod
= mod
->next
) {
856 #define safe_copy_str(str, len) \
860 memcpy(p, str, len); p += len, left -= len; \
862 #define safe_copy_cstr(str) safe_copy_str(str, sizeof(str)-1)
864 len
= strlen(mod
->name
);
865 safe_copy_str(mod
->name
, len
);
867 if ((len
= 20 - len
) > 0) {
875 len
= sprintf(tmpstr
, "%8lu", mod
->size
);
876 safe_copy_str(tmpstr
, len
);
878 if (mod
->flags
& MOD_RUNNING
) {
879 len
= sprintf(tmpstr
, "%4ld",
880 (mod_member_present(mod
, can_unload
)
882 ? -1L : (long)atomic_read(&mod
->uc
.usecount
)));
883 safe_copy_str(tmpstr
, len
);
886 if (mod
->flags
& MOD_DELETED
)
887 safe_copy_cstr(" (deleted)");
888 else if (mod
->flags
& MOD_RUNNING
) {
889 if (mod
->flags
& MOD_AUTOCLEAN
)
890 safe_copy_cstr(" (autoclean)");
891 if (!(mod
->flags
& MOD_USED_ONCE
))
892 safe_copy_cstr(" (unused)");
894 else if (mod
->flags
& MOD_INITIALIZING
)
895 safe_copy_cstr(" (initializing)");
897 safe_copy_cstr(" (uninitialized)");
899 if ((ref
= mod
->refs
) != NULL
) {
900 safe_copy_cstr(" [");
904 safe_copy_str(q
, len
);
906 if ((ref
= ref
->next_ref
) != NULL
)
913 safe_copy_cstr("\n");
916 #undef safe_copy_cstr
920 return PAGE_SIZE
- left
;
924 * Called by the /proc file system to return a current list of ksyms.
928 get_ksyms_list(char *buf
, char **start
, off_t offset
, int length
)
932 int len
= 0; /* code from net/ipv4/proc.c */
936 for (mod
= module_list
; mod
; mod
= mod
->next
) {
938 struct module_symbol
*sym
;
940 if (!MOD_CAN_QUERY(mod
))
943 for (i
= mod
->nsyms
, sym
= mod
->syms
; i
> 0; --i
, ++sym
) {
946 len
+= sprintf(p
, "%0*lx %s\t[%s]\n",
947 (int)(2*sizeof(void*)),
948 sym
->value
, sym
->name
,
951 len
+= sprintf(p
, "%0*lx %s\n",
952 (int)(2*sizeof(void*)),
953 sym
->value
, sym
->name
);
961 if (pos
> offset
+length
)
966 *start
= buf
+ (offset
- begin
);
967 len
-= (offset
- begin
);
974 * Gets the address for a symbol in the given module. If modname is
975 * NULL, it looks for the name in any registered symbol table. If the
976 * modname is an empty string, it looks for the symbol in kernel exported
977 * symbol tables. Increase the usage count of the module in which the
978 * symbol was found - it's the only way we can guarantee that it's still
979 * there by the time our caller actually uses it.
982 get_module_symbol(char *modname
, char *symname
)
985 struct module_symbol
*sym
;
988 spin_lock(&unload_lock
);
989 for (mp
= module_list
; mp
; mp
= mp
->next
) {
990 if (((modname
== NULL
) || (strcmp(mp
->name
, modname
) == 0)) &&
993 for (i
= mp
->nsyms
, sym
= mp
->syms
;
996 if (strcmp(sym
->name
, symname
) == 0) {
997 __MOD_INC_USE_COUNT(mp
);
998 spin_unlock(&unload_lock
);
1004 spin_unlock(&unload_lock
);
1008 /* Decrease the use count of the module containing a symbol with the
1011 void put_module_symbol(unsigned long addr
)
1015 for (mp
= module_list
; mp
; mp
= mp
->next
) {
1016 if (MOD_CAN_QUERY(mp
) &&
1017 addr
>= (unsigned long)mp
&&
1018 addr
< (unsigned long)mp
+ mp
->size
) {
1019 __MOD_DEC_USE_COUNT(mp
);
1025 #else /* CONFIG_MODULES */
1027 /* Dummy syscalls for people who don't want modules */
1029 asmlinkage
unsigned long
1030 sys_create_module(const char *name_user
, size_t size
)
1036 sys_init_module(const char *name_user
, struct module
*mod_user
)
1042 sys_delete_module(const char *name_user
)
1048 sys_query_module(const char *name_user
, int which
, char *buf
, size_t bufsize
,
1051 /* Let the program know about the new interface. Not that
1052 it'll do them much good. */
1060 sys_get_kernel_syms(struct kernel_sym
*table
)
1065 int try_inc_mod_count(struct module
*mod
)
1070 #endif /* CONFIG_MODULES */