%type <val> optional_size
%type <val> arg_device_spec
%type <val> root_device_spec
%type <val> dump_device_spec
%type <file> swap_device_spec
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
* @(#)config.y 5.3 (Berkeley) %G%
= { verifysystemspecs(); }
= { do_trace = !do_trace; } |
if (!strcmp($2, "vax")) {
} else if (!strcmp($2, "tahoe")) {
yyerror("Unknown machine type");
(struct cputype *)malloc(sizeof (struct cputype));
= { yyerror("HZ specification obsolete; delete"); } |
= { timezone = 60 * $2; check_tz(); } |
TIMEZONE NUMBER DST NUMBER
= { timezone = 60 * $2; dst = $4; check_tz(); } |
= { timezone = 60 * $2; dst = 1; check_tz(); } |
= { timezone = $2; check_tz(); } |
TIMEZONE FPNUMBER DST NUMBER
= { timezone = $2; dst = $4; check_tz(); } |
= { timezone = $2; dst = 1; check_tz(); } |
= { timezone = -60 * $3; check_tz(); } |
TIMEZONE MINUS NUMBER DST NUMBER
= { timezone = -60 * $3; dst = $5; check_tz(); } |
TIMEZONE MINUS NUMBER DST
= { timezone = -60 * $3; dst = 1; check_tz(); } |
= { timezone = -$3; check_tz(); } |
TIMEZONE MINUS FPNUMBER DST NUMBER
= { timezone = -$3; dst = $5; check_tz(); } |
TIMEZONE MINUS FPNUMBER DST
= { timezone = -$3; dst = 1; check_tz(); } |
System_id System_parameter_list
= { checksystemspec(*confp); }
System_parameter_list System_parameter
SWAP optional_on swap_device_list
swap_device_list AND swap_device
swap_device_spec optional_size
= { mkswap(*confp, $1, $2); }
struct file_list *fl = newswap();
fl->f_swapdev = nametodev($1, 0, 'b');
fl->f_fn = devtoname(fl->f_swapdev);
struct file_list *fl = newswap();
fl->f_fn = devtoname($1);
ROOT optional_on root_device_spec
struct file_list *fl = *confp;
if (fl && fl->f_rootdev != NODEV)
yyerror("extraneous root device specification");
= { $$ = nametodev($1, 0, 'a'); }
DUMPS optional_on dump_device_spec
struct file_list *fl = *confp;
if (fl && fl->f_dumpdev != NODEV)
yyerror("extraneous dump device specification");
= { $$ = nametodev($1, 0, 'b'); }
ARGS optional_on arg_device_spec
struct file_list *fl = *confp;
if (fl && fl->f_argdev != NODEV)
yyerror("extraneous arg device specification");
= { $$ = nametodev($1, 0, 'b'); }
MAJOR NUMBER MINOR NUMBER
= { $$ = makedev($2, $4); }
(void) sprintf(buf, "%s%d", $1, $2);
(void) sprintf(buf, "%s%d%s", $1, $2, $3);
struct opt *op = (struct opt *)malloc(sizeof (struct opt));
struct opt *op = (struct opt *)malloc(sizeof (struct opt));
= { $$ = val_id = ns($1); } |
= { char nb[16]; $$ = val_id = ns(sprintf(nb, "%d", $1)); };
= { $$ = temp_id = ns($1); }
Mkopt_list COMMA Mkoption
struct opt *op = (struct opt *)malloc(sizeof (struct opt));
DEVICE Dev_name Dev_info Int_spec
= { cur.d_type = DEVICE; } |
MASTER Dev_name Dev_info Int_spec
= { cur.d_type = MASTER; } |
DISK Dev_name Dev_info Int_spec
= { cur.d_dk = 1; cur.d_type = DEVICE; } |
CONTROLLER Dev_name Dev_info Int_spec
= { cur.d_type = CONTROLLER; } |
PSEUDO_DEVICE Init_dev Dev
cur.d_type = PSEUDO_DEVICE;
PSEUDO_DEVICE Init_dev Dev NUMBER
cur.d_type = PSEUDO_DEVICE;
if (eq(cur.d_name, "mba") || eq(cur.d_name, "uba"))
"%s must be connected to a nexus", cur.d_name));
cur.d_conn = connect($2, $3);
= { check_nexus(&cur, $3); cur.d_conn = TO_NEXUS; };
= { cur.d_drive = $2; } |
if (cur.d_conn != 0 && cur.d_conn != TO_NEXUS &&
cur.d_conn->d_type == MASTER)
yyerror("can't specify slave--not to master");
struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
a->id = $1; a->id_next = 0; $$ = a;
struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
a->id = $1; a->id_next = $2; $$ = a;
fprintf(stderr, "config: line %d: %s\n", yyline, s);
* return the passed string in a new space
cp = malloc((unsigned)(strlen(str)+1));
* add a device to the list of devices
register struct device *dp;
register struct device *np;
np = (struct device *) malloc(sizeof *np);
* note that a configuration should be made
register struct file_list *fl, **flp;
fl = (struct file_list *) malloc(sizeof *fl);
for (flp = confp; *flp; flp = &(*flp)->f_next)
struct file_list *fl = (struct file_list *)malloc(sizeof (*fl));
* Add a swap device to the system's configuration
struct file_list *system, *fl;
register struct file_list **flp;
if (system == 0 || system->f_type != SYSTEMSPEC) {
yyerror("\"swap\" spec precedes \"config\" specification");
yyerror("illegal swap partition size");
* Append swap description to the end of the list.
for (; *flp && (*flp)->f_type == SWAPSPEC; flp = &(*flp)->f_next)
* If first swap device for this system,
* set up f_fn field to insure swap
* files are created with unique names.
if (eq(fl->f_fn, "generic"))
system->f_fn = ns(fl->f_fn);
system->f_fn = ns(system->f_needs);
* find the pointer to connect to the given device and number.
* returns 0 if no such device and prints an error message
register struct device *dp;
for (dp = dtab; dp != 0; dp = dp->d_next) {
if ((num != dp->d_unit) || !eq(dev, dp->d_name))
if (dp->d_type != CONTROLLER && dp->d_type != MASTER) {
"%s connected to non-controller", dev));
yyerror(sprintf(errbuf, "%s %d not defined", dev, num));
* connect to an unspecific thing
register struct device *dp, *dcp;
* First make certain that there are some of these to wildcard on
for (dp = dtab; dp != 0; dp = dp->d_next)
yyerror(sprintf(errbuf, "no %s's to wildcard", dev));
* Now see if there is already a wildcard entry for this device
* (e.g. Search for a "uba ?")
for (; dp != 0; dp = dp->d_next)
if (eq(dev, dp->d_name) && dp->d_unit == -1)
* If there isn't, make one because everything needs to be connected
* Connect it to the same thing that other similar things are
* connected to, but make sure it is a wildcard unit
* (e.g. up connected to sc ?, here we make connect sc? to a
* uba?). If other things like this are on the NEXUS or
* if they aren't connected to anything, then make the same
* connection, else call ourself to connect to another
if (dcp == TO_NEXUS || dcp == 0)
dp->d_conn = connect(dcp->d_name, QUES);
register struct device *dp;
dp->d_addr = dp->d_pri = dp->d_flags = dp->d_dk = 0;
dp->d_slave = dp->d_drive = dp->d_unit = UNKNOWN;
* make certain that this is a reasonable type of thing to connect to a nexus
register struct device *dev;
if (!eq(dev->d_name, "uba") && !eq(dev->d_name, "mba"))
yyerror("only uba's and mba's should be connected to the nexus");
yyerror("can't give specific nexus numbers");
if (!eq(dev->d_name, "vba"))
yyerror("only vba's should be connected to the nexus");
* Check the timezone to make certain it is sensible
if (abs(timezone) > 12 * 60)
yyerror("timezone is unreasonable");
* Check system specification and apply defaulting
* rules on root, argument, dump, and swap devices.
register struct file_list *fl;
register struct file_list *swap;
if (fl == 0 || fl->f_type != SYSTEMSPEC) {
yyerror("internal error, bad system specification");
generic = swap && swap->f_type == SWAPSPEC && eq(swap->f_fn, "generic");
if (fl->f_rootdev == NODEV && !generic) {
yyerror("no root device specified");
* Default swap area to be in 'b' partition of root's
* device. If root specified to be other than on 'a'
* partition, give warning, something probably amiss.
if (swap == 0 || swap->f_type != SWAPSPEC) {
"Warning, swap defaulted to 'b' partition with root on '%c' partition",
(minor(dev) & 07) + 'a');
makedev(major(dev), (minor(dev) &~ 07) | ('b' - 'a'));
swap->f_fn = devtoname(swap->f_swapdev);
* Make sure a generic swap isn't specified, along with
* other stuff (user must really be confused).
if (fl->f_rootdev != NODEV)
yyerror("root device specified with generic swap");
if (fl->f_argdev != NODEV)
yyerror("arg device specified with generic swap");
if (fl->f_dumpdev != NODEV)
yyerror("dump device specified with generic swap");
* Default argument device and check for oddball arrangements.
if (fl->f_argdev == NODEV)
fl->f_argdev = swap->f_swapdev;
if (fl->f_argdev != swap->f_swapdev)
yyerror("Warning, arg device different than primary swap");
* Default dump device and warn if place is not a
* swap area or the argument device partition.
if (fl->f_dumpdev == NODEV)
fl->f_dumpdev = swap->f_swapdev;
if (fl->f_dumpdev != swap->f_swapdev && fl->f_dumpdev != fl->f_argdev) {
struct file_list *p = swap->f_next;
for (; p && p->f_type == SWAPSPEC; p = p->f_next)
if (fl->f_dumpdev == p->f_swapdev)
sprintf(buf, "Warning, orphaned dump device, %s",
"do you know what you're doing");
* Verify all devices specified in the system specification
* are present in the device specifications.
register struct file_list *fl;
dev_t checked[50], *verifyswap();
register dev_t *pchecked = checked;
for (fl = conf_list; fl; fl = fl->f_next) {
if (fl->f_type != SYSTEMSPEC)
if (!finddev(fl->f_rootdev))
deverror(fl->f_needs, "root");
*pchecked++ = fl->f_rootdev;
pchecked = verifyswap(fl->f_next, checked, pchecked);
#define samedev(dev1, dev2) \
((minor(dev1) &~ 07) != (minor(dev2) &~ 07))
if (!alreadychecked(fl->f_dumpdev, checked, pchecked)) {
if (!finddev(fl->f_dumpdev))
deverror(fl->f_needs, "dump");
*pchecked++ = fl->f_dumpdev;
if (!alreadychecked(fl->f_argdev, checked, pchecked)) {
if (!finddev(fl->f_argdev))
deverror(fl->f_needs, "arg");
*pchecked++ = fl->f_argdev;
* Do as above, but for swap devices.
verifyswap(fl, checked, pchecked)
register struct file_list *fl;
register dev_t *pchecked;
for (;fl && fl->f_type == SWAPSPEC; fl = fl->f_next) {
if (eq(fl->f_fn, "generic"))
if (alreadychecked(fl->f_swapdev, checked, pchecked))
if (!finddev(fl->f_swapdev))
"config: swap device %s not configured", fl->f_fn);
*pchecked++ = fl->f_swapdev;
* Has a device already been checked
* for it's existence in the configuration?
alreadychecked(dev, list, last)
for (p = list; p < last; p++)
deverror(systemname, devtype)
char *systemname, *devtype;
fprintf(stderr, "config: %s: %s device not configured\n",
* Look for the device in the list of
* configured hardware devices. Must
* take into account stuff wildcarded.
/* punt on this right now */