Generate modules.dep with absolute paths as before
[opensuse:module-init-tools.git] / depmod.c
1 /* New simplified depmod without backwards compat stuff and not
2    requiring ksyms.
3
4    (C) 2002 Rusty Russell IBM Corporation
5  */
6 #define _GNU_SOURCE /* asprintf */
7
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <getopt.h>
11 #include <string.h>
12 #include <errno.h>
13 #include <unistd.h>
14 #include <elf.h>
15 #include <sys/types.h>
16 #include <sys/stat.h>
17 #include <fcntl.h>
18 #include <dirent.h>
19 #include <sys/utsname.h>
20 #include <sys/mman.h>
21
22 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
23
24 #include "util.h"
25 #include "zlibsupport.h"
26 #include "depmod.h"
27 #include "logging.h"
28 #include "index.h"
29 #include "elfops.h"
30 #include "tables.h"
31 #include "config_filter.h"
32
33 #include "testing.h"
34
35 #ifndef MODULE_DIR
36 #define MODULE_DIR "/lib/modules/"
37 #endif
38
39 #ifndef MODULE_BUILTIN_KEY
40 #define MODULE_BUILTIN_KEY "built-in"
41 #endif
42
43 struct module_overrides
44 {
45         /* Next override */
46         struct module_overrides *next;
47
48         /* overridden module */
49         char *modfile;
50 };
51
52 struct module_search
53 {
54         /* Next search */
55         struct module_search *next;
56
57         /* search path */
58         char *search_path;
59         size_t len;
60 };
61
62 static unsigned int skipchars;
63 static unsigned int make_map_files = 1; /* default to on */
64 static unsigned int force_map_files = 0; /* default to on */
65
66 #define SYMBOL_HASH_SIZE 1024
67 struct symbol
68 {
69         struct symbol *next;
70         struct module *owner;
71         uint64_t ver;
72         char name[0];
73 };
74
75 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
76
77 /* This is based on the hash agorithm from gdbm, via tdb */
78 static inline unsigned int tdb_hash(const char *name)
79 {
80         unsigned value; /* Used to compute the hash value.  */
81         unsigned   i;   /* Used to cycle through random values. */
82
83         /* Set the initial value from the key size. */
84         for (value = 0x238F13AF * strlen(name), i=0; name[i]; i++)
85                 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
86
87         return (1103515243 * value + 12345);
88 }
89
90 void add_symbol(const char *name, uint64_t ver, struct module *owner)
91 {
92         unsigned int hash;
93         struct symbol *new = NOFAIL(malloc(sizeof *new + strlen(name) + 1));
94
95         new->owner = owner;
96         new->ver = ver;
97         strcpy(new->name, name);
98
99         hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
100         new->next = symbolhash[hash];
101         symbolhash[hash] = new;
102 }
103
104 static int print_unknown, check_symvers;
105
106 struct module *find_symbol(const char *name, uint64_t ver,
107                 const char *modname, int weak)
108 {
109         struct symbol *s;
110
111         /* For our purposes, .foo matches foo.  PPC64 needs this. */
112         if (name[0] == '.')
113                 name++;
114
115         for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s=s->next) {
116                 if (streq(s->name, name))
117                         break;
118         }
119         if (s) {
120                 if (ver && s->ver && s->ver != ver && print_unknown && !weak)
121                         warn("%s disagrees about version of symbol %s\n",
122                                         modname, name);
123                 return s->owner;
124         }
125
126         if (print_unknown && !weak)
127                 warn("%s needs unknown symbol %s\n", modname, name);
128
129         return NULL;
130 }
131
132 void add_dep(struct module *mod, struct module *depends_on)
133 {
134         unsigned int i;
135
136         for (i = 0; i < mod->num_deps; i++)
137                 if (mod->deps[i] == depends_on)
138                         return;
139
140         mod->deps = NOFAIL(realloc(mod->deps, sizeof(mod->deps[0])*(mod->num_deps+1)));
141         mod->deps[mod->num_deps++] = depends_on;
142 }
143
144 static void add_fake_syms(void)
145 {
146         /* __this_module is magic inserted by kernel loader. */
147         add_symbol("__this_module", 0, NULL);
148         /* On S390, this is faked up too */
149         add_symbol("_GLOBAL_OFFSET_TABLE_", 0, NULL);
150 }
151
152 static void load_system_map(const char *filename)
153 {
154         FILE *system_map;
155         char line[10240];
156         const char ksymstr[] = "__ksymtab_";
157         const int ksymstr_len = strlen(ksymstr);
158
159         system_map = fopen(filename, "r");
160         if (!system_map)
161                 fatal("Could not open '%s': %s\n", filename, strerror(errno));
162
163         /* eg. c0294200 R __ksymtab_devfs_alloc_devnum */
164         while (fgets(line, sizeof(line)-1, system_map)) {
165                 char *ptr;
166
167                 /* Snip \n */
168                 ptr = strchr(line, '\n');
169                 if (ptr)
170                         *ptr = '\0';
171
172                 ptr = strchr(line, ' ');
173                 if (!ptr || !(ptr = strchr(ptr + 1, ' ')))
174                         continue;
175
176                 /* Covers gpl-only and normal symbols. */
177                 if (strstarts(ptr+1, ksymstr))
178                         add_symbol(ptr+1+ksymstr_len, 0, NULL);
179         }
180
181         fclose(system_map);
182         add_fake_syms();
183 }
184
185 static void load_module_symvers(const char *filename)
186 {
187         FILE *module_symvers;
188         char line[10240];
189
190         module_symvers = fopen(filename, "r");
191         if (!module_symvers)
192                 fatal("Could not open '%s': %s\n", filename, strerror(errno));
193
194         /* eg. "0xb352177e\tfind_first_bit\tvmlinux\tEXPORT_SYMBOL" */
195         while (fgets(line, sizeof(line)-1, module_symvers)) {
196                 const char *ver, *sym, *where, *slash;
197
198                 ver = strtok(line, " \t");
199                 sym = strtok(NULL, " \t");
200                 where = strtok(NULL, " \t");
201                 if (!ver || !sym || !where)
202                         continue;
203
204                 if (streq(where, "vmlinux") ||
205                     (((slash = strrchr(where, '/'))) &&
206                     streq(slash, "/built-in")))
207                         add_symbol(sym, strtoull(ver, NULL, 16), NULL);
208         }
209
210         fclose(module_symvers);
211         add_fake_syms();
212 }
213
214 static struct option options[] = { { "all", 0, NULL, 'a' },
215                                    { "quick", 0, NULL, 'A' },
216                                    { "basedir", 1, NULL, 'b' },
217                                    { "config", 1, NULL, 'C' },
218                                    { "symvers", 1, NULL, 'E' },
219                                    { "filesyms", 1, NULL, 'F' },
220                                    { "errsyms", 0, NULL, 'e' },
221                                    { "unresolved-error", 0, NULL, 'u' },
222                                    { "quiet", 0, NULL, 'q' },
223                                    { "root", 0, NULL, 'r' },
224                                    { "verbose", 0, NULL, 'v' },
225                                    { "show", 0, NULL, 'n' },
226                                    { "dry-run", 0, NULL, 'n' },
227                                    { "help", 0, NULL, 'h' },
228                                    { "version", 0, NULL, 'V' },
229                                    { "warn", 0, NULL, 'w' },
230                                    { "map", 0, NULL, 'm' },
231                                    { NULL, 0, NULL, 0 } };
232
233 /* Version number or module name?  Don't assume extension. */
234 static int is_version_number(const char *version)
235 {
236         unsigned int dummy;
237
238         return (sscanf(version, "%u.%u.%u", &dummy, &dummy, &dummy) == 3);
239 }
240
241 static int old_module_version(const char *version)
242 {
243         /* Expect three part version. */
244         unsigned int major, sub, minor;
245
246         sscanf(version, "%u.%u.%u", &major, &sub, &minor);
247
248         if (major > 2) return 0;
249         if (major < 2) return 1;
250
251         /* 2.x */
252         if (sub > 5) return 0;
253         if (sub < 5) return 1;
254
255         /* 2.5.x */
256         if (minor >= 48) return 0;
257         return 1;
258 }
259
260 static void print_usage(const char *name)
261 {
262         fprintf(stderr,
263         "%s " VERSION " -- part of " PACKAGE "\n"
264         "%s -[aA] [-n -e -v -q -V -r -u -w -m]\n"
265         "      [-b basedirectory] [forced_version]\n"
266         "depmod [-n -e -v -q -r -u -w] [-F kernelsyms] module1.ko module2.ko ...\n"
267         "If no arguments (except options) are given, \"depmod -a\" is assumed\n"
268         "\n"
269         "depmod will output a dependancy list suitable for the modprobe utility.\n"
270         "\n"
271         "\n"
272         "Options:\n"
273         "\t-a, --all            Probe all modules\n"
274         "\t-A, --quick          Only does the work if there's a new module\n"
275         "\t-e, --errsyms        Report not supplied symbols\n"
276         "\t-m, --map            Create the legacy map files\n"
277         "\t-n, --show           Write the dependency file on stdout only\n"
278         "\t-V, --version        Print the release version\n"
279         "\t-v, --verbose        Enable verbose mode\n"
280         "\t-w, --warn           Warn on duplicates\n"
281         "\t-h, --help           Print this usage message\n"
282         "\n"
283         "The following options are useful for people managing distributions:\n"
284         "\t-b basedirectory\n"
285         "\t    --basedir basedirectory    Use an image of a module tree.\n"
286         "\t-F kernelsyms\n"
287         "\t    --filesyms kernelsyms      Use the file instead of the\n"
288         "\t                               current kernel symbols.\n"
289         "\t-E Module.symvers\n"
290         "\t    --symvers Module.symvers   Use Module.symvers file to check\n"
291         "\t                               symbol versions.\n",
292         "depmod", "depmod");
293 }
294
295 static int ends_in(const char *name, const char *ext)
296 {
297         unsigned int namelen, extlen;
298
299         /* Grab lengths */
300         namelen = strlen(name);
301         extlen = strlen(ext);
302
303         if (namelen < extlen) return 0;
304
305         if (streq(name + namelen - extlen, ext))
306                 return 1;
307         return 0;
308 }
309
310 static struct module *grab_module(const char *dirname, const char *filename)
311 {
312         struct module *new;
313
314         new = NOFAIL(malloc(sizeof(*new)
315                             + strlen(dirname?:"") + 1 + strlen(filename) + 1));
316         if (dirname)
317                 sprintf(new->pathname, "%s/%s", dirname, filename);
318         else
319                 strcpy(new->pathname, filename);
320         new->basename = my_basename(new->pathname);
321
322         INIT_LIST_HEAD(&new->dep_list);
323         new->order = INDEX_PRIORITY_MIN;
324
325         new->file = grab_elf_file(new->pathname);
326         if (!new->file) {
327                 warn("Can't read module %s: %s\n",
328                      new->pathname, strerror(errno));
329                 free(new);
330                 return NULL;
331         }
332         return new;
333 }
334
335 struct module_traverse
336 {
337         struct module_traverse *prev;
338         struct module *mod;
339 };
340
341 static int in_loop(struct module *mod, const struct module_traverse *traverse)
342 {
343         const struct module_traverse *i;
344
345         for (i = traverse; i; i = i->prev) {
346                 if (i->mod == mod)
347                         return 1;
348         }
349         return 0;
350 }
351
352 /* Assume we are doing all the modules, so only report each loop once. */
353 static void report_loop(const struct module *mod,
354                         const struct module_traverse *traverse)
355 {
356         const struct module_traverse *i;
357
358         /* Check that start is least alphabetically.  eg.  a depends
359            on b depends on a will get reported for a, not b.  */
360         for (i = traverse->prev; i->prev; i = i->prev) {
361                 if (strcmp(mod->pathname, i->mod->pathname) > 0)
362                         return;
363         }
364
365         /* Is start in the loop?  If not, don't report now. eg. a
366            depends on b which depends on c which depends on b.  Don't
367            report when generating depends for a. */
368         if (mod != i->mod)
369                 return;
370
371         warn("Loop detected: %s ", mod->pathname);
372         for (i = traverse->prev; i->prev; i = i->prev)
373                 fprintf(stderr, "needs %s ", i->mod->basename);
374         fprintf(stderr, "which needs %s again!\n", i->mod->basename);
375 }
376
377 /* This is damn slow, but loops actually happen, and we don't want to
378    just exit() and leave the user without any modules. */
379 static int has_dep_loop(struct module *module, struct module_traverse *prev)
380 {
381         unsigned int i;
382         struct module_traverse traverse = { .prev = prev, .mod = module };
383
384         if (in_loop(module, prev)) {
385                 report_loop(module, &traverse);
386                 return 1;
387         }
388
389         for (i = 0; i < module->num_deps; i++)
390                 if (has_dep_loop(module->deps[i], &traverse))
391                         return 1;
392         return 0;
393 }
394
395 /* Uniquifies and orders a dependency list. */
396 static void order_dep_list(struct module *start, struct module *mod)
397 {
398         unsigned int i;
399
400         for (i = 0; i < mod->num_deps; i++) {
401                 /* If it was previously depended on, move it to the
402                    tail.  ie. if a needs b and c, and c needs b, we
403                    must order b after c. */
404                 list_del(&mod->deps[i]->dep_list);
405                 list_add_tail(&mod->deps[i]->dep_list, &start->dep_list);
406                 order_dep_list(start, mod->deps[i]);
407         }
408 }
409
410 static struct module *deleted = NULL;
411
412 static void del_module(struct module **modules, struct module *delme)
413 {
414         struct module **i;
415
416         /* Find pointer to it. */ 
417         if (modules) {
418                 for (i = modules; *i != delme; i = &(*i)->next);
419                 
420                 *i = delme->next;
421         }
422         
423         /* Save on a list to quiet valgrind.
424            Can't free - other modules may depend on them */
425         delme->next = deleted;
426         deleted = delme;
427 }
428
429 /* convert to relative path if possible */
430 static const char *compress_path(const char *path, const char *basedir)
431 {
432         int len = strlen(basedir);
433
434         if (strncmp(path, basedir, len) == 0)
435                 path += len + 1;
436         return path;
437 }
438
439 static int output_deps(struct module *modules,
440                         FILE *out, char *dirname)
441 {
442         struct module *i;
443
444         for (i = modules; i; i = i->next) {
445                 struct list_head *j, *tmp;
446                 order_dep_list(i, i);
447
448                 fprintf(out, "%s:", i->pathname);
449                 list_for_each_safe(j, tmp, &i->dep_list) {
450                         struct module *dep
451                                 = list_entry(j, struct module, dep_list);
452                         fprintf(out, " %s", dep->pathname);
453                         list_del_init(j);
454                 }
455                 fprintf(out, "\n");
456         }
457         return 1;
458 }
459
460 /* warn whenever duplicate module aliases, deps, or symbols are found. */
461 int warn_dups = 0;
462
463 static int output_deps_bin(struct module *modules,
464                         FILE *out, char *dirname)
465 {
466         struct module *i;
467         struct index_node *index;
468         char *line;
469         char *p;
470
471         index = index_create();
472
473         for (i = modules; i; i = i->next) {
474                 struct list_head *j, *tmp;
475                 char modname[strlen(i->pathname)+1];
476                 
477                 order_dep_list(i, i);
478                 
479                 filename2modname(modname, i->pathname);
480                 nofail_asprintf(&line, "%s:",
481                                 compress_path(i->pathname, dirname));
482                 p = line;
483                 list_for_each_safe(j, tmp, &i->dep_list) {
484                         struct module *dep
485                                 = list_entry(j, struct module, dep_list);
486                         nofail_asprintf(&line, "%s %s",
487                                         p,
488                                         compress_path(dep->pathname, dirname));
489                         free(p);
490                         p = line;
491                         list_del_init(j);
492                 }
493                 if (index_insert(index, modname, line, i->order) && warn_dups)
494                         warn("duplicate module deps:\n%s\n",line);
495                 free(line);
496         }
497         
498         index_write(index, out);
499         index_destroy(index);
500
501         return 1;
502 }
503
504
505 static int smells_like_module(const char *name)
506 {
507         return ends_in(name,".ko") || ends_in(name, ".ko.gz");
508 }
509
510 typedef struct module *(*do_module_t)(const char *dirname,
511                                       const char *filename,
512                                       struct module *next,
513                                       struct module_search *search,
514                                       struct module_overrides *overrides);
515
516 static int is_higher_priority(const char *newpath, const char *oldpath,
517                               struct module_search *search,
518                               struct module_overrides *overrides)
519 {
520         struct module_search *tmp;
521         struct module_overrides *ovtmp;
522         int i = 0;
523         int prio_builtin = -1;
524         int prio_new = -1;
525         int prio_old = -1;
526
527 /* The names already match, now we check for overrides and directory search
528  * order
529  */
530         for (ovtmp = overrides; ovtmp != NULL; ovtmp = ovtmp->next) {
531                 if (streq(ovtmp->modfile, newpath))
532                         return 1;
533                 if (streq(ovtmp->modfile, oldpath))
534                         return 0;
535         }
536         for (i = 0, tmp = search; tmp != NULL; tmp = tmp->next, i++) {
537                 if (streq(tmp->search_path, MODULE_BUILTIN_KEY))
538                         prio_builtin = i;
539                 else if (strncmp(tmp->search_path, newpath, tmp->len) == 0)
540                         prio_new = i;
541                 else if (strncmp(tmp->search_path, oldpath, tmp->len) == 0)
542                         prio_old = i;
543         }
544         if (prio_new < 0)
545                 prio_new = prio_builtin;
546         if (prio_old < 0)
547                 prio_old = prio_builtin;
548
549         return prio_new > prio_old;
550 }
551
552
553 static struct module *do_module(const char *dirname,
554                                        const char *filename,
555                                        struct module *list,
556                                        struct module_search *search,
557                                        struct module_overrides *overrides)
558 {
559         struct module *new, **i;
560
561         new = grab_module(dirname, filename);
562         if (!new)
563                 return list;
564
565         /* Check if module is already in the list. */
566         for (i = &list; *i; i = &(*i)->next) {
567
568                 if (streq((*i)->basename, filename)) {
569                         char newpath[strlen(dirname) + strlen("/")
570                                       + strlen(filename) + 1];
571
572                         sprintf(newpath, "%s/%s", dirname, filename);
573
574                         if (is_higher_priority(newpath, (*i)->pathname,search,
575                                                overrides)) {
576                                 del_module(i, *i);
577                                 
578                                 new->next = *i;
579                                 *i = new;
580                         } else
581                                 del_module(NULL, new);
582
583                         return list;
584                 }
585         }
586
587         /* Not in the list already. Just prepend. */
588         new->next = list;
589         return new;
590 }
591
592 static struct module *grab_dir(const char *dirname,
593                                DIR *dir,
594                                struct module *next,
595                                do_module_t do_mod,
596                                struct module_search *search,
597                                struct module_overrides *overrides)
598 {
599         struct dirent *dirent;
600
601         while ((dirent = readdir(dir)) != NULL) {
602                 if (smells_like_module(dirent->d_name))
603                         next = do_mod(dirname, dirent->d_name, next,
604                                       search, overrides);
605                 else if (!streq(dirent->d_name, ".")
606                          && !streq(dirent->d_name, "..")
607                          && !streq(dirent->d_name, "source")
608                          && !streq(dirent->d_name, "build")) {
609
610                         DIR *sub;
611                         char subdir[strlen(dirname) + 1
612                                    + strlen(dirent->d_name) + 1];
613                         sprintf(subdir, "%s/%s", dirname, dirent->d_name);
614                         sub = opendir(subdir);
615                         if (sub) {
616                                 next = grab_dir(subdir, sub, next, do_mod,
617                                                 search, overrides);
618                                 closedir(sub);
619                         }
620                 }
621         }
622         return next;
623 }
624
625 static struct module *grab_basedir(const char *dirname,
626                                    struct module_search *search,
627                                    struct module_overrides *overrides)
628 {
629         DIR *dir;
630         struct module *list;
631
632         dir = opendir(dirname);
633         if (!dir) {
634                 warn("Couldn't open directory %s: %s\n",
635                      dirname, strerror(errno));
636                 return NULL;
637         }
638         list = grab_dir(dirname, dir, NULL, do_module, search, overrides);
639         closedir(dir);
640
641         return list;
642 }
643
644 static struct module *sort_modules(const char *dirname, struct module *list)
645 {
646         struct module *tlist = NULL, **tpos = &tlist;
647         FILE *modorder;
648         int dir_len = strlen(dirname) + 1;
649         char file_name[dir_len + strlen("modules.order") + 1];
650         char line[10240];
651         unsigned int linenum = 0;
652
653         sprintf(file_name, "%s/%s", dirname, "modules.order");
654
655         modorder = fopen(file_name, "r");
656         if (!modorder) {
657                 /* Older kernels don't generate modules.order.  Just
658                    return if the file doesn't exist. */
659                 if (errno == ENOENT)
660                         return list;
661                 fatal("Could not open '%s': %s\n", file_name, strerror(errno));
662         }
663
664         sprintf(line, "%s/", dirname);
665
666         /* move modules listed in modorder file to tlist in order */
667         while (fgets(line, sizeof(line), modorder)) {
668                 struct module **pos, *mod;
669                 int len = strlen(line);
670
671                 linenum++;
672                 if (line[len - 1] == '\n')
673                         line[len - 1] = '\0';
674
675                 for (pos = &list; (mod = *pos); pos = &(*pos)->next) {
676                         if (streq(line, mod->pathname + dir_len)) {
677                                 mod->order = linenum;
678                                 *pos = mod->next;
679                                 mod->next = NULL;
680                                 *tpos = mod;
681                                 tpos = &mod->next;
682                                 break;
683                         }
684                 }
685         }
686
687         /* append the rest */
688         *tpos = list;
689
690         fclose(modorder);
691
692         return tlist;
693 }
694
695 /* Calculate the dependencies for this module */
696 static void calculate_deps(struct module *module)
697 {
698         unsigned int i;
699         struct string_table *symnames;
700         struct string_table *symtypes;
701         uint64_t *symvers = NULL;
702         struct elf_file *file;
703
704         module->num_deps = 0;
705         module->deps = NULL;
706         file = module->file;
707
708         symnames = file->ops->load_dep_syms(file, &symtypes,
709                         check_symvers ? &symvers : NULL);
710         if (!symnames || !symtypes)
711                 return;
712
713         for (i = 0; i < symnames->cnt; i++) {
714                 const char *name;
715                 uint64_t ver;
716                 struct module *owner;
717                 int weak;
718
719                 name = symnames->str[i];
720                 ver = symvers ? symvers[i] : 0;
721                 weak = (*(symtypes->str[i]) == 'W');
722                 owner = find_symbol(name, ver, module->pathname, weak);
723                 if (owner) {
724                         info("%s needs \"%s\": %s\n",
725                                module->pathname, name,
726                                owner->pathname);
727                         add_dep(module, owner);
728                 }
729         }
730
731         free(symnames);
732         free(symtypes);
733         free(symvers);
734 }
735
736 static struct module *parse_modules(struct module *list)
737 {
738         struct module *i;
739         struct elf_file *file;
740         struct string_table *syms;
741         int j;
742
743         for (i = list; i; i = i->next) {
744                 uint64_t *symvers = NULL;
745                 file = i->file;
746                 syms = file->ops->load_symbols(file,
747                                 check_symvers ? &symvers : NULL);
748                 if (syms) {
749                         for (j = 0; j < syms->cnt; j++)
750                                 add_symbol(syms->str[j],
751                                         symvers ? symvers[j] : 0, i);
752                         strtbl_free(syms);
753                 }
754                 free(symvers);
755                 file->ops->fetch_tables(file, &i->tables);
756         }
757         
758         for (i = list; i; i = i->next)
759                 calculate_deps(i);
760         
761         /* Strip out modules with dependency loops. */
762  again:
763         for (i = list; i; i = i->next) {
764                 if (has_dep_loop(i, NULL)) {
765                         warn("Module %s ignored, due to loop\n",
766                              i->pathname + skipchars);
767                         del_module(&list, i);
768                         goto again;
769                 }
770         }
771         
772         return list;
773 }
774
775 /* Simply dump hash table. */
776 static int output_symbols(struct module *unused, FILE *out, char *dirname)
777 {
778         unsigned int i;
779
780         fprintf(out, "# Aliases for symbols, used by symbol_request().\n");
781         for (i = 0; i < SYMBOL_HASH_SIZE; i++) {
782                 struct symbol *s;
783
784                 for (s = symbolhash[i]; s; s = s->next) {
785                         if (s->owner) {
786                                 char modname[strlen(s->owner->pathname)+1];
787                                 filename2modname(modname, s->owner->pathname);
788                                 fprintf(out, "alias symbol:%s %s\n",
789                                         s->name, modname);
790                         }
791                 }
792         }
793         return 1;
794 }
795
796 static int output_symbols_bin(struct module *unused, FILE *out, char *dirname)
797 {
798         struct index_node *index;
799         unsigned int i;
800         char *alias;
801         int duplicate;
802
803         index = index_create();
804         
805         for (i = 0; i < SYMBOL_HASH_SIZE; i++) {
806                 struct symbol *s;
807
808                 for (s = symbolhash[i]; s; s = s->next) {
809                         if (s->owner) {
810                                 char modname[strlen(s->owner->pathname)+1];
811                                 filename2modname(modname, s->owner->pathname);
812                                 nofail_asprintf(&alias, "symbol:%s", s->name);
813                                 duplicate = index_insert(index, alias, modname,
814                                                          s->owner->order);
815                                 if (duplicate && warn_dups)
816                                         warn("duplicate module syms:\n%s %s\n",
817                                                 alias, modname);
818                                 free(alias);
819                         }
820                 }
821         }
822         
823         index_write(index, out);
824         index_destroy(index);
825
826         return 1;
827 }
828
829 static int output_builtin_bin(struct module *unused, FILE *out, char *dirname)
830 {
831         struct index_node *index;
832         char *textfile, *line;
833         unsigned int linenum;
834         FILE *f;
835
836         nofail_asprintf(&textfile, "%s/modules.builtin", dirname);
837         if (!(f = fopen(textfile, "r"))) {
838                 if (errno != ENOENT)
839                         fatal("Could not open '%s': %s\n",
840                                         textfile, strerror(errno));
841                 free(textfile);
842                 return 0;
843         }
844         free(textfile);
845         index = index_create();
846
847         while ((line = getline_wrapped(f, &linenum)) != NULL) {
848                 char *module = line;
849
850                 if (!*line || *line == '#') {
851                         free(line);
852                         continue;
853                 }
854                 filename2modname(module, module);
855                 index_insert(index, module, "", 0);
856                 free(line);
857         }
858         fclose(f);
859         index_write(index, out);
860         index_destroy(index);
861
862         return 1;
863 }
864
865 static int output_aliases(struct module *modules, FILE *out, char *dirname)
866 {
867         struct module *i;
868         struct elf_file *file;
869         struct string_table *tbl;
870         int j;
871
872         fprintf(out, "# Aliases extracted from modules themselves.\n");
873         for (i = modules; i; i = i->next) {
874                 char modname[strlen(i->pathname)+1];
875
876                 file = i->file;
877                 filename2modname(modname, i->pathname);
878
879                 /* Grab from old-style .modalias section. */
880                 tbl = file->ops->load_strings(file, ".modalias", NULL, fatal);
881                 for (j = 0; tbl && j < tbl->cnt; j++)
882                         fprintf(out, "alias %s %s\n", tbl->str[j], modname);
883                 strtbl_free(tbl);
884
885                 /* Grab from new-style .modinfo section. */
886                 tbl = file->ops->load_strings(file, ".modinfo", NULL, fatal);
887                 for (j = 0; tbl && j < tbl->cnt; j++) {
888                         const char *p = tbl->str[j];
889                         if (strstarts(p, "alias="))
890                                 fprintf(out, "alias %s %s\n",
891                                         p + strlen("alias="), modname);
892                 }
893                 strtbl_free(tbl);
894         }
895         return 1;
896 }
897
898 static int output_aliases_bin(struct module *modules, FILE *out, char *dirname)
899 {
900         struct module *i;
901         struct elf_file *file;
902         struct string_table *tbl;
903         int j;
904         char *alias;
905         struct index_node *index;
906         int duplicate;
907
908         index = index_create();
909         
910         for (i = modules; i; i = i->next) {
911                 char modname[strlen(i->pathname)+1];
912
913                 file = i->file;
914                 filename2modname(modname, i->pathname);
915
916                 /* Grab from old-style .modalias section. */
917                 tbl = file->ops->load_strings(file, ".modalias", NULL, fatal);
918                 for (j = 0; tbl && j < tbl->cnt; j++) {
919                         alias = NOFAIL(strdup(tbl->str[j]));
920                         underscores(alias);
921                         duplicate = index_insert(index, alias, modname, i->order);
922                         if (duplicate && warn_dups)
923                                 warn("duplicate module alias:\n%s %s\n",
924                                         alias, modname);
925                         free(alias);
926                 }
927                 strtbl_free(tbl);
928
929                 /* Grab from new-style .modinfo section. */
930                 tbl = file->ops->load_strings(file, ".modinfo", NULL, fatal);
931                 for (j = 0; tbl && j < tbl->cnt; j++) {
932                         const char *p = tbl->str[j];
933                         if (strstarts(p, "alias=")) {
934                                 alias = NOFAIL(strdup(p + strlen("alias=")));
935                                 underscores(alias);
936                                 duplicate = index_insert(index, alias, modname, i->order);
937                                 if (duplicate && warn_dups)
938                                         warn("duplicate module alias:\n%s %s\n",
939                                                 alias, modname);
940                                 free(alias);
941                         }
942                 }
943                 strtbl_free(tbl);
944         }
945         
946         index_write(index, out);
947         index_destroy(index);
948
949         return 1;
950 }
951
952 struct depfile {
953         char *name;
954         int (*func)(struct module *, FILE *, char *dirname);
955         int map_file;
956 };
957
958 static struct depfile depfiles[] = {
959         { "modules.dep", output_deps, 0 }, /* This is what we check for '-A'. */
960         { "modules.dep.bin", output_deps_bin, 0 },
961         { "modules.pcimap", output_pci_table, 1 },
962         { "modules.usbmap", output_usb_table, 1 },
963         { "modules.ccwmap", output_ccw_table, 1 },
964         { "modules.ieee1394map", output_ieee1394_table, 1 },
965         { "modules.isapnpmap", output_isapnp_table, 1 },
966         { "modules.inputmap", output_input_table, 1 },
967         { "modules.ofmap", output_of_table, 1 },
968         { "modules.seriomap", output_serio_table, 1 },
969         { "modules.alias", output_aliases, 0 },
970         { "modules.alias.bin", output_aliases_bin, 0 },
971         { "modules.symbols", output_symbols, 0 },
972         { "modules.symbols.bin", output_symbols_bin, 0 },
973         { "modules.builtin.bin", output_builtin_bin, 0 },
974 };
975
976 /* If we can't figure it out, it's safe to say "true". */
977 static int any_modules_newer(const char *dirname, time_t mtime)
978 {
979         DIR *dir;
980         struct dirent *dirent;
981
982         dir = opendir(dirname);
983         if (!dir)
984                 return 1;
985
986         while ((dirent = readdir(dir)) != NULL) {
987                 struct stat st;
988                 char file[strlen(dirname) + 1 + strlen(dirent->d_name) + 1];
989
990                 if (streq(dirent->d_name, ".") || streq(dirent->d_name, ".."))
991                         continue;
992
993                 sprintf(file, "%s/%s", dirname, dirent->d_name);
994                 if (lstat(file, &st) != 0)
995                         goto ret_true;
996
997                 if (smells_like_module(dirent->d_name)) {
998                         if (st.st_mtime > mtime)
999                                 goto ret_true;
1000                 } else if (S_ISDIR(st.st_mode)) {
1001                         if (any_modules_newer(file, mtime))
1002                                 goto ret_true;
1003                 }
1004         }
1005         closedir(dir);
1006         return 0;
1007
1008 ret_true:
1009         closedir(dir);
1010         return 1;
1011 }
1012
1013 static int depfile_out_of_date(const char *dirname)
1014 {
1015         struct stat st;
1016         char depfile[strlen(dirname) + 1 + strlen(depfiles[0].name) + 1];
1017
1018         sprintf(depfile, "%s/%s", dirname, depfiles[0].name);
1019
1020         if (stat(depfile, &st) != 0)
1021                 return 1;
1022
1023         return any_modules_newer(dirname, st.st_mtime);
1024 }
1025
1026 static char *strsep_skipspace(char **string, char *delim)
1027 {
1028         if (!*string)
1029                 return NULL;
1030         *string += strspn(*string, delim);
1031         return strsep(string, delim);
1032 }
1033
1034 static struct module_search *add_search(const char *search_path,
1035                                         size_t len,
1036                                         struct module_search *search)
1037 {
1038
1039         struct module_search *new;
1040         
1041         new = NOFAIL(malloc(sizeof(*new)));
1042         new->search_path = NOFAIL(strdup(search_path));
1043         new->len = len;
1044         new->next = search;
1045
1046         return new;
1047         
1048 }
1049
1050 static struct module_overrides *add_override(const char *modfile,
1051                                              struct module_overrides *overrides)
1052 {
1053
1054         struct module_overrides *new;
1055         
1056         new = NOFAIL(malloc(sizeof(*new)));
1057         new->modfile = NOFAIL(strdup(modfile));
1058         new->next = overrides;
1059
1060         return new;
1061         
1062 }
1063
1064 static int parse_config_scan(const char *filename,
1065                              const char *basedir,
1066                              const char *kernelversion,
1067                              struct module_search **search,
1068                              struct module_overrides **overrides);
1069
1070 static int parse_config_file(const char *filename,
1071                              const char *basedir,
1072                              const char *kernelversion,
1073                              struct module_search **search,
1074                              struct module_overrides **overrides)
1075 {
1076         char *line;
1077         unsigned int linenum = 0;
1078         FILE *cfile;
1079
1080         cfile = fopen(filename, "r");
1081         if (!cfile) {
1082                 if (errno != ENOENT)
1083                         fatal("could not open '%s', reason: %s\n", filename,
1084                               strerror(errno));
1085                 return 0;
1086         }
1087
1088         while ((line = getline_wrapped(cfile, &linenum)) != NULL) {
1089                 char *ptr = line;
1090                 char *cmd, *modname;
1091
1092                 cmd = strsep_skipspace(&ptr, "\t ");
1093
1094                 if (cmd == NULL || cmd[0] == '#' || cmd[0] == '\0') {
1095                         free(line);
1096                         continue;
1097                 }
1098
1099                 if (streq(cmd, "search")) {
1100                         char *search_path;
1101                         
1102                         while ((search_path = strsep_skipspace(&ptr, "\t "))) {
1103                                 char *dirname;
1104                                 size_t len;
1105
1106                                 if (strcmp(search_path,
1107                                                 MODULE_BUILTIN_KEY) == 0) {
1108                                         *search = add_search(MODULE_BUILTIN_KEY,
1109                                                              0, *search);
1110                                         continue;
1111                                 }
1112                                 nofail_asprintf(&dirname, "%s%s%s/%s", basedir,
1113                                         MODULE_DIR, kernelversion, search_path);
1114                                 len = strlen(dirname);
1115                                 *search = add_search(dirname, len, *search);
1116                                 free(dirname);
1117                         }
1118                 } else if (streq(cmd, "override")) {
1119                         char *pathname = NULL, *version, *subdir;
1120                         modname = strsep_skipspace(&ptr, "\t ");
1121                         version = strsep_skipspace(&ptr, "\t ");
1122                         subdir = strsep_skipspace(&ptr, "\t ");
1123
1124                         if (strcmp(version, kernelversion) != 0 &&
1125                             strcmp(version, "*") != 0)
1126                                 continue;
1127
1128                         nofail_asprintf(&pathname, "%s%s%s/%s/%s.ko", basedir,
1129                                 MODULE_DIR, kernelversion, subdir, modname);
1130
1131                         *overrides = add_override(pathname, *overrides);
1132                         free(pathname);
1133                 } else if (streq(cmd, "include")) {
1134                         char *newfilename;
1135
1136                         newfilename = strsep_skipspace(&ptr, "\t ");
1137                         if (!newfilename) {
1138                                 grammar(cmd, filename, linenum);
1139                         } else {
1140                                 warn("\"include %s\" is deprecated, "
1141                                      "please use /etc/depmod.d\n", newfilename);
1142                                 if (strstarts(newfilename, "/etc/depmod.d")) {
1143                                         warn("\"include /etc/depmod.d\" is "
1144                                              "the default, ignored\n");
1145                                 } else {
1146                                         if (!parse_config_scan(newfilename, basedir,
1147                                                                kernelversion,
1148                                                                search, overrides))
1149                                         warn("Failed to open included"
1150                                              " config file %s: %s\n",
1151                                              newfilename, strerror(errno));
1152                                 }
1153                         }
1154                 } else if (streq(cmd, "make_map_files")) {
1155                         char *option;
1156
1157                         option = strsep_skipspace(&ptr, "\t ");
1158                         if (!option)
1159                                 grammar(cmd, filename, linenum);
1160                         else {
1161                                 if (streq(option, "yes"))
1162                                         make_map_files = 1;
1163                                 else if (streq(option, "no"))
1164                                         make_map_files = 0;
1165                                 else
1166                                         grammar(cmd, filename, linenum);
1167                         }
1168                 } else
1169                         grammar(cmd, filename, linenum);
1170
1171                 free(line);
1172         }
1173         fclose(cfile);
1174         return 1;
1175 }
1176
1177 static int parse_config_scan(const char *filename,
1178                              const char *basedir,
1179                              const char *kernelversion,
1180                              struct module_search **search,
1181                              struct module_overrides **overrides)
1182 {
1183         DIR *dir;
1184         int ret = 0;
1185
1186         dir = opendir(filename);
1187         if (dir) {
1188                 struct file_entry {
1189                         struct list_head node;
1190                         char name[];
1191                 };
1192                 LIST_HEAD(files_list);
1193                 struct file_entry *fe, *fe_tmp;
1194                 struct dirent *i;
1195
1196                 /* sort files from directory into list */
1197                 while ((i = readdir(dir)) != NULL) {
1198                         size_t len;
1199
1200                         if (i->d_name[0] == '.')
1201                                 continue;
1202                         if (!config_filter(i->d_name))
1203                                 continue;
1204
1205                         len = strlen(i->d_name);
1206                         if (len < 6 || strcmp(&i->d_name[len-5], ".conf") != 0)
1207                                 warn("All config files need .conf: %s/%s, "
1208                                      "it will be ignored in a future release.\n",
1209                                      filename, i->d_name);
1210                         fe = malloc(sizeof(struct file_entry) + len + 1);
1211                         if (fe == NULL)
1212                                 continue;
1213                         strcpy(fe->name, i->d_name);
1214                         list_for_each_entry(fe_tmp, &files_list, node)
1215                                 if (strcmp(fe_tmp->name, fe->name) >= 0)
1216                                         break;
1217                         list_add_tail(&fe->node, &fe_tmp->node);
1218                 }
1219                 closedir(dir);
1220
1221                 /* parse list of files */
1222                 list_for_each_entry_safe(fe, fe_tmp, &files_list, node) {
1223                         char *cfgfile;
1224
1225                         nofail_asprintf(&cfgfile, "%s/%s", filename, fe->name);
1226                         if (!parse_config_file(cfgfile, basedir, kernelversion,
1227                                                search, overrides))
1228                                 warn("Failed to open config file "
1229                                      "%s: %s\n", fe->name, strerror(errno));
1230                         free(cfgfile);
1231                         list_del(&fe->node);
1232                         free(fe);
1233                 }
1234
1235                 ret = 1;
1236         } else {
1237                 if (parse_config_file(filename, basedir, kernelversion, search,
1238                                       overrides))
1239                         ret = 1;
1240         }
1241
1242         return ret;
1243 }
1244
1245 static void parse_toplevel_config(const char *filename,
1246                                   const char *basedir,
1247                                   const char *kernelversion,
1248                                   struct module_search **search,
1249                                   struct module_overrides **overrides)
1250 {
1251         if (filename) {
1252                 if (!parse_config_scan(filename, basedir, kernelversion, search,
1253                                  overrides))
1254                         fatal("Failed to open config file %s: %s\n",
1255                               filename, strerror(errno));
1256                 return;
1257         }
1258
1259         /* deprecated config file */
1260         if (parse_config_file("/etc/depmod.conf", basedir, kernelversion,
1261                               search, overrides) > 0)
1262                 warn("Deprecated config file /etc/depmod.conf, "
1263                       "all config files belong into /etc/depmod.d/.\n");
1264
1265         /* default config */
1266         parse_config_scan("/etc/depmod.d", basedir, kernelversion,
1267                           search, overrides);
1268 }
1269
1270 /* Local to main, but not freed on exit.  Keep valgrind quiet. */
1271 struct module *list = NULL;
1272 struct module_search *search = NULL;
1273 struct module_overrides *overrides = NULL;
1274
1275 int main(int argc, char *argv[])
1276 {
1277         int opt, all = 0, maybe_all = 0, doing_stdout = 0;
1278         char *basedir = "", *dirname, *version;
1279         char *system_map = NULL, *module_symvers = NULL;
1280         int i;
1281         const char *config = NULL;
1282
1283         if (native_endianness() == 0)
1284                 abort();
1285
1286         while ((opt = getopt_long(argc, argv, "aAb:C:E:F:euqrvnhVwm", options, NULL))
1287                != -1) {
1288                 switch (opt) {
1289                 case 'a':
1290                         all = 1;
1291                         break;
1292                 case 'A':
1293                         maybe_all = 1;
1294                         break;
1295                 case 'b':
1296                         basedir = optarg;
1297                         skipchars = strlen(basedir);
1298                         break;
1299                 case 'C':
1300                         config = optarg;
1301                         break;
1302                 case 'E':
1303                         module_symvers = optarg;
1304                         check_symvers = 1;
1305                         break;
1306                 case 'F':
1307                         system_map = optarg;
1308                         break;
1309                 case 'e':
1310                         print_unknown = 1;
1311                         break;
1312                 case 'u':
1313                 case 'q':
1314                 case 'r':
1315                         break;
1316                 case 'v':
1317                         verbose = 1;
1318                         break;
1319                 case 'n':
1320                         doing_stdout = 1;
1321                         break;
1322                 case 'h':
1323                         print_usage(argv[0]);
1324                         exit(0);
1325                         break;
1326                 case 'V':
1327                         printf("%s %s\n", PACKAGE, VERSION);
1328                         exit(0);
1329                 case 'w':
1330                         warn_dups = 1;
1331                         break;
1332                 case 'm':
1333                         force_map_files = 1;
1334                         break;
1335                 default:
1336                         print_usage(argv[0]);
1337                         exit(1);
1338                 }
1339         }
1340
1341         if (module_symvers)
1342                 load_module_symvers(module_symvers);
1343         else if (system_map)
1344                 load_system_map(system_map);
1345         else if (print_unknown) {
1346                 warn("-e needs -E or -F");
1347                 print_unknown = 0;
1348         }
1349
1350         /* They can specify the version naked on the command line */
1351         if (optind < argc && is_version_number(argv[optind])) {
1352                 version = NOFAIL(strdup(argv[optind]));
1353                 optind++;
1354         } else {
1355                 struct utsname buf;
1356                 uname(&buf);
1357                 version = NOFAIL(strdup(buf.release));
1358         }
1359
1360         /* Check for old version. */
1361         if (old_module_version(version)) {
1362                 fprintf(stderr, "Kernel version %s requires old depmod\n",
1363                         version);
1364                 exit(2);
1365         }
1366
1367         /* Depmod -a by default if no names. */
1368         if (optind == argc)
1369                 all = 1;
1370
1371         nofail_asprintf(&dirname, "%s%s%s", basedir, MODULE_DIR, version);
1372
1373         if (maybe_all) {
1374                 if (!doing_stdout && !depfile_out_of_date(dirname))
1375                         exit(0);
1376                 all = 1;
1377         }
1378
1379         parse_toplevel_config(config, basedir, version, &search, &overrides);
1380
1381         /* For backward compatibility add "updates" to the head of the search
1382          * list here. But only if there was no "search" option specified.
1383          */
1384         if (!search) {
1385                 char *dirname;
1386                 size_t len;
1387
1388                 nofail_asprintf(&dirname, "%s%s%s/updates", basedir,
1389                                 MODULE_DIR, version);
1390                 len = strlen(dirname);
1391                 search = add_search(dirname, len, search);
1392         }
1393         if (!all) {
1394                 /* Do command line args. */
1395                 for (opt = optind; opt < argc; opt++) {
1396                         struct module *new;
1397
1398                         if (argv[opt][0] != '/')
1399                                 fatal("modules must be specified using absolute paths.\n"
1400                                         "\"%s\" is a relative path\n", argv[opt]);
1401
1402                         new = grab_module(NULL, argv[opt]);
1403                         if (!new) {
1404                                 /* cmd-line specified modules must exist */
1405                                 fatal("grab_module() failed for module %s\n", argv[opt]);
1406                         }
1407                         new->next = list;
1408                         list = new;
1409                 }
1410         } else {
1411                 list = grab_basedir(dirname,search,overrides);
1412         }
1413         list = sort_modules(dirname,list);
1414         list = parse_modules(list);
1415
1416         for (i = 0; i < sizeof(depfiles)/sizeof(depfiles[0]); i++) {
1417                 FILE *out;
1418                 int res;
1419                 struct depfile *d = &depfiles[i];
1420                 char depname[strlen(dirname) + 1 + strlen(d->name) + 1];
1421                 char tmpname[strlen(dirname) + 1 + strlen(d->name) +
1422                                                 strlen(".temp") + 1];
1423
1424                 if (d->map_file && !make_map_files && !force_map_files)
1425                         continue;
1426
1427                 sprintf(depname, "%s/%s", dirname, d->name);
1428                 sprintf(tmpname, "%s/%s.temp", dirname, d->name);
1429                 if (!doing_stdout) {
1430                         out = fopen(tmpname, "w");
1431                         if (!out)
1432                                 fatal("Could not open %s for writing: %s\n",
1433                                         tmpname, strerror(errno));
1434                 } else {
1435                         out = stdout;
1436                         if (ends_in(depname, ".bin"))
1437                                 continue;
1438                 }
1439                 res = d->func(list, out, dirname);
1440                 if (doing_stdout)
1441                         continue;
1442                 fclose(out);
1443                 if (res) {
1444                         if (rename(tmpname, depname) < 0)
1445                                 fatal("Could not rename %s into %s: %s\n",
1446                                         tmpname, depname, strerror(errno));
1447                 } else {
1448                         if (unlink(tmpname) < 0)
1449                                 warn("Could not delete %s: %s\n",
1450                                         tmpname, strerror(errno));
1451                 }
1452         }
1453
1454         free(dirname);
1455         free(version);
1456         
1457         return 0;
1458 }