arch/common/boot/grub2/util/genmoddep.c

   1 /*
   2  *  GRUB  --  GRand Unified Bootloader
   3  *  Copyright (C) 2002,2007  Free Software Foundation, Inc.
   4  *
   5  *  GRUB is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  GRUB is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22 #include <stdarg.h>
  23
  24 #define BUF_SIZE        1024
  25 #define SYMTAB_SIZE     509
  26
  27 struct symbol
  28 {
  29   const char *name;
  30   const char *mod;
  31   struct symbol *next;
  32 };
  33
  34 struct module
  35 {
  36   const char *name;
  37   struct module *next;
  38 };
  39
  40 static char buf[BUF_SIZE];
  41 static struct symbol *symtab[SYMTAB_SIZE];
  42
  43 static void
  44 err (const char *fmt, ...)
  45 {
  46   va_list ap;
  47
  48   fprintf (stderr, "genmoddep: error: ");
  49
  50   va_start (ap, fmt);
  51   vfprintf (stderr, fmt, ap);
  52   va_end (ap);
  53
  54   fputc ('\n', stderr);
  55   exit (1);
  56 }
  57
  58 static void *
  59 xmalloc (size_t size)
  60 {
  61   void *p;
  62
  63   p = malloc (size);
  64   if (! p)
  65     err ("out of memory");
  66
  67   return p;
  68 }
  69
  70 static char *
  71 xstrdup (const char *str)
  72 {
  73   char *s;
  74   size_t len;
  75
  76   len = strlen (str);
  77   s = (char *) xmalloc (len + 1);
  78   memcpy (s, str, len + 1);
  79
  80   return s;
  81 }
  82
  83 static void
  84 chomp (char *str)
  85 {
  86   int end;
  87
  88   end = strlen (str) - 1;
  89   if (end < 0)
  90     err ("empty string");
  91
  92   if (str[end] == '\n')
  93     str[end] = '\0';
  94 }
  95
  96 static unsigned
  97 symbol_hash (const char *s)
  98 {
  99   unsigned key = 0;
 100
 101   while (*s)
 102     key = key * 65599 + *s++;
 103
 104   return (key + (key >> 5)) % SYMTAB_SIZE;
 105 }
 106
 107 static struct symbol *
 108 get_symbol (const char *name)
 109 {
 110   unsigned k;
 111   struct symbol *sym;
 112
 113   k = symbol_hash (name);
 114   for (sym = symtab[k]; sym; sym = sym->next)
 115     if (strcmp (sym->name, name) == 0)
 116       return sym;
 117
 118   return 0;
 119 }
 120
 121 static void
 122 add_symbol (const char *name, const char *mod)
 123 {
 124   unsigned k;
 125   struct symbol *sym;
 126
 127   if (get_symbol (name))
 128     err ("duplicated symbol: %s", name);
 129
 130   sym = (struct symbol *) xmalloc (sizeof (*sym));
 131   sym->name = xstrdup (name);
 132   sym->mod = xstrdup (mod);
 133
 134   k = symbol_hash (name);
 135   sym->next = symtab[k];
 136   symtab[k] = sym;
 137 }
 138
 139 static void
 140 free_symbols (void)
 141 {
 142   int i;
 143
 144   for (i = 0; i < SYMTAB_SIZE; i++)
 145     {
 146       struct symbol *p, *q;
 147
 148       p = symtab[i];
 149       while (p)
 150         {
 151           q = p->next;
 152           free ((void *) p->name);
 153           free ((void *) p->mod);
 154           free (p);
 155           p = q;
 156         }
 157     }
 158 }
 159
 160 static void
 161 read_defined_symbols (FILE *fp)
 162 {
 163   while (fgets (buf, sizeof (buf), fp))
 164     {
 165       char *p;
 166
 167       if (! *buf)
 168         err ("empty symbol name: %s", buf);
 169
 170       p = strchr (buf, ' ');
 171       if (! p)
 172         err ("invalid line format: %s", buf);
 173
 174       p++;
 175
 176       if (! *p)
 177         err ("empty module name: %s", buf);
 178
 179       *(p - 1) = '\0';
 180       chomp (p);
 181
 182       add_symbol (buf, p);
 183     }
 184 }
 185
 186 static void
 187 add_module (struct module **head, const char *name)
 188 {
 189   struct module *mod;
 190
 191   for (mod = *head; mod; mod = mod->next)
 192     if (strcmp (mod->name, name) == 0)
 193       return;
 194
 195   mod = (struct module *) xmalloc (sizeof (*mod));
 196   mod->name = xstrdup (name);
 197
 198   mod->next = *head;
 199   *head = mod;
 200 }
 201
 202 static void
 203 free_modules (struct module *head)
 204 {
 205   struct module *next;
 206
 207   while (head)
 208     {
 209       next = head->next;
 210       free ((void *) head->name);
 211       free (head);
 212       head = next;
 213     }
 214 }
 215
 216 static void
 217 find_dependencies (FILE *fp)
 218 {
 219   char *mod_name;
 220   struct module *mod_list = 0;
 221   struct module *mod;
 222
 223   if (! fgets (buf, sizeof (buf), fp) || buf[0] == '\n' || buf[0] == '\0')
 224     err ("no module name");
 225
 226   chomp (buf);
 227   mod_name = xstrdup (buf);
 228
 229   while (fgets (buf, sizeof (buf), fp))
 230     {
 231       struct symbol *sym;
 232
 233       chomp (buf);
 234       sym = get_symbol (buf);
 235       if (! sym)
 236         err ("%s in %s is not defined", buf, mod_name);
 237
 238       add_module (&mod_list, sym->mod);
 239     }
 240
 241   printf ("%s:", mod_name);
 242
 243   for (mod = mod_list; mod; mod = mod->next)
 244     if (strcmp (mod->name, "kernel") != 0)
 245       printf (" %s", mod->name);
 246
 247   putchar ('\n');
 248
 249   free_modules (mod_list);
 250 }
 251
 252 int
 253 main (int argc, char *argv[])
 254 {
 255   int i;
 256
 257   /* First, get defined symbols.  */
 258   read_defined_symbols (stdin);
 259
 260   /* Second, find the dependencies.  */
 261   for (i = 1; i < argc; i++)
 262     {
 263       FILE *fp;
 264
 265       fp = fopen (argv[i], "r");
 266       if (! fp)
 267         err ("cannot open %s", argv[i]);
 268
 269       find_dependencies (fp);
 270
 271       fclose (fp);
 272     }
 273
 274   /* Last, free memory.  */
 275   free_symbols ();
 276
 277   return 0;
 278 }