1/* 2 Copyright (C) 2002 Richard Henderson 3 Copyright (C) 2001 Rusty Russell, 2002 Rusty Russell IBM. 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 2 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, write to the Free Software 17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18*/ 19#include <linux/module.h> 20#include <linux/moduleloader.h> 21#include <linux/init.h> 22#include <linux/kallsyms.h> 23#include <linux/kernel.h> 24#include <linux/slab.h> 25#include <linux/vmalloc.h> 26#include <linux/elf.h> 27#include <linux/seq_file.h> 28#include <linux/syscalls.h> 29#include <linux/fcntl.h> 30#include <linux/rcupdate.h> 31#include <linux/capability.h> 32#include <linux/cpu.h> 33#include <linux/moduleparam.h> 34#include <linux/errno.h> 35#include <linux/err.h> 36#include <linux/vermagic.h> 37#include <linux/notifier.h> 38#include <linux/sched.h> 39#include <linux/stop_machine.h> 40#include <linux/device.h> 41#include <linux/string.h> 42#include <linux/mutex.h> 43#include <linux/unwind.h> 44#include <asm/uaccess.h> 45#include <asm/semaphore.h> 46#include <asm/cacheflush.h> 47#include <linux/license.h> 48 49extern int module_sysfs_initialized; 50 51#define DEBUGP(fmt , a...) 52 53#ifndef ARCH_SHF_SMALL 54#define ARCH_SHF_SMALL 0 55#endif 56 57/* If this is set, the section belongs in the init part of the module */ 58#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1)) 59 60/* Protects module list */ 61static DEFINE_SPINLOCK(modlist_lock); 62 63/* List of modules, protected by module_mutex AND modlist_lock */ 64static DEFINE_MUTEX(module_mutex); 65static LIST_HEAD(modules); 66 67static BLOCKING_NOTIFIER_HEAD(module_notify_list); 68 69int register_module_notifier(struct notifier_block * nb) 70{ 71 return blocking_notifier_chain_register(&module_notify_list, nb); 72} 73EXPORT_SYMBOL(register_module_notifier); 74 75int unregister_module_notifier(struct notifier_block * nb) 76{ 77 return blocking_notifier_chain_unregister(&module_notify_list, nb); 78} 79EXPORT_SYMBOL(unregister_module_notifier); 80 81/* We require a truly strong try_module_get() */ 82static inline int strong_try_module_get(struct module *mod) 83{ 84 if (mod && mod->state == MODULE_STATE_COMING) 85 return 0; 86 return try_module_get(mod); 87} 88 89static inline void add_taint_module(struct module *mod, unsigned flag) 90{ 91 add_taint(flag); 92 mod->taints |= flag; 93} 94 95/* 96 * A thread that wants to hold a reference to a module only while it 97 * is running can call this to safely exit. nfsd and lockd use this. 98 */ 99void __module_put_and_exit(struct module *mod, long code) 100{ 101 module_put(mod); 102 do_exit(code); 103} 104EXPORT_SYMBOL(__module_put_and_exit); 105 106/* Find a module section: 0 means not found. */ 107static unsigned int find_sec(Elf_Ehdr *hdr, 108 Elf_Shdr *sechdrs, 109 const char *secstrings, 110 const char *name) 111{ 112 unsigned int i; 113 114 for (i = 1; i < hdr->e_shnum; i++) 115 /* Alloc bit cleared means "ignore it." */ 116 if ((sechdrs[i].sh_flags & SHF_ALLOC) 117 && strcmp(secstrings+sechdrs[i].sh_name, name) == 0) 118 return i; 119 return 0; 120} 121 122/* Provided by the linker */ 123extern const struct kernel_symbol __start___ksymtab[]; 124extern const struct kernel_symbol __stop___ksymtab[]; 125extern const struct kernel_symbol __start___ksymtab_gpl[]; 126extern const struct kernel_symbol __stop___ksymtab_gpl[]; 127extern const struct kernel_symbol __start___ksymtab_gpl_future[]; 128extern const struct kernel_symbol __stop___ksymtab_gpl_future[]; 129extern const struct kernel_symbol __start___ksymtab_unused[]; 130extern const struct kernel_symbol __stop___ksymtab_unused[]; 131extern const struct kernel_symbol __start___ksymtab_unused_gpl[]; 132extern const struct kernel_symbol __stop___ksymtab_unused_gpl[]; 133extern const struct kernel_symbol __start___ksymtab_gpl_future[]; 134extern const struct kernel_symbol __stop___ksymtab_gpl_future[]; 135extern const unsigned long __start___kcrctab[]; 136extern const unsigned long __start___kcrctab_gpl[]; 137extern const unsigned long __start___kcrctab_gpl_future[]; 138extern const unsigned long __start___kcrctab_unused[]; 139extern const unsigned long __start___kcrctab_unused_gpl[]; 140 141#ifndef CONFIG_MODVERSIONS 142#define symversion(base, idx) NULL 143#else 144#define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL) 145#endif 146 147/* lookup symbol in given range of kernel_symbols */ 148static const struct kernel_symbol *lookup_symbol(const char *name, 149 const struct kernel_symbol *start, 150 const struct kernel_symbol *stop) 151{ 152 const struct kernel_symbol *ks = start; 153 for (; ks < stop; ks++) 154 if (strcmp(ks->name, name) == 0) 155 return ks; 156 return NULL; 157} 158 159static void printk_unused_warning(const char *name) 160{ 161 printk(KERN_WARNING "Symbol %s is marked as UNUSED, " 162 "however this module is using it.\n", name); 163 printk(KERN_WARNING "This symbol will go away in the future.\n"); 164 printk(KERN_WARNING "Please evalute if this is the right api to use, " 165 "and if it really is, submit a report the linux kernel " 166 "mailinglist together with submitting your code for " 167 "inclusion.\n"); 168} 169 170/* Find a symbol, return value, crc and module which owns it */ 171static unsigned long __find_symbol(const char *name, 172 struct module **owner, 173 const unsigned long **crc, 174 int gplok) 175{ 176 struct module *mod; 177 const struct kernel_symbol *ks; 178 179 /* Core kernel first. */ 180 *owner = NULL; 181 ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab); 182 if (ks) { 183 *crc = symversion(__start___kcrctab, (ks - __start___ksymtab)); 184 return ks->value; 185 } 186 if (gplok) { 187 ks = lookup_symbol(name, __start___ksymtab_gpl, 188 __stop___ksymtab_gpl); 189 if (ks) { 190 *crc = symversion(__start___kcrctab_gpl, 191 (ks - __start___ksymtab_gpl)); 192 return ks->value; 193 } 194 } 195 ks = lookup_symbol(name, __start___ksymtab_gpl_future, 196 __stop___ksymtab_gpl_future); 197 if (ks) { 198 if (!gplok) { 199 printk(KERN_WARNING "Symbol %s is being used " 200 "by a non-GPL module, which will not " 201 "be allowed in the future\n", name); 202 printk(KERN_WARNING "Please see the file " 203 "Documentation/feature-removal-schedule.txt " 204 "in the kernel source tree for more " 205 "details.\n"); 206 } 207 *crc = symversion(__start___kcrctab_gpl_future, 208 (ks - __start___ksymtab_gpl_future)); 209 return ks->value; 210 } 211 212 ks = lookup_symbol(name, __start___ksymtab_unused, 213 __stop___ksymtab_unused); 214 if (ks) { 215 printk_unused_warning(name); 216 *crc = symversion(__start___kcrctab_unused, 217 (ks - __start___ksymtab_unused)); 218 return ks->value; 219 } 220 221 if (gplok) 222 ks = lookup_symbol(name, __start___ksymtab_unused_gpl, 223 __stop___ksymtab_unused_gpl); 224 if (ks) { 225 printk_unused_warning(name); 226 *crc = symversion(__start___kcrctab_unused_gpl, 227 (ks - __start___ksymtab_unused_gpl)); 228 return ks->value; 229 } 230 231 /* Now try modules. */ 232 list_for_each_entry(mod, &modules, list) { 233 *owner = mod; 234 ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms); 235 if (ks) { 236 *crc = symversion(mod->crcs, (ks - mod->syms)); 237 return ks->value; 238 } 239 240 if (gplok) { 241 ks = lookup_symbol(name, mod->gpl_syms, 242 mod->gpl_syms + mod->num_gpl_syms); 243 if (ks) { 244 *crc = symversion(mod->gpl_crcs, 245 (ks - mod->gpl_syms)); 246 return ks->value; 247 } 248 } 249 ks = lookup_symbol(name, mod->unused_syms, mod->unused_syms + mod->num_unused_syms); 250 if (ks) { 251 printk_unused_warning(name); 252 *crc = symversion(mod->unused_crcs, (ks - mod->unused_syms)); 253 return ks->value; 254 } 255 256 if (gplok) { 257 ks = lookup_symbol(name, mod->unused_gpl_syms, 258 mod->unused_gpl_syms + mod->num_unused_gpl_syms); 259 if (ks) { 260 printk_unused_warning(name); 261 *crc = symversion(mod->unused_gpl_crcs, 262 (ks - mod->unused_gpl_syms)); 263 return ks->value; 264 } 265 } 266 ks = lookup_symbol(name, mod->gpl_future_syms, 267 (mod->gpl_future_syms + 268 mod->num_gpl_future_syms)); 269 if (ks) { 270 if (!gplok) { 271 printk(KERN_WARNING "Symbol %s is being used " 272 "by a non-GPL module, which will not " 273 "be allowed in the future\n", name); 274 printk(KERN_WARNING "Please see the file " 275 "Documentation/feature-removal-schedule.txt " 276 "in the kernel source tree for more " 277 "details.\n"); 278 } 279 *crc = symversion(mod->gpl_future_crcs, 280 (ks - mod->gpl_future_syms)); 281 return ks->value; 282 } 283 } 284 DEBUGP("Failed to find symbol %s\n", name); 285 return 0; 286} 287 288/* Search for module by name: must hold module_mutex. */ 289static struct module *find_module(const char *name) 290{ 291 struct module *mod; 292 293 list_for_each_entry(mod, &modules, list) { 294 if (strcmp(mod->name, name) == 0) 295 return mod; 296 } 297 return NULL; 298} 299 300#ifdef CONFIG_SMP 301/* Number of blocks used and allocated. */ 302static unsigned int pcpu_num_used, pcpu_num_allocated; 303/* Size of each block. -ve means used. */ 304static int *pcpu_size; 305 306static int split_block(unsigned int i, unsigned short size) 307{ 308 /* Reallocation required? */ 309 if (pcpu_num_used + 1 > pcpu_num_allocated) { 310 int *new; 311 312 new = krealloc(pcpu_size, sizeof(new[0])*pcpu_num_allocated*2, 313 GFP_KERNEL); 314 if (!new) 315 return 0; 316 317 pcpu_num_allocated *= 2; 318 pcpu_size = new; 319 } 320 321 /* Insert a new subblock */ 322 memmove(&pcpu_size[i+1], &pcpu_size[i], 323 sizeof(pcpu_size[0]) * (pcpu_num_used - i)); 324 pcpu_num_used++; 325 326 pcpu_size[i+1] -= size; 327 pcpu_size[i] = size; 328 return 1; 329} 330 331static inline unsigned int block_size(int val) 332{ 333 if (val < 0) 334 return -val; 335 return val; 336} 337 338/* Created by linker magic */ 339extern char __per_cpu_start[], __per_cpu_end[]; 340 341static void *percpu_modalloc(unsigned long size, unsigned long align, 342 const char *name) 343{ 344 unsigned long extra; 345 unsigned int i; 346 void *ptr; 347 348 if (align > PAGE_SIZE) { 349 printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n", 350 name, align, PAGE_SIZE); 351 align = PAGE_SIZE; 352 } 353 354 ptr = __per_cpu_start; 355 for (i = 0; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) { 356 /* Extra for alignment requirement. */ 357 extra = ALIGN((unsigned long)ptr, align) - (unsigned long)ptr; 358 BUG_ON(i == 0 && extra != 0); 359 360 if (pcpu_size[i] < 0 || pcpu_size[i] < extra + size) 361 continue; 362 363 /* Transfer extra to previous block. */ 364 if (pcpu_size[i-1] < 0) 365 pcpu_size[i-1] -= extra; 366 else 367 pcpu_size[i-1] += extra; 368 pcpu_size[i] -= extra; 369 ptr += extra; 370 371 /* Split block if warranted */ 372 if (pcpu_size[i] - size > sizeof(unsigned long)) 373 if (!split_block(i, size)) 374 return NULL; 375 376 /* Mark allocated */ 377 pcpu_size[i] = -pcpu_size[i]; 378 return ptr; 379 } 380 381 printk(KERN_WARNING "Could not allocate %lu bytes percpu data\n", 382 size); 383 return NULL; 384} 385 386static void percpu_modfree(void *freeme) 387{ 388 unsigned int i; 389 void *ptr = __per_cpu_start + block_size(pcpu_size[0]); 390 391 /* First entry is core kernel percpu data. */ 392 for (i = 1; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) { 393 if (ptr == freeme) { 394 pcpu_size[i] = -pcpu_size[i]; 395 goto free; 396 } 397 } 398 BUG(); 399 400 free: 401 /* Merge with previous? */ 402 if (pcpu_size[i-1] >= 0) { 403 pcpu_size[i-1] += pcpu_size[i]; 404 pcpu_num_used--; 405 memmove(&pcpu_size[i], &pcpu_size[i+1], 406 (pcpu_num_used - i) * sizeof(pcpu_size[0])); 407 i--; 408 } 409 /* Merge with next? */ 410 if (i+1 < pcpu_num_used && pcpu_size[i+1] >= 0) { 411 pcpu_size[i] += pcpu_size[i+1]; 412 pcpu_num_used--; 413 memmove(&pcpu_size[i+1], &pcpu_size[i+2], 414 (pcpu_num_used - (i+1)) * sizeof(pcpu_size[0])); 415 } 416} 417 418static unsigned int find_pcpusec(Elf_Ehdr *hdr, 419 Elf_Shdr *sechdrs, 420 const char *secstrings) 421{ 422 return find_sec(hdr, sechdrs, secstrings, ".data.percpu"); 423} 424 425static int percpu_modinit(void) 426{ 427 pcpu_num_used = 2; 428 pcpu_num_allocated = 2; 429 pcpu_size = kmalloc(sizeof(pcpu_size[0]) * pcpu_num_allocated, 430 GFP_KERNEL); 431 /* Static in-kernel percpu data (used). */ 432 pcpu_size[0] = -(__per_cpu_end-__per_cpu_start); 433 /* Free room. */ 434 pcpu_size[1] = PERCPU_ENOUGH_ROOM + pcpu_size[0]; 435 if (pcpu_size[1] < 0) { 436 printk(KERN_ERR "No per-cpu room for modules.\n"); 437 pcpu_num_used = 1; 438 } 439 440 return 0; 441} 442__initcall(percpu_modinit); 443#else /* ... !CONFIG_SMP */ 444static inline void *percpu_modalloc(unsigned long size, unsigned long align, 445 const char *name) 446{ 447 return NULL; 448} 449static inline void percpu_modfree(void *pcpuptr) 450{ 451 BUG(); 452} 453static inline unsigned int find_pcpusec(Elf_Ehdr *hdr, 454 Elf_Shdr *sechdrs, 455 const char *secstrings) 456{ 457 return 0; 458} 459static inline void percpu_modcopy(void *pcpudst, const void *src, 460 unsigned long size) 461{ 462 /* pcpusec should be 0, and size of that section should be 0. */ 463 BUG_ON(size != 0); 464} 465#endif /* CONFIG_SMP */ 466 467#define MODINFO_ATTR(field) \ 468static void setup_modinfo_##field(struct module *mod, const char *s) \ 469{ \ 470 mod->field = kstrdup(s, GFP_KERNEL); \ 471} \ 472static ssize_t show_modinfo_##field(struct module_attribute *mattr, \ 473 struct module *mod, char *buffer) \ 474{ \ 475 return sprintf(buffer, "%s\n", mod->field); \ 476} \ 477static int modinfo_##field##_exists(struct module *mod) \ 478{ \ 479 return mod->field != NULL; \ 480} \ 481static void free_modinfo_##field(struct module *mod) \ 482{ \ 483 kfree(mod->field); \ 484 mod->field = NULL; \ 485} \ 486static struct module_attribute modinfo_##field = { \ 487 .attr = { .name = __stringify(field), .mode = 0444, \ 488 .owner = THIS_MODULE }, \ 489 .show = show_modinfo_##field, \ 490 .setup = setup_modinfo_##field, \ 491 .test = modinfo_##field##_exists, \ 492 .free = free_modinfo_##field, \ 493}; 494 495MODINFO_ATTR(version); 496MODINFO_ATTR(srcversion); 497 498#ifdef CONFIG_MODULE_UNLOAD 499/* Init the unload section of the module. */ 500static void module_unload_init(struct module *mod) 501{ 502 unsigned int i; 503 504 INIT_LIST_HEAD(&mod->modules_which_use_me); 505 for (i = 0; i < NR_CPUS; i++) 506 local_set(&mod->ref[i].count, 0); 507 /* Hold reference count during initialization. */ 508 local_set(&mod->ref[raw_smp_processor_id()].count, 1); 509 /* Backwards compatibility macros put refcount during init. */ 510 mod->waiter = current; 511} 512 513/* modules using other modules */ 514struct module_use 515{ 516 struct list_head list; 517 struct module *module_which_uses; 518}; 519 520/* Does a already use b? */ 521static int already_uses(struct module *a, struct module *b) 522{ 523 struct module_use *use; 524 525 list_for_each_entry(use, &b->modules_which_use_me, list) { 526 if (use->module_which_uses == a) { 527 DEBUGP("%s uses %s!\n", a->name, b->name); 528 return 1; 529 } 530 } 531 DEBUGP("%s does not use %s!\n", a->name, b->name); 532 return 0; 533} 534 535/* Module a uses b */ 536static int use_module(struct module *a, struct module *b) 537{ 538 struct module_use *use; 539 int no_warn; 540 541 if (b == NULL || already_uses(a, b)) return 1; 542 543 if (!strong_try_module_get(b)) 544 return 0; 545 546 DEBUGP("Allocating new usage for %s.\n", a->name); 547 use = kmalloc(sizeof(*use), GFP_ATOMIC); 548 if (!use) { 549 printk("%s: out of memory loading\n", a->name); 550 module_put(b); 551 return 0; 552 } 553 554 use->module_which_uses = a; 555 list_add(&use->list, &b->modules_which_use_me); 556 no_warn = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name); 557 return 1; 558} 559 560/* Clear the unload stuff of the module. */ 561static void module_unload_free(struct module *mod) 562{ 563 struct module *i; 564 565 list_for_each_entry(i, &modules, list) { 566 struct module_use *use; 567 568 list_for_each_entry(use, &i->modules_which_use_me, list) { 569 if (use->module_which_uses == mod) { 570 DEBUGP("%s unusing %s\n", mod->name, i->name); 571 module_put(i); 572 list_del(&use->list); 573 kfree(use); 574 sysfs_remove_link(i->holders_dir, mod->name); 575 /* There can be at most one match. */ 576 break; 577 } 578 } 579 } 580} 581 582#ifdef CONFIG_MODULE_FORCE_UNLOAD 583static inline int try_force_unload(unsigned int flags) 584{ 585 int ret = (flags & O_TRUNC); 586 if (ret) 587 add_taint(TAINT_FORCED_RMMOD); 588 return ret; 589} 590#else 591static inline int try_force_unload(unsigned int flags) 592{ 593 return 0; 594} 595#endif /* CONFIG_MODULE_FORCE_UNLOAD */ 596 597struct stopref 598{ 599 struct module *mod; 600 int flags; 601 int *forced; 602}; 603 604/* Whole machine is stopped with interrupts off when this runs. */ 605static int __try_stop_module(void *_sref) 606{ 607 struct stopref *sref = _sref; 608 609 /* If it's not unused, quit unless we are told to block. */ 610 if ((sref->flags & O_NONBLOCK) && module_refcount(sref->mod) != 0) { 611 if (!(*sref->forced = try_force_unload(sref->flags))) 612 return -EWOULDBLOCK; 613 } 614 615 /* Mark it as dying. */ 616 sref->mod->state = MODULE_STATE_GOING; 617 return 0; 618} 619 620static int try_stop_module(struct module *mod, int flags, int *forced) 621{ 622 struct stopref sref = { mod, flags, forced }; 623 624 return stop_machine_run(__try_stop_module, &sref, NR_CPUS); 625} 626 627unsigned int module_refcount(struct module *mod) 628{ 629 unsigned int i, total = 0; 630 631 for (i = 0; i < NR_CPUS; i++) 632 total += local_read(&mod->ref[i].count); 633 return total; 634} 635EXPORT_SYMBOL(module_refcount); 636 637/* This exists whether we can unload or not */ 638static void free_module(struct module *mod); 639 640static void wait_for_zero_refcount(struct module *mod) 641{ 642 /* Since we might sleep for some time, drop the semaphore first */ 643 mutex_unlock(&module_mutex); 644 for (;;) { 645 DEBUGP("Looking at refcount...\n"); 646 set_current_state(TASK_UNINTERRUPTIBLE); 647 if (module_refcount(mod) == 0) 648 break; 649 schedule(); 650 } 651 current->state = TASK_RUNNING; 652 mutex_lock(&module_mutex); 653} 654 655asmlinkage long 656sys_delete_module(const char __user *name_user, unsigned int flags) 657{ 658 struct module *mod; 659 char name[MODULE_NAME_LEN]; 660 int ret, forced = 0; 661 662 if (!capable(CAP_SYS_MODULE)) 663 return -EPERM; 664 665 if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0) 666 return -EFAULT; 667 name[MODULE_NAME_LEN-1] = '\0'; 668 669 if (mutex_lock_interruptible(&module_mutex) != 0) 670 return -EINTR; 671 672 mod = find_module(name); 673 if (!mod) { 674 ret = -ENOENT; 675 goto out; 676 } 677 678 if (!list_empty(&mod->modules_which_use_me)) { 679 /* Other modules depend on us: get rid of them first. */ 680 ret = -EWOULDBLOCK; 681 goto out; 682 } 683 684 /* Doing init or already dying? */ 685 if (mod->state != MODULE_STATE_LIVE) { 686 DEBUGP("%s already dying\n", mod->name); 687 ret = -EBUSY; 688 goto out; 689 } 690 691 /* If it has an init func, it must have an exit func to unload */ 692 if ((mod->init != NULL && mod->exit == NULL) 693 || mod->unsafe) { 694 forced = try_force_unload(flags); 695 if (!forced) { 696 /* This module can't be removed */ 697 ret = -EBUSY; 698 goto out; 699 } 700 } 701 702 /* Set this up before setting mod->state */ 703 mod->waiter = current; 704 705 /* Stop the machine so refcounts can't move and disable module. */ 706 ret = try_stop_module(mod, flags, &forced); 707 if (ret != 0) 708 goto out; 709 710 /* Never wait if forced. */ 711 if (!forced && module_refcount(mod) != 0) 712 wait_for_zero_refcount(mod); 713 714 /* Final destruction now noone is using it. */ 715 if (mod->exit != NULL) { 716 mutex_unlock(&module_mutex); 717 mod->exit(); 718 mutex_lock(&module_mutex); 719 } 720 free_module(mod); 721 722 out: 723 mutex_unlock(&module_mutex); 724 return ret; 725} 726 727static void print_unload_info(struct seq_file *m, struct module *mod) 728{ 729 struct module_use *use; 730 int printed_something = 0; 731 732 seq_printf(m, " %u ", module_refcount(mod)); 733 734 /* Always include a trailing , so userspace can differentiate 735 between this and the old multi-field proc format. */ 736 list_for_each_entry(use, &mod->modules_which_use_me, list) { 737 printed_something = 1; 738 seq_printf(m, "%s,", use->module_which_uses->name); 739 } 740 741 if (mod->unsafe) { 742 printed_something = 1; 743 seq_printf(m, "[unsafe],"); 744 } 745 746 if (mod->init != NULL && mod->exit == NULL) { 747 printed_something = 1; 748 seq_printf(m, "[permanent],"); 749 } 750 751 if (!printed_something) 752 seq_printf(m, "-"); 753} 754 755void __symbol_put(const char *symbol) 756{ 757 struct module *owner; 758 unsigned long flags; 759 const unsigned long *crc; 760 761 spin_lock_irqsave(&modlist_lock, flags); 762 if (!__find_symbol(symbol, &owner, &crc, 1)) 763 BUG(); 764 module_put(owner); 765 spin_unlock_irqrestore(&modlist_lock, flags); 766} 767EXPORT_SYMBOL(__symbol_put); 768 769void symbol_put_addr(void *addr) 770{ 771 struct module *modaddr; 772 773 if (core_kernel_text((unsigned long)addr)) 774 return; 775 776 if (!(modaddr = module_text_address((unsigned long)addr))) 777 BUG(); 778 module_put(modaddr); 779} 780EXPORT_SYMBOL_GPL(symbol_put_addr); 781 782static ssize_t show_refcnt(struct module_attribute *mattr, 783 struct module *mod, char *buffer) 784{ 785 /* sysfs holds a reference */ 786 return sprintf(buffer, "%u\n", module_refcount(mod)-1); 787} 788 789static struct module_attribute refcnt = { 790 .attr = { .name = "refcnt", .mode = 0444, .owner = THIS_MODULE }, 791 .show = show_refcnt, 792}; 793 794void module_put(struct module *module) 795{ 796 if (module) { 797 unsigned int cpu = get_cpu(); 798 local_dec(&module->ref[cpu].count); 799 /* Maybe they're waiting for us to drop reference? */ 800 if (unlikely(!module_is_live(module))) 801 wake_up_process(module->waiter); 802 put_cpu(); 803 } 804} 805EXPORT_SYMBOL(module_put); 806 807#else /* !CONFIG_MODULE_UNLOAD */ 808static void print_unload_info(struct seq_file *m, struct module *mod) 809{ 810 /* We don't know the usage count, or what modules are using. */ 811 seq_printf(m, " - -"); 812} 813 814static inline void module_unload_free(struct module *mod) 815{ 816} 817 818static inline int use_module(struct module *a, struct module *b) 819{ 820 return strong_try_module_get(b); 821} 822 823static inline void module_unload_init(struct module *mod) 824{ 825} 826#endif /* CONFIG_MODULE_UNLOAD */ 827 828static ssize_t show_initstate(struct module_attribute *mattr, 829 struct module *mod, char *buffer) 830{ 831 const char *state = "unknown"; 832 833 switch (mod->state) { 834 case MODULE_STATE_LIVE: 835 state = "live"; 836 break; 837 case MODULE_STATE_COMING: 838 state = "coming"; 839 break; 840 case MODULE_STATE_GOING: 841 state = "going"; 842 break; 843 } 844 return sprintf(buffer, "%s\n", state); 845} 846 847static struct module_attribute initstate = { 848 .attr = { .name = "initstate", .mode = 0444, .owner = THIS_MODULE }, 849 .show = show_initstate, 850}; 851 852static struct module_attribute *modinfo_attrs[] = { 853 &modinfo_version, 854 &modinfo_srcversion, 855 &initstate, 856#ifdef CONFIG_MODULE_UNLOAD 857 &refcnt, 858#endif 859 NULL, 860}; 861 862static const char vermagic[] = VERMAGIC_STRING; 863 864#ifdef CONFIG_MODVERSIONS 865static int check_version(Elf_Shdr *sechdrs, 866 unsigned int versindex, 867 const char *symname, 868 struct module *mod, 869 const unsigned long *crc) 870{ 871 unsigned int i, num_versions; 872 struct modversion_info *versions; 873 874 /* Exporting module didn't supply crcs? OK, we're already tainted. */ 875 if (!crc) 876 return 1; 877 878 versions = (void *) sechdrs[versindex].sh_addr; 879 num_versions = sechdrs[versindex].sh_size 880 / sizeof(struct modversion_info); 881 882 for (i = 0; i < num_versions; i++) { 883 if (strcmp(versions[i].name, symname) != 0) 884 continue; 885 886 if (versions[i].crc == *crc) 887 return 1; 888 printk("%s: disagrees about version of symbol %s\n", 889 mod->name, symname); 890 DEBUGP("Found checksum %lX vs module %lX\n", 891 *crc, versions[i].crc); 892 return 0; 893 } 894 /* Not in module's version table. OK, but that taints the kernel. */ 895 if (!(tainted & TAINT_FORCED_MODULE)) 896 printk("%s: no version for \"%s\" found: kernel tainted.\n", 897 mod->name, symname); 898 add_taint_module(mod, TAINT_FORCED_MODULE); 899 return 1; 900} 901 902static inline int check_modstruct_version(Elf_Shdr *sechdrs, 903 unsigned int versindex, 904 struct module *mod) 905{ 906 const unsigned long *crc; 907 struct module *owner; 908 909 if (!__find_symbol("struct_module", &owner, &crc, 1)) 910 BUG(); 911 return check_version(sechdrs, versindex, "struct_module", mod, 912 crc); 913} 914 915/* First part is kernel version, which we ignore. */ 916static inline int same_magic(const char *amagic, const char *bmagic) 917{ 918 amagic += strcspn(amagic, " "); 919 bmagic += strcspn(bmagic, " "); 920 return strcmp(amagic, bmagic) == 0; 921} 922#else 923static inline int check_version(Elf_Shdr *sechdrs, 924 unsigned int versindex, 925 const char *symname, 926 struct module *mod, 927 const unsigned long *crc) 928{ 929 return 1; 930} 931 932static inline int check_modstruct_version(Elf_Shdr *sechdrs, 933 unsigned int versindex, 934 struct module *mod) 935{ 936 return 1; 937} 938 939static inline int same_magic(const char *amagic, const char *bmagic) 940{ 941 return strcmp(amagic, bmagic) == 0; 942} 943#endif /* CONFIG_MODVERSIONS */ 944 945/* Resolve a symbol for this module. I.e. if we find one, record usage. 946 Must be holding module_mutex. */ 947static unsigned long resolve_symbol(Elf_Shdr *sechdrs, 948 unsigned int versindex, 949 const char *name, 950 struct module *mod) 951{ 952 struct module *owner; 953 unsigned long ret; 954 const unsigned long *crc; 955 956 ret = __find_symbol(name, &owner, &crc, 957 !(mod->taints & TAINT_PROPRIETARY_MODULE)); 958 if (ret) { 959 /* use_module can fail due to OOM, or module unloading */ 960 if (!check_version(sechdrs, versindex, name, mod, crc) || 961 !use_module(mod, owner)) 962 ret = 0; 963 } 964 return ret; 965} 966 967 968/* 969 * /sys/module/foo/sections stuff 970 * J. Corbet <corbet@lwn.net> 971 */ 972#ifdef CONFIG_KALLSYMS 973static ssize_t module_sect_show(struct module_attribute *mattr, 974 struct module *mod, char *buf) 975{ 976 struct module_sect_attr *sattr = 977 container_of(mattr, struct module_sect_attr, mattr); 978 return sprintf(buf, "0x%lx\n", sattr->address); 979} 980 981static void free_sect_attrs(struct module_sect_attrs *sect_attrs) 982{ 983 int section; 984 985 for (section = 0; section < sect_attrs->nsections; section++) 986 kfree(sect_attrs->attrs[section].name); 987 kfree(sect_attrs); 988} 989 990static void add_sect_attrs(struct module *mod, unsigned int nsect, 991 char *secstrings, Elf_Shdr *sechdrs) 992{ 993 unsigned int nloaded = 0, i, size[2]; 994 struct module_sect_attrs *sect_attrs; 995 struct module_sect_attr *sattr; 996 struct attribute **gattr; 997 998 /* Count loaded sections and allocate structures */ 999 for (i = 0; i < nsect; i++) 1000 if (sechdrs[i].sh_flags & SHF_ALLOC) 1001 nloaded++; 1002 size[0] = ALIGN(sizeof(*sect_attrs) 1003 + nloaded * sizeof(sect_attrs->attrs[0]), 1004 sizeof(sect_attrs->grp.attrs[0])); 1005 size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]); 1006 sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL); 1007 if (sect_attrs == NULL) 1008 return; 1009 1010 /* Setup section attributes. */ 1011 sect_attrs->grp.name = "sections"; 1012 sect_attrs->grp.attrs = (void *)sect_attrs + size[0]; 1013 1014 sect_attrs->nsections = 0; 1015 sattr = §_attrs->attrs[0]; 1016 gattr = §_attrs->grp.attrs[0]; 1017 for (i = 0; i < nsect; i++) { 1018 if (! (sechdrs[i].sh_flags & SHF_ALLOC)) 1019 continue; 1020 sattr->address = sechdrs[i].sh_addr; 1021 sattr->name = kstrdup(secstrings + sechdrs[i].sh_name, 1022 GFP_KERNEL); 1023 if (sattr->name == NULL) 1024 goto out; 1025 sect_attrs->nsections++; 1026 sattr->mattr.show = module_sect_show; 1027 sattr->mattr.store = NULL; 1028 sattr->mattr.attr.name = sattr->name; 1029 sattr->mattr.attr.owner = mod; 1030 sattr->mattr.attr.mode = S_IRUGO; 1031 *(gattr++) = &(sattr++)->mattr.attr; 1032 } 1033 *gattr = NULL; 1034 1035 if (sysfs_create_group(&mod->mkobj.kobj, §_attrs->grp)) 1036 goto out; 1037 1038 mod->sect_attrs = sect_attrs; 1039 return; 1040 out: 1041 free_sect_attrs(sect_attrs); 1042} 1043 1044static void remove_sect_attrs(struct module *mod) 1045{ 1046 if (mod->sect_attrs) { 1047 sysfs_remove_group(&mod->mkobj.kobj, 1048 &mod->sect_attrs->grp); 1049 /* We are positive that no one is using any sect attrs 1050 * at this point. Deallocate immediately. */ 1051 free_sect_attrs(mod->sect_attrs); 1052 mod->sect_attrs = NULL; 1053 } 1054} 1055 1056#else 1057 1058static inline void add_sect_attrs(struct module *mod, unsigned int nsect, 1059 char *sectstrings, Elf_Shdr *sechdrs) 1060{ 1061} 1062 1063static inline void remove_sect_attrs(struct module *mod) 1064{ 1065} 1066#endif /* CONFIG_KALLSYMS */ 1067 1068#ifdef CONFIG_SYSFS 1069int module_add_modinfo_attrs(struct module *mod) 1070{ 1071 struct module_attribute *attr; 1072 struct module_attribute *temp_attr; 1073 int error = 0; 1074 int i; 1075 1076 mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) * 1077 (ARRAY_SIZE(modinfo_attrs) + 1)), 1078 GFP_KERNEL); 1079 if (!mod->modinfo_attrs) 1080 return -ENOMEM; 1081 1082 temp_attr = mod->modinfo_attrs; 1083 for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) { 1084 if (!attr->test || 1085 (attr->test && attr->test(mod))) { 1086 memcpy(temp_attr, attr, sizeof(*temp_attr)); 1087 temp_attr->attr.owner = mod; 1088 error = sysfs_create_file(&mod->mkobj.kobj,&temp_attr->attr); 1089 ++temp_attr; 1090 } 1091 } 1092 return error; 1093} 1094 1095void module_remove_modinfo_attrs(struct module *mod) 1096{ 1097 struct module_attribute *attr; 1098 int i; 1099 1100 for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) { 1101 /* pick a field to test for end of list */ 1102 if (!attr->attr.name) 1103 break; 1104 sysfs_remove_file(&mod->mkobj.kobj,&attr->attr); 1105 if (attr->free) 1106 attr->free(mod); 1107 } 1108 kfree(mod->modinfo_attrs); 1109} 1110#endif 1111 1112#ifdef CONFIG_SYSFS 1113int mod_sysfs_init(struct module *mod) 1114{ 1115 int err; 1116 1117 if (!module_sysfs_initialized) { 1118 printk(KERN_ERR "%s: module sysfs not initialized\n", 1119 mod->name); 1120 err = -EINVAL; 1121 goto out; 1122 } 1123 memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj)); 1124 err = kobject_set_name(&mod->mkobj.kobj, "%s", mod->name); 1125 if (err) 1126 goto out; 1127 kobj_set_kset_s(&mod->mkobj, module_subsys); 1128 mod->mkobj.mod = mod; 1129 1130 kobject_init(&mod->mkobj.kobj); 1131 1132out: 1133 return err; 1134} 1135 1136int mod_sysfs_setup(struct module *mod, 1137 struct kernel_param *kparam, 1138 unsigned int num_params) 1139{ 1140 int err; 1141 1142 /* delay uevent until full sysfs population */ 1143 err = kobject_add(&mod->mkobj.kobj); 1144 if (err) 1145 goto out; 1146 1147 mod->holders_dir = kobject_add_dir(&mod->mkobj.kobj, "holders"); 1148 if (!mod->holders_dir) { 1149 err = -ENOMEM; 1150 goto out_unreg; 1151 } 1152 1153 err = module_param_sysfs_setup(mod, kparam, num_params); 1154 if (err) 1155 goto out_unreg_holders; 1156 1157 err = module_add_modinfo_attrs(mod); 1158 if (err) 1159 goto out_unreg_param; 1160 1161 kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD); 1162 return 0; 1163 1164out_unreg_param: 1165 module_param_sysfs_remove(mod); 1166out_unreg_holders: 1167 kobject_unregister(mod->holders_dir); 1168out_unreg: 1169 kobject_del(&mod->mkobj.kobj); 1170 kobject_put(&mod->mkobj.kobj); 1171out: 1172 return err; 1173} 1174#endif 1175 1176static void mod_kobject_remove(struct module *mod) 1177{ 1178 module_remove_modinfo_attrs(mod); 1179 module_param_sysfs_remove(mod); 1180 kobject_unregister(mod->mkobj.drivers_dir); 1181 kobject_unregister(mod->holders_dir); 1182 kobject_unregister(&mod->mkobj.kobj); 1183} 1184 1185/* 1186 * unlink the module with the whole machine is stopped with interrupts off 1187 * - this defends against kallsyms not taking locks 1188 */ 1189static int __unlink_module(void *_mod) 1190{ 1191 struct module *mod = _mod; 1192 list_del(&mod->list); 1193 return 0; 1194} 1195 1196/* Free a module, remove from lists, etc (must hold module_mutex). */ 1197static void free_module(struct module *mod) 1198{ 1199 /* Delete from various lists */ 1200 stop_machine_run(__unlink_module, mod, NR_CPUS); 1201 remove_sect_attrs(mod); 1202 mod_kobject_remove(mod); 1203 1204 unwind_remove_table(mod->unwind_info, 0); 1205 1206 /* Arch-specific cleanup. */ 1207 module_arch_cleanup(mod); 1208 1209 /* Module unload stuff */ 1210 module_unload_free(mod); 1211 1212 /* This may be NULL, but that's OK */ 1213 module_free(mod, mod->module_init); 1214 kfree(mod->args); 1215 if (mod->percpu) 1216 percpu_modfree(mod->percpu); 1217 1218 /* Free lock-classes: */ 1219 lockdep_free_key_range(mod->module_core, mod->core_size); 1220 1221 /* Finally, free the core (containing the module structure) */ 1222 module_free(mod, mod->module_core); 1223} 1224 1225void *__symbol_get(const char *symbol) 1226{ 1227 struct module *owner; 1228 unsigned long value, flags; 1229 const unsigned long *crc; 1230 1231 spin_lock_irqsave(&modlist_lock, flags); 1232 value = __find_symbol(symbol, &owner, &crc, 1); 1233 if (value && !strong_try_module_get(owner)) 1234 value = 0; 1235 spin_unlock_irqrestore(&modlist_lock, flags); 1236 1237 return (void *)value; 1238} 1239EXPORT_SYMBOL_GPL(__symbol_get); 1240 1241/* 1242 * Ensure that an exported symbol [global namespace] does not already exist 1243 * in the kernel or in some other module's exported symbol table. 1244 */ 1245static int verify_export_symbols(struct module *mod) 1246{ 1247 const char *name = NULL; 1248 unsigned long i, ret = 0; 1249 struct module *owner; 1250 const unsigned long *crc; 1251 1252 for (i = 0; i < mod->num_syms; i++) 1253 if (__find_symbol(mod->syms[i].name, &owner, &crc, 1)) { 1254 name = mod->syms[i].name; 1255 ret = -ENOEXEC; 1256 goto dup; 1257 } 1258 1259 for (i = 0; i < mod->num_gpl_syms; i++) 1260 if (__find_symbol(mod->gpl_syms[i].name, &owner, &crc, 1)) { 1261 name = mod->gpl_syms[i].name; 1262 ret = -ENOEXEC; 1263 goto dup; 1264 } 1265 1266dup: 1267 if (ret) 1268 printk(KERN_ERR "%s: exports duplicate symbol %s (owned by %s)\n", 1269 mod->name, name, module_name(owner)); 1270 1271 return ret; 1272} 1273 1274/* Change all symbols so that sh_value encodes the pointer directly. */ 1275static int simplify_symbols(Elf_Shdr *sechdrs, 1276 unsigned int symindex, 1277 const char *strtab, 1278 unsigned int versindex, 1279 unsigned int pcpuindex, 1280 struct module *mod) 1281{ 1282 Elf_Sym *sym = (void *)sechdrs[symindex].sh_addr; 1283 unsigned long secbase; 1284 unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym); 1285 int ret = 0; 1286 1287 for (i = 1; i < n; i++) { 1288 switch (sym[i].st_shndx) { 1289 case SHN_COMMON: 1290 /* We compiled with -fno-common. These are not 1291 supposed to happen. */ 1292 DEBUGP("Common symbol: %s\n", strtab + sym[i].st_name); 1293 printk("%s: please compile with -fno-common\n", 1294 mod->name); 1295 ret = -ENOEXEC; 1296 break; 1297 1298 case SHN_ABS: 1299 /* Don't need to do anything */ 1300 DEBUGP("Absolute symbol: 0x%08lx\n", 1301 (long)sym[i].st_value); 1302 break; 1303 1304 case SHN_UNDEF: 1305 sym[i].st_value 1306 = resolve_symbol(sechdrs, versindex, 1307 strtab + sym[i].st_name, mod); 1308 1309 /* Ok if resolved. */ 1310 if (sym[i].st_value != 0) 1311 break; 1312 /* Ok if weak. */ 1313 if (ELF_ST_BIND(sym[i].st_info) == STB_WEAK) 1314 break; 1315 1316 printk(KERN_WARNING "%s: Unknown symbol %s\n", 1317 mod->name, strtab + sym[i].st_name); 1318 ret = -ENOENT; 1319 break; 1320 1321 default: 1322 /* Divert to percpu allocation if a percpu var. */ 1323 if (sym[i].st_shndx == pcpuindex) 1324 secbase = (unsigned long)mod->percpu; 1325 else 1326 secbase = sechdrs[sym[i].st_shndx].sh_addr; 1327 sym[i].st_value += secbase; 1328 break; 1329 } 1330 } 1331 1332 return ret; 1333} 1334 1335/* Update size with this section: return offset. */ 1336static long get_offset(unsigned long *size, Elf_Shdr *sechdr) 1337{ 1338 long ret; 1339 1340 ret = ALIGN(*size, sechdr->sh_addralign ?: 1); 1341 *size = ret + sechdr->sh_size; 1342 return ret; 1343} 1344 1345/* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld 1346 might -- code, read-only data, read-write data, small data. Tally 1347 sizes, and place the offsets into sh_entsize fields: high bit means it 1348 belongs in init. */ 1349static void layout_sections(struct module *mod, 1350 const Elf_Ehdr *hdr, 1351 Elf_Shdr *sechdrs, 1352 const char *secstrings) 1353{ 1354 static unsigned long const masks[][2] = { 1355 /* NOTE: all executable code must be the first section 1356 * in this array; otherwise modify the text_size 1357 * finder in the two loops below */ 1358 { SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL }, 1359 { SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL }, 1360 { SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL }, 1361 { ARCH_SHF_SMALL | SHF_ALLOC, 0 } 1362 }; 1363 unsigned int m, i; 1364 1365 for (i = 0; i < hdr->e_shnum; i++) 1366 sechdrs[i].sh_entsize = ~0UL; 1367 1368 DEBUGP("Core section allocation order:\n"); 1369 for (m = 0; m < ARRAY_SIZE(masks); ++m) { 1370 for (i = 0; i < hdr->e_shnum; ++i) { 1371 Elf_Shdr *s = &sechdrs[i]; 1372 1373 if ((s->sh_flags & masks[m][0]) != masks[m][0] 1374 || (s->sh_flags & masks[m][1]) 1375 || s->sh_entsize != ~0UL 1376 || strncmp(secstrings + s->sh_name, 1377 ".init", 5) == 0) 1378 continue; 1379 s->sh_entsize = get_offset(&mod->core_size, s); 1380 DEBUGP("\t%s\n", secstrings + s->sh_name); 1381 } 1382 if (m == 0) 1383 mod->core_text_size = mod->core_size; 1384 } 1385 1386 DEBUGP("Init section allocation order:\n"); 1387 for (m = 0; m < ARRAY_SIZE(masks); ++m) { 1388 for (i = 0; i < hdr->e_shnum; ++i) { 1389 Elf_Shdr *s = &sechdrs[i]; 1390 1391 if ((s->sh_flags & masks[m][0]) != masks[m][0] 1392 || (s->sh_flags & masks[m][1]) 1393 || s->sh_entsize != ~0UL 1394 || strncmp(secstrings + s->sh_name, 1395 ".init", 5) != 0) 1396 continue; 1397 s->sh_entsize = (get_offset(&mod->init_size, s) 1398 | INIT_OFFSET_MASK); 1399 DEBUGP("\t%s\n", secstrings + s->sh_name); 1400 } 1401 if (m == 0) 1402 mod->init_text_size = mod->init_size; 1403 } 1404} 1405 1406static void set_license(struct module *mod, const char *license) 1407{ 1408 if (!license) 1409 license = "unspecified"; 1410 1411 if (!license_is_gpl_compatible(license)) { 1412 if (!(tainted & TAINT_PROPRIETARY_MODULE)) 1413 printk(KERN_WARNING "%s: module license '%s' taints " 1414 "kernel.\n", mod->name, license); 1415 add_taint_module(mod, TAINT_PROPRIETARY_MODULE); 1416 } 1417} 1418 1419/* Parse tag=value strings from .modinfo section */ 1420static char *next_string(char *string, unsigned long *secsize) 1421{ 1422 /* Skip non-zero chars */ 1423 while (string[0]) { 1424 string++; 1425 if ((*secsize)-- <= 1) 1426 return NULL; 1427 } 1428 1429 /* Skip any zero padding. */ 1430 while (!string[0]) { 1431 string++; 1432 if ((*secsize)-- <= 1) 1433 return NULL; 1434 } 1435 return string; 1436} 1437 1438static char *get_modinfo(Elf_Shdr *sechdrs, 1439 unsigned int info, 1440 const char *tag) 1441{ 1442 char *p; 1443 unsigned int taglen = strlen(tag); 1444 unsigned long size = sechdrs[info].sh_size; 1445 1446 for (p = (char *)sechdrs[info].sh_addr; p; p = next_string(p, &size)) { 1447 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=') 1448 return p + taglen + 1; 1449 } 1450 return NULL; 1451} 1452 1453static void setup_modinfo(struct module *mod, Elf_Shdr *sechdrs, 1454 unsigned int infoindex) 1455{ 1456 struct module_attribute *attr; 1457 int i; 1458 1459 for (i = 0; (attr = modinfo_attrs[i]); i++) { 1460 if (attr->setup) 1461 attr->setup(mod, 1462 get_modinfo(sechdrs, 1463 infoindex, 1464 attr->attr.name)); 1465 } 1466} 1467 1468#ifdef CONFIG_KALLSYMS 1469static int is_exported(const char *name, const struct module *mod) 1470{ 1471 if (!mod && lookup_symbol(name, __start___ksymtab, __stop___ksymtab)) 1472 return 1; 1473 else 1474 if (mod && lookup_symbol(name, mod->syms, mod->syms + mod->num_syms)) 1475 return 1; 1476 else 1477 return 0; 1478} 1479 1480/* As per nm */ 1481static char elf_type(const Elf_Sym *sym, 1482 Elf_Shdr *sechdrs, 1483 const char *secstrings, 1484 struct module *mod) 1485{ 1486 if (ELF_ST_BIND(sym->st_info) == STB_WEAK) { 1487 if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT) 1488 return 'v'; 1489 else 1490 return 'w'; 1491 } 1492 if (sym->st_shndx == SHN_UNDEF) 1493 return 'U'; 1494 if (sym->st_shndx == SHN_ABS) 1495 return 'a'; 1496 if (sym->st_shndx >= SHN_LORESERVE) 1497 return '?'; 1498 if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR) 1499 return 't'; 1500 if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC 1501 && sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) { 1502 if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE)) 1503 return 'r'; 1504 else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL) 1505 return 'g'; 1506 else 1507 return 'd'; 1508 } 1509 if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) { 1510 if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL) 1511 return 's'; 1512 else 1513 return 'b'; 1514 } 1515 if (strncmp(secstrings + sechdrs[sym->st_shndx].sh_name, 1516 ".debug", strlen(".debug")) == 0) 1517 return 'n'; 1518 return '?'; 1519} 1520 1521static void add_kallsyms(struct module *mod, 1522 Elf_Shdr *sechdrs, 1523 unsigned int symindex, 1524 unsigned int strindex, 1525 const char *secstrings) 1526{ 1527 unsigned int i; 1528 1529 mod->symtab = (void *)sechdrs[symindex].sh_addr; 1530 mod->num_symtab = sechdrs[symindex].sh_size / sizeof(Elf_Sym); 1531 mod->strtab = (void *)sechdrs[strindex].sh_addr; 1532 1533 /* Set types up while we still have access to sections. */ 1534 for (i = 0; i < mod->num_symtab; i++) 1535 mod->symtab[i].st_info 1536 = elf_type(&mod->symtab[i], sechdrs, secstrings, mod); 1537} 1538#else 1539static inline void add_kallsyms(struct module *mod, 1540 Elf_Shdr *sechdrs, 1541 unsigned int symindex, 1542 unsigned int strindex, 1543 const char *secstrings) 1544{ 1545} 1546#endif /* CONFIG_KALLSYMS */ 1547 1548/* Allocate and load the module: note that size of section 0 is always 1549 zero, and we rely on this for optional sections. */ 1550static struct module *load_module(void __user *umod, 1551 unsigned long len, 1552 const char __user *uargs) 1553{ 1554 Elf_Ehdr *hdr; 1555 Elf_Shdr *sechdrs; 1556 char *secstrings, *args, *modmagic, *strtab = NULL; 1557 unsigned int i; 1558 unsigned int symindex = 0; 1559 unsigned int strindex = 0; 1560 unsigned int setupindex; 1561 unsigned int exindex; 1562 unsigned int exportindex; 1563 unsigned int modindex; 1564 unsigned int obsparmindex; 1565 unsigned int infoindex; 1566 unsigned int gplindex; 1567 unsigned int crcindex; 1568 unsigned int gplcrcindex; 1569 unsigned int versindex; 1570 unsigned int pcpuindex; 1571 unsigned int gplfutureindex; 1572 unsigned int gplfuturecrcindex; 1573 unsigned int unwindex = 0; 1574 unsigned int unusedindex; 1575 unsigned int unusedcrcindex; 1576 unsigned int unusedgplindex; 1577 unsigned int unusedgplcrcindex; 1578 struct module *mod; 1579 long err = 0; 1580 void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */ 1581 struct exception_table_entry *extable; 1582 mm_segment_t old_fs; 1583 1584 DEBUGP("load_module: umod=%p, len=%lu, uargs=%p\n", 1585 umod, len, uargs); 1586 if (len < sizeof(*hdr)) 1587 return ERR_PTR(-ENOEXEC); 1588 1589 /* Suck in entire file: we'll want most of it. */ 1590 /* vmalloc barfs on "unusual" numbers. Check here */ 1591 if (len > 64 * 1024 * 1024 || (hdr = vmalloc(len)) == NULL) 1592 return ERR_PTR(-ENOMEM); 1593 if (copy_from_user(hdr, umod, len) != 0) { 1594 err = -EFAULT; 1595 goto free_hdr; 1596 } 1597 1598 /* Sanity checks against insmoding binaries or wrong arch, 1599 weird elf version */ 1600 if (memcmp(hdr->e_ident, ELFMAG, 4) != 0 1601 || hdr->e_type != ET_REL 1602 || !elf_check_arch(hdr) 1603 || hdr->e_shentsize != sizeof(*sechdrs)) { 1604 err = -ENOEXEC; 1605 goto free_hdr; 1606 } 1607 1608 if (len < hdr->e_shoff + hdr->e_shnum * sizeof(Elf_Shdr)) 1609 goto truncated; 1610 1611 /* Convenience variables */ 1612 sechdrs = (void *)hdr + hdr->e_shoff; 1613 secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset; 1614 sechdrs[0].sh_addr = 0; 1615 1616 for (i = 1; i < hdr->e_shnum; i++) { 1617 if (sechdrs[i].sh_type != SHT_NOBITS 1618 && len < sechdrs[i].sh_offset + sechdrs[i].sh_size) 1619 goto truncated; 1620 1621 /* Mark all sections sh_addr with their address in the 1622 temporary image. */ 1623 sechdrs[i].sh_addr = (size_t)hdr + sechdrs[i].sh_offset; 1624 1625 /* Internal symbols and strings. */ 1626 if (sechdrs[i].sh_type == SHT_SYMTAB) { 1627 symindex = i; 1628 strindex = sechdrs[i].sh_link; 1629 strtab = (char *)hdr + sechdrs[strindex].sh_offset; 1630 } 1631#ifndef CONFIG_MODULE_UNLOAD 1632 /* Don't load .exit sections */ 1633 if (strncmp(secstrings+sechdrs[i].sh_name, ".exit", 5) == 0) 1634 sechdrs[i].sh_flags &= ~(unsigned long)SHF_ALLOC; 1635#endif 1636 } 1637 1638 modindex = find_sec(hdr, sechdrs, secstrings, 1639 ".gnu.linkonce.this_module"); 1640 if (!modindex) { 1641 printk(KERN_WARNING "No module found in object\n"); 1642 err = -ENOEXEC; 1643 goto free_hdr; 1644 } 1645 mod = (void *)sechdrs[modindex].sh_addr; 1646 1647 if (symindex == 0) { 1648 printk(KERN_WARNING "%s: module has no symbols (stripped?)\n", 1649 mod->name); 1650 err = -ENOEXEC; 1651 goto free_hdr; 1652 } 1653 1654 /* Optional sections */ 1655 exportindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab"); 1656 gplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl"); 1657 gplfutureindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl_future"); 1658 unusedindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused"); 1659 unusedgplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused_gpl"); 1660 crcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab"); 1661 gplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl"); 1662 gplfuturecrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl_future"); 1663 unusedcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused"); 1664 unusedgplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused_gpl"); 1665 setupindex = find_sec(hdr, sechdrs, secstrings, "__param"); 1666 exindex = find_sec(hdr, sechdrs, secstrings, "__ex_table"); 1667 obsparmindex = find_sec(hdr, sechdrs, secstrings, "__obsparm"); 1668 versindex = find_sec(hdr, sechdrs, secstrings, "__versions"); 1669 infoindex = find_sec(hdr, sechdrs, secstrings, ".modinfo"); 1670 pcpuindex = find_pcpusec(hdr, sechdrs, secstrings); 1671#ifdef ARCH_UNWIND_SECTION_NAME 1672 unwindex = find_sec(hdr, sechdrs, secstrings, ARCH_UNWIND_SECTION_NAME); 1673#endif 1674 1675 /* Don't keep modinfo section */ 1676 sechdrs[infoindex].sh_flags &= ~(unsigned long)SHF_ALLOC; 1677#ifdef CONFIG_KALLSYMS 1678 /* Keep symbol and string tables for decoding later. */ 1679 sechdrs[symindex].sh_flags |= SHF_ALLOC; 1680 sechdrs[strindex].sh_flags |= SHF_ALLOC; 1681#endif 1682 if (unwindex) 1683 sechdrs[unwindex].sh_flags |= SHF_ALLOC; 1684 1685 /* Check module struct version now, before we try to use module. */ 1686 if (!check_modstruct_version(sechdrs, versindex, mod)) { 1687 err = -ENOEXEC; 1688 goto free_hdr; 1689 } 1690 1691 modmagic = get_modinfo(sechdrs, infoindex, "vermagic"); 1692 /* This is allowed: modprobe --force will invalidate it. */ 1693 if (!modmagic) { 1694 add_taint_module(mod, TAINT_FORCED_MODULE); 1695 printk(KERN_WARNING "%s: no version magic, tainting kernel.\n", 1696 mod->name); 1697 } else if (!same_magic(modmagic, vermagic)) { 1698 printk(KERN_ERR "%s: version magic '%s' should be '%s'\n", 1699 mod->name, modmagic, vermagic); 1700 err = -ENOEXEC; 1701 goto free_hdr; 1702 } 1703 1704 /* Now copy in args */ 1705 args = strndup_user(uargs, ~0UL >> 1); 1706 if (IS_ERR(args)) { 1707 err = PTR_ERR(args); 1708 goto free_hdr; 1709 } 1710 1711 if (find_module(mod->name)) { 1712 err = -EEXIST; 1713 goto free_mod; 1714 } 1715 1716 mod->state = MODULE_STATE_COMING; 1717 1718 /* Allow arches to frob section contents and sizes. */ 1719 err = module_frob_arch_sections(hdr, sechdrs, secstrings, mod); 1720 if (err < 0) 1721 goto free_mod; 1722 1723 if (pcpuindex) { 1724 /* We have a special allocation for this section. */ 1725 percpu = percpu_modalloc(sechdrs[pcpuindex].sh_size, 1726 sechdrs[pcpuindex].sh_addralign, 1727 mod->name); 1728 if (!percpu) { 1729 err = -ENOMEM; 1730 goto free_mod; 1731 } 1732 sechdrs[pcpuindex].sh_flags &= ~(unsigned long)SHF_ALLOC; 1733 mod->percpu = percpu; 1734 } 1735 1736 /* Determine total sizes, and put offsets in sh_entsize. For now 1737 this is done generically; there doesn't appear to be any 1738 special cases for the architectures. */ 1739 layout_sections(mod, hdr, sechdrs, secstrings); 1740 1741 /* Do the allocs. */ 1742 ptr = module_alloc(mod->core_size); 1743 if (!ptr) { 1744 err = -ENOMEM; 1745 goto free_percpu; 1746 } 1747 memset(ptr, 0, mod->core_size); 1748 mod->module_core = ptr; 1749 1750 ptr = module_alloc(mod->init_size); 1751 if (!ptr && mod->init_size) { 1752 err = -ENOMEM; 1753 goto free_core; 1754 } 1755 memset(ptr, 0, mod->init_size); 1756 mod->module_init = ptr; 1757 1758 /* Transfer each section which specifies SHF_ALLOC */ 1759 DEBUGP("final section addresses:\n"); 1760 for (i = 0; i < hdr->e_shnum; i++) { 1761 void *dest; 1762 1763 if (!(sechdrs[i].sh_flags & SHF_ALLOC)) 1764 continue; 1765 1766 if (sechdrs[i].sh_entsize & INIT_OFFSET_MASK) 1767 dest = mod->module_init 1768 + (sechdrs[i].sh_entsize & ~INIT_OFFSET_MASK); 1769 else 1770 dest = mod->module_core + sechdrs[i].sh_entsize; 1771 1772 if (sechdrs[i].sh_type != SHT_NOBITS) 1773 memcpy(dest, (void *)sechdrs[i].sh_addr, 1774 sechdrs[i].sh_size); 1775 /* Update sh_addr to point to copy in image. */ 1776 sechdrs[i].sh_addr = (unsigned long)dest; 1777 DEBUGP("\t0x%lx %s\n", sechdrs[i].sh_addr, secstrings + sechdrs[i].sh_name); 1778 } 1779 /* Module has been moved. */ 1780 mod = (void *)sechdrs[modindex].sh_addr; 1781 1782 /* Now we've moved module, initialize linked lists, etc. */ 1783 module_unload_init(mod); 1784 1785 /* Initialize kobject, so we can reference it. */ 1786 if (mod_sysfs_init(mod) != 0) 1787 goto cleanup; 1788 1789 /* Set up license info based on the info section */ 1790 set_license(mod, get_modinfo(sechdrs, infoindex, "license")); 1791 1792 if (strcmp(mod->name, "ndiswrapper") == 0) 1793 add_taint(TAINT_PROPRIETARY_MODULE); 1794 if (strcmp(mod->name, "driverloader") == 0) 1795 add_taint_module(mod, TAINT_PROPRIETARY_MODULE); 1796 1797 /* Set up MODINFO_ATTR fields */ 1798 setup_modinfo(mod, sechdrs, infoindex); 1799 1800 /* Fix up syms, so that st_value is a pointer to location. */ 1801 err = simplify_symbols(sechdrs, symindex, strtab, versindex, pcpuindex, 1802 mod); 1803 if (err < 0) 1804 goto cleanup; 1805 1806 /* Set up EXPORTed & EXPORT_GPLed symbols (section 0 is 0 length) */ 1807 mod->num_syms = sechdrs[exportindex].sh_size / sizeof(*mod->syms); 1808 mod->syms = (void *)sechdrs[exportindex].sh_addr; 1809 if (crcindex) 1810 mod->crcs = (void *)sechdrs[crcindex].sh_addr; 1811 mod->num_gpl_syms = sechdrs[gplindex].sh_size / sizeof(*mod->gpl_syms); 1812 mod->gpl_syms = (void *)sechdrs[gplindex].sh_addr; 1813 if (gplcrcindex) 1814 mod->gpl_crcs = (void *)sechdrs[gplcrcindex].sh_addr; 1815 mod->num_gpl_future_syms = sechdrs[gplfutureindex].sh_size / 1816 sizeof(*mod->gpl_future_syms); 1817 mod->num_unused_syms = sechdrs[unusedindex].sh_size / 1818 sizeof(*mod->unused_syms); 1819 mod->num_unused_gpl_syms = sechdrs[unusedgplindex].sh_size / 1820 sizeof(*mod->unused_gpl_syms); 1821 mod->gpl_future_syms = (void *)sechdrs[gplfutureindex].sh_addr; 1822 if (gplfuturecrcindex) 1823 mod->gpl_future_crcs = (void *)sechdrs[gplfuturecrcindex].sh_addr; 1824 1825 mod->unused_syms = (void *)sechdrs[unusedindex].sh_addr; 1826 if (unusedcrcindex) 1827 mod->unused_crcs = (void *)sechdrs[unusedcrcindex].sh_addr; 1828 mod->unused_gpl_syms = (void *)sechdrs[unusedgplindex].sh_addr; 1829 if (unusedgplcrcindex) 1830 mod->unused_crcs = (void *)sechdrs[unusedgplcrcindex].sh_addr; 1831 1832#ifdef CONFIG_MODVERSIONS 1833 if ((mod->num_syms && !crcindex) || 1834 (mod->num_gpl_syms && !gplcrcindex) || 1835 (mod->num_gpl_future_syms && !gplfuturecrcindex) || 1836 (mod->num_unused_syms && !unusedcrcindex) || 1837 (mod->num_unused_gpl_syms && !unusedgplcrcindex)) { 1838 printk(KERN_WARNING "%s: No versions for exported symbols." 1839 " Tainting kernel.\n", mod->name); 1840 add_taint_module(mod, TAINT_FORCED_MODULE); 1841 } 1842#endif 1843 1844 /* Now do relocations. */ 1845 for (i = 1; i < hdr->e_shnum; i++) { 1846 const char *strtab = (char *)sechdrs[strindex].sh_addr; 1847 unsigned int info = sechdrs[i].sh_info; 1848 1849 /* Not a valid relocation section? */ 1850 if (info >= hdr->e_shnum) 1851 continue; 1852 1853 /* Don't bother with non-allocated sections */ 1854 if (!(sechdrs[info].sh_flags & SHF_ALLOC)) 1855 continue; 1856 1857 if (sechdrs[i].sh_type == SHT_REL) 1858 err = apply_relocate(sechdrs, strtab, symindex, i,mod); 1859 else if (sechdrs[i].sh_type == SHT_RELA) 1860 err = apply_relocate_add(sechdrs, strtab, symindex, i, 1861 mod); 1862 if (err < 0) 1863 goto cleanup; 1864 } 1865 1866 /* Find duplicate symbols */ 1867 err = verify_export_symbols(mod); 1868 1869 if (err < 0) 1870 goto cleanup; 1871 1872 /* Set up and sort exception table */ 1873 mod->num_exentries = sechdrs[exindex].sh_size / sizeof(*mod->extable); 1874 mod->extable = extable = (void *)sechdrs[exindex].sh_addr; 1875 sort_extable(extable, extable + mod->num_exentries); 1876 1877 /* Finally, copy percpu area over. */ 1878 percpu_modcopy(mod->percpu, (void *)sechdrs[pcpuindex].sh_addr, 1879 sechdrs[pcpuindex].sh_size); 1880 1881 add_kallsyms(mod, sechdrs, symindex, strindex, secstrings); 1882 1883 err = module_finalize(hdr, sechdrs, mod); 1884 if (err < 0) 1885 goto cleanup; 1886 1887 /* flush the icache in correct context */ 1888 old_fs = get_fs(); 1889 set_fs(KERNEL_DS); 1890 1891 /* 1892 * Flush the instruction cache, since we've played with text. 1893 * Do it before processing of module parameters, so the module 1894 * can provide parameter accessor functions of its own. 1895 */ 1896 if (mod->module_init) 1897 flush_icache_range((unsigned long)mod->module_init, 1898 (unsigned long)mod->module_init 1899 + mod->init_size); 1900 flush_icache_range((unsigned long)mod->module_core, 1901 (unsigned long)mod->module_core + mod->core_size); 1902 1903 set_fs(old_fs); 1904 1905 mod->args = args; 1906 if (obsparmindex) 1907 printk(KERN_WARNING "%s: Ignoring obsolete parameters\n", 1908 mod->name); 1909 1910 /* Size of section 0 is 0, so this works well if no params */ 1911 err = parse_args(mod->name, mod->args, 1912 (struct kernel_param *) 1913 sechdrs[setupindex].sh_addr, 1914 sechdrs[setupindex].sh_size 1915 / sizeof(struct kernel_param), 1916 NULL); 1917 if (err < 0) 1918 goto arch_cleanup; 1919 1920 err = mod_sysfs_setup(mod, 1921 (struct kernel_param *) 1922 sechdrs[setupindex].sh_addr, 1923 sechdrs[setupindex].sh_size 1924 / sizeof(struct kernel_param)); 1925 if (err < 0) 1926 goto arch_cleanup; 1927 add_sect_attrs(mod, hdr->e_shnum, secstrings, sechdrs); 1928 1929 /* Size of section 0 is 0, so this works well if no unwind info. */ 1930 mod->unwind_info = unwind_add_table(mod, 1931 (void *)sechdrs[unwindex].sh_addr, 1932 sechdrs[unwindex].sh_size); 1933 1934 /* Get rid of temporary copy */ 1935 vfree(hdr); 1936 1937 /* Done! */ 1938 return mod; 1939 1940 arch_cleanup: 1941 module_arch_cleanup(mod); 1942 cleanup: 1943 module_unload_free(mod); 1944 module_free(mod, mod->module_init); 1945 free_core: 1946 module_free(mod, mod->module_core); 1947 free_percpu: 1948 if (percpu) 1949 percpu_modfree(percpu); 1950 free_mod: 1951 kfree(args); 1952 free_hdr: 1953 vfree(hdr); 1954 return ERR_PTR(err); 1955 1956 truncated: 1957 printk(KERN_ERR "Module len %lu truncated\n", len); 1958 err = -ENOEXEC; 1959 goto free_hdr; 1960} 1961 1962/* 1963 * link the module with the whole machine is stopped with interrupts off 1964 * - this defends against kallsyms not taking locks 1965 */ 1966static int __link_module(void *_mod) 1967{ 1968 struct module *mod = _mod; 1969 list_add(&mod->list, &modules); 1970 return 0; 1971} 1972 1973/* This is where the real work happens */ 1974asmlinkage long 1975sys_init_module(void __user *umod, 1976 unsigned long len, 1977 const char __user *uargs) 1978{ 1979 struct module *mod; 1980 int ret = 0; 1981 1982 /* Must have permission */ 1983 if (!capable(CAP_SYS_MODULE)) 1984 return -EPERM; 1985 1986 /* Only one module load at a time, please */ 1987 if (mutex_lock_interruptible(&module_mutex) != 0) 1988 return -EINTR; 1989 1990 /* Do all the hard work */ 1991 mod = load_module(umod, len, uargs); 1992 if (IS_ERR(mod)) { 1993 mutex_unlock(&module_mutex); 1994 return PTR_ERR(mod); 1995 } 1996 1997 /* Now sew it into the lists. They won't access us, since 1998 strong_try_module_get() will fail. */ 1999 stop_machine_run(__link_module, mod, NR_CPUS); 2000 2001 /* Drop lock so they can recurse */ 2002 mutex_unlock(&module_mutex); 2003 2004 blocking_notifier_call_chain(&module_notify_list, 2005 MODULE_STATE_COMING, mod); 2006 2007 /* Start the module */ 2008 if (mod->init != NULL) 2009 ret = mod->init(); 2010 if (ret < 0) { 2011 /* Init routine failed: abort. Try to protect us from 2012 buggy refcounters. */ 2013 mod->state = MODULE_STATE_GOING; 2014 synchronize_sched(); 2015 if (mod->unsafe) 2016 printk(KERN_ERR "%s: module is now stuck!\n", 2017 mod->name); 2018 else { 2019 module_put(mod); 2020 mutex_lock(&module_mutex); 2021 free_module(mod); 2022 mutex_unlock(&module_mutex); 2023 } 2024 return ret; 2025 } 2026 2027 /* Now it's a first class citizen! */ 2028 mutex_lock(&module_mutex); 2029 mod->state = MODULE_STATE_LIVE; 2030 /* Drop initial reference. */ 2031 module_put(mod); 2032 unwind_remove_table(mod->unwind_info, 1); 2033 module_free(mod, mod->module_init); 2034 mod->module_init = NULL; 2035 mod->init_size = 0; 2036 mod->init_text_size = 0; 2037 mutex_unlock(&module_mutex); 2038 2039 return 0; 2040} 2041 2042static inline int within(unsigned long addr, void *start, unsigned long size) 2043{ 2044 return ((void *)addr >= start && (void *)addr < start + size); 2045} 2046 2047#ifdef CONFIG_KALLSYMS 2048/* 2049 * This ignores the intensely annoying "mapping symbols" found 2050 * in ARM ELF files: $a, $t and $d. 2051 */ 2052static inline int is_arm_mapping_symbol(const char *str) 2053{ 2054 return str[0] == '$' && strchr("atd", str[1]) 2055 && (str[2] == '\0' || str[2] == '.'); 2056} 2057 2058static const char *get_ksymbol(struct module *mod, 2059 unsigned long addr, 2060 unsigned long *size, 2061 unsigned long *offset) 2062{ 2063 unsigned int i, best = 0; 2064 unsigned long nextval; 2065 2066 /* At worse, next value is at end of module */ 2067 if (within(addr, mod->module_init, mod->init_size)) 2068 nextval = (unsigned long)mod->module_init+mod->init_text_size; 2069 else 2070 nextval = (unsigned long)mod->module_core+mod->core_text_size; 2071 2072 /* Scan for closest preceeding symbol, and next symbol. (ELF 2073 starts real symbols at 1). */ 2074 for (i = 1; i < mod->num_symtab; i++) { 2075 if (mod->symtab[i].st_shndx == SHN_UNDEF) 2076 continue; 2077 2078 /* We ignore unnamed symbols: they're uninformative 2079 * and inserted at a whim. */ 2080 if (mod->symtab[i].st_value <= addr 2081 && mod->symtab[i].st_value > mod->symtab[best].st_value 2082 && *(mod->strtab + mod->symtab[i].st_name) != '\0' 2083 && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name)) 2084 best = i; 2085 if (mod->symtab[i].st_value > addr 2086 && mod->symtab[i].st_value < nextval 2087 && *(mod->strtab + mod->symtab[i].st_name) != '\0' 2088 && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name)) 2089 nextval = mod->symtab[i].st_value; 2090 } 2091 2092 if (!best) 2093 return NULL; 2094 2095 if (size) 2096 *size = nextval - mod->symtab[best].st_value; 2097 if (offset) 2098 *offset = addr - mod->symtab[best].st_value; 2099 return mod->strtab + mod->symtab[best].st_name; 2100} 2101 2102/* For kallsyms to ask for address resolution. NULL means not found. 2103 We don't lock, as this is used for oops resolution and races are a 2104 lesser concern. */ 2105const char *module_address_lookup(unsigned long addr, 2106 unsigned long *size, 2107 unsigned long *offset, 2108 char **modname) 2109{ 2110 struct module *mod; 2111 2112 list_for_each_entry(mod, &modules, list) { 2113 if (within(addr, mod->module_init, mod->init_size) 2114 || within(addr, mod->module_core, mod->core_size)) { 2115 if (modname) 2116 *modname = mod->name; 2117 return get_ksymbol(mod, addr, size, offset); 2118 } 2119 } 2120 return NULL; 2121} 2122 2123int lookup_module_symbol_name(unsigned long addr, char *symname) 2124{ 2125 struct module *mod; 2126 2127 mutex_lock(&module_mutex); 2128 list_for_each_entry(mod, &modules, list) { 2129 if (within(addr, mod->module_init, mod->init_size) || 2130 within(addr, mod->module_core, mod->core_size)) { 2131 const char *sym; 2132 2133 sym = get_ksymbol(mod, addr, NULL, NULL); 2134 if (!sym) 2135 goto out; 2136 strlcpy(symname, sym, KSYM_NAME_LEN + 1); 2137 mutex_unlock(&module_mutex); 2138 return 0; 2139 } 2140 } 2141out: 2142 mutex_unlock(&module_mutex); 2143 return -ERANGE; 2144} 2145 2146int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, 2147 unsigned long *offset, char *modname, char *name) 2148{ 2149 struct module *mod; 2150 2151 mutex_lock(&module_mutex); 2152 list_for_each_entry(mod, &modules, list) { 2153 if (within(addr, mod->module_init, mod->init_size) || 2154 within(addr, mod->module_core, mod->core_size)) { 2155 const char *sym; 2156 2157 sym = get_ksymbol(mod, addr, size, offset); 2158 if (!sym) 2159 goto out; 2160 if (modname) 2161 strlcpy(modname, mod->name, MODULE_NAME_LEN + 1); 2162 if (name) 2163 strlcpy(name, sym, KSYM_NAME_LEN + 1); 2164 mutex_unlock(&module_mutex); 2165 return 0; 2166 } 2167 } 2168out: 2169 mutex_unlock(&module_mutex); 2170 return -ERANGE; 2171} 2172 2173int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type, 2174 char *name, char *module_name, int *exported) 2175{ 2176 struct module *mod; 2177 2178 mutex_lock(&module_mutex); 2179 list_for_each_entry(mod, &modules, list) { 2180 if (symnum < mod->num_symtab) { 2181 *value = mod->symtab[symnum].st_value; 2182 *type = mod->symtab[symnum].st_info; 2183 strlcpy(name, mod->strtab + mod->symtab[symnum].st_name, 2184 KSYM_NAME_LEN + 1); 2185 strlcpy(module_name, mod->name, MODULE_NAME_LEN + 1); 2186 *exported = is_exported(name, mod); 2187 mutex_unlock(&module_mutex); 2188 return 0; 2189 } 2190 symnum -= mod->num_symtab; 2191 } 2192 mutex_unlock(&module_mutex); 2193 return -ERANGE; 2194} 2195 2196static unsigned long mod_find_symname(struct module *mod, const char *name) 2197{ 2198 unsigned int i; 2199 2200 for (i = 0; i < mod->num_symtab; i++) 2201 if (strcmp(name, mod->strtab+mod->symtab[i].st_name) == 0 && 2202 mod->symtab[i].st_info != 'U') 2203 return mod->symtab[i].st_value; 2204 return 0; 2205} 2206 2207/* Look for this name: can be of form module:name. */ 2208unsigned long module_kallsyms_lookup_name(const char *name) 2209{ 2210 struct module *mod; 2211 char *colon; 2212 unsigned long ret = 0; 2213 2214 /* Don't lock: we're in enough trouble already. */ 2215 if ((colon = strchr(name, ':')) != NULL) { 2216 *colon = '\0'; 2217 if ((mod = find_module(name)) != NULL) 2218 ret = mod_find_symname(mod, colon+1); 2219 *colon = ':'; 2220 } else { 2221 list_for_each_entry(mod, &modules, list) 2222 if ((ret = mod_find_symname(mod, name)) != 0) 2223 break; 2224 } 2225 return ret; 2226} 2227#endif /* CONFIG_KALLSYMS */ 2228 2229/* Called by the /proc file system to return a list of modules. */ 2230static void *m_start(struct seq_file *m, loff_t *pos) 2231{ 2232 struct list_head *i; 2233 loff_t n = 0; 2234 2235 mutex_lock(&module_mutex); 2236 list_for_each(i, &modules) { 2237 if (n++ == *pos) 2238 break; 2239 } 2240 if (i == &modules) 2241 return NULL; 2242 return i; 2243} 2244 2245static void *m_next(struct seq_file *m, void *p, loff_t *pos) 2246{ 2247 struct list_head *i = p; 2248 (*pos)++; 2249 if (i->next == &modules) 2250 return NULL; 2251 return i->next; 2252} 2253 2254static void m_stop(struct seq_file *m, void *p) 2255{ 2256 mutex_unlock(&module_mutex); 2257} 2258 2259static char *taint_flags(unsigned int taints, char *buf) 2260{ 2261 int bx = 0; 2262 2263 if (taints) { 2264 buf[bx++] = '('; 2265 if (taints & TAINT_PROPRIETARY_MODULE) 2266 buf[bx++] = 'P'; 2267 if (taints & TAINT_FORCED_MODULE) 2268 buf[bx++] = 'F'; 2269 /* 2270 * TAINT_FORCED_RMMOD: could be added. 2271 * TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't 2272 * apply to modules. 2273 */ 2274 buf[bx++] = ')'; 2275 } 2276 buf[bx] = '\0'; 2277 2278 return buf; 2279} 2280 2281static int m_show(struct seq_file *m, void *p) 2282{ 2283 struct module *mod = list_entry(p, struct module, list); 2284 char buf[8]; 2285 2286 seq_printf(m, "%s %lu", 2287 mod->name, mod->init_size + mod->core_size); 2288 print_unload_info(m, mod); 2289 2290 /* Informative for users. */ 2291 seq_printf(m, " %s", 2292 mod->state == MODULE_STATE_GOING ? "Unloading": 2293 mod->state == MODULE_STATE_COMING ? "Loading": 2294 "Live"); 2295 /* Used by oprofile and other similar tools. */ 2296 seq_printf(m, " 0x%p", mod->module_core); 2297 2298 /* Taints info */ 2299 if (mod->taints) 2300 seq_printf(m, " %s", taint_flags(mod->taints, buf)); 2301 2302 seq_printf(m, "\n"); 2303 return 0; 2304} 2305 2306/* Format: modulename size refcount deps address 2307 2308 Where refcount is a number or -, and deps is a comma-separated list 2309 of depends or -. 2310*/ 2311const struct seq_operations modules_op = { 2312 .start = m_start, 2313 .next = m_next, 2314 .stop = m_stop, 2315 .show = m_show 2316}; 2317 2318/* Given an address, look for it in the module exception tables. */ 2319const struct exception_table_entry *search_module_extables(unsigned long addr) 2320{ 2321 unsigned long flags; 2322 const struct exception_table_entry *e = NULL; 2323 struct module *mod; 2324 2325 spin_lock_irqsave(&modlist_lock, flags); 2326 list_for_each_entry(mod, &modules, list) { 2327 if (mod->num_exentries == 0) 2328 continue; 2329 2330 e = search_extable(mod->extable, 2331 mod->extable + mod->num_exentries - 1, 2332 addr); 2333 if (e) 2334 break; 2335 } 2336 spin_unlock_irqrestore(&modlist_lock, flags); 2337 2338 /* Now, if we found one, we are running inside it now, hence 2339 we cannot unload the module, hence no refcnt needed. */ 2340 return e; 2341} 2342 2343/* 2344 * Is this a valid module address? 2345 */ 2346int is_module_address(unsigned long addr) 2347{ 2348 unsigned long flags; 2349 struct module *mod; 2350 2351 spin_lock_irqsave(&modlist_lock, flags); 2352 2353 list_for_each_entry(mod, &modules, list) { 2354 if (within(addr, mod->module_core, mod->core_size)) { 2355 spin_unlock_irqrestore(&modlist_lock, flags); 2356 return 1; 2357 } 2358 } 2359 2360 spin_unlock_irqrestore(&modlist_lock, flags); 2361 2362 return 0; 2363} 2364 2365 2366/* Is this a valid kernel address? We don't grab the lock: we are oopsing. */ 2367struct module *__module_text_address(unsigned long addr) 2368{ 2369 struct module *mod; 2370 2371 list_for_each_entry(mod, &modules, list) 2372 if (within(addr, mod->module_init, mod->init_text_size) 2373 || within(addr, mod->module_core, mod->core_text_size)) 2374 return mod; 2375 return NULL; 2376} 2377 2378struct module *module_text_address(unsigned long addr) 2379{ 2380 struct module *mod; 2381 unsigned long flags; 2382 2383 spin_lock_irqsave(&modlist_lock, flags); 2384 mod = __module_text_address(addr); 2385 spin_unlock_irqrestore(&modlist_lock, flags); 2386 2387 return mod; 2388} 2389 2390/* Don't grab lock, we're oopsing. */ 2391void print_modules(void) 2392{ 2393 struct module *mod; 2394 char buf[8]; 2395 2396 printk("Modules linked in:"); 2397 list_for_each_entry(mod, &modules, list) 2398 printk(" %s%s", mod->name, taint_flags(mod->taints, buf)); 2399 printk("\n"); 2400} 2401 2402#ifdef CONFIG_SYSFS 2403static char *make_driver_name(struct device_driver *drv) 2404{ 2405 char *driver_name; 2406 2407 driver_name = kmalloc(strlen(drv->name) + strlen(drv->bus->name) + 2, 2408 GFP_KERNEL); 2409 if (!driver_name) 2410 return NULL; 2411 2412 sprintf(driver_name, "%s:%s", drv->bus->name, drv->name); 2413 return driver_name; 2414} 2415 2416static void module_create_drivers_dir(struct module_kobject *mk) 2417{ 2418 if (!mk || mk->drivers_dir) 2419 return; 2420 2421 mk->drivers_dir = kobject_add_dir(&mk->kobj, "drivers"); 2422} 2423 2424void module_add_driver(struct module *mod, struct device_driver *drv) 2425{ 2426 char *driver_name; 2427 int no_warn; 2428 struct module_kobject *mk = NULL; 2429 2430 if (!drv) 2431 return; 2432 2433 if (mod) 2434 mk = &mod->mkobj; 2435 else if (drv->mod_name) { 2436 struct kobject *mkobj; 2437 2438 /* Lookup built-in module entry in /sys/modules */ 2439 mkobj = kset_find_obj(&module_subsys, drv->mod_name); 2440 if (mkobj) { 2441 mk = container_of(mkobj, struct module_kobject, kobj); 2442 /* remember our module structure */ 2443 drv->mkobj = mk; 2444 /* kset_find_obj took a reference */ 2445 kobject_put(mkobj); 2446 } 2447 } 2448 2449 if (!mk) 2450 return; 2451 2452 /* Don't check return codes; these calls are idempotent */ 2453 no_warn = sysfs_create_link(&drv->kobj, &mk->kobj, "module"); 2454 driver_name = make_driver_name(drv); 2455 if (driver_name) { 2456 module_create_drivers_dir(mk); 2457 no_warn = sysfs_create_link(mk->drivers_dir, &drv->kobj, 2458 driver_name); 2459 kfree(driver_name); 2460 } 2461} 2462EXPORT_SYMBOL(module_add_driver); 2463 2464void module_remove_driver(struct device_driver *drv) 2465{ 2466 struct module_kobject *mk = NULL; 2467 char *driver_name; 2468 2469 if (!drv) 2470 return; 2471 2472 sysfs_remove_link(&drv->kobj, "module"); 2473 2474 if (drv->owner) 2475 mk = &drv->owner->mkobj; 2476 else if (drv->mkobj) 2477 mk = drv->mkobj; 2478 if (mk && mk->drivers_dir) { 2479 driver_name = make_driver_name(drv); 2480 if (driver_name) { 2481 sysfs_remove_link(mk->drivers_dir, driver_name); 2482 kfree(driver_name); 2483 } 2484 } 2485} 2486EXPORT_SYMBOL(module_remove_driver); 2487#endif 2488 2489#ifdef CONFIG_MODVERSIONS 2490/* Generate the signature for struct module here, too, for modversions. */ 2491void struct_module(struct module *mod) { return; } 2492EXPORT_SYMBOL(struct_module); 2493#endif 2494