v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / kernel / module.c
1 #include <linux/config.h>
2 #include <linux/mm.h>
3 #include <linux/module.h>
4 #include <asm/module.h>
5 #include <asm/uaccess.h>
6 #include <linux/vmalloc.h>
7 #include <linux/smp_lock.h>
8 #include <asm/pgalloc.h>
9 #include <linux/init.h>
10 #include <linux/slab.h>
11 #include <linux/kmod.h>
12
13 /*
14  * Originally by Anonymous (as far as I know...)
15  * Linux version by Bas Laarhoven <bas@vimec.nl>
16  * 0.99.14 version by Jon Tombs <jon@gtex02.us.es>,
17  * Heavily modified by Bjorn Ekwall <bj0rn@blox.se> May 1994 (C)
18  * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
19  * Add MOD_INITIALIZING Keith Owens <kaos@ocs.com.au> Nov 1999
20  * Add kallsyms support, Keith Owens <kaos@ocs.com.au> Apr 2000
21  * Add asm/module support, IA64 has special requirements.  Keith Owens <kaos@ocs.com.au> Sep 2000
22  * Fix assorted bugs in module verification.  Keith Owens <kaos@ocs.com.au> Sep 2000
23  * Fix sys_init_module race, Andrew Morton <andrewm@uow.edu.au> Oct 2000
24  *     http://www.uwsg.iu.edu/hypermail/linux/kernel/0008.3/0379.html
25  * Replace xxx_module_symbol with inter_module_xxx.  Keith Owens <kaos@ocs.com.au> Oct 2000
26  * Add a module list lock for kernel fault race fixing. Alan Cox <alan@redhat.com>
27  *
28  * This source is covered by the GNU GPL, the same as all kernel sources.
29  */
30
31 #if defined(CONFIG_MODULES) || defined(CONFIG_KALLSYMS)
32
33 extern struct module_symbol __start___ksymtab[];
34 extern struct module_symbol __stop___ksymtab[];
35
36 extern const struct exception_table_entry __start___ex_table[];
37 extern const struct exception_table_entry __stop___ex_table[];
38
39 extern const char __start___kallsyms[] __attribute__ ((weak));
40 extern const char __stop___kallsyms[] __attribute__ ((weak));
41
42 struct module kernel_module =
43 {
44         size_of_struct:         sizeof(struct module),
45         name:                   "",
46         uc:                     {ATOMIC_INIT(1)},
47         flags:                  MOD_RUNNING,
48         syms:                   __start___ksymtab,
49         ex_table_start:         __start___ex_table,
50         ex_table_end:           __stop___ex_table,
51         kallsyms_start:         __start___kallsyms,
52         kallsyms_end:           __stop___kallsyms,
53 };
54
55 struct module *module_list = &kernel_module;
56
57 #endif  /* defined(CONFIG_MODULES) || defined(CONFIG_KALLSYMS) */
58
59 /* inter_module functions are always available, even when the kernel is
60  * compiled without modules.  Consumers of inter_module_xxx routines
61  * will always work, even when both are built into the kernel, this
62  * approach removes lots of #ifdefs in mainline code.
63  */
64
65 static struct list_head ime_list = LIST_HEAD_INIT(ime_list);
66 static spinlock_t ime_lock = SPIN_LOCK_UNLOCKED;
67 static int kmalloc_failed;
68
69 /*
70  *      This lock prevents modifications that might race the kernel fault
71  *      fixups. It does not prevent reader walks that the modules code
72  *      does. The kernel lock does that.
73  *
74  *      Since vmalloc fault fixups occur in any context this lock is taken
75  *      irqsave at all times.
76  */
77  
78 spinlock_t modlist_lock = SPIN_LOCK_UNLOCKED;
79
80 /**
81  * inter_module_register - register a new set of inter module data.
82  * @im_name: an arbitrary string to identify the data, must be unique
83  * @owner: module that is registering the data, always use THIS_MODULE
84  * @userdata: pointer to arbitrary userdata to be registered
85  *
86  * Description: Check that the im_name has not already been registered,
87  * complain if it has.  For new data, add it to the inter_module_entry
88  * list.
89  */
90 void inter_module_register(const char *im_name, struct module *owner, const void *userdata)
91 {
92         struct list_head *tmp;
93         struct inter_module_entry *ime, *ime_new;
94
95         if (!(ime_new = kmalloc(sizeof(*ime), GFP_KERNEL))) {
96                 /* Overloaded kernel, not fatal */
97                 printk(KERN_ERR
98                         "Aiee, inter_module_register: cannot kmalloc entry for '%s'\n",
99                         im_name);
100                 kmalloc_failed = 1;
101                 return;
102         }
103         memset(ime_new, 0, sizeof(*ime_new));
104         ime_new->im_name = im_name;
105         ime_new->owner = owner;
106         ime_new->userdata = userdata;
107
108         spin_lock(&ime_lock);
109         list_for_each(tmp, &ime_list) {
110                 ime = list_entry(tmp, struct inter_module_entry, list);
111                 if (strcmp(ime->im_name, im_name) == 0) {
112                         spin_unlock(&ime_lock);
113                         kfree(ime_new);
114                         /* Program logic error, fatal */
115                         printk(KERN_ERR "inter_module_register: duplicate im_name '%s'", im_name);
116                         BUG();
117                 }
118         }
119         list_add(&(ime_new->list), &ime_list);
120         spin_unlock(&ime_lock);
121 }
122
123 /**
124  * inter_module_unregister - unregister a set of inter module data.
125  * @im_name: an arbitrary string to identify the data, must be unique
126  *
127  * Description: Check that the im_name has been registered, complain if
128  * it has not.  For existing data, remove it from the
129  * inter_module_entry list.
130  */
131 void inter_module_unregister(const char *im_name)
132 {
133         struct list_head *tmp;
134         struct inter_module_entry *ime;
135
136         spin_lock(&ime_lock);
137         list_for_each(tmp, &ime_list) {
138                 ime = list_entry(tmp, struct inter_module_entry, list);
139                 if (strcmp(ime->im_name, im_name) == 0) {
140                         list_del(&(ime->list));
141                         spin_unlock(&ime_lock);
142                         kfree(ime);
143                         return;
144                 }
145         }
146         spin_unlock(&ime_lock);
147         if (kmalloc_failed) {
148                 printk(KERN_ERR
149                         "inter_module_unregister: no entry for '%s', "
150                         "probably caused by previous kmalloc failure\n",
151                         im_name);
152                 return;
153         }
154         else {
155                 /* Program logic error, fatal */
156                 printk(KERN_ERR "inter_module_unregister: no entry for '%s'", im_name);
157                 BUG();
158         }
159 }
160
161 /**
162  * inter_module_get - return arbitrary userdata from another module.
163  * @im_name: an arbitrary string to identify the data, must be unique
164  *
165  * Description: If the im_name has not been registered, return NULL.
166  * Try to increment the use count on the owning module, if that fails
167  * then return NULL.  Otherwise return the userdata.
168  */
169 const void *inter_module_get(const char *im_name)
170 {
171         struct list_head *tmp;
172         struct inter_module_entry *ime;
173         const void *result = NULL;
174
175         spin_lock(&ime_lock);
176         list_for_each(tmp, &ime_list) {
177                 ime = list_entry(tmp, struct inter_module_entry, list);
178                 if (strcmp(ime->im_name, im_name) == 0) {
179                         if (try_inc_mod_count(ime->owner))
180                                 result = ime->userdata;
181                         break;
182                 }
183         }
184         spin_unlock(&ime_lock);
185         return(result);
186 }
187
188 /**
189  * inter_module_get_request - im get with automatic request_module.
190  * @im_name: an arbitrary string to identify the data, must be unique
191  * @modname: module that is expected to register im_name
192  *
193  * Description: If inter_module_get fails, do request_module then retry.
194  */
195 const void *inter_module_get_request(const char *im_name, const char *modname)
196 {
197         const void *result = inter_module_get(im_name);
198         if (!result) {
199                 request_module(modname);
200                 result = inter_module_get(im_name);
201         }
202         return(result);
203 }
204
205 /**
206  * inter_module_put - release use of data from another module.
207  * @im_name: an arbitrary string to identify the data, must be unique
208  *
209  * Description: If the im_name has not been registered, complain,
210  * otherwise decrement the use count on the owning module.
211  */
212 void inter_module_put(const char *im_name)
213 {
214         struct list_head *tmp;
215         struct inter_module_entry *ime;
216
217         spin_lock(&ime_lock);
218         list_for_each(tmp, &ime_list) {
219                 ime = list_entry(tmp, struct inter_module_entry, list);
220                 if (strcmp(ime->im_name, im_name) == 0) {
221                         if (ime->owner)
222                                 __MOD_DEC_USE_COUNT(ime->owner);
223                         spin_unlock(&ime_lock);
224                         return;
225                 }
226         }
227         spin_unlock(&ime_lock);
228         printk(KERN_ERR "inter_module_put: no entry for '%s'", im_name);
229         BUG();
230 }
231
232
233 #if defined(CONFIG_MODULES)     /* The rest of the source */
234
235 static long get_mod_name(const char *user_name, char **buf);
236 static void put_mod_name(char *buf);
237 struct module *find_module(const char *name);
238 void free_module(struct module *, int tag_freed);
239
240
241 /*
242  * Called at boot time
243  */
244
245 void __init init_modules(void)
246 {
247         kernel_module.nsyms = __stop___ksymtab - __start___ksymtab;
248
249 #ifdef __alpha__
250         __asm__("stq $29,%0" : "=m"(kernel_module.gp));
251 #endif
252 }
253
254 /*
255  * Copy the name of a module from user space.
256  */
257
258 static inline long
259 get_mod_name(const char *user_name, char **buf)
260 {
261         unsigned long page;
262         long retval;
263
264         page = __get_free_page(GFP_KERNEL);
265         if (!page)
266                 return -ENOMEM;
267
268         retval = strncpy_from_user((char *)page, user_name, PAGE_SIZE);
269         if (retval > 0) {
270                 if (retval < PAGE_SIZE) {
271                         *buf = (char *)page;
272                         return retval;
273                 }
274                 retval = -ENAMETOOLONG;
275         } else if (!retval)
276                 retval = -EINVAL;
277
278         free_page(page);
279         return retval;
280 }
281
282 static inline void
283 put_mod_name(char *buf)
284 {
285         free_page((unsigned long)buf);
286 }
287
288 /*
289  * Allocate space for a module.
290  */
291
292 asmlinkage unsigned long
293 sys_create_module(const char *name_user, size_t size)
294 {
295         char *name;
296         long namelen, error;
297         struct module *mod;
298         unsigned long flags;
299
300         if (!capable(CAP_SYS_MODULE))
301                 return -EPERM;
302         lock_kernel();
303         if ((namelen = get_mod_name(name_user, &name)) < 0) {
304                 error = namelen;
305                 goto err0;
306         }
307         if (size < sizeof(struct module)+namelen) {
308                 error = -EINVAL;
309                 goto err1;
310         }
311         if (find_module(name) != NULL) {
312                 error = -EEXIST;
313                 goto err1;
314         }
315         if ((mod = (struct module *)module_map(size)) == NULL) {
316                 error = -ENOMEM;
317                 goto err1;
318         }
319
320         memset(mod, 0, sizeof(*mod));
321         mod->size_of_struct = sizeof(*mod);
322         mod->name = (char *)(mod + 1);
323         mod->size = size;
324         memcpy((char*)(mod+1), name, namelen+1);
325
326         put_mod_name(name);
327
328         spin_lock_irqsave(&modlist_lock, flags);
329         mod->next = module_list;
330         module_list = mod;      /* link it in */
331         spin_unlock_irqrestore(&modlist_lock, flags);
332
333         error = (long) mod;
334         goto err0;
335 err1:
336         put_mod_name(name);
337 err0:
338         unlock_kernel();
339         return error;
340 }
341
342 /*
343  * Initialize a module.
344  */
345
346 asmlinkage long
347 sys_init_module(const char *name_user, struct module *mod_user)
348 {
349         struct module mod_tmp, *mod;
350         char *name, *n_name, *name_tmp = NULL;
351         long namelen, n_namelen, i, error;
352         unsigned long mod_user_size;
353         struct module_ref *dep;
354
355         if (!capable(CAP_SYS_MODULE))
356                 return -EPERM;
357         lock_kernel();
358         if ((namelen = get_mod_name(name_user, &name)) < 0) {
359                 error = namelen;
360                 goto err0;
361         }
362         if ((mod = find_module(name)) == NULL) {
363                 error = -ENOENT;
364                 goto err1;
365         }
366
367         /* Check module header size.  We allow a bit of slop over the
368            size we are familiar with to cope with a version of insmod
369            for a newer kernel.  But don't over do it. */
370         if ((error = get_user(mod_user_size, &mod_user->size_of_struct)) != 0)
371                 goto err1;
372         if (mod_user_size < (unsigned long)&((struct module *)0L)->persist_start
373             || mod_user_size > sizeof(struct module) + 16*sizeof(void*)) {
374                 printk(KERN_ERR "init_module: Invalid module header size.\n"
375                        KERN_ERR "A new version of the modutils is likely "
376                                 "needed.\n");
377                 error = -EINVAL;
378                 goto err1;
379         }
380
381         /* Hold the current contents while we play with the user's idea
382            of righteousness.  */
383         mod_tmp = *mod;
384         name_tmp = kmalloc(strlen(mod->name) + 1, GFP_KERNEL);  /* Where's kstrdup()? */
385         if (name_tmp == NULL) {
386                 error = -ENOMEM;
387                 goto err1;
388         }
389         strcpy(name_tmp, mod->name);
390
391         error = copy_from_user(mod, mod_user, mod_user_size);
392         if (error) {
393                 error = -EFAULT;
394                 goto err2;
395         }
396
397         /* Sanity check the size of the module.  */
398         error = -EINVAL;
399
400         if (mod->size > mod_tmp.size) {
401                 printk(KERN_ERR "init_module: Size of initialized module "
402                                 "exceeds size of created module.\n");
403                 goto err2;
404         }
405
406         /* Make sure all interesting pointers are sane.  */
407
408         if (!mod_bound(mod->name, namelen, mod)) {
409                 printk(KERN_ERR "init_module: mod->name out of bounds.\n");
410                 goto err2;
411         }
412         if (mod->nsyms && !mod_bound(mod->syms, mod->nsyms, mod)) {
413                 printk(KERN_ERR "init_module: mod->syms out of bounds.\n");
414                 goto err2;
415         }
416         if (mod->ndeps && !mod_bound(mod->deps, mod->ndeps, mod)) {
417                 printk(KERN_ERR "init_module: mod->deps out of bounds.\n");
418                 goto err2;
419         }
420         if (mod->init && !mod_bound(mod->init, 0, mod)) {
421                 printk(KERN_ERR "init_module: mod->init out of bounds.\n");
422                 goto err2;
423         }
424         if (mod->cleanup && !mod_bound(mod->cleanup, 0, mod)) {
425                 printk(KERN_ERR "init_module: mod->cleanup out of bounds.\n");
426                 goto err2;
427         }
428         if (mod->ex_table_start > mod->ex_table_end
429             || (mod->ex_table_start &&
430                 !((unsigned long)mod->ex_table_start >= ((unsigned long)mod + mod->size_of_struct)
431                   && ((unsigned long)mod->ex_table_end
432                       < (unsigned long)mod + mod->size)))
433             || (((unsigned long)mod->ex_table_start
434                  - (unsigned long)mod->ex_table_end)
435                 % sizeof(struct exception_table_entry))) {
436                 printk(KERN_ERR "init_module: mod->ex_table_* invalid.\n");
437                 goto err2;
438         }
439         if (mod->flags & ~MOD_AUTOCLEAN) {
440                 printk(KERN_ERR "init_module: mod->flags invalid.\n");
441                 goto err2;
442         }
443 #ifdef __alpha__
444         if (!mod_bound(mod->gp - 0x8000, 0, mod)) {
445                 printk(KERN_ERR "init_module: mod->gp out of bounds.\n");
446                 goto err2;
447         }
448 #endif
449         if (mod_member_present(mod, can_unload)
450             && mod->can_unload && !mod_bound(mod->can_unload, 0, mod)) {
451                 printk(KERN_ERR "init_module: mod->can_unload out of bounds.\n");
452                 goto err2;
453         }
454         if (mod_member_present(mod, kallsyms_end)) {
455             if (mod->kallsyms_end &&
456                 (!mod_bound(mod->kallsyms_start, 0, mod) ||
457                  !mod_bound(mod->kallsyms_end, 0, mod))) {
458                 printk(KERN_ERR "init_module: mod->kallsyms out of bounds.\n");
459                 goto err2;
460             }
461             if (mod->kallsyms_start > mod->kallsyms_end) {
462                 printk(KERN_ERR "init_module: mod->kallsyms invalid.\n");
463                 goto err2;
464             }
465         }
466         if (mod_member_present(mod, archdata_end)) {
467             if (mod->archdata_end &&
468                 (!mod_bound(mod->archdata_start, 0, mod) ||
469                  !mod_bound(mod->archdata_end, 0, mod))) {
470                 printk(KERN_ERR "init_module: mod->archdata out of bounds.\n");
471                 goto err2;
472             }
473             if (mod->archdata_start > mod->archdata_end) {
474                 printk(KERN_ERR "init_module: mod->archdata invalid.\n");
475                 goto err2;
476             }
477         }
478         if (mod_member_present(mod, kernel_data) && mod->kernel_data) {
479             printk(KERN_ERR "init_module: mod->kernel_data must be zero.\n");
480             goto err2;
481         }
482
483         /* Check that the user isn't doing something silly with the name.  */
484
485         if ((n_namelen = get_mod_name(mod->name - (unsigned long)mod
486                                       + (unsigned long)mod_user,
487                                       &n_name)) < 0) {
488                 printk(KERN_ERR "init_module: get_mod_name failure.\n");
489                 error = n_namelen;
490                 goto err2;
491         }
492         if (namelen != n_namelen || strcmp(n_name, mod_tmp.name) != 0) {
493                 printk(KERN_ERR "init_module: changed module name to "
494                                 "`%s' from `%s'\n",
495                        n_name, mod_tmp.name);
496                 goto err3;
497         }
498
499         /* Ok, that's about all the sanity we can stomach; copy the rest.  */
500
501         if (copy_from_user((char *)mod+mod_user_size,
502                            (char *)mod_user+mod_user_size,
503                            mod->size-mod_user_size)) {
504                 error = -EFAULT;
505                 goto err3;
506         }
507
508         if (module_arch_init(mod))
509                 goto err3;
510
511         /* On some machines it is necessary to do something here
512            to make the I and D caches consistent.  */
513         flush_icache_range((unsigned long)mod, (unsigned long)mod + mod->size);
514
515         mod->next = mod_tmp.next;
516         mod->refs = NULL;
517
518         /* Sanity check the module's dependents */
519         for (i = 0, dep = mod->deps; i < mod->ndeps; ++i, ++dep) {
520                 struct module *o, *d = dep->dep;
521
522                 /* Make sure the indicated dependencies are really modules.  */
523                 if (d == mod) {
524                         printk(KERN_ERR "init_module: self-referential "
525                                         "dependency in mod->deps.\n");
526                         goto err3;
527                 }
528
529                 /* Scan the current modules for this dependency */
530                 for (o = module_list; o != &kernel_module && o != d; o = o->next)
531                         ;
532
533                 if (o != d) {
534                         printk(KERN_ERR "init_module: found dependency that is "
535                                 "(no longer?) a module.\n");
536                         goto err3;
537                 }
538         }
539
540         /* Update module references.  */
541         for (i = 0, dep = mod->deps; i < mod->ndeps; ++i, ++dep) {
542                 struct module *d = dep->dep;
543
544                 dep->ref = mod;
545                 dep->next_ref = d->refs;
546                 d->refs = dep;
547                 /* Being referenced by a dependent module counts as a
548                    use as far as kmod is concerned.  */
549                 d->flags |= MOD_USED_ONCE;
550         }
551
552         /* Free our temporary memory.  */
553         put_mod_name(n_name);
554         put_mod_name(name);
555
556         /* Initialize the module.  */
557         atomic_set(&mod->uc.usecount,1);
558         mod->flags |= MOD_INITIALIZING;
559         if (mod->init && (error = mod->init()) != 0) {
560                 atomic_set(&mod->uc.usecount,0);
561                 mod->flags &= ~MOD_INITIALIZING;
562                 if (error > 0)  /* Buggy module */
563                         error = -EBUSY;
564                 goto err0;
565         }
566         atomic_dec(&mod->uc.usecount);
567
568         /* And set it running.  */
569         mod->flags = (mod->flags | MOD_RUNNING) & ~MOD_INITIALIZING;
570         error = 0;
571         goto err0;
572
573 err3:
574         put_mod_name(n_name);
575 err2:
576         *mod = mod_tmp;
577         strcpy((char *)mod->name, name_tmp);    /* We know there is room for this */
578 err1:
579         put_mod_name(name);
580 err0:
581         unlock_kernel();
582         kfree(name_tmp);
583         return error;
584 }
585
586 static spinlock_t unload_lock = SPIN_LOCK_UNLOCKED;
587 int try_inc_mod_count(struct module *mod)
588 {
589         int res = 1;
590         if (mod) {
591                 spin_lock(&unload_lock);
592                 if (mod->flags & MOD_DELETED)
593                         res = 0;
594                 else
595                         __MOD_INC_USE_COUNT(mod);
596                 spin_unlock(&unload_lock);
597         }
598         return res;
599 }
600
601 asmlinkage long
602 sys_delete_module(const char *name_user)
603 {
604         struct module *mod, *next;
605         char *name;
606         long error;
607         int something_changed;
608
609         if (!capable(CAP_SYS_MODULE))
610                 return -EPERM;
611
612         lock_kernel();
613         if (name_user) {
614                 if ((error = get_mod_name(name_user, &name)) < 0)
615                         goto out;
616                 error = -ENOENT;
617                 if ((mod = find_module(name)) == NULL) {
618                         put_mod_name(name);
619                         goto out;
620                 }
621                 put_mod_name(name);
622                 error = -EBUSY;
623                 if (mod->refs != NULL)
624                         goto out;
625
626                 spin_lock(&unload_lock);
627                 if (!__MOD_IN_USE(mod)) {
628                         mod->flags |= MOD_DELETED;
629                         spin_unlock(&unload_lock);
630                         free_module(mod, 0);
631                         error = 0;
632                 } else {
633                         spin_unlock(&unload_lock);
634                 }
635                 goto out;
636         }
637
638         /* Do automatic reaping */
639 restart:
640         something_changed = 0;
641         
642         for (mod = module_list; mod != &kernel_module; mod = next) {
643                 next = mod->next;
644                 spin_lock(&unload_lock);
645                 if (mod->refs == NULL
646                     && (mod->flags & MOD_AUTOCLEAN)
647                     && (mod->flags & MOD_RUNNING)
648                     && !(mod->flags & MOD_DELETED)
649                     && (mod->flags & MOD_USED_ONCE)
650                     && !__MOD_IN_USE(mod)) {
651                         if ((mod->flags & MOD_VISITED)
652                             && !(mod->flags & MOD_JUST_FREED)) {
653                                 spin_unlock(&unload_lock);
654                                 mod->flags &= ~MOD_VISITED;
655                         } else {
656                                 mod->flags |= MOD_DELETED;
657                                 spin_unlock(&unload_lock);
658                                 free_module(mod, 1);
659                                 something_changed = 1;
660                         }
661                 } else {
662                         spin_unlock(&unload_lock);
663                 }
664         }
665         
666         if (something_changed)
667                 goto restart;
668                 
669         for (mod = module_list; mod != &kernel_module; mod = mod->next)
670                 mod->flags &= ~MOD_JUST_FREED;
671         
672         error = 0;
673 out:
674         unlock_kernel();
675         return error;
676 }
677
678 /* Query various bits about modules.  */
679
680 static int
681 qm_modules(char *buf, size_t bufsize, size_t *ret)
682 {
683         struct module *mod;
684         size_t nmod, space, len;
685
686         nmod = space = 0;
687
688         for (mod=module_list; mod != &kernel_module; mod=mod->next, ++nmod) {
689                 len = strlen(mod->name)+1;
690                 if (len > bufsize)
691                         goto calc_space_needed;
692                 if (copy_to_user(buf, mod->name, len))
693                         return -EFAULT;
694                 buf += len;
695                 bufsize -= len;
696                 space += len;
697         }
698
699         if (put_user(nmod, ret))
700                 return -EFAULT;
701         else
702                 return 0;
703
704 calc_space_needed:
705         space += len;
706         while ((mod = mod->next) != &kernel_module)
707                 space += strlen(mod->name)+1;
708
709         if (put_user(space, ret))
710                 return -EFAULT;
711         else
712                 return -ENOSPC;
713 }
714
715 static int
716 qm_deps(struct module *mod, char *buf, size_t bufsize, size_t *ret)
717 {
718         size_t i, space, len;
719
720         if (mod == &kernel_module)
721                 return -EINVAL;
722         if (!MOD_CAN_QUERY(mod))
723                 if (put_user(0, ret))
724                         return -EFAULT;
725                 else
726                         return 0;
727
728         space = 0;
729         for (i = 0; i < mod->ndeps; ++i) {
730                 const char *dep_name = mod->deps[i].dep->name;
731
732                 len = strlen(dep_name)+1;
733                 if (len > bufsize)
734                         goto calc_space_needed;
735                 if (copy_to_user(buf, dep_name, len))
736                         return -EFAULT;
737                 buf += len;
738                 bufsize -= len;
739                 space += len;
740         }
741
742         if (put_user(i, ret))
743                 return -EFAULT;
744         else
745                 return 0;
746
747 calc_space_needed:
748         space += len;
749         while (++i < mod->ndeps)
750                 space += strlen(mod->deps[i].dep->name)+1;
751
752         if (put_user(space, ret))
753                 return -EFAULT;
754         else
755                 return -ENOSPC;
756 }
757
758 static int
759 qm_refs(struct module *mod, char *buf, size_t bufsize, size_t *ret)
760 {
761         size_t nrefs, space, len;
762         struct module_ref *ref;
763
764         if (mod == &kernel_module)
765                 return -EINVAL;
766         if (!MOD_CAN_QUERY(mod))
767                 if (put_user(0, ret))
768                         return -EFAULT;
769                 else
770                         return 0;
771
772         space = 0;
773         for (nrefs = 0, ref = mod->refs; ref ; ++nrefs, ref = ref->next_ref) {
774                 const char *ref_name = ref->ref->name;
775
776                 len = strlen(ref_name)+1;
777                 if (len > bufsize)
778                         goto calc_space_needed;
779                 if (copy_to_user(buf, ref_name, len))
780                         return -EFAULT;
781                 buf += len;
782                 bufsize -= len;
783                 space += len;
784         }
785
786         if (put_user(nrefs, ret))
787                 return -EFAULT;
788         else
789                 return 0;
790
791 calc_space_needed:
792         space += len;
793         while ((ref = ref->next_ref) != NULL)
794                 space += strlen(ref->ref->name)+1;
795
796         if (put_user(space, ret))
797                 return -EFAULT;
798         else
799                 return -ENOSPC;
800 }
801
802 static int
803 qm_symbols(struct module *mod, char *buf, size_t bufsize, size_t *ret)
804 {
805         size_t i, space, len;
806         struct module_symbol *s;
807         char *strings;
808         unsigned long *vals;
809
810         if (!MOD_CAN_QUERY(mod))
811                 if (put_user(0, ret))
812                         return -EFAULT;
813                 else
814                         return 0;
815
816         space = mod->nsyms * 2*sizeof(void *);
817
818         i = len = 0;
819         s = mod->syms;
820
821         if (space > bufsize)
822                 goto calc_space_needed;
823
824         if (!access_ok(VERIFY_WRITE, buf, space))
825                 return -EFAULT;
826
827         bufsize -= space;
828         vals = (unsigned long *)buf;
829         strings = buf+space;
830
831         for (; i < mod->nsyms ; ++i, ++s, vals += 2) {
832                 len = strlen(s->name)+1;
833                 if (len > bufsize)
834                         goto calc_space_needed;
835
836                 if (copy_to_user(strings, s->name, len)
837                     || __put_user(s->value, vals+0)
838                     || __put_user(space, vals+1))
839                         return -EFAULT;
840
841                 strings += len;
842                 bufsize -= len;
843                 space += len;
844         }
845         if (put_user(i, ret))
846                 return -EFAULT;
847         else
848                 return 0;
849
850 calc_space_needed:
851         for (; i < mod->nsyms; ++i, ++s)
852                 space += strlen(s->name)+1;
853
854         if (put_user(space, ret))
855                 return -EFAULT;
856         else
857                 return -ENOSPC;
858 }
859
860 static int
861 qm_info(struct module *mod, char *buf, size_t bufsize, size_t *ret)
862 {
863         int error = 0;
864
865         if (mod == &kernel_module)
866                 return -EINVAL;
867
868         if (sizeof(struct module_info) <= bufsize) {
869                 struct module_info info;
870                 info.addr = (unsigned long)mod;
871                 info.size = mod->size;
872                 info.flags = mod->flags;
873                 
874                 /* usecount is one too high here - report appropriately to
875                    compensate for locking */
876                 info.usecount = (mod_member_present(mod, can_unload)
877                                  && mod->can_unload ? -1 : atomic_read(&mod->uc.usecount)-1);
878
879                 if (copy_to_user(buf, &info, sizeof(struct module_info)))
880                         return -EFAULT;
881         } else
882                 error = -ENOSPC;
883
884         if (put_user(sizeof(struct module_info), ret))
885                 return -EFAULT;
886
887         return error;
888 }
889
890 asmlinkage long
891 sys_query_module(const char *name_user, int which, char *buf, size_t bufsize,
892                  size_t *ret)
893 {
894         struct module *mod;
895         int err;
896
897         lock_kernel();
898         if (name_user == NULL)
899                 mod = &kernel_module;
900         else {
901                 long namelen;
902                 char *name;
903
904                 if ((namelen = get_mod_name(name_user, &name)) < 0) {
905                         err = namelen;
906                         goto out;
907                 }
908                 err = -ENOENT;
909                 if ((mod = find_module(name)) == NULL) {
910                         put_mod_name(name);
911                         goto out;
912                 }
913                 put_mod_name(name);
914         }
915
916         /* __MOD_ touches the flags. We must avoid that */
917         
918         atomic_inc(&mod->uc.usecount);
919                 
920         switch (which)
921         {
922         case 0:
923                 err = 0;
924                 break;
925         case QM_MODULES:
926                 err = qm_modules(buf, bufsize, ret);
927                 break;
928         case QM_DEPS:
929                 err = qm_deps(mod, buf, bufsize, ret);
930                 break;
931         case QM_REFS:
932                 err = qm_refs(mod, buf, bufsize, ret);
933                 break;
934         case QM_SYMBOLS:
935                 err = qm_symbols(mod, buf, bufsize, ret);
936                 break;
937         case QM_INFO:
938                 err = qm_info(mod, buf, bufsize, ret);
939                 break;
940         default:
941                 err = -EINVAL;
942                 break;
943         }
944         atomic_dec(&mod->uc.usecount);
945         
946 out:
947         unlock_kernel();
948         return err;
949 }
950
951 /*
952  * Copy the kernel symbol table to user space.  If the argument is
953  * NULL, just return the size of the table.
954  *
955  * This call is obsolete.  New programs should use query_module+QM_SYMBOLS
956  * which does not arbitrarily limit the length of symbols.
957  */
958
959 asmlinkage long
960 sys_get_kernel_syms(struct kernel_sym *table)
961 {
962         struct module *mod;
963         int i;
964         struct kernel_sym ksym;
965
966         lock_kernel();
967         for (mod = module_list, i = 0; mod; mod = mod->next) {
968                 /* include the count for the module name! */
969                 i += mod->nsyms + 1;
970         }
971
972         if (table == NULL)
973                 goto out;
974
975         /* So that we don't give the user our stack content */
976         memset (&ksym, 0, sizeof (ksym));
977
978         for (mod = module_list, i = 0; mod; mod = mod->next) {
979                 struct module_symbol *msym;
980                 unsigned int j;
981
982                 if (!MOD_CAN_QUERY(mod))
983                         continue;
984
985                 /* magic: write module info as a pseudo symbol */
986                 ksym.value = (unsigned long)mod;
987                 ksym.name[0] = '#';
988                 strncpy(ksym.name+1, mod->name, sizeof(ksym.name)-1);
989                 ksym.name[sizeof(ksym.name)-1] = '\0';
990
991                 if (copy_to_user(table, &ksym, sizeof(ksym)) != 0)
992                         goto out;
993                 ++i, ++table;
994
995                 if (mod->nsyms == 0)
996                         continue;
997
998                 for (j = 0, msym = mod->syms; j < mod->nsyms; ++j, ++msym) {
999                         ksym.value = msym->value;
1000                         strncpy(ksym.name, msym->name, sizeof(ksym.name));
1001                         ksym.name[sizeof(ksym.name)-1] = '\0';
1002
1003                         if (copy_to_user(table, &ksym, sizeof(ksym)) != 0)
1004                                 goto out;
1005                         ++i, ++table;
1006                 }
1007         }
1008 out:
1009         unlock_kernel();
1010         return i;
1011 }
1012
1013 /*
1014  * Look for a module by name, ignoring modules marked for deletion.
1015  */
1016
1017 struct module *
1018 find_module(const char *name)
1019 {
1020         struct module *mod;
1021
1022         for (mod = module_list; mod ; mod = mod->next) {
1023                 if (mod->flags & MOD_DELETED)
1024                         continue;
1025                 if (!strcmp(mod->name, name))
1026                         break;
1027         }
1028
1029         return mod;
1030 }
1031
1032 /*
1033  * Free the given module.
1034  */
1035
1036 void
1037 free_module(struct module *mod, int tag_freed)
1038 {
1039         struct module_ref *dep;
1040         unsigned i;
1041         unsigned long flags;
1042
1043         /* Let the module clean up.  */
1044
1045         if (mod->flags & MOD_RUNNING)
1046         {
1047                 if(mod->cleanup)
1048                         mod->cleanup();
1049                 mod->flags &= ~MOD_RUNNING;
1050         }
1051
1052         /* Remove the module from the dependency lists.  */
1053
1054         for (i = 0, dep = mod->deps; i < mod->ndeps; ++i, ++dep) {
1055                 struct module_ref **pp;
1056                 for (pp = &dep->dep->refs; *pp != dep; pp = &(*pp)->next_ref)
1057                         continue;
1058                 *pp = dep->next_ref;
1059                 if (tag_freed && dep->dep->refs == NULL)
1060                         dep->dep->flags |= MOD_JUST_FREED;
1061         }
1062
1063         /* And from the main module list.  */
1064
1065         spin_lock_irqsave(&modlist_lock, flags);
1066         if (mod == module_list) {
1067                 module_list = mod->next;
1068         } else {
1069                 struct module *p;
1070                 for (p = module_list; p->next != mod; p = p->next)
1071                         continue;
1072                 p->next = mod->next;
1073         }
1074         spin_unlock_irqrestore(&modlist_lock, flags);
1075
1076         /* And free the memory.  */
1077
1078         module_unmap(mod);
1079 }
1080
1081 /*
1082  * Called by the /proc file system to return a current list of modules.
1083  */
1084
1085 int get_module_list(char *p)
1086 {
1087         size_t left = PAGE_SIZE;
1088         struct module *mod;
1089         char tmpstr[64];
1090         struct module_ref *ref;
1091
1092         for (mod = module_list; mod != &kernel_module; mod = mod->next) {
1093                 long len;
1094                 const char *q;
1095
1096 #define safe_copy_str(str, len)                                         \
1097                 do {                                                    \
1098                         if (left < len)                                 \
1099                                 goto fini;                              \
1100                         memcpy(p, str, len); p += len, left -= len;     \
1101                 } while (0)
1102 #define safe_copy_cstr(str)     safe_copy_str(str, sizeof(str)-1)
1103
1104                 len = strlen(mod->name);
1105                 safe_copy_str(mod->name, len);
1106
1107                 if ((len = 20 - len) > 0) {
1108                         if (left < len)
1109                                 goto fini;
1110                         memset(p, ' ', len);
1111                         p += len;
1112                         left -= len;
1113                 }
1114
1115                 len = sprintf(tmpstr, "%8lu", mod->size);
1116                 safe_copy_str(tmpstr, len);
1117
1118                 if (mod->flags & MOD_RUNNING) {
1119                         len = sprintf(tmpstr, "%4ld",
1120                                       (mod_member_present(mod, can_unload)
1121                                        && mod->can_unload
1122                                        ? -1L : (long)atomic_read(&mod->uc.usecount)));
1123                         safe_copy_str(tmpstr, len);
1124                 }
1125
1126                 if (mod->flags & MOD_DELETED)
1127                         safe_copy_cstr(" (deleted)");
1128                 else if (mod->flags & MOD_RUNNING) {
1129                         if (mod->flags & MOD_AUTOCLEAN)
1130                                 safe_copy_cstr(" (autoclean)");
1131                         if (!(mod->flags & MOD_USED_ONCE))
1132                                 safe_copy_cstr(" (unused)");
1133                 }
1134                 else if (mod->flags & MOD_INITIALIZING)
1135                         safe_copy_cstr(" (initializing)");
1136                 else
1137                         safe_copy_cstr(" (uninitialized)");
1138
1139                 if ((ref = mod->refs) != NULL) {
1140                         safe_copy_cstr(" [");
1141                         while (1) {
1142                                 q = ref->ref->name;
1143                                 len = strlen(q);
1144                                 safe_copy_str(q, len);
1145
1146                                 if ((ref = ref->next_ref) != NULL)
1147                                         safe_copy_cstr(" ");
1148                                 else
1149                                         break;
1150                         }
1151                         safe_copy_cstr("]");
1152                 }
1153                 safe_copy_cstr("\n");
1154
1155 #undef safe_copy_str
1156 #undef safe_copy_cstr
1157         }
1158
1159 fini:
1160         return PAGE_SIZE - left;
1161 }
1162
1163 /*
1164  * Called by the /proc file system to return a current list of ksyms.
1165  */
1166
1167 int
1168 get_ksyms_list(char *buf, char **start, off_t offset, int length)
1169 {
1170         struct module *mod;
1171         char *p = buf;
1172         int len     = 0;        /* code from  net/ipv4/proc.c */
1173         off_t pos   = 0;
1174         off_t begin = 0;
1175
1176         for (mod = module_list; mod; mod = mod->next) {
1177                 unsigned i;
1178                 struct module_symbol *sym;
1179
1180                 if (!MOD_CAN_QUERY(mod))
1181                         continue;
1182
1183                 for (i = mod->nsyms, sym = mod->syms; i > 0; --i, ++sym) {
1184                         p = buf + len;
1185                         if (*mod->name) {
1186                                 len += sprintf(p, "%0*lx %s\t[%s]\n",
1187                                                (int)(2*sizeof(void*)),
1188                                                sym->value, sym->name,
1189                                                mod->name);
1190                         } else {
1191                                 len += sprintf(p, "%0*lx %s\n",
1192                                                (int)(2*sizeof(void*)),
1193                                                sym->value, sym->name);
1194                         }
1195                         pos = begin + len;
1196                         if (pos < offset) {
1197                                 len = 0;
1198                                 begin = pos;
1199                         }
1200                         pos = begin + len;
1201                         if (pos > offset+length)
1202                                 goto leave_the_loop;
1203                 }
1204         }
1205 leave_the_loop:
1206         *start = buf + (offset - begin);
1207         len -= (offset - begin);
1208         if (len > length)
1209                 len = length;
1210         return len;
1211 }
1212
1213 #else           /* CONFIG_MODULES */
1214
1215 /* Dummy syscalls for people who don't want modules */
1216
1217 asmlinkage unsigned long
1218 sys_create_module(const char *name_user, size_t size)
1219 {
1220         return -ENOSYS;
1221 }
1222
1223 asmlinkage long
1224 sys_init_module(const char *name_user, struct module *mod_user)
1225 {
1226         return -ENOSYS;
1227 }
1228
1229 asmlinkage long
1230 sys_delete_module(const char *name_user)
1231 {
1232         return -ENOSYS;
1233 }
1234
1235 asmlinkage long
1236 sys_query_module(const char *name_user, int which, char *buf, size_t bufsize,
1237                  size_t *ret)
1238 {
1239         /* Let the program know about the new interface.  Not that
1240            it'll do them much good.  */
1241         if (which == 0)
1242                 return 0;
1243
1244         return -ENOSYS;
1245 }
1246
1247 asmlinkage long
1248 sys_get_kernel_syms(struct kernel_sym *table)
1249 {
1250         return -ENOSYS;
1251 }
1252
1253 int try_inc_mod_count(struct module *mod)
1254 {
1255         return 1;
1256 }
1257
1258 #endif  /* CONFIG_MODULES */