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 && (error = mod->init()) != 0) {
 330                 atomic_set(&mod->uc.usecount,0);
 331                 mod->flags &= ~MOD_INITIALIZING;
 332                 if (error > 0)  /* Buggy module */
 333                         error = -EBUSY;
 334                 goto err0;
 335         }
 336         atomic_dec(&mod->uc.usecount);
 337
 338         /* And set it running.  */
 339         mod->flags = (mod->flags | MOD_RUNNING) & ~MOD_INITIALIZING;
 340         error = 0;
 341         goto err0;
 342
 343 err3:
 344         put_mod_name(n_name);
 345 err2:
 346         *mod = mod_tmp;
 347 err1:
 348         put_mod_name(name);
 349 err0:
 350         unlock_kernel();
 351         return error;
 352 }
 353
 354 static spinlock_t unload_lock = SPIN_LOCK_UNLOCKED;
 355 int try_inc_mod_count(struct module *mod)
 356 {
 357         int res = 1;
 358         if (mod) {
 359                 spin_lock(&unload_lock);
 360                 if (mod->flags & MOD_DELETED)
 361                         res = 0;
 362                 else
 363                         __MOD_INC_USE_COUNT(mod);
 364                 spin_unlock(&unload_lock);
 365         }
 366         return res;
 367 }
 368
 369 asmlinkage long
 370 sys_delete_module(const char *name_user)
 371 {
 372         struct module *mod, *next;
 373         char *name;
 374         long error;
 375         int something_changed;
 376
 377         if (!capable(CAP_SYS_MODULE))
 378                 return -EPERM;
 379
 380         lock_kernel();
 381         if (name_user) {
 382                 if ((error = get_mod_name(name_user, &name)) < 0)
 383                         goto out;
 384                 if (error == 0) {
 385                         error = -EINVAL;
 386                         put_mod_name(name);
 387                         goto out;
 388                 }
 389                 error = -ENOENT;
 390                 if ((mod = find_module(name)) == NULL) {
 391                         put_mod_name(name);
 392                         goto out;
 393                 }
 394                 put_mod_name(name);
 395                 error = -EBUSY;
 396                 if (mod->refs != NULL)
 397                         goto out;
 398
 399                 spin_lock(&unload_lock);
 400                 if (!__MOD_IN_USE(mod)) {
 401                         mod->flags |= MOD_DELETED;
 402                         spin_unlock(&unload_lock);
 403                         free_module(mod, 0);
 404                         error = 0;
 405                 } else {
 406                         spin_unlock(&unload_lock);
 407                 }
 408                 goto out;
 409         }
 410
 411         /* Do automatic reaping */
 412 restart:
 413         something_changed = 0;
 414         for (mod = module_list; mod != &kernel_module; mod = next) {
 415                 next = mod->next;
 416                 spin_lock(&unload_lock);
 417                 if (mod->refs == NULL
 418                     && (mod->flags & MOD_AUTOCLEAN)
 419                     && (mod->flags & MOD_RUNNING)
 420                     && !(mod->flags & MOD_DELETED)
 421                     && (mod->flags & MOD_USED_ONCE)
 422                     && !__MOD_IN_USE(mod)) {
 423                         if ((mod->flags & MOD_VISITED)
 424                             && !(mod->flags & MOD_JUST_FREED)) {
 425                                 spin_unlock(&unload_lock);
 426                                 mod->flags &= ~MOD_VISITED;
 427                         } else {
 428                                 mod->flags |= MOD_DELETED;
 429                                 spin_unlock(&unload_lock);
 430                                 free_module(mod, 1);
 431                                 something_changed = 1;
 432                         }
 433                 } else {
 434                         spin_unlock(&unload_lock);
 435                 }
 436         }
 437         if (something_changed)
 438                 goto restart;
 439         for (mod = module_list; mod != &kernel_module; mod = mod->next)
 440                 mod->flags &= ~MOD_JUST_FREED;
 441         error = 0;
 442 out:
 443         unlock_kernel();
 444         return error;
 445 }
 446
 447 /* Query various bits about modules.  */
 448
 449 static int
 450 qm_modules(char *buf, size_t bufsize, size_t *ret)
 451 {
 452         struct module *mod;
 453         size_t nmod, space, len;
 454
 455         nmod = space = 0;
 456
 457         for (mod=module_list; mod != &kernel_module; mod=mod->next, ++nmod) {
 458                 len = strlen(mod->name)+1;
 459                 if (len > bufsize)
 460                         goto calc_space_needed;
 461                 if (copy_to_user(buf, mod->name, len))
 462                         return -EFAULT;
 463                 buf += len;
 464                 bufsize -= len;
 465                 space += len;
 466         }
 467
 468         if (put_user(nmod, ret))
 469                 return -EFAULT;
 470         else
 471                 return 0;
 472
 473 calc_space_needed:
 474         space += len;
 475         while ((mod = mod->next) != &kernel_module)
 476                 space += strlen(mod->name)+1;
 477
 478         if (put_user(space, ret))
 479                 return -EFAULT;
 480         else
 481                 return -ENOSPC;
 482 }
 483
 484 static int
 485 qm_deps(struct module *mod, char *buf, size_t bufsize, size_t *ret)
 486 {
 487         size_t i, space, len;
 488
 489         if (mod == &kernel_module)
 490                 return -EINVAL;
 491         if (!MOD_CAN_QUERY(mod))
 492                 if (put_user(0, ret))
 493                         return -EFAULT;
 494                 else
 495                         return 0;
 496
 497         space = 0;
 498         for (i = 0; i < mod->ndeps; ++i) {
 499                 const char *dep_name = mod->deps[i].dep->name;
 500
 501                 len = strlen(dep_name)+1;
 502                 if (len > bufsize)
 503                         goto calc_space_needed;
 504                 if (copy_to_user(buf, dep_name, len))
 505                         return -EFAULT;
 506                 buf += len;
 507                 bufsize -= len;
 508                 space += len;
 509         }
 510
 511         if (put_user(i, ret))
 512                 return -EFAULT;
 513         else
 514                 return 0;
 515
 516 calc_space_needed:
 517         space += len;
 518         while (++i < mod->ndeps)
 519                 space += strlen(mod->deps[i].dep->name)+1;
 520
 521         if (put_user(space, ret))
 522                 return -EFAULT;
 523         else
 524                 return -ENOSPC;
 525 }
 526
 527 static int
 528 qm_refs(struct module *mod, char *buf, size_t bufsize, size_t *ret)
 529 {
 530         size_t nrefs, space, len;
 531         struct module_ref *ref;
 532
 533         if (mod == &kernel_module)
 534                 return -EINVAL;
 535         if (!MOD_CAN_QUERY(mod))
 536                 if (put_user(0, ret))
 537                         return -EFAULT;
 538                 else
 539                         return 0;
 540
 541         space = 0;
 542         for (nrefs = 0, ref = mod->refs; ref ; ++nrefs, ref = ref->next_ref) {
 543                 const char *ref_name = ref->ref->name;
 544
 545                 len = strlen(ref_name)+1;
 546                 if (len > bufsize)
 547                         goto calc_space_needed;
 548                 if (copy_to_user(buf, ref_name, len))
 549                         return -EFAULT;
 550                 buf += len;
 551                 bufsize -= len;
 552                 space += len;
 553         }
 554
 555         if (put_user(nrefs, ret))
 556                 return -EFAULT;
 557         else
 558                 return 0;
 559
 560 calc_space_needed:
 561         space += len;
 562         while ((ref = ref->next_ref) != NULL)
 563                 space += strlen(ref->ref->name)+1;
 564
 565         if (put_user(space, ret))
 566                 return -EFAULT;
 567         else
 568                 return -ENOSPC;
 569 }
 570
 571 static int
 572 qm_symbols(struct module *mod, char *buf, size_t bufsize, size_t *ret)
 573 {
 574         size_t i, space, len;
 575         struct module_symbol *s;
 576         char *strings;
 577         unsigned long *vals;
 578
 579         if (!MOD_CAN_QUERY(mod))
 580                 if (put_user(0, ret))
 581                         return -EFAULT;
 582                 else
 583                         return 0;
 584
 585         space = mod->nsyms * 2*sizeof(void *);
 586
 587         i = len = 0;
 588         s = mod->syms;
 589
 590         if (space > bufsize)
 591                 goto calc_space_needed;
 592
 593         if (!access_ok(VERIFY_WRITE, buf, space))
 594                 return -EFAULT;
 595
 596         bufsize -= space;
 597         vals = (unsigned long *)buf;
 598         strings = buf+space;
 599
 600         for (; i < mod->nsyms ; ++i, ++s, vals += 2) {
 601                 len = strlen(s->name)+1;
 602                 if (len > bufsize)
 603                         goto calc_space_needed;
 604
 605                 if (copy_to_user(strings, s->name, len)
 606                     || __put_user(s->value, vals+0)
 607                     || __put_user(space, vals+1))
 608                         return -EFAULT;
 609
 610                 strings += len;
 611                 bufsize -= len;
 612                 space += len;
 613         }
 614
 615         if (put_user(i, ret))
 616                 return -EFAULT;
 617         else
 618                 return 0;
 619
 620 calc_space_needed:
 621         for (; i < mod->nsyms; ++i, ++s)
 622                 space += strlen(s->name)+1;
 623
 624         if (put_user(space, ret))
 625                 return -EFAULT;
 626         else
 627                 return -ENOSPC;
 628 }
 629
 630 static int
 631 qm_info(struct module *mod, char *buf, size_t bufsize, size_t *ret)
 632 {
 633         int error = 0;
 634
 635         if (mod == &kernel_module)
 636                 return -EINVAL;
 637
 638         if (sizeof(struct module_info) <= bufsize) {
 639                 struct module_info info;
 640                 info.addr = (unsigned long)mod;
 641                 info.size = mod->size;
 642                 info.flags = mod->flags;
 643                 info.usecount = (mod_member_present(mod, can_unload)
 644                                  && mod->can_unload ? -1 : atomic_read(&mod->uc.usecount));
 645
 646                 if (copy_to_user(buf, &info, sizeof(struct module_info)))
 647                         return -EFAULT;
 648         } else
 649                 error = -ENOSPC;
 650
 651         if (put_user(sizeof(struct module_info), ret))
 652                 return -EFAULT;
 653
 654         return error;
 655 }
 656
 657 asmlinkage long
 658 sys_query_module(const char *name_user, int which, char *buf, size_t bufsize,
 659                  size_t *ret)
 660 {
 661         struct module *mod;
 662         int err;
 663
 664         lock_kernel();
 665         if (name_user == NULL)
 666                 mod = &kernel_module;
 667         else {
 668                 long namelen;
 669                 char *name;
 670
 671                 if ((namelen = get_mod_name(name_user, &name)) < 0) {
 672                         err = namelen;
 673                         goto out;
 674                 }
 675                 err = -ENOENT;
 676                 if (namelen == 0)
 677                         mod = &kernel_module;
 678                 else if ((mod = find_module(name)) == NULL) {
 679                         put_mod_name(name);
 680                         goto out;
 681                 }
 682                 put_mod_name(name);
 683         }
 684
 685         switch (which)
 686         {
 687         case 0:
 688                 err = 0;
 689                 break;
 690         case QM_MODULES:
 691                 err = qm_modules(buf, bufsize, ret);
 692                 break;
 693         case QM_DEPS:
 694                 err = qm_deps(mod, buf, bufsize, ret);
 695                 break;
 696         case QM_REFS:
 697                 err = qm_refs(mod, buf, bufsize, ret);
 698                 break;
 699         case QM_SYMBOLS:
 700                 err = qm_symbols(mod, buf, bufsize, ret);
 701                 break;
 702         case QM_INFO:
 703                 err = qm_info(mod, buf, bufsize, ret);
 704                 break;
 705         default:
 706                 err = -EINVAL;
 707                 break;
 708         }
 709 out:
 710         unlock_kernel();
 711         return err;
 712 }
 713
 714 /*
 715  * Copy the kernel symbol table to user space.  If the argument is
 716  * NULL, just return the size of the table.
 717  *
 718  * This call is obsolete.  New programs should use query_module+QM_SYMBOLS
 719  * which does not arbitrarily limit the length of symbols.
 720  */
 721
 722 asmlinkage long
 723 sys_get_kernel_syms(struct kernel_sym *table)
 724 {
 725         struct module *mod;
 726         int i;
 727         struct kernel_sym ksym;
 728
 729         lock_kernel();
 730         for (mod = module_list, i = 0; mod; mod = mod->next) {
 731                 /* include the count for the module name! */
 732                 i += mod->nsyms + 1;
 733         }
 734
 735         if (table == NULL)
 736                 goto out;
 737
 738         /* So that we don't give the user our stack content */
 739         memset (&ksym, 0, sizeof (ksym));
 740
 741         for (mod = module_list, i = 0; mod; mod = mod->next) {
 742                 struct module_symbol *msym;
 743                 unsigned int j;
 744
 745                 if (!MOD_CAN_QUERY(mod))
 746                         continue;
 747
 748                 /* magic: write module info as a pseudo symbol */
 749                 ksym.value = (unsigned long)mod;
 750                 ksym.name[0] = '#';
 751                 strncpy(ksym.name+1, mod->name, sizeof(ksym.name)-1);
 752                 ksym.name[sizeof(ksym.name)-1] = '\0';
 753
 754                 if (copy_to_user(table, &ksym, sizeof(ksym)) != 0)
 755                         goto out;
 756                 ++i, ++table;
 757
 758                 if (mod->nsyms == 0)
 759                         continue;
 760
 761                 for (j = 0, msym = mod->syms; j < mod->nsyms; ++j, ++msym) {
 762                         ksym.value = msym->value;
 763                         strncpy(ksym.name, msym->name, sizeof(ksym.name));
 764                         ksym.name[sizeof(ksym.name)-1] = '\0';
 765
 766                         if (copy_to_user(table, &ksym, sizeof(ksym)) != 0)
 767                                 goto out;
 768                         ++i, ++table;
 769                 }
 770         }
 771 out:
 772         unlock_kernel();
 773         return i;
 774 }
 775
 776 /*
 777  * Look for a module by name, ignoring modules marked for deletion.
 778  */
 779
 780 static struct module *
 781 find_module(const char *name)
 782 {
 783         struct module *mod;
 784
 785         for (mod = module_list; mod ; mod = mod->next) {
 786                 if (mod->flags & MOD_DELETED)
 787                         continue;
 788                 if (!strcmp(mod->name, name))
 789                         break;
 790         }
 791
 792         return mod;
 793 }
 794
 795 /*
 796  * Free the given module.
 797  */
 798
 799 static void
 800 free_module(struct module *mod, int tag_freed)
 801 {
 802         struct module_ref *dep;
 803         unsigned i;
 804
 805         /* Let the module clean up.  */
 806
 807         if (mod->flags & MOD_RUNNING)
 808         {
 809                 if(mod->cleanup)
 810                         mod->cleanup();
 811                 mod->flags &= ~MOD_RUNNING;
 812         }
 813
 814         /* Remove the module from the dependency lists.  */
 815
 816         for (i = 0, dep = mod->deps; i < mod->ndeps; ++i, ++dep) {
 817                 struct module_ref **pp;
 818                 for (pp = &dep->dep->refs; *pp != dep; pp = &(*pp)->next_ref)
 819                         continue;
 820                 *pp = dep->next_ref;
 821                 if (tag_freed && dep->dep->refs == NULL)
 822                         dep->dep->flags |= MOD_JUST_FREED;
 823         }
 824
 825         /* And from the main module list.  */
 826
 827         if (mod == module_list) {
 828                 module_list = mod->next;
 829         } else {
 830                 struct module *p;
 831                 for (p = module_list; p->next != mod; p = p->next)
 832                         continue;
 833                 p->next = mod->next;
 834         }
 835
 836         /* And free the memory.  */
 837
 838         module_unmap(mod);
 839 }
 840
 841 /*
 842  * Called by the /proc file system to return a current list of modules.
 843  */
 844
 845 int get_module_list(char *p)
 846 {
 847         size_t left = PAGE_SIZE;
 848         struct module *mod;
 849         char tmpstr[64];
 850         struct module_ref *ref;
 851
 852         for (mod = module_list; mod != &kernel_module; mod = mod->next) {
 853                 long len;
 854                 const char *q;
 855
 856 #define safe_copy_str(str, len)                                         \
 857                 do {                                                    \
 858                         if (left < len)                                 \
 859                                 goto fini;                              \
 860                         memcpy(p, str, len); p += len, left -= len;     \
 861                 } while (0)
 862 #define safe_copy_cstr(str)     safe_copy_str(str, sizeof(str)-1)
 863
 864                 len = strlen(mod->name);
 865                 safe_copy_str(mod->name, len);
 866
 867                 if ((len = 20 - len) > 0) {
 868                         if (left < len)
 869                                 goto fini;
 870                         memset(p, ' ', len);
 871                         p += len;
 872                         left -= len;
 873                 }
 874
 875                 len = sprintf(tmpstr, "%8lu", mod->size);
 876                 safe_copy_str(tmpstr, len);
 877
 878                 if (mod->flags & MOD_RUNNING) {
 879                         len = sprintf(tmpstr, "%4ld",
 880                                       (mod_member_present(mod, can_unload)
 881                                        && mod->can_unload
 882                                        ? -1L : (long)atomic_read(&mod->uc.usecount)));
 883                         safe_copy_str(tmpstr, len);
 884                 }
 885
 886                 if (mod->flags & MOD_DELETED)
 887                         safe_copy_cstr(" (deleted)");
 888                 else if (mod->flags & MOD_RUNNING) {
 889                         if (mod->flags & MOD_AUTOCLEAN)
 890                                 safe_copy_cstr(" (autoclean)");
 891                         if (!(mod->flags & MOD_USED_ONCE))
 892                                 safe_copy_cstr(" (unused)");
 893                 }
 894                 else if (mod->flags & MOD_INITIALIZING)
 895                         safe_copy_cstr(" (initializing)");
 896                 else
 897                         safe_copy_cstr(" (uninitialized)");
 898
 899                 if ((ref = mod->refs) != NULL) {
 900                         safe_copy_cstr(" [");
 901                         while (1) {
 902                                 q = ref->ref->name;
 903                                 len = strlen(q);
 904                                 safe_copy_str(q, len);
 905
 906                                 if ((ref = ref->next_ref) != NULL)
 907                                         safe_copy_cstr(" ");
 908                                 else
 909                                         break;
 910                         }
 911                         safe_copy_cstr("]");
 912                 }
 913                 safe_copy_cstr("\n");
 914
 915 #undef safe_copy_str
 916 #undef safe_copy_cstr
 917         }
 918
 919 fini:
 920         return PAGE_SIZE - left;
 921 }
 922
 923 /*
 924  * Called by the /proc file system to return a current list of ksyms.
 925  */
 926
 927 int
 928 get_ksyms_list(char *buf, char **start, off_t offset, int length)
 929 {
 930         struct module *mod;
 931         char *p = buf;
 932         int len     = 0;        /* code from  net/ipv4/proc.c */
 933         off_t pos   = 0;
 934         off_t begin = 0;
 935
 936         for (mod = module_list; mod; mod = mod->next) {
 937                 unsigned i;
 938                 struct module_symbol *sym;
 939
 940                 if (!MOD_CAN_QUERY(mod))
 941                         continue;
 942
 943                 for (i = mod->nsyms, sym = mod->syms; i > 0; --i, ++sym) {
 944                         p = buf + len;
 945                         if (*mod->name) {
 946                                 len += sprintf(p, "%0*lx %s\t[%s]\n",
 947                                                (int)(2*sizeof(void*)),
 948                                                sym->value, sym->name,
 949                                                mod->name);
 950                         } else {
 951                                 len += sprintf(p, "%0*lx %s\n",
 952                                                (int)(2*sizeof(void*)),
 953                                                sym->value, sym->name);
 954                         }
 955                         pos = begin + len;
 956                         if (pos < offset) {
 957                                 len = 0;
 958                                 begin = pos;
 959                         }
 960                         pos = begin + len;
 961                         if (pos > offset+length)
 962                                 goto leave_the_loop;
 963                 }
 964         }
 965 leave_the_loop:
 966         *start = buf + (offset - begin);
 967         len -= (offset - begin);
 968         if (len > length)
 969                 len = length;
 970         return len;
 971 }
 972
 973 /*
 974  * Gets the address for a symbol in the given module.  If modname is
 975  * NULL, it looks for the name in any registered symbol table.  If the
 976  * modname is an empty string, it looks for the symbol in kernel exported
 977  * symbol tables. Increase the usage count of the module in which the
 978  * symbol was found - it's the only way we can guarantee that it's still
 979  * there by the time our caller actually uses it.
 980  */
 981 unsigned long
 982 get_module_symbol(char *modname, char *symname)
 983 {
 984         struct module *mp;
 985         struct module_symbol *sym;
 986         int i;
 987
 988         spin_lock(&unload_lock);
 989         for (mp = module_list; mp; mp = mp->next) {
 990                 if (((modname == NULL) || (strcmp(mp->name, modname) == 0)) &&
 991                         MOD_CAN_QUERY(mp) &&
 992                         (mp->nsyms > 0)) {
 993                         for (i = mp->nsyms, sym = mp->syms;
 994                                 i > 0; --i, ++sym) {
 995
 996                                 if (strcmp(sym->name, symname) == 0) {
 997                                         __MOD_INC_USE_COUNT(mp);
 998                                         spin_unlock(&unload_lock);
 999                                         return sym->value;
1000                                 }
1001                         }
1002                 }
1003         }
1004         spin_unlock(&unload_lock);
1005         return 0;
1006 }
1007
1008 /* Decrease the use count of the module containing a symbol with the
1009  * address passed.
1010  */
1011 void put_module_symbol(unsigned long addr)
1012 {
1013         struct module *mp;
1014
1015         for (mp = module_list; mp; mp = mp->next) {
1016                 if (MOD_CAN_QUERY(mp) &&
1017                     addr >= (unsigned long)mp &&
1018                     addr < (unsigned long)mp + mp->size) {
1019                         __MOD_DEC_USE_COUNT(mp);
1020                         return;
1021                 }
1022         }
1023 }
1024
1025 #else           /* CONFIG_MODULES */
1026
1027 /* Dummy syscalls for people who don't want modules */
1028
1029 asmlinkage unsigned long
1030 sys_create_module(const char *name_user, size_t size)
1031 {
1032         return -ENOSYS;
1033 }
1034
1035 asmlinkage long
1036 sys_init_module(const char *name_user, struct module *mod_user)
1037 {
1038         return -ENOSYS;
1039 }
1040
1041 asmlinkage long
1042 sys_delete_module(const char *name_user)
1043 {
1044         return -ENOSYS;
1045 }
1046
1047 asmlinkage long
1048 sys_query_module(const char *name_user, int which, char *buf, size_t bufsize,
1049                  size_t *ret)
1050 {
1051         /* Let the program know about the new interface.  Not that
1052            it'll do them much good.  */
1053         if (which == 0)
1054                 return 0;
1055
1056         return -ENOSYS;
1057 }
1058
1059 asmlinkage long
1060 sys_get_kernel_syms(struct kernel_sym *table)
1061 {
1062         return -ENOSYS;
1063 }
1064
1065 int try_inc_mod_count(struct module *mod)
1066 {
1067         return 1;
1068 }
1069
1070 #endif  /* CONFIG_MODULES */