yconfig.y

<B>Digital的Unix操作系统VAX 4.2源码</B>

		cur.d_name = $3;
		cur.d_type = PSEUDO_DEVICE;
		cur.d_slave = $4;
		} |
	BUS Init_dev Dev
	      = {
		cur.d_name = $3;
		cur.d_type = BUS;
		} |
	BUS Init_dev Dev NUMBER
	      = {
		cur.d_name = $3;
		cur.d_type = BUS;
		cur.d_slave = $4;
		} |
        SHADOW Shad_dev_name ON Shad_const_list  
        ;

Dev_name:
	Init_dev Dev NUMBER
	      = {
		cur.d_name = $2;
		if (eq($2, "mba"))
			seen_mba = 1;
		else if (eq($2, "uba")) {
			seen_uba = 1;
			if ($3 > highuba) {
				highuba = $3;
			}
		}
		cur.d_unit = $3;
		};

Init_dev:
	/* lambda */
	      = { init_dev(&cur); };

Dev_info:
	Con_info Info_list
		|
	/* lambda */
		;

Con_info:
	AT Dev NUMBER
	      = {
		if (must_nexus(cur.d_name))
			yyerror(sprintf(errbuf,
			    "You can not connect a %s to a %s", cur.d_name,$2));
		if ((cur.d_conn = connect($2, $3)) != 0) {
			cur.d_adaptor = cur.d_conn ->d_adaptor;
			cur.d_nexus = cur.d_conn ->d_nexus;
			cur.d_extranum = cur.d_conn->d_extranum;
			if(needs_csr(cur.d_conn->d_name)) {
			    cur.d_addr = cur.d_conn->d_addr;
			    cur.d_conn->d_addr = 0;
			}
			if(needs_vector(cur.d_conn->d_name)){
			    cur.d_vec = cur.d_conn->d_vec;
			    cur.d_conn->d_vec = 0;
			}
		}
		} |
		AT MSCP = {
			/* create a mscp pseudo if it doesn't exist */
			/* and link this one to it */
		    if (first_mscp) {
			struct device tempdev;

		    	init_dev(&tempdev);
	       		tempdev.d_type = CONTROLLER;
			tempdev.d_name = ns("mscp");
			tempdev.d_unit = 0;
			psuedo_controller.d_name = ns("mscp");
		        tempdev.d_conn = &psuedo_controller;
		    	newdev(&tempdev);
			first_mscp = 0;

		    }
		    cur.d_conn = connect("mscp", 0);
		    cur.d_drive = QUES;
		}|
		
	AT NEXUS NUMBER
	      = { check_nexus(&cur, $3); cur.d_conn = TO_NEXUS;
		cur.d_adaptor = cur.d_unit;
		} |
	AT Dev NUMBER NEXUS NUMBER
	      = { if(!(eq($2, "vaxbi") || eq($2, "xmi")||eq($2,"vba")|| eq($2, "ci") || eq($2, "msi")))
			yyerror(sprintf(errbuf,
			 "You can't specify a %s at a(n) %s with a node or nexus number",
			 cur.d_name,$2));
/* hack */
			cur.d_conn = connect($2,$3);
			cur.d_adaptor = $3;
			cur.d_nexus = $5;
			if(needs_pseudo_uba(cur.d_name)) {
			    cur.d_extranum = extrauba++;
			}
		} |
	AT Dev NUMBER REMOTE_CONTROLLER NUMBER
	     =	{
			cur.d_conn = connect($2,$3);
			cur.d_adaptor = $3;
			cur.d_rcntl = $5;
	      	};
		
Info_list:
	Info_list Info
		|
	/* lambda */
		;

Info:
	CSR NUMBER
	      = {     cur.d_addr = $2; } | 
	CSR NUMBER CSR NUMBER NUMBER
	      = { cur.d_addr = $2;
		  cur.d_addr2 = $5;    } |
	DRIVE NUMBER
	      = { cur.d_drive = $2;    } |
	SLAVE NUMBER
	      = {
		if (cur.d_conn != 0 && cur.d_conn != TO_NEXUS &&
		     cur.d_conn->d_type == MASTER)
			cur.d_slave = $2;
		else
			yyerror("can't specify slave--not to master");
		} |
	FLAGS NUMBER
	      = { cur.d_flags = $2; };

Int_spec:
	VECTOR Id_list
	      = { cur.d_vec = $2;   } |
	VECTOR Id_list NUMBER
	      = { cur.d_vec = $2;
		  cur.d_ivnum = $3; } |
	PRIORITY NUMBER 
	      = { cur.d_pri = $2;   } |
	PRIORITY NUMBER VECTOR Id_list
	      = { cur.d_pri = $2;
		  cur.d_vec = $4;   } |
	PRIORITY NUMBER VECTOR Id_list NUMBER
	      = { cur.d_pri = $2;
		  cur.d_vec = $4;
		  cur.d_ivnum = $5; } |
	/* lambda */
		;

Id_list:
	Save_id
	      = {
		struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
		a->id = $1; a->id_next = 0; $$ = a;
		} |
	Save_id Id_list =
		{
		struct idlst *a = (struct idlst *)malloc(sizeof(struct idlst));
	        a->id = $1; a->id_next = $2; $$ = a;
		};

Shad_dev_name:
	device_name
              = {
                mk_shaddev($1);
                }
        ;

Shad_const_list:
	Shad_const_list AND Shad_const
      | Shad_const 
        ;

Shad_const:
	device_name
              = { 
                add_shaddev($1); 
                }
	;   

%%

yyerror(s)
	char *s;
{

	fprintf(stderr, "config: line %d: %s\n", yyline, s);
}

/*
 * return the passed string in a new space
 */
char *
ns(str)
	register char *str;
{
	register char *cp;

	cp = malloc((unsigned)(strlen(str)+1));
	(void) strcpy(cp, str);
	return (cp);
}

/*
 * add a device to the list of devices
 */
newdev(dp)
	register struct device *dp;
{
	register struct device *np;

	np = (struct device *) malloc(sizeof *np);
	*np = *dp;
	if (curp == 0)
		dtab = np;
	else
		curp->d_next = np;
	curp = np;
}

/*
 * note that a configuration should be made
 */
mkconf(sysname)
	char *sysname;
{
	register struct file_list *fl, **flp;
	int i;

	fl = (struct file_list *) malloc(sizeof *fl);
	fl->f_type = SYSTEMSPEC;
	fl->f_needs[0] = sysname;
	for (i = 1; i < NNEEDS; i++) {
		fl->f_needs[i] = 0;
	}
	fl->f_rootdev = NODEV;
	fl->f_dumpdev = NODEV;
	fl->f_fn = 0;
	fl->f_next = 0;
	for (flp = confp; *flp; flp = &(*flp)->f_next)
		;
	*flp = fl;
	confp = flp;
}

struct file_list *
newswap()
{
	struct file_list *fl = (struct file_list *)malloc(sizeof (*fl));
	int i;

	fl->f_type = SWAPSPEC;
	fl->f_next = 0;
	fl->f_swapdev = NODEV;
	fl->f_swapsize = 0;
	for (i = 0; i < NNEEDS; i++) {
		fl->f_needs[i] = 0;
	}
	fl->f_fn = 0;
	return (fl);
}

/*
 * Add a swap device to the system's configuration
 */
mkswap(system, fl, size)
	struct file_list *system, *fl;
	int size;
{
	register struct file_list **flp;
	char *cp, name[80];

	if (system == 0 || system->f_type != SYSTEMSPEC) {
		yyerror("\"swap\" spec precedes \"config\" specification");
		return;
	}
	if (size < 0) {
		yyerror("illegal swap partition size");
		return;
	}
	/*
	 * Append swap description to the end of the list.
	 */
	flp = &system->f_next;
	for (; *flp && (*flp)->f_type == SWAPSPEC; flp = &(*flp)->f_next)
		;
	fl->f_next = *flp;
	*flp = fl;
	/*
	 * If first swap device for this system,
	 * set up f_fn field to insure swap
	 * files are created with unique names.
	 */
	if (system->f_fn)
		return;
	if (eq(fl->f_fn, "generic") || eq(fl->f_fn, "boot") || eq(fl->f_fn, "none"))
		system->f_fn = ns(fl->f_fn);
	else
		system->f_fn = ns(system->f_needs[0]);
}

/*
 * find the pointer to connect to the given device and number.
 * returns 0 if no such device and prints an error message
 */
struct device *
connect(dev, num)
	register char *dev;
	register int num;
{
	register struct device *dp;
	struct device *huhcon();

	if (num == QUES)
		return (huhcon(dev));
	for (dp = dtab; dp != 0; dp = dp->d_next) {
		if ((num != dp->d_unit) || !eq(dev, dp->d_name))
			continue;
		if (dp->d_type != CONTROLLER && dp->d_type != MASTER){
			yyerror(sprintf(errbuf,
			    "%s connected to non-controller", dev));
			return (0);
		}
		return (dp);
	}
	yyerror(sprintf(errbuf, "%s %d not defined", dev, num));
	return (0);
}

/*
 * connect to an unspecific thing
 */
struct device *
huhcon(dev)
	register char *dev;
{
	register struct device *dp, *dcp;
	struct device rdev;
	int oldtype;

	/*
	 * First make certain that there are some of these to wildcard on
	 */
	for (dp = dtab; dp != 0; dp = dp->d_next)
		if (eq(dp->d_name, dev))
			break;
	if (dp == 0) {
		yyerror(sprintf(errbuf, "no %s's to wildcard", dev));
		return (0);
	}
	oldtype = dp->d_type;
	dcp = dp->d_conn;
	/*
	 * Now see if there is already a wildcard entry for this device
	 * (e.g. Search for a "uba ?")
	 */
	if(dp->d_unit != -1)
	for (; dp != 0; dp = dp->d_next)
		if (eq(dev, dp->d_name) && dp->d_unit == -1)
			break;
	/*
	 * If there isn't, make one because everything needs to be connected
	 * to something.
	 */
	if (dp == 0) {
		dp = &rdev;
		init_dev(dp);
		dp->d_unit = QUES;
		dp->d_adaptor = dp->d_nexus = QUES;
		dp->d_name = ns(dev);
		dp->d_type = oldtype;
		dp->d_next = 0;
		newdev(dp);
		dp = curp;
		/*
		 * 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
		 * unspecific device.
		 */
		if (dcp == TO_NEXUS || dcp == 0)
			dp->d_conn = dcp;
		else
			dp->d_conn = connect(dcp->d_name, QUES);
	}
	return (dp);
}

init_dev(dp)
	register struct device *dp;
{

	dp->d_name = "OHNO!!!";
	dp->d_type = DEVICE;
	dp->d_conn = 0;
	dp->d_vec = 0;
	dp->d_addr = dp->d_addr2 = dp->d_ivnum = 0;
        dp->d_pri = dp->d_flags = dp->d_dk = 0;
	dp->d_slave = dp->d_drive = dp->d_unit = UNKNOWN;
	dp->d_adaptor = dp->d_nexus = dp->d_extranum = UNKNOWN;
}

/*
 * make certain that this is a reasonable type of thing to connect to a nexus
 */
check_nexus(dev, num)
	register struct device *dev;
	int num;
{

	switch (machine) {

	case MACHINE_VAX:
	    	if(!can_nexus(dev->d_name))
			yyerror("only vba's, uba's, mba's, xmi's, and vaxbi's should be connected to the nexus");
		if (num != QUES)
			yyerror("can't give specific nexus numbers");
		break;

	case MACHINE_SUN:
		if (!eq(dev->d_name, "mb"))
			yyerror("only mb's should be connected to the nexus");
		break;
	}
}

/*
 * Check the timezone to make certain it is sensible
 */

check_tz()
{
	if (abs(timezone) > 12 * 60)
		yyerror("timezone is unreasonable");
	else
		hadtz = 1;
}

/*
 * Check system specification and apply defaulting
 * rules on root, dump, and swap devices.
 */
checksystemspec(fl)
	register struct file_list *fl;
{
	char buf[BUFSIZ];
	register struct file_list *swap;
	int generic;

	if (fl == 0 || fl->f_type != SYSTEMSPEC) {
		yyerror("internal error, bad system specification");
		exit(1);
	}
	swap = fl->f_next;
	generic = swap && swap->f_type == SWAPSPEC &&
			(eq(swap->f_fn, "generic") || eq(swap->f_fn, "boot"));
	if (fl->f_rootdev == NODEV && !generic) {
		yyerror("no root device specified");
		exit(1);
	}
	/*
	 * 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) {
		dev_t dev;

		swap = newswap();
		dev = fl->f_rootdev;
		if (minor(dev) & 07) {
			sprintf(buf, 
"Warning, swap defaulted to 'b' partition with root on '%c' partition",
				(minor(dev) & 07) + 'a');
			yyerror(buf);
		}
		swap->f_swapdev =
		   makedev(major(dev), (minor(dev) &~ 07) | ('b' - 'a'));
		swap->f_fn = devtoname(swap->f_swapdev);
		mkswap(fl, swap, 0);
	}
	/*
	 * Make sure a generic swap isn't specified, along with
	 * other stuff (user must really be confused).
	 */
	if (generic) {
		if (fl->f_rootdev != NODEV) {
			sprintf(buf, "root device specified with %s swap",
					fl->f_fn);
			yyerror(buf);
		}
		if (fl->f_dumpdev != NODEV) {
			sprintf(buf, "dump device specified with %s swap",
					fl->f_fn);
			yyerror(buf);
		}
		return;
	}
	/*
	 * Default dump device and warn if place is not a
	 * swap area
	 */
	if (fl->f_dumpdev == NODEV)
		fl->f_dumpdev = swap->f_swapdev;
	if (fl->f_dumpdev != swap->f_swapdev) {
		struct file_list *p = swap->f_next;

		for (; p && p->f_type == SWAPSPEC; p = p->f_next)
			if (fl->f_dumpdev == p->f_swapdev)
				return;
		sprintf(buf, "Warning, orphaned dump device, %s",
			"do you know what you're doing");
		yyerror(buf);
	}
}

/*
 * Verify all devices specified in the system specification
 * are present in the device specifications.
 */
verifysystemspecs()
{
	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)
			continue;
		if (!finddev(fl->f_rootdev))
			deverror(fl->f_needs[0], "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[0], "dump");
			*pchecked++ = fl->f_dumpdev;
		}
	}
}

/*
 * Do as above, but for swap devices.
 */
dev_t *
verifyswap(fl, checked, pchecked)
	register struct file_list *fl;
	dev_t checked[];
	register dev_t *pchecked;
{

	for (;fl && fl->f_type == SWAPSPEC; fl = fl->f_next) {
		if (eq(fl->f_fn, "generic") || eq(fl->f_fn, "boot")||
			eq(fl->f_fn, "none"))
			continue;
		if (alreadychecked(fl->f_swapdev, checked, pchecked))
			continue;
		if (!finddev(fl->f_swapdev))
			fprintf(stderr,
			   "config: swap device %s not configured", fl->f_fn);
		*pchecked++ = fl->f_swapdev;
	}
	return (pchecked);
}

/*
 * Has a device already been checked
 * for it's existence in the configuration?
 */
alreadychecked(dev, list, last)
	dev_t dev, list[];
	register dev_t *last;
{
	register dev_t *p;

	for (p = list; p < last; p++)
		if (samedev(*p, dev))
			return (1);
	return (0);
}

deverror(systemname, devtype)
	char *systemname, *devtype;
{

	fprintf(stderr, "config: %s: %s device not configured\n",
		systemname, devtype);
}

/*
 * Look for the device in the list of
 * configured hardware devices.  Must
 * take into account stuff wildcarded.
 */
finddev(dev)
	dev_t dev;
{

	/* punt on this right now */
	return (1);
}

char *tbl_pseudo_uba[] = { "kdb", "kdm", "klesib", 0 } ;
 
/*
 * look up this device in a table to see if it needs a pseudo_uba.
 */
needs_pseudo_uba(str)
register	char	*str;
{
	register	char	**ptr = tbl_pseudo_uba;

	while(*ptr) if(!strcmp(str,*ptr++)) return(1);
	
	return(0);
}

char *tbl_must_nexus[] = { "mba", "vaxbi", "ci",  "xmi", "ibus", "vba", 0 };

/*
 * See if the device must be connected to a nexus
 */
must_nexus(str)
register	char	*str;
{
	register	char	**ptr = tbl_must_nexus;

	while(*ptr) if(!strcmp(str,*ptr++)) return(1);
	
	return(0);
}

char *tbl_can_nexus[] = { "uba", "mba", "vaxbi", "ci", "xmi", "msi","ibus", "vba", 0 };


/*
 * See if the device can be connected to a nexus
 */
can_nexus(str)
register	char	*str;
{
	register	char	**ptr = tbl_can_nexus;

	while(*ptr) if(!strcmp(str,*ptr++)) return(1);
	
	return(0);
}


/*
 * If a shadow device is used for storing the root file system, we
 * create a configuration data structure that will indicate the shadow
 * device and the associated physical devices.
 */
mk_shaddev(name)
register char *name;
{
    register struct shad_device *sp;

    sp = (struct shad_device *) malloc(sizeof *sp);

    sp->next_shad = NULL;
    sp->shad_devt = shadnametodev(name, 1, 'a'); 
    sp->num_of_const = 0;

    if ( cur_shadp == 0 ) {
        shad_tabp = sp;        
    }
    else {
        cur_shadp->next_shad = sp;
    }

    cur_shadp = sp;
}

/*
 * This function records the additional constituents of the shadow set.
 */
add_shaddev(name)
register char *name;
{
    register int i;

    i = cur_shadp->num_of_const;
    cur_shadp->constituents[i] = nametodev(name, 1, 'a');
    cur_shadp->num_of_const++;

}