usr.bin/config/mkioconf.c

   1 /*      $NetBSD: mkioconf.c,v 1.13 2009/01/20 18:20:48 drochner Exp $   */
   2
   3 /*
   4  * Copyright (c) 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This software was developed by the Computer Systems Engineering group
   8  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   9  * contributed to Berkeley.
  10  *
  11  * All advertising materials mentioning features or use of this software
  12  * must display the following acknowledgement:
  13  *      This product includes software developed by the University of
  14  *      California, Lawrence Berkeley Laboratories.
  15  *
  16  * Redistribution and use in source and binary forms, with or without
  17  * modification, are permitted provided that the following conditions
  18  * are met:
  19  * 1. Redistributions of source code must retain the above copyright
  20  *    notice, this list of conditions and the following disclaimer.
  21  * 2. Redistributions in binary form must reproduce the above copyright
  22  *    notice, this list of conditions and the following disclaimer in the
  23  *    documentation and/or other materials provided with the distribution.
  24  * 3. Neither the name of the University nor the names of its contributors
  25  *    may be used to endorse or promote products derived from this software
  26  *    without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  38  * SUCH DAMAGE.
  39  *
  40  *      from: @(#)mkioconf.c    8.1 (Berkeley) 6/6/93
  41  */
  42
  43 #if HAVE_NBTOOL_CONFIG_H
  44 #include "nbtool_config.h"
  45 #endif
  46
  47 #include <sys/param.h>
  48 #include <err.h>
  49 #include <errno.h>
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include <string.h>
  53 #include "defs.h"
  54
  55 /*
  56  * Make ioconf.c.
  57  */
  58 static int cf_locators_print(const char *, void *, void *);
  59 static int cforder(const void *, const void *);
  60 static void emitcfdata(FILE *);
  61 static void emitcfdrivers(FILE *);
  62 static void emitexterns(FILE *);
  63 static void emitcfattachinit(FILE *);
  64 static void emithdr(FILE *);
  65 static void emitloc(FILE *);
  66 static void emitpseudo(FILE *);
  67 static void emitparents(FILE *);
  68 static void emitroots(FILE *);
  69 static void emitname2blk(FILE *);
  70
  71 #define SEP(pos, max)   (((u_int)(pos) % (max)) == 0 ? "\n\t" : " ")
  72
  73 #define ARRNAME(n, l) (strchr((n), ARRCHR) && strncmp((n), (l), strlen((l))) == 0)
  74
  75 /*
  76  * NEWLINE can only be used in the emitXXX functions.
  77  * In most cases it can be subsumed into an fprintf.
  78  */
  79 #define NEWLINE         putc('\n', fp)
  80
  81 int
  82 mkioconf(void)
  83 {
  84         FILE *fp;
  85
  86         qsort(packed, npacked, sizeof *packed, cforder);
  87         if ((fp = fopen("ioconf.c.tmp", "w")) == NULL) {
  88                 warn("cannot write ioconf.c");
  89                 return (1);
  90         }
  91
  92         emithdr(fp);
  93         emitcfdrivers(fp);
  94         emitexterns(fp);
  95         emitcfattachinit(fp);
  96         emitloc(fp);
  97         emitparents(fp);
  98         emitcfdata(fp);
  99         emitroots(fp);
 100         emitpseudo(fp);
 101         if (!do_devsw)
 102                 emitname2blk(fp);
 103
 104         fflush(fp);
 105         if (ferror(fp)) {
 106                 warn("error writing ioconf.c");
 107                 (void)fclose(fp);
 108 #if 0
 109                 (void)unlink("ioconf.c.tmp");
 110 #endif
 111                 return (1);
 112         }
 113
 114         (void)fclose(fp);
 115         if (moveifchanged("ioconf.c.tmp", "ioconf.c") != 0) {
 116                 warn("error renaming ioconf.c");
 117                 return (1);
 118         }
 119         return (0);
 120 }
 121
 122 static int
 123 cforder(const void *a, const void *b)
 124 {
 125         int n1, n2;
 126
 127         n1 = (*(const struct devi * const *)a)->i_cfindex;
 128         n2 = (*(const struct devi * const *)b)->i_cfindex;
 129         return (n1 - n2);
 130 }
 131
 132 static void
 133 emithdr(FILE *ofp)
 134 {
 135         FILE *ifp;
 136         int n;
 137         char ifnbuf[200], buf[BUFSIZ];
 138         char *ifn;
 139
 140         autogen_comment(ofp, "ioconf.c");
 141
 142         (void)snprintf(ifnbuf, sizeof(ifnbuf), "arch/%s/conf/ioconf.incl.%s",
 143             machine, machine);
 144         ifn = sourcepath(ifnbuf);
 145         if ((ifp = fopen(ifn, "r")) != NULL) {
 146                 while ((n = fread(buf, 1, sizeof(buf), ifp)) > 0)
 147                         (void)fwrite(buf, 1, n, ofp);
 148                 if (ferror(ifp))
 149                         err(EXIT_FAILURE, "error reading %s", ifn);
 150                 (void)fclose(ifp);
 151         } else {
 152                 fputs("#include <sys/param.h>\n"
 153                         "#include <sys/conf.h>\n"
 154                         "#include <sys/device.h>\n"
 155                         "#include <sys/mount.h>\n", ofp);
 156         }
 157         free(ifn);
 158 }
 159
 160 /*
 161  * Emit an initialized array of character strings describing this
 162  * attribute's locators.
 163  */
 164 static int
 165 cf_locators_print(const char *name, void *value, void *arg)
 166 {
 167         struct attr *a;
 168         struct nvlist *nv;
 169         FILE *fp = arg;
 170
 171         a = value;
 172         if (!a->a_iattr)
 173                 return (0);
 174
 175         if (a->a_locs) {
 176                 fprintf(fp,
 177                     "static const struct cfiattrdata %scf_iattrdata = {\n",
 178                             name);
 179                 fprintf(fp, "\t\"%s\", %d,\n\t{\n", name, a->a_loclen);
 180                 for (nv = a->a_locs; nv; nv = nv->nv_next)
 181                         fprintf(fp, "\t\t{ \"%s\", \"%s\", %s },\n",
 182                                 nv->nv_name,
 183                                 (nv->nv_str ? nv->nv_str : "NULL"),
 184                                 (nv->nv_str ? nv->nv_str : "0"));
 185                 fprintf(fp, "\t}\n};\n");
 186         } else {
 187                 fprintf(fp,
 188                     "static const struct cfiattrdata %scf_iattrdata = {\n"
 189                     "\t\"%s\", 0, {\n\t\t{ NULL, NULL, 0 },\n\t}\n};\n",
 190                     name, name);
 191         }
 192
 193         return 0;
 194 }
 195
 196 static void
 197 emitcfdrivers(FILE *fp)
 198 {
 199         struct devbase *d;
 200         struct nvlist *nv;
 201         struct attr *a;
 202         int has_iattrs;
 203
 204         NEWLINE;
 205         ht_enumerate(attrtab, cf_locators_print, fp);
 206
 207         NEWLINE;
 208         TAILQ_FOREACH(d, &allbases, d_next) {
 209                 if (!devbase_has_instances(d, WILD))
 210                         continue;
 211                 has_iattrs = 0;
 212                 for (nv = d->d_attrs; nv != NULL; nv = nv->nv_next) {
 213                         a = nv->nv_ptr;
 214                         if (a->a_iattr == 0)
 215                                 continue;
 216                         if (has_iattrs == 0)
 217                                 fprintf(fp,
 218                                     "static const struct cfiattrdata * const %s_attrs[] = { ",
 219                                     d->d_name);
 220                         has_iattrs = 1;
 221                         fprintf(fp, "&%scf_iattrdata, ", a->a_name);
 222                 }
 223                 if (has_iattrs)
 224                         fprintf(fp, "NULL };\n");
 225                 fprintf(fp, "CFDRIVER_DECL(%s, %s, ", d->d_name, /* ) */
 226                     d->d_classattr != NULL ? d->d_classattr->a_devclass
 227                                            : "DV_DULL");
 228                 if (has_iattrs)
 229                         fprintf(fp, "%s_attrs", d->d_name);
 230                 else
 231                         fprintf(fp, "NULL");
 232                 fprintf(fp, /* ( */ ");\n\n");
 233         }
 234
 235         NEWLINE;
 236         fprintf(fp, "struct cfdriver * const cfdriver_list_initial[] = {\n");
 237         TAILQ_FOREACH(d, &allbases, d_next) {
 238                 if (!devbase_has_instances(d, WILD))
 239                         continue;
 240                 fprintf(fp, "\t&%s_cd,\n", d->d_name);
 241         }
 242         fprintf(fp, "\tNULL\n};\n");
 243 }
 244
 245 static void
 246 emitexterns(FILE *fp)
 247 {
 248         struct deva *da;
 249
 250         NEWLINE;
 251         TAILQ_FOREACH(da, &alldevas, d_next) {
 252                 if (!deva_has_instances(da, WILD))
 253                         continue;
 254                 fprintf(fp, "extern struct cfattach %s_ca;\n",
 255                             da->d_name);
 256         }
 257 }
 258
 259 static void
 260 emitcfattachinit(FILE *fp)
 261 {
 262         struct devbase *d;
 263         struct deva *da;
 264
 265         NEWLINE;
 266         TAILQ_FOREACH(d, &allbases, d_next) {
 267                 if (!devbase_has_instances(d, WILD))
 268                         continue;
 269                 if (d->d_ahead == NULL)
 270                         continue;
 271
 272                 fprintf(fp,
 273                     "static struct cfattach * const %s_cfattachinit[] = {\n\t",
 274                             d->d_name);
 275                 for (da = d->d_ahead; da != NULL; da = da->d_bsame) {
 276                         if (!deva_has_instances(da, WILD))
 277                                 continue;
 278                         fprintf(fp, "&%s_ca, ", da->d_name);
 279                 }
 280                 fprintf(fp, "NULL\n};\n");
 281         }
 282
 283         NEWLINE;
 284         fprintf(fp, "const struct cfattachinit cfattachinit[] = {\n");
 285
 286         TAILQ_FOREACH(d, &allbases, d_next) {
 287                 if (!devbase_has_instances(d, WILD))
 288                         continue;
 289                 if (d->d_ahead == NULL)
 290                         continue;
 291
 292                 fprintf(fp, "\t{ \"%s\", %s_cfattachinit },\n",
 293                             d->d_name, d->d_name);
 294         }
 295
 296         fprintf(fp, "\t{ NULL, NULL }\n};\n");
 297 }
 298
 299 static void
 300 emitloc(FILE *fp)
 301 {
 302         int i;
 303
 304         if (locators.used != 0) {
 305                 fprintf(fp, "\n/* locators */\n"
 306                         "static int loc[%d] = {", locators.used);
 307                 for (i = 0; i < locators.used; i++)
 308                         fprintf(fp, "%s%s,", SEP(i, 8), locators.vec[i]);
 309                 fprintf(fp, "\n};\n");
 310         } else if (*packed != NULL) {
 311                 /* We need to have *something*. */
 312                 fprintf(fp, "\n/* locators */\n"
 313                         "static int loc[1] = { -1 };\n");
 314         }
 315 }
 316
 317 /*
 318  * Emit static parent data.
 319  */
 320 static void
 321 emitparents(FILE *fp)
 322 {
 323         struct pspec *p;
 324
 325         NEWLINE;
 326         TAILQ_FOREACH(p, &allpspecs, p_list) {
 327                 if (p->p_devs == NULL || p->p_active != DEVI_ACTIVE)
 328                         continue;
 329                 fprintf(fp,
 330                     "static const struct cfparent pspec%d = {\n", p->p_inst);
 331                 fprintf(fp, "\t\"%s\", ", p->p_iattr->a_name);
 332                 if (p->p_atdev != NULL) {
 333                         fprintf(fp, "\"%s\", ", p->p_atdev->d_name);
 334                         if (p->p_atunit == WILD)
 335                                 fprintf(fp, "DVUNIT_ANY");
 336                         else
 337                                 fprintf(fp, "%d", p->p_atunit);
 338                 } else
 339                         fprintf(fp, "NULL, 0");
 340                 fprintf(fp, "\n};\n");
 341         }
 342 }
 343
 344 /*
 345  * Emit the cfdata array.
 346  */
 347 static void
 348 emitcfdata(FILE *fp)
 349 {
 350         struct devi **p, *i;
 351         struct pspec *ps;
 352         int unit, v;
 353         const char *state, *basename, *attachment;
 354         struct nvlist *nv;
 355         struct attr *a;
 356         const char *loc;
 357         char locbuf[20];
 358         const char *lastname = "";
 359
 360         fprintf(fp, "\n"
 361                 "#define NORM FSTATE_NOTFOUND\n"
 362                 "#define STAR FSTATE_STAR\n"
 363                 "\n"
 364                 "struct cfdata cfdata[] = {\n"
 365                 "    /* driver           attachment    unit state "
 366                 "loc   flags pspec */\n");
 367         for (p = packed; (i = *p) != NULL; p++) {
 368                 /* the description */
 369                 fprintf(fp, "/*%3d: %s at ", i->i_cfindex, i->i_name);
 370                 if ((ps = i->i_pspec) != NULL) {
 371                         if (ps->p_atdev != NULL &&
 372                             ps->p_atunit != WILD) {
 373                                 fprintf(fp, "%s%d", ps->p_atdev->d_name,
 374                                             ps->p_atunit);
 375                         } else if (ps->p_atdev != NULL) {
 376                                 fprintf(fp, "%s?", ps->p_atdev->d_name);
 377                         } else {
 378                                 fprintf(fp, "%s?", ps->p_iattr->a_name);
 379                         }
 380
 381                         a = ps->p_iattr;
 382                         for (nv = a->a_locs, v = 0; nv != NULL;
 383                              nv = nv->nv_next, v++) {
 384                                 if (ARRNAME(nv->nv_name, lastname)) {
 385                                         fprintf(fp, " %s %s",
 386                                             nv->nv_name, i->i_locs[v]);
 387                                 } else {
 388                                         fprintf(fp, " %s %s",
 389                                                     nv->nv_name,
 390                                                     i->i_locs[v]);
 391                                         lastname = nv->nv_name;
 392                                 }
 393                         }
 394                 } else {
 395                         a = NULL;
 396                         fputs("root", fp);
 397                 }
 398
 399                 fputs(" */\n", fp);
 400
 401                 /* then the actual defining line */
 402                 basename = i->i_base->d_name;
 403                 attachment = i->i_atdeva->d_name;
 404                 if (i->i_unit == STAR) {
 405                         unit = i->i_base->d_umax;
 406                         state = "STAR";
 407                 } else {
 408                         unit = i->i_unit;
 409                         state = "NORM";
 410                 }
 411                 if (i->i_locoff >= 0) {
 412                         (void)snprintf(locbuf, sizeof(locbuf), "loc+%3d",
 413                             i->i_locoff);
 414                         loc = locbuf;
 415                 } else
 416                         loc = "loc";
 417                 fprintf(fp, "    { \"%s\",%s\"%s\",%s%2d, %s, %7s, %#6x, ",
 418                             basename, strlen(basename) < 8 ? "\t\t"
 419                                                            : "\t",
 420                             attachment, strlen(attachment) < 5 ? "\t\t"
 421                                                                : "\t",
 422                             unit, state, loc, i->i_cfflags);
 423                 if (ps != NULL)
 424                         fprintf(fp, "&pspec%d },\n", ps->p_inst);
 425                 else
 426                         fputs("NULL },\n", fp);
 427         }
 428         fprintf(fp, "    { %s,%s%s,%s%2d, %s, %7s, %#6x, %s }\n};\n",
 429             "NULL", "\t\t", "NULL", "\t\t", 0, "0", "NULL", 0, "NULL");
 430 }
 431
 432 /*
 433  * Emit the table of potential roots.
 434  */
 435 static void
 436 emitroots(FILE *fp)
 437 {
 438         struct devi **p, *i;
 439
 440         fputs("\nconst short cfroots[] = {\n", fp);
 441         for (p = packed; (i = *p) != NULL; p++) {
 442                 if (i->i_at != NULL)
 443                         continue;
 444                 if (i->i_unit != 0 &&
 445                     (i->i_unit != STAR || i->i_base->d_umax != 0))
 446                         warnx("warning: `%s at root' is not unit 0", i->i_name);
 447                 fprintf(fp, "\t%2d /* %s */,\n",
 448                     i->i_cfindex, i->i_name);
 449         }
 450         fputs("\t-1\n};\n", fp);
 451 }
 452
 453 /*
 454  * Emit pseudo-device initialization.
 455  */
 456 static void
 457 emitpseudo(FILE *fp)
 458 {
 459         struct devi *i;
 460         struct devbase *d;
 461
 462         fputs("\n/* pseudo-devices */\n", fp);
 463         TAILQ_FOREACH(i, &allpseudo, i_next) {
 464                 fprintf(fp, "void %sattach(int);\n",
 465                     i->i_base->d_name);
 466         }
 467         fputs("\nstruct pdevinit pdevinit[] = {\n", fp);
 468         TAILQ_FOREACH(i, &allpseudo, i_next) {
 469                 d = i->i_base;
 470                 fprintf(fp, "\t{ %sattach, %d },\n",
 471                     d->d_name, d->d_umax);
 472         }
 473         fputs("\t{ 0, 0 }\n};\n", fp);
 474 }
 475
 476 /*
 477  * Emit name to major block number table.
 478  */
 479 void
 480 emitname2blk(FILE *fp)
 481 {
 482         struct devbase *dev;
 483
 484         fputs("\n/* device name to major block number */\n", fp);
 485
 486         fprintf(fp, "struct devnametobdevmaj dev_name2blk[] = {\n");
 487
 488         TAILQ_FOREACH(dev, &allbases, d_next) {
 489                 if (dev->d_major == NODEVMAJOR)
 490                         continue;
 491
 492                 fprintf(fp, "\t{ \"%s\", %d },\n",
 493                             dev->d_name, dev->d_major);
 494         }
 495         fprintf(fp, "\t{ NULL, 0 }\n};\n");
 496 }