/*	$OpenBSD: sem.c,v 1.36 2015/12/14 05:59:56 mmcc Exp $	*/

/*	$NetBSD: sem.c,v 1.10 1996/11/11 23:40:11 gwr Exp $	*/

/*

 * Copyright (c) 1992, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * This software was developed by the Computer Systems Engineering group

 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and

 * contributed to Berkeley.

 *

 * All advertising materials mentioning features or use of this software

 * must display the following acknowledgement:

 *	This product includes software developed by the University of

 *	California, Lawrence Berkeley Laboratories.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 *	from: @(#)sem.c	8.1 (Berkeley) 6/6/93

 */

#include <sys/param.h>	/* NODEV */

#include <ctype.h>

#include <err.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "config.h"

#include "sem.h"

/*

 * config semantics.

 */

#define	NAMESIZE	100	/* local name buffers */

const char *s_generic;

const char *s_nfs;

static struct hashtab *attrtab;		/* for attribute lookup */

static struct hashtab *cfhashtab;	/* for config lookup */

static struct hashtab *devitab;		/* etc */

static struct attr errattr;

static struct devbase errdev;

static struct deva errdeva;

static struct devbase **nextbase;

static struct deva **nextdeva;

static struct config **nextcf;

static struct devi **nextdevi;

static struct devi **nextpseudo;

static int has_errobj(struct nvlist *, void *);

static struct nvlist *addtoattr(struct nvlist *, struct devbase *);

static int exclude(struct nvlist *, const char *, const char *);

static int resolve(struct nvlist **, const char *, const char *,

    struct nvlist *, int);

static int lresolve(struct nvlist **, const char *, const char *,

    struct nvlist *, int);

static struct devi *newdevi(const char *, int, struct devbase *d);

static struct devi *getdevi(const char *);

static const char *concat(const char *, int);

static char *extend(char *, const char *);

static int split(const char *, size_t, char *, size_t, int *);

static void selectbase(struct devbase *, struct deva *);

static int onlist(struct nvlist *, void *);

static const char **fixloc(const char *, struct attr *, struct nvlist *);

void

initsem(void)

{

}

/* Name of include file just ended (set in scan.l) */

extern const char *lastfile;

void

enddefs(void)

{

	struct devbase *dev;

			    "%s: device `%s' used but not defined\n",

		}

	}

	}

}

void

setdefmaxusers(int min, int def, int max)

{

	else {

	}

}

void

setmaxusers(int n)

{

	}

	}

}

/*

 * Define an attribute, optionally with an interface (a locator list).

 * Since an empty locator list is logically different from "no interface",

 * all locator lists include a dummy head node, which we discard here.

 */

int

defattr(const char *name, struct nvlist *locs)

{

	struct attr *a;

	struct nvlist *nv;

	int len;

	}

	}

	len = 0;

}

/*

 * Return true if the given `error object' is embedded in the given

 * pointer list.

 */

static int

has_errobj(struct nvlist *nv, void *obj)

{

}

/*

 * Add a device base to a list in an attribute (actually, to any list).

 * Note that this does not check for duplicates, and does reverse the

 * list order, but no one cares anyway.

 */

static struct nvlist *

addtoattr(struct nvlist *l, struct devbase *dev)

{

	struct nvlist *n;

}

/*

 * Define a device.  This may (or may not) also define an interface

 * attribute and/or refer to existing attributes.

 */

void

defdev(struct devbase *dev, int ispseudo, struct nvlist *loclist,

    struct nvlist *attrs)

{

	struct nvlist *nv;

	struct attr *a;

		goto bad;

	}

		goto bad;

	/*

	 * Handle implicit attribute definition from locator list.  Do

	 * this before scanning the `at' list so that we can have, e.g.:

	 *	device foo at other, foo { slot = -1 }

	 * (where you can plug in a foo-bus extender to a foo-bus).

	 */

		nv = loclist;

		loclist = NULL;	/* defattr disposes of them for us */

			goto bad;

		    attrs);

	}

	/* Committed!  Set up fields. */

	/*

	 * For each interface attribute this device refers to, add this

	 * device to its reference list.  This makes, e.g., finding all

	 * "scsi"s easier.

	 */

	}

bad:

}

/*

 * Look up a devbase.  Also makes sure it is a reasonable name,

 * i.e., does not end in a digit or contain special characters.

 */

struct devbase *

getdevbase(char *name)

{

	u_char *p;

	struct devbase *dev;

	p = (u_char *)name;

		goto badname;

			goto badname;

	}

badname:

	}

	}

}

/*

 * Define some of a device's allowable parent attachments.

 * There may be a list of (plain) attributes.

 */

void

defdevattach(struct deva *deva, struct devbase *dev, struct nvlist *atlist,

    struct nvlist *attrs)

{

	struct nvlist *nv;

	struct attr *a;

	struct deva *da;

		goto bad;

		goto bad;

	}

	}

	}

		goto bad;

			continue;		/* already complained */

	}

	/* Committed!  Set up fields. */

	/*

	 * Turn the `at' list into interface attributes (map each

	 * nv_name to an attribute, or to NULL for root), and add

	 * this device to those attributes, so that children can

	 * be listed at this particular device if they are supported

	 * by that attribute.

	 */

		else

			continue;		/* already complained */

		/*

		 * Make sure that an attachment spec doesn't

		 * already say how to attach to this attribute.

		 */

			continue;		/* at root; don't add */

		else

	}

	/* attach to parent */

bad:

}

/*

 * Look up a device attachment.  Also makes sure it is a reasonable

 * name, i.e., does not contain digits or special characters.

 */

struct deva *

getdevattach(const char *name)

{

	u_char *p;

	struct deva *deva;

	p = (u_char *)name;

		goto badname;

			goto badname;

	}

badname:

	}

	}

}

/*

 * Look up an attribute.

 */

struct attr *

getattr(const char *name)

{

	struct attr *a;

		a = &errattr;

	}

}

/*

 * Set the major device number for a device, so that it can be used

 * as a root/swap/dumps "on" device in a configuration.

 */

void

setmajor(struct devbase *d, int n)

{

	else

}

static int

exclude(struct nvlist *nv, const char *name, const char *what)

{

	}

}

/*

 * Map things like "ra0b" => makedev(major("ra"), 0*maxpartitions + 'b'-'a').

 * Handle the case where the device number is given but there is no

 * corresponding name, and map NULL to the default.

 */

static int

resolve(struct nvlist **nvp, const char *name, const char *what,

    struct nvlist *dflt, int part)

{

	struct nvlist *nv;

	struct devbase *dev;

	const char *cp;

	int maj, min, l;

		dev_t	d = NODEV;

		/*

		 * Apply default.  Easiest to do this by number.

		 * Make sure to retain NODEVness, if this is dflt's disposition.

		 */

		}

	}

		/*

		 * By the numbers.  Find the appropriate major number

		 * to make a name.

		 */

				break;

			    maj, min);

		else

	}

		/*

		 * NFS spec. Leave as NODEV.

		 */

	/*

	 * The normal case: things like "ra2b".  Check for partition

	 * suffix, remove it if there, and split into name ("ra") and

	 * unit (2).

	 */

	}

	}

	}

}

static int

lresolve(struct nvlist **nvp, const char *name, const char *what,

    struct nvlist *dflt, int part)

{

	int err;

		nvp = &(*nvp)->nv_next;

}

/*

 * Add a completed configuration to the list.

 */

void

addconf(struct config *cf0)

{

	struct config *cf;

	struct nvlist *nv;

	const char *name;

	}

	/*

	 * Look for "swap generic".

	 */

		break;

		/*

		 * Make sure no root or dump device specified, and no

		 * other swap devices.  Note single | here (check all).

		 */

			goto bad;

	} else {

		}

			goto bad;

	}

bad:

}

void

setconf(struct nvlist **npp, const char *what, struct nvlist *v)

{

}

static struct devi *

newdevi(const char *name, int unit, struct devbase *d)

{

	struct devi *i;

}

/*

 * Enable an already declared but disabled device.

 */

void

enabledev(const char *name, const char *at)

{

	struct devbase *ib, *ab;

	struct attr *attr;

	struct nvlist *nv;

	struct devi *i;

	const char *cp;

	}

	}

	}

			goto foundattachment;

	}

foundattachment:

	} else

}

/*

 * Add the named device as attaching to the named attribute (or perhaps

 * another device instead) plus unit number.

 */

void

adddev(const char *name, const char *at, struct nvlist *loclist, int flags,

    int disable)

{

	struct devi *i;	/* the new instance */

	struct attr *attr;	/* attribute that allows attach */

	struct devbase *ib;	/* i->i_base */

	struct devbase *ab;	/* not NULL => at another dev */

	struct nvlist *nv;

	struct deva *iba;	/* devbase attachment used */

	const char *cp;

	int hit;

	ab = NULL;

	iba = NULL;

		/* "at root" */

			goto bad;

		/*

		 * Must warn about i_unit > 0 later, after taking care of

		 * the STAR cases (we could do non-star's here but why

		 * bother?).  Make sure this device can be at root.

		 */

		hit = 0;

				hit = 1;

			}

		}

		attr = &errattr;	/* a convenient "empty" attr */

			/* (void)getdevi(name); -- ??? */

		}

			goto bad;

		/*

		 * Devices can attach to two types of things: Attributes,

		 * and other devices (which have the appropriate attributes

		 * to allow attachment).

		 *

		 * (1) If we're attached to an attribute, then we don't need

		 *     look at the parent base device to see what attributes

		 *     it has, and make sure that we can attach to them.

		 *

		 * (2) If we're attached to a real device (i.e. named in

		 *     the config file), we want to remember that so that

		 *     at cross-check time, if the device we're attached to

		 *     is missing but other devices which also provide the

		 *     attribute are present, we don't get a false "OK."

		 *

		 * (3) If the thing we're attached to is an attribute

		 *     but is actually named in the config file, we still

		 *     have to remember its devbase.

		 */

		/* Figure out parent's devbase, to satisfy case (3). */

		/* Find out if it's an attribute. */

		/* Make sure we're _really_ attached to the attr.  Case (1). */

			goto findattachment;

		/*

		 * Else a real device, and not just an attribute.  Case (2).

		 *

		 * Have to work a bit harder to see whether we have

		 * something like "tg0 at esp0" (where esp is merely

		 * not an attribute) or "tg0 at nonesuch0" (where

		 * nonesuch is not even a device).

		 */

			    name, at, atbuf);

		}

		/*

		 * See if the named parent carries an attribute

		 * that allows it to supervise device ib.

		 */

				goto findattachment;

		}

findattachment:

		/* find out which attachment it uses */

		hit = 0;

				hit = 1;

			}

	}

		goto bad;

	/* all done, fall into ... */

bad:

	return;

}

void

addpseudo(const char *name, int number, int disable)

{

	struct devbase *d;

	struct devi *i;

	}

	}

	}

}

/*

 * Define a new instance of a specific device.

 */

static struct devi *

getdevi(const char *name)

{

	struct devi *i, *firsti;

	struct devbase *d;

	}

	}

	}

			firsti = firsti->i_alias;

	}

}

static const char *

concat(const char *name, int c)

{

	size_t len;

		len = sizeof(buf) - 2;

	}

}

const char *

starref(const char *name)

{

}

const char *

wildref(const char *name)

{

}

/*

 * Split a name like "foo0" into base name (foo) and unit number (0).