all 330 changes

Change-Id: I1728e08622dbdec9bd1e37a9ba6afff80e8fb847

bin/Makefile

@@ -1,7 +1,7 @@
 #	$NetBSD: Makefile,v 1.22 2007/12/31 15:31:24 ad Exp $
 #	@(#)Makefile	8.1 (Berkeley) 5/31/93
 
-SUBDIR=	cat date echo ed expr kill ksh ln ls \
+SUBDIR=	cat date df echo ed expr kill ksh ln ls \
 	mkdir pax pwd rm rmdir sync test
 
 .include <bsd.subdir.mk>

bin/cat/cat.1

@@ -1,4 +1,4 @@
-.\"	$NetBSD: cat.1,v 1.32 2006/09/23 11:24:44 wiz Exp $
+.\"	$NetBSD: cat.1,v 1.34 2012/08/09 07:26:28 dholland Exp $
 .\"
 .\" Copyright (c) 1989, 1990, 1993
 .\"	The Regents of the University of California.  All rights reserved.
@@ -32,7 +32,7 @@
 .\"
 .\"     @(#)cat.1	8.3 (Berkeley) 5/2/95
 .\"
-.Dd September 23, 2006
+.Dd April 6, 2012
 .Dt CAT 1
 .Os
 .Sh NAME
@@ -54,6 +54,9 @@ A single dash represents the standard input,
 and may appear multiple times in the
 .Ar file
 list.
+If no
+.Ar file
+operands are given, standard input is read.
 .Pp
 The word
 .Dq concatenate
@@ -65,7 +68,7 @@ The options are as follows:
 .It Fl b
 Implies the
 .Fl n
-option but doesn't number blank lines.
+option, but doesn't number blank lines.
 .It Fl e
 Implies the
 .Fl v
@@ -139,7 +142,7 @@ to the file
 truncating
 .Ar file3
 if it already exists.
-See the manual page for your shell (i.e.,
+See the manual page for your shell (e.g.,
 .Xr sh 1 )
 for more information on redirection.
 .Pp

bin/cat/cat.c

@@ -1,4 +1,4 @@
-/* $NetBSD: cat.c,v 1.47 2008/07/20 00:52:39 lukem Exp $	*/
+/* $NetBSD: cat.c,v 1.48 2012/03/17 23:35:28 christos Exp $	*/
 
 /*
  * Copyright (c) 1989, 1993
@@ -44,7 +44,7 @@ __COPYRIGHT(
 #if 0
 static char sccsid[] = "@(#)cat.c	8.2 (Berkeley) 4/27/95";
 #else
-__RCSID("$NetBSD: cat.c,v 1.47 2008/07/20 00:52:39 lukem Exp $");
+__RCSID("$NetBSD: cat.c,v 1.48 2012/03/17 23:35:28 christos Exp $");
 #endif
 #endif /* not lint */
 
@@ -295,8 +295,8 @@ raw_cat(int rfd)
 	if (buf == NULL) {
 		struct stat sbuf;
 
-		if (fstat(wfd, &sbuf) == 0 &&
+		if (fstat(wfd, &sbuf) == 0 && sbuf.st_blksize > 0 &&
-		    sbuf.st_blksize > sizeof(fb_buf)) {
+		    (size_t)sbuf.st_blksize > sizeof(fb_buf)) {
 			bsize = sbuf.st_blksize;
 			buf = malloc(bsize);
 		}

bin/df/Makefile

@@ -0,0 +1,11 @@
+#	$NetBSD: Makefile,v 1.19 2011/08/28 08:20:58 christos Exp $
+#	@(#)Makefile	8.3 (Berkeley) 5/8/95
+
+.include <bsd.own.mk>
+
+PROG=	df
+
+LDADD+=-lutil
+DPADD+=${LIBUTIL}
+
+.include <bsd.prog.mk>

bin/df/df.1

@@ -0,0 +1,206 @@
+.\"	$NetBSD: df.1,v 1.44 2010/04/05 21:17:28 joerg Exp $
+.\"
+.\" Copyright (c) 1989, 1990, 1993
+.\"	The Regents of the University of California.  All rights reserved.
+.\"
+.\" 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.
+.\"
+.\"	@(#)df.1	8.2 (Berkeley) 1/13/92
+.\"
+.Dd March 4, 2008
+.Dt DF 1
+.Os
+.Sh NAME
+.Nm df
+.Nd display free disk space
+.Sh SYNOPSIS
+.Nm
+.Op Fl agklmn
+.Op Fl G | Fl i | Fl P
+.Op Fl t Ar type
+.Op Ar file | Ar file_system ...
+.Sh DESCRIPTION
+.Nm
+displays statistics about the amount of free disk space on the specified
+.Ar file_system
+or on the file system of which
+.Ar file
+is a part.
+By default, all sizes are reported in 512-byte block counts.
+If neither a file or a
+.Ar file_system
+operand is specified,
+statistics for all mounted file systems are displayed
+(subject to the
+.Fl l
+and
+.Fl t
+options below).
+.Pp
+Note that the printed count of available blocks takes
+.Va minfree
+into account, and thus will be negative when the number of free blocks
+on the filesystem is less than
+.Va minfree .
+.Pp
+The following options are available:
+.Bl -tag -width Ds
+.It Fl a
+Show all mount points,
+including those that were mounted with the
+.Dv MNT_IGNORE
+flag.
+.It Fl G
+Display all the fields of the structure(s) returned by
+.Xr statvfs 2 .
+This option cannot be used with the
+.Fl i
+or
+.Fl P
+options, and it is modelled after the Solaris
+.Fl g
+option.
+This option will override the
+.Fl g ,
+.Fl h ,
+.Fl k ,
+and
+.Fl m
+options, as well as any setting of
+.Ev BLOCKSIZE .
+.It Fl g
+The
+.Fl g
+option causes the numbers to be reported in gigabytes (1024*1024*1024
+bytes).
+.It Fl h
+"Human-readable" output.
+Use unit suffixes: Byte, Kilobyte, Megabyte,
+Gigabyte, Terabyte, Petabyte, Exabyte in order to reduce the number of
+digits to four or less.
+.It Fl i
+Include statistics on the number of free inodes.
+.It Fl k
+By default, all sizes are reported in 512-byte block counts.
+The
+.Fl k
+option causes the numbers to be reported in kilobytes (1024 bytes).
+.It Fl l
+Display statistics only about mounted file systems with the
+.Dv MNT_LOCAL
+flag set.
+If a non-local file system is given as an argument, a
+warning is issued and no information is given on that file system.
+.It Fl m
+The
+.Fl m
+option causes the numbers to be reported in megabytes (1024*1024 bytes).
+.It Fl n
+Print out the previously obtained statistics from the file systems.
+This option should be used if it is possible that one or more
+file systems are in a state such that they will not be able to provide
+statistics without a long delay.
+When this option is specified,
+.Nm
+will not request new statistics from the file systems, but will respond
+with the possibly stale statistics that were previously obtained.
+.It Fl P
+Produce output in the following portable format:
+.Pp
+If both the
+.Fl P
+and
+.Fl k
+option are specified, the output will be preceded by the following header
+line, formatted to match the data following it:
+.Bd -literal
+"Filesystem 1024-blocks Used Available Capacity Mounted on\en"
+.Ed
+.Pp
+If the
+.Fl P
+option is specified without the
+.Fl k
+options, the output will be preceded by the following header line,
+formatted to match the data following it:
+.Bd -literal
+"Filesystem \*[Lt]blksize\*[Gt]-blocks Used Available Capacity Mounted on\en"
+.Ed
+.Pp
+The header line is followed by data formatted as follows:
+.Bd -literal
+"%s %d %d %d %d%% %s\en", \*[Lt]file system name\*[Gt], \*[Lt]total space\*[Gt],
+    \*[Lt]space used\*[Gt], \*[Lt]space free\*[Gt], \*[Lt]percentage used\*[Gt],
+    \*[Lt]file system root\*[Gt]
+.Ed
+.Pp
+Note that the
+.Fl i
+option may not be specified with
+.Fl P .
+.It Fl t Ar type
+Is used to indicate the actions should only be taken on
+filesystems of the specified type.
+More than one type may be specified in a comma-separated list.
+The list of filesystem types can be prefixed with
+.Dq no
+to specify the filesystem types for which action should
+.Em not
+be taken.
+If a file system is given on the command line that is not of
+the specified type, a warning is issued and no information is given on
+that file system.
+.El
+.Sh ENVIRONMENT
+.Bl -tag -width BLOCKSIZE
+.It Ev BLOCKSIZE
+If the environment variable
+.Ev BLOCKSIZE
+is set, and the
+.Fl g ,
+.Fl h ,
+.Fl k
+and
+.Fl m
+options are not specified, the block counts will be displayed in units of that
+size block.
+.El
+.Sh SEE ALSO
+.Xr quota 1 ,
+.Xr fstatvfs 2 ,
+.Xr getvfsstat 2 ,
+.Xr statvfs 2 ,
+.Xr getbsize 3 ,
+.Xr getmntinfo 3 ,
+.Xr fs 5 ,
+.Xr fstab 5 ,
+.Xr mount 8 ,
+.Xr quot 8 ,
+.Xr tunefs 8
+.Sh HISTORY
+A
+.Nm
+utility appeared in
+.At v6 .

bin/df/df.c

@@ -0,0 +1,520 @@
+/*	$NetBSD: df.c,v 1.90 2012/01/07 18:45:13 christos Exp $ */
+
+/*
+ * Copyright (c) 1980, 1990, 1993, 1994
+ *	The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * 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.
+ */
+
+#include <sys/cdefs.h>
+#ifndef lint
+__COPYRIGHT(
+"@(#) Copyright (c) 1980, 1990, 1993, 1994\
+ The Regents of the University of California.  All rights reserved.");
+#endif /* not lint */
+
+#ifndef lint
+#if 0
+static char sccsid[] = "@(#)df.c	8.7 (Berkeley) 4/2/94";
+#else
+__RCSID("$NetBSD: df.c,v 1.90 2012/01/07 18:45:13 christos Exp $");
+#endif
+#endif /* not lint */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+
+#include <assert.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <locale.h>
+#include <util.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <util.h>
+
+static char	*getmntpt(const char *);
+static void	 prtstat(struct statvfs *, int);
+static int	 selected(const char *, size_t);
+static void	 maketypelist(char *);
+static size_t	 regetmntinfo(struct statvfs **, size_t);
+__dead static void usage(void);
+static void	 prthumanval(int64_t, const char *);
+static void	 prthuman(struct statvfs *, int64_t, int64_t);
+
+static int	 aflag, gflag, hflag, iflag, lflag, nflag, Pflag;
+static long	 usize;
+static char	**typelist;
+
+int
+main(int argc, char *argv[])
+{
+	struct stat stbuf;
+	struct statvfs *mntbuf;
+	long mntsize;
+	int ch, i, maxwidth, width;
+	char *mntpt;
+
+	setprogname(argv[0]);
+	(void)setlocale(LC_ALL, "");
+
+	while ((ch = getopt(argc, argv, "aGghiklmnPt:")) != -1)
+		switch (ch) {
+		case 'a':
+			aflag = 1;
+			break;
+		case 'g':
+			hflag = 0;
+			usize = 1024 * 1024 * 1024;
+			break;
+		case 'G':
+			gflag = 1;
+			break;
+		case 'h':
+			hflag = 1;
+			usize = 0;
+			break;
+		case 'i':
+			iflag = 1;
+			break;
+		case 'k':
+			hflag = 0;
+			usize = 1024;
+			break;
+		case 'l':
+			lflag = 1;
+			break;
+		case 'm':
+			hflag = 0;
+			usize = 1024 * 1024;
+			break;
+		case 'n':
+			nflag = 1;
+			break;
+		case 'P':
+			Pflag = 1;
+			break;
+		case 't':
+			if (typelist != NULL)
+				errx(EXIT_FAILURE,
+				    "only one -t option may be specified.");
+			maketypelist(optarg);
+			break;
+		case '?':
+		default:
+			usage();
+		}
+
+	if (gflag && (Pflag || iflag))
+		errx(EXIT_FAILURE,
+		    "only one of -G and -P or -i may be specified");
+	if (Pflag && iflag)
+		errx(EXIT_FAILURE,
+		    "only one of -P and -i may be specified");
+#if 0
+	/*
+	 * The block size cannot be checked until after getbsize() is called.
+	 */
+	if (Pflag && (hflag || (usize != 1024 && usize != 512)))
+		errx(EXIT_FAILURE,
+		    "non-standard block size incompatible with -P");
+#endif
+	argc -= optind;
+	argv += optind;
+
+	mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
+	if (mntsize == 0)
+		err(EXIT_FAILURE,
+		    "retrieving information on mounted file systems");
+
+	if (*argv == NULL) {
+		mntsize = regetmntinfo(&mntbuf, mntsize);
+	} else {
+		if ((mntbuf = malloc(argc * sizeof(*mntbuf))) == NULL)
+			err(EXIT_FAILURE, "can't allocate statvfs array");
+		mntsize = 0;
+		for (/*EMPTY*/; *argv != NULL; argv++) {
+			if (stat(*argv, &stbuf) < 0) {
+				if ((mntpt = getmntpt(*argv)) == 0) {
+					warn("%s", *argv);
+					continue;
+				}
+			} else if (S_ISBLK(stbuf.st_mode)) {
+				if ((mntpt = getmntpt(*argv)) == 0)
+					mntpt = *argv;
+			} else
+				mntpt = *argv;
+			/*
+			 * Statfs does not take a `wait' flag, so we cannot
+			 * implement nflag here.
+			 */
+			if (!statvfs(mntpt, &mntbuf[mntsize]))
+				if (lflag &&
+				    (mntbuf[mntsize].f_flag & MNT_LOCAL) == 0)
+					warnx("Warning: %s is not a local %s",
+					    *argv, "file system");
+				else if
+				    (!selected(mntbuf[mntsize].f_fstypename,
+					sizeof(mntbuf[mntsize].f_fstypename)))
+					warnx("Warning: %s mounted as a %s %s",
+					    *argv,
+					    mntbuf[mntsize].f_fstypename,
+					    "file system");
+				else
+					++mntsize;
+			else
+				warn("%s", *argv);
+		}
+	}
+
+	maxwidth = 0;
+	for (i = 0; i < mntsize; i++) {
+		width = (int)strlen(mntbuf[i].f_mntfromname);
+		if (width > maxwidth)
+			maxwidth = width;
+	}
+	for (i = 0; i < mntsize; i++)
+		prtstat(&mntbuf[i], maxwidth);
+	return 0;
+}
+
+static char *
+getmntpt(const char *name)
+{
+	size_t mntsize, i;
+	struct statvfs *mntbuf;
+
+	mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
+	if (mntsize == 0)
+		err(EXIT_FAILURE, "Can't get mount information");
+	for (i = 0; i < mntsize; i++) {
+		if (!strcmp(mntbuf[i].f_mntfromname, name))
+			return mntbuf[i].f_mntonname;
+	}
+	return 0;
+}
+
+static enum { IN_LIST, NOT_IN_LIST } which;
+
+static int
+selected(const char *type, size_t len)
+{
+	char **av;
+
+	/* If no type specified, it's always selected. */
+	if (typelist == NULL)
+		return 1;
+	for (av = typelist; *av != NULL; ++av)
+		if (!strncmp(type, *av, len))
+			return which == IN_LIST ? 1 : 0;
+	return which == IN_LIST ? 0 : 1;
+}
+
+static void
+maketypelist(char *fslist)
+{
+	size_t i;
+	char *nextcp, **av;
+
+	if ((fslist == NULL) || (fslist[0] == '\0'))
+		errx(EXIT_FAILURE, "empty type list");
+
+	/*
+	 * XXX
+	 * Note: the syntax is "noxxx,yyy" for no xxx's and
+	 * no yyy's, not the more intuitive "noyyy,noyyy".
+	 */
+	if (fslist[0] == 'n' && fslist[1] == 'o') {
+		fslist += 2;
+		which = NOT_IN_LIST;
+	} else
+		which = IN_LIST;
+
+	/* Count the number of types. */
+	for (i = 1, nextcp = fslist;
+	    (nextcp = strchr(nextcp, ',')) != NULL; i++)
+		++nextcp;
+
+	/* Build an array of that many types. */
+	if ((av = typelist = malloc((i + 1) * sizeof(*av))) == NULL)
+		err(EXIT_FAILURE, "can't allocate type array");
+	av[0] = fslist;
+	for (i = 1, nextcp = fslist;
+	    (nextcp = strchr(nextcp, ',')) != NULL; i++) {
+		*nextcp = '\0';
+		av[i] = ++nextcp;
+	}
+	/* Terminate the array. */
+	av[i] = NULL;
+}
+
+/*
+ * Make a pass over the filesystem info in ``mntbuf'' filtering out
+ * filesystem types not in ``fsmask'' and possibly re-stating to get
+ * current (not cached) info.  Returns the new count of valid statvfs bufs.
+ */
+static size_t
+regetmntinfo(struct statvfs **mntbufp, size_t mntsize)
+{
+	size_t i, j;
+	struct statvfs *mntbuf;
+
+	if (!lflag && typelist == NULL && aflag)
+		return nflag ? mntsize : (size_t)getmntinfo(mntbufp, MNT_WAIT);
+
+	mntbuf = *mntbufp;
+	j = 0;
+	for (i = 0; i < mntsize; i++) {
+		if (!aflag && (mntbuf[i].f_flag & MNT_IGNORE) != 0)
+			continue;
+		if (lflag && (mntbuf[i].f_flag & MNT_LOCAL) == 0)
+			continue;
+		if (!selected(mntbuf[i].f_fstypename,
+		    sizeof(mntbuf[i].f_fstypename)))
+			continue;
+		if (nflag)
+			mntbuf[j] = mntbuf[i];
+		else {
+			struct statvfs layerbuf = mntbuf[i];
+			(void)statvfs(mntbuf[i].f_mntonname, &mntbuf[j]);
+			/*
+			 * If the FS name changed, then new data is for
+			 * a different layer and we don't want it.
+			 */
+			if (memcmp(layerbuf.f_mntfromname,
+			    mntbuf[j].f_mntfromname, MNAMELEN))
+				mntbuf[j] = layerbuf;
+		}
+		j++;
+	}
+	return j;
+}
+
+static void
+prthumanval(int64_t bytes, const char *pad)
+{
+	char buf[6];
+
+	(void)humanize_number(buf, sizeof(buf) - (bytes < 0 ? 0 : 1),
+	    bytes, "", HN_AUTOSCALE,
+	    HN_B | HN_NOSPACE | HN_DECIMAL);
+
+	(void)printf("%s %6s", pad, buf);
+}
+
+static void
+prthuman(struct statvfs *sfsp, int64_t used, int64_t bavail)
+{
+
+	prthumanval((int64_t)(sfsp->f_blocks * sfsp->f_frsize), "   ");
+	prthumanval((int64_t)(used * sfsp->f_frsize), "    ");
+	prthumanval((int64_t)(bavail * sfsp->f_frsize), "    ");
+}
+
+/*
+ * Convert statvfs returned filesystem size into BLOCKSIZE units.
+ * Attempts to avoid overflow for large filesystems.
+ */
+#define fsbtoblk(num, fsbs, bs)					\
+	(((fsbs) != 0 && (uint64_t)(fsbs) < (uint64_t)(bs)) ?	\
+	    (int64_t)(num) / (int64_t)((bs) / (fsbs)) :		\
+	    (int64_t)(num) * (int64_t)((fsbs) / (bs)))
+
+/*
+ * Print out status about a filesystem.
+ */
+static void
+prtstat(struct statvfs *sfsp, int maxwidth)
+{
+	static long blocksize;
+	static int headerlen, timesthrough;
+	static const char *header;
+	static const char full[] = "100";
+	static const char empty[] = "  0";
+	int64_t used, availblks, inodes;
+	int64_t bavail;
+	char pb[64];
+
+	if (gflag) {
+		/*
+		 * From SunOS-5.6:
+		 *
+		 * /var               (/dev/dsk/c0t0d0s3 ):         8192 block size          1024 frag size
+		 *   984242 total blocks     860692 free blocks   859708 available         249984 total files
+		 *   248691 free files      8388611 filesys id
+		 *      ufs fstype       0x00000004 flag             255 filename length
+		 *
+		 */
+		(void)printf("%10s (%-12s): %7ld block size %12ld frag size\n",
+		    sfsp->f_mntonname, sfsp->f_mntfromname,
+		    sfsp->f_iosize,	/* On UFS/FFS systems this is
+					 * also called the "optimal
+					 * transfer block size" but it
+					 * is of course the file
+					 * system's block size too.
+					 */
+		    sfsp->f_bsize);	/* not so surprisingly the
+					 * "fundamental file system
+					 * block size" is the frag
+					 * size.
+					 */
+		(void)printf("%10" PRId64 " total blocks %10" PRId64
+		    " free blocks  %10" PRId64 " available\n",
+		    (uint64_t)sfsp->f_blocks, (uint64_t)sfsp->f_bfree,
+		    (uint64_t)sfsp->f_bavail);
+		(void)printf("%10" PRId64 " total files  %10" PRId64
+		    " free files %12lx filesys id\n",
+		    (uint64_t)sfsp->f_ffree, (uint64_t)sfsp->f_files,
+		    sfsp->f_fsid);
+		(void)printf("%10s fstype  %#15lx flag  %17ld filename "
+		    "length\n", sfsp->f_fstypename, sfsp->f_flag,
+		    sfsp->f_namemax);
+		(void)printf("%10lu owner %17" PRId64 " syncwrites %12" PRId64
+		    " asyncwrites\n\n", (unsigned long)sfsp->f_owner,
+		    sfsp->f_syncwrites, sfsp->f_asyncwrites);
+
+		/*
+		 * a concession by the structured programming police to the
+		 * indentation police....
+		 */
+		return;
+	}
+	if (maxwidth < 12)
+		maxwidth = 12;
+	if (++timesthrough == 1) {
+		switch (blocksize = usize) {
+		case 1024:
+			header = Pflag ? "1024-blocks" : "1K-blocks";
+			headerlen = (int)strlen(header);
+			break;
+		case 1024 * 1024:
+			header = "1M-blocks";
+			headerlen = (int)strlen(header);
+			break;
+		case 1024 * 1024 * 1024:
+			header = "1G-blocks";
+			headerlen = (int)strlen(header);
+			break;
+		default:
+			if (hflag) {
+				header = "Size";
+				headerlen = (int)strlen(header);
+			} else
+				header = getbsize(&headerlen, &blocksize);
+			break;
+		}
+		if (Pflag) {
+			/*
+			 * either:
+			 *  "Filesystem 1024-blocks Used Available Capacity Mounted on\n"
+			 * or:
+			 *  "Filesystem 512-blocks Used Available Capacity Mounted on\n"
+			 */
+			if (blocksize != 1024 && blocksize != 512)
+				errx(EXIT_FAILURE,
+				    "non-standard block size incompatible with -P");
+			(void)printf("Filesystem %s Used Available Capacity "
+			    "Mounted on\n", header);
+		} else {
+			(void)printf("%-*.*s %s       Used      Avail %%Cap",
+			    maxwidth - (headerlen - 10),
+			    maxwidth - (headerlen - 10),
+			    "Filesystem", header);
+			if (iflag)
+				(void)printf("    iUsed   iAvail %%iCap");
+			(void)printf(" Mounted on\n");
+		}
+	}
+	used = sfsp->f_blocks - sfsp->f_bfree;
+	bavail = sfsp->f_bfree - sfsp->f_bresvd;
+	availblks = bavail + used;
+	if (Pflag) {
+		assert(hflag == 0);
+		assert(blocksize > 0);
+		/*
+		 * "%s %d %d %d %s %s\n", <file system name>, <total space>,
+		 * <space used>, <space free>, <percentage used>,
+		 * <file system root>
+		 */
+		(void)printf("%s %" PRId64 " %" PRId64 " %" PRId64 " %s%% %s\n",
+		    sfsp->f_mntfromname,
+		    fsbtoblk(sfsp->f_blocks, sfsp->f_frsize, blocksize),
+		    fsbtoblk(used, sfsp->f_frsize, blocksize),
+		    fsbtoblk(bavail, sfsp->f_frsize, blocksize),
+		    availblks == 0 ? full : strspct(pb, sizeof(pb), used,
+		    availblks, 0), sfsp->f_mntonname);
+		/*
+		 * another concession by the structured programming police to
+		 * the indentation police....
+		 *
+		 * Note iflag cannot be set when Pflag is set.
+		 */
+		return;
+	}
+
+	(void)printf("%-*.*s ", maxwidth, maxwidth, sfsp->f_mntfromname);
+
+	if (hflag)
+		prthuman(sfsp, used, bavail);
+	else
+		(void)printf("%10" PRId64 " %10" PRId64 " %10" PRId64,
+		    fsbtoblk(sfsp->f_blocks, sfsp->f_frsize, blocksize),
+		    fsbtoblk(used, sfsp->f_frsize, blocksize),
+		    fsbtoblk(bavail, sfsp->f_frsize, blocksize));
+	(void)printf(" %3s%%",
+	    availblks == 0 ? full :
+	    strspct(pb, sizeof(pb), used, availblks, 0));
+	if (iflag) {
+		inodes = sfsp->f_files;
+		used = inodes - sfsp->f_ffree;
+		(void)printf(" %8jd %8jd %3s%%",
+		    (intmax_t)used, (intmax_t)sfsp->f_ffree,
+		    inodes == 0 ? (used == 0 ? empty : full) :
+		    strspct(pb, sizeof(pb), used, inodes, 0));
+	}
+	(void)printf(" %s\n", sfsp->f_mntonname);
+}
+
+static void
+usage(void)
+{
+
+	(void)fprintf(stderr,
+	    "Usage: %s [-aGgln] [-hkm|-ihkm|-Pk] [-t type] [file | "
+	    "file_system ...]\n",
+	    getprogname());
+	exit(1);
+	/* NOTREACHED */
+}

bin/pax/ar_io.c

@@ -456,13 +456,8 @@ ar_close(void)
 
 	/* mimic cpio's block count first */
 	if (frmt && strcmp(NM_CPIO, argv0) == 0) {
-#ifdef __minix
-		(void)fprintf(listf, "%d blocks\n",
-		    (rdcnt ? rdcnt : wrcnt) / 5120);
-#else
 		(void)fprintf(listf, OFFT_F " blocks\n",
 		    (rdcnt ? rdcnt : wrcnt) / 5120);
-#endif
 	}
 
 	ar_summary(0);

commands/DESCRIBE/DESCRIBE.sh

@@ -126,10 +126,6 @@ do
 	;;
     4,125)	des="video output" dev=video
 	;;
-    4,126)	des="auxiliary input" dev=kbdaux
-	;;
-    4,127)	des="keyboard input" dev=kbd
-	;;
     4,12[89]|4,1[3-8]?|4,19[01])
 	p=`expr \\( $minor - 128 \\) / 16 | tr '0123' 'pqrs'`
 	n=`expr $minor % 16`
@@ -196,6 +192,40 @@ do
     18,0)
 	des="UNIX domain socket" dev=uds
 	;;
+    5[6-9],0|6[0-3],0)
+	drive=`expr $major - 56`
+	des="vnode disk $drive" dev=vnd$drive
+	;;
+    5[6-9],[1-4]|6[0-3],[1-4])
+	drive=`expr $major - 56`
+	par=`expr $minor - 1`
+	des="vnode disk $drive partition $par" dev=vnd${drive}p${par}
+	;;
+    5[6-9],12[89]|5[6-9],13[0-9]|5[6-9],14[0-3]|6[0-3],12[89]|5[6-9],13[0-9]|5[6-9],14[0-3])
+	drive=`expr $major - 56`
+	par=`expr \\( \\( $minor - 128 \\) / 4 \\) % 4`
+	sub=`expr \\( $minor - 128 \\) % 4`
+	des="vnode disk $drive partition $par slice $sub"
+	dev=vnd${drive}p${par}s${sub}
+	;;
+    64,0)
+	des="keyboard input multiplexer"
+	dev=kbdmux
+	;;
+    64,[1-4])
+	n=`expr $minor - 1`
+	des="keyboard input $n"
+	dev=kbd$n
+	;;
+    64,64)
+	des="mouse input multiplexer"
+	dev=mousemux
+	;;
+    64,6[5-8])
+	n=`expr $minor - 65`
+	des="mouse input $n"
+	dev=mouse$n
+	;;
     BAD,BAD)
 	des= dev=
 	;;

commands/MAKEDEV/MAKEDEV.8

@@ -0,0 +1,57 @@
+.Dd October 4, 2013
+.Dt MAKEDEV 8
+.Os
+.Sh NAME
+.Nm MAKEDEV, DESCRIBE
+.Nd make/describe device files
+.Sh SYNOPSIS
+.Nm MAKEDEV
+.Op Fl n | Fl m
+.Op Fl r | Fl s
+.Op key ...
+.Nm DESCRIBE
+.Op device ...
+.Sh DESCRIPTION
+.Nm MAKEDEV
+may be used to create the device files normally found in the /dev directory.
+.Nm MAKEDEV
+knows about all supported devices and will create them in the current
+directory with the proper owner and mode. For many devices
+.Nm MAKEDEV
+will not only create the device you want, but also the devices related
+to it that you will probably want too. Naming one floppy device will
+create all floppy devices for the same drive for instance.
+.Pp
+The options are as follows:
+.Bl -tag -width Xxxexcludexfilexx
+.It Fl n
+echo the commands it would execute when you call it without that flag.
+.It Fl m
+echo
+.Nm mtree(8)
+formatted lines instead of creating the device nodes.
+.It Fl r
+Restricted set of devices. This set is used when generating the ramdisk.
+.It Fl s
+Standard set of devices. This set is used when popluating /dev.
+.El
+.Pp
+.Ar key
+arguments are simply the names of the devices you want to create. Call
+.Nm MAKEDEV
+without arguments to see a list of keys that it understands.
+.Pp
+The command
+.Nm DESCRIBE
+will give you a one-line description of a given device. By default It
+will list all devices in /dev.
+.Sh "SEE ALSO"
+.Xr dev 4 ,
+.Xr mknod 8
+.Sh BUGS
+The eagerness of
+.Nm MAKEDEV
+to create devices may cause many "File exists" errors from
+.Nm mknod .
+.Sh AUTHORS
+Written by Kees J. Bot (kjb@cs.vu.nl) and Lionel A. Sambuc (lionel@minix3.org)

commands/MAKEDEV/MAKEDEV.sh

@@ -1,43 +1,115 @@
 #!/bin/sh
 #
 # MAKEDEV 3.3 - Make special devices.			Author: Kees J. Bot
+# 3.4 - Rewritten to allow mtree line to be printed,	Lionel A. Sambuc
+#       also use getopt for argument parsing
+umask 077
 
-case $1 in
+MTREE=false
--n)	e=echo; shift ;;	# Just echo when -n is given.
+STD=false
-*)	e=
+RAMDISK=false
-esac
+ECHO=
+EXIT=0
 
-case $#:$1 in
+# console => lp tty log
-1:std)		# Standard devices.
+# boot    => kmem mem null ram zero
-    set -$- mem fd0 fd1 fd0p0 fd1p0 \
+RAMDISK_DEVICES="
-	c0d0 c0d0p0 c0d0p0s0 c0d1 c0d1p0 c0d1p0s0 \
+	boot
-	c0d2 c0d2p0 c0d2p0s0 c0d3 c0d3p0 c0d3p0s0 \
+	console
-	c0d4 c0d4p0 c0d4p0s0 c0d5 c0d5p0 c0d5p0s0 \
+	input
-	c0d6 c0d6p0 c0d6p0s0 c0d7 c0d7p0 c0d7p0s0 \
+	c0d0 c0d0p0 c0d0p0s0 c0d1 c0d1p0 c0d1p0s0
-	c1d0 c1d0p0 c1d0p0s0 c1d1 c1d1p0 c1d1p0s0 \
+	c0d2 c0d2p0 c0d2p0s0 c0d3 c0d3p0 c0d3p0s0
-	c1d2 c1d2p0 c1d2p0s0 c1d3 c1d3p0 c1d3p0s0 \
+	c0d4 c0d4p0 c0d4p0s0 c0d5 c0d5p0 c0d5p0s0
-	c1d4 c1d4p0 c1d4p0s0 c1d5 c1d5p0 c1d5p0s0 \
+	c0d6 c0d6p0 c0d6p0s0 c0d7 c0d7p0 c0d7p0s0
-	c1d6 c1d6p0 c1d6p0s0 c1d7 c1d7p0 c1d7p0s0 \
+	c1d0 c1d0p0 c1d0p0s0 c1d1 c1d1p0 c1d1p0s0
-	tty ttyc1 ttyc2 ttyc3 tty00 tty01 tty02 tty03 \
+	c1d2 c1d2p0 c1d2p0s0 c1d3 c1d3p0 c1d3p0s0
-	ttyp0 ttyp1 ttyp2 ttyp3 ttyp4 ttyp5 ttyp6 ttyp7 ttyp8 ttyp9 \
+	c1d4 c1d4p0 c1d4p0s0 c1d5 c1d5p0 c1d5p0s0
-	ttypa ttypb ttypc ttypd ttype ttypf \
+	c1d6 c1d6p0 c1d6p0s0 c1d7 c1d7p0 c1d7p0s0
-	ttyq0 ttyq1 ttyq2 ttyq3 ttyq4 ttyq5 ttyq6 ttyq7 ttyq8 ttyq9 \
+	fd0 fd1 fd0p0 fd1p0
-	ttyqa ttyqb ttyqc ttyqd ttyqe ttyqf \
+	ttyc1 ttyc2 ttyc3 tty00 tty01 tty02 tty03
-	eth klog random uds filter fbd hello fb0 \
+	ttyp0 ttyp1 ttyp2 ttyp3 ttyp4 ttyp5 ttyp6 ttyp7 ttyp8 ttyp9
-	i2c-1 i2c-2 i2c-3 \
+	ttypa ttypb ttypc ttypd ttype ttypf
-	eepromb1s50 eepromb1s51 eepromb1s52 eepromb1s53 \
+	ttyq0 ttyq1 ttyq2 ttyq3 ttyq4 ttyq5 ttyq6 ttyq7 ttyq8 ttyq9
-	eepromb1s54 eepromb1s55 eepromb1s56 eepromb1s57 \
+	ttyqa ttyqb ttyqc ttyqd ttyqe ttyqf
-	eepromb2s50 eepromb2s51 eepromb2s52 eepromb2s53 \
+"
-	eepromb2s54 eepromb2s55 eepromb2s56 eepromb2s57 \
+
-	eepromb3s50 eepromb3s51 eepromb3s52 eepromb3s53 \
+#eth      => ip tcp udp
-	eepromb3s54 eepromb3s55 eepromb3s56 eepromb3s57 \
+STD_DEVICES="
-	tsl2550b1s39 tsl2550b2s39 tsl2550b3s39 \
+	${RAMDISK_DEVICES}
-	sht21b1s40 sht21b2s40 sht21b3s40 \
 	bmp085b1s77 bmp085b2s77 bmp085b3s77
-    ;;
+	eepromb1s50 eepromb1s51 eepromb1s52 eepromb1s53
-0:|1:-\?)
+	eepromb1s54 eepromb1s55 eepromb1s56 eepromb1s57
-    cat >&2 <<EOF
+	eepromb2s50 eepromb2s51 eepromb2s52 eepromb2s53
-Usage:	$0 [-n] key ...
+	eepromb2s54 eepromb2s55 eepromb2s56 eepromb2s57
+	eepromb3s50 eepromb3s51 eepromb3s52 eepromb3s53
+	eepromb3s54 eepromb3s55 eepromb3s56 eepromb3s57
+	eth fb0 fbd filter hello
+	i2c-1 i2c-2 i2c-3
+	klog random
+	sht21b1s40 sht21b2s40 sht21b3s40
+	tsl2550b1s39 tsl2550b2s39 tsl2550b3s39
+	uds
+	vnd0 vnd0p0 vnd0p0s0 vnd1 vnd1p0 vnd1p0s0
+	vnd2 vnd3 vnd4 vnd5 vnd6 vnd7
+"
+
+#makedev ${dev} $type ${major} ${minor} ${uname} ${gname} ${permissions} [link_target]
+#When called for a link, major and minor are ignored
+makedev()
+{
+	# Check that all the arguments are there, we trust the caller to put
+	# values which make sens.
+	[ $# -eq 7 ] || [ $# -eq 8 ] || return 1;
+
+	local _dev=$1
+	local __type=$2
+	local _major=$3
+	local _minor=$4
+	local _uname=$5
+	local _gname=$6
+	local _mode=$7
+
+	case ${__type} in
+	b)_type=block;;
+	c) _type=char;;
+	l) _type=link; _target=$8;;
+	*) return 2;;
+	esac
+
+	if [ ${MTREE} = "yes" ]
+	then
+		if [ ${_type} = "link" ]
+		then
+			echo ./dev/${_dev} type=${_type} \
+			    uname=${_uname} gname=${_gname} mode=${_mode} \
+			    link=${_target}
+		else
+			echo ./dev/${_dev} type=${_type} \
+			    uname=${_uname} gname=${_gname} mode=${_mode} \
+			    device=native,${_major},${_minor}
+		fi
+	else
+		if [ ${_type} = "link" ]
+		then
+			${ECHO} ln -f ${_target} ${_dev}
+		else
+			${ECHO} mknod ${_dev} ${__type} ${_major} ${_minor}
+			${ECHO} chmod ${_mode} ${_dev}
+			${ECHO} chown ${_uname}:${_gname} ${_dev}
+		fi
+	fi
+}
+
+# no_return usage()
+usage()
+{
+	cat >&2 <<EOF
+Usage:	$0 [-n|-m] [-s|-r] key ...
+	-n: print the commands instead of executing them
+	-m: print mtree(8) line
+	-s: standard set of devices
+	-r: reduced for ramdisk set of devices
+
 Where key is one of the following:
   ram mem kmem null boot zero	  # One of these makes all these memory devices
   fb0			  # Make /dev/fb0
@@ -61,280 +133,341 @@ Where key is one of the following:
   klog                    # Make /dev/klog
   random                  # Make /dev/random, /dev/urandom
   uds                     # Make /dev/uds
-  kbd                     # Make /dev/kbd
-  kbdaux                  # Make /dev/kbdaux
   filter                  # Make /dev/filter
   fbd                     # Make /dev/fbd
   hello                   # Make /dev/hello
   video                   # Make /dev/video
-  std			  # All standard devices
+  vnd0 vnd0p0 vnd0p0s0 .. # Make vnode disks /dev/vnd[0-7] and (sub)partitions
+  input                   # Make /dev/kbdmux, /dev/kbd[0-3], idem /dev/mouse~
 EOF
-    exit 1
+	exit 1
-esac
+}
 
-umask 077
+# Parse options
-ex=0
+while getopts "nmrs" arg
-
-for dev
 do
-    case $dev in	# One of the controllers?  Precompute major device nr.
+	case "$arg" in
-    c0*) maj=3  ;;
+	n)
-    c1*) maj=8  ;;
+		ECHO=echo
-    c2*) maj=10 ;;
+		;;
-    c3*) maj=12 ;;
+	m)
-    esac
+		MTREE=yes
-
+		;;
-    case $dev in
+	r)
-    ram|mem|kmem|null|boot|zero|imgrd)
+		RAMDISK=yes
-	# Memory devices.
+		;;
-	#
+	s)
-	$e mknod ram b 1 0;	$e chmod 600 ram
+		STD=yes
-	$e mknod mem c 1 1;	$e chmod 640 mem
+		;;
-	$e mknod kmem c 1 2;	$e chmod 640 kmem
+	h|\?)
-	$e mknod null c 1 3;	$e chmod 666 null
+		usage
-	$e mknod boot b 1 4;	$e chmod 600 ram
+		;;
-	$e mknod zero c 1 5;	$e chmod 644 zero
-	$e mknod imgrd b 1 6;	$e chmod 644 zero
-	for n in 0 1 2 3 4 5
-	do	$e mknod ram$n b 1 $((7+$n));	$e chmod 600 ram$n
-	done
-	$e chgrp kmem ram* mem kmem null boot zero imgrd
-	;;
-    fd[0-3])
-	# Floppy disk drive n.
-	#
-	d=`expr $dev : '.*\\(.\\)'`	# Drive number.
-	$e mknod $dev  b 2 $d
-	$e chmod 666 $dev
-	;;
-    pc[0-3]|at[0-3]|qd[0-3]|ps[0-3]|pat[0-3]|qh[0-3]|PS[0-3])
-	# Obsolete density locked floppy disk drive n.
-	#
-	d=`expr $dev : '.*\\(.\\)'`	# Drive number.
-	m=$d				# Minor device number.
-
-	$e mknod pc$d  b 2 $m;	m=`expr $m + 4`
-	$e mknod at$d  b 2 $m;	m=`expr $m + 4`
-	$e mknod qd$d  b 2 $m;	m=`expr $m + 4`
-	$e mknod ps$d  b 2 $m;	m=`expr $m + 4`
-	$e mknod pat$d b 2 $m;	m=`expr $m + 4`
-	$e mknod qh$d  b 2 $m;	m=`expr $m + 4`
-	$e mknod PS$d  b 2 $m;	m=`expr $m + 4`
-
-	$e chmod 666 pc$d at$d qd$d ps$d pat$d qh$d PS$d
-	;;
-    fd[0-3]p[0-3])
-	# Floppy disk partitions.
-	#
-	n=`expr $dev : '\\(.*\\)..'`	# Name prefix.
-	d=`expr $dev : '..\\(.\\)'`	# Drive number.
-	m=`expr 112 + $d`		# Minor of partition 0.
-	alldev=
-
-	for p in 0 1 2 3
-	do
-	    m=`expr 112 + $d + $p '*' 4` # Minor of partition $p.
-	    $e mknod ${n}p${p} b 2 $m	# Make e.g. fd0p0 - fd0p3
-	    alldev="$alldev ${n}p${p}"
-	done
-	$e chmod 666 $alldev
-	;;
-    c[0-3]d[0-7])
-	# Whole disk devices.
-	d=`expr $dev : '...\\(.\\)'`	# Disk number.
-	m=`expr $d '*' 5`		# Minor device number.
-	$e mknod $dev b $maj $m
-	$e chmod 600 $dev
-	;;
-    c[0-3]d[0-7]p[0-3])
-	# Disk primary partitions.
-	n=`expr $dev : '\\(.*\\).'`	# Name prefix.
-	d=`expr $dev : '...\\(.\\)'`	# Disk number.
-	alldev=
-
-	for p in 0 1 2 3
-	do
-	    m=`expr $d '*' 5 + 1 + $p`	# Minor device number.
-	    $e mknod $n$p b $maj $m
-	    alldev="$alldev $n$p"
-	done
-	echo $alldev | xargs $e chmod 600
-	;;
-    c[0-3]d[0-7]p[0-3]s[0-3])
-	# Disk subpartition.
-	n=`expr $dev : '\\(.*\\)...'`	# Name prefix.
-	d=`expr $dev : '...\\(.\\)'`	# Disk number.
-	alldev=
-
-	for p in 0 1 2 3
-	do
-	    for s in 0 1 2 3
-	    do
-		m=`expr 128 + $d '*' 16 + $p '*' 4 + $s`  # Minor device nr.
-		$e mknod ${n}${p}s${s} b $maj $m
-		alldev="$alldev ${n}${p}s${s}"
-	    done
-	done
-	echo $alldev | xargs $e chmod 600
-	;;
-    c[0-3]t[0-7]|c[0-3]t[0-7]n)
-	# Tape devices.
-	n=`expr $dev : '\\(....\\)'`	# Name prefix.
-	t=`expr $dev : '...\\(.\\)'`	# Tape number.
-	m=`expr 64 + $t '*' 2`		# Minor device number.
-	$e mknod ${n}n c $maj $m
-	$e mknod ${n} c $maj `expr $m + 1`
-	$e chmod 660 ${n}n ${n}
-	;;
-    console|lp|tty|log|kbd|kbdaux|video)
-	# Console, line printer, anonymous tty, diagnostics device,
-	# raw keyboard, ps/2 mouse, video.
-	$e mknod console c 4 0
-	$e chmod 600 console
-	$e chgrp tty console
-	$e mknod tty c 5 0
-	$e chmod 666 tty
-	$e mknod lp c 6 0
-	$e chown daemon lp
-	$e chgrp daemon lp
-	$e chmod 200 lp
-	$e mknod log c 4 15
-	$e chmod 222 log
-	$e mknod kbd c 4 127
-	$e mknod kbdaux c 4 126
-	$e chmod 660 kbd kbdaux
-	$e chgrp operator kbd kbdaux
-	$e mknod video c 4 125
-	$e chmod 600 video
-	$e chgrp operator video
-	;;
-    ttyc[1-7])
-	# Virtual consoles.
-	#
-	m=`expr $dev : '....\\(.*\\)'`	# Minor device number.
-	$e mknod $dev c 4 $m
-	$e chgrp tty $dev
-	$e chmod 600 $dev
-	;;
-    tty0[0-3])
-	# Serial lines.
-	#
-	n=`expr $dev : '.*\\(.\\)'`
-	$e mknod $dev c 4 `expr $n + 16`
-	$e chmod 666 $dev
-	$e chgrp tty $dev
-	;;
-    tty[p-s][0-9a-f]|pty[p-s][0-9a-f])
-	# Pseudo ttys.
-	#
-	dev=`expr $dev : '...\\(..\\)'`
-	g=`expr $dev : '\\(.\\)'`	# Which group.
-	g=`echo $g | tr 'pqrs' '0123'`
-	n=`expr $dev : '.\\(.\\)'`	# Which pty in the group.
-	case $n in
-	[a-f])	n=1`/bin/echo $n | tr 'abcdef' '012345'`
 	esac
-
-	$e mknod tty$dev c 4 `expr $g '*' 16 + $n + 128`
-	$e mknod pty$dev c 4 `expr $g '*' 16 + $n + 192`
-	$e chgrp tty tty$dev pty$dev
-	$e chmod 666 tty$dev pty$dev
-	;;
-    eth|ip|tcp|udp|eth0|ip0|tcp0|udp0)
-	# TCP/IP devices.
-	#
-	$e mknod eth0 c 7 0		# Network 0 (Ethernet)
-	$e mknod ip0 c 7 1
-	$e mknod tcp0 c 7 2
-	$e mknod udp0 c 7 3
-	$e chmod 600 eth0 ip0
-	$e chmod 666 tcp0 udp0
-	$e ln -f eth0 eth		# Default interface
-	$e ln -f ip0 ip
-	$e ln -f tcp0 tcp
-	$e ln -f udp0 udp
-	;;
-    audio|mixer)
-	# Audio devices.
-	#
-   $e mknod audio c 13 0
-   $e mknod mixer c 13 1
-   $e chmod 666 audio mixer
-	;;
-    random|urandom)
-	# random data generator.
-	$e mknod random c 16 0;	$e chmod 644 random
-	$e mknod urandom c 16 0; $e chmod 644 urandom
-	$e chgrp operator random urandom
-	;;
-    uds)
-	# unix domain sockets device
-	$e mknod uds c 18 0;
-	$e chgrp operator uds
-	$e chmod 666 uds
-	;;
-    klog)
-    	# logging device.
-    	$e mknod klog c 15 0
-	$e chmod 600 klog
-	;;
-    filter)
-	# filter driver
-	$e mknod filter b 11 0
-	$e chmod 600 filter
-	;;
-    fbd)
-	# faulty block device driver
-	$e mknod fbd b 14 0
-	$e chmod 600 fbd
-	;;
-    hello)
-	# hello driver
-	$e mknod hello c 17 0
-	$e chmod 644 hello
-	;;
-    fb0)
-	# framebuffer driver
-	$e mknod fb0 c 19 0
-	$e chmod 644 fb0
-	;;
-    i2c-[1-3])
-	# i2c driver
-	b=`expr $dev : '....\\(.*\\)'` # bus number
-	m=`expr $dev : '....\\(.*\\)' - 1` # least significant digit of major
-	$e mknod i2c-${b} c 2${m} 0
-	$e chmod 600 i2c-${b}
-	;;
-    eepromb[1-3]s5[0-7])
-	# cat24c256 driver
-	b=`expr $dev : 'eepromb\\(.*\\)s'` # bus number
-	s=`expr $dev : 'eepromb.s5\\(.*\\)'` # configurable part of slave addr
-	m=`expr ${b} \* 8 + ${s} + 17`
-	$e mknod eepromb${b}s5${s} b ${m} 0
-	$e chmod 600 eepromb${b}s5${s}
-	;;
-    tsl2550b[1-3]s39)
-	b=`expr $dev : 'tsl2550b\\(.*\\)s39'` #bus number
-	m=`expr ${b} + 46`
-	$e mknod tsl2550b${b}s39 c ${m} 0
-	$e chmod 444 tsl2550b${b}s39
-	;;
-    sht21b[1-3]s40)
-	b=`expr $dev : 'sht21b\\(.*\\)s40'` #bus number
-	m=`expr ${b} + 49`
-	$e mknod sht21b${b}s40 c ${m} 0
-	$e chmod 444 sht21b${b}s40
-	;;
-    bmp085b[1-3]s77)
-	b=`expr $dev : 'bmp085b\\(.*\\)s77'` #bus number
-	m=`expr ${b} + 52`
-	$e mknod bmp085b${b}s77 c ${m} 0
-	$e chmod 444 bmp085b${b}s77
-	;;
-    *)
-	echo "$0: don't know about $dev" >&2
-	ex=1
-    esac
 done
 
-exit $ex
+if [ ${STD} = "yes" ]
+then
+	DEVICES=${STD_DEVICES}
+elif [ ${RAMDISK} = "yes" ]
+then
+	DEVICES=${RAMDISK_DEVICES}
+else
+	while [ $OPTIND -gt 1 ]
+	do
+		shift
+		OPTIND=$((${OPTIND} - 1))
+	done
+	while [ ! -z "$1" ]
+	do
+		DEVICES="${DEVICES} $1"
+		shift
+	done
+fi
+
+for dev in ${DEVICES}
+do
+	# Reset the defaults
+	uname=root
+	gname=operator
+	permissions=600
+
+	case ${dev} in
+	c0*) major=3 ;;
+	c1*) major=8 ;;
+	c2*) major=10 ;;
+	c3*) major=12 ;;
+	vnd*) # Whole vnode disk devices.
+		disk=`expr ${dev} : '...\\(.\\)'`
+		major=`expr ${disk} + 56`
+		;;
+	esac
+
+	# The following is lexicographicaly ordered
+	case ${dev} in
+	audio|mixer)
+		# Audio devices.
+		makedev audio c 13 0 ${uname} ${gname} 666
+		makedev mixer c 13 1 ${uname} ${gname} 666
+		;;
+	bmp085b[1-3]s77)
+		# Weather Cape: temperature & pressure sensor
+		bus=`expr ${dev} : 'bmp085b\\(.*\\)s77'` #bus number
+		major=`expr ${bus} + 52`
+
+		makedev bmp085b${bus}s77 c ${major} 0 ${uname} ${gname} 444
+		;;
+	c[0-3]d[0-7])
+		# Whole disk devices.
+		disk=`expr ${dev} : '...\\(.\\)'`
+		minor=`expr ${disk} '*' 5`
+
+		makedev ${dev} b ${major} ${minor} ${uname} ${gname} ${permissions}
+		;;
+	c[0-3]d[0-7]p[0-3])
+		# Disk primary partitions.
+		prefix=`expr ${dev} : '\\(.*\\).'`
+		disk=`expr ${dev} : '...\\(.\\)'`
+
+		for p in 0 1 2 3
+		do
+			minor=`expr ${disk} '*' 5 + 1 + ${p}`
+			makedev ${prefix}${p} b ${major} ${minor} \
+				${uname} ${gname} ${permissions}
+		done
+		;;
+	c[0-3]d[0-7]p[0-3]s[0-3])
+		# Disk subpartition.
+		prefix=`expr ${dev} : '\\(.*\\)...'`
+		disk=`expr ${dev} : '...\\(.\\)'`
+
+		for p in 0 1 2 3
+		do
+			for s in 0 1 2 3
+			do
+				minor=`expr 128 + ${disk} '*' 16 + ${p} '*' 4 + ${s}`
+				makedev ${prefix}${p}s${s} b ${major} ${minor} \
+					${uname} ${gname} ${permissions}
+			done
+		done
+		;;
+	c[0-3]t[0-7]|c[0-3]t[0-7]n)
+		# Tape devices.
+		prefix=`expr ${dev} : '\\(....\\)'`
+		tape=`expr ${dev} : '...\\(.\\)'`
+		minor=`expr 64 + ${tape} '*' 2`
+
+		makedev ${prefix}n c ${major} ${minor} ${uname} ${gname} 660
+		makedev ${prefix} c ${major} `expr ${minor} + 1` ${uname} ${gname} 660
+		;;
+	console|lp|tty|log|video)
+		# Console, line printer, anonymous tty, diagnostics device, video.
+		makedev console c 4 0 ${uname} tty ${permissions}
+		makedev tty c 5 0 ${uname} ${gname} 666
+		makedev lp c 6 0 daemon daemon 200
+		makedev log c 4 15 ${uname} ${gname} 222
+		makedev video c 4 125 ${uname} ${gname} ${permissions}
+		;;
+	eepromb[1-3]s5[0-7])
+		# cat24c256 driver
+		bus=`expr ${dev} : 'eepromb\\(.*\\)s'`
+		# configurable part of slave addr
+		slave_low=`expr ${dev} : 'eepromb.s5\\(.*\\)'`
+		major=`expr ${bus} '*' 8 + ${slave_low} + 17`
+
+		makedev eepromb${bus}s5${slave_low} b ${major} 0 ${uname} ${gname} ${permissions}
+		;;
+	eth|ip|tcp|udp|eth0|ip0|tcp0|udp0)
+		# TCP/IP devices.
+		makedev ipstat c 7 0 ${uname} ${gname} 666
+		makedev eth0 c 7 1 ${uname} ${gname} ${permissions}
+		makedev ip0 c 7 2 ${uname} ${gname} ${permissions}
+		makedev tcp0 c 7 3 ${uname} ${gname} 666
+		makedev udp0 c 7 4 ${uname} ${gname} 666
+
+		# Default interface
+		makedev eth c 7 1 ${uname} ${gname} ${permissions}
+		makedev ip c 7 2 ${uname} ${gname} ${permissions}
+		makedev tcp c 7 3 ${uname} ${gname} 666
+		makedev udp c 7 4 ${uname} ${gname} 666
+		;;
+	fb0)
+		# Framebuffer driver
+		makedev ${dev} c 19 0 ${uname} ${gname} 644
+		;;
+	fbd)
+		# Faulty block device driver
+		makedev ${dev} b 14 0 ${uname} ${gname} ${permissions}
+		;;
+	fd[0-3])
+		# Floppy disk drive N has minor N.
+		minor=`expr ${dev} : '..\\(.\\)'`
+
+		makedev ${dev} b 2 ${minor} ${uname} ${gname} 666
+		;;
+	fd[0-3]p[0-3])
+		# Floppy disk partitions.
+		prefix=`expr ${dev} : '\\(.*\\).'`
+		drive=`expr ${dev} : '..\\(.\\)'`
+
+		for p in 0 1 2 3
+		do
+			minor=`expr 112 + ${drive} + ${p} '*' 4`
+			makedev ${prefix}${p} b 2 ${minor} \
+				${uname} ${gname} 666
+		done
+		;;
+	filter)
+		# Filter driver
+		makedev ${dev} b 11 0 ${uname} ${gname} ${permissions}
+		;;
+	hello)
+		# Hello driver
+		makedev ${dev} c 17 0 ${uname} ${gname} 644
+		;;
+	i2c-[1-3])
+		# i2c driver
+		bus=`expr ${dev} : '....\\(.*\\)'` # bus number
+		# least significant digit of major
+		major_low=`expr ${dev} : '....\\(.*\\)'`
+		major_low=`expr ${major_low} - 1`
+
+		makedev "i2c-${bus}" c 2${major_low} 0 ${uname} ${gname} ${permissions}
+		;;
+	input)
+		# Input server
+		makedev kbdmux c 64 0 ${uname} ${gname} ${permissions}
+		makedev mousemux c 64 64 ${uname} ${gname} ${permissions}
+
+		for n in 0 1 2 3
+		do
+			minor_keyboard=`expr ${n} + 1`
+			minor_mouse=`expr ${n} + 65`
+
+			makedev kbd${n} c 64 ${minor_keyboard} ${uname} ${gname} ${permissions}
+			makedev mouse${n} c 64 ${minor_mouse} ${uname} ${gname} ${permissions}
+		done
+		;;
+	klog)
+		# Logging device.
+		makedev ${dev} c 15 0 ${uname} ${gname} ${permissions}
+		;;
+	pc[0-3]|at[0-3]|qd[0-3]|ps[0-3]|pat[0-3]|qh[0-3]|PS[0-3])
+		# Obsolete density locked floppy disk drive n.
+		drive=`expr ${dev} : '.*\\(.\\)'`
+		minor=${drive}
+
+		for prefix in pc at qd ps pat qh PS
+		do
+			makedev ${prefix}${drive} b 2 ${minor} \
+				${uname} ${gname} 666
+			minor=`expr ${minor} + 4`
+		done
+		;;
+	ram|mem|kmem|null|boot|zero|imgrd)
+		# Memory devices.
+		makedev ram   b 1 0 ${uname} kmem ${permissions}
+		makedev mem   c 1 1 ${uname} kmem 640
+		makedev kmem  c 1 2 ${uname} kmem 640
+		makedev null  c 1 3 ${uname} kmem 666
+		makedev boot  b 1 4 ${uname} kmem ${permissions}
+		makedev zero  c 1 5 ${uname} kmem 644
+		makedev imgrd b 1 6 ${uname} kmem ${permissions}
+
+		for n in 0 1 2 3 4 5
+		do
+			minor=`expr ${n} + 7`
+
+			makedev ram${n} b 1 ${minor} ${uname} kmem ${permissions}
+		done
+		;;
+	random|urandom)
+		# Random data generator.
+		makedev random c 16 0 ${uname} ${gname} 644
+		makedev urandom c 16 0 ${uname} ${gname} 644
+		;;
+	sht21b[1-3]s40)
+		# Weather Cape: relative humidity & temperature sensor
+		bus=`expr ${dev} : 'sht21b\\(.*\\)s40'`
+		major=`expr ${bus} + 49`
+
+		makedev sht21b${bus}s40 c ${major} 0 ${uname} ${gname} 444
+		;;
+	tsl2550b[1-3]s39)
+		# Weather Cape: ambient light sensor
+		bus=`expr ${dev} : 'tsl2550b\\(.*\\)s39'`
+		major=`expr ${bus} + 46`
+
+		makedev tsl2550b${bus}s39 c ${major} 0 ${uname} ${gname} 444
+		;;
+	tty0[0-3])
+		# Serial lines.
+		line=`expr ${dev} : '.*\\(.\\)'`
+		minor=`expr ${line} + 16`
+
+		makedev ${dev} c 4 ${minor} ${uname} tty 666
+		;;
+	tty[p-s][0-9a-f]|pty[p-s][0-9a-f])
+		# Pseudo ttys.
+		dev=`expr ${dev} : '...\\(..\\)'`
+		group=`expr ${dev} : '\\(.\\)'`
+		group=`echo ${group} | tr 'pqrs' '0123'`
+		pty=`expr ${dev} : '.\\(.\\)'`
+		case ${pty} in
+			[a-f])	pty=1`/bin/echo ${pty} | tr 'abcdef' '012345'`
+		esac
+		minor_tty=`expr ${group} '*' 16 + ${pty} + 128`
+		minor_pty=`expr ${group} '*' 16 + ${pty} + 192`
+
+		makedev tty${dev} c 4 ${minor_tty} ${uname} tty 666
+		makedev pty${dev} c 4 ${minor_pty} ${uname} tty 666
+		;;
+	ttyc[1-7])
+		# Virtual consoles.
+		minor=`expr ${dev} : '....\\(.*\\)'`
+
+		makedev ${dev} c 4 ${minor} ${uname} tty ${permissions}
+		;;
+	uds)
+		# Unix domain sockets device
+		makedev ${dev} c 18 0 ${uname} ${gname} 666
+		;;
+	vnd[0-7])
+		# Whole vnode disk devices.
+		makedev ${dev} b ${major} 0 ${uname} ${gname} ${permissions}
+		;;
+	vnd[0-7]p[0-3])
+		# Vnode disk primary partitions.
+		prefix=`expr ${dev} : '\\(.*\\).'`
+		disk=`expr ${dev} : '...\\(.\\)'`
+
+		for p in 0 1 2 3
+		do
+			minor=`expr 1 + ${p}`
+
+			makedev ${prefix}${p} b ${major} ${minor} \
+				${uname} ${gname} ${permissions}
+		done
+		;;
+	vnd[0-7]p[0-3]s[0-3])
+		# Vnode disk subpartition.
+		prefix=`expr ${dev} : '\\(.*\\)...'`
+		disk=`expr ${dev} : '...\\(.\\)'`
+
+		for p in 0 1 2 3
+		do
+			for s in 0 1 2 3
+			do
+				minor=`expr 128 + ${p} '*' 4 + ${s}`
+
+				makedev ${prefix}${p}s${s} b ${major} ${minor} \
+					${uname} ${gname} ${permissions}
+			done
+		done
+		;;
+	*)
+		echo "$0: don't know about ${dev}" >&2
+		EXIT=1
+	esac
+done
+
+exit $EXIT

commands/MAKEDEV/Makefile

@@ -1,4 +1,4 @@
 SCRIPTS= MAKEDEV.sh
-MAN=
+MAN= MAKEDEV.8
 
 .include <bsd.prog.mk>

commands/Makefile

@@ -6,11 +6,11 @@ SUBDIR=	add_route arp ash at backup btrace \
 	cawf cd cdprobe cpp \
 	chmod chown ci cleantmp cmp co \
 	comm compress cp crc cron crontab \
-	dd decomp16 DESCRIBE devmand devsize df dhcpd \
+	dd decomp16 DESCRIBE devmand devsize dhcpd \
-	dhrystone diff diskctl dumpcore \
+	dhrystone diff diskctl \
 	eject env factor fbdctl \
 	find fix fold format fortune fsck.mfs \
-	gcore gcov-pull getty grep hexdump host \
+	gcov-pull getty grep hexdump host \
 	hostaddr id ifconfig ifdef \
 	intr ipcrm ipcs irdpd isoread last \
 	less loadkeys loadramdisk logger look lp \
@@ -27,14 +27,16 @@ SUBDIR=	add_route arp ash at backup btrace \
 	stty svclog svrctl swifi synctree sysenv \
 	syslogd tail tcpd tcpdp tcpstat telnet \
 	telnetd term termcap tget time touch \
-	truncate tty udpstat umount uname \
+	truncate tty udpstat umount \
 	unstack update uud uue version vol \
 	whereis which write writeisofs fetch \
 	zdump zmodem pkgin_cd pkgin_all \
 	worldstone updateboot update_bootcfg \
 	atnormalize dosread fdisk loadfont \
 	autopart part partition playwave  \
-	recwave repartition screendump
+	recwave repartition screendump \
+	command echo expr false getopts read test true \
+       	umask wait
 
 .if ${MACHINE_ARCH} == "earm"
 SUBDIR+=	eepromread

commands/ash/Makefile

@@ -41,7 +41,7 @@ CPPFLAGS+= -I. -I${.CURDIR}
 # A. Generate C tools used to build ash
 .for tool in init nodes signames syntax
 ${.OBJDIR}/mk${tool}: ${.CURDIR}/mk${tool}.c
-	${HOST_CC} ${.ALLSRC} -o ${.TARGET}
+	${HOST_CC} ${HOST_CFLAGS} ${HOST_CPPFLAGS} ${.ALLSRC} -o ${.TARGET}
 
 CLEANFILES+= ${.OBJDIR}/mk${tool}
 .endfor

commands/cd/Makefile

@@ -2,17 +2,4 @@ SCRIPTS= cd.sh
 BINDIR=	/bin
 MAN=
 
-LINKS+=	${BINDIR}/cd ${BINDIR}/[
-LINKS+=	${BINDIR}/cd ${BINDIR}/command
-LINKS+=	${BINDIR}/cd ${BINDIR}/echo
-LINKS+=	${BINDIR}/cd ${BINDIR}/expr
-LINKS+=	${BINDIR}/cd ${BINDIR}/false
-LINKS+=	${BINDIR}/cd ${BINDIR}/getopts
-LINKS+=	${BINDIR}/cd ${BINDIR}/read
-LINKS+=	${BINDIR}/cd ${BINDIR}/test
-LINKS+=	${BINDIR}/cd ${BINDIR}/true
-LINKS+=	${BINDIR}/cd ${BINDIR}/umask
-LINKS+=	${BINDIR}/cd ${BINDIR}/wait
-
-
 .include <bsd.prog.mk>

commands/cd/cd.sh

@@ -1,11 +0,0 @@
-#!/bin/sh
-#
-# cd 1.3 - equivalents for normally builtin commands.	Author: Kees J. Bot
-
-case $0 in
-*/*)	command="`expr "$0" : '.*/\(.*\)'`"
-	;;
-*)	command="$0"
-esac
-
-"$command" "$@"

commands/cd/cd.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/command/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= command.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/command/command.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/df/Makefile

@@ -1,4 +0,0 @@
-PROG=	df
-MAN=
-
-.include <bsd.prog.mk>

commands/df/df.c

@@ -1,237 +0,0 @@
-/* df - disk free block printout	Author: Andy Tanenbaum
- *
- * 91/04/30 Kees J. Bot (kjb@cs.vu.nl)
- *	Map filename arguments to the devices they live on.
- *	Changed output to show percentages.
- *
- * 92/12/12 Kees J. Bot
- *	Posixized.  (Almost, the normal output is in kilobytes, it should
- *	be 512-byte units.  'df -P' and 'df -kP' are as it should be.)
- *
- */
-
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/statvfs.h>
-#include <sys/stat.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <minix/minlib.h>
-
-struct mtab {	/* List of mounted devices from /etc/mtab. */
-	struct mtab	*next;
-	dev_t		device;
-	char		*devname;
-	char		*mountpoint;
-} *mtab= NULL;
-
-struct mtab *searchtab(char *name);
-static void readmtab(const char *type);
-int df(const struct mtab *mt);
-
-int iflag= 0;	/* Focus on inodes instead of blocks. */
-int Pflag= 0;	/* Posix standard output. */
-int kflag= 0;	/* Output in kilobytes instead of 512 byte units for -P. */
-int istty;	/* isatty(1) */
-
-void usage(void)
-{
-	fprintf(stderr, "Usage: df [-ikP] [-t type] [device]...\n");
-	exit(1);
-}
-
-int unitsize;
-
-int main(int argc, char *argv[])
-{
-  int i;
-  struct mtab *mt;
-  char *type= "dev";
-  int ex= 0;
-
-  while (argc > 1 && argv[1][0] == '-') {
-  	char *opt= argv[1]+1;
-
-  	while (*opt != 0) {
-  		switch (*opt++) {
-  		case 'i':	iflag= 1;	break;
-  		case 'k':	kflag= 1;	break;
-  		case 'P':	Pflag= 1;	break;
-  		case 't':
-			if (argc < 3) usage();
-			type= argv[2];
-			argv++;
-			argc--;
-			break;
-		default:
-			usage();
-		}
-	}
-	argc--;
-	argv++;
-  }
-
-  istty= isatty(1);
-
-  readmtab(type);
- 
-  if(!Pflag || (Pflag && kflag)) unitsize = 1024;
-  else unitsize = 512;
-
-  if (Pflag) {
-	if (!iflag)
-		printf("\
-Filesystem    %4d-blocks      Used    Available  Capacity  Mounted on\n",
-			unitsize);
-	else
-		printf("\
-Filesystem         Inodes       IUsed      IFree    %%IUsed    Mounted on\n"
-		);
-  } else {
-	printf("%s\n", !iflag ? "\
-Filesystem      Size (kB)       Free       Used    % Files%   Mounted on" : "\
-Filesystem          Files       Free       Used    % BUsed%   Mounted on"
-	);
-  }
-
-  if (argc == 1) {
-	for (mt= mtab; mt != NULL; mt= mt->next) ex |= df(mt);
-  } else {
-	for (i = 1; i < argc; i++) ex |= df(searchtab(argv[i]));
-  }
-  exit(ex);
-}
-
-static void readmtab(const char *type)
-/* Turn the mounted file table into a list. */
-{
-  struct mtab **amt= &mtab, *new;
-  struct stat st;
-  char devname[PATH_MAX], mountpoint[PATH_MAX], version[MNTNAMELEN],
-	rw_flag[MNTFLAGLEN];
-
-  if (load_mtab("df") < 0) exit(1);
-
-  while (get_mtab_entry(devname, mountpoint, version, rw_flag),
-							  devname[0] != 0) {
-	if (strcmp(type, "dev") != 0 && strcmp(type, version) != 0) continue;
-
-	/* Make new list cell. */
-	if ((new= (struct mtab *) malloc(sizeof(*new))) == NULL
-	  || (new->devname= (char *) malloc(strlen(devname) + 1)) == NULL
-	  || (new->mountpoint= (char *) malloc(strlen(mountpoint) + 1)) == NULL
-	) break;
-
-	if (strcmp(devname, "none") != 0 && stat(devname, &st) == 0 &&
-	  S_ISBLK(st.st_mode)) {
-		new->device= st.st_rdev;
-	} else if (stat(mountpoint, &st) == 0) {
-		new->device= st.st_dev;
-	}
-	strcpy(new->devname, devname);
-	strcpy(new->mountpoint, mountpoint);
-
-	*amt= new;		/* Add the cell to the end. */
-	amt= &new->next;
-	*amt= NULL;
-  }
-}
-
-struct mtab *searchtab(char *name)
-/* See what we can do with a user supplied name, there are three possibilities:
- * 1. It's a device and it is in the mtab: Return mtab entry.
- * 2. It's a file and lives on a device in the mtab: Return mtab entry.
- * 3. It's anything else: Return something df() will choke on.
- */
-{
-  static struct mtab unknown;
-  struct mtab *mt;
-  struct stat st;
-
-  unknown.devname= name;
-  unknown.mountpoint= "";
-
-  if (stat(name, &st) < 0) return &unknown;	/* Case 3. */
-
-  unknown.device= S_ISBLK(st.st_mode) ? st.st_rdev : st.st_dev;
-
-  for (mt= mtab; mt != NULL; mt= mt->next) {
-	if (unknown.device == mt->device)
-		return mt;			/* Case 1 & 2. */
-  }
-
-  return &unknown;				/* Case 3. */
-}
-
-/* (num / tot) in percentages rounded up. */
-#define percent(num, tot) \
- ((tot > 0) ? ((int) ((100ULL * (num) + ((tot) - 1)) / (tot))) : 0)
-
-int df(const struct mtab *mt)
-{
-  long totblocks, busyblocks, totinodes, busyinodes;
-  struct statvfs sv;
-  int n;
-
-  if (statvfs(mt->mountpoint, &sv) < 0) {
-	fprintf(stderr, "df: %s: %s\n", mt->devname, strerror(errno));
-	return(1);
-  }
-
-  /* Print results. */
-  printf("%s", mt->devname);
-  n= strlen(mt->devname);
-  if (n > 15 && istty) { putchar('\n'); n= 0; }
-  while (n < 15) { putchar(' '); n++; }
-
-  totblocks = sv.f_blocks;
-  busyblocks = sv.f_blocks - sv.f_bfree;
-
-  busyblocks = busyblocks * (sv.f_bsize/512) / (unitsize/512);
-  totblocks = totblocks * (sv.f_bsize/512) / (unitsize/512);
-
-  totinodes = sv.f_files;
-  busyinodes = sv.f_files - sv.f_ffree;
-
-  if (!Pflag && !iflag) {
-	printf(" %9ld  %9ld  %9ld %3d%%   %3d%%   %s\n",
-		totblocks,				/* Blocks */
-		totblocks - busyblocks,			/* free */
-		busyblocks,				/* used */
-		percent(busyblocks, totblocks),		/* % */
-		percent(busyinodes, totinodes),		/* FUsed% */
-		mt->mountpoint				/* Mounted on */
-	);
-  }
-  if (!Pflag && iflag) {
-	printf(" %9ld  %9ld  %9ld %3d%%   %3d%%   %s\n",
-		totinodes,				/* Files */
-		totinodes - busyinodes,			/* free */
-		busyinodes,				/* used */
-		percent(busyinodes, totinodes),		/* % */
-		percent(busyblocks, totblocks),		/* BUsed% */
-		mt->mountpoint				/* Mounted on */
-	);
-  }
-  if (Pflag && !iflag) {
-	printf(" %9ld   %9ld  %9ld     %4d%%    %s\n",
-		totblocks,				/* Blocks */
-		busyblocks,				/* Used */
-		totblocks - busyblocks,			/* Available */
-		percent(busyblocks, totblocks),		/* Capacity */
-		mt->mountpoint				/* Mounted on */
-	);
-  }
-  if (Pflag && iflag) {
-	printf(" %9ld   %9ld  %9ld     %4d%%    %s\n",
-		totinodes,				/* Inodes */
-		busyinodes,				/* IUsed */
-		totinodes - busyinodes,			/* IAvail */
-		percent(busyinodes, totinodes),		/* Capacity */
-		mt->mountpoint				/* Mounted on */
-	);
-  }
-  return(0);
-}

commands/dumpcore/Makefile

@@ -1,5 +0,0 @@
-PROG=	dumpcore
-CPPFLAGS+= -I${NETBSDSRCDIR}
-MAN=
-
-.include <bsd.prog.mk>

commands/dumpcore/dumpcore.c

@@ -1,71 +0,0 @@
-/* dumpcore - create core file of running process */
-
-#include <fcntl.h>
-#include <unistd.h>	
-#include <minix/config.h>
-#include <minix/type.h>
-#include <minix/ipc.h>
-#include <minix/const.h>
-#include <sys/ptrace.h>
-#include <sys/wait.h>
-#include <signal.h>
-#include <timers.h>
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include <machine/archtypes.h>
-#include "kernel/proc.h"
-
-#define CLICK_WORDS (CLICK_SIZE / sizeof(unsigned long))
-
-int main(int argc, char *argv[])
-{
-	pid_t pid;
-	int r, status;
-
-	if(argc != 2) {
-		printf("usage: %s <pid>\n", argv[0]);
-		return 1;
-	}
-
-	pid = atoi(argv[1]);
-
-	if (ptrace(T_ATTACH, pid, 0, 0) != 0) {
-		perror("ptrace(T_ATTACH)");
-		return 1;
-	}
-
-	if (waitpid(pid, &status, 0) != pid) {
-		perror("waitpid");
-		return 1;
-	}
-
-	while (WIFSTOPPED(status) && WSTOPSIG(status) != SIGSTOP) {
-		/* whatever happens here is fine */
-		ptrace(T_RESUME, pid, 0, WSTOPSIG(status));
-
-		if (waitpid(pid, &status, 0) != pid) {
-			perror("waitpid");
-			return 1;
-		}
-	}
-
-	if (!WIFSTOPPED(status)) {
-		fprintf(stderr, "process died while attaching\n");
-		return 1;
-	}
-
-	if (ptrace(T_DUMPCORE, pid, 0, 0) != 0) {
-		fprintf(stderr, "warning, dumpcore failed (%s)\n",
-			strerror(errno));
-	}
-
-	if (ptrace(T_DETACH, pid, 0, 0)) {
-		fprintf(stderr, "warning, detaching failed (%s)\n",
-			strerror(errno));
-	}
-
-	return r;
-}

commands/echo/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= echo.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/echo/echo.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/expr/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= expr.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/expr/expr.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/false/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= false.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/false/false.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/fdisk/fdisk.c

@@ -75,7 +75,7 @@ char *secbuf;
 int badbases;
 int badsizes;
 int badorders;
-char *devname;
+char *dev_name;
 int nhead;
 int nsec;
 int ncyl = 1024;
@@ -161,9 +161,9 @@ int main(int argc, char *argv[])
   }
 
   if (argn == argc)
-	devname = DEFAULT_DEV;
+	dev_name = DEFAULT_DEV;
   else if (argn == argc - 1)
-	devname = argv[argn];
+	dev_name = argv[argn];
   else
 	usage();
 
@@ -232,7 +232,7 @@ void getgeom(void)
 
   if (override) return;
 
-  if ((fd= open(devname, O_RDONLY)) < 0) return;
+  if ((fd= open(dev_name, O_RDONLY)) < 0) return;
 
   r = ioctl(fd, DIOCGETP, &geom);
   close(fd);
@@ -242,21 +242,21 @@ void getgeom(void)
   nsec = geom.sectors;
   ncyl = geom.cylinders;
 
-  printf("Geometry of %s: %dx%dx%d\n", devname, ncyl, nhead, nsec);
+  printf("Geometry of %s: %dx%dx%d\n", dev_name, ncyl, nhead, nsec);
 }
 
 static int devfd;
 
 void getboot(char *buffer)
 {
-  devfd = open(devname, 2);
+  devfd = open(dev_name, 2);
   if (devfd < 0) {
-	printf("No write permission on %s\n", devname);
+	printf("No write permission on %s\n", dev_name);
 	readonly = 1;
-	devfd = open(devname, 0);
+	devfd = open(dev_name, 0);
   }
   if (devfd < 0) {
-	printf("Cannot open device %s\n", devname);
+	printf("Cannot open device %s\n", dev_name);
 	exit(1);
   }
   if (read(devfd, buffer, SECSIZE) != SECSIZE) {
@@ -264,7 +264,7 @@ void getboot(char *buffer)
 	exit(1);
   }
   if (* (unsigned short *) &buffer[510] != 0xAA55) {
-	printf("Invalid boot sector on %s.\n", devname);
+	printf("Invalid boot sector on %s.\n", dev_name);
 	printf("Partition table reset and boot code installed.\n");
 	memset(buffer, 0, 512);
 	memcpy(buffer, bootstrap, sizeof(bootstrap));
@@ -514,8 +514,8 @@ int chk_table(void)
 		printf(
 	"Disk appears to have mis-specified number of heads or sectors.\n");
 		printf("Try  fdisk -h%d -s%d %s  instead of\n",
-			maxhead + 1, maxsec, devname);
+			maxhead + 1, maxsec, dev_name);
-		printf("     fdisk -h%d -s%d %s\n", nhead, nsec, devname);
+		printf("     fdisk -h%d -s%d %s\n", nhead, nsec, dev_name);
 		seenpart = 0;
 	}
   } else {
@@ -695,12 +695,12 @@ void getboot(char *buffer)
 
   segread(&sregs);		/* get ds */
 
-  if (devname[1] != ':') {
+  if (dev_name[1] != ':') {
-	printf("Invalid drive %s\n", devname);
+	printf("Invalid drive %s\n", dev_name);
 	exit(1);
   }
-  if (*devname >= 'a') *devname += 'A' - 'a';
+  if (*dev_name >= 'a') *dev_name += 'A' - 'a';
-  drivenum = (*devname - 'C') & 0xff;
+  drivenum = (*dev_name - 'C') & 0xff;
   if (drivenum < 0 || drivenum > 7) {
 	printf("Funny drive number %d\n", drivenum);
 	exit(1);

commands/fsck.mfs/fsck.c

@@ -686,7 +686,7 @@ char **clist;
 		if (input(buf, 80)) ip->i_mode = atoo(buf);
 		printf("    nlinks = %6u", ip->i_nlinks);
 		if (input(buf, 80)) ip->i_nlinks = atol(buf);
-		printf("    size   = %6ld", ip->i_size);
+		printf("    size   = %6d", ip->i_size);
 		if (input(buf, 80)) ip->i_size = atol(buf);
 		if (yes("Write this back")) {
 			devwrite(inoblock(ino), inooff(ino), (char *) ip,

commands/gcore/Makefile

@@ -1,4 +0,0 @@
-PROG=  gcore
-MAN=
-
-.include <bsd.prog.mk>

commands/gcore/gcore.c

@@ -1,58 +0,0 @@
-/* gcore - create core file of running process */
-
-#include <sys/types.h>
-#include <sys/ptrace.h>
-#include <sys/wait.h>
-#include <signal.h>
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-int main(int argc, char *argv[])
-{
-  pid_t pid;
-  int status;
-
-  if(argc != 2) {
-	printf("usage: %s <pid>\n", argv[0]);
-	return 1;
-  }
-
-  pid = atoi(argv[1]);
-
-  if (ptrace(T_ATTACH, pid, 0, 0) != 0) {
-	perror("ptrace(T_ATTACH)");
-	return 1;
-  }
-
-  if (waitpid(pid, &status, 0) != pid) {
-	perror("waitpid");
-	return 1;
-  }
-
-  while (WIFSTOPPED(status) && WSTOPSIG(status) != SIGSTOP) {
-	/* whatever happens here is fine */
-	ptrace(T_RESUME, pid, 0, WSTOPSIG(status));
-
-	if (waitpid(pid, &status, 0) != pid) {
-		perror("waitpid");
-		return 1;
-	}
-  }
-
-  if (!WIFSTOPPED(status)) {
-	fprintf(stderr, "process died while attaching\n");
-	return 1;
-  }
-
-  if (ptrace(T_DUMPCORE, pid, 0, 0)) {
-	fprintf(stderr, "warning, dumpcore failed (%s)\n", strerror(errno));
-  }
-
-  if (ptrace(T_DETACH, pid, 0, 0)) {
-	fprintf(stderr, "warning, detaching failed (%s)\n", strerror(errno));
-  }
-
-  return 0;
-}

commands/getopts/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= getopts.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/getopts/getopts.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/getty/getty.c

@@ -88,7 +88,7 @@ void do_getty(char *name, size_t len, char **args, const char *ttyname)
   int ch;
   struct utsname utsname;
   char **banner, *t;
-  static char *def_banner[] = { "%s  Release %r Version %v  (%t)\n\n%n login: ", 0 };
+  static char *def_banner[] = { "%s/%p (%t)\n\n%n login: ", 0 };
 
   /* Clean up tty name. */
   if((t = strrchr(ttyname, '/'))) ttyname = t + 1;

commands/loadkeys/loadkeys.c

@@ -6,86 +6,51 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 #include <errno.h>
 
-#if __minix_vmd
-#define KBD_DEVICE	"/dev/kbd"
-#else
 #define KBD_DEVICE	"/dev/console"
-#endif
-
-u16_t keymap[NR_SCAN_CODES * MAP_COLS];
-u8_t comprmap[4 + NR_SCAN_CODES * MAP_COLS * 9/8 * 2 + 1];
-
-
-void tell(char *s)
-{
-  write(2, s, strlen(s));
-}
-
 
 void fatal(char *say)
 {
-  int err = errno;
+  fprintf(stderr, "loadkeys: %s: %s\n", say, strerror(errno));
-  tell("loadkeys: ");
+  exit(EXIT_FAILURE);
-  if (say != NULL) {
-	tell(say);
-	tell(": ");
-  }
-  tell(strerror(err));
-  tell("\n");
-  exit(1);
 }
 
 
 void usage(void)
 {
-  tell("Usage: loadkeys mapfile\n");
+  fprintf(stderr, "usage: loadkeys <mapfile>\n");
-  exit(1);
+  exit(EXIT_FAILURE);
 }
 
 
 int main(int argc, char *argv[])
 {
-  u8_t *cm;
+  char sig[4];
-  u16_t *km;
+  keymap_t keymap;
-  int fd, n, fb;
+  int fd;
 
   if (argc != 2)
 	usage();
 
   if ((fd = open(argv[1], O_RDONLY)) < 0) fatal(argv[1]);
 
-  if (read(fd, comprmap, sizeof(comprmap)) < 0) fatal(argv[1]);
+  if (read(fd, sig, sizeof(sig)) < sizeof(sig)) fatal(argv[1]);
 
-  if (memcmp(comprmap, KEY_MAGIC, 4) != 0) {
+  if (memcmp(sig, KEY_MAGIC, sizeof(sig)) != 0) {
-	tell("loadkeys: ");
+	fprintf(stderr, "loadkeys: %s: not a keymap file\n", argv[1]);
-	tell(argv[1]);
+	return EXIT_FAILURE;
-	tell(": not a keymap file\n");
-	exit(1);
   }
+
+  if (read(fd, keymap, sizeof(keymap)) < sizeof(keymap)) fatal(argv[1]);
+
   close(fd);
 
-  /* Decompress the keymap data. */
-  cm = comprmap + 4;
-  n = 8;
-  for (km = keymap; km < keymap + NR_SCAN_CODES * MAP_COLS; km++) {
-	if (n == 8) {
-		/* Need a new flag byte. */
-		fb = *cm++;
-		n = 0;
-	}
-	*km = *cm++;			/* Low byte. */
-	if (fb & (1 << n)) {
-		*km |= (*cm++ << 8);	/* One of the few special keys. */
-	}
-	n++;
-  }
-
   if ((fd = open(KBD_DEVICE, O_WRONLY)) < 0) fatal(KBD_DEVICE);
 
   if (ioctl(fd, KIOCSMAP, keymap) < 0) fatal(KBD_DEVICE);
 
-  return 0;
+  return EXIT_SUCCESS;
 }

commands/mount/mount.c

@@ -24,11 +24,12 @@ int main(argc, argv)
 int argc;
 char *argv[];
 {
-  int all = 0, i, v = 0, mountflags;
+  int all = 0, i, v = 0, mountflags, srvflags;
   char **ap, *opt, *err, *type, *args, *device;
 
   if (argc == 1) list();	/* just list /etc/mtab */
   mountflags = 0;
+  srvflags = 0;
   type = NULL;
   args = NULL;
   ap = argv+1;
@@ -36,12 +37,12 @@ char *argv[];
 	if (argv[i][0] == '-') {
 		opt = argv[i]+1;
 		while (*opt != 0) switch (*opt++) {
-		case 'r':	mountflags |= MS_RDONLY;	break;
+		case 'r':	mountflags |= MNT_RDONLY;	break;
 		case 't':	if (++i == argc) usage();
 				type = argv[i];
 				break;
-		case 'i':	mountflags |= MS_REUSE;		break;
+		case 'i':	srvflags |= MS_REUSE;		break;
-		case 'e':	mountflags |= MS_EXISTING;		break;
+		case 'e':	srvflags |= MS_EXISTING;		break;
 		case 'n':	write_mtab = 0;			break;
 		case 'o':	if (++i == argc) usage();
 				args = argv[i];
@@ -75,7 +76,7 @@ char *argv[];
 	}
   }
   
-  if (mount(device, argv[2], mountflags, type, args) < 0) {
+  if (mount(device, argv[2], mountflags, srvflags, type, args) < 0) {
 	err = strerror(errno);
 	fprintf(stderr, "mount: Can't mount %s on %s: %s\n",
 		argv[1], argv[2], err);
@@ -141,7 +142,7 @@ mount_all()
 		if (has_opt(fs->fs_mntops, "ro"))
 			ro = 1;
 		if (ro) {
-			mountflags |= MS_RDONLY;
+			mountflags |= MNT_RDONLY;
 		}
 
 		device = fs->fs_spec;
@@ -152,7 +153,7 @@ mount_all()
 		if (!strcmp(device, "none")) 
 			device = NULL;
 
-		if (mount(device, mountpoint, mountflags, fs->fs_vfstype,
+		if (mount(device, mountpoint, mountflags, 0, fs->fs_vfstype,
 		    fs->fs_mntops) != 0) {
 			err = strerror(errno);
 			fprintf(stderr, "mount: Can't mount %s on %s: %s\n",

commands/playwave/playwave.c

@@ -66,15 +66,36 @@ void usage()
   exit(-1);
 }
 
+int open_audio(unsigned int *fragment_size, unsigned int channels,
+	unsigned int samples_per_sec, unsigned int bits)
+{
+  unsigned int sign;
+  int audio;
+
+  /* Open DSP */
+  if ((audio = open("/dev/audio", O_RDWR | O_REOPEN)) < 0)
+  {
+    printf("Cannot open /dev/audio: %s\n", strerror(errno));
+    exit(-1);
+  }
+
+  ioctl(audio, DSPIOMAX, fragment_size); /* Get maximum fragment size. */
+
+  /* Set DSP parameters (should check return values..) */
+  ioctl(audio, DSPIOSIZE, fragment_size);	/* Use max. fragment size. */
+  ioctl(audio, DSPIOSTEREO, &channels);
+  ioctl(audio, DSPIORATE, &samples_per_sec);
+  ioctl(audio, DSPIOBITS, &bits);
+  sign = (bits == 16 ? 1 : 0);
+  ioctl(audio, DSPIOSIGN, &sign);
+  return audio;
+}
 
 int main ( int argc, char *argv[] )
 {
   int i, r, audio, file;
   char *buffer, *file_name = NULL;
-  unsigned int sign;
+  unsigned int fragment_size, fragment_size2;
-  unsigned int fragment_size;
-  unsigned int channels;
-  unsigned int bits;
   long data_pos;  
   int showinfo = 0;
 
@@ -91,22 +112,6 @@ int main ( int argc, char *argv[] )
   }
   else file_name = argv[1];
 
-  /* Open DSP */
-  if ((audio = open("/dev/audio", O_RDWR | O_REOPEN)) < 0) 
-  {
-    printf("Cannot open /dev/audio: %s\n", strerror(errno));
-    exit(-1);
-  }
-
-  /* Get maximum fragment size and try to allocate a buffer */
-  ioctl(audio, DSPIOMAX, &fragment_size);
-  if ((buffer = malloc(fragment_size)) == (char *)0)
-  {
-    fprintf(stderr, "Cannot allocate buffer\n");
-    exit(-1);
-  } 
-  ioctl(audio, DSPIOSIZE, &fragment_size);
-
   /* Open wav file */
   if((file = open(file_name, O_RDONLY)) < 0)
   {
@@ -141,15 +146,15 @@ int main ( int argc, char *argv[] )
     exit(1);
   }
 
-  /* Set DSP parameters */
+  /* Open audio device and set DSP parameters */
-  channels = c_fields.Channels;
+  audio = open_audio(&fragment_size, c_fields.Channels - 1,
-  channels--;
+	c_fields.SamplesPerSec, s_fields.BitsPerSample);
-  bits = s_fields.BitsPerSample;
+
-  ioctl(audio, DSPIOSTEREO, &channels); 
+  if ((buffer = malloc(fragment_size)) == (char *)0)
-  ioctl(audio, DSPIORATE, &c_fields.SamplesPerSec);
+  {
-  ioctl(audio, DSPIOBITS, &bits); 
+    fprintf(stderr, "Cannot allocate buffer\n");
-  sign = (bits == 16 ? 1 : 0);
+    exit(-1);
-  ioctl(audio, DSPIOSIGN, &sign); 
+  }
 
   /* Goto data chunk */
   lseek(file, data_pos, SEEK_SET);
@@ -203,6 +208,20 @@ int main ( int argc, char *argv[] )
 	{
 		fprintf(stderr, "playwave: write to audio device failed: %s\n",
 			strerror(errno));
+
+		/* If we get EIO, the driver might have restarted. Reopen the
+		 * audio device.
+		 */
+		if (errno == EIO) {
+			close(audio);
+			audio = open_audio(&fragment_size2,
+				c_fields.Channels - 1, c_fields.SamplesPerSec,
+				s_fields.BitsPerSample);
+			if (fragment_size2 != fragment_size) {
+			    fprintf(stderr, "Fragment size has changed\n");
+			    exit(1);
+			}
+		}
 	}
 	else
 	{

commands/ps/ps.c

@@ -203,7 +203,6 @@ static char *prrecv(struct pstat *ps)
 	case FSTATE_LOCK: blkstr = "flock"; break;
 	case FSTATE_POPEN: blkstr = "popen"; break;
 	case FSTATE_SELECT: blkstr = "select"; break;
-	case FSTATE_DOPEN: blkstr = "dopen"; break;
 	case FSTATE_TASK: blkstr = taskname(ps->ps_ftask); break;
 	default: blkstr = "??"; break;
 	}

commands/read/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= read.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/read/read.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/service/parse.c

@@ -26,7 +26,7 @@
 #include <configfile.h>
 
 #include <machine/archtypes.h>
-#include <timers.h>
+#include <minix/timers.h>
 #include "kernel/proc.h"
 
 #include "config.h"
@@ -519,7 +519,7 @@ static void do_io(config_t *cpe, struct rs_start *rs_start)
 
 static void do_pci_device(config_t *cpe, struct rs_start *rs_start)
 {
-	u16_t vid, did;
+	u16_t vid, did, sub_vid, sub_did;
 	char *check, *check2;
 
 	/* Process a list of PCI device IDs */
@@ -536,13 +536,26 @@ static void do_pci_device(config_t *cpe, struct rs_start *rs_start)
 				cpe->file, cpe->line);
 		}
 		vid= strtoul(cpe->word, &check, 0x10);
-		if (check[0] == '/')
+		if (check[0] != ':' && /* LEGACY: */ check[0] != '/') {
-			did= strtoul(check+1, &check2, 0x10);
-		if (check[0] != '/' || check2[0] != '\0')
-		{
 			fatal("do_pci_device: bad ID '%s' at %s:%d",
 				cpe->word, cpe->file, cpe->line);
 		}
+		did= strtoul(check+1, &check, 0x10);
+		if (check[0] == '/') {
+			sub_vid= strtoul(check+1, &check, 0x10);
+			if (check[0] == ':')
+				sub_did= strtoul(check+1, &check2, 0x10);
+			if (check[0] != ':' || check2[0] != '\0') {
+				fatal("do_pci_device: bad ID '%s' at %s:%d",
+					cpe->word, cpe->file, cpe->line);
+			}
+		} else if (check[0] != '\0') {
+			fatal("do_pci_device: bad ID '%s' at %s:%d",
+				cpe->word, cpe->file, cpe->line);
+		} else {
+			sub_vid = NO_SUB_VID;
+			sub_did = NO_SUB_DID;
+		}
 		if (rs_start->rss_nr_pci_id >= RS_NR_PCI_DEVICE)
 		{
 			fatal("do_pci_device: too many device IDs (max %d)",
@@ -550,6 +563,8 @@ static void do_pci_device(config_t *cpe, struct rs_start *rs_start)
 		}
 		rs_start->rss_pci_id[rs_start->rss_nr_pci_id].vid= vid;
 		rs_start->rss_pci_id[rs_start->rss_nr_pci_id].did= did;
+		rs_start->rss_pci_id[rs_start->rss_nr_pci_id].sub_vid= sub_vid;
+		rs_start->rss_pci_id[rs_start->rss_nr_pci_id].sub_did= sub_did;
 		rs_start->rss_nr_pci_id++;
 	}
 }
@@ -734,6 +749,7 @@ struct
 	{ "PROCCTL",		VM_PROCCTL },
 	{ "MAPCACHEPAGE",	VM_MAPCACHEPAGE },
 	{ "SETCACHEPAGE",	VM_SETCACHEPAGE },
+	{ "CLEARCACHE",		VM_CLEARCACHE },
 	{ "VFS_MMAP",		VM_VFS_MMAP },
 	{ "VFS_REPLY",		VM_VFS_REPLY },
 	{ NULL,			0 },

commands/service/print.c

@@ -25,7 +25,7 @@
 #include <configfile.h>
 
 #include <machine/archtypes.h>
-#include <timers.h>
+#include <minix/timers.h>
 #include <err.h>
 
 #include "config.h"

commands/service/service.8

@@ -5,7 +5,7 @@ service \- Manage an operating system service.
 .PP
 \fBservice [-b -c -n -p -r] (up|run|edit|update)\fR \fI<binary|self>\fR
 [\fB-args\fR \fI<args>\fR] [\fB-dev\fR \fI<special>\fR]
-[\fB-devstyle\fR \fI<style>\fR] [\fB-period\fR \fI<ticks>\fR]
+[\fB-period\fR \fI<ticks>\fR]
 [\fB-script\fR \fI<path>\fR] [\fB-label\fR \fI<name>\fR]
 [\fB-config\fR \fI<path>\fR] [\fB-state\fR \fI<state>\fR]
 [\fB-maxtime\fR \fI<time>\fR]
@@ -103,12 +103,6 @@ given by \fI<binary>\fR. The default is to use no arguments.
 specifies the device file to associate to the system service (used only for
 device drivers). The default is to associate no device file to the service.
 .TP
-.BI \-devstyle " <style>"
-specifies the device style to associate to the system service (used only for
-device drivers). The list of supported device styles is available in
-the header file \fB<minix/dmap.h>\fR.
-The default is to associate no device style (\fBSTYLE_NDEV\fR) to the service.
-.TP
 .BI \-period " <ticks>"
 specifies the period to use for the system service.
 When a period is specified, \fBRS\fR sends a ping request to
@@ -160,7 +154,7 @@ label \fI<name>\fR. This action can be used to dynamically update the
 properties of any system service, including those contained in the
 boot image (e.g. \fBVM\fR). There are a few exceptions to the properties
 that can be actually overridden dynamically. For example, the device file
-and the device style associated to the service will no be updated. This
+associated to the service will no be updated. This
 action takes the same options supported by the \fBup\fR action.
 .PP
 .SS

commands/service/service.c

@@ -32,7 +32,7 @@
 #include <configfile.h>
 
 #include <machine/archtypes.h>
-#include <timers.h>
+#include <minix/timers.h>
 #include <err.h>
 #include "kernel/proc.h"
 
@@ -86,7 +86,6 @@ static char *known_requests[] = {
 #define ARG_ARGS	"-args"		/* list of arguments to be passed */
 #define ARG_DEV		"-dev"		/* major device number for drivers */
 #define ARG_MAJOR	"-major"	/* major number */
-#define ARG_DEVSTYLE	"-devstyle"	/* device style */
 #define ARG_PERIOD	"-period"	/* heartbeat period in ticks */
 #define ARG_SCRIPT	"-script"	/* name of the script to restart a
 					 * system service
@@ -113,7 +112,6 @@ static char *req_path_self = SELF_REQ_PATH;
 static char *req_args = "";
 static int req_major = 0;
 static int devman_id = 0;
-static int req_dev_style = STYLE_NDEV;
 static long req_period = 0;
 static char *req_script = NULL;
 static char *req_config = PATH_CONFIG;
@@ -131,9 +129,9 @@ static void print_usage(char *app_name, char *problem)
   fprintf(stderr, "Warning, %s\n", problem);
   fprintf(stderr, "Usage:\n");
   fprintf(stderr,
-  "    %s [%s %s %s %s] (up|run|edit|update) <binary|%s> [%s <args>] [%s <special>] [%s <style>] [%s <major_nr>] [%s <dev_id>] [%s <ticks>] [%s <path>] [%s <name>] [%s <path>] [%s <state>] [%s <time>]\n", 
+  "    %s [%s %s %s %s] (up|run|edit|update) <binary|%s> [%s <args>] [%s <special>] [%s <major_nr>] [%s <dev_id>] [%s <ticks>] [%s <path>] [%s <name>] [%s <path>] [%s <state>] [%s <time>]\n", 
 	app_name, OPT_COPY, OPT_REUSE, OPT_NOBLOCK, OPT_REPLICA, SELF_BINARY,
-	ARG_ARGS, ARG_DEV, ARG_DEVSTYLE, ARG_MAJOR, ARG_DEVMANID, ARG_PERIOD, ARG_SCRIPT,
+	ARG_ARGS, ARG_DEV, ARG_MAJOR, ARG_DEVMANID, ARG_PERIOD, ARG_SCRIPT,
 	ARG_LABELNAME, ARG_CONFIG, ARG_LU_STATE, ARG_LU_MAXTIME);
   fprintf(stderr, "    %s down <label>\n", app_name);
   fprintf(stderr, "    %s refresh <label>\n", app_name);
@@ -315,9 +313,6 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
 				  exit(EINVAL);
 			  }
               req_major = major(stat_buf.st_rdev);
-              if(req_dev_style == STYLE_NDEV) {
-                  req_dev_style = STYLE_DEV;
-              }
           }
 		  else if (strcmp(argv[i], ARG_MAJOR)==0) {
 			  if (req_major != 0) {
@@ -329,26 +324,7 @@ static int parse_arguments(int argc, char **argv, u32_t *rss_flags)
 			 } else {
 				 exit(EINVAL);
 			 }
-			 if(req_dev_style == STYLE_NDEV) {
-                  req_dev_style = STYLE_DEV;
-              }
 		  }
-          else if (strcmp(argv[i], ARG_DEVSTYLE)==0) {
-              char* dev_style_keys[] = { "STYLE_DEV", "STYLE_DEVA", "STYLE_TTY",
-                  "STYLE_CTTY", "STYLE_CLONE", "STYLE_CLONE_A", NULL };
-              int dev_style_values[] = { STYLE_DEV, STYLE_DEVA, STYLE_TTY,
-                  STYLE_CTTY, STYLE_CLONE, STYLE_CLONE_A };
-              for(j=0;dev_style_keys[j]!=NULL;j++) {
-                  if(!strcmp(dev_style_keys[j], argv[i+1])) {
-                      break;
-                  }
-              }
-              if(dev_style_keys[j] == NULL) {
-                  print_usage(argv[ARG_NAME], "bad device style");
-                  exit(EINVAL);
-              }
-              req_dev_style = dev_style_values[j];
-          }
           else if (strcmp(argv[i], ARG_SCRIPT)==0) {
               req_script = argv[i+1];
           }
@@ -466,7 +442,6 @@ int main(int argc, char **argv)
       config.rs_start.rss_cmd= command;
       config.rs_start.rss_cmdlen= strlen(command);
       config.rs_start.rss_major= req_major;
-      config.rs_start.rss_dev_style= req_dev_style;
       config.rs_start.rss_period= req_period;
       config.rs_start.rss_script= req_script;
       config.rs_start.devman_id= devman_id;

commands/setup/setup.sh

@@ -432,9 +432,9 @@ then
 
 	# Get sizes and space availability while the file systems are still
 	# mounted. Otherwise we have to mount them again just for this.
-	required_root_space=`df -k /dev/$root | awk '{print $4}' | tail -n 1`
+	required_root_space=`df -kP /dev/$root | awk '{print $3}' | tail -n 1`
-	free_root_space=`df -k /dev/$root | awk '{print $3}' | tail -n 1`
+	free_root_space=`df -kP /dev/$root | awk '{print $4}' | tail -n 1`
-	free_usr_space=`df -k /dev/$usr | awk '{print $3}' | tail -n 1`
+	free_usr_space=`df -kP /dev/$usr | awk '{print $4}' | tail -n 1`
 
 	umount /mnt/usr && umount /mnt || exit
 

commands/shared/README

@@ -0,0 +1,22 @@
+builtin.sh is installed as a set of tools to stand in for specific
+filesystem call to builtin commands.
+
+for example if /bin/test is used, then builtin.sh will be loaded
+and simply call the builtin function of the same name.
+
+At this moment it is installed as the following commands:
+/bin/[
+/bin/command
+/bin/echo
+/bin/expr
+/bin/false
+/bin/getopts
+/bin/read
+/bin/test
+/bin/true
+/bin/umask
+/bin/wait
+
+If one of the following is replaced by the NetBSD equivalent, please
+update the list, and remove this completly when it is not anymore
+required.

commands/shared/builtin.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+#
+# cd 1.3 - equivalents for normally builtin commands.	Author: Kees J. Bot
+
+case $0 in
+*/*)	command="`expr "$0" : '.*/\(.*\)'`"
+	;;
+*)	command="$0"
+esac
+
+"$command" "$@"

commands/test/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= test.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/test/test.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/true/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= true.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/true/true.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/umask/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= umask.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/umask/umask.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

commands/umount/umount.c

@@ -47,7 +47,7 @@ char *argv[];
  
   found = find_mtab_entry(name);
 
-  if (umount2(name, umount_flags) < 0) {
+  if (umount(name, umount_flags) < 0) {
 	if (errno == EINVAL)
 		std_err("umount: Device not mounted\n");
 	else if (errno == ENOTBLK)

commands/uname/Makefile

@@ -1,6 +0,0 @@
-PROG=	uname
-MAN=
-
-LINKS+=      ${BINDIR}/uname ${BINDIR}/arch
-
-.include <bsd.prog.mk>

commands/uname/uname.c

@@ -1,124 +0,0 @@
-/*  uname - print system name			Author: Earl Chew */
-
-/* Print the following system information as returned by the uname()
- * function:
- *
- *	system name		Minix
- *	node name		waddles
- *	release name		1.5
- *	version			10
- *	machine name		i86
- *	arch			i86	(Minix specific)
- */
-
-#include <sys/types.h>
-#include <sys/utsname.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-/* Define the uname components. */
-#define ALL	 ((unsigned) 0x1F)
-#define SYSNAME  ((unsigned) 0x01)
-#define NODENAME ((unsigned) 0x02)
-#define RELEASE  ((unsigned) 0x04)
-#define U_MACHINE  ((unsigned) 0x10)
-#define ARCH     ((unsigned) 0x20)
-
-int main(int argc, char **argv );
-void print(int fd, ... );
-void usage(void );
-
-#ifdef __STDC__
-void print(int fd, ...)
-#else
-void print(fd)
-int fd;
-#endif
-{
-/* Print a sequence of strings onto the named channel. */
-  va_list argp;
-  char *p;
-
-  va_start(argp, fd);
-  while (1) {
-	p = va_arg(argp, char *);
-	if (p == (char *) NULL) break;
-	write(fd, p, strlen(p));
-  }
-  va_end(argp);
-}
-
-char *name;
-
-void usage()
-{
-  print(STDERR_FILENO, "Usage: ", name, " -snrvmpa\n", (char *) NULL);
-  exit(EXIT_FAILURE);
-}
-
-int main(argc, argv)
-int argc;
-char **argv;
-{
-  int info;
-  char *p;
-  struct utsname un;
-
-  name = strrchr(argv[0], '/');
-  if (name == NULL) name = argv[0]; else name++;
-
-  for (info = 0; argc > 1; argc--, argv++) {
-  	if (argv[1][0] == '-') {
-  		for (p = &argv[1][1]; *p; p++) {
-  			switch (*p) {
-				case 'a': info |= ALL;      break;
-				case 'm': info |= U_MACHINE;  break;
-				case 'n': info |= NODENAME; break;
-				case 'r': info |= RELEASE;  break;
-				case 's': info |= SYSNAME;  break;
-				case 'v': info |= RELEASE;  break;
-				case 'p': info |= ARCH;     break;
-				default: usage();
-  			}
-		}
-	} else {
-		usage();
-	}
-  }
-
-  if (info == 0) info = strcmp(name, "arch") == 0 ? ARCH : SYSNAME;
-
-  if (uname(&un) != 0) {
-	print(STDERR_FILENO, "unable to determine uname values\n", (char *) NULL);
-	exit(EXIT_FAILURE);
-  }
-
-  if ((info & SYSNAME) != 0)
-	print(STDOUT_FILENO, un.sysname, (char *) NULL);
-  if ((info & NODENAME) != 0) {
-	if ((info & (SYSNAME)) != 0)
-		print(STDOUT_FILENO, " ", (char *) NULL);
-	print(STDOUT_FILENO, un.nodename, (char *) NULL);
-  }
-  if ((info & RELEASE) != 0) {
-	if ((info & (SYSNAME|NODENAME)) != 0)
-		print(STDOUT_FILENO, " ", (char *) NULL);
-	print(STDOUT_FILENO, un.release, (char *) NULL);
-	print(STDOUT_FILENO, ".", (char *) NULL);
-	print(STDOUT_FILENO, un.version, (char *) NULL);
-  }
-  if ((info & U_MACHINE) != 0) {
-	if ((info & (SYSNAME|NODENAME|RELEASE)) != 0)
-		print(STDOUT_FILENO, " ", (char *) NULL);
-	print(STDOUT_FILENO, un.machine, (char *) NULL);
-  }
-  if ((info & ARCH) != 0) {
-	if ((info & (SYSNAME|NODENAME|RELEASE|U_MACHINE)) != 0)
-		print(STDOUT_FILENO, " ", (char *) NULL);
-	print(STDOUT_FILENO, un.arch, (char *) NULL);
-  }
-  print(STDOUT_FILENO, "\n", (char *) NULL);
-  return EXIT_SUCCESS;
-}

commands/wait/Makefile

@@ -0,0 +1,5 @@
+SCRIPTS= wait.sh
+BINDIR=	/bin
+MAN=
+
+.include <bsd.prog.mk>

commands/wait/wait.sh

@@ -0,0 +1 @@
+../shared/builtin.sh

distrib/sets/lists/minix/md.evbarm

@@ -1,18 +1,16 @@
-./boot/minix/.temp/mod07_log		minix-sys
+./boot/minix/.temp/mod07_tty		minix-sys
-./boot/minix/.temp/mod08_tty		minix-sys
+./boot/minix/.temp/mod08_mfs		minix-sys
-./boot/minix/.temp/mod09_mfs		minix-sys
+./boot/minix/.temp/mod09_vm		minix-sys
-./boot/minix/.temp/mod10_vm		minix-sys
+./boot/minix/.temp/mod10_pfs		minix-sys
-./boot/minix/.temp/mod11_pfs		minix-sys
+./boot/minix/.temp/mod11_init		minix-sys
-./boot/minix/.temp/mod12_init		minix-sys
 ./etc/rc.capes				minix-sys
 ./etc/rc.capes/BB-BONE-WTHR-01		minix-sys
 ./etc/system.conf.d/lan8710a		minix-sys
-./multiboot/mod07_log			minix-sys
+./multiboot/mod07_tty			minix-sys
-./multiboot/mod08_tty			minix-sys
+./multiboot/mod08_mfs			minix-sys
-./multiboot/mod09_mfs			minix-sys
+./multiboot/mod09_vm			minix-sys
-./multiboot/mod10_vm			minix-sys
+./multiboot/mod10_pfs			minix-sys
-./multiboot/mod11_pfs			minix-sys
+./multiboot/mod11_init			minix-sys
-./multiboot/mod12_init			minix-sys
 ./sbin/gpio				minix-sys
 ./usr/bin/eepromread			minix-sys
 ./usr/include/arm			minix-sys

distrib/sets/lists/minix/md.i386

@@ -1,10 +1,9 @@
 
-./boot/minix/.temp/mod07_log		minix-sys
+./boot/minix/.temp/mod07_tty		minix-sys
-./boot/minix/.temp/mod08_tty		minix-sys
+./boot/minix/.temp/mod08_mfs		minix-sys
-./boot/minix/.temp/mod09_mfs		minix-sys
+./boot/minix/.temp/mod09_vm		minix-sys
-./boot/minix/.temp/mod10_vm		minix-sys
+./boot/minix/.temp/mod10_pfs		minix-sys
-./boot/minix/.temp/mod11_pfs		minix-sys
+./boot/minix/.temp/mod11_init		minix-sys
-./boot/minix/.temp/mod12_init		minix-sys
 ./etc/system.conf.d/atl2		minix-sys
 ./etc/system.conf.d/dec21140A		minix-sys
 ./etc/system.conf.d/e1000		minix-sys
@@ -13,16 +12,16 @@
 ./etc/system.conf.d/rtl8139		minix-sys
 ./etc/system.conf.d/rtl8169		minix-sys
 ./etc/system.conf.d/virtio_net		minix-sys
-./multiboot/mod07_log			minix-sys
+./multiboot/mod07_tty			minix-sys
-./multiboot/mod08_tty			minix-sys
+./multiboot/mod08_mfs			minix-sys
-./multiboot/mod09_mfs			minix-sys
+./multiboot/mod09_vm			minix-sys
-./multiboot/mod10_vm			minix-sys
+./multiboot/mod10_pfs			minix-sys
-./multiboot/mod11_pfs			minix-sys
+./multiboot/mod11_init			minix-sys
-./multiboot/mod12_init			minix-sys
 ./sbin/ahci				minix-sys
 ./sbin/at_wini				minix-sys
 ./sbin/floppy				minix-sys
 ./sbin/hgfs				minix-sys
+./sbin/pckbd				minix-sys
 ./sbin/vbfs				minix-sys
 ./sbin/virtio_blk			minix-sys
 ./usr/include/gcc-4.5/abmintrin.h	minix-sys	gcccmds

drivers/Makefile

@@ -6,25 +6,25 @@
 .if ${MKIMAGEONLY} == "yes"
 
 .if ${MACHINE_ARCH} == "i386"
-SUBDIR=	at_wini floppy log tty pci
+SUBDIR=	at_wini floppy tty pci pckbd
 .endif
 
 .if ${MACHINE_ARCH} == "earm"
-SUBDIR= log tty
+SUBDIR= tty
 .endif
 
 .else # ${MKIMAGEONLY} != "yes"
 
 .if ${MACHINE_ARCH} == "i386"
 SUBDIR= ahci amddev atl2 at_wini audio dec21140A dp8390 dpeth \
-	e1000 fbd filter floppy fxp hello lance log mmc orinoco pci printer \
+	e1000 fbd filter floppy fxp hello lance log mmc orinoco pci pckbd \
-	random readclock rtl8139 rtl8169 ti1225 tty vbox acpi \
+	printer random readclock rtl8139 rtl8169 ti1225 tty uds vbox acpi \
-	virtio_blk virtio_net
+	virtio_blk virtio_net vnd
 .endif
 
 .if ${MACHINE_ARCH} == "earm"
 SUBDIR= bmp085 cat24c256 fb gpio i2c mmc lan8710a log readclock \
-	sht21 tda19988 tps65217 tps65950 tsl2550 tty random
+	sht21 tda19988 tps65217 tps65950 tsl2550 tty random uds vnd
 .endif
 
 .endif # ${MKIMAGEONLY} != "yes"

drivers/ahci/ahci.c

@@ -170,7 +170,7 @@ static struct port_state {
 	struct device part[DEV_PER_DRIVE];	/* partition bases and sizes */
 	struct device subpart[SUB_PER_DRIVE];	/* same for subpartitions */
 
-	timer_t timer;		/* port-specific timeout timer */
+	minix_timer_t timer;		/* port-specific timeout timer */
 	int left;		/* number of tries left before giving up */
 				/* (only used for signature probing) */
 
@@ -178,7 +178,7 @@ static struct port_state {
 	u32_t pend_mask;	/* commands not yet complete */
 	struct {
 		thread_id_t tid;/* ID of the worker thread */
-		timer_t timer;	/* timer associated with each request */
+		minix_timer_t timer;	/* timer associated with each request */
 		int result;	/* success/failure result of the commands */
 	} cmd_info[NR_CMDS];
 } port_state[NR_PORTS];
@@ -232,36 +232,33 @@ static void port_set_cmd(struct port_state *ps, int cmd, cmd_fis_t *fis,
 	u8_t packet[ATAPI_PACKET_SIZE], prd_t *prdt, int nr_prds, int write);
 static void port_issue(struct port_state *ps, int cmd, clock_t timeout);
 static int port_exec(struct port_state *ps, int cmd, clock_t timeout);
-static void port_timeout(struct timer *tp);
+static void port_timeout(minix_timer_t *tp);
 static void port_disconnect(struct port_state *ps);
 
 static char *ahci_portname(struct port_state *ps);
-static int ahci_open(dev_t minor, int access);
+static int ahci_open(devminor_t minor, int access);
-static int ahci_close(dev_t minor);
+static int ahci_close(devminor_t minor);
-static ssize_t ahci_transfer(dev_t minor, int do_write, u64_t position,
+static ssize_t ahci_transfer(devminor_t minor, int do_write, u64_t position,
 	endpoint_t endpt, iovec_t *iovec, unsigned int count, int flags);
-static struct device *ahci_part(dev_t minor);
+static struct device *ahci_part(devminor_t minor);
 static void ahci_alarm(clock_t stamp);
-static int ahci_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
+static int ahci_ioctl(devminor_t minor, unsigned long request,
-	cp_grant_id_t grant);
+	endpoint_t endpt, cp_grant_id_t grant, endpoint_t user_endpt);
 static void ahci_intr(unsigned int mask);
-static int ahci_device(dev_t minor, device_id_t *id);
+static int ahci_device(devminor_t minor, device_id_t *id);
-static struct port_state *ahci_get_port(dev_t minor);
+static struct port_state *ahci_get_port(devminor_t minor);
 
 /* AHCI driver table. */
 static struct blockdriver ahci_dtab = {
-	BLOCKDRIVER_TYPE_DISK,
+	.bdr_type	= BLOCKDRIVER_TYPE_DISK,
-	ahci_open,
+	.bdr_open	= ahci_open,
-	ahci_close,
+	.bdr_close	= ahci_close,
-	ahci_transfer,
+	.bdr_transfer	= ahci_transfer,
-	ahci_ioctl,
+	.bdr_ioctl	= ahci_ioctl,
-	NULL,		/* bdr_cleanup */
+	.bdr_part	= ahci_part,
-	ahci_part,
+	.bdr_intr	= ahci_intr,
-	NULL,		/* bdr_geometry */
+	.bdr_alarm	= ahci_alarm,
-	ahci_intr,
+	.bdr_device	= ahci_device
-	ahci_alarm,
-	NULL,		/* bdr_other */
-	ahci_device
 };
 
 /*===========================================================================*
@@ -1714,7 +1711,7 @@ static void port_intr(struct port_state *ps)
 /*===========================================================================*
  *				port_timeout				     *
  *===========================================================================*/
-static void port_timeout(struct timer *tp)
+static void port_timeout(minix_timer_t *tp)
 {
 	/* A timeout has occurred on this port. Figure out what the timeout is
 	 * for, and take appropriate action.
@@ -2421,7 +2418,7 @@ static char *ahci_portname(struct port_state *ps)
 /*===========================================================================*
  *				ahci_map_minor				     *
  *===========================================================================*/
-static struct port_state *ahci_map_minor(dev_t minor, struct device **dvp)
+static struct port_state *ahci_map_minor(devminor_t minor, struct device **dvp)
 {
 	/* Map a minor device number to a port and a pointer to the partition's
 	 * device structure. Return NULL if this minor device number does not
@@ -2432,7 +2429,7 @@ static struct port_state *ahci_map_minor(dev_t minor, struct device **dvp)
 
 	ps = NULL;
 
-	if (minor < NR_MINORS) {
+	if (minor >= 0 && minor < NR_MINORS) {
 		port = ahci_map[minor / DEV_PER_DRIVE];
 
 		if (port == NO_PORT)
@@ -2457,7 +2454,7 @@ static struct port_state *ahci_map_minor(dev_t minor, struct device **dvp)
 /*===========================================================================*
  *				ahci_part				     *
  *===========================================================================*/
-static struct device *ahci_part(dev_t minor)
+static struct device *ahci_part(devminor_t minor)
 {
 	/* Return a pointer to the partition information structure of the given
 	 * minor device.
@@ -2473,7 +2470,7 @@ static struct device *ahci_part(dev_t minor)
 /*===========================================================================*
  *				ahci_open				     *
  *===========================================================================*/
-static int ahci_open(dev_t minor, int access)
+static int ahci_open(devminor_t minor, int access)
 {
 	/* Open a device.
 	 */
@@ -2499,7 +2496,7 @@ static int ahci_open(dev_t minor, int access)
 		return ENXIO;
 
 	/* Some devices may only be opened in read-only mode. */
-	if ((ps->flags & FLAG_READONLY) && (access & W_BIT))
+	if ((ps->flags & FLAG_READONLY) && (access & BDEV_W_BIT))
 		return EACCES;
 
 	if (ps->open_count == 0) {
@@ -2542,7 +2539,7 @@ static int ahci_open(dev_t minor, int access)
 /*===========================================================================*
  *				ahci_close				     *
  *===========================================================================*/
-static int ahci_close(dev_t minor)
+static int ahci_close(devminor_t minor)
 {
 	/* Close a device.
 	 */
@@ -2598,7 +2595,7 @@ static int ahci_close(dev_t minor)
 /*===========================================================================*
  *				ahci_transfer				     *
  *===========================================================================*/
-static ssize_t ahci_transfer(dev_t minor, int do_write, u64_t position,
+static ssize_t ahci_transfer(devminor_t minor, int do_write, u64_t position,
 	endpoint_t endpt, iovec_t *iovec, unsigned int count, int flags)
 {
 	/* Perform data transfer on the selected device.
@@ -2633,8 +2630,8 @@ static ssize_t ahci_transfer(dev_t minor, int do_write, u64_t position,
 /*===========================================================================*
  *				ahci_ioctl				     *
  *===========================================================================*/
-static int ahci_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
+static int ahci_ioctl(devminor_t minor, unsigned long request,
-	cp_grant_id_t grant)
+	endpoint_t endpt, cp_grant_id_t grant, endpoint_t UNUSED(user_endpt))
 {
 	/* Process I/O control requests.
 	 */
@@ -2684,13 +2681,13 @@ static int ahci_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
 			sizeof(val));
 	}
 
-	return EINVAL;
+	return ENOTTY;
 }
 
 /*===========================================================================*
  *				ahci_device				     *
  *===========================================================================*/
-static int ahci_device(dev_t minor, device_id_t *id)
+static int ahci_device(devminor_t minor, device_id_t *id)
 {
 	/* Map a minor device number to a device ID.
 	 */
@@ -2708,7 +2705,7 @@ static int ahci_device(dev_t minor, device_id_t *id)
 /*===========================================================================*
  *				ahci_get_port				     *
  *===========================================================================*/
-static struct port_state *ahci_get_port(dev_t minor)
+static struct port_state *ahci_get_port(devminor_t minor)
 {
 	/* Get the port structure associated with the given minor device.
 	 * Called only from worker threads, so the minor device is already

drivers/ahci/ahci.h

@@ -264,7 +264,6 @@ typedef struct vumap_phys prd_t;
  */
 #define MAX_DRIVES		8
 #define NR_MINORS		(MAX_DRIVES * DEV_PER_DRIVE)
-#define SUB_PER_DRIVE		(NR_PARTITIONS * NR_PARTITIONS)
 #define NR_SUBDEVS		(MAX_DRIVES * SUB_PER_DRIVE)
 
 /* Port states. */

drivers/at_wini/at_wini.h

@@ -4,7 +4,6 @@
 
 #define VERBOSE		   0	/* display identify messages during boot */
 #define VERBOSE_DMA	   0	/* display DMA debugging information */
-#define ENABLE_ATAPI	   1	/* add ATAPI cd-rom support to driver */
 
 #define ATAPI_DEBUG	    0	/* To debug ATAPI code. */
 
@@ -129,7 +128,6 @@
 						 * regular LBA.
 						 */
 
-#if ENABLE_ATAPI
 #define   ERROR_SENSE           0xF0    /* sense key mask */
 #define     SENSE_NONE          0x00    /* no sense key */
 #define     SENSE_RECERR        0x10    /* recovered error */
@@ -156,7 +154,6 @@
 #define REG_CNT_LO          4   /* low byte of cylinder number */
 #define REG_CNT_HI          5   /* high byte of cylinder number */
 #define REG_DRIVE           6   /* drive select */
-#endif
 
 #define REG_STATUS          7   /* status */
 #define   STATUS_BSY            0x80    /* controller busy */
@@ -167,15 +164,10 @@
 #define   STATUS_CORR           0x04    /* correctable error occurred */
 #define   STATUS_CHECK          0x01    /* check error */
 
-#if ENABLE_ATAPI
 #define   ATAPI_PACKETCMD       0xA0    /* packet command */
 #define   ATAPI_IDENTIFY        0xA1    /* identify drive */
 #define   SCSI_READ10           0x28    /* read from disk */
 #define   SCSI_SENSE            0x03    /* sense request */
-#endif /* ATAPI */
-
-/* Interrupt request lines. */
-#define NO_IRQ		 0	/* no IRQ set yet */
 
 #define ATAPI_PACKETSIZE	12
 #define SENSE_PACKETSIZE	18
@@ -185,17 +177,16 @@
 #define ERR_BAD_SECTOR	 (-2)	/* block marked bad detected */
 
 /* Some controllers don't interrupt, the clock will wake us up. */
-#define WAKEUP_SECS	32			/* drive may be out for 31 seconds max */
+#define WAKEUP_SECS	32	/* drive may be out for 31 seconds max */
 #define WAKEUP_TICKS	(WAKEUP_SECS*system_hz)
 
 /* Miscellaneous. */
-#define MAX_DRIVES         8
+#define MAX_DRIVES         4	/* max number of actual drives per instance */
-#define COMPAT_DRIVES      4
+#define MAX_DRIVENODES     8	/* number of drive nodes, for node numbering */
 #define MAX_SECS	 256	/* controller can transfer this many sectors */
 #define MAX_ERRORS         4	/* how often to try rd/wt before quitting */
-#define NR_MINORS       (MAX_DRIVES * DEV_PER_DRIVE)
+#define NR_MINORS       (MAX_DRIVENODES * DEV_PER_DRIVE)
-#define SUB_PER_DRIVE	(NR_PARTITIONS * NR_PARTITIONS)
+#define NR_SUBDEVS	(MAX_DRIVENODES * SUB_PER_DRIVE)
-#define NR_SUBDEVS	(MAX_DRIVES * SUB_PER_DRIVE)
 #define DELAY_USECS     1000	/* controller timeout in microseconds */
 #define DELAY_TICKS 	   1	/* controller timeout in ticks */
 #define DEF_TIMEOUT_USECS 5000000L  /* controller timeout in microseconds */
@@ -204,18 +195,15 @@
 #define INITIALIZED	0x01	/* drive is initialized */
 #define DEAF		0x02	/* controller must be reset */
 #define SMART		0x04	/* drive supports ATA commands */
-#if ENABLE_ATAPI
 #define ATAPI		0x08	/* it is an ATAPI device */
-#else
-#define ATAPI		   0	/* don't bother with ATAPI; optimise out */
-#endif
 #define IDENTIFIED	0x10	/* w_identify done successfully */
 #define IGNORING	0x20	/* w_identify failed once */
 
 #define NO_DMA_VAR 	"ata_no_dma"
 
-/* BIOS parameter table layout. */
+#define ATA_IF_NATIVE0	(1L << 0)	/* first channel is in native mode */
-#define bp_cylinders(t)	(t[0] | (t[1] << 8))
+#define ATA_IF_NATIVE1	(1L << 2)	/* second channel is in native mode */
-#define bp_heads(t)	(t[2])
+
-#define bp_precomp(t)	(t[5] | (t[6] << 8))
+extern int sef_cb_lu_prepare(int state);
-#define bp_sectors(t)	(t[14])
+extern int sef_cb_lu_state_isvalid(int state);
+extern void sef_cb_lu_state_dump(int state);

drivers/atl2/atl2.conf

@@ -6,7 +6,7 @@ service atl2
                 UMAP            # 14
                 IRQCTL          # 19
         ;
-        pci device      1969/2048;
+        pci device      1969:2048;
         ipc
                 SYSTEM pm rs tty ds vm
                 pci inet lwip

drivers/audio/es1370/es1370.c

@@ -286,7 +286,7 @@ int drv_stop(int sub_dev)
 
 
 /* all IO-ctl's sent to the upper driver are passed to this function */
-int drv_io_ctl(int request, void * val, int * len, int sub_dev) {
+int drv_io_ctl(unsigned long request, void * val, int * len, int sub_dev) {
 
 	int status;
 

drivers/audio/es1371/es1371.c

@@ -287,7 +287,7 @@ int drv_stop(int sub_dev)
 
 
 /* all IO-ctl's sent to the upper driver are passed to this function */
-int drv_io_ctl(int request, void * val, int * len, int sub_dev) {
+int drv_io_ctl(unsigned long request, void * val, int * len, int sub_dev) {
 
 	int status;
 

drivers/audio/sb16/mixer.c

@@ -14,7 +14,7 @@ static int get_set_output(struct inout_ctrl *output, int flag);
 /*=========================================================================*
  *				mixer_ioctl				   	
  *=========================================================================*/
-int mixer_ioctl(int request, void *val, int *UNUSED(len)) {
+int mixer_ioctl(unsigned long request, void *val, int *UNUSED(len)) {
 	int status;
 
 	switch(request) {

drivers/audio/sb16/mixer.h

@@ -2,7 +2,7 @@
 #define SB16_MIXER_H
 
 int mixer_init(void);
-int mixer_ioctl(int request, void *val, int *len);
+int mixer_ioctl(unsigned long request, void *val, int *len);
 
 int mixer_set(int reg, int data);
 int mixer_get(int reg);

drivers/audio/sb16/sb16.c

@@ -13,7 +13,7 @@
 
 static void dsp_dma_setup(phys_bytes address, int count, int sub_dev);
 
-static int dsp_ioctl(int request, void *val, int *len);
+static int dsp_ioctl(unsigned long request, void *val, int *len);
 static int dsp_set_size(unsigned int size);
 static int dsp_set_speed(unsigned int speed);
 static int dsp_set_stereo(unsigned int stereo);
@@ -141,7 +141,7 @@ int drv_start(int channel, int DmaMode) {
 	dsp_set_speed(DspSpeed);
 
 	/* Put the speaker on */
-	if(DmaMode == DEV_WRITE_S) {
+	if(DmaMode == WRITE_DMA) {
 		dsp_command (DSP_CMD_SPKON); /* put speaker on */
 
 		/* Program DSP with dma mode */
@@ -232,8 +232,9 @@ int drv_resume(int UNUSED(chan)) {
 
 
 
-int drv_io_ctl(int request, void *val, int *len, int sub_dev) {
+int drv_io_ctl(unsigned long request, void *val, int *len, int sub_dev) {
-	Dprint(("dsp_ioctl: got ioctl %d, argument: %d sub_dev: %d\n", request, val, sub_dev));
+	Dprint(("dsp_ioctl: got ioctl %lu, argument: %d sub_dev: %d\n",
+		request, val, sub_dev));
 
 	if(sub_dev == AUDIO) {
 		return dsp_ioctl(request, val, len);
@@ -262,7 +263,7 @@ int drv_get_frag_size(u32_t *frag_size, int UNUSED(sub_dev)) {
 
 
 
-static int dsp_ioctl(int request, void *val, int *len) {
+static int dsp_ioctl(unsigned long request, void *val, int *len) {
 	int status;
 	
 	switch(request) {
@@ -293,7 +294,7 @@ static void dsp_dma_setup(phys_bytes address, int count, int DmaMode) {
 		pv_set(pvb[1], DMA8_CLEAR, 0x00);		       /* Clear flip flop */
 
 		/* set DMA mode */
-		pv_set(pvb[2], DMA8_MODE, (DmaMode == DEV_WRITE_S ? DMA8_AUTO_PLAY : DMA8_AUTO_REC)); 
+		pv_set(pvb[2], DMA8_MODE, (DmaMode == WRITE_DMA ? DMA8_AUTO_PLAY : DMA8_AUTO_REC)); 
 
 		pv_set(pvb[3], DMA8_ADDR, (u8_t)(address >>  0)); /* Low_byte of address */
 		pv_set(pvb[4], DMA8_ADDR, (u8_t)(address >>  8)); /* High byte of address */
@@ -311,7 +312,7 @@ static void dsp_dma_setup(phys_bytes address, int count, int DmaMode) {
 		pv_set(pvb[1], DMA16_CLEAR, 0x00);                  /* Clear flip flop */
 
 		/* Set dma mode */
-		pv_set(pvb[2], DMA16_MODE, (DmaMode == DEV_WRITE_S ? DMA16_AUTO_PLAY : DMA16_AUTO_REC));        
+		pv_set(pvb[2], DMA16_MODE, (DmaMode == WRITE_DMA ? DMA16_AUTO_PLAY : DMA16_AUTO_REC));        
 
 		pv_set(pvb[3], DMA16_ADDR, (address >> 1) & 0xFF);  /* Low_byte of address */
 		pv_set(pvb[4], DMA16_ADDR, (address >> 9) & 0xFF);  /* High byte of address */

drivers/bmp085/bmp085.c

@@ -151,11 +151,9 @@ static int read_cal_coef(void);
 static int measure(int32_t * temperature, int32_t * pressure);
 
 /* libchardriver callbacks */
-static struct device *bmp085_prepare(dev_t UNUSED(dev));
+static ssize_t bmp085_read(devminor_t minor, u64_t position, endpoint_t endpt,
-static int bmp085_transfer(endpoint_t endpt, int opcode, u64_t position,
+    cp_grant_id_t grant, size_t size, int flags, cdev_id_t id);
-    iovec_t * iov, unsigned nr_req, endpoint_t UNUSED(user_endpt),
+static void bmp085_other(message * m, int ipc_status);
-    unsigned int UNUSED(flags));
-static int bmp085_other(message * m);
 
 /* SEF Function */
 static int sef_cb_lu_state_save(int);
@@ -165,21 +163,8 @@ static void sef_local_startup(void);
 
 /* Entry points to this driver from libchardriver. */
 static struct chardriver bmp085_tab = {
-	.cdr_open = do_nop,
+	.cdr_read	= bmp085_read,
-	.cdr_close = do_nop,
+	.cdr_other	= bmp085_other
-	.cdr_ioctl = nop_ioctl,
-	.cdr_prepare = bmp085_prepare,
-	.cdr_transfer = bmp085_transfer,
-	.cdr_cleanup = nop_cleanup,
-	.cdr_alarm = nop_alarm,
-	.cdr_cancel = nop_cancel,
-	.cdr_select = nop_select,
-	.cdr_other = bmp085_other
-};
-
-static struct device bmp085_device = {
-	.dv_base = 0,
-	.dv_size = 0
 };
 
 /*
@@ -438,18 +423,12 @@ measure(int32_t * temperature, int32_t * pressure)
 	return OK;
 }
 
-static struct device *
+static ssize_t
-bmp085_prepare(dev_t UNUSED(dev))
+bmp085_read(devminor_t UNUSED(minor), u64_t position, endpoint_t endpt,
+    cp_grant_id_t grant, size_t size, int UNUSED(flags), cdev_id_t UNUSED(id))
 {
-	return &bmp085_device;
+	u64_t dev_size;
-}
+	int r;
-
-static int
-bmp085_transfer(endpoint_t endpt, int opcode, u64_t position,
-    iovec_t * iov, unsigned nr_req, endpoint_t UNUSED(user_endpt),
-    unsigned int UNUSED(flags))
-{
-	int bytes, r;
 	uint32_t temperature, pressure;
 
 	r = measure(&temperature, &pressure);
@@ -464,48 +443,33 @@ bmp085_transfer(endpoint_t endpt, int opcode, u64_t position,
 
 	log_trace(&log, "%s", buffer);
 
-	bytes = strlen(buffer) - position < iov->iov_size ?
+	dev_size = (u64_t)strlen(buffer);
-	    strlen(buffer) - position : iov->iov_size;
+	if (position >= dev_size) return 0;
+	if (position + size > dev_size)
+		size = (size_t)(dev_size - position);
 
-	if (bytes <= 0) {
+	r = sys_safecopyto(endpt, grant, 0,
-		return OK;
+	    (vir_bytes)(buffer + (size_t)position), size);
-	}
 
-	switch (opcode) {
+	return (r != OK) ? r : size;
-	case DEV_GATHER_S:
-		r = sys_safecopyto(endpt, (cp_grant_id_t) iov->iov_addr, 0,
-		    (vir_bytes) (buffer + position), bytes);
-		iov->iov_size -= bytes;
-		break;
-	default:
-		return EINVAL;
-	}
-
-	return r;
 }
 
-static int
+static void
-bmp085_other(message * m)
+bmp085_other(message * m, int ipc_status)
 {
 	int r;
 
-	switch (m->m_type) {
+	if (is_ipc_notify(ipc_status)) {
-	case NOTIFY_MESSAGE:
 		if (m->m_source == DS_PROC_NR) {
 			log_debug(&log,
 			    "bus driver changed state, update endpoint\n");
 			i2cdriver_handle_bus_update(&bus_endpoint, bus,
 			    address);
 		}
-		r = OK;
+		return;
-		break;
-	default:
-		log_warn(&log, "Invalid message type (0x%x)\n", m->m_type);
-		r = EINVAL;
-		break;
 	}
 
-	return r;
+	log_warn(&log, "Invalid message type (0x%x)\n", m->m_type);
 }
 
 static int
@@ -624,7 +588,7 @@ main(int argc, char *argv[])
 
 	sef_local_startup();
 
-	chardriver_task(&bmp085_tab, CHARDRIVER_SYNC);
+	chardriver_task(&bmp085_tab);
 
 	return 0;
 }

drivers/cat24c256/cat24c256.c

@@ -29,14 +29,14 @@ static int sef_cb_lu_state_save(int);
 static int lu_state_restore(void);
 
 /* libblockdriver callbacks */
-static int cat24c256_blk_open(dev_t minor, int access);
+static int cat24c256_blk_open(devminor_t minor, int access);
-static int cat24c256_blk_close(dev_t minor);
+static int cat24c256_blk_close(devminor_t minor);
-static ssize_t cat24c256_blk_transfer(dev_t minor, int do_write, u64_t pos,
+static ssize_t cat24c256_blk_transfer(devminor_t minor, int do_write,
-    endpoint_t endpt, iovec_t * iov, unsigned count, int flags);
+    u64_t pos, endpoint_t endpt, iovec_t * iov, unsigned int count, int flags);
-static int cat24c256_blk_ioctl(dev_t minor, unsigned int request,
+static int cat24c256_blk_ioctl(devminor_t minor, unsigned long request,
-    endpoint_t endpt, cp_grant_id_t grant);
+    endpoint_t endpt, cp_grant_id_t grant, endpoint_t user_endpt);
-static struct device *cat24c256_blk_part(dev_t minor);
+static struct device *cat24c256_blk_part(devminor_t minor);
-static int cat24c256_blk_other(message * m);
+static void cat24c256_blk_other(message * m, int ipc_status);
 
 /* Entry points into the device dependent code of block drivers. */
 struct blockdriver cat24c256_tab = {
@@ -44,14 +44,9 @@ struct blockdriver cat24c256_tab = {
 	.bdr_open = cat24c256_blk_open,
 	.bdr_close = cat24c256_blk_close,
 	.bdr_transfer = cat24c256_blk_transfer,
-	.bdr_ioctl = cat24c256_blk_ioctl,	/* nop -- always returns EINVAL */
+	.bdr_ioctl = cat24c256_blk_ioctl,	/* always returns ENOTTY */
-	.bdr_cleanup = NULL,	/* nothing allocated -- nothing to clean up */
 	.bdr_part = cat24c256_blk_part,
-	.bdr_geometry = NULL,	/* no geometry (cylinders, heads, sectors, etc) */
+	.bdr_other = cat24c256_blk_other	/* for notify events from DS */
-	.bdr_intr = NULL,	/* i2c devices don't generate interrupts */
-	.bdr_alarm = NULL,	/* alarm not needed */
-	.bdr_other = cat24c256_blk_other,	/* to recv notify events from DS */
-	.bdr_device = NULL	/* 1 insance per bus, threads not needed */
 };
 
 static int cat24c256_read128(uint16_t memaddr, void *buf, size_t buflen, int flags);
@@ -84,7 +79,7 @@ static struct log log = {
 };
 
 static int
-cat24c256_blk_open(dev_t minor, int access)
+cat24c256_blk_open(devminor_t minor, int access)
 {
 	log_trace(&log, "cat24c256_blk_open(%d,%d)\n", minor, access);
 	if (cat24c256_blk_part(minor) == NULL) {
@@ -97,7 +92,7 @@ cat24c256_blk_open(dev_t minor, int access)
 }
 
 static int
-cat24c256_blk_close(dev_t minor)
+cat24c256_blk_close(devminor_t minor)
 {
 	log_trace(&log, "cat24c256_blk_close(%d)\n", minor);
 	if (cat24c256_blk_part(minor) == NULL) {
@@ -114,11 +109,11 @@ cat24c256_blk_close(dev_t minor)
 }
 
 static ssize_t
-cat24c256_blk_transfer(dev_t minor, int do_write, u64_t pos64,
+cat24c256_blk_transfer(devminor_t minor, int do_write, u64_t pos64,
-    endpoint_t endpt, iovec_t * iov, unsigned nr_req, int flags)
+    endpoint_t endpt, iovec_t * iov, unsigned int nr_req, int flags)
 {
 	/* Read or write one the driver's block devices. */
-	unsigned count;
+	unsigned int count;
 	struct device *dv;
 	u64_t dv_size;
 	int r;
@@ -214,50 +209,40 @@ cat24c256_blk_transfer(dev_t minor, int do_write, u64_t pos64,
 }
 
 static int
-cat24c256_blk_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
+cat24c256_blk_ioctl(devminor_t minor, unsigned long request, endpoint_t endpt,
-    cp_grant_id_t grant)
+    cp_grant_id_t grant, endpoint_t UNUSED(user_endpt))
 {
 	log_trace(&log, "cat24c256_blk_ioctl(%d)\n", minor);
 	/* no supported ioctls for this device */
-	return EINVAL;
+	return ENOTTY;
 }
 
 static struct device *
-cat24c256_blk_part(dev_t minor)
+cat24c256_blk_part(devminor_t minor)
 {
 	log_trace(&log, "cat24c256_blk_part(%d)\n", minor);
 
-	if (minor >= NR_DEVS) {
+	if (minor < 0 || minor >= NR_DEVS) {
 		return NULL;
 	}
 
 	return &geom[minor];
 }
 
-static int
+static void
-cat24c256_blk_other(message * m)
+cat24c256_blk_other(message * m, int ipc_status)
 {
-	int r;
-
 	log_trace(&log, "cat24c256_blk_other(0x%x)\n", m->m_type);
 
-	switch (m->m_type) {
+	if (is_ipc_notify(ipc_status)) {
-	case NOTIFY_MESSAGE:
 		if (m->m_source == DS_PROC_NR) {
 			log_debug(&log,
 			    "bus driver changed state, update endpoint\n");
 			i2cdriver_handle_bus_update(&bus_endpoint, bus,
 			    address);
 		}
-		r = OK;
+	} else
-		break;
-	default:
 		log_warn(&log, "Invalid message type (0x%x)\n", m->m_type);
-		r = EINVAL;
-		break;
-	}
-
-	return r;
 }
 
 /* The lower level i2c interface can only read/write 128 bytes at a time.

drivers/dec21140A/dec21140A.conf

@@ -8,7 +8,7 @@ service dec21140A
                 IRQCTL          # 19
                 DEVIO           # 21
         ;
-        pci device      1011/0009;
+        pci device      1011:0009;
         ipc
                 SYSTEM pm rs log tty ds vm
                 pci inet lwip

drivers/e1000/e1000.c

@@ -13,7 +13,7 @@
 #include <machine/pci.h>
 #include <minix/ds.h>
 #include <minix/vm.h>
-#include <timers.h>
+#include <minix/timers.h>
 #include <sys/mman.h>
 #include "assert.h"
 #include "e1000.h"

drivers/e1000/e1000.conf

@@ -7,13 +7,13 @@ service e1000
                 IRQCTL          # 19
                 DEVIO           # 21
         ;
-        pci device      8086/100e;
+        pci device      8086:100e;
-        pci device      8086/100f;
+        pci device      8086:100f;
-        pci device      8086/107c;
+        pci device      8086:107c;
-        pci device      8086/10cd;
+        pci device      8086:10cd;
-        pci device      8086/10d3;
+        pci device      8086:10d3;
-        pci device      8086/10de;
+        pci device      8086:10de;
-        pci device      8086/105e;
+        pci device      8086:105e;
         ipc
                 SYSTEM pm rs log tty ds vm
                 pci inet lwip ;

drivers/fb/arch/earm/fb_arch.c

@@ -312,7 +312,7 @@ arch_pan_display(int minor, struct fb_var_screeninfo *fbvsp)
 }
 
 int
-arch_fb_init(int minor, struct device *dev, struct edid_info *info)
+arch_fb_init(int minor, struct edid_info *info)
 {
 	int r;
 	u32_t rdispc;
@@ -320,13 +320,9 @@ arch_fb_init(int minor, struct device *dev, struct edid_info *info)
 
 	const struct panel_config *panel_cfg = &omap_cfg[minor];
 
-	assert(dev != NULL);
 	if (minor != 0) return ENXIO;	/* We support only one minor */
 
-
 	if (initialized) {
-		dev->dv_base = fb_vir;
-		dev->dv_size = fb_size;
 		return OK;
 	} else if (info != NULL) {
 		log_debug(&log, "Configuring Settings based on EDID...\n");
@@ -403,8 +399,6 @@ arch_fb_init(int minor, struct device *dev, struct edid_info *info)
 	if (fb_vir == (vir_bytes) MAP_FAILED) {
 		panic("Unable to allocate contiguous memory\n");
 	} 
-	dev->dv_base = fb_vir;
-	dev->dv_size = fb_size;
 
 	/* Configure buffer settings and turn on LCD/Digital */
 	arch_configure_display(minor);

drivers/fb/fb.c

@@ -23,17 +23,14 @@
 /*
  * Function prototypes for the fb driver.
  */
-static int fb_open(message *m);
+static int fb_open(devminor_t minor, int access, endpoint_t user_endpt);
-static int fb_close(message *m);
+static int fb_close(devminor_t minor);
-static struct device * fb_prepare(dev_t device);
+static ssize_t fb_read(devminor_t minor, u64_t pos, endpoint_t ep,
-static int fb_transfer(endpoint_t endpt, int opcode, u64_t position,
+	cp_grant_id_t gid, size_t size, int flags, cdev_id_t id);
-	iovec_t *iov, unsigned int nr_req, endpoint_t user_endpt, unsigned int
+static ssize_t fb_write(devminor_t minor, u64_t pos, endpoint_t ep,
-	flags);
+	cp_grant_id_t gid, size_t size, int flags, cdev_id_t id);
-static int fb_do_read(endpoint_t ep, iovec_t *iov, int minor, u64_t pos,
+static int fb_ioctl(devminor_t minor, unsigned long request, endpoint_t ep,
-	size_t *io_bytes);
+	cp_grant_id_t gid, int flags, endpoint_t user_ep, cdev_id_t id);
-static int fb_do_write(endpoint_t ep, iovec_t *iov, int minor, u64_t pos,
-	size_t *io_bytes);
-static int fb_ioctl(message *m);
 static void paint_bootlogo(int minor);
 static void paint_restartlogo(int minor);
 static void paint_centered(int minor, char *data, int width, int height);
@@ -52,143 +49,90 @@ static int lu_state_restore(void);
 /* Entry points to the fb driver. */
 static struct chardriver fb_tab =
 {
-	fb_open,
+	.cdr_open	= fb_open,
-	fb_close,
+	.cdr_close	= fb_close,
-	fb_ioctl,
+	.cdr_read	= fb_read,
-	fb_prepare,
+	.cdr_write	= fb_write,
-	fb_transfer,
+	.cdr_ioctl	= fb_ioctl
-	nop_cleanup,
-	nop_alarm,
-	nop_cancel,
-	nop_select,
-	NULL
 };
 
 /** Represents the /dev/fb device. */
-static struct device fb_device[FB_DEV_NR];
+static int has_restarted = 0;
-static int fb_minor, has_restarted = 0;
 static u64_t has_restarted_t1, has_restarted_t2;
 
 static int open_counter[FB_DEV_NR];		/* Open count */
 
 static int
-fb_open(message *m)
+fb_open(devminor_t minor, int UNUSED(access), endpoint_t UNUSED(user_endpt))
 {
 	int r;
 	static int initialized = 0;
 	static struct edid_info info;
 	static struct edid_info *infop = NULL;
 
-	if (m->DEVICE < 0 || m->DEVICE >= FB_DEV_NR) return ENXIO;
+	if (minor < 0 || minor >= FB_DEV_NR) return ENXIO;
 
 	if (!initialized) {
-		r = fb_edid_read(m->DEVICE, &info);
+		r = fb_edid_read(minor, &info);
 		infop = (r == 0) ? &info : NULL;
 	}
 
-	if (arch_fb_init(m->DEVICE, &fb_device[m->DEVICE], infop) == OK) {
+	if (arch_fb_init(minor, infop) == OK) {
-		open_counter[m->DEVICE]++;
+		open_counter[minor]++;
 		if (!initialized) {
 			if (has_restarted) {
 				read_frclock_64(&has_restarted_t1);
-				paint_restartlogo(m->DEVICE);
+				paint_restartlogo(minor);
 			} else {
-				paint_bootlogo(m->DEVICE);
+				paint_bootlogo(minor);
 			}
 			initialized = 1;
 		}
 		return OK;
 	}
-	return ENXIO ;
+	return ENXIO;
 }
 
 static int
-fb_close(message *m)
+fb_close(devminor_t minor)
 {
-	if (m->DEVICE < 0 || m->DEVICE >= FB_DEV_NR) return ENXIO;
+	if (minor < 0 || minor >= FB_DEV_NR) return ENXIO;
-	assert(open_counter[m->DEVICE] > 0);
+	assert(open_counter[minor] > 0);
-	open_counter[m->DEVICE]--;
+	open_counter[minor]--;
 	return OK;
 }
 
-static struct device *
+static ssize_t
-fb_prepare(dev_t dev)
+fb_read(devminor_t minor, u64_t pos, endpoint_t ep, cp_grant_id_t gid,
-{
+	size_t size, int UNUSED(flags), cdev_id_t UNUSED(id))
-	if (dev < 0 || dev >= FB_DEV_NR) return NULL;
-	assert(open_counter[dev] > 0);
-	fb_minor = dev;
-	return &fb_device[dev];
-}
-
-static int
-fb_transfer(endpoint_t endpt, int opcode, u64_t position,
-    iovec_t *iov, unsigned nr_req, endpoint_t UNUSED(user_endpt),
-    unsigned int UNUSED(flags))
-{
-	size_t io_bytes = 0, ret;
-
-	if (nr_req != 1) {
-		/* This should never trigger for char drivers at the moment. */
-		printf("fb: vectored transfer, using first element only\n");
-	}
-
-	switch (opcode) {
-	case DEV_GATHER_S:
-	    /* Userland read operation */
-	    ret = fb_do_read(endpt, iov, fb_minor, position, &io_bytes);
-	    iov->iov_size -= io_bytes;
-            break;
-	case DEV_SCATTER_S:
-	    /* Userland write operation */
-	    ret = fb_do_write(endpt, iov, fb_minor, position, &io_bytes);
-	    iov->iov_size -= io_bytes;
-	    break;
-	default:
-	    return EINVAL;
-	}
-	return ret;
-}
-
-static int
-fb_do_read(endpoint_t ep, iovec_t *iov, int minor, u64_t pos, size_t *io_bytes)
 {
 	struct device dev;
+	int r;
+
+	if (minor < 0 || minor >= FB_DEV_NR) return ENXIO;
+	assert(open_counter[minor] > 0);
 
 	arch_get_device(minor, &dev);
 
-	if (pos >= dev.dv_size) return EINVAL;
+	if (size == 0 || pos >= dev.dv_size) return 0;
+	if (pos + size > dev.dv_size)
+		size = (size_t)(dev.dv_size - pos);
 
-	if (dev.dv_size - pos < iov->iov_size) {
+	r = sys_safecopyto(ep, gid, 0, (vir_bytes)(dev.dv_base + (size_t)pos),
-		*io_bytes = dev.dv_size - pos;
+	    size);
-	} else {
-		*io_bytes = iov->iov_size;
-	}
 
-        if (*io_bytes <= 0) {
+	return (r != OK) ? r : size;
-                return OK;
-        }
-
-	return sys_safecopyto(ep, (cp_grant_id_t) iov->iov_addr, 0,
-				(vir_bytes) (dev.dv_base + ex64lo(pos)),
-				*io_bytes);
 }
 
 static int
-fb_ioctl(message *m)
+fb_ioctl(devminor_t minor, unsigned long request, endpoint_t ep,
+	cp_grant_id_t gid, int UNUSED(flags), endpoint_t UNUSED(user_ep),
+	cdev_id_t UNUSED(id))
 {
 /* Process I/O control requests */
-	endpoint_t ep;
-	cp_grant_id_t gid;
-	int minor;
-	unsigned int request;
 	int r;
 
-	minor = m->DEVICE;
+	if (minor < 0 || minor >= FB_DEV_NR) return ENXIO;
-	request = m->COUNT;
-	ep = (endpoint_t) m->USER_ENDPT;
-	gid = (cp_grant_id_t) m->IO_GRANT;
-
-	if (minor != 0) return EINVAL;
 
 	switch(request) {
 	case FBIOGET_VSCREENINFO:
@@ -205,7 +149,7 @@ fb_ioctl(message *m)
 		return r;
 	}
 
-	return EINVAL;
+	return ENOTTY;
 }
 
 static int
@@ -270,34 +214,29 @@ do_get_fixscreeninfo(int minor, endpoint_t ep, cp_grant_id_t gid)
         return r;
 }
 
-static int
+static ssize_t
-fb_do_write(endpoint_t ep, iovec_t *iov, int minor, u64_t pos, size_t *io_bytes)
+fb_write(devminor_t minor, u64_t pos, endpoint_t ep, cp_grant_id_t gid,
+	size_t size, int UNUSED(flags), cdev_id_t UNUSED(id))
 {
 	struct device dev;
+	int r;
+
+	if (minor < 0 || minor >= FB_DEV_NR) return ENXIO;
+	assert(open_counter[minor] > 0);
+
+	if (has_restarted && keep_displaying_restarted())
+		return EAGAIN;
 
 	arch_get_device(minor, &dev);
 
-	if (pos >= dev.dv_size) {
+	if (size == 0 || pos >= dev.dv_size) return 0;
-		return EINVAL;
+	if (pos + size > dev.dv_size)
-	}
+		size = (size_t)(dev.dv_size - pos);
 
-	if (dev.dv_size - pos < iov->iov_size) {
+	r = sys_safecopyfrom(ep, gid, 0,
-		*io_bytes = dev.dv_size - pos;
+	    (vir_bytes)(dev.dv_base + (size_t)pos), size);
-	} else {
-		*io_bytes = iov->iov_size;
-	}
 
-        if (*io_bytes <= 0) {
+	return (r != OK) ? r : size;
-                return OK;
-        }
-
-	if (has_restarted && keep_displaying_restarted()) {
-		return EAGAIN;
-	}
-
-	return sys_safecopyfrom(ep, (cp_grant_id_t) iov->iov_addr, 0,
-				(vir_bytes) (dev.dv_base + ex64lo(pos)),
-				*io_bytes);
 }
 
 static int
@@ -382,7 +321,7 @@ main(int argc, char *argv[])
 	fb_edid_args_parse();
 
 	sef_local_startup();
-	chardriver_task(&fb_tab, CHARDRIVER_SYNC);
+	chardriver_task(&fb_tab);
 	return OK;
 }
 

drivers/fb/fb.h

@@ -3,7 +3,7 @@
 
 #include <minix/fb.h>
 
-int arch_fb_init(int minor, struct device *dev, struct edid_info *info);
+int arch_fb_init(int minor, struct edid_info *info);
 int arch_get_device(int minor, struct device *dev);
 int arch_get_varscreeninfo(int minor, struct fb_var_screeninfo *fbvsp);
 int arch_put_varscreeninfo(int minor, struct fb_var_screeninfo *fbvs_copy);

drivers/fb/fb_edid.c

@@ -92,7 +92,7 @@ do_read(endpoint_t driver_endpt, uint8_t *buf, size_t bufsize)
 	/* Open Device - required for drivers using libblockdriver */
 	memset(&m, '\0', sizeof(message));
 	m.m_type = BDEV_OPEN;
-	m.BDEV_ACCESS = R_BIT;
+	m.BDEV_ACCESS = BDEV_R_BIT;
 	m.BDEV_ID = 0;
 	m.BDEV_MINOR = 0;
 

drivers/fbd/fbd.c

@@ -15,34 +15,27 @@
 #define BUF_SIZE (NR_IOREQS * CLICK_SIZE)	/* 256k */
 
 /* Function declarations. */
-static int fbd_open(dev_t minor, int access);
+static int fbd_open(devminor_t minor, int access);
-static int fbd_close(dev_t minor);
+static int fbd_close(devminor_t minor);
-static int fbd_transfer(dev_t minor, int do_write, u64_t position,
+static int fbd_transfer(devminor_t minor, int do_write, u64_t position,
 	endpoint_t endpt, iovec_t *iov, unsigned int nr_req, int flags);
-static int fbd_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
+static int fbd_ioctl(devminor_t minor, unsigned long request, endpoint_t endpt,
-	cp_grant_id_t grant);
+	cp_grant_id_t grant, endpoint_t user_endpt);
 
 /* Variables. */
 static char *fbd_buf;			/* scratch buffer */
 
 static char driver_label[32] = "";	/* driver DS label */
-static dev_t driver_minor = -1;	/* driver's partition minor to use */
+static devminor_t driver_minor = -1;	/* driver's partition minor to use */
-static endpoint_t driver_endpt;	/* driver endpoint */
+static endpoint_t driver_endpt;		/* driver endpoint */
 
 /* Entry points to this driver. */
 static struct blockdriver fbd_dtab = {
-	BLOCKDRIVER_TYPE_OTHER,	/* do not handle partition requests */
+	.bdr_type	= BLOCKDRIVER_TYPE_OTHER,/* do not handle part. reqs */
-	fbd_open,		/* open or mount request, initialize device */
+	.bdr_open	= fbd_open,	/* open request, initialize device */
-	fbd_close,		/* release device */
+	.bdr_close	= fbd_close,	/* release device */
-	fbd_transfer,		/* do the I/O */
+	.bdr_transfer	= fbd_transfer,	/* do the I/O */
-	fbd_ioctl,		/* perform I/O control request */
+	.bdr_ioctl	= fbd_ioctl	/* perform I/O control request */
-	NULL,			/* nothing to clean up */
-	NULL,			/* we will not be asked about partitions */
-	NULL,			/* we will not be asked for geometry */
-	NULL,			/* ignore leftover hardware interrupts */
-	NULL,			/* ignore alarms */
-	NULL,			/* ignore other messages */
-	NULL			/* no multithreading support */
 };
 
 /* Options supported by this driver. */
@@ -147,7 +140,7 @@ int main(int argc, char **argv)
 /*===========================================================================*
  *				fbd_open				     *
  *===========================================================================*/
-static int fbd_open(dev_t UNUSED(minor), int access)
+static int fbd_open(devminor_t UNUSED(minor), int access)
 {
 	/* Open a device. */
 	message m;
@@ -172,7 +165,7 @@ static int fbd_open(dev_t UNUSED(minor), int access)
 /*===========================================================================*
  *				fbd_close				     *
  *===========================================================================*/
-static int fbd_close(dev_t UNUSED(minor))
+static int fbd_close(devminor_t UNUSED(minor))
 {
 	/* Close a device. */
 	message m;
@@ -196,8 +189,8 @@ static int fbd_close(dev_t UNUSED(minor))
 /*===========================================================================*
  *				fbd_ioctl				     *
  *===========================================================================*/
-static int fbd_ioctl(dev_t UNUSED(minor), unsigned int request,
+static int fbd_ioctl(devminor_t UNUSED(minor), unsigned long request,
-	endpoint_t endpt, cp_grant_id_t grant)
+	endpoint_t endpt, cp_grant_id_t grant, endpoint_t UNUSED(user_endpt))
 {
 	/* Handle an I/O control request. */
 	cp_grant_id_t gid;
@@ -222,6 +215,7 @@ static int fbd_ioctl(dev_t UNUSED(minor), unsigned int request,
 	m.BDEV_MINOR = driver_minor;
 	m.BDEV_REQUEST = request;
 	m.BDEV_GRANT = gid;
+	m.BDEV_USER = NONE;
 	m.BDEV_ID = 0;
 
 	if ((r = sendrec(driver_endpt, &m)) != OK)
@@ -406,11 +400,11 @@ static ssize_t fbd_transfer_copy(int do_write, u64_t position,
 /*===========================================================================*
  *				fbd_transfer				     *
  *===========================================================================*/
-static int fbd_transfer(dev_t UNUSED(minor), int do_write, u64_t position,
+static int fbd_transfer(devminor_t UNUSED(minor), int do_write, u64_t position,
 	endpoint_t endpt, iovec_t *iov, unsigned int nr_req, int flags)
 {
 	/* Transfer data from or to the device. */
-	unsigned count;
+	unsigned int count;
 	size_t size, osize;
 	int i, hooks;
 	ssize_t r;

drivers/filter/driver.c

@@ -31,7 +31,7 @@ static int driver_open(int which)
 	memset(&msg, 0, sizeof(msg));
 	msg.m_type = BDEV_OPEN;
 	msg.BDEV_MINOR = driver[which].minor;
-	msg.BDEV_ACCESS = R_BIT | W_BIT;
+	msg.BDEV_ACCESS = BDEV_R_BIT | BDEV_W_BIT;
 	msg.BDEV_ID = 0;
 	r = sendrec(driver[which].endpt, &msg);
 
@@ -60,6 +60,7 @@ static int driver_open(int which)
 	msg.BDEV_MINOR = driver[which].minor;
 	msg.BDEV_REQUEST = DIOCGETP;
 	msg.BDEV_GRANT = gid;
+	msg.BDEV_USER = NONE;
 	msg.BDEV_ID = 0;
 
 	r = sendrec(driver[which].endpt, &msg);
@@ -582,7 +583,7 @@ static int flt_receive(message *mess, int which)
 		}
 
 		if(mess->m_source == CLOCK && is_ipc_notify(ipc_status)) {
-			if (mess->NOTIFY_TIMESTAMP < flt_alarm(-1)) {
+			if (mess->NOTIFY_TIMESTAMP < flt_alarm((clock_t) -1)) {
 #if DEBUG
 				printf("Filter: SKIPPING old alarm "
 					"notification\n");

drivers/filter/main.c

@@ -63,12 +63,6 @@ static struct optset optset_table[] = {
   { NULL,	0,		NULL,			0		}
 };
 
-/* Request message. */
-static message m_in;
-static endpoint_t who_e;			/* m_source */
-static long req_id;				/* BDEV_ID */
-static cp_grant_id_t grant_id;			/* BDEV_GRANT */
-
 /* Data buffers. */
 static char *buf_array, *buffer;		/* contiguous buffer */
 
@@ -77,26 +71,46 @@ static void sef_local_startup(void);
 static int sef_cb_init_fresh(int type, sef_init_info_t *info);
 static void sef_cb_signal_handler(int signo);
 
-/*===========================================================================*
+static int filter_open(devminor_t minor, int access);
- *				carry					     *
+static int filter_close(devminor_t minor);
- *===========================================================================*/
+static ssize_t filter_transfer(devminor_t minor, int do_write, u64_t pos,
-static int carry(size_t size, int flag_rw)
+	endpoint_t endpt, iovec_t *iov, unsigned int count, int flags);
-{
+static int filter_ioctl(devminor_t minor, unsigned long request,
-	/* Carry data between caller proc and filter.
+	endpoint_t endpt, cp_grant_id_t grant, endpoint_t user_endpt);
-	 */
+static void filter_other(message *m, int ipc_status);
 
-	if (flag_rw == FLT_WRITE)
+static struct blockdriver filter_tab = {
-		return sys_safecopyfrom(who_e, grant_id, 0,
+	.bdr_type	= BLOCKDRIVER_TYPE_OTHER,
-			(vir_bytes) buffer, size);
+	.bdr_open	= filter_open,
-	else
+	.bdr_close	= filter_close,
-		return sys_safecopyto(who_e, grant_id, 0,
+	.bdr_transfer	= filter_transfer,
-			(vir_bytes) buffer, size);
+	.bdr_ioctl	= filter_ioctl,
+	.bdr_other	= filter_other
+};
+
+/*===========================================================================*
+ *				filter_open				     *
+ *===========================================================================*/
+static int filter_open(devminor_t UNUSED(minor), int UNUSED(access))
+{
+	/* Open is a noop for filter. */
+	return OK;
+}
+
+/*===========================================================================*
+ *				filter_close				     *
+ *===========================================================================*/
+static int filter_close(devminor_t UNUSED(minor))
+{
+	/* Close is a noop for filter. */
+	return OK;
 }
 
 /*===========================================================================*
  *				vcarry					     *
  *===========================================================================*/
-static int vcarry(int grants, iovec_t *iov, int flag_rw, size_t size)
+static int vcarry(endpoint_t endpt, unsigned int grants, iovec_t *iov,
+	int do_write, size_t size)
 {
 	/* Carry data between caller proc and filter, through grant-vector.
 	 */
@@ -108,12 +122,12 @@ static int vcarry(int grants, iovec_t *iov, int flag_rw, size_t size)
 	for(i = 0; i < grants && size > 0; i++) {
 		bytes = MIN(size, iov[i].iov_size);
 
-		if (flag_rw == FLT_WRITE)
+		if (do_write)
-			r = sys_safecopyfrom(who_e,
+			r = sys_safecopyfrom(endpt,
 				(vir_bytes) iov[i].iov_addr, 0,
 				(vir_bytes) bufp, bytes);
 		else
-			r = sys_safecopyto(who_e,
+			r = sys_safecopyto(endpt,
 				(vir_bytes) iov[i].iov_addr, 0,
 				(vir_bytes) bufp, bytes);
 
@@ -127,76 +141,19 @@ static int vcarry(int grants, iovec_t *iov, int flag_rw, size_t size)
 	return OK;
 }
 
-/*===========================================================================*
- *				do_rdwt					     *
- *===========================================================================*/
-static int do_rdwt(int flag_rw)
-{
-	size_t size, size_ret;
-	u64_t pos;
-	int r;
-
-	pos = make64(m_in.BDEV_POS_LO, m_in.BDEV_POS_HI);
-	size = m_in.BDEV_COUNT;
-
-	if (rem64u(pos, SECTOR_SIZE) != 0 || size % SECTOR_SIZE != 0) {
-		printf("Filter: unaligned request from caller!\n");
-
-		return EINVAL;
-	}
-
-	buffer = flt_malloc(size, buf_array, BUF_SIZE);
-
-	if(flag_rw == FLT_WRITE)
-		carry(size, flag_rw);
-
-	reset_kills();
-
-	for (;;) {
-		size_ret = size;
-		r = transfer(pos, buffer, &size_ret, flag_rw);
-		if(r != RET_REDO)
-			break;
-
-#if DEBUG
-		printf("Filter: transfer yielded RET_REDO, checking drivers\n");
-#endif
-		if((r = check_driver(DRIVER_MAIN)) != OK) break;
-		if((r = check_driver(DRIVER_BACKUP)) != OK) break;
-	}
-
-	if(r == OK && flag_rw == FLT_READ)
-		carry(size_ret, flag_rw);
-
-	flt_free(buffer, size, buf_array);
-
-	if (r != OK)
-		return r;
-
-	return size_ret;
-}
 
 /*===========================================================================*
- *				do_vrdwt				     *
+ *				filter_transfer				     *
  *===========================================================================*/
-static int do_vrdwt(int flag_rw)
+static ssize_t filter_transfer(devminor_t UNUSED(minor), int do_write,
+	u64_t pos, endpoint_t endpt, iovec_t *iov, unsigned int count,
+	int UNUSED(flags))
 {
 	size_t size, size_ret;
-	int grants;
 	int r, i;
-	u64_t pos;
-	iovec_t iov_proc[NR_IOREQS];
 
-	/* Extract informations. */
+	for(size = 0, i = 0; i < count; i++)
-	grants = m_in.BDEV_COUNT;
+		size += iov[i].iov_size;
-	if((r = sys_safecopyfrom(who_e, grant_id, 0, (vir_bytes) iov_proc,
-		grants * sizeof(iovec_t))) != OK) {
-		panic("copying in grant vector failed: %d", r);
-	}
-
-	pos = make64(m_in.BDEV_POS_LO, m_in.BDEV_POS_HI);
-	for(size = 0, i = 0; i < grants; i++)
-		size += iov_proc[i].iov_size;
 
 	if (rem64u(pos, SECTOR_SIZE) != 0 || size % SECTOR_SIZE != 0) {
 		printf("Filter: unaligned request from caller!\n");
@@ -205,14 +162,15 @@ static int do_vrdwt(int flag_rw)
 
 	buffer = flt_malloc(size, buf_array, BUF_SIZE);
 
-	if(flag_rw == FLT_WRITE)
+	if (do_write)
-		vcarry(grants, iov_proc, flag_rw, size);
+		vcarry(endpt, count, iov, do_write, size);
 
 	reset_kills();
 
 	for (;;) {
 		size_ret = size;
-		r = transfer(pos, buffer, &size_ret, flag_rw);
+		r = transfer(pos, buffer, &size_ret,
+			do_write ? FLT_WRITE : FLT_READ);
 		if(r != RET_REDO)
 			break;
 
@@ -228,8 +186,8 @@ static int do_vrdwt(int flag_rw)
 		return r;
 	}
 
-	if(flag_rw == FLT_READ)
+	if (!do_write)
-		vcarry(grants, iov_proc, flag_rw, size_ret);
+		vcarry(endpt, count, iov, do_write, size_ret);
 
 	flt_free(buffer, size, buf_array);
 
@@ -237,13 +195,14 @@ static int do_vrdwt(int flag_rw)
 }
 
 /*===========================================================================*
- *				do_ioctl				     *
+ *				filter_ioctl				     *
  *===========================================================================*/
-static int do_ioctl(message *m)
+static int filter_ioctl(devminor_t UNUSED(minor), unsigned long request,
+	endpoint_t endpt, cp_grant_id_t grant, endpoint_t UNUSED(user_endpt))
 {
 	struct part_geom sizepart;
 
-	switch(m->BDEV_REQUEST) {
+	switch (request) {
 	case DIOCSETP:
 	case DIOCTIMEOUT:
 	case DIOCOPENCT:
@@ -258,8 +217,7 @@ static int do_ioctl(message *m)
 		 */
 		sizepart.size = convert(get_raw_size());
 
-		if(sys_safecopyto(who_e, (vir_bytes) grant_id, 0,
+		if (sys_safecopyto(endpt, grant, 0, (vir_bytes) &sizepart,
-				(vir_bytes) &sizepart,
 				sizeof(struct part_geom)) != OK) {
 			printf("Filter: DIOCGETP safecopyto failed\n");
 			return EIO;
@@ -267,14 +225,24 @@ static int do_ioctl(message *m)
 		break;
 
 	default:
-		printf("Filter: unknown ioctl request: %d!\n",
+		printf("Filter: unknown ioctl request: %ld!\n", request);
-			m->BDEV_REQUEST);
+		return ENOTTY;
-		return EINVAL;
 	}
 
 	return OK;
 }
 
+/*===========================================================================*
+ *				filter_other				     *
+ *===========================================================================*/
+static void filter_other(message *m, int ipc_status)
+{
+	/* Process other messages. */
+	if (m->m_source == DS_PROC_NR && is_ipc_notify(ipc_status)) {
+		ds_event();
+	}
+}
+
 /*===========================================================================*
  *				parse_arguments				     *
  *===========================================================================*/
@@ -371,53 +339,7 @@ int main(int argc, char *argv[])
 	env_setargs(argc, argv);
 	sef_local_startup();
 
-	for (;;) {
+	blockdriver_task(&filter_tab);
-		/* Wait for request. */
-		if(driver_receive(ANY, &m_in, &ipc_status) != OK) {
-			panic("driver_receive failed");
-		}
-
-#if DEBUG2
-		printf("Filter: got request %d from %d\n",
-			m_in.m_type, m_in.m_source);
-#endif
-
-		if(m_in.m_source == DS_PROC_NR && is_ipc_notify(ipc_status)) {
-			ds_event();
-			continue;
-		}
-
-		who_e = m_in.m_source;
-		req_id = m_in.BDEV_ID;
-		grant_id = m_in.BDEV_GRANT;
-		size = 0;
-
-		/* Forword the request message to the drivers. */
-		switch(m_in.m_type) {
-		case BDEV_OPEN:		/* open/close is a noop for filter. */
-		case BDEV_CLOSE:	r = OK;				break;
-		case BDEV_READ:		r = do_rdwt(FLT_READ);		break;
-		case BDEV_WRITE:	r = do_rdwt(FLT_WRITE);		break;
-		case BDEV_GATHER:	r = do_vrdwt(FLT_READ);		break;
-		case BDEV_SCATTER:	r = do_vrdwt(FLT_WRITE);	break;
-		case BDEV_IOCTL:	r = do_ioctl(&m_in);		break;
-
-		default:
-			printf("Filter: ignoring unknown request %d from %d\n", 
-				m_in.m_type, m_in.m_source);
-			continue;
-		}
-
-#if DEBUG2
-		printf("Filter: replying with code %d\n", r);
-#endif
-
-		/* Send back reply message. */
-		m_out.m_type = BDEV_REPLY;
-		m_out.BDEV_ID = req_id;
-		m_out.BDEV_STATUS = r;
-		send(who_e, &m_out);
-	}
 
 	return 0;
 }
@@ -490,4 +412,3 @@ static void sef_cb_signal_handler(int signo)
 
 	exit(0);
 }
-

drivers/filter/util.c

@@ -45,7 +45,7 @@ clock_t flt_alarm(clock_t dt)
 {
 	int r;
 
-	if(dt < 0)
+	if((int) dt < 0)
 		return next_alarm;
 
 	r = sys_setalarm(dt, 0);

drivers/floppy/floppy.c

@@ -23,7 +23,7 @@
  */
 
 #include "floppy.h"
-#include <timers.h>
+#include <minix/timers.h>
 #include <machine/diskparm.h>
 #include <minix/sysutil.h>
 #include <minix/syslib.h>
@@ -212,7 +212,7 @@ static struct floppy {		/* main drive struct, one entry per drive */
   char fl_calibration;		/* CALIBRATED or UNCALIBRATED */
   u8_t fl_density;		/* NO_DENS = ?, 0 = 360K; 1 = 360K/1.2M; etc.*/
   u8_t fl_class;		/* bitmap for possible densities */
-  timer_t fl_tmr_stop;		/* timer to stop motor */
+  minix_timer_t fl_tmr_stop;		/* timer to stop motor */
   struct device fl_geom;	/* Geometry of the drive */
   struct device fl_part[NR_PARTITIONS];  /* partition's base & size */
 } floppy[NR_DRIVES];
@@ -236,16 +236,16 @@ static u8_t f_results[MAX_RESULTS];/* the controller can give lots of output */
  * Besides the 'f_tmr_timeout' timer below, the floppy structure for each
  * floppy disk drive contains a 'fl_tmr_stop' timer. 
  */
-static timer_t f_tmr_timeout;		/* timer for various timeouts */
+static minix_timer_t f_tmr_timeout;		/* timer for various timeouts */
 static u32_t system_hz;		/* system clock frequency */
 static void f_expire_tmrs(clock_t stamp);
-static void stop_motor(timer_t *tp);
+static void stop_motor(minix_timer_t *tp);
-static void f_timeout(timer_t *tp);
+static void f_timeout(minix_timer_t *tp);
 
-static struct device *f_prepare(dev_t device);
+static struct device *f_prepare(devminor_t device);
-static struct device *f_part(dev_t minor);
+static struct device *f_part(devminor_t minor);
 static void f_cleanup(void);
-static ssize_t f_transfer(dev_t minor, int do_write, u64_t position,
+static ssize_t f_transfer(devminor_t minor, int do_write, u64_t position,
 	endpoint_t proc_nr, iovec_t *iov, unsigned int nr_req, int flags);
 static int dma_setup(int do_write);
 static void start_motor(void);
@@ -258,25 +258,21 @@ static int recalibrate(void);
 static void f_reset(void);
 static int f_intr_wait(void);
 static int read_id(void);
-static int f_do_open(dev_t minor, int access);
+static int f_do_open(devminor_t minor, int access);
-static int f_do_close(dev_t minor);
+static int f_do_close(devminor_t minor);
 static int test_read(int density);
-static void f_geometry(dev_t minor, struct part_geom *entry);
+static void f_geometry(devminor_t minor, struct part_geom *entry);
 
 /* Entry points to this driver. */
 static struct blockdriver f_dtab = {
-  BLOCKDRIVER_TYPE_DISK,	/* handle partition requests */
+  .bdr_type	= BLOCKDRIVER_TYPE_DISK,	/* handle partition requests */
-  f_do_open,	/* open or mount request, sense type of diskette */
+  .bdr_open	= f_do_open,	/* open request, sense type of diskette */
-  f_do_close,	/* nothing on a close */
+  .bdr_close	= f_do_close,	/* nothing on a close */
-  f_transfer,	/* do the I/O */
+  .bdr_transfer	= f_transfer,	/* do the I/O */
-  NULL,		/* no other I/O control requests are supported */
+  .bdr_cleanup	= f_cleanup,	/* cleanup before sending reply to caller */
-  f_cleanup,	/* cleanup before sending reply to user process */
+  .bdr_part	= f_part,	/* return partition information structure */
-  f_part,	/* return partition information structure */
+  .bdr_geometry	= f_geometry,	/* tell the geometry of the diskette */
-  f_geometry,	/* tell the geometry of the diskette */
+  .bdr_alarm	= f_expire_tmrs /* expire all alarm timers */
-  NULL,		/* no processing of hardware interrupts */
-  f_expire_tmrs,/* expire all alarm timers */
-  NULL,		/* no processing of other messages */
-  NULL		/* no threading support */
 };
 
 static char *floppy_buf;
@@ -397,13 +393,13 @@ static void f_expire_tmrs(clock_t stamp)
 /*===========================================================================*
  *				f_prepare				     *
  *===========================================================================*/
-static struct device *f_prepare(dev_t device)
+static struct device *f_prepare(devminor_t device)
 {
 /* Prepare for I/O on a device. */
 
   f_device = device;
   f_drive = device & ~(DEV_TYPE_BITS | FORMAT_DEV_BIT);
-  if (f_drive >= NR_DRIVES) return(NULL);
+  if (device < 0 || f_drive >= NR_DRIVES) return(NULL);
 
   f_fp = &floppy[f_drive];
   f_dv = &f_fp->fl_geom;
@@ -424,7 +420,7 @@ static struct device *f_prepare(dev_t device)
 /*===========================================================================*
  *				f_part					     *
  *===========================================================================*/
-static struct device *f_part(dev_t minor)
+static struct device *f_part(devminor_t minor)
 {
 /* Return a pointer to the partition information of the given minor device. */
 
@@ -447,7 +443,7 @@ static void f_cleanup(void)
  *				f_transfer				     *
  *===========================================================================*/
 static ssize_t f_transfer(
-  dev_t minor,			/* minor device number */
+  devminor_t minor,		/* minor device number */
   int do_write,			/* read or write? */
   u64_t pos64,			/* offset on device to read or write */
   endpoint_t proc_nr,		/* process doing the request */
@@ -789,7 +785,7 @@ static void start_motor(void)
 /*===========================================================================*
  *				stop_motor				     *
  *===========================================================================*/
-static void stop_motor(timer_t *tp)
+static void stop_motor(minix_timer_t *tp)
 {
 /* This routine is called from an alarm timer after several seconds have
  * elapsed with no floppy disk activity.  It turns the drive motor off.
@@ -1203,7 +1199,7 @@ static int f_intr_wait(void)
 /*===========================================================================*
  *				f_timeout				     *
  *===========================================================================*/
-static void f_timeout(timer_t *UNUSED(tp))
+static void f_timeout(minix_timer_t *UNUSED(tp))
 {
 /* This routine is called when a timer expires.  Usually to tell that a
  * motor has spun up, but also to forge an interrupt when it takes too long
@@ -1251,7 +1247,7 @@ static int read_id(void)
 /*===========================================================================*
  *				f_do_open				     *
  *===========================================================================*/
-static int f_do_open(dev_t minor, int UNUSED(access))
+static int f_do_open(devminor_t minor, int UNUSED(access))
 {
 /* Handle an open on a floppy.  Determine diskette type if need be. */
 
@@ -1310,7 +1306,7 @@ static int f_do_open(dev_t minor, int UNUSED(access))
 /*===========================================================================*
  *				f_do_close				     *
  *===========================================================================*/
-static int f_do_close(dev_t UNUSED(minor))
+static int f_do_close(devminor_t UNUSED(minor))
 {
 /* Handle a close on a floppy.  Nothing to do here. */
 
@@ -1350,7 +1346,7 @@ static int test_read(int density)
 /*===========================================================================*
  *				f_geometry				     *
  *===========================================================================*/
-static void f_geometry(dev_t minor, struct part_geom *entry)
+static void f_geometry(devminor_t minor, struct part_geom *entry)
 {
   if (f_prepare(minor) == NULL) return;
 

drivers/fxp/fxp.c

@@ -18,7 +18,7 @@
 #include <minix/ds.h>
 #include <minix/endpoint.h>
 
-#include <timers.h>
+#include <minix/timers.h>
 
 #define debug			0
 #define RAND_UPDATE		/**/
@@ -141,7 +141,7 @@ static int fxp_instance;
 
 static fxp_t *fxp_state;
 
-static timer_t fxp_watchdog;
+static minix_timer_t fxp_watchdog;
 
 static u32_t system_hz;
 
@@ -170,7 +170,7 @@ static void fxp_restart_ru(fxp_t *fp);
 static void fxp_getstat_s(message *mp);
 static void fxp_handler(fxp_t *fp);
 static void fxp_check_ints(fxp_t *fp);
-static void fxp_watchdog_f(timer_t *tp);
+static void fxp_watchdog_f(minix_timer_t *tp);
 static int fxp_link_changed(fxp_t *fp);
 static void fxp_report_link(fxp_t *fp);
 static void reply(fxp_t *fp);
@@ -1627,7 +1627,7 @@ static void fxp_check_ints(fxp_t *fp)
  *				fxp_watchdog_f				     *
  *===========================================================================*/
 static void fxp_watchdog_f(tp)
-timer_t *tp;
+minix_timer_t *tp;
 {
 	fxp_t *fp;
 

drivers/fxp/fxp.conf

@@ -8,13 +8,13 @@ service fxp
                 IRQCTL          # 19
                 DEVIO           # 21
         ;
-        pci device      8086/1031;
+        pci device      8086:1031;
-        pci device      8086/1032;
+        pci device      8086:1032;
-        pci device      8086/103d;
+        pci device      8086:103d;
-        pci device      8086/1064;
+        pci device      8086:1064;
-        pci device      8086/1229;
+        pci device      8086:1229;
-        pci device      8086/2449;
+        pci device      8086:2449;
-        pci device      8086/1209;
+        pci device      8086:1209;
         ipc
                 SYSTEM pm rs log tty ds vm
                 pci inet lwip amddev

drivers/hello/hello.c

@@ -8,12 +8,10 @@
 /*
  * Function prototypes for the hello driver.
  */
-static int hello_open(message *m);
+static int hello_open(devminor_t minor, int access, endpoint_t user_endpt);
-static int hello_close(message *m);
+static int hello_close(devminor_t minor);
-static struct device * hello_prepare(dev_t device);
+static ssize_t hello_read(devminor_t minor, u64_t position, endpoint_t endpt,
-static int hello_transfer(endpoint_t endpt, int opcode, u64_t position,
+    cp_grant_id_t grant, size_t size, int flags, cdev_id_t id);
-	iovec_t *iov, unsigned int nr_req, endpoint_t user_endpt, unsigned int
-	flags);
 
 /* SEF functions and variables. */
 static void sef_local_startup(void);
@@ -24,77 +22,54 @@ static int lu_state_restore(void);
 /* Entry points to the hello driver. */
 static struct chardriver hello_tab =
 {
-    hello_open,
+    .cdr_open	= hello_open,
-    hello_close,
+    .cdr_close	= hello_close,
-    nop_ioctl,
+    .cdr_read	= hello_read,
-    hello_prepare,
-    hello_transfer,
-    nop_cleanup,
-    nop_alarm,
-    nop_cancel,
-    nop_select,
-    NULL
 };
 
-/** Represents the /dev/hello device. */
+/** State variable to count the number of times the device has been opened.
-static struct device hello_device;
+ * Note that this is not the regular type of open counter: it never decreases.
-
+ */
-/** State variable to count the number of times the device has been opened. */
 static int open_counter;
 
-static int hello_open(message *UNUSED(m))
+static int hello_open(devminor_t UNUSED(minor), int UNUSED(access),
+    endpoint_t UNUSED(user_endpt))
 {
     printf("hello_open(). Called %d time(s).\n", ++open_counter);
     return OK;
 }
 
-static int hello_close(message *UNUSED(m))
+static int hello_close(devminor_t UNUSED(minor))
 {
     printf("hello_close()\n");
     return OK;
 }
 
-static struct device * hello_prepare(dev_t UNUSED(dev))
+static ssize_t hello_read(devminor_t UNUSED(minor), u64_t position,
+    endpoint_t endpt, cp_grant_id_t grant, size_t size, int UNUSED(flags),
+    cdev_id_t UNUSED(id))
 {
-    hello_device.dv_base = make64(0, 0);
+    u64_t dev_size;
-    hello_device.dv_size = make64(strlen(HELLO_MESSAGE), 0);
+    char *ptr;
-    return &hello_device;
+    int ret;
-}
 
-static int hello_transfer(endpoint_t endpt, int opcode, u64_t position,
+    printf("hello_read()\n");
-    iovec_t *iov, unsigned nr_req, endpoint_t UNUSED(user_endpt),
-    unsigned int UNUSED(flags))
-{
-    int bytes, ret;
 
-    printf("hello_transfer()\n");
+    /* This is the total size of our device. */
+    dev_size = (u64_t) strlen(HELLO_MESSAGE);
 
-    if (nr_req != 1)
+    /* Check for EOF, and possibly limit the read size. */
-    {
+    if (position >= dev_size) return 0;		/* EOF */
-        /* This should never trigger for character drivers at the moment. */
+    if (position + size > dev_size)
-        printf("HELLO: vectored transfer request, using first element only\n");
+        size = (size_t)(dev_size - position);	/* limit size */
-    }
 
-    bytes = strlen(HELLO_MESSAGE) - ex64lo(position) < iov->iov_size ?
+    /* Copy the requested part to the caller. */
-            strlen(HELLO_MESSAGE) - ex64lo(position) : iov->iov_size;
+    ptr = HELLO_MESSAGE + (size_t)position;
+    if ((ret = sys_safecopyto(endpt, grant, 0, (vir_bytes) ptr, size)) != OK)
+        return ret;
 
-    if (bytes <= 0)
+    /* Return the number of bytes read. */
-    {
+    return size;
-        return OK;
-    }
-    switch (opcode)
-    {
-        case DEV_GATHER_S:
-            ret = sys_safecopyto(endpt, (cp_grant_id_t) iov->iov_addr, 0,
-                                (vir_bytes) (HELLO_MESSAGE + ex64lo(position)),
-                                 bytes);
-            iov->iov_size -= bytes;
-            break;
-
-        default:
-            return EINVAL;
-    }
-    return ret;
 }
 
 static int sef_cb_lu_state_save(int UNUSED(state)) {
@@ -181,7 +156,7 @@ int main(void)
     /*
      * Run the main loop.
      */
-    chardriver_task(&hello_tab, CHARDRIVER_SYNC);
+    chardriver_task(&hello_tab);
     return OK;
 }
 

drivers/i2c/i2c.c

@@ -33,16 +33,14 @@ static void update_reservation(endpoint_t endpt, char *key);
 static void ds_event(void);
 
 static int validate_ioctl_exec(minix_i2c_ioctl_exec_t * ioctl_exec);
-static int do_i2c_ioctl_exec(message * m);
+static int do_i2c_ioctl_exec(endpoint_t caller, cp_grant_id_t grant_nr);
 
 static int env_parse_instance(void);
 
 /* libchardriver callbacks */
-int i2c_ioctl(message * m);
+static int i2c_ioctl(devminor_t minor, unsigned long request, endpoint_t endpt,
-struct device *i2c_prepare(dev_t dev);
+	cp_grant_id_t grant, int flags, endpoint_t user_endpt, cdev_id_t id);
-int i2c_transfer(endpoint_t endpt, int opcode, u64_t position,
+static void i2c_other(message * m, int ipc_status);
-    iovec_t * iov, unsigned nr_req, endpoint_t user_endpt, unsigned int flags);
-int i2c_other(message * m);
 
 /* SEF callbacks and driver state management */
 static int sef_cb_lu_state_save(int);
@@ -68,8 +66,6 @@ static struct i2cdev
  */
 int (*process) (minix_i2c_ioctl_exec_t * ioctl_exec);
 
-struct device i2c_device;
-
 /* logging - use with log_warn(), log_info(), log_debug(), log_trace() */
 static struct log log = {
 	.name = "i2c",
@@ -81,16 +77,8 @@ static struct log log = {
  * Only i2c_ioctl() and i2c_other() are implemented. The rest are no-op.
  */
 static struct chardriver i2c_tab = {
-	.cdr_open = do_nop,
+	.cdr_ioctl	= i2c_ioctl,
-	.cdr_close = do_nop,
+	.cdr_other	= i2c_other
-	.cdr_ioctl = i2c_ioctl,
-	.cdr_prepare = i2c_prepare,
-	.cdr_transfer = i2c_transfer,
-	.cdr_cleanup = nop_cleanup,
-	.cdr_alarm = nop_alarm,
-	.cdr_cancel = nop_cancel,
-	.cdr_select = nop_select,
-	.cdr_other = i2c_other
 };
 
 /*
@@ -232,14 +220,14 @@ validate_ioctl_exec(minix_i2c_ioctl_exec_t * ioctl_exec)
 	}
 
 	len = ioctl_exec->iie_cmdlen;
-	if (len < 0 || len > I2C_EXEC_MAX_CMDLEN) {
+	if (len > I2C_EXEC_MAX_CMDLEN) {
 		log_warn(&log,
 		    "iie_cmdlen out of range 0-I2C_EXEC_MAX_CMDLEN\n");
 		return EINVAL;
 	}
 
 	len = ioctl_exec->iie_buflen;
-	if (len < 0 || len > I2C_EXEC_MAX_BUFLEN) {
+	if (len > I2C_EXEC_MAX_BUFLEN) {
 		log_warn(&log,
 		    "iie_buflen out of range 0-I2C_EXEC_MAX_BUFLEN\n");
 		return EINVAL;
@@ -252,16 +240,11 @@ validate_ioctl_exec(minix_i2c_ioctl_exec_t * ioctl_exec)
  * Performs the action in minix_i2c_ioctl_exec_t.
  */
 static int
-do_i2c_ioctl_exec(message * m)
+do_i2c_ioctl_exec(endpoint_t caller, cp_grant_id_t grant_nr)
 {
 	int r;
-	endpoint_t caller;
-	cp_grant_id_t grant_nr;
 	minix_i2c_ioctl_exec_t ioctl_exec;
 
-	caller = (endpoint_t) m->m_source;
-	grant_nr = (cp_grant_id_t) m->IO_GRANT;
-
 	/* Copy the requested exection into the driver */
 	r = sys_safecopyfrom(caller, grant_nr, (vir_bytes) 0,
 	    (vir_bytes) & ioctl_exec, sizeof(ioctl_exec));
@@ -302,45 +285,48 @@ do_i2c_ioctl_exec(message * m)
 	return OK;
 }
 
-int
+static int
-i2c_ioctl(message * m)
+i2c_ioctl(devminor_t UNUSED(minor), unsigned long request, endpoint_t endpt,
+	cp_grant_id_t grant, int UNUSED(flags), endpoint_t UNUSED(user_endpt),
+	cdev_id_t UNUSED(id))
 {
 	int r;
 
-	switch (m->COUNT) {
+	switch (request) {
 	case MINIX_I2C_IOCTL_EXEC:
-		r = do_i2c_ioctl_exec(m);
+		r = do_i2c_ioctl_exec(endpt, grant);
 		break;
 	default:
-		log_warn(&log, "Invalid ioctl() 0x%x\n", m->COUNT);
+		log_warn(&log, "Invalid ioctl() 0x%x\n", request);
-		r = EINVAL;
+		r = ENOTTY;
 		break;
 	}
 
 	return r;
 }
 
-int
+static void
-i2c_other(message * m)
+i2c_other(message * m, int ipc_status)
 {
+	message m_reply;
 	int r;
 
-	switch (m->m_type) {
+	if (is_ipc_notify(ipc_status)) {
-	case BUSC_I2C_RESERVE:
-		/* reserve a device on the bus for exclusive access */
-		r = do_reserve((endpoint_t) m->m_source, m->DEVICE);
-		break;
-	case BUSC_I2C_EXEC:
-		/* handle request from another driver */
-		m->COUNT = MINIX_I2C_IOCTL_EXEC;
-		r = do_i2c_ioctl_exec(m);
-		break;
-	case NOTIFY_MESSAGE:
 		/* handle notifications about drivers changing state */
 		if (m->m_source == DS_PROC_NR) {
 			ds_event();
 		}
-		r = OK;
+		return;
+	}
+
+	switch (m->m_type) {
+	case BUSC_I2C_RESERVE:
+		/* reserve a device on the bus for exclusive access */
+		r = do_reserve(m->m_source, m->BUSC_I2C_ADDR);
+		break;
+	case BUSC_I2C_EXEC:
+		/* handle request from another driver */
+		r = do_i2c_ioctl_exec(m->m_source, m->BUSC_I2C_GRANT);
 		break;
 	default:
 		log_warn(&log, "Invalid message type (0x%x)\n", m->m_type);
@@ -350,25 +336,12 @@ i2c_other(message * m)
 
 	log_trace(&log, "i2c_other() returning r=%d\n", r);
 
-	return r;
+	/* Send a reply. */
-}
+	memset(&m_reply, 0, sizeof(m_reply));
+	m_reply.m_type = r;
 
-struct device *
+	if ((r = send(m->m_source, &m_reply)) != OK)
-i2c_prepare(dev_t dev)
+		log_warn(&log, "send() to %d failed: %d\n", m->m_source, r);
-{
-	/* NOP */
-	i2c_device.dv_base = make64(0, 0);
-	i2c_device.dv_size = make64(0, 0);
-
-	return &i2c_device;
-}
-
-int
-i2c_transfer(endpoint_t endpt, int opcode, u64_t position,
-    iovec_t * iov, unsigned nr_req, endpoint_t user_endpt, unsigned int flags)
-{
-	/* NOP */
-	return OK;
 }
 
 /*
@@ -549,7 +522,7 @@ main(int argc, char *argv[])
 
 	memset(i2cdev, '\0', sizeof(i2cdev));
 	sef_local_startup();
-	chardriver_task(&i2c_tab, CHARDRIVER_SYNC);
+	chardriver_task(&i2c_tab);
 
 	return OK;
 }

drivers/lance/lance.conf

@@ -8,7 +8,7 @@ service lance
                 IRQCTL          # 19
                 DEVIO           # 21
         ;
-        pci device      1022/2000;
+        pci device      1022:2000;
         uid     0;
 };
 

drivers/log/log.c

@@ -19,32 +19,24 @@
 #define LOGINC(n, i)	do { (n) = (((n) + (i)) % LOG_SIZE); } while(0)
 
 struct logdevice logdevices[NR_DEVS];
-static struct device log_geom[NR_DEVS];  	/* base and size of devices */
-static int log_device = -1;	 		/* current device */
 
-static struct device *log_prepare(dev_t device);
+static ssize_t log_read(devminor_t minor, u64_t position, endpoint_t endpt,
-static int log_transfer(endpoint_t endpt, int opcode, u64_t position,
+	cp_grant_id_t grant, size_t size, int flags, cdev_id_t id);
-	iovec_t *iov, unsigned int nr_req, endpoint_t user_endpt, unsigned int
+static ssize_t log_write(devminor_t minor, u64_t position, endpoint_t endpt,
-	flags);
+	cp_grant_id_t grant, size_t size, int flags, cdev_id_t id);
-static int log_do_open(message *m_ptr);
+static int log_open(devminor_t minor, int access, endpoint_t user_endpt);
-static int log_cancel(message *m_ptr);
+static int log_cancel(devminor_t minor, endpoint_t endpt, cdev_id_t id);
-static int log_select(message *m_ptr);
+static int log_select(devminor_t minor, unsigned int ops, endpoint_t endpt);
-static int log_other(message *m_ptr);
+static int subread(struct logdevice *log, size_t size, endpoint_t endpt,
-static int subread(struct logdevice *log, int count, endpoint_t endpt,
+	cp_grant_id_t grant);
-	cp_grant_id_t grant, size_t);
 
 /* Entry points to this driver. */
 static struct chardriver log_dtab = {
-  log_do_open,	/* open or mount */
+  .cdr_open	= log_open,
-  do_nop,	/* nothing on a close */
+  .cdr_read	= log_read,
-  nop_ioctl,	/* ioctl nop */
+  .cdr_write	= log_write,
-  log_prepare,	/* prepare for I/O on a given minor device */
+  .cdr_cancel	= log_cancel,
-  log_transfer,	/* do the I/O */
+  .cdr_select	= log_select
-  nop_cleanup,	/* no need to clean up */
-  nop_alarm,	/* no alarm */
-  log_cancel,	/* CANCEL request */
-  log_select,	/* DEV_SELECT request */
-  log_other	/* Unrecognized messages */
 };
 
 /* SEF functions and variables. */
@@ -64,7 +56,7 @@ int main(void)
   sef_local_startup();
 
   /* Call the generic receive loop. */
-  chardriver_task(&log_dtab, CHARDRIVER_ASYNC);
+  chardriver_task(&log_dtab);
 
   return(OK);
 }
@@ -101,17 +93,15 @@ static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info))
 
   /* Initialize log devices. */
   for(i = 0; i < NR_DEVS; i++) {
-  	log_geom[i].dv_size = ((u64_t)(LOG_SIZE));
- 	log_geom[i].dv_base = ((u64_t)((long)logdevices[i].log_buffer));
  	logdevices[i].log_size = logdevices[i].log_read =
 	 	logdevices[i].log_write =
-	 	logdevices[i].log_select_alerted =
+		logdevices[i].log_selected = 0;
-	 	logdevices[i].log_selected =
-	 	logdevices[i].log_select_ready_ops = 0;
  	logdevices[i].log_source = NONE;
- 	logdevices[i].log_revive_alerted = 0;
   }
 
+  /* Register for diagnostics notifications. */
+  sys_diagctl_register();
+
   return(OK);
 }
 
@@ -126,29 +116,24 @@ static void sef_cb_signal_handler(int signo)
   do_new_kmess();
 }
 
-/*===========================================================================*
- *				log_prepare				     *
- *===========================================================================*/
-static struct device *log_prepare(dev_t device)
-{
-/* Prepare for I/O on a device: check if the minor device number is ok. */
-
-  if (device >= NR_DEVS) return(NULL);
-  log_device = (int) device;
-
-  return(&log_geom[device]);
-}
-
 /*===========================================================================*
  *				subwrite				     *
  *===========================================================================*/
 static int
-subwrite(struct logdevice *log, int count, endpoint_t endpt,
+subwrite(struct logdevice *log, size_t size, endpoint_t endpt,
-	cp_grant_id_t grant, size_t offset, char *localbuf)
+	cp_grant_id_t grant, char *localbuf)
 {
-	int d, r;
+  size_t count, offset;
-	char *buf;
+  int overflow, r;
-	message m;
+  devminor_t minor;
+  char *buf;
+  message m;
+
+  /* With a sufficiently large input size, we might wrap around the ring buffer
+   * multiple times.
+   */
+  for (offset = 0; offset < size; offset += count) {
+	count = size - offset;
 
 	if (log->log_write + count > LOG_SIZE)
 		count = LOG_SIZE - log->log_write;
@@ -156,75 +141,49 @@ subwrite(struct logdevice *log, int count, endpoint_t endpt,
 
 	if(localbuf != NULL) {
 		memcpy(buf, localbuf, count);
+		localbuf += count;
 	}
 	else {
 		if((r=sys_safecopyfrom(endpt, grant, offset,
 			(vir_bytes)buf, count)) != OK)
-			return r;
+			break; /* do process partial write upon error */
 	}
 
 	LOGINC(log->log_write, count);
 	log->log_size += count;
 
         if(log->log_size > LOG_SIZE) {
-        	int overflow;
         	overflow = log->log_size - LOG_SIZE;
         	log->log_size -= overflow;
         	LOGINC(log->log_read, overflow);
         }
 
-        if(log->log_size > 0 && log->log_source != NONE &&
+	r = offset; /* this will be the return value upon success */
-			!log->log_revive_alerted) {
+  }
-        	/* Someone who was suspended on read can now
-        	 * be revived.
-        	 */
-    		log->log_status = subread(log, log->log_iosize,
-    			log->log_source, log->log_user_grant,
-			log->log_user_offset);
 
-		m.m_type = DEV_REVIVE;
+  if (log->log_size > 0 && log->log_source != NONE) {
-		m.REP_ENDPT = log->log_proc_nr;
+	/* Someone who was suspended on read can now be revived. */
-		m.REP_STATUS  = log->log_status;
+	r = subread(log, log->log_iosize, log->log_source, log->log_grant);
-		m.REP_IO_GRANT  = log->log_user_grant;
-  		r= send(log->log_source, &m);
-		if (r != OK)
-		{
-			printf("log`subwrite: send to %d failed: %d\n",
-				log->log_source, r);
-		}
-		log->log_source = NONE;
- 	} 
 
-	if(log->log_size > 0)
+	chardriver_reply_task(log->log_source, log->log_id, r);
-		log->log_select_ready_ops |= SEL_RD;
 
-	if(log->log_size > 0 && log->log_selected &&
+	log->log_source = NONE;
-	  !(log->log_select_alerted)) {
+  }
-  		/* Someone(s) who was/were select()ing can now
+
-  		 * be awoken. If there was a blocking read (above),
+  if (log->log_size > 0 && (log->log_selected & CDEV_OP_RD)) {
-  		 * this can only happen if the blocking read didn't
+	/* Someone(s) who was/were select()ing can now be awoken. If there was
-  		 * swallow all the data (log_size > 0).
+	 * a blocking read (above), this can only happen if the blocking read
-  		 */
+	 * didn't swallow all the data (log_size > 0).
-  		if(log->log_selected & SEL_RD) {
+	 */
-			d= log-logdevices;
+	minor = log-logdevices;
-			m.m_type = DEV_SEL_REPL2;
-			m.DEV_SEL_OPS = log->log_select_ready_ops;
-			m.DEV_MINOR   = d;
 #if LOG_DEBUG
-			printf("select sending DEV_SEL_REPL2\n");
+	printf("select sending CDEV_SEL2_REPLY\n");
 #endif
-  			r= send(log->log_select_proc, &m);
+	chardriver_reply_select(log->log_select_proc, minor, CDEV_OP_RD);
-			if (r != OK)
+	log->log_selected &= ~CDEV_OP_RD;
-			{
+  }
-				printf(	
-				"log`subwrite: send to %d failed: %d\n",
-					log->log_select_proc, r);
-			}
-			log->log_selected &= ~log->log_select_ready_ops;
-  		}
-  	}
 
-        return count;
+  return r;
 }
 
 /*===========================================================================*
@@ -233,210 +192,156 @@ subwrite(struct logdevice *log, int count, endpoint_t endpt,
 void
 log_append(char *buf, int count)
 {
-	int w = 0, skip = 0;
+  int skip = 0;
 
-	if(count < 1) return;
+  if(count < 1) return;
-	if(count > LOG_SIZE) skip = count - LOG_SIZE;
+  if(count > LOG_SIZE) skip = count - LOG_SIZE;
-	count -= skip;
+  count -= skip;
-	buf += skip;
+  buf += skip;
-	w = subwrite(&logdevices[0], count, SELF, GRANT_INVALID, 0, buf);
 
-	if(w > 0 && w < count)
+  subwrite(&logdevices[0], count, SELF, GRANT_INVALID, buf);
-		subwrite(&logdevices[0], count-w, SELF, GRANT_INVALID, 0,
-			buf + w);
-	return;
 }
 
 /*===========================================================================*
  *				subread					     *
  *===========================================================================*/
 static int
-subread(struct logdevice *log, int count, endpoint_t endpt,
+subread(struct logdevice *log, size_t size, endpoint_t endpt,
-	cp_grant_id_t grant, size_t offset)
+	cp_grant_id_t grant)
 {
-	char *buf;
+  size_t offset, count;
-	int r;
+  char *buf;
+  int r;
+
+  for (offset = 0; log->log_size > 0 && offset < size; offset += count) {
+	count = size - offset;
+
     	if (count > log->log_size)
     		count = log->log_size;
         if (log->log_read + count > LOG_SIZE)
         	count = LOG_SIZE - log->log_read;
 
     	buf = log->log_buffer + log->log_read;
-	if((r=sys_safecopyto(endpt, grant, offset,
+	if((r=sys_safecopyto(endpt, grant, offset, (vir_bytes)buf,
-		(vir_bytes)buf, count)) != OK)
+		count)) != OK)
 		return r;
 
   	LOGINC(log->log_read, count);
         log->log_size -= count;
+  }
 
-        return count;
+  return offset;
 }
 
 /*===========================================================================*
- *				log_transfer				     *
+ *				log_read				     *
  *===========================================================================*/
-static int log_transfer(
+static ssize_t log_read(devminor_t minor, u64_t UNUSED(position),
-  endpoint_t endpt,		/* endpoint of grant owner */
+	endpoint_t endpt, cp_grant_id_t grant, size_t size, int flags,
-  int opcode,			/* DEV_GATHER_S or DEV_SCATTER_S */
+	cdev_id_t id)
-  u64_t UNUSED(position),	/* offset on device to read or write */
-  iovec_t *iov,			/* pointer to read or write request vector */
-  unsigned int nr_req,		/* length of request vector */
-  endpoint_t user_endpt,	/* endpoint of user process */
-  unsigned int UNUSED(flags)
-)
 {
-/* Read or write one the driver's minor devices. */
+/* Read from one of the driver's minor devices. */
-  int count;
-  cp_grant_id_t grant;
-  int accumulated_read = 0;
   struct logdevice *log;
-  size_t vir_offset = 0;
+  int r;
 
-  if(log_device < 0 || log_device >= NR_DEVS)
+  if (minor < 0 || minor >= NR_DEVS) return EIO;
-  	return EIO;
+  log = &logdevices[minor];
 
-  /* Get minor device number and check for /dev/null. */
+  /* If there's already someone hanging to read, don't accept new work. */
-  log = &logdevices[log_device];
+  if (log->log_source != NONE) return OK;
 
-  while (nr_req > 0) {
+  if (!log->log_size && size > 0) {
-	/* How much to transfer and where to / from. */
+	if (flags & CDEV_NONBLOCK) return EAGAIN;
-	count = iov->iov_size;
-	grant = iov->iov_addr;
 
-	switch (log_device) {
+	/* No data available; let caller block. */
-
+	log->log_source = endpt;
-	case MINOR_KLOG:
+	log->log_iosize = size;
-	    if (opcode == DEV_GATHER_S) {
+	log->log_grant = grant;
-	    	if (log->log_source != NONE || count < 1) {
+	log->log_id = id;
-	    		/* There's already someone hanging to read, or
-	    		 * no real I/O requested.
-	    		 */
-	    		return(OK);
-	    	}
-
-	    	if (!log->log_size) {
-	    		if(accumulated_read)
-	    			return OK;
-	    		/* No data available; let caller block. */
-			log->log_source = endpt;
-	    		log->log_iosize = count;
-	    		log->log_user_grant = grant;
-	    		log->log_user_offset = 0;
-	    		log->log_revive_alerted = 0;
-			log->log_proc_nr = user_endpt;
 #if LOG_DEBUG
-	    		printf("blocked %d (%d)\n", 
+	printf("blocked %d (%d)\n", log->log_source, id);
-	    			log->log_source, log->log_proc_nr);
 #endif
-	    		return(EDONTREPLY);
+	return EDONTREPLY;
-	    	}
-		count = subread(log, count, endpt, grant, vir_offset);
-	    	if(count < 0) {
-	    		return count;
-	    	}
-	    	accumulated_read += count;
-	    } else {
-		count = subwrite(log, count, endpt, grant, vir_offset, NULL);
-	    	if(count < 0)
-	    		return count;
-	    }
-	    break;
-	/* Unknown (illegal) minor device. */
-	default:
-	    return(EINVAL);
-	}
-
-	/* Book the number of bytes transferred. */
-	vir_offset += count;
-  	if ((iov->iov_size -= count) == 0) { iov++; nr_req--; vir_offset = 0; }
   }
-  return(OK);
+
+  return subread(log, size, endpt, grant);
+}
+
+/*===========================================================================*
+ *				log_write				     *
+ *===========================================================================*/
+static ssize_t log_write(devminor_t minor, u64_t UNUSED(position),
+	endpoint_t endpt, cp_grant_id_t grant, size_t size, int UNUSED(flags),
+	cdev_id_t UNUSED(id))
+{
+/* Write to one of the driver's minor devices. */
+  struct logdevice *log;
+  int r;
+
+  if (minor < 0 || minor >= NR_DEVS) return EIO;
+  log = &logdevices[minor];
+
+  return subwrite(log, size, endpt, grant, NULL);
 }
 
 /*============================================================================*
- *				log_do_open				      *
+ *				log_open				      *
  *============================================================================*/
-static int log_do_open(message *m_ptr)
+static int log_open(devminor_t minor, int UNUSED(access),
+	endpoint_t UNUSED(user_endpt))
 {
-  if (log_prepare(m_ptr->DEVICE) == NULL) return(ENXIO);
+  if (minor < 0 || minor >= NR_DEVS) return(ENXIO);
+
   return(OK);
 }
 
 /*============================================================================*
  *				log_cancel				      *
  *============================================================================*/
-static int log_cancel(message *m_ptr)
+static int log_cancel(devminor_t minor, endpoint_t endpt, cdev_id_t id)
 {
-  int d;
+  if (minor < 0 || minor >= NR_DEVS)
-  d = m_ptr->TTY_LINE;
-  if(d < 0 || d >= NR_DEVS)
   	return EINVAL;
-  logdevices[d].log_proc_nr = NONE;
-  logdevices[d].log_revive_alerted = 0;
-  return(OK);
-}
 
-/*============================================================================*
+  /* Not for the suspended request? Must be a stale cancel request. Ignore. */
- *				log_other				      *
+  if (logdevices[minor].log_source != endpt || logdevices[minor].log_id != id)
- *============================================================================*/
+	return EDONTREPLY;
-static int log_other(message *m_ptr)
-{
-	int r;
 
-	/* This function gets messages that the generic driver doesn't
+  logdevices[minor].log_source = NONE;
-	 * understand.
-	 */
-	if (is_notify(m_ptr->m_type)) {
-		return EINVAL;
-	}
 
-	switch(m_ptr->m_type) {
+  return EINTR;	/* this is the reply to the original, interrupted request */
-	case DEV_STATUS: {
-		printf("log_other: unexpected DEV_STATUS request\n");
-		r = EDONTREPLY;
-		break;
-	}
-	default:
-		r = EINVAL;
-		break;
-	}
-	return r;
 }
 
 /*============================================================================*
  *				log_select				      *
  *============================================================================*/
-static int log_select(message *m_ptr)
+static int log_select(devminor_t minor, unsigned int ops, endpoint_t endpt)
 {
-  int d, ready_ops = 0, ops = 0;
+  int want_ops, ready_ops = 0;
-  d = m_ptr->TTY_LINE;
-  if(d < 0 || d >= NR_DEVS) {
-#if LOG_DEBUG
-  	printf("line %d? EINVAL\n", d);
-#endif
-  	return EINVAL;
-  }
 
-  ops = m_ptr->USER_ENDPT & (SEL_RD|SEL_WR|SEL_ERR);
+  if (minor < 0 || minor >= NR_DEVS)
+	return ENXIO;
+
+  want_ops = ops & (CDEV_OP_RD | CDEV_OP_WR | CDEV_OP_ERR);
 
   /* Read blocks when there is no log. */
-  if((m_ptr->USER_ENDPT & SEL_RD) && logdevices[d].log_size > 0) {
+  if ((want_ops & CDEV_OP_RD) && logdevices[minor].log_size > 0) {
 #if LOG_DEBUG
-  	printf("log can read; size %d\n", logdevices[d].log_size);
+	printf("log can read; size %d\n", logdevices[minor].log_size);
 #endif
-  	ready_ops |= SEL_RD; /* writes never block */
+	ready_ops |= CDEV_OP_RD;
   }
 
   /* Write never blocks. */
-  if(m_ptr->USER_ENDPT & SEL_WR) ready_ops |= SEL_WR;
+  if (want_ops & CDEV_OP_WR) ready_ops |= CDEV_OP_WR;
 
-	/* Enable select calback if no operations were
+  /* Enable select calback if not all requested operations were ready to go,
-	 * ready to go, but operations were requested,
+   * and notify was enabled.
-	 * and notify was enabled.
+   */
-	 */
+  want_ops &= ~ready_ops;
-  if((m_ptr->USER_ENDPT & SEL_NOTIFY) && ops && !ready_ops) {
+  if ((ops & CDEV_NOTIFY) && want_ops) {
-  	logdevices[d].log_selected |= ops;
+	logdevices[minor].log_selected |= want_ops;
-  	logdevices[d].log_select_proc = m_ptr->m_source;
+	logdevices[minor].log_select_proc = endpt;
 #if LOG_DEBUG
   	printf("log setting selector.\n");
 #endif
@@ -448,4 +353,3 @@ static int log_select(message *m_ptr)
 
   return(ready_ops);
 }
-

drivers/log/log.h

@@ -10,24 +10,18 @@
 /* Constants and types. */
 
 #define LOG_SIZE	(50*1024) 
-#define SUSPENDABLE 	      1
 
 struct logdevice {
 	char log_buffer[LOG_SIZE];
 	int	log_size,	/* no. of bytes in log buffer */
 		log_read,	/* read mark */
 		log_write;	/* write mark */
-#if SUSPENDABLE
+	endpoint_t log_source;
-	endpoint_t log_proc_nr,
+	cdev_id_t log_id;
-		log_source;
 	int log_iosize,
-		log_revive_alerted,
 		log_status;
-	cp_grant_id_t log_user_grant;
+	cp_grant_id_t log_grant;
-	vir_bytes log_user_offset;
+	int	log_selected, log_select_proc;
-#endif
-	int	log_selected, log_select_proc,
-		log_select_alerted, log_select_ready_ops;
 };
 
 /* Function prototypes. */

drivers/memory/memory.c

@@ -41,63 +41,46 @@
 
 static struct device m_geom[NR_DEVS];  /* base and size of each device */
 static vir_bytes m_vaddrs[NR_DEVS];
-static dev_t m_device;			/* current minor character device */
 
 static int openct[NR_DEVS];
 
-static struct device *m_prepare(dev_t device);
+static ssize_t m_char_read(devminor_t minor, u64_t position, endpoint_t endpt,
-static int m_transfer(endpoint_t endpt, int opcode, u64_t position,
+	cp_grant_id_t grant, size_t size, int flags, cdev_id_t id);
-	iovec_t *iov, unsigned int nr_req, endpoint_t user_endpt, unsigned int
+static ssize_t m_char_write(devminor_t minor, u64_t position, endpoint_t endpt,
-	flags);
+	cp_grant_id_t grant, size_t size, int flags, cdev_id_t id);
-static int m_do_open(message *m_ptr);
+static int m_char_open(devminor_t minor, int access, endpoint_t user_endpt);
-static int m_do_close(message *m_ptr);
+static int m_char_close(devminor_t minor);
 
-static struct device *m_block_part(dev_t minor);
+static struct device *m_block_part(devminor_t minor);
-static int m_block_transfer(dev_t minor, int do_write, u64_t position,
+static ssize_t m_block_transfer(devminor_t minor, int do_write, u64_t position,
 	endpoint_t endpt, iovec_t *iov, unsigned int nr_req, int flags);
-static int m_block_open(dev_t minor, int access);
+static int m_block_open(devminor_t minor, int access);
-static int m_block_close(dev_t minor);
+static int m_block_close(devminor_t minor);
-static int m_block_ioctl(dev_t minor, unsigned int request, endpoint_t
+static int m_block_ioctl(devminor_t minor, unsigned long request, endpoint_t
-	endpt, cp_grant_id_t grant);
+	endpt, cp_grant_id_t grant, endpoint_t user_endpt);
 
 /* Entry points to the CHARACTER part of this driver. */
 static struct chardriver m_cdtab = {
-  m_do_open,	/* open or mount */
+  .cdr_open	= m_char_open,		/* open device */
-  m_do_close,	/* nothing on a close */
+  .cdr_close	= m_char_close,		/* close device */
-  nop_ioctl,	/* no I/O control */
+  .cdr_read	= m_char_read,		/* read from device */
-  m_prepare,	/* prepare for I/O on a given minor device */
+  .cdr_write	= m_char_write		/* write to device */
-  m_transfer,	/* do the I/O */
-  nop_cleanup,	/* no need to clean up */
-  nop_alarm,	/* no alarms */
-  nop_cancel,	/* no blocking operations */
-  nop_select,	/* select not supported */
-  NULL		/* other messages not supported */
 };
 
 /* Entry points to the BLOCK part of this driver. */
 static struct blockdriver m_bdtab = {
-  BLOCKDRIVER_TYPE_DISK,/* handle partition requests */
+  .bdr_type	= BLOCKDRIVER_TYPE_DISK,/* handle partition requests */
-  m_block_open,		/* open or mount */
+  .bdr_open	= m_block_open,		/* open device */
-  m_block_close,	/* nothing on a close */
+  .bdr_close	= m_block_close,	/* nothing on a close */
-  m_block_transfer,	/* do the I/O */
+  .bdr_transfer	= m_block_transfer,	/* do the I/O */
-  m_block_ioctl,	/* ram disk I/O control */
+  .bdr_ioctl	= m_block_ioctl,	/* ram disk I/O control */
-  NULL,			/* no need to clean up */
+  .bdr_part	= m_block_part		/* return partition information */
-  m_block_part,		/* return partition information */
-  NULL,			/* no geometry */
-  NULL,			/* no interrupt processing */
-  NULL,			/* no alarm processing */
-  NULL,			/* no processing of other messages */
-  NULL			/* no threading support */
 };
 
-#define click_to_round_k(n) \
-	((unsigned) ((((unsigned long) (n) << CLICK_SHIFT) + 512) / 1024))
-
 /* SEF functions and variables. */
 static void sef_local_startup(void);
 static int sef_cb_init_fresh(int type, sef_init_info_t *info);
 
-
 /*===========================================================================*
  *				   main 				     *
  *===========================================================================*/
@@ -117,8 +100,7 @@ int main(void)
 	if (IS_BDEV_RQ(msg.m_type))
 		blockdriver_process(&m_bdtab, &msg, ipc_status);
 	else
-		chardriver_process(&m_cdtab, CHARDRIVER_SYNC, &msg,
+		chardriver_process(&m_cdtab, &msg, ipc_status);
-			ipc_status);
   }
 
   return(OK);
@@ -158,8 +140,8 @@ static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info))
   }
 
   /* Map in kernel memory for /dev/kmem. */
-  m_geom[KMEM_DEV].dv_base = cvul64(kinfo.kmem_base);
+  m_geom[KMEM_DEV].dv_base = kinfo.kmem_base;
-  m_geom[KMEM_DEV].dv_size = cvul64(kinfo.kmem_size);
+  m_geom[KMEM_DEV].dv_size = kinfo.kmem_size;
   if((m_vaddrs[KMEM_DEV] = vm_map_phys(SELF, (void *) kinfo.kmem_base,
 	kinfo.kmem_size)) == MAP_FAILED) {
 	printf("MEM: Couldn't map in /dev/kmem.");
@@ -167,16 +149,16 @@ static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info))
 #endif
 
   /* Ramdisk image built into the memory driver */
-  m_geom[IMGRD_DEV].dv_base= ((u64_t)(0));
+  m_geom[IMGRD_DEV].dv_base= 0;
-  m_geom[IMGRD_DEV].dv_size= ((u64_t)(imgrd_size));
+  m_geom[IMGRD_DEV].dv_size= imgrd_size;
   m_vaddrs[IMGRD_DEV] = (vir_bytes) imgrd;
 
   for(i = 0; i < NR_DEVS; i++)
 	openct[i] = 0;
 
   /* Set up memory range for /dev/mem. */
-  m_geom[MEM_DEV].dv_base = ((u64_t)(0));
+  m_geom[MEM_DEV].dv_base = 0;
-  m_geom[MEM_DEV].dv_size = ((u64_t)(0xffffffff));
+  m_geom[MEM_DEV].dv_size = 0xffffffffULL;
 
   m_vaddrs[MEM_DEV] = (vir_bytes) MAP_FAILED; /* we are not mapping this in. */
 
@@ -186,7 +168,7 @@ static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info))
 /*===========================================================================*
  *				m_is_block				     *
  *===========================================================================*/
-static int m_is_block(dev_t minor)
+static int m_is_block(devminor_t minor)
 {
 /* Return TRUE iff the given minor device number is for a block device. */
 
@@ -203,206 +185,218 @@ static int m_is_block(dev_t minor)
 }
 
 /*===========================================================================*
- *				m_prepare				     *
+ *				m_transfer_kmem				     *
  *===========================================================================*/
-static struct device *m_prepare(dev_t device)
+static ssize_t m_transfer_kmem(devminor_t minor, int do_write, u64_t position,
+	endpoint_t endpt, cp_grant_id_t grant, size_t size)
 {
-/* Prepare for I/O on a device: check if the minor device number is ok. */
+/* Transfer from or to the KMEM device. */
-  if (device >= NR_DEVS || m_is_block(device)) return(NULL);
+  u64_t dv_size, dev_vaddr;
-  m_device = device;
-
-  return(&m_geom[device]);
-}
-
-/*===========================================================================*
- *				m_transfer				     *
- *===========================================================================*/
-static int m_transfer(
-  endpoint_t endpt,		/* endpoint of grant owner */
-  int opcode,			/* DEV_GATHER_S or DEV_SCATTER_S */
-  u64_t pos64,			/* offset on device to read or write */
-  iovec_t *iov,			/* pointer to read or write request vector */
-  unsigned int nr_req,		/* length of request vector */
-  endpoint_t UNUSED(user_endpt),/* endpoint of user process */
-  unsigned int UNUSED(flags)
-)
-{
-/* Read or write one the driver's character devices. */
-  unsigned count;
-  vir_bytes vir_offset = 0;
-  struct device *dv;
-  u64_t dv_size;
-  int s, r;
-  u64_t position;
-  cp_grant_id_t grant;
-  vir_bytes dev_vaddr;
-
-  /* ZERO_DEV and NULL_DEV are infinite in size. */
-  if (m_device != ZERO_DEV && m_device != NULL_DEV && ex64hi(pos64) != 0)
-	return OK;	/* Beyond EOF */
-  position= pos64;
-
-  /* Get minor device number and check for /dev/null. */
-  dv = &m_geom[m_device];
-  dv_size = dv->dv_size;
-  dev_vaddr = m_vaddrs[m_device];
-
-  while (nr_req > 0) {
-
-	/* How much to transfer and where to / from. */
-	count = iov->iov_size;
-	grant = (cp_grant_id_t) iov->iov_addr;
-
-	switch (m_device) {
-
-	/* No copying; ignore request. */
-	case NULL_DEV:
-	    if (opcode == DEV_GATHER_S) return(OK);	/* always at EOF */
-	    break;
-
-	/* Virtual copying. For kernel memory. */
-	default:
-	case KMEM_DEV:
-	    if(!dev_vaddr || dev_vaddr == (vir_bytes) MAP_FAILED) {
-		printf("MEM: dev %d not initialized\n", m_device);
-		return EIO;
-	    }
-	    if (position >= dv_size) return(OK);	/* check for EOF */
-	    if (position + count > dv_size) count = dv_size - position;
-	    if (opcode == DEV_GATHER_S) {	/* copy actual data */
-	        r=sys_safecopyto(endpt, grant, vir_offset,
-		  dev_vaddr + position, count);
-	    } else {
-	        r=sys_safecopyfrom(endpt, grant, vir_offset,
-		  dev_vaddr + position, count);
-	    }
-	    if(r != OK) {
-              panic("I/O copy failed: %d", r);
-	    }
-	    break;
-
-	/* Physical copying. Only used to access entire memory.
-	 * Transfer one 'page window' at a time.
-	 */
-	case MEM_DEV:
-	{
-	    u32_t pagestart, page_off;
-	    static u32_t pagestart_mapped;
-	    static int any_mapped = 0;
-	    static char *vaddr;
-	    int r;
-	    u32_t subcount;
-	    phys_bytes mem_phys;
-
-	    if (position >= dv_size)
-		return(OK);	/* check for EOF */
-	    if (position + count > dv_size)
-		count = dv_size - position;
-	    mem_phys = position;
-
-	    page_off = mem_phys % PAGE_SIZE;
-	    pagestart = mem_phys - page_off; 
-
-	    /* All memory to the map call has to be page-aligned.
-	     * Don't have to map same page over and over.
-	     */
-	    if(!any_mapped || pagestart_mapped != pagestart) {
-	     if(any_mapped) {
-		if(vm_unmap_phys(SELF, vaddr, PAGE_SIZE) != OK)
-			panic("vm_unmap_phys failed");
-		any_mapped = 0;
-	     }
-	     vaddr = vm_map_phys(SELF, (void *) pagestart, PAGE_SIZE);
-	     if(vaddr == MAP_FAILED) 
-		r = ENOMEM;
-	     else
-		r = OK;
-	     if(r != OK) {
-		printf("memory: vm_map_phys failed\n");
-		return r;
-	     }
-	     any_mapped = 1;
-	     pagestart_mapped = pagestart;
-	   }
-
-	    /* how much to be done within this page. */
-	    subcount = PAGE_SIZE-page_off;
-	    if(subcount > count)
-		subcount = count;
-
-	    if (opcode == DEV_GATHER_S) {			/* copy data */
-	           s=sys_safecopyto(endpt, grant,
-		       vir_offset, (vir_bytes) vaddr+page_off, subcount);
-	    } else {
-	           s=sys_safecopyfrom(endpt, grant,
-		       vir_offset, (vir_bytes) vaddr+page_off, subcount);
-	    }
-	    if(s != OK)
-		return s;
-	    count = subcount;
-	    break;
-	}
-
-	/* Null byte stream generator. */
-	case ZERO_DEV:
-	    if (opcode == DEV_GATHER_S)
-	        if ((s = sys_safememset(endpt, grant, 0, '\0', count)) != OK)
-		    return s;
-
-	    break;
-
-	}
-
-	/* Book the number of bytes transferred. */
-	position += count;
-	vir_offset += count;
-	if ((iov->iov_size -= count) == 0) { iov++; nr_req--; vir_offset = 0; }
-
-  }
-  return(OK);
-}
-
-/*===========================================================================*
- *				m_do_open				     *
- *===========================================================================*/
-static int m_do_open(message *m_ptr)
-{
-/* Open a memory character device. */
   int r;
 
-/* Check device number on open. */
+  dv_size = m_geom[minor].dv_size;
-  if (m_prepare(m_ptr->DEVICE) == NULL) return(ENXIO);
+  dev_vaddr = m_vaddrs[minor];
+
+  if (!dev_vaddr || dev_vaddr == (vir_bytes) MAP_FAILED) {
+	printf("MEM: dev %d not initialized\n", minor);
+	return EIO;
+  }
+
+  if (position >= dv_size) return 0;	/* check for EOF */
+  if (position + size > dv_size) size = dv_size - position;
+
+  if (!do_write)			/* copy actual data */
+	r = sys_safecopyto(endpt, grant, 0, dev_vaddr + position, size);
+  else
+	r = sys_safecopyfrom(endpt, grant, 0, dev_vaddr + position, size);
+
+  return (r != OK) ? r : size;
+}
+
+/*===========================================================================*
+ *				m_transfer_mem				     *
+ *===========================================================================*/
+static ssize_t m_transfer_mem(devminor_t minor, int do_write, u64_t position,
+	endpoint_t endpt, cp_grant_id_t grant, size_t size)
+{
+/* Transfer from or to the MEM device. */
+  static int any_mapped = 0;
+  static phys_bytes pagestart_mapped;
+  static char *vaddr;
+  phys_bytes mem_phys, pagestart;
+  size_t off, page_off, subcount;
+  u64_t dv_size;
+  int r;
+
+  dv_size = m_geom[minor].dv_size;
+  if (position >= dv_size) return 0;	/* check for EOF */
+  if (position + size > dv_size) size = dv_size - position;
+
+  /* Physical copying. Only used to access entire memory.
+   * Transfer one 'page window' at a time.
+   */
+  off = 0;
+  while (off < size) {
+	mem_phys = (phys_bytes) position;
+
+	page_off = (size_t) (mem_phys % PAGE_SIZE);
+	pagestart = mem_phys - page_off;
+
+	/* All memory to the map call has to be page-aligned.
+	 * Don't have to map same page over and over.
+	 */
+	if (!any_mapped || pagestart_mapped != pagestart) {
+		if (any_mapped) {
+			if (vm_unmap_phys(SELF, vaddr, PAGE_SIZE) != OK)
+				panic("vm_unmap_phys failed");
+			any_mapped = 0;
+		}
+
+		vaddr = vm_map_phys(SELF, (void *) pagestart, PAGE_SIZE);
+		if (vaddr == MAP_FAILED) {
+			printf("memory: vm_map_phys failed\n");
+			return ENOMEM;
+		}
+		any_mapped = 1;
+		pagestart_mapped = pagestart;
+	}
+
+	/* how much to be done within this page. */
+	subcount = PAGE_SIZE - page_off;
+	if (subcount > size)
+		subcount = size;
+
+	if (!do_write)	/* copy data */
+		r = sys_safecopyto(endpt, grant, off,
+			(vir_bytes) vaddr + page_off, subcount);
+	else
+		r = sys_safecopyfrom(endpt, grant, off,
+			(vir_bytes) vaddr + page_off, subcount);
+	if (r != OK)
+		return r;
+
+	position += subcount;
+	off += subcount;
+  }
+
+  return off;
+}
+
+/*===========================================================================*
+ *				m_char_read				     *
+ *===========================================================================*/
+static ssize_t m_char_read(devminor_t minor, u64_t position, endpoint_t endpt,
+	cp_grant_id_t grant, size_t size, int UNUSED(flags),
+	cdev_id_t UNUSED(id))
+{
+/* Read from one of the driver's character devices. */
+  ssize_t r;
+
+  /* Check if the minor device number is ok. */
+  if (minor < 0 || minor >= NR_DEVS || m_is_block(minor)) return ENXIO;
+
+  switch (minor) {
+  case NULL_DEV:
+	r = 0;	/* always at EOF */
+	break;
+
+  case ZERO_DEV:
+	/* Fill the target area with zeroes. In fact, let the kernel do it! */
+	if ((r = sys_safememset(endpt, grant, 0, '\0', size)) == OK)
+		r = size;
+	break;
+
+  case KMEM_DEV:
+	r = m_transfer_kmem(minor, FALSE, position, endpt, grant, size);
+	break;
+
+  case MEM_DEV:
+	r = m_transfer_mem(minor, FALSE, position, endpt, grant, size);
+	break;
+
+  default:
+	panic("unknown character device %d", minor);
+  }
+
+  return r;
+}
+
+/*===========================================================================*
+ *				m_char_write				     *
+ *===========================================================================*/
+static ssize_t m_char_write(devminor_t minor, u64_t position, endpoint_t endpt,
+	cp_grant_id_t grant, size_t size, int UNUSED(flags),
+	cdev_id_t UNUSED(id))
+{
+/* Write to one of the driver's character devices. */
+  ssize_t r;
+
+  /* Check if the minor device number is ok. */
+  if (minor < 0 || minor >= NR_DEVS || m_is_block(minor)) return ENXIO;
+
+  switch (minor) {
+  case NULL_DEV:
+  case ZERO_DEV:
+	r = size;	/* just eat everything */
+	break;
+
+  case KMEM_DEV:
+	r = m_transfer_kmem(minor, TRUE, position, endpt, grant, size);
+	break;
+
+  case MEM_DEV:
+	r = m_transfer_mem(minor, TRUE, position, endpt, grant, size);
+	break;
+
+  default:
+	panic("unknown character device %d", minor);
+  }
+
+  return r;
+}
+
+/*===========================================================================*
+ *				m_char_open				     *
+ *===========================================================================*/
+static int m_char_open(devminor_t minor, int access, endpoint_t user_endpt)
+{
+/* Open a memory character device. */
+
+  /* Check if the minor device number is ok. */
+  if (minor < 0 || minor >= NR_DEVS || m_is_block(minor)) return ENXIO;
+
 #if defined(__i386__)
-  if (m_device == MEM_DEV)
+  if (minor == MEM_DEV)
   {
-	r = sys_enable_iop(m_ptr->USER_ENDPT);
+	int r = sys_enable_iop(user_endpt);
 	if (r != OK)
 	{
-		printf("m_do_open: sys_enable_iop failed for %d: %d\n",
+		printf("m_char_open: sys_enable_iop failed for %d: %d\n",
-			m_ptr->USER_ENDPT, r);
+			user_endpt, r);
 		return r;
 	}
   }
 #endif
 
-  openct[m_device]++;
+  openct[minor]++;
 
   return(OK);
 }
 
 /*===========================================================================*
- *				m_do_close				     *
+ *				m_char_close				     *
  *===========================================================================*/
-static int m_do_close(message *m_ptr)
+static int m_char_close(devminor_t minor)
 {
 /* Close a memory character device. */
-  if (m_prepare(m_ptr->DEVICE) == NULL) return(ENXIO);
 
-  if(openct[m_device] < 1) {
+  if (minor < 0 || minor >= NR_DEVS || m_is_block(minor)) return ENXIO;
-	printf("MEMORY: closing unopened device %d\n", m_device);
+
+  if(openct[minor] < 1) {
+	printf("MEMORY: closing unopened device %d\n", minor);
 	return(EINVAL);
   }
-  openct[m_device]--;
+  openct[minor]--;
 
   return(OK);
 }
@@ -410,10 +404,10 @@ static int m_do_close(message *m_ptr)
 /*===========================================================================*
  *				m_block_part				     *
  *===========================================================================*/
-static struct device *m_block_part(dev_t minor)
+static struct device *m_block_part(devminor_t minor)
 {
 /* Prepare for I/O on a device: check if the minor device number is ok. */
-  if (minor >= NR_DEVS || !m_is_block(minor)) return(NULL);
+  if (minor < 0 || minor >= NR_DEVS || !m_is_block(minor)) return(NULL);
 
   return(&m_geom[minor]);
 }
@@ -422,9 +416,9 @@ static struct device *m_block_part(dev_t minor)
  *				m_block_transfer			     *
  *===========================================================================*/
 static int m_block_transfer(
-  dev_t minor,			/* minor device number */
+  devminor_t minor,		/* minor device number */
   int do_write,			/* read or write? */
-  u64_t pos64,			/* offset on device to read or write */
+  u64_t position,		/* offset on device to read or write */
   endpoint_t endpt,		/* process doing the request */
   iovec_t *iov,			/* pointer to read or write request vector */
   unsigned int nr_req,		/* length of request vector */
@@ -437,7 +431,6 @@ static int m_block_transfer(
   struct device *dv;
   u64_t dv_size;
   int r;
-  u64_t position;
   vir_bytes dev_vaddr;
   cp_grant_id_t grant;
   ssize_t total = 0;
@@ -447,9 +440,8 @@ static int m_block_transfer(
   dv_size = dv->dv_size;
   dev_vaddr = m_vaddrs[minor];
 
-  if (ex64hi(pos64) != 0)
+  if (ex64hi(position) != 0)
 	return OK;	/* Beyond EOF */
-  position= pos64;
 
   while (nr_req > 0) {
 
@@ -488,7 +480,7 @@ static int m_block_transfer(
 /*===========================================================================*
  *				m_block_open				     *
  *===========================================================================*/
-static int m_block_open(dev_t minor, int UNUSED(access))
+static int m_block_open(devminor_t minor, int UNUSED(access))
 {
 /* Open a memory block device. */
   if (m_block_part(minor) == NULL) return(ENXIO);
@@ -501,7 +493,7 @@ static int m_block_open(dev_t minor, int UNUSED(access))
 /*===========================================================================*
  *				m_block_close				     *
  *===========================================================================*/
-static int m_block_close(dev_t minor)
+static int m_block_close(devminor_t minor)
 {
 /* Close a memory block device. */
   if (m_block_part(minor) == NULL) return(ENXIO);
@@ -518,8 +510,8 @@ static int m_block_close(dev_t minor)
 /*===========================================================================*
  *				m_block_ioctl				     *
  *===========================================================================*/
-static int m_block_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
+static int m_block_ioctl(devminor_t minor, unsigned long request,
-	cp_grant_id_t grant)
+	endpoint_t endpt, cp_grant_id_t grant, endpoint_t UNUSED(user_endpt))
 {
 /* I/O controls for the block devices of the memory driver. Currently there is
  * one I/O control specific to the memory driver:
@@ -554,7 +546,7 @@ static int m_block_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
 	return s;
   if(is_imgrd)
   	ramdev_size = 0;
-  if(m_vaddrs[minor] && !cmp64(dv->dv_size, ((u64_t)(ramdev_size)))) {
+  if(m_vaddrs[minor] && dv->dv_size == (u64_t) ramdev_size) {
 	return(OK);
   }
   /* openct is 1 for the ioctl(). */
@@ -602,7 +594,7 @@ static int m_block_ioctl(dev_t minor, unsigned int request, endpoint_t endpt,
 
   m_vaddrs[minor] = (vir_bytes) mem;
 
-  dv->dv_size = ((u64_t)(ramdev_size));
+  dv->dv_size = ramdev_size;
 
   return(OK);
 }

drivers/mmc/mmcblk.c

@@ -32,7 +32,6 @@ static struct log log = {
 /* holding the current host controller */
 static struct mmc_host host;
 
-#define SUB_PER_DRIVE           (NR_PARTITIONS * NR_PARTITIONS)
 #define NR_SUBDEVS              (MAX_DRIVES * SUB_PER_DRIVE)
 
 /* When passing data over a grant one needs to pass
@@ -40,19 +39,19 @@ static struct mmc_host host;
 #define COPYBUFF_SIZE 0x1000	/* 4k buff */
 static unsigned char copybuff[COPYBUFF_SIZE];
 
-static struct sd_slot *get_slot(dev_t minor);
+static struct sd_slot *get_slot(devminor_t minor);
 
 /* Prototypes for the block device */
-static int block_open(dev_t minor, int access);
+static int block_open(devminor_t minor, int access);
-static int block_close(dev_t minor);
+static int block_close(devminor_t minor);
-static int block_transfer(dev_t minor,
+static int block_transfer(devminor_t minor,
     int do_write,
     u64_t position,
     endpoint_t endpt, iovec_t * iov, unsigned int nr_req, int flags);
 
-static int block_ioctl(dev_t minor,
+static int block_ioctl(devminor_t minor, unsigned long request,
-    unsigned int request, endpoint_t endpt, cp_grant_id_t grant);
+	endpoint_t endpt, cp_grant_id_t grant, endpoint_t user_endpt);
-static struct device *block_part(dev_t minor);
+static struct device *block_part(devminor_t minor);
 
 /* System even handling */
 static void sef_local_startup();
@@ -73,18 +72,14 @@ static void set_log_level(int level);
 
 /* Entry points for the BLOCK driver. */
 static struct blockdriver mmc_driver = {
-	BLOCKDRIVER_TYPE_DISK,	/* handle partition requests */
+	.bdr_type 	= BLOCKDRIVER_TYPE_DISK,/* handle partition requests */
-	block_open,		/* open or mount */
+	.bdr_open	= block_open,		/* device open */
-	block_close,		/* on a close */
+	.bdr_close	= block_close,		/* on a close */
-	block_transfer,		/* does the I/O */
+	.bdr_transfer	= block_transfer,	/* does the I/O */
-	block_ioctl,		/* ioclt's */
+	.bdr_ioctl	= block_ioctl,		/* ioctls */
-	NULL,			/* no need to clean up (yet) */
+	.bdr_part	= block_part,		/* get partition information */
-	block_part,		/* return partition information */
+	.bdr_intr	= hw_intr,		/* left over interrupts */
-	NULL,			/* no geometry */
+	.bdr_alarm	= bdr_alarm		/* no alarm processing */
-	hw_intr,		/* left over interrupts */
-	bdr_alarm,		/* no alarm processing */
-	NULL,			/* no processing of other messages */
-	NULL			/* no threading support */
 };
 
 static void
@@ -142,7 +137,7 @@ apply_env()
  *                    block_open                                             *
  *===========================================================================*/
 static int
-block_open(dev_t minor, int access)
+block_open(devminor_t minor, int access)
 {
 	struct sd_slot *slot;
 	slot = get_slot(minor);
@@ -214,7 +209,7 @@ block_open(dev_t minor, int access)
  *                    block_close                                            *
  *===========================================================================*/
 static int
-block_close(dev_t minor)
+block_close(devminor_t minor)
 {
 	struct sd_slot *slot;
 
@@ -281,7 +276,8 @@ copyfrom(endpoint_t src_e,
  *                    block_transfer                                         *
  *===========================================================================*/
 static int
-block_transfer(dev_t minor,	/* minor device number */
+block_transfer(
+    devminor_t minor,		/* minor device number */
     int do_write,		/* read or write? */
     u64_t position,		/* offset on device to read or write */
     endpoint_t endpt,		/* process doing the request */
@@ -439,8 +435,8 @@ block_transfer(dev_t minor,	/* minor device number */
  *				block_ioctl		                     *
  *===========================================================================*/
 static int
-block_ioctl(dev_t minor,
+block_ioctl(devminor_t minor, unsigned long request, endpoint_t endpt,
-    unsigned int request, endpoint_t endpt, cp_grant_id_t grant)
+    cp_grant_id_t grant, endpoint_t UNUSED(user_endpt))
 {
 	/* IOCTL handling */
 	struct sd_slot *slot;
@@ -470,14 +466,14 @@ block_ioctl(dev_t minor,
 		return OK;
 	}
 
-	return EINVAL;
+	return ENOTTY;
 }
 
 /*===========================================================================*
  *                    block_part                                             *
  *===========================================================================*/
 static struct device *
-block_part(dev_t minor)
+block_part(devminor_t minor)
 {
 	/* 
 	 * Reuse the existing MINIX major/minor partitioning scheme.
@@ -615,7 +611,7 @@ block_signal_handler_cb(int signo)
 #define IS_MINIX_SUB_PARTITION_MINOR(minor) (minor >= MINOR_d0p0s0 )
 
 static struct sd_slot *
-get_slot(dev_t minor)
+get_slot(devminor_t minor)
 {
 	/* 
 	 * Get an sd_slot based on the minor number.
@@ -627,7 +623,7 @@ get_slot(dev_t minor)
 	 * number 128 till 144 for sub partitions.
 	 */
 	/* If this is a minor for the first disk (e.g. minor 0 till 5) */
-	if (minor / DEV_PER_DRIVE == 0) {
+	if (minor >= 0 && minor / DEV_PER_DRIVE == 0) {
 		/* we are talking about the first disk and that is all we
 		 * support */
 		return &host.slot[0];

drivers/orinoco/orinoco.c

@@ -15,7 +15,7 @@
 #include	<minix/syslib.h>
 #include	<minix/type.h>
 #include	<minix/sysutil.h>
-#include	<timers.h>
+#include	<minix/timers.h>
 #include	<machine/pci.h>
 #include 	<minix/ds.h>
 #include	<minix/endpoint.h>
@@ -149,7 +149,7 @@ static void or_getstat_s(message * mp);
 static void print_linkstatus(t_or * orp, u16_t status);
 static int or_get_recvd_packet(t_or *orp, u16_t rxfid, u8_t *databuf);
 static void or_reset(void);
-static void or_watchdog_f(timer_t *tp);
+static void or_watchdog_f(minix_timer_t *tp);
 static void setup_wepkey(t_or *orp, char *wepkey0);
 static void do_hard_int(void);
 static void check_int_events(void);
@@ -1092,7 +1092,7 @@ next:
  * Will be called regularly to see whether the driver has crashed. If that   *
  * condition is detected, reset the driver and card                          *
  *****************************************************************************/
-static void or_watchdog_f(timer_t *tp)
+static void or_watchdog_f(minix_timer_t *tp)
 {
 	t_or *orp;
 	

drivers/pci/pci.c

@@ -70,6 +70,8 @@ static struct pcidev
 	u8_t pd_infclass;
 	u16_t pd_vid;
 	u16_t pd_did;
+	u16_t pd_sub_vid;
+	u16_t pd_sub_did;
 	u8_t pd_ilr;
 
 	u8_t pd_inuse;
@@ -737,7 +739,7 @@ static void pci_intel_init()
 		dstr= "unknown device";
 	if (debug)
 	{
-		printf("pci_intel_init: %s (%04X/%04X)\n",
+		printf("pci_intel_init: %s (%04X:%04X)\n",
 			dstr, vid, did);
 	}
 
@@ -774,7 +776,7 @@ static void pci_intel_init()
 static void probe_bus(int busind)
 {
 	u32_t dev, func, t3;
-	u16_t vid, did, sts;
+	u16_t vid, did, sts, sub_vid, sub_did;
 	u8_t headt;
 	u8_t baseclass, subclass, infclass;
 	int devind, busnr;
@@ -831,12 +833,15 @@ static void probe_bus(int busind)
 			    }
 			}
 
+			sub_vid= pci_attr_r16(devind, PCI_SUBVID);
+			sub_did= pci_attr_r16(devind, PCI_SUBDID);
+
 			dstr= pci_dev_name(vid, did);
 			if (debug)
 			{
 				if (dstr)
 				{
-					printf("%d.%lu.%lu: %s (%04X/%04X)\n",
+					printf("%d.%lu.%lu: %s (%04X:%04X)\n",
 						busnr, (unsigned long)dev,
 						(unsigned long)func, dstr,
 						vid, did);
@@ -851,8 +856,7 @@ static void probe_bus(int busind)
 				}
 				printf("Device index: %d\n", devind);
 				printf("Subsystem: Vid 0x%x, did 0x%x\n",
-					pci_attr_r16(devind, PCI_SUBVID),
+					sub_vid, sub_did);
-					pci_attr_r16(devind, PCI_SUBDID));
 			}
 
 			baseclass= pci_attr_r8_u(devind, PCI_BCR);
@@ -886,6 +890,8 @@ static void probe_bus(int busind)
 			pcidev[devind].pd_infclass= infclass;
 			pcidev[devind].pd_vid= vid;
 			pcidev[devind].pd_did= did;
+			pcidev[devind].pd_sub_vid= sub_vid;
+			pcidev[devind].pd_sub_did= sub_did;
 			pcidev[devind].pd_inuse= 0;
 			pcidev[devind].pd_bar_nr= 0;
 			record_irq(devind);
@@ -1531,7 +1537,7 @@ static void complete_bars(void)
 			if (debug)
 			{
 				printf(
-		"pci device %d (%04x/%04x), bar %d: base 0x%x, size 0x%x\n",
+		"pci device %d (%04x:%04x), bar %d: base 0x%x, size 0x%x\n",
 					i, pcidev[i].pd_vid, pcidev[i].pd_did,
 					j, base, size);
 			}
@@ -1765,7 +1771,7 @@ int busind;
 			dstr= "unknown device";
 		if (debug)
 		{
-			printf("found ISA bridge (%04X/%04X) %s\n",
+			printf("found ISA bridge (%04X:%04X) %s\n",
 				vid, did, dstr);
 		}
 		pcibus[busind].pb_isabridge_dev= bridge_dev;
@@ -1803,7 +1809,7 @@ int busind;
 	if (debug)
 	{
 		printf(
-		"(warning) unsupported ISA bridge %04X/%04X for bus %d\n",
+		"(warning) unsupported ISA bridge %04X:%04X for bus %d\n",
 			pcidev[unknown_bridge].pd_vid,
 			pcidev[unknown_bridge].pd_did, busind);
 	}
@@ -1899,7 +1905,7 @@ int busind;
 				t3 != PCI_T3_PCI2PCI_SUBTR)
 			{
 				printf(
-"Unknown PCI class %02x:%02x:%02x for PCI-to-PCI bridge, device %04X/%04X\n",
+"Unknown PCI class %02x/%02x/%02x for PCI-to-PCI bridge, device %04X:%04X\n",
 					baseclass, subclass, infclass,
 					vid, did);
 				continue;
@@ -1908,7 +1914,7 @@ int busind;
 				t3 != PCI_T3_CARDBUS)
 			{
 				printf(
-"Unknown PCI class %02x:%02x:%02x for Cardbus bridge, device %04X/%04X\n",
+"Unknown PCI class %02x/%02x/%02x for Cardbus bridge, device %04X:%04X\n",
 					baseclass, subclass, infclass,
 					vid, did);
 				continue;
@@ -1917,7 +1923,7 @@ int busind;
 
 		if (debug)
 		{
-			printf("%u.%u.%u: PCI-to-PCI bridge: %04X/%04X\n",
+			printf("%u.%u.%u: PCI-to-PCI bridge: %04X:%04X\n",
 				pcidev[devind].pd_busnr,
 				pcidev[devind].pd_dev, 
 				pcidev[devind].pd_func, vid, did);
@@ -2640,6 +2646,7 @@ static int visible(aclp, devind)
 struct rs_pci *aclp;
 int devind;
 {
+	u16_t acl_sub_vid, acl_sub_did;
 	int i;
 	u32_t class_id;
 
@@ -2651,8 +2658,14 @@ int devind;
 	/* Check whether the caller is allowed to get this device. */
 	for (i= 0; i<aclp->rsp_nr_device; i++)
 	{
+		acl_sub_vid = aclp->rsp_device[i].sub_vid;
+		acl_sub_did = aclp->rsp_device[i].sub_did;
 		if (aclp->rsp_device[i].vid == pcidev[devind].pd_vid &&
-			aclp->rsp_device[i].did == pcidev[devind].pd_did)
+			aclp->rsp_device[i].did == pcidev[devind].pd_did &&
+			(acl_sub_vid == NO_SUB_VID ||
+			acl_sub_vid == pcidev[devind].pd_sub_vid) &&
+			(acl_sub_did == NO_SUB_DID ||
+			acl_sub_did == pcidev[devind].pd_sub_did))
 		{
 			return TRUE;
 		}

drivers/pckbd/Makefile

@@ -0,0 +1,12 @@
+# Makefile for the PC keyboard/mouse driver (PCKBD)
+PROG=	pckbd
+SRCS=	pckbd.c table.c
+
+DPADD+=	${LIBINPUTDRIVER} ${LIBSYS} ${LIBTIMERS}
+LDADD+=	-linputdriver -lsys -ltimers
+
+MAN=
+
+BINDIR?= /sbin
+
+.include <minix.service.mk>

drivers/pckbd/pckbd.c

@@ -0,0 +1,476 @@
+/* Keyboard driver for PCs and ATs. */
+#include <minix/drivers.h>
+#include <minix/input.h>
+#include <minix/inputdriver.h>
+
+#include "pckbd.h"
+
+/*
+ * Data that is to be sent to the keyboard. Each byte is ACKed by the keyboard.
+ * This is currently somewhat overpowered for its only purpose: setting LEDs.
+ */
+static struct kbdout {
+	unsigned char buf[KBD_OUT_BUFSZ];
+	int offset;
+	int avail;
+	int expect_ack;
+} kbdout;
+
+static int kbd_watchdog_set = 0;
+static int kbd_alive = 1;
+static minix_timer_t tmr_kbd_wd;
+
+static int irq_hook_id = -1;
+static int aux_irq_hook_id = -1;
+
+static int kbd_state = 0;
+
+static unsigned char aux_bytes[3];
+static unsigned char aux_state = 0;
+static int aux_counter = 0;
+
+static void pckbd_leds(unsigned int);
+static void pckbd_intr(unsigned int);
+static void pckbd_alarm(clock_t);
+
+static struct inputdriver pckbd_tab = {
+	.idr_leds	= pckbd_leds,
+	.idr_intr	= pckbd_intr,
+	.idr_alarm	= pckbd_alarm
+};
+
+/*
+ * The watchdog timer function, implementing all but the actual reset.
+ */
+static void
+kbd_watchdog(minix_timer_t *UNUSED(tmrp))
+{
+	kbd_watchdog_set = 0;
+	if (!kbdout.avail)
+		return;	/* Watchdog is no longer needed */
+
+	if (!kbd_alive)
+		printf("PCKBD: watchdog should reset keyboard\n");
+	kbd_alive = 0;
+
+	set_timer(&tmr_kbd_wd, sys_hz(), kbd_watchdog, 0);
+
+	kbd_watchdog_set = 1;
+}
+
+/*
+ * Send queued data to the keyboard.
+ */
+static void
+kbd_send(void)
+{
+	u32_t sb;
+	int r;
+
+	if (!kbdout.avail)
+		return;
+	if (kbdout.expect_ack)
+		return;
+
+	if ((r = sys_inb(KB_STATUS, &sb)) != OK)
+		printf("PCKBD: send sys_inb() failed (1): %d\n", r);
+
+	if (sb & (KB_OUT_FULL | KB_IN_FULL)) {
+		printf("PCKBD: not sending (1): sb = 0x%x\n", sb);
+		return;
+	}
+	micro_delay(KBC_IN_DELAY);
+	if ((r = sys_inb(KB_STATUS, &sb)) != OK)
+		printf("PCKBD: send sys_inb() failed (2): %d\n", r);
+	if (sb & (KB_OUT_FULL | KB_IN_FULL)) {
+		printf("PCKBD: not sending (2): sb = 0x%x\n", sb);
+		return;
+	}
+
+	/* Okay, buffer is really empty */
+	if ((r = sys_outb(KEYBD, kbdout.buf[kbdout.offset])) != OK)
+		printf("PCKBD: send sys_outb() failed: %d\n", r);
+	kbdout.offset++;
+	kbdout.avail--;
+	kbdout.expect_ack = 1;
+
+	kbd_alive = 1;
+	if (kbd_watchdog_set) {
+		/* Set a watchdog timer for one second. */
+		set_timer(&tmr_kbd_wd, sys_hz(), kbd_watchdog, 0);
+
+		kbd_watchdog_set = 1;
+	}
+}
+
+/*
+ * Try to obtain input from the keyboard.
+ */
+static int
+scan_keyboard(unsigned char *bp, int *isauxp)
+{
+	u32_t b, sb;
+	int r;
+
+	if ((r = sys_inb(KB_STATUS, &sb)) != OK) {
+		printf("PCKBD: scan sys_inb() failed (1): %d\n", r);
+		return FALSE;
+	}
+	if (!(sb & KB_OUT_FULL)) {
+		if (kbdout.avail && !kbdout.expect_ack)
+			kbd_send();
+		return FALSE;
+	}
+	if ((r = sys_inb(KEYBD, &b)) != OK) {
+		printf("PCKBD: scan sys_inb() failed (2): %d\n", r);
+		return FALSE;
+	}
+	if (!(sb & KB_AUX_BYTE) && b == KB_ACK && kbdout.expect_ack) {
+		kbdout.expect_ack = 0;
+		micro_delay(KBC_IN_DELAY);
+		kbd_send();
+		return FALSE;
+	}
+	if (bp)
+		*bp = b;
+	if (isauxp)
+		*isauxp = !!(sb & KB_AUX_BYTE);
+	if (kbdout.avail && !kbdout.expect_ack) {
+		micro_delay(KBC_IN_DELAY);
+		kbd_send();
+	}
+	return TRUE;
+}
+
+/*
+ * Wait until the controller is ready.  Return TRUE on success, FALSE on
+ * timeout.  Since this may discard input, only use during initialization.
+ */
+static int
+kb_wait(void)
+{
+	spin_t spin;
+	u32_t status;
+	int r, isaux;
+	unsigned char byte;
+
+	SPIN_FOR(&spin, KBC_WAIT_TIME) {
+		if ((r = sys_inb(KB_STATUS, &status)) != OK)
+			printf("PCKBD: wait sys_inb() failed: %d\n", r);
+		if (status & KB_OUT_FULL)
+			(void) scan_keyboard(&byte, &isaux);
+		if (!(status & (KB_IN_FULL | KB_OUT_FULL)))
+			return TRUE;		/* wait until ready */
+	}
+
+	printf("PCKBD: wait timeout\n");
+	return FALSE;
+}
+
+/*
+ * Set the LEDs on the caps, num, and scroll lock keys.
+ */
+static void
+set_leds(unsigned char ledmask)
+{
+	if (kbdout.avail == 0)
+		kbdout.offset = 0;
+	if (kbdout.offset + kbdout.avail + 2 > KBD_OUT_BUFSZ) {
+		/*
+		 * The output buffer is full.  Ignore this command.  Reset the
+		 * ACK flag.
+		 */
+		kbdout.expect_ack = 0;
+	} else {
+		kbdout.buf[kbdout.offset+kbdout.avail] = LED_CODE;
+		kbdout.buf[kbdout.offset+kbdout.avail+1] = ledmask;
+		kbdout.avail += 2;
+	}
+	if (!kbdout.expect_ack)
+		kbd_send();
+}
+
+/*
+ * Send a command to the keyboard.
+ */
+static void
+kbc_cmd0(int cmd)
+{
+	int r;
+
+	kb_wait();
+	if ((r = sys_outb(KB_COMMAND, cmd)) != OK)
+		printf("PCKBD: cmd0 sys_outb() failed: %d\n", r);
+}
+
+/*
+ * Send a command to the keyboard, including data.
+ */
+static void
+kbc_cmd1(int cmd, int data)
+{
+	int r;
+
+	kb_wait();
+	if ((r = sys_outb(KB_COMMAND, cmd)) != OK)
+		printf("PCKBD: cmd1 sys_outb() failed (1): %d\n", r);
+	kb_wait();
+	if ((r = sys_outb(KEYBD, data)) != OK)
+		printf("PCKBD: cmd1 sys_outb() failed (2): %d\n", r);
+}
+
+/*
+ * Wait at most one second for a byte from the keyboard or the controller.
+ */
+static int
+kbc_read(void)
+{
+	u32_t byte, status;
+	spin_t spin;
+	int r;
+
+	SPIN_FOR(&spin, KBC_READ_TIME) {
+		if ((r = sys_inb(KB_STATUS, &status)) != OK)
+			printf("PCKBD: read sys_inb() failed (1): %d\n", r);
+		if (status & KB_OUT_FULL) {
+			micro_delay(KBC_IN_DELAY);
+			if ((r = sys_inb(KEYBD, &byte)) != OK)
+				printf("PCKBD: read sys_inb() failed (2): "
+				    "%d\n", r);
+			if (status & KB_AUX_BYTE)
+				printf("PCKBD: read got aux 0x%x\n", byte);
+			return byte;
+		}
+	}
+
+	panic("kbc_read failed to complete");
+}
+
+/*
+ * Initialize the keyboard hardware.
+ */
+static void
+kb_init(void)
+{
+	int r, ccb;
+
+	/* Discard leftover keystroke. */
+	scan_keyboard(NULL, NULL);
+
+	/* Set interrupt handler and enable keyboard IRQ. */
+	irq_hook_id = KEYBOARD_IRQ;	/* id to be returned on interrupt */
+	r = sys_irqsetpolicy(KEYBOARD_IRQ, IRQ_REENABLE, &irq_hook_id);
+	if (r != OK)
+		panic("Couldn't set keyboard IRQ policy: %d", r);
+	if ((r = sys_irqenable(&irq_hook_id)) != OK)
+		panic("Couldn't enable keyboard IRQs: %d", r);
+
+	/* Set AUX interrupt handler and enable AUX IRQ. */
+	aux_irq_hook_id = KBD_AUX_IRQ;	/* id to be returned on interrupt */
+	r = sys_irqsetpolicy(KBD_AUX_IRQ, IRQ_REENABLE, &aux_irq_hook_id);
+	if (r != OK)
+		panic("Couldn't set AUX IRQ policy: %d", r);
+	if ((r = sys_irqenable(&aux_irq_hook_id)) != OK)
+		panic("Couldn't enable AUX IRQs: %d", r);
+
+	/* Disable the keyboard and AUX. */
+	kbc_cmd0(KBC_DI_KBD);
+	kbc_cmd0(KBC_DI_AUX);
+
+	/* Get the current configuration byte. */
+	kbc_cmd0(KBC_RD_RAM_CCB);
+	ccb = kbc_read();
+
+	/* Enable both interrupts. */
+	kbc_cmd1(KBC_WR_RAM_CCB, ccb | 3);
+
+	/* Re-enable the keyboard device. */
+	kbc_cmd0(KBC_EN_KBD);
+
+	/* Enable the AUX device. */
+	kbc_cmd0(KBC_EN_AUX);
+
+	/* Set the initial LED state. */
+	kb_wait();
+
+	set_leds(0);
+}
+
+/*
+ * Process a keyboard scancode.
+ */
+static void
+kbd_process(unsigned char scode)
+{
+	int press, index, page, code;
+
+	press = !(scode & SCAN_RELEASE) ? INPUT_PRESS : INPUT_RELEASE;
+	index = scode & ~SCAN_RELEASE;
+
+	switch (kbd_state) {
+	case 1:
+		page = scanmap_escaped[index].page;
+		code = scanmap_escaped[index].code;
+		break;
+	case 2:
+		kbd_state = (index == SCAN_CTRL) ? 3 : 0;
+		return;
+	case 3:
+		if (index == SCAN_NUMLOCK) {
+			page = INPUT_PAGE_KEY;
+			code = INPUT_KEY_PAUSE;
+			break;
+		}
+		/* FALLTHROUGH */
+	default:
+		switch (scode) {
+		case SCAN_EXT0:
+			kbd_state = 1;
+			return;
+		case SCAN_EXT1:
+			kbd_state = 2;
+			return;
+		}
+		page = scanmap_normal[index].page;
+		code = scanmap_normal[index].code;
+		break;
+	}
+
+	if (page)
+		inputdriver_send_event(FALSE /*mouse*/, page, code, press, 0);
+
+	kbd_state = 0;
+}
+
+/*
+ * Process an auxiliary (mouse) scancode.
+ */
+static void
+kbdaux_process(unsigned char scode)
+{
+	u32_t delta;
+	int i;
+
+	if (aux_counter == 0 && !(scode & 0x08))
+		return;	/* resync */
+
+	aux_bytes[aux_counter++] = scode;
+
+	if (aux_counter < 3)
+		return; /* need more first */
+
+	aux_counter = 0;
+
+	/* Send an event for each button state change. */
+	for (i = 0; i < 3; i++) {
+		if ((aux_state ^ aux_bytes[0]) & (1 << i)) {
+			aux_state ^= (1 << i);
+
+			inputdriver_send_event(TRUE /*mouse*/,
+			    INPUT_PAGE_BUTTON, INPUT_BUTTON_1 + i,
+			    aux_state & (1 << i), 0);
+		}
+	}
+
+	/* Send an event for each relative mouse movement, X and/or Y. */
+	for (i = 0; i < 2; i++) {
+		delta = aux_bytes[1 + i];
+		if (delta != 0) {
+			if (aux_bytes[0] & (0x10 << i))
+				delta |= 0xFFFFFF00; /* make signed */
+
+			inputdriver_send_event(TRUE /*mouse*/, INPUT_PAGE_GD,
+			    !i ? INPUT_GD_X : INPUT_GD_Y, delta,
+			    INPUT_FLAG_REL);
+		}
+	}
+}
+
+/*
+ * Set keyboard LEDs.
+ */
+static void
+pckbd_leds(unsigned int leds)
+{
+	unsigned char b;
+
+	b = 0;
+	if (leds & (1 << INPUT_LED_NUMLOCK)) b |= LED_NUM_LOCK;
+	if (leds & (1 << INPUT_LED_CAPSLOCK)) b |= LED_CAPS_LOCK;
+	if (leds & (1 << INPUT_LED_SCROLLLOCK)) b |= LED_SCROLL_LOCK;
+
+	set_leds(b);
+}
+
+/*
+ * Process a keyboard interrupt.
+ */
+static void
+pckbd_intr(unsigned int UNUSED(mask))
+{
+	unsigned char scode;
+	int isaux;
+
+	/* Fetch a character from the keyboard hardware and acknowledge it. */
+	if (!scan_keyboard(&scode, &isaux))
+		return;
+
+	if (!isaux) {
+		/* A keyboard key press or release. */
+		kbd_process(scode);
+	} else {
+		/* A mouse event. */
+		kbdaux_process(scode);
+	}
+}
+
+/*
+ * Process a timer signal.
+ */
+static void
+pckbd_alarm(clock_t stamp)
+{
+	expire_timers(stamp);
+}
+
+/*
+ * Initialize the driver.
+ */
+static int
+pckbd_init(int UNUSED(type), sef_init_info_t *UNUSED(info))
+{
+	/* Initialize the watchdog timer. */
+	init_timer(&tmr_kbd_wd);
+
+	/* Initialize the keyboard. */
+	kb_init();
+
+	/* Announce the driver's presence. */
+	inputdriver_announce(INPUT_DEV_KBD | INPUT_DEV_MOUSE);
+
+	return OK;
+}
+
+/*
+ * Set callback routines and let SEF initialize.
+ */
+static void
+pckbd_startup(void)
+{
+	sef_setcb_init_fresh(pckbd_init);
+
+	sef_startup();
+}
+
+/*
+ * PC keyboard/mouse driver task.
+ */
+int
+main(void)
+{
+	pckbd_startup();
+
+	inputdriver_task(&pckbd_tab);
+
+	return 0;
+}