kernel/module.c

   1 #include <linux/config.h>
   2 #include <linux/mm.h>
   3 #include <linux/module.h>
   4 #include <asm/uaccess.h>
   5 #include <linux/vmalloc.h>
   6 #include <linux/smp_lock.h>
   7 #include <asm/pgalloc.h>
   8 #include <linux/init.h>
   9
  10 /*
  11  * Originally by Anonymous (as far as I know...)
  12  * Linux version by Bas Laarhoven <bas@vimec.nl>
  13  * 0.99.14 version by Jon Tombs <jon@gtex02.us.es>,
  14  * Heavily modified by Bjorn Ekwall <bj0rn@blox.se> May 1994 (C)
  15  * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
  16  * Add MOD_INITIALIZING Keith Owens <kaos@ocs.com.au> Nov 1999
  17  *
  18  * This source is covered by the GNU GPL, the same as all kernel sources.
  19  */
  20
  21 #ifdef CONFIG_MODULES           /* a *big* #ifdef block... */
  22
  23 extern struct module_symbol __start___ksymtab[];
  24 extern struct module_symbol __stop___ksymtab[];
  25
  26 extern const struct exception_table_entry __start___ex_table[];
  27 extern const struct exception_table_entry __stop___ex_table[];
  28
  29 static struct module kernel_module =
  30 {
  31         sizeof(struct module),  /* size_of_struct */
  32         NULL,                   /* next */
  33         "",                     /* name */
  34         0,                      /* size */
  35         {ATOMIC_INIT(1)},       /* usecount */
  36         MOD_RUNNING,            /* flags */
  37         0,                      /* nsyms -- to filled in in init_modules */
  38         0,                      /* ndeps */
  39         __start___ksymtab,      /* syms */
  40         NULL,                   /* deps */
  41         NULL,                   /* refs */
  42         NULL,                   /* init */
  43         NULL,                   /* cleanup */
  44         __start___ex_table,     /* ex_table_start */
  45         __stop___ex_table,      /* ex_table_end */
  46         /* Rest are NULL */
  47 };
  48
  49 struct module *module_list = &kernel_module;
  50
  51 static long get_mod_name(const char *user_name, char **buf);
  52 static void put_mod_name(char *buf);
  53 static struct module *find_module(const char *name);
  54 static void free_module(struct module *, int tag_freed);
  55
  56
  57 /*
  58  * Called at boot time
  59  */
  60
  61 void __init init_modules(void)
  62 {
  63         kernel_module.nsyms = __stop___ksymtab - __start___ksymtab;
  64
  65 #ifdef __alpha__
  66         __asm__("stq $29,%0" : "=m"(kernel_module.gp));
  67 #endif
  68 }
  69
  70 /*
  71  * Copy the name of a module from user space.
  72  */
  73
  74 static inline long
  75 get_mod_name(const char *user_name, char **buf)
  76 {
  77         unsigned long page;
  78         long retval;
  79
  80         page = __get_free_page(GFP_KERNEL);
  81         if (!page)
  82                 return -ENOMEM;
  83
  84         retval = strncpy_from_user((char *)page, user_name, PAGE_SIZE);
  85         if (retval > 0) {
  86                 if (retval < PAGE_SIZE) {
  87                         *buf = (char *)page;
  88                         return retval;
  89                 }
  90                 retval = -ENAMETOOLONG;
  91         } else if (!retval)
  92                 retval = -EINVAL;
  93
  94         free_page(page);
  95         return retval;
  96 }
  97
  98 static inline void
  99 put_mod_name(char *buf)
 100 {
 101         free_page((unsigned long)buf);
 102 }
 103
 104 /*
 105  * Allocate space for a module.
 106  */
 107
 108 asmlinkage unsigned long
 109 sys_create_module(const char *name_user, size_t size)
 110 {
 111         char *name;
 112         long namelen, error;
 113         struct module *mod;
 114
 115         if (!capable(CAP_SYS_MODULE))
 116                 return -EPERM;
 117         lock_kernel();
 118         if ((namelen = get_mod_name(name_user, &name)) < 0) {
 119                 error = namelen;
 120                 goto err0;
 121         }
 122         if (size < sizeof(struct module)+namelen) {
 123                 error = -EINVAL;
 124                 goto err1;
 125         }
 126         if (find_module(name) != NULL) {
 127                 error = -EEXIST;
 128                 goto err1;
 129         }
 130         if ((mod = (struct module *)module_map(size)) == NULL) {
 131                 error = -ENOMEM;
 132                 goto err1;
 133         }
 134
 135         memset(mod, 0, sizeof(*mod));
 136         mod->size_of_struct = sizeof(*mod);
 137         mod->next = module_list;
 138         mod->name = (char *)(mod + 1);
 139         mod->size = size;
 140         memcpy((char*)(mod+1), name, namelen+1);
 141
 142         put_mod_name(name);
 143
 144         module_list = mod;      /* link it in */
 145
 146         error = (long) mod;
 147         goto err0;
 148 err1:
 149         put_mod_name(name);
 150 err0:
 151         unlock_kernel();
 152         return error;
 153 }
 154
 155 /*
 156  * Initialize a module.
 157  */
 158
 159 asmlinkage long
 160 sys_init_module(const char *name_user, struct module *mod_user)
 161 {
 162         struct module mod_tmp, *mod;
 163         char *name, *n_name;
 164         long namelen, n_namelen, i, error;
 165         unsigned long mod_user_size;
 166         struct module_ref *dep;
 167
 168         if (!capable(CAP_SYS_MODULE))
 169                 return -EPERM;
 170         lock_kernel();
 171         if ((namelen = get_mod_name(name_user, &name)) < 0) {
 172                 error = namelen;
 173                 goto err0;
 174         }
 175         if ((mod = find_module(name)) == NULL) {
 176                 error = -ENOENT;
 177                 goto err1;
 178         }
 179
 180         /* Check module header size.  We allow a bit of slop over the
 181            size we are familiar with to cope with a version of insmod
 182            for a newer kernel.  But don't over do it. */
 183         if ((error = get_user(mod_user_size, &mod_user->size_of_struct)) != 0)
 184                 goto err1;
 185         if (mod_user_size < (unsigned long)&((struct module *)0L)->persist_start
 186             || mod_user_size > sizeof(struct module) + 16*sizeof(void*)) {
 187                 printk(KERN_ERR "init_module: Invalid module header size.\n"
 188                        KERN_ERR "A new version of the modutils is likely "
 189                                 "needed.\n");
 190                 error = -EINVAL;
 191                 goto err1;
 192         }
 193
 194         /* Hold the current contents while we play with the user's idea
 195            of righteousness.  */
 196         mod_tmp = *mod;
 197
 198         error = copy_from_user(mod, mod_user, sizeof(struct module));
 199         if (error) {
 200                 error = -EFAULT;
 201                 goto err2;
 202         }
 203
 204         /* Sanity check the size of the module.  */
 205         error = -EINVAL;
 206
 207         if (mod->size > mod_tmp.size) {
 208                 printk(KERN_ERR "init_module: Size of initialized module "
 209                                 "exceeds size of created module.\n");
 210                 goto err2;
 211         }
 212
 213         /* Make sure all interesting pointers are sane.  */
 214
 215 #define bound(p, n, m)  ((unsigned long)(p) >= (unsigned long)(m+1) &&  \
 216                  (unsigned long)((p)+(n)) <= (unsigned long)(m) + (m)->size)
 217
 218         if (!bound(mod->name, namelen, mod)) {
 219                 printk(KERN_ERR "init_module: mod->name out of bounds.\n");
 220                 goto err2;
 221         }
 222         if (mod->nsyms && !bound(mod->syms, mod->nsyms, mod)) {
 223                 printk(KERN_ERR "init_module: mod->syms out of bounds.\n");
 224                 goto err2;
 225         }
 226         if (mod->ndeps && !bound(mod->deps, mod->ndeps, mod)) {
 227                 printk(KERN_ERR "init_module: mod->deps out of bounds.\n");
 228                 goto err2;
 229         }
 230         if (mod->init && !bound(mod->init, 0, mod)) {
 231                 printk(KERN_ERR "init_module: mod->init out of bounds.\n");
 232                 goto err2;
 233         }
 234         if (mod->cleanup && !bound(mod->cleanup, 0, mod)) {
 235                 printk(KERN_ERR "init_module: mod->cleanup out of bounds.\n");
 236                 goto err2;
 237         }
 238         if (mod->ex_table_start > mod->ex_table_end
 239             || (mod->ex_table_start &&
 240                 !((unsigned long)mod->ex_table_start >= (unsigned long)(mod+1)
 241                   && ((unsigned long)mod->ex_table_end
 242                       < (unsigned long)mod + mod->size)))
 243             || (((unsigned long)mod->ex_table_start
 244                  - (unsigned long)mod->ex_table_end)
 245                 % sizeof(struct exception_table_entry))) {
 246                 printk(KERN_ERR "init_module: mod->ex_table_* invalid.\n");
 247                 goto err2;
 248         }
 249         if (mod->flags & ~MOD_AUTOCLEAN) {
 250                 printk(KERN_ERR "init_module: mod->flags invalid.\n");
 251                 goto err2;
 252         }
 253 #ifdef __alpha__
 254         if (!bound(mod->gp - 0x8000, 0, mod)) {
 255                 printk(KERN_ERR "init_module: mod->gp out of bounds.\n");
 256                 goto err2;
 257         }
 258 #endif
 259         if (mod_member_present(mod, can_unload)
 260             && mod->can_unload && !bound(mod->can_unload, 0, mod)) {
 261                 printk(KERN_ERR "init_module: mod->can_unload out of bounds.\n");
 262                 goto err2;
 263         }
 264
 265 #undef bound
 266
 267         /* Check that the user isn't doing something silly with the name.  */
 268
 269         if ((n_namelen = get_mod_name(mod->name - (unsigned long)mod
 270                                       + (unsigned long)mod_user,
 271                                       &n_name)) < 0) {
 272                 error = n_namelen;
 273                 goto err2;
 274         }
 275         if (namelen != n_namelen || strcmp(n_name, mod_tmp.name) != 0) {
 276                 printk(KERN_ERR "init_module: changed module name to "
 277                                 "`%s' from `%s'\n",
 278                        n_name, mod_tmp.name);
 279                 goto err3;
 280         }
 281
 282         /* Ok, that's about all the sanity we can stomach; copy the rest.  */
 283
 284         if (copy_from_user(mod+1, mod_user+1, mod->size-sizeof(*mod))) {
 285                 error = -EFAULT;
 286                 goto err3;
 287         }
 288
 289         /* On some machines it is necessary to do something here
 290            to make the I and D caches consistent.  */
 291         flush_icache_range((unsigned long)mod, (unsigned long)mod + mod->size);
 292
 293         /* Update module references.  */
 294         mod->next = mod_tmp.next;
 295         mod->refs = NULL;
 296         for (i = 0, dep = mod->deps; i < mod->ndeps; ++i, ++dep) {
 297                 struct module *o, *d = dep->dep;
 298
 299                 /* Make sure the indicated dependencies are really modules.  */
 300                 if (d == mod) {
 301                         printk(KERN_ERR "init_module: self-referential "
 302                                         "dependency in mod->deps.\n");
 303                         goto err3;
 304                 }
 305
 306                 for (o = module_list; o != &kernel_module; o = o->next)
 307                         if (o == d) goto found_dep;
 308
 309                 printk(KERN_ERR "init_module: found dependency that is "
 310                                 "(no longer?) a module.\n");
 311                 goto err3;
 312
 313         found_dep:
 314                 dep->ref = mod;
 315                 dep->next_ref = d->refs;
 316                 d->refs = dep;
 317                 /* Being referenced by a dependent module counts as a
 318                    use as far as kmod is concerned.  */
 319                 d->flags |= MOD_USED_ONCE;
 320         }
 321
 322         /* Free our temporary memory.  */
 323         put_mod_name(n_name);
 324         put_mod_name(name);
 325
 326         /* Initialize the module.  */
 327         mod->flags |= MOD_INITIALIZING;
 328         atomic_set(&mod->uc.usecount,1);
 329         if (mod->init && mod->init() != 0) {
 330                 atomic_set(&mod->uc.usecount,0);
 331                 mod->flags &= ~MOD_INITIALIZING;
 332                 error = -EBUSY;
 333                 goto err0;
 334         }
 335         atomic_dec(&mod->uc.usecount);
 336
 337         /* And set it running.  */
 338         mod->flags = (mod->flags | MOD_RUNNING) & ~MOD_INITIALIZING;
 339         error = 0;
 340         goto err0;
 341
 342 err3:
 343         put_mod_name(n_name);
 344 err2:
 345         *mod = mod_tmp;
 346 err1:
 347         put_mod_name(name);
 348 err0:
 349         unlock_kernel();
 350         return error;
 351 }
 352
 353 static spinlock_t unload_lock = SPIN_LOCK_UNLOCKED;
 354 int try_inc_mod_count(struct module *mod)
 355 {
 356         int res = 1;
 357         if (mod) {
 358                 spin_lock(&unload_lock);
 359                 if (mod->flags & MOD_DELETED)
 360                         res = 0;
 361                 else
 362                         __MOD_INC_USE_COUNT(mod);
 363                 spin_unlock(&unload_lock);
 364         }
 365         return res;
 366 }
 367
 368 asmlinkage long
 369 sys_delete_module(const char *name_user)
 370 {
 371         struct module *mod, *next;
 372         char *name;
 373         long error;
 374         int something_changed;
 375
 376         if (!capable(CAP_SYS_MODULE))
 377                 return -EPERM;
 378
 379         lock_kernel();
 380         if (name_user) {
 381                 if ((error = get_mod_name(name_user, &name)) < 0)
 382                         goto out;
 383                 if (error == 0) {
 384                         error = -EINVAL;
 385                         put_mod_name(name);
 386                         goto out;
 387                 }
 388                 error = -ENOENT;
 389                 if ((mod = find_module(name)) == NULL) {
 390                         put_mod_name(name);
 391                         goto out;
 392                 }
 393                 put_mod_name(name);
 394                 error = -EBUSY;
 395                 if (mod->refs != NULL)
 396                         goto out;
 397
 398                 spin_lock(&unload_lock);
 399                 if (!__MOD_IN_USE(mod)) {
 400                         mod->flags |= MOD_DELETED;
 401                         spin_unlock(&unload_lock);
 402                         free_module(mod, 0);
 403                         error = 0;
 404                 } else {
 405                         spin_unlock(&unload_lock);
 406                 }
 407                 goto out;
 408         }
 409
 410         /* Do automatic reaping */
 411 restart:
 412         something_changed = 0;
 413         for (mod = module_list; mod != &kernel_module; mod = next) {
 414                 next = mod->next;
 415                 spin_lock(&unload_lock);
 416                 if (mod->refs == NULL
 417                     && (mod->flags & MOD_AUTOCLEAN)
 418                     && (mod->flags & MOD_RUNNING)
 419                     && !(mod->flags & MOD_DELETED)
 420                     && (mod->flags & MOD_USED_ONCE)
 421                     && !__MOD_IN_USE(mod)) {
 422                         if ((mod->flags & MOD_VISITED)
 423                             && !(mod->flags & MOD_JUST_FREED)) {
 424                                 spin_unlock(&unload_lock);
 425                                 mod->flags &= ~MOD_VISITED;
 426                         } else {
 427                                 mod->flags |= MOD_DELETED;
 428                                 spin_unlock(&unload_lock);
 429                                 free_module(mod, 1);
 430                                 something_changed = 1;
 431                         }
 432                 } else {
 433                         spin_unlock(&unload_lock);
 434                 }
 435         }
 436         if (something_changed)
 437                 goto restart;
 438         for (mod = module_list; mod != &kernel_module; mod = mod->next)
 439                 mod->flags &= ~MOD_JUST_FREED;
 440         error = 0;
 441 out:
 442         unlock_kernel();
 443         return error;
 444 }
 445
 446 /* Query various bits about modules.  */
 447
 448 static int
 449 qm_modules(char *buf, size_t bufsize, size_t *ret)
 450 {
 451         struct module *mod;
 452         size_t nmod, space, len;
 453
 454         nmod = space = 0;
 455
 456         for (mod=module_list; mod != &kernel_module; mod=mod->next, ++nmod) {
 457                 len = strlen(mod->name)+1;
 458                 if (len > bufsize)
 459                         goto calc_space_needed;
 460                 if (copy_to_user(buf, mod->name, len))
 461                         return -EFAULT;
 462                 buf += len;
 463                 bufsize -= len;
 464                 space += len;
 465         }
 466
 467         if (put_user(nmod, ret))
 468                 return -EFAULT;
 469         else
 470                 return 0;
 471
 472 calc_space_needed:
 473         space += len;
 474         while ((mod = mod->next) != &kernel_module)
 475                 space += strlen(mod->name)+1;
 476
 477         if (put_user(space, ret))
 478                 return -EFAULT;
 479         else
 480                 return -ENOSPC;
 481 }
 482
 483 static int
 484 qm_deps(struct module *mod, char *buf, size_t bufsize, size_t *ret)
 485 {
 486         size_t i, space, len;
 487
 488         if (mod == &kernel_module)
 489                 return -EINVAL;
 490         if (!MOD_CAN_QUERY(mod))
 491                 if (put_user(0, ret))
 492                         return -EFAULT;
 493                 else
 494                         return 0;
 495
 496         space = 0;
 497         for (i = 0; i < mod->ndeps; ++i) {
 498                 const char *dep_name = mod->deps[i].dep->name;
 499
 500                 len = strlen(dep_name)+1;
 501                 if (len > bufsize)
 502                         goto calc_space_needed;
 503                 if (copy_to_user(buf, dep_name, len))
 504                         return -EFAULT;
 505                 buf += len;
 506                 bufsize -= len;
 507                 space += len;
 508         }
 509
 510         if (put_user(i, ret))
 511                 return -EFAULT;
 512         else
 513                 return 0;
 514
 515 calc_space_needed:
 516         space += len;
 517         while (++i < mod->ndeps)
 518                 space += strlen(mod->deps[i].dep->name)+1;
 519
 520         if (put_user(space, ret))
 521                 return -EFAULT;
 522         else
 523                 return -ENOSPC;
 524 }
 525
 526 static int
 527 qm_refs(struct module *mod, char *buf, size_t bufsize, size_t *ret)
 528 {
 529         size_t nrefs, space, len;
 530         struct module_ref *ref;
 531
 532         if (mod == &kernel_module)
 533                 return -EINVAL;
 534         if (!MOD_CAN_QUERY(mod))
 535                 if (put_user(0, ret))
 536                         return -EFAULT;
 537                 else
 538                         return 0;
 539
 540         space = 0;
 541         for (nrefs = 0, ref = mod->refs; ref ; ++nrefs, ref = ref->next_ref) {
 542                 const char *ref_name = ref->ref->name;
 543
 544                 len = strlen(ref_name)+1;
 545                 if (len > bufsize)
 546                         goto calc_space_needed;
 547                 if (copy_to_user(buf, ref_name, len))
 548                         return -EFAULT;
 549                 buf += len;
 550                 bufsize -= len;
 551                 space += len;
 552         }
 553
 554         if (put_user(nrefs, ret))
 555                 return -EFAULT;
 556         else
 557                 return 0;
 558
 559 calc_space_needed:
 560         space += len;
 561         while ((ref = ref->next_ref) != NULL)
 562                 space += strlen(ref->ref->name)+1;
 563
 564         if (put_user(space, ret))
 565                 return -EFAULT;
 566         else
 567                 return -ENOSPC;
 568 }
 569
 570 static int
 571 qm_symbols(struct module *mod, char *buf, size_t bufsize, size_t *ret)
 572 {
 573         size_t i, space, len;
 574         struct module_symbol *s;
 575         char *strings;
 576         unsigned long *vals;
 577
 578         if (!MOD_CAN_QUERY(mod))
 579                 if (put_user(0, ret))
 580                         return -EFAULT;
 581                 else
 582                         return 0;
 583
 584         space = mod->nsyms * 2*sizeof(void *);
 585
 586         i = len = 0;
 587         s = mod->syms;
 588
 589         if (space > bufsize)
 590                 goto calc_space_needed;
 591
 592         if (!access_ok(VERIFY_WRITE, buf, space))
 593                 return -EFAULT;
 594
 595         bufsize -= space;
 596         vals = (unsigned long *)buf;
 597         strings = buf+space;
 598
 599         for (; i < mod->nsyms ; ++i, ++s, vals += 2) {
 600                 len = strlen(s->name)+1;
 601                 if (len > bufsize)
 602                         goto calc_space_needed;
 603
 604                 if (copy_to_user(strings, s->name, len)
 605                     || __put_user(s->value, vals+0)
 606                     || __put_user(space, vals+1))
 607                         return -EFAULT;
 608
 609                 strings += len;
 610                 bufsize -= len;
 611                 space += len;
 612         }
 613
 614         if (put_user(i, ret))
 615                 return -EFAULT;
 616         else
 617                 return 0;
 618
 619 calc_space_needed:
 620         for (; i < mod->nsyms; ++i, ++s)
 621                 space += strlen(s->name)+1;
 622
 623         if (put_user(space, ret))
 624                 return -EFAULT;
 625         else
 626                 return -ENOSPC;
 627 }
 628
 629 static int
 630 qm_info(struct module *mod, char *buf, size_t bufsize, size_t *ret)
 631 {
 632         int error = 0;
 633
 634         if (mod == &kernel_module)
 635                 return -EINVAL;
 636
 637         if (sizeof(struct module_info) <= bufsize) {
 638                 struct module_info info;
 639                 info.addr = (unsigned long)mod;
 640                 info.size = mod->size;
 641                 info.flags = mod->flags;
 642                 info.usecount = (mod_member_present(mod, can_unload)
 643                                  && mod->can_unload ? -1 : atomic_read(&mod->uc.usecount));
 644
 645                 if (copy_to_user(buf, &info, sizeof(struct module_info)))
 646                         return -EFAULT;
 647         } else
 648                 error = -ENOSPC;
 649
 650         if (put_user(sizeof(struct module_info), ret))
 651                 return -EFAULT;
 652
 653         return error;
 654 }
 655
 656 asmlinkage long
 657 sys_query_module(const char *name_user, int which, char *buf, size_t bufsize,
 658                  size_t *ret)
 659 {
 660         struct module *mod;
 661         int err;
 662
 663         lock_kernel();
 664         if (name_user == NULL)
 665                 mod = &kernel_module;
 666         else {
 667                 long namelen;
 668                 char *name;
 669
 670                 if ((namelen = get_mod_name(name_user, &name)) < 0) {
 671                         err = namelen;
 672                         goto out;
 673                 }
 674                 err = -ENOENT;
 675                 if (namelen == 0)
 676                         mod = &kernel_module;
 677                 else if ((mod = find_module(name)) == NULL) {
 678                         put_mod_name(name);
 679                         goto out;
 680                 }
 681                 put_mod_name(name);
 682         }
 683
 684         switch (which)
 685         {
 686         case 0:
 687                 err = 0;
 688                 break;
 689         case QM_MODULES:
 690                 err = qm_modules(buf, bufsize, ret);
 691                 break;
 692         case QM_DEPS:
 693                 err = qm_deps(mod, buf, bufsize, ret);
 694                 break;
 695         case QM_REFS:
 696                 err = qm_refs(mod, buf, bufsize, ret);
 697                 break;
 698         case QM_SYMBOLS:
 699                 err = qm_symbols(mod, buf, bufsize, ret);
 700                 break;
 701         case QM_INFO:
 702                 err = qm_info(mod, buf, bufsize, ret);
 703                 break;
 704         default:
 705                 err = -EINVAL;
 706                 break;
 707         }
 708 out:
 709         unlock_kernel();
 710         return err;
 711 }
 712
 713 /*
 714  * Copy the kernel symbol table to user space.  If the argument is
 715  * NULL, just return the size of the table.
 716  *
 717  * This call is obsolete.  New programs should use query_module+QM_SYMBOLS
 718  * which does not arbitrarily limit the length of symbols.
 719  */
 720
 721 asmlinkage long
 722 sys_get_kernel_syms(struct kernel_sym *table)
 723 {
 724         struct module *mod;
 725         int i;
 726         struct kernel_sym ksym;
 727
 728         lock_kernel();
 729         for (mod = module_list, i = 0; mod; mod = mod->next) {
 730                 /* include the count for the module name! */
 731                 i += mod->nsyms + 1;
 732         }
 733
 734         if (table == NULL)
 735                 goto out;
 736
 737         /* So that we don't give the user our stack content */
 738         memset (&ksym, 0, sizeof (ksym));
 739
 740         for (mod = module_list, i = 0; mod; mod = mod->next) {
 741                 struct module_symbol *msym;
 742                 unsigned int j;
 743
 744                 if (!MOD_CAN_QUERY(mod))
 745                         continue;
 746
 747                 /* magic: write module info as a pseudo symbol */
 748                 ksym.value = (unsigned long)mod;
 749                 ksym.name[0] = '#';
 750                 strncpy(ksym.name+1, mod->name, sizeof(ksym.name)-1);
 751                 ksym.name[sizeof(ksym.name)-1] = '\0';
 752
 753                 if (copy_to_user(table, &ksym, sizeof(ksym)) != 0)
 754                         goto out;
 755                 ++i, ++table;
 756
 757                 if (mod->nsyms == 0)
 758                         continue;
 759
 760                 for (j = 0, msym = mod->syms; j < mod->nsyms; ++j, ++msym) {
 761                         ksym.value = msym->value;
 762                         strncpy(ksym.name, msym->name, sizeof(ksym.name));
 763                         ksym.name[sizeof(ksym.name)-1] = '\0';
 764
 765                         if (copy_to_user(table, &ksym, sizeof(ksym)) != 0)
 766                                 goto out;
 767                         ++i, ++table;
 768                 }
 769         }
 770 out:
 771         unlock_kernel();
 772         return i;
 773 }
 774
 775 /*
 776  * Look for a module by name, ignoring modules marked for deletion.
 777  */
 778
 779 static struct module *
 780 find_module(const char *name)
 781 {
 782         struct module *mod;
 783
 784         for (mod = module_list; mod ; mod = mod->next) {
 785                 if (mod->flags & MOD_DELETED)
 786                         continue;
 787                 if (!strcmp(mod->name, name))
 788                         break;
 789         }
 790
 791         return mod;
 792 }
 793
 794 /*
 795  * Free the given module.
 796  */
 797
 798 static void
 799 free_module(struct module *mod, int tag_freed)
 800 {
 801         struct module_ref *dep;
 802         unsigned i;
 803
 804         /* Let the module clean up.  */
 805
 806         if (mod->flags & MOD_RUNNING)
 807         {
 808                 if(mod->cleanup)
 809                         mod->cleanup();
 810                 mod->flags &= ~MOD_RUNNING;
 811         }
 812
 813         /* Remove the module from the dependency lists.  */
 814
 815         for (i = 0, dep = mod->deps; i < mod->ndeps; ++i, ++dep) {
 816                 struct module_ref **pp;
 817                 for (pp = &dep->dep->refs; *pp != dep; pp = &(*pp)->next_ref)
 818                         continue;
 819                 *pp = dep->next_ref;
 820                 if (tag_freed && dep->dep->refs == NULL)
 821                         dep->dep->flags |= MOD_JUST_FREED;
 822         }
 823
 824         /* And from the main module list.  */
 825
 826         if (mod == module_list) {
 827                 module_list = mod->next;
 828         } else {
 829                 struct module *p;
 830                 for (p = module_list; p->next != mod; p = p->next)
 831                         continue;
 832                 p->next = mod->next;
 833         }
 834
 835         /* And free the memory.  */
 836
 837         module_unmap(mod);
 838 }
 839
 840 /*
 841  * Called by the /proc file system to return a current list of modules.
 842  */
 843
 844 int get_module_list(char *p)
 845 {
 846         size_t left = PAGE_SIZE;
 847         struct module *mod;
 848         char tmpstr[64];
 849         struct module_ref *ref;
 850
 851         for (mod = module_list; mod != &kernel_module; mod = mod->next) {
 852                 long len;
 853                 const char *q;
 854
 855 #define safe_copy_str(str, len)                                         \
 856                 do {                                                    \
 857                         if (left < len)                                 \
 858                                 goto fini;                              \
 859                         memcpy(p, str, len); p += len, left -= len;     \
 860                 } while (0)
 861 #define safe_copy_cstr(str)     safe_copy_str(str, sizeof(str)-1)
 862
 863                 len = strlen(mod->name);
 864                 safe_copy_str(mod->name, len);
 865
 866                 if ((len = 20 - len) > 0) {
 867                         if (left < len)
 868                                 goto fini;
 869                         memset(p, ' ', len);
 870                         p += len;
 871                         left -= len;
 872                 }
 873
 874                 len = sprintf(tmpstr, "%8lu", mod->size);
 875                 safe_copy_str(tmpstr, len);
 876
 877                 if (mod->flags & MOD_RUNNING) {
 878                         len = sprintf(tmpstr, "%4ld",
 879                                       (mod_member_present(mod, can_unload)
 880                                        && mod->can_unload
 881                                        ? -1L : (long)atomic_read(&mod->uc.usecount)));
 882                         safe_copy_str(tmpstr, len);
 883                 }
 884
 885                 if (mod->flags & MOD_DELETED)
 886                         safe_copy_cstr(" (deleted)");
 887                 else if (mod->flags & MOD_RUNNING) {
 888                         if (mod->flags & MOD_AUTOCLEAN)
 889                                 safe_copy_cstr(" (autoclean)");
 890                         if (!(mod->flags & MOD_USED_ONCE))
 891                                 safe_copy_cstr(" (unused)");
 892                 }
 893                 else if (mod->flags & MOD_INITIALIZING)
 894                         safe_copy_cstr(" (initializing)");
 895                 else
 896                         safe_copy_cstr(" (uninitialized)");
 897
 898                 if ((ref = mod->refs) != NULL) {
 899                         safe_copy_cstr(" [");
 900                         while (1) {
 901                                 q = ref->ref->name;
 902                                 len = strlen(q);
 903                                 safe_copy_str(q, len);
 904
 905                                 if ((ref = ref->next_ref) != NULL)
 906                                         safe_copy_cstr(" ");
 907                                 else
 908                                         break;
 909                         }
 910                         safe_copy_cstr("]");
 911                 }
 912                 safe_copy_cstr("\n");
 913
 914 #undef safe_copy_str
 915 #undef safe_copy_cstr
 916         }
 917
 918 fini:
 919         return PAGE_SIZE - left;
 920 }
 921
 922 /*
 923  * Called by the /proc file system to return a current list of ksyms.
 924  */
 925
 926 int
 927 get_ksyms_list(char *buf, char **start, off_t offset, int length)
 928 {
 929         struct module *mod;
 930         char *p = buf;
 931         int len     = 0;        /* code from  net/ipv4/proc.c */
 932         off_t pos   = 0;
 933         off_t begin = 0;
 934
 935         for (mod = module_list; mod; mod = mod->next) {
 936                 unsigned i;
 937                 struct module_symbol *sym;
 938
 939                 if (!MOD_CAN_QUERY(mod))
 940                         continue;
 941
 942                 for (i = mod->nsyms, sym = mod->syms; i > 0; --i, ++sym) {
 943                         p = buf + len;
 944                         if (*mod->name) {
 945                                 len += sprintf(p, "%0*lx %s\t[%s]\n",
 946                                                (int)(2*sizeof(void*)),
 947                                                sym->value, sym->name,
 948                                                mod->name);
 949                         } else {
 950                                 len += sprintf(p, "%0*lx %s\n",
 951                                                (int)(2*sizeof(void*)),
 952                                                sym->value, sym->name);
 953                         }
 954                         pos = begin + len;
 955                         if (pos < offset) {
 956                                 len = 0;
 957                                 begin = pos;
 958                         }
 959                         pos = begin + len;
 960                         if (pos > offset+length)
 961                                 goto leave_the_loop;
 962                 }
 963         }
 964 leave_the_loop:
 965         *start = buf + (offset - begin);
 966         len -= (offset - begin);
 967         if (len > length)
 968                 len = length;
 969         return len;
 970 }
 971
 972 /*
 973  * Gets the address for a symbol in the given module.  If modname is
 974  * NULL, it looks for the name in any registered symbol table.  If the
 975  * modname is an empty string, it looks for the symbol in kernel exported
 976  * symbol tables. Increase the usage count of the module in which the
 977  * symbol was found - it's the only way we can guarantee that it's still
 978  * there by the time our caller actually uses it.
 979  */
 980 unsigned long
 981 get_module_symbol(char *modname, char *symname)
 982 {
 983         struct module *mp;
 984         struct module_symbol *sym;
 985         int i;
 986
 987         spin_lock(&unload_lock);
 988         for (mp = module_list; mp; mp = mp->next) {
 989                 if (((modname == NULL) || (strcmp(mp->name, modname) == 0)) &&
 990                         MOD_CAN_QUERY(mp) &&
 991                         (mp->nsyms > 0)) {
 992                         for (i = mp->nsyms, sym = mp->syms;
 993                                 i > 0; --i, ++sym) {
 994
 995                                 if (strcmp(sym->name, symname) == 0) {
 996                                         __MOD_INC_USE_COUNT(mp);
 997                                         spin_unlock(&unload_lock);
 998                                         return sym->value;
 999                                 }
1000                         }
1001                 }
1002         }
1003         spin_unlock(&unload_lock);
1004         return 0;
1005 }
1006
1007 /* Decrease the use count of the module containing a symbol with the
1008  * address passed.
1009  */
1010 void put_module_symbol(unsigned long addr)
1011 {
1012         struct module *mp;
1013
1014         for (mp = module_list; mp; mp = mp->next) {
1015                 if (MOD_CAN_QUERY(mp) &&
1016                     addr >= (unsigned long)mp &&
1017                     addr < (unsigned long)mp + mp->size) {
1018                         __MOD_DEC_USE_COUNT(mp);
1019                         return;
1020                 }
1021         }
1022 }
1023
1024 #else           /* CONFIG_MODULES */
1025
1026 /* Dummy syscalls for people who don't want modules */
1027
1028 asmlinkage unsigned long
1029 sys_create_module(const char *name_user, size_t size)
1030 {
1031         return -ENOSYS;
1032 }
1033
1034 asmlinkage long
1035 sys_init_module(const char *name_user, struct module *mod_user)
1036 {
1037         return -ENOSYS;
1038 }
1039
1040 asmlinkage long
1041 sys_delete_module(const char *name_user)
1042 {
1043         return -ENOSYS;
1044 }
1045
1046 asmlinkage long
1047 sys_query_module(const char *name_user, int which, char *buf, size_t bufsize,
1048                  size_t *ret)
1049 {
1050         /* Let the program know about the new interface.  Not that
1051            it'll do them much good.  */
1052         if (which == 0)
1053                 return 0;
1054
1055         return -ENOSYS;
1056 }
1057
1058 asmlinkage long
1059 sys_get_kernel_syms(struct kernel_sym *table)
1060 {
1061         return -ENOSYS;
1062 }
1063
1064 int try_inc_mod_count(struct module *mod)
1065 {
1066         return 1;
1067 }
1068
1069 #endif  /* CONFIG_MODULES */