New installation mechanism, updated to 1.5

mach/minix/libsys/.distr

@@ -1,7 +1,5 @@
 LIST
-Makefile
-compmodule
 head_em.s
 end.s
 lib.h
-libsys_s.a
+libmon_s.a

mach/minix/libsys/LIST

@@ -1,58 +1,122 @@
-libsys_s.a
-stty.c
-gtty.c
-access.c
-alarm.c
-brk.c
-call.c
-chdir.c
-chmod.c
-chown.c
-chroot.c
-close.c
-creat.c
-dup.c
-dup2.c
-exec.c
-exit.c
+libmon_s.a
+access.s
+alarm.s
+brk.s
+chdir.s
+chmod.s
+chown.s
+chroot.s
+close.s
+creat.s
+dup.s
+dup2.s
+exec.s
+execn.s
+execnl.s
+fcntl.s
+fork.s
+fstat.s
+getcwd.s
+getegid.s
+geteuid.s
+getgid.s
+getpid.s
+getppid.s
+getuid.s
+gtty.s
+ioctl.s
+kill.s
+link.s
+lseek.s
+mkdir.s
+mkfifo.s
+mknod.s
+mknod4.s
+mount.s
+open.s
+pause.s
+pipe.s
+ptrace.s
+read.s
+rename.s
+rmdir.s
+setgid.s
+setuid.s
+signal.s
+stat.s
+stime.s
+stty.s
+sync.s
+time.s
+times.s
+umask.s
+umount.s
+unlink.s
+utime.s
+wait.s
+write.s
 _exit.c
-cleanup.c
-fork.c
-fstat.c
-getegid.c
-geteuid.c
-getgid.c
-getpid.c
-getuid.c
-ioctl.c
-kill.c
-link.c
-lseek.c
+_access.c
+_alarm.c
+_brk.c
+call.c
+_chdir.c
+_chmod.c
+_chown.c
+_chroot.c
+_close.c
+_creat.c
+_dup.c
+_dup2.c
+_exec.c
+_execn.c
+_execnl.c
+_fcntl.c
+_fork.c
+fpathconf.c
+_fstat.c
+_getcwd.c
+_getegid.c
+_geteuid.c
+_getgid.c
+_getpid.c
+_getppid.c
+_getuid.c
+_gtty.c
+_ioctl.c
+_isatty.c
+_kill.c
+_link.c
+_lseek.c
 message.c
-mknod.c
-mktemp.c
-mount.c
-open.c
-pause.c
-pipe.c
-read.c
-setgid.c
-setuid.c
-signal.c
-stat.c
-stderr.c
-stime.c
-sync.c
+_mkdir.c
+_mkfifo.c
+_mknod.c
+_mknod4.c
+_mount.c
+_open.c
+pathconf.c
+_pause.c
+_pipe.c
+_ptrace.c
+_read.c
+_rename.c
+_rmdir.c
+_setgid.c
+_setuid.c
+_signal.c
+_stat.c
+_stime.c
+_stty.c
+_sync.c
 syslib.c
-time.c
-times.c
-umask.c
-umount.c
-unlink.c
-utime.c
-wait.c
-write.c
-brksize.s
-sendrec.s
-catchsig.s
-trp.s
+_time.c
+_times.c
+_umask.c
+_umount.c
+_unlink.c
+_utime.c
+_wait.c
+_write.c
+vectab.c
+errno.c

mach/minix/libsys/_access.c

@@ -0,0 +1,9 @@
+#include <lib.h>
+#define access	_access
+
+int access(name, mode)
+char *name;
+int mode;
+{
+  return(_callm3(FS, ACCESS, mode, name));
+}

mach/minix/libsys/_alarm.c

@@ -0,0 +1,8 @@
+#include <lib.h>
+#define alarm	_alarm
+
+unsigned int alarm(sec)
+unsigned int sec;
+{
+  return(_callm1(MM, ALARM, (int) sec, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_brk.c

@@ -0,0 +1,32 @@
+#include <lib.h>
+#define brk	_brk
+#define sbrk	_sbrk
+
+extern char *_brksize;
+
+PUBLIC char *brk(addr)
+char *addr;
+{
+  if (_callm1(MM, BRK, 0, 0, 0, addr, NIL_PTR, NIL_PTR) == 0) {
+	_brksize = _M.m2_p1;
+	return(NIL_PTR);
+  } else {
+	return((char *) -1);
+  }
+}
+
+
+PUBLIC char *sbrk(incr)
+int incr;
+{
+  char *newsize, *oldsize;
+
+  oldsize = _brksize;
+  newsize = _brksize + incr;
+  if (incr > 0 && newsize < oldsize || incr < 0 && newsize > oldsize)
+	return((char *) -1);
+  if (_brk(newsize) == 0)
+	return(oldsize);
+  else
+	return((char *) -1);
+}

mach/minix/libsys/_chdir.c

@@ -0,0 +1,8 @@
+#include <lib.h>
+#define chdir	_chdir
+
+int chdir(name)
+char *name;
+{
+  return(_callm3(FS, CHDIR, 0, name));
+}

mach/minix/libsys/_chmod.c

@@ -0,0 +1,9 @@
+#include <lib.h>
+#define chmod	_chmod
+
+PUBLIC int chmod(name, mode)
+char *name;
+mode_t mode;
+{
+  return(_callm3(FS, CHMOD, mode, name));
+}

mach/minix/libsys/_chown.c

@@ -0,0 +1,9 @@
+#include <lib.h>
+#define chown	_chown
+
+PUBLIC int chown(name, owner, grp)
+char *name;
+int owner, grp;
+{
+  return(_callm1(FS, CHOWN, _len(name), owner, grp, name, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_chroot.c

@@ -0,0 +1,8 @@
+#include <lib.h>
+#define chroot	_chroot
+
+PUBLIC int chroot(name)
+char *name;
+{
+  return(_callm3(FS, CHROOT, 0, name));
+}

mach/minix/libsys/_close.c

@@ -0,0 +1,8 @@
+#include <lib.h>
+#define close	_close
+
+PUBLIC int close(fd)
+int fd;
+{
+  return(_callm1(FS, CLOSE, fd, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_creat.c

@@ -0,0 +1,9 @@
+#include <lib.h>
+#define creat	_creat
+
+PUBLIC int creat(name, mode)
+char *name;
+mode_t mode;
+{
+  return(_callm3(FS, CREAT, mode, name));
+}

mach/minix/libsys/_dup.c

@@ -0,0 +1,9 @@
+#include <lib.h>
+#define dup	_dup
+#include <fcntl.h>
+
+PUBLIC int dup(fd)
+int fd;
+{
+  return(fcntl(fd, F_DUPFD, 0));
+}

mach/minix/libsys/_dup2.c

@@ -0,0 +1,29 @@
+#include <lib.h>
+#define dup2     _dup2
+#include <fcntl.h>
+#include <limits.h>
+#include <errno.h>
+
+PUBLIC int dup2(fd, fd2)
+int fd, fd2;
+{
+/* The behavior of dup2 is defined by POSIX in 6.2.1.2 as almost, but not
+ * quite the same as fcntl.
+ */
+
+  if (fd2 < 0 || fd2 > OPEN_MAX) {
+	errno = EBADF;
+	return(-1);
+  }
+
+  /* Check to see if fildes is valid. */
+  if (fcntl(fd, F_GETFL) < 0) {
+	/* fd is not valid. */
+	return(-1);
+  } else {
+	/* fd is valid. */
+	if (fd == fd2) return(fd2);
+	close(fd2);
+	return(fcntl(fd, F_DUPFD, fd2));
+  }
+}

mach/minix/libsys/_exec.c

@@ -0,0 +1,167 @@
+#include <lib.h>
+#define execl	_execl
+#define execle	_execle
+#define execv	_execv
+#define execve	_execve
+
+extern char **environ;		/* environment pointer */
+
+#define	PTRSIZE	(sizeof(char *))
+_PROTOTYPE( char *_sbrk, (int _incr)					);
+
+#if _ANSI
+#include	<stdarg.h>
+
+PUBLIC int execl(char *name, ...)
+{
+	int retval;
+	va_list ap;
+
+	va_start(ap, name);
+	retval = execve(name, (char **)ap, environ);
+	va_end(ap);
+	return retval;
+}
+#else
+PUBLIC int execl(name, arg0)
+char *name;
+char *arg0;
+{
+  return(execve(name, &arg0, environ));
+}
+#endif
+
+#if _ANSI
+PUBLIC int execle(char *name, ...)
+{
+	int retval;
+	va_list ap;
+	char *p;
+
+	va_start(ap, name);
+	do {
+	    p = va_arg(ap, char *);
+	} while(p);
+	p = (char *)va_arg(ap, char **);
+	va_end(ap);
+	va_start(ap, name);
+	retval = execve(name, (char **)ap, (char **) p);
+	va_end(ap);
+	return retval;
+}
+#else
+PUBLIC int execle(name, argv)
+char *name, *argv;
+{
+  char **p;
+  p = (char **) &argv;
+  while (*p++)			/* null statement */
+	;
+  return(execve(name, &argv, (char **) *p));
+}
+#endif
+
+PUBLIC int execv(name, argv)
+char *name, *argv[];
+{
+
+  return(execve(name, argv, environ));
+}
+
+PUBLIC int execve(path, argv, envp)
+char *path;			/* pointer to name of file to be executed */
+char *argv[];			/* pointer to argument array */
+char *envp[];			/* pointer to environment */
+{
+  register char **argtop;
+  register char **envtop;
+
+	/* Count the argument pointers and environment pointers. */
+  for (argtop = argv; *argtop != (char *) NULL; ) argtop++;
+  for (envtop = envp; *envtop != (char *) NULL; ) envtop++;
+  return(__execve(path, argv, envp, (int)(argtop - argv), (int)(envtop - envp)));
+}
+
+PUBLIC int __execve(path, argv, envp, nargs, nenvps)
+char *path;			/* pointer to name of file to be executed */
+char *argv[];			/* pointer to argument array */
+char *envp[];			/* pointer to environment */
+int nargs;			/* number of args */
+int nenvps;			/* number of environment strings */
+{
+/* This is split off from execve to be called from execvp, so execvp does not
+ * have to allocate up to ARG_MAX bytes just to prepend "sh" to the arg array.
+ */
+
+  char *hp, **ap, *p;
+  int i, stackbytes, npointers, overflow, temp;
+  char *stack;
+  /* Decide how big a stack is needed. Be paranoid about overflow. */
+#if ARG_MAX > INT_MAX
+#error /* overflow checks and sbrk depend on sizes being ints */
+#endif
+  overflow = FALSE;
+  npointers = 1 + nargs + 1 + nenvps + 1;	/* 1's for argc and NULLs */
+  stackbytes = 0;	/* changed because _len is used now */
+  if (nargs < 0 || nenvps < 0 || nargs+nenvps < 0 || npointers < 0)
+	overflow = TRUE;
+  for (i = PTRSIZE; i != 0; i--) {
+	temp = stackbytes + npointers;
+	if (temp < stackbytes) overflow = TRUE;
+	stackbytes = temp;
+  }
+  for (i = 0, ap = argv; i < nargs; i++) {
+	temp = stackbytes + _len(*ap++);
+	if (temp < stackbytes) overflow = TRUE;
+	stackbytes = temp;
+  }
+  for (i = 0, ap = envp; i < nenvps; i++) {
+	temp = stackbytes + _len(*ap++);
+	if (temp < stackbytes) overflow = TRUE;
+	stackbytes = temp;
+  }
+  temp = stackbytes + PTRSIZE - 1;
+  if (temp < stackbytes) overflow = TRUE;
+  stackbytes = (temp / PTRSIZE) * PTRSIZE;
+
+  /* Check for overflow before committing sbrk. */
+  if (overflow || stackbytes > ARG_MAX) {
+	errno = E2BIG;
+	return(-1);
+  }
+
+  /* Allocate the stack. */
+  stack = _sbrk(stackbytes);
+  if (stack == (char *) -1) {
+	errno = E2BIG;
+	return(-1);
+  }
+
+  /* Prepare the stack vector and argc. */
+  ap = (char **) stack;
+  hp = &stack[npointers * PTRSIZE];
+  *ap++ = (char *) nargs;
+
+  /* Prepare the argument pointers and strings. */
+  for (i = 0; i < nargs; i++) {
+	*ap++ = (char *) (hp - stack);
+	p = *argv++;
+	while ((*hp++ = *p++) != 0)
+		;
+  }
+  *ap++ = (char *) NULL;
+
+  /* Prepare the environment pointers and strings. */
+  for (i = 0; i < nenvps; i++) {
+	*ap++ = (char *) (hp - stack);
+	p = *envp++;
+	while ((*hp++ = *p++) != 0)
+		;
+  }
+  *ap++ = (char *) NULL;
+
+  /* Do the real work. */
+  temp = _callm1(MM, EXEC, _len(path), stackbytes, 0, path, stack, NIL_PTR);
+  _sbrk(-stackbytes);
+  return(temp);
+}

mach/minix/libsys/_execn.c

@@ -0,0 +1,16 @@
+#include <lib.h>
+
+#define	PTRSIZE	sizeof(char *)
+_PROTOTYPE( int _execn, (char * name));
+
+PUBLIC int _execn(name)
+char *name;			/* pointer to file to be exec'd */
+{
+/* Special version used when there are no args and no environment.  This call
+ * is principally used by INIT, to avoid having to allocate ARG_MAX.
+ */
+
+  PRIVATE char stack[3 * PTRSIZE];
+
+  return(_callm1(MM, EXEC, _len(name), sizeof(stack), 0, name, stack, NIL_PTR));
+}

mach/minix/libsys/_execnl.c

@@ -0,0 +1,75 @@
+/*
+ * This file contains two functions that can be used to perform
+ * an EXEC call without the need for a "big" stack of MAX_ARG
+ * bytes.  It is primarily used by the INIT module of the system.
+ */
+#include <lib.h>
+#include <sys/types.h>
+
+#define MAXSTK	256		/* maximum EXEC stack size */
+#define	PTRSIZE	sizeof(char *)
+
+_PROTOTYPE(int _execn,(char *name));
+_PROTOTYPE(int _execnl,(char *name, char *arg0));
+PRIVATE _PROTOTYPE(int _nexec,(char *name, char *argv[]));
+
+PUBLIC int _execn(name)
+char *name;			/* pointer to file to be exec'd */
+{
+/* This funcion uses no arguments at all. */
+  PRIVATE char stack[3 * PTRSIZE];
+
+  return(_callm1(MM, EXEC, _len(name), sizeof(stack), 0, name, stack, NIL_PTR));
+}
+
+
+PUBLIC int _execnl(name, arg0)
+char *name;
+char *arg0;
+{
+  /* This function resembles execl(2). */
+
+  return(_nexec(name, &arg0));
+}
+
+PRIVATE int _nexec(name, argv)
+char *name;			/* pointer to name of file to be executed */
+char *argv[];			/* pointer to argument array */
+{
+  char stack[MAXSTK];
+  char **argorg, *hp, **ap, *p;
+  int i, nargs, stackbytes, offset;
+
+  /* Count the argument pointers. */
+  nargs = 0;
+  argorg = argv;
+  while (*argorg++ != NIL_PTR) nargs++;
+
+  /* Prepare to set up the initial stack. */
+  hp = &stack[(nargs + 3) * PTRSIZE];
+  if (hp + nargs >= &stack[MAXSTK]) {
+	errno = E2BIG;
+	return(-1);
+  }
+  ap = (char **) stack;
+  *ap++ = (char *) nargs;
+
+  /* Prepare the argument pointers and strings. */
+  for (i = 0; i < nargs; i++) {
+	offset = hp - stack;
+	*ap++ = (char *) offset;
+	p = *argv++;
+	while (*p) {
+		*hp++ = *p++;
+		if (hp >= &stack[MAXSTK]) {
+			errno = E2BIG;
+			return(-1);
+		}
+	}
+	*hp++ = (char) 0;
+  }
+  *ap++ = NIL_PTR;
+
+  stackbytes = (((int) (hp - stack) + PTRSIZE - 1) / PTRSIZE) * PTRSIZE;
+  return(_callm1(MM, EXEC, _len(name), stackbytes, 0, name, stack, NIL_PTR));
+}

mach/minix/libsys/_exit.c

@@ -1,7 +1,7 @@
-#include "lib.h"
+#include <lib.h>
 
-PUBLIC int _exit(status)
+PUBLIC void _exit(status)
 int status;
 {
-  return callm1(MM, EXIT, status, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  _callm1(MM, EXIT, status, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
 }

mach/minix/libsys/_fcntl.c

@@ -0,0 +1,45 @@
+#include <lib.h>
+#define fcntl _fcntl
+#include <fcntl.h>
+#if _ANSI
+#include <stdarg.h>
+#endif
+
+#if _ANSI
+PUBLIC int fcntl(int fd, int cmd, ...)
+#else
+PUBLIC int fcntl(fd, cmd)
+int fd;
+int cmd;
+#endif
+{
+  va_list argp;
+  int int3;			/* third integer parameter for callm1 */
+  char *ptr1;			/* first pointer parameter for callm1 */
+
+  va_start(argp, cmd);
+
+  /* Set up for the sensible case where there is no variable parameter.  This
+   * covers F_GETFD, F_GETFL and invalid commands.
+   */
+  int3 = 0;
+  ptr1 = NIL_PTR;
+
+  /* Adjust for the stupid cases. */
+  switch(cmd) {
+     case F_DUPFD:
+     case F_SETFD:
+     case F_SETFL:
+	int3 = va_arg(argp, int);
+	break;
+     case F_GETLK:
+     case F_SETLK:
+     case F_SETLKW:
+	ptr1 = (char *) va_arg(argp, struct flock *);
+	break;
+  }
+
+  /* Clean up and make the system call. */  
+  va_end(argp);	
+  return(_callm1(FS, FCNTL, fd, cmd, int3, ptr1, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_fork.c

@@ -0,0 +1,7 @@
+#include <lib.h>
+#define fork	_fork
+
+PUBLIC int fork()
+{
+  return(_callm1(MM, FORK, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_fstat.c

@@ -0,0 +1,11 @@
+#include <lib.h>
+#include <sys/types.h>
+#define fstat	_fstat
+#include <sys/stat.h>
+
+PUBLIC int fstat(fd, buffer)
+int fd;
+struct stat *buffer;
+{
+  return(_callm1(FS, FSTAT, fd, 0, 0, (char *)buffer, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_getcwd.c

@@ -0,0 +1,120 @@
+/*  getcwd - get current working directory	Author: Terrence W. Holm */
+
+/* Directly derived from Adri Koppes' pwd(1).
+ * Modified by Andy Tanenbaum for POSIX (29 Oct. 1989)
+ */
+
+#include <lib.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/dir.h>
+#include <string.h>
+#define getcwd	_getcwd
+
+#define  DIRECT_SIZE  (sizeof (struct direct))
+
+PRIVATE _PROTOTYPE(void,  go_back(char *path) );
+
+char *getcwd(buffer, size)
+char *buffer;
+int size;
+/* Get current working directory. */
+{
+  int same_device, found, fd;
+  char *r, path[PATH_MAX + 1], temp_name[NAME_MAX + 1];
+  struct stat current, parent, dir_entry;
+  struct direct d;
+
+  if (buffer == (char *)NULL || size <= 0) {
+	errno = EINVAL;
+	return((char *)NULL);
+  }
+  path[0] = '\0';
+
+  /* Get the inode for the current directory  */
+  if (stat(".", &current) == -1) return((char *)NULL);
+  if ((current.st_mode & S_IFMT) != S_IFDIR) return((char *)NULL);
+
+  /* Run backwards up the directory tree, grabbing dir names on the way. */
+  while (1) {
+	same_device = 0;
+	found = 0;
+
+	/* Get the inode for the parent directory  */
+	if (chdir("..") == -1) return((char *)NULL);
+	if (stat(".", &parent) == -1) return((char *)NULL);
+	if ((parent.st_mode & S_IFMT) != S_IFDIR) return((char *)NULL);
+	if (current.st_dev == parent.st_dev) same_device = 1;
+
+	/* At the root, "." is the same as ".."  */
+	if (same_device && current.st_ino == parent.st_ino) break;
+
+	/* Search the parent directory for the current entry  */
+	if ((fd = open(".", O_RDONLY)) == -1) return((char *)NULL);
+	while (!found && read(fd, (char *)&d, DIRECT_SIZE) == DIRECT_SIZE) {
+		if (d.d_ino == 0L) continue;	/* empty slot */
+		if (same_device) {
+			if (current.st_ino == d.d_ino) found = 1;
+		} else {
+			temp_name[0] = '\0';
+			strncat(temp_name, d.d_name, NAME_MAX);
+			if (stat(temp_name, &dir_entry) == -1) {
+				close(fd);
+				go_back(path);
+				return((char *)NULL);
+			}
+			if (current.st_dev == dir_entry.st_dev &&
+			    current.st_ino == dir_entry.st_ino)
+				found = 1;
+		}
+	}
+
+	close(fd);
+	if (!found) {
+		go_back(path);
+		return((char *)NULL);
+	}
+	if (strlen(path) + NAME_MAX + 1 > PATH_MAX) {
+		errno = ERANGE;
+		go_back(path);
+		return((char *)NULL);
+	}
+	strcat(path, "/");
+	strncat(path, d.d_name, NAME_MAX);
+	current.st_dev = parent.st_dev;
+	current.st_ino = parent.st_ino;
+  }
+
+  /* Copy the reversed path name into <buffer>  */
+  if (strlen(path) + 1 > size) {
+	errno = ERANGE;
+	go_back(path);
+	return((char *)NULL);
+  }
+  if (strlen(path) == 0) {
+	strcpy(buffer, "/");
+	return(buffer);
+  }
+  *buffer = '\0';
+  while ((r = strrchr(path, '/')) != (char *)NULL) {
+	strcat(buffer, r);
+	*r = '\0';
+  }
+  return(chdir(buffer) ? (char *)NULL : buffer);
+}
+
+PRIVATE void go_back(path)
+char *path;
+{
+/* If getcwd() gets in trouble and can't complete normally, reverse the
+ * path built so far and change there so we end up in the directory that
+ * we started in.
+ */
+
+  char *r;
+
+  while ((r = strrchr(path, '/')) != (char *)NULL) {
+	chdir(r+1);
+	*r = '\0';
+  }
+}

mach/minix/libsys/_getegid.c

@@ -0,0 +1,11 @@
+#include <lib.h>
+#include <sys/types.h>
+#define getegid	_getegid
+
+PUBLIC gid_t getegid()
+{
+  int k;
+  k = _callm1(MM, GETGID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  if (k < 0) return((gid_t) k);
+  return((gid_t) _M.m2_i1);
+}

mach/minix/libsys/_geteuid.c

@@ -0,0 +1,11 @@
+#include <lib.h>
+#include <sys/types.h>
+#define geteuid	_geteuid
+
+PUBLIC uid_t geteuid()
+{
+  int k;
+  k = _callm1(MM, GETUID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  if (k < 0) return((uid_t) k);
+  return((uid_t) _M.m2_i1);
+}

mach/minix/libsys/_getgid.c

@@ -0,0 +1,8 @@
+#include <lib.h>
+#include <sys/types.h>
+#define getgid	_getgid
+
+PUBLIC gid_t getgid()
+{
+  return((gid_t)_callm1(MM, GETGID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_getpid.c

@@ -0,0 +1,7 @@
+#include <lib.h>
+#define getpid	_getpid
+
+PUBLIC int getpid()
+{
+  return(_callm1(MM, GETPID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_getppid.c

@@ -0,0 +1,11 @@
+#include <lib.h>
+#define getppid	_getppid
+
+PUBLIC int getppid()
+{
+  int p;
+
+  p = _callm1(MM, GETPID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  if (p < 0) return(p);
+  return(_M.m2_i1);
+}

mach/minix/libsys/_getuid.c

@@ -0,0 +1,8 @@
+#include <lib.h>
+#include <sys/types.h>
+#define getuid	_getuid
+
+PUBLIC uid_t getuid()
+{
+  return((uid_t)_callm1(MM, GETUID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_gtty.c

@@ -0,0 +1,11 @@
+#include <lib.h>
+#define gtty	_gtty
+#define ioctl	_ioctl
+#include <sgtty.h>
+
+PUBLIC int gtty(fd, argp)
+int fd;
+struct sgttyb *argp;
+{
+  return(ioctl(fd, TIOCGETP, argp));
+}

mach/minix/libsys/_ioctl.c

@@ -0,0 +1,77 @@
+#include <lib.h>
+#include <minix/com.h>
+#define ioctl	_ioctl
+#include <sgtty.h>
+
+PUBLIC int ioctl(fd, request, argp)
+int fd;
+int request;
+struct sgttyb *argp;
+{
+  int n;
+  long erase, kill, intr, quit, xon, xoff, eof, brk, speed;
+  struct tchars *argt;
+
+  _M.TTY_REQUEST = request;
+  _M.TTY_LINE = fd;
+
+  switch(request) {
+     case TIOCSETP:
+	erase = argp->sg_erase & BYTE;
+	kill = argp->sg_kill & BYTE;
+	speed = ((argp->sg_ospeed & BYTE) << 8) | (argp->sg_ispeed & BYTE);
+	_M.TTY_SPEK = (speed << 16) | (erase << 8) | kill;
+	_M.TTY_FLAGS = argp->sg_flags;
+	n = _callx(FS, IOCTL);
+  	return(n);
+ 
+     case TIOCSETC:
+	argt = (struct tchars * /* kludge */) argp;
+  	intr = argt->t_intrc & BYTE;
+  	quit = argt->t_quitc & BYTE;
+  	xon  = argt->t_startc & BYTE;
+  	xoff = argt->t_stopc & BYTE;
+  	eof  = argt->t_eofc & BYTE;
+  	brk  = argt->t_brkc & BYTE;		/* not used at the moment */
+  	_M.TTY_SPEK = (intr<<24) | (quit<<16) | (xon<<8) | (xoff<<0);
+  	_M.TTY_FLAGS = (eof<<8) | (brk<<0);
+  	n = _callx(FS, IOCTL);
+  	return(n);
+  	
+     case TIOCGETP:
+  	n = _callx(FS, IOCTL);
+	argp->sg_erase = (_M.TTY_SPEK >> 8) & BYTE;
+	argp->sg_kill  = (_M.TTY_SPEK >> 0) & BYTE;
+  	argp->sg_flags = _M.TTY_FLAGS & 0xFFFFL;
+	speed = (_M.TTY_SPEK >> 16) & 0xFFFFL;
+	argp->sg_ispeed = speed & BYTE;
+	argp->sg_ospeed = (speed >> 8) & BYTE;
+  	return(n);
+
+     case TIOCGETC:
+  	n = _callx(FS, IOCTL);
+	argt = (struct tchars *) argp;
+  	argt->t_intrc  = (_M.TTY_SPEK >> 24) & BYTE;
+  	argt->t_quitc  = (_M.TTY_SPEK >> 16) & BYTE;
+  	argt->t_startc = (_M.TTY_SPEK >>  8) & BYTE;
+  	argt->t_stopc  = (_M.TTY_SPEK >>  0) & BYTE;
+  	argt->t_eofc   = (_M.TTY_FLAGS >> 8) & BYTE;
+  	argt->t_brkc   = (_M.TTY_FLAGS >> 8) & BYTE;
+  	return(n);
+
+/* This is silly, do we want to add 1001 cases and _M.TTY_XYZ's here?
+ * We should just pop argp into the message for low-level interpretation.
+ */
+
+     case TIOCFLUSH:
+	_M.TTY_FLAGS = (int /* kludge */) argp;
+	return _callx(FS, IOCTL);
+
+/* decided to pop argp in the ADDRESS field. Left TIOCFLUSH a special case
+ * since it affects other platforms and old software too. FM
+ */
+     default:
+	_M.ADDRESS = (char *)argp;
+	return _callx(FS, IOCTL);
+  }
+}

mach/minix/libsys/_kill.c

@@ -0,0 +1,10 @@
+#include <lib.h>
+#define kill	_kill
+#include <signal.h>
+
+PUBLIC int kill(proc, sig)
+int proc;			/* which process is to be sent the signal */
+int sig;			/* signal number */
+{
+  return(_callm1(MM, KILL, proc, sig, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_link.c

@@ -0,0 +1,10 @@
+#include <lib.h>
+#define link	_link
+
+PUBLIC int link(name, name2)
+char *name, *name2;
+{
+  return(_callm1(FS, LINK, _len(name), _len(name2), 0,
+	 (char *) name, (char *) name2,	/* perhaps callm1 preserves these */
+	 NIL_PTR));
+}

mach/minix/libsys/_lseek.c

@@ -0,0 +1,17 @@
+#include <lib.h>
+#include <sys/types.h>
+#define lseek	_lseek
+
+PUBLIC off_t lseek(fd, offset, whence)
+int fd;
+off_t offset;
+int whence;
+{
+  int k;
+  _M.m2_i1 = fd;
+  _M.m2_l1 = offset;
+  _M.m2_i2 = whence;
+  k = _callx(FS, LSEEK);
+  if (k != 0) return((off_t) k);	/* _send() itself failed */
+  return((off_t)_M.m2_l1);
+}

mach/minix/libsys/_mkdir.c

@@ -0,0 +1,10 @@
+#include <lib.h>
+#define mkdir	_mkdir
+#include <sys/stat.h>
+
+PUBLIC int mkdir(name, mode)
+char *name;
+int mode;
+{
+  return(_callm1(FS, MKDIR, _len(name), mode, 0, (char *)name, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_mkfifo.c

@@ -0,0 +1,13 @@
+#include <lib.h>
+#include <sys/types.h>
+#define mkfifo	_mkfifo
+#include <sys/stat.h>
+
+PUBLIC int mkfifo(name, mode)
+char *name;
+int mode;
+{
+  mode = (mode & 0777) | S_IFIFO;
+  return(_callm1(FS, MKNOD, _len(name), (int)mode, 0,
+	 (char *)name, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_mknod.c

@@ -0,0 +1,10 @@
+#include <lib.h>
+#define mknod	_mknod
+
+PUBLIC int mknod(name, mode, addr)
+char *name;
+int mode, addr;
+{
+  return(_callm1(FS, MKNOD, _len(name), mode, addr,
+					(char *) name, (char *) 0, NIL_PTR));
+}

mach/minix/libsys/_mknod4.c

@@ -0,0 +1,11 @@
+#include <lib.h>
+#define mknod4	_mknod4
+
+PUBLIC int mknod4(name, mode, addr, size)
+char *name;
+int mode, addr;
+unsigned int size;
+{
+  return(_callm1(FS, MKNOD, _len(name), mode, addr, 
+				       (char *) name, (char *) size, NIL_PTR));
+}

mach/minix/libsys/_mount.c

@@ -0,0 +1,9 @@
+#include <lib.h>
+#define mount	_mount
+
+PUBLIC int mount(special, name, rwflag)
+char *name, *special;
+int rwflag;
+{
+  return(_callm1(FS, MOUNT, _len(special), _len(name), rwflag, special, name, NIL_PTR));
+}

mach/minix/libsys/_open.c

@@ -0,0 +1,34 @@
+#include <lib.h>
+#include <sys/types.h>
+#define open	_open
+#include <fcntl.h>
+
+#if _ANSI
+#include <stdarg.h>
+
+PUBLIC int open(const char *name, int flags, ...)
+{
+	int i;
+	va_list ap;
+
+	if (flags & O_CREAT) {
+		va_start(ap, flags);
+		i = va_arg(ap, int);
+		i = _callm1(FS, OPEN, _len(name), flags, i,
+			    (char *)name, NIL_PTR, NIL_PTR);
+		va_end(ap);
+		return i;
+	}
+	return _callm3(FS, OPEN, flags, name);
+}
+#else
+PUBLIC int open(name, flags, mode)
+char *name;
+int flags, mode;
+{
+  if (flags & O_CREAT)
+	return _callm1(FS, OPEN, _len(name), flags, mode,
+		      (char *)name, NIL_PTR, NIL_PTR);
+  return(_callm3(FS, OPEN, flags, name));
+}
+#endif

mach/minix/libsys/_pause.c

@@ -0,0 +1,7 @@
+#include <lib.h>
+#define pause	_pause
+
+PUBLIC int pause()
+{
+  return(_callm1(MM, PAUSE, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_pipe.c

@@ -0,0 +1,15 @@
+#include <lib.h>
+#define pipe	_pipe
+
+PUBLIC int pipe(fild)
+int fild[2];
+{
+  int k;
+  k = _callm1(FS, PIPE, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  if (k >= 0) {
+	fild[0] = _M.m1_i1;
+	fild[1] = _M.m1_i2;
+	return(0);
+  } else
+	return(k);
+}

mach/minix/libsys/_ptrace.c

@@ -0,0 +1,18 @@
+#include <lib.h>
+#define ptrace _ptrace
+
+PUBLIC long ptrace(req, pid, addr, data)
+int req, pid;
+long addr, data;
+{
+  _M.m2_i1 = pid;
+  _M.m2_i2 = req;
+  _M.m2_l1 = addr;
+  _M.m2_l2 = data;
+  if (_callx(MM, PTRACE) == -1) return(-1L);
+  if (_M.m2_l2 == -1) {
+	errno = 0;
+	return(-1L);
+  }
+  return(_M.m2_l2);
+}

mach/minix/libsys/_read.c

@@ -0,0 +1,10 @@
+#include <lib.h>
+#define read	_read
+
+PUBLIC int read(fd, buffer, nbytes)
+int fd;
+char *buffer;
+unsigned nbytes;
+{
+  return(_callm1(FS, READ, fd, nbytes, 0, buffer, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_rename.c

@@ -0,0 +1,10 @@
+#include <lib.h>
+#define rename	_rename
+
+PUBLIC int rename(name, name2)
+char *name, *name2;
+{
+  return(_callm1(FS, RENAME, _len(name), _len(name2), 0,
+	 (char *) name, (char *) name2,	/* perhaps callm1 preserves these */
+	 NIL_PTR));
+}

mach/minix/libsys/_rmdir.c

@@ -0,0 +1,8 @@
+#include <lib.h>
+#define rmdir	_rmdir
+
+PUBLIC int rmdir(name)
+char *name;
+{
+  return(_callm3(FS, RMDIR, 0, name));
+}

mach/minix/libsys/_setgid.c

@@ -0,0 +1,9 @@
+#include <lib.h>
+#include <sys/types.h>
+#define setgid	_setgid
+
+PUBLIC int setgid(grp)
+gid_t grp;
+{
+  return(_callm1(MM, SETGID, (int)grp, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_setuid.c

@@ -0,0 +1,9 @@
+#include <lib.h>
+#include <sys/types.h>
+#define setuid	_setuid
+
+PUBLIC int setuid(usr)
+int usr;
+{
+  return(_callm1(MM, SETUID, (int)usr, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_signal.c

@@ -0,0 +1,41 @@
+#include <lib.h>
+#define signal	_signal
+#include <signal.h>
+
+extern _PROTOTYPE(void (*_vectab[_NSIG]), (int));	/* array of funcs to catch signals */
+
+/* The definition of signal really should be
+ *  PUBLIC void (*signal(signr, func))()
+ * but some compilers refuse to accept this, even though it is correct.
+ * The only thing to do if you are stuck with such a defective compiler is
+ * change it to
+ *  PUBLIC void *signal(signr, func)
+ * and change ../h/signal.h accordingly.
+ */
+
+PUBLIC void (*signal(signr, func))()
+int signr;			/* which signal is being set */
+_PROTOTYPE( void (*func), (int));	/* pointer to function that catches signal */
+{
+  int r;
+  _PROTOTYPE( void (*old), (int));
+
+  old = _vectab[signr - 1];
+  _M.m6_i1 = signr;
+  if (func == SIG_IGN || func == SIG_DFL)
+	/* Keep old signal catcher until it is completely de-installed */
+	_M.m6_f1 = func;
+  else {
+	/* Use new signal catcher immediately (old one may not exist) */
+	_vectab[signr - 1] = func;
+	_M.m6_f1 = _begsig;
+  }
+  r = _callx(MM, SIGNAL);
+  if (r < 0) {
+	_vectab[signr - 1] = old;/* undo any pre-installation */
+	return((void (*) ()) r);
+  }
+  _vectab[signr - 1] = func;	/* redo any pre-installation */
+  if (r == 1) return(SIG_IGN);
+  return(old);
+}

mach/minix/libsys/_stat.c

@@ -0,0 +1,11 @@
+#include <lib.h>
+#define stat	_stat
+#include <sys/stat.h>
+
+PUBLIC int stat(name, buffer)
+char *name;
+struct stat *buffer;
+{
+  return(_callm1(FS, STAT, _len(name), 0, 0,
+  		(char *)name, (char *)buffer, NIL_PTR));
+}

mach/minix/libsys/_stime.c

@@ -0,0 +1,9 @@
+#include <lib.h>
+#define stime _stime
+
+PUBLIC int stime(top)
+long *top;
+{
+  _M.m2_l1 = *top;
+  return(_callx(FS, STIME));
+}

mach/minix/libsys/_stty.c

@@ -0,0 +1,11 @@
+#include <lib.h>
+#define stty	_stty
+#define ioctl	_ioctl
+#include <sgtty.h>
+
+PUBLIC int stty(fd, argp)
+int fd;
+struct sgttyb *argp;
+{
+  return ioctl(fd, TIOCSETP, argp);
+}

mach/minix/libsys/_sync.c

@@ -0,0 +1,7 @@
+#include <lib.h>
+#define sync	_sync
+
+PUBLIC int sync()
+{
+  return(_callm1(FS, SYNC, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_time.c

@@ -0,0 +1,18 @@
+#include <lib.h>
+#define time	_time
+#include <time.h>
+
+PUBLIC long time(tp)
+long *tp;
+{
+  int k;
+  long l;
+  k = _callm1(FS, TIME, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  if (_M.m_type < 0 || k != 0) {
+	errno = -_M.m_type;
+	return(-1L);
+  }
+  l = _M.m2_l1;
+  if (tp != (long *) 0) *tp = l;
+  return(l);
+}

mach/minix/libsys/_times.c

@@ -0,0 +1,17 @@
+#include <lib.h>
+#include <sys/types.h>
+#include <time.h>
+#define times	_times
+#include <sys/times.h>
+
+PUBLIC clock_t times(buf)
+struct tms *buf;
+{
+  clock_t k;
+  k = (clock_t)_callm1(FS, TIMES, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  buf->tms_utime = _M.m4_l1;
+  buf->tms_stime = _M.m4_l2;
+  buf->tms_cutime = _M.m4_l3;
+  buf->tms_cstime = _M.m4_l4;
+  return(k);
+}

mach/minix/libsys/_umask.c

@@ -0,0 +1,10 @@
+#include <lib.h>
+#include <sys/types.h>
+#define umask	_umask
+#include <sys/stat.h>
+
+PUBLIC mode_t umask(complmode)
+int complmode;
+{
+  return((mode_t)_callm1(FS, UMASK, (int)complmode, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/_umount.c

@@ -0,0 +1,8 @@
+#include <lib.h>
+#define umount	_umount
+
+PUBLIC int umount(name)
+char *name;
+{
+  return(_callm3(FS, UMOUNT, 0, name));
+}

mach/minix/libsys/_unlink.c

@@ -0,0 +1,8 @@
+#include <lib.h>
+#define unlink	_unlink
+
+PUBLIC int unlink(name)
+char *name;
+{
+  return(_callm3(FS, UNLINK, 0, name));
+}

mach/minix/libsys/_utime.c

@@ -0,0 +1,29 @@
+/* _utime(2) for POSIX		Authors: Terrence W. Holm & Edwin L. Froese */
+
+#include <lib.h>
+#define time	_time
+#include <time.h>
+#define utime	_utime
+#include <utime.h>
+
+long time();
+
+PUBLIC int utime(name, timp)
+char *name;
+struct utimbuf *timp;
+{
+  long current_time;
+
+  if (timp == (struct utimbuf *)NULL) {
+	current_time = time((long *)NULL);
+	_M.m2_l1 = current_time;
+	_M.m2_l2 = current_time;
+  } else {
+	_M.m2_l1 = timp->actime;
+	_M.m2_l2 = timp->modtime;
+  }
+
+  _M.m2_i1 = _len(name);
+  _M.m2_p1 = name;
+  return _callx(FS, UTIME);
+}

mach/minix/libsys/_wait.c

@@ -0,0 +1,12 @@
+#include <lib.h>
+#define wait	_wait
+#include <sys/wait.h>
+
+PUBLIC int wait(status)
+int *status;
+{
+  int k;
+  k = _callm1(MM, WAIT, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  if (k >= 0 && status != 0) *status = _M.m2_i1;
+  return(k);
+}

mach/minix/libsys/_write.c

@@ -0,0 +1,10 @@
+#include <lib.h>
+#define write	_write
+
+PUBLIC int write(fd, buffer, nbytes)
+int fd;
+char *buffer;
+unsigned nbytes;
+{
+  return(_callm1(FS, WRITE, fd, nbytes, 0, buffer, NIL_PTR, NIL_PTR));
+}

mach/minix/libsys/access.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _access
+_access:
+	jmp __access

mach/minix/libsys/alarm.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _alarm
+_alarm:
+	jmp __alarm

mach/minix/libsys/brk.s

@@ -0,0 +1,8 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _brk
+.define _sbrk
+_brk:
+	jmp __brk
+_sbrk:
+	jmp __sbrk

mach/minix/libsys/call.c

@@ -1,8 +1,6 @@
-#include "lib.h"
+#include <lib.h>
 
-PUBLIC int errno;		/* place where error numbers go */
-
-PUBLIC int callm1(proc, syscallnr, int1, int2, int3, ptr1, ptr2, ptr3)
+PUBLIC int _callm1(proc, syscallnr, int1, int2, int3, ptr1, ptr2, ptr3)
 int proc;			/* FS or MM */
 int syscallnr;			/* which system call */
 int int1;			/* first integer parameter */
@@ -12,27 +10,24 @@ char *ptr1;			/* pointer parameter */
 char *ptr2;			/* pointer parameter */
 char *ptr3;			/* pointer parameter */
 {
-/* Send a message and get the response.  The 'M.m_type' field of the
+/* Send a message and get the response.  The '_M.m_type' field of the
  * reply contains a value (>= 0) or an error code (<0). Use message format m1.
  */
-  M.m1_i1 = int1;
-  M.m1_i2 = int2;
-  M.m1_i3 = int3;
-  M.m1_p1 = ptr1;
-  M.m1_p2 = ptr2;
-  M.m1_p3 = ptr3;
-  return callx(proc, syscallnr);
+  _M.m1_i1 = int1;
+  _M.m1_i2 = int2;
+  _M.m1_i3 = int3;
+  _M.m1_p1 = ptr1;
+  _M.m1_p2 = ptr2;
+  _M.m1_p3 = ptr3;
+  return _callx(proc, syscallnr);
 }
 
 
-
-
-
-PUBLIC int callm3(proc, syscallnr, int1, name)
+PUBLIC int _callm3(proc, syscallnr, int1, name)
 int proc;			/* FS or MM */
 int syscallnr;			/* which system call */
 int int1;			/* integer parameter */
-char *name;			/* string */
+_CONST char *name;		/* string */
 {
 /* This form of system call is used for those calls that contain at most
  * one integer parameter along with a string.  If the string fits in the
@@ -40,46 +35,44 @@ char *name;			/* string */
  */
   register int k;
   register char *rp;
-  k = len(name);
-  M.m3_i1 = k;
-  M.m3_i2 = int1;
-  M.m3_p1 = name;
-  rp = &M.m3_ca1[0];
-  if (k <= M3_STRING) while (k--) *rp++ = *name++;
-  return callx(proc, syscallnr);
+  k = _len(name);
+  _M.m3_i1 = k;
+  _M.m3_i2 = int1;
+  _M.m3_p1 = (char *) name;
+  rp = &_M.m3_ca1[0];
+  if (k <= M3_STRING) while (k--)
+		*rp++ = *name++;
+  return _callx(proc, syscallnr);
 }
 
 
-
-
-
-PUBLIC int callx(proc, syscallnr)
+PUBLIC int _callx(proc, syscallnr)
 int proc;			/* FS or MM */
 int syscallnr;			/* which system call */
 {
-/* Send a message and get the response.  The 'M.m_type' field of the
+/* Send a message and get the response.  The '_M.m_type' field of the
  * reply contains a value (>= 0) or an error code (<0).
  */
   int k;
 
-  M.m_type = syscallnr;
-  k = sendrec(proc, &M);
-  if (k != OK) return(k);	/* send itself failed */
-  if (M.m_type < 0) {errno = -M.m_type; return(-1);}
-  return(M.m_type);
+  _M.m_type = syscallnr;
+  k = _sendrec(proc, &_M);
+  if (k != 0) return(k);	/* _send() itself failed */
+  if (_M.m_type < 0) {
+	errno = -_M.m_type;
+	return(-1);
+  }
+  return(_M.m_type);
 }
 
 
-
-
-
-PUBLIC int len(s)
-register char *s;		/* character string whose length is needed */
+PUBLIC int _len(s)
+_CONST register char *s;	/* character string whose length is needed */
 {
 /* Return the length of a character string, including the 0 at the end. */
   register int k;
 
   k = 0;
   while (*s++ != 0) k++;
-  return(k+1);			/* return length including the 0-byte at end */
+  return(k + 1);		/* return length including the 0-byte at end */
 }

mach/minix/libsys/chdir.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _chdir
+_chdir:
+	jmp __chdir

mach/minix/libsys/chmod.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _chmod
+_chmod:
+	jmp __chmod

mach/minix/libsys/chown.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _chown
+_chown:
+	jmp __chown

mach/minix/libsys/chroot.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _chroot
+_chroot:
+	jmp __chroot

mach/minix/libsys/close.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _close
+_close:
+	jmp __close

mach/minix/libsys/creat.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _creat
+_creat:
+	jmp __creat

mach/minix/libsys/dup.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _dup
+_dup:
+	jmp __dup

mach/minix/libsys/dup2.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _dup2
+_dup2:
+	jmp __dup2

mach/minix/libsys/errno.c

@@ -0,0 +1,4 @@
+#include <lib.h>
+/* errno.c - declare variable errno             Author: F. Meulenbroeks */
+
+int errno = 0;

mach/minix/libsys/exec.s

@@ -0,0 +1,14 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _execl
+.define _execle
+.define _execv
+.define _execve
+_execl:
+	jmp __execl
+_execle:
+	jmp __execle
+_execv:
+	jmp __execv
+_execve:
+	jmp __execve

mach/minix/libsys/execn.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _execn
+_execn:
+	jmp __execn

mach/minix/libsys/execnl.s

@@ -0,0 +1,8 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _execn
+.define _execnl
+_execn:
+	jmp __execn
+_execnl:
+	jmp __execnl

mach/minix/libsys/fcntl.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _fcntl
+_fcntl:
+	jmp __fcntl

mach/minix/libsys/fork.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _fork
+_fork:
+	jmp __fork

mach/minix/libsys/fpathconf.c

@@ -0,0 +1,59 @@
+/* POSIX fpathconf (Sec. 5.7.1) 		Author: Andy Tanenbaum */
+
+#include <lib.h>
+#include <sys/types.h>
+#define fstat	_fstat
+#include <sys/stat.h>
+#include <errno.h>
+#include <limits.h>
+
+PUBLIC long fpathconf(fd, name)
+int fd;				/* file descriptor being interrogated */
+int name;			/* property being inspected */
+{
+/* POSIX allows some of the values in <limits.h> to be increased at
+ * run time.  The pathconf and fpathconf functions allow these values
+ * to be checked at run time.  MINIX does not use this facility.
+ * The run-time limits are those given in <limits.h>.
+ */
+
+  struct stat stbuf;
+
+  switch(name) {
+	case _PC_LINK_MAX:
+		/* Fstat the file.  If that fails, return -1. */
+		if (fstat(fd, &stbuf) != 0) return(-1L);
+		if (S_ISDIR(stbuf.st_mode))
+			return(1L);	/* no links to directories */
+		else
+			return( (long) LINK_MAX);
+
+	case _PC_MAX_CANON:
+		return( (long) MAX_CANON);
+
+	case _PC_MAX_INPUT:
+		return( (long) MAX_INPUT);
+
+	case _PC_NAME_MAX:
+		return( (long) NAME_MAX);
+
+	case _PC_PATH_MAX:
+		return( (long) PATH_MAX);
+
+	case _PC_PIPE_BUF:
+		return( (long) PIPE_BUF);
+
+	case _PC_CHOWN_RESTRICTED:
+		return( (long) 1);	/* MINIX defines CHOWN_RESTRICTED */
+
+	case _PC_NO_TRUNC:		/* MINIX does not define NO_TRUNC */
+		return( (long) 0);
+
+	case _PC_VDISABLE:		/* MINIX defines VDISABLE */
+		return( (long) _POSIX_VDISABLE);
+
+	default:
+		errno = EINVAL;
+		return(-1L);
+  }
+}

mach/minix/libsys/fstat.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _fstat
+_fstat:
+	jmp __fstat

mach/minix/libsys/getcwd.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _getcwd
+_getcwd:
+	jmp __getcwd

mach/minix/libsys/getegid.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _getegid
+_getegid:
+	jmp __getegid

mach/minix/libsys/geteuid.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _geteuid
+_geteuid:
+	jmp __geteuid

mach/minix/libsys/getgid.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _getgid
+_getgid:
+	jmp __getgid

mach/minix/libsys/getpid.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _getpid
+_getpid:
+	jmp __getpid

mach/minix/libsys/getppid.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _getppid
+_getppid:
+	jmp __getppid

mach/minix/libsys/getuid.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _getuid
+_getuid:
+	jmp __getuid

mach/minix/libsys/gtty.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _gtty
+_gtty:
+	jmp __gtty

mach/minix/libsys/ioctl.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _ioctl
+_ioctl:
+	jmp __ioctl

mach/minix/libsys/kill.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _kill
+_kill:
+	jmp __kill

mach/minix/libsys/link.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _link
+_link:
+	jmp __link

mach/minix/libsys/lseek.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _lseek
+_lseek:
+	jmp __lseek

mach/minix/libsys/message.c

@@ -1,5 +1,4 @@
-#include <minix/const.h>
-#include <minix/type.h>
+#include <lib.h>
 
-/* some compilers require an initializer to force storage allocation */
-message M = {0};
+/* Some compilers require an initializer to force storage allocation */
+message _M = {0};

mach/minix/libsys/mkdir.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _mkdir
+_mkdir:
+	jmp __mkdir

mach/minix/libsys/mkfifo.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _mkfifo
+_mkfifo:
+	jmp __mkfifo

mach/minix/libsys/mknod.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _mknod
+_mknod:
+	jmp __mknod

mach/minix/libsys/mknod4.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _mknod4
+_mknod4:
+	jmp __mknod4

mach/minix/libsys/mount.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _mount
+_mount:
+	jmp __mount

mach/minix/libsys/open.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _open
+_open:
+	jmp __open

mach/minix/libsys/pathconf.c

@@ -0,0 +1,27 @@
+/* POSIX pathconf (Sec. 5.7.1) 		Author: Andy Tanenbaum */
+
+#include <lib.h>
+#include <sys/types.h>
+#define open	_open
+#include <fcntl.h>
+#include <errno.h>
+#define close	_close
+
+PUBLIC long pathconf(path, name)
+char *path;			/* name of file being interrogated */
+int name;			/* property being inspected */
+{
+/* POSIX allows some of the values in <limits.h> to be increased at
+ * run time.  The pathconf and fpathconf functions allow these values
+ * to be checked at run time.  MINIX does not use this facility.
+ * The run-time limits are those given in <limits.h>.
+ */
+
+  int fd;
+  long val;
+
+  if ( (fd = open(path, O_RDONLY)) < 0) return(-1L);
+  val = fpathconf(fd, name);
+  close(fd);
+  return(val);
+}

mach/minix/libsys/pause.s

@@ -0,0 +1,5 @@
+.sect .text; .sect .rom; .sect .data; .sect .bss
+.sect .text
+.define _pause
+_pause:
+	jmp __pause