Initial revision

mach/minix/libsys/access.c

@@ -0,0 +1,9 @@
+#include "lib.h"
+
+PUBLIC int access(name, mode)
+char *name;
+int mode;
+{
+  return callm3(FS, ACCESS, mode, name);
+
+}

mach/minix/libsys/alarm.c

@@ -0,0 +1,7 @@
+#include "lib.h"
+
+PUBLIC int alarm(sec)
+unsigned sec;
+{
+  return callm1(MM, ALARM, (int) sec, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/brk.c

@@ -0,0 +1,34 @@
+#include "lib.h"
+
+extern char *brksize;
+
+PUBLIC char *brk(addr)
+char *addr;
+{
+  int k;
+
+  k = callm1(MM, BRK, 0, 0, 0, addr, NIL_PTR, NIL_PTR);
+  if (k == OK) {
+	brksize = M.m2_p1;
+	return(NIL_PTR);
+  } else {
+	return( (char*) -1 );
+  }
+}
+
+
+PUBLIC char *sbrk(incr)
+int incr;
+{
+  char *newsize, *oldsize;
+  extern int endv, dorgv;
+
+  oldsize = brksize;
+  newsize = brksize + incr;
+  if (incr > 0 && newsize < oldsize) return( (char *) -1);
+  if (brk(newsize) == 0)
+	return(oldsize);
+  else
+	return( (char *) -1 );
+}
+

mach/minix/libsys/call.c

@@ -0,0 +1,85 @@
+#include "lib.h"
+
+PUBLIC int errno;		/* place where error numbers go */
+
+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 */
+int int2;			/* second integer parameter */
+int int3;			/* third integer parameter */
+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
+ * 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);
+}
+
+
+
+
+
+PUBLIC int callm3(proc, syscallnr, int1, name)
+int proc;			/* FS or MM */
+int syscallnr;			/* which system call */
+int int1;			/* integer parameter */
+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
+ * message, it is copied there.  If not, a pointer to it is passed.
+ */
+  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);
+}
+
+
+
+
+
+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
+ * 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);
+}
+
+
+
+
+
+PUBLIC int len(s)
+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 */
+}

mach/minix/libsys/chdir.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+PUBLIC int chdir(name)
+char *name;
+{
+  return callm3(FS, CHDIR, 0, name);
+
+}

mach/minix/libsys/chmod.c

@@ -0,0 +1,9 @@
+#include "lib.h"
+
+PUBLIC int chmod(name, mode)
+char* name;
+int mode;
+{
+  return callm3(FS, CHMOD, mode, name);
+
+}

mach/minix/libsys/chown.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+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"
+
+PUBLIC int chroot(name)
+char* name;
+{
+  return callm3(FS, CHROOT, 0, name);
+
+}

mach/minix/libsys/close.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+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,8 @@
+#include "lib.h"
+
+PUBLIC int creat(name, mode)
+char* name;
+int mode;
+{
+  return callm3(FS, CREAT, mode, name);
+}

mach/minix/libsys/dup.c

@@ -0,0 +1,7 @@
+#include "lib.h"
+
+PUBLIC int dup(fd)
+int fd;
+{
+  return callm1(FS, DUP, fd, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/dup2.c

@@ -0,0 +1,7 @@
+#include "lib.h"
+
+PUBLIC int dup2(fd, fd2)
+int fd, fd2;
+{
+  return callm1(FS, DUP, fd+0100, fd2, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/exec.c

@@ -0,0 +1,103 @@
+#include "lib.h"
+
+char *nullptr[1];		/* the EXEC calls need a zero pointer */
+
+#define	PTRSIZE	sizeof(char *)
+
+PUBLIC int execl(name, arg0)
+char *name;
+char *arg0;
+{
+  return execve(name, &arg0, nullptr);
+}
+
+PUBLIC int execle(name, argv)
+char *name, *argv;
+{
+  char **p;
+  p = (char **) &argv;
+  while (*p++) /* null statement */ ;
+  return execve(name, &argv, *p);
+}
+
+PUBLIC int execv(name, argv)
+char *name, *argv[];
+{
+  return execve(name, argv, nullptr);
+}
+
+
+PUBLIC int execve(name, argv, envp)
+char *name;			/* pointer to name of file to be executed */
+char *argv[];			/* pointer to argument array */
+char *envp[];			/* pointer to environment */
+{
+  char stack[MAX_ISTACK_BYTES];
+  char **argorg, **envorg, *hp, **ap, *p;
+  int i, nargs, nenvps, stackbytes, offset;
+  extern errno;
+
+  /* Count the argument pointers and environment pointers. */
+  nargs = 0;
+  nenvps = 0;
+  argorg = argv;
+  envorg = envp;
+  while (*argorg++ != NIL_PTR) nargs++;
+  while (*envorg++ != NIL_PTR) nenvps++;
+
+  /* Prepare to set up the initial stack. */
+  hp = &stack[(nargs + nenvps + 3) * PTRSIZE];
+  if (hp + nargs + nenvps >= &stack[MAX_ISTACK_BYTES]) {
+	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[MAX_ISTACK_BYTES]) {
+			errno = E2BIG;
+			return(-1);
+		}
+	}
+	*hp++ = (char) 0;
+  }
+  *ap++ = NIL_PTR;
+
+  /* Prepare the environment pointers and strings. */
+  for (i = 0; i < nenvps; i++) {
+	offset = hp - stack;
+	*ap++ = (char *) offset;
+	p = *envp++;
+	while (*p) {
+		*hp++ = *p++;
+		if (hp >= &stack[MAX_ISTACK_BYTES]) {
+			errno = E2BIG;
+			return(-1);
+		}
+	}
+	*hp++ = (char) 0;
+  }
+  *ap++ = NIL_PTR;
+  stackbytes = ( ( (int)(hp - stack) + PTRSIZE - 1)/PTRSIZE) * PTRSIZE;
+  return callm1(MM_PROC_NR, EXEC, len(name), stackbytes, 0,name, stack,NIL_PTR);
+}
+
+
+PUBLIC 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 MAX_ISTACK_BYTES.
+ */
+
+  static char stack[3 * PTRSIZE];
+
+  return callm1(MM_PROC_NR, EXEC, len(name), sizeof(stack), 0, name, stack, NIL_PTR);
+}

mach/minix/libsys/exit.c

@@ -0,0 +1,10 @@
+#include "lib.h"
+
+PUBLIC int (*__cleanup)();
+
+PUBLIC int exit(status)
+int status;
+{
+  if (__cleanup) (*__cleanup)();
+  return callm1(MM, EXIT, status, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/fork.c

@@ -0,0 +1,6 @@
+#include "lib.h"
+
+PUBLIC int fork()
+{
+  return callm1(MM, FORK, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/fstat.c

@@ -0,0 +1,10 @@
+#include "lib.h"
+
+PUBLIC int fstat(fd, buffer)
+int fd;
+char *buffer;
+{
+  int n;
+  n = callm1(FS, FSTAT, fd, 0, 0, buffer, NIL_PTR, NIL_PTR);
+  return(n);
+}

mach/minix/libsys/getegid.c

@@ -0,0 +1,9 @@
+#include "lib.h"
+
+PUBLIC gid getegid()
+{
+  int k;
+  k = callm1(MM, GETGID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  if (k < 0) return ( (gid) k);
+  return( (gid) M.m2_i1);
+}

mach/minix/libsys/geteuid.c

@@ -0,0 +1,9 @@
+#include "lib.h"
+
+PUBLIC uid geteuid()
+{
+  int k;
+  k = callm1(MM, GETUID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  if (k < 0) return ( (uid) k);
+  return ((uid) M.m2_i1);
+}

mach/minix/libsys/getgid.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+PUBLIC gid getgid()
+{
+  int k;
+  k = callm1(MM, GETGID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  return( (gid) k);
+}

mach/minix/libsys/getpid.c

@@ -0,0 +1,6 @@
+#include "lib.h"
+
+PUBLIC int getpid()
+{
+  return callm1(MM, GETPID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/getuid.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+PUBLIC uid getuid()
+{
+  int k;
+  k = callm1(MM, GETUID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  return( (uid) k);
+}

mach/minix/libsys/gtty.c

@@ -0,0 +1,9 @@
+#include <sgtty.h>
+
+gtty(fd, argp)
+int fd;
+char *argp;
+{
+  return ioctl(fd, TIOCGETP, argp);
+}
+

mach/minix/libsys/ioctl.c

@@ -0,0 +1,64 @@
+#include "lib.h"
+#include <minix/com.h>
+#include <sgtty.h>
+
+PUBLIC int ioctl(fd, request, u)
+int fd;
+int request;
+union {
+  struct sgttyb *argp;
+  struct tchars *argt;
+} u;
+
+{
+  int n;
+  long erase, kill, intr, quit, xon, xoff, eof, brk;
+
+  M.TTY_REQUEST = request;
+  M.TTY_LINE = fd;
+
+  switch(request) {
+     case TIOCSETP:
+	erase = u.argp->sg_erase & 0377;
+	kill = u.argp->sg_kill & 0377;
+	M.TTY_SPEK = (erase << 8) | kill;
+	M.TTY_FLAGS = u.argp->sg_flags;
+	n = callx(FS, IOCTL);
+  	return(n);
+ 
+     case TIOCSETC:
+  	intr = u.argt->t_intrc & 0377;
+  	quit = u.argt->t_quitc & 0377;
+  	xon  = u.argt->t_startc & 0377;
+  	xoff = u.argt->t_stopc & 0377;
+  	eof  = u.argt->t_eofc & 0377;
+  	brk  = u.argt->t_brkc & 0377;		/* 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);
+	u.argp->sg_erase = (M.TTY_SPEK >> 8) & 0377;
+	u.argp->sg_kill  = (M.TTY_SPEK >> 0) & 0377;
+  	u.argp->sg_flags = M.TTY_FLAGS;
+  	return(n);
+
+     case TIOCGETC:
+  	n = callx(FS, IOCTL);
+  	u.argt->t_intrc  = (M.TTY_SPEK >> 24) & 0377;
+  	u.argt->t_quitc  = (M.TTY_SPEK >> 16) & 0377;
+  	u.argt->t_startc = (M.TTY_SPEK >>  8) & 0377;
+  	u.argt->t_stopc  = (M.TTY_SPEK >>  0) & 0377;
+  	u.argt->t_eofc   = (M.TTY_FLAGS >> 8) & 0377;
+  	u.argt->t_brkc   = (M.TTY_FLAGS >> 8) & 0377;
+  	return(n);
+
+     default:
+	n = -1;
+	errno = -(EINVAL);
+	return(n);
+  }
+}
+

mach/minix/libsys/kill.c

@@ -0,0 +1,8 @@
+#include "lib.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/lib.h

@@ -0,0 +1,13 @@
+#include <minix/const.h>
+#include <minix/type.h>
+#include <minix/callnr.h>
+#include <errno.h>
+
+extern message M;
+
+#define MM                 0
+#define FS                 1
+
+extern int callm1(), callm3(), callx(), len();
+extern int errno;
+extern int begsig();		/* interrupts all vector here */

mach/minix/libsys/link.c

@@ -0,0 +1,7 @@
+#include "lib.h"
+
+PUBLIC int link(name, name2)
+char *name, *name2;
+{
+  return callm1(FS, LINK, len(name), len(name2), 0, name, name2, NIL_PTR);
+}

mach/minix/libsys/lseek.c

@@ -0,0 +1,15 @@
+#include "lib.h"
+
+PUBLIC long lseek(fd, offset, whence)
+int fd;
+long offset;
+int whence;
+{
+  int k; 
+  M.m2_i1 = fd;
+  M.m2_l1 = offset;
+  M.m2_i2 = whence;
+  k = callx(FS, LSEEK);
+  if (k != OK) return( (long) k);	/* send itself failed */
+  return(M.m2_l1);
+}

mach/minix/libsys/message.c

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

mach/minix/libsys/mknod.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+PUBLIC int mknod(name, mode, addr)
+char *name;
+int mode, addr;
+{
+  return callm1(FS, MKNOD, len(name), mode, addr, name, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/mktemp.c

@@ -0,0 +1,20 @@
+/* mktemp - make a name for a temporary file */
+
+char *mktemp(template)
+char *template;
+{
+  int pid, k;
+  char *p;
+
+  pid = getpid();		/* get process id as semi-unique number */
+  p = template;
+  while (*p++) ;		/* find end of string */
+  p--;				/* backup to last character */
+
+  /* Replace XXXXXX at end of template with pid. */
+  while (*--p == 'X') {
+	*p = '0' + (pid % 10);
+	pid = pid/10;
+  }
+  return(template);
+}

mach/minix/libsys/mount.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+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,8 @@
+#include "lib.h"
+
+PUBLIC int open(name, mode)
+char* name;
+int mode;
+{
+  return callm3(FS, OPEN, mode, name);
+}

mach/minix/libsys/pause.c

@@ -0,0 +1,6 @@
+#include "lib.h"
+
+PUBLIC int pause()
+{
+  return callm1(MM, PAUSE, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/pipe.c

@@ -0,0 +1,14 @@
+#include "lib.h"
+
+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/read.c

@@ -0,0 +1,11 @@
+#include "lib.h"
+
+PUBLIC int read(fd, buffer, nbytes)
+int fd;
+char *buffer;
+int nbytes;
+{
+  int n;
+  n = callm1(FS, READ, fd, nbytes, 0, buffer, NIL_PTR, NIL_PTR);
+  return(n);
+}

mach/minix/libsys/setgid.c

@@ -0,0 +1,7 @@
+#include "lib.h"
+
+PUBLIC int setgid(grp)
+int grp;
+{
+  return callm1(MM, SETGID, grp, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/setuid.c

@@ -0,0 +1,7 @@
+#include "lib.h"
+
+PUBLIC int setuid(usr)
+int usr;
+{
+  return callm1(MM, SETUID, usr, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/signal.c

@@ -0,0 +1,27 @@
+#include "lib.h"
+#include <signal.h>
+
+int (*vectab[NSIG])();	/* array of functions to catch signals */
+
+/* The definition of signal really should be 
+ *  PUBLIC int (*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 int *signal(signr, func)
+ * and change ../h/signal.h accordingly.
+ */
+
+PUBLIC int (*signal(signr, func))()
+int signr;			/* which signal is being set */
+int (*func)();			/* pointer to function that catches signal */
+{
+  int r,(*old)();
+
+  old = vectab[signr - 1];
+  vectab[signr - 1] = func;
+  M.m6_i1 = signr;
+  M.m6_f1 = ( (func == SIG_IGN || func == SIG_DFL) ? func : begsig);
+  r = callx(MM, SIGNAL);
+  return( (r < 0 ? (int (*)()) r : old) );
+}

mach/minix/libsys/stat.c

@@ -0,0 +1,10 @@
+#include "lib.h"
+
+PUBLIC int stat(name, buffer)
+char *name;
+char *buffer;
+{
+  int n;
+  n = callm1(FS, STAT, len(name), 0, 0, name, buffer, NIL_PTR);
+  return(n);
+}

mach/minix/libsys/stderr.c

@@ -0,0 +1,8 @@
+std_err(s)
+char *s;
+{
+  char *p = s;
+
+  while(*p != 0) p++;
+  write(2, s, (int)(p - s));
+}

mach/minix/libsys/stime.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+PUBLIC int stime(top)
+long *top;
+{
+  M.m2_l1 = *top;
+  return callx(FS, STIME);
+}

mach/minix/libsys/stty.c

@@ -0,0 +1,9 @@
+#include <sgtty.h>
+
+stty(fd, argp)
+int fd;
+char *argp;
+{
+  return ioctl(fd, TIOCSETP, argp);
+}
+

mach/minix/libsys/sync.c

@@ -0,0 +1,6 @@
+#include "lib.h"
+
+PUBLIC int sync()
+{
+  return callm1(FS, SYNC, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/syslib.c

@@ -0,0 +1,167 @@
+#include <minix/const.h>
+#include <minix/type.h>
+#include <minix/callnr.h>
+#include <minix/com.h>
+#include <errno.h>
+
+#define FS          FS_PROC_NR
+#define MM          MMPROCNR
+
+extern message M;
+
+
+/*----------------------------------------------------------------------------
+			Messages to systask (special calls)
+----------------------------------------------------------------------------*/
+
+#ifdef ATARI_ST
+PUBLIC sys_xit(parent, proc, basep, sizep)
+phys_clicks *basep, *sizep;
+#else
+PUBLIC sys_xit(parent, proc)
+#endif
+int parent;			/* parent of exiting proc. */
+int proc;			/* which proc has exited */
+{
+/* A proc has exited.  Tell the kernel. */
+
+  callm1(SYSTASK, SYS_XIT, parent, proc, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+#ifdef ATARI_ST
+  *basep = (phys_clicks)M.m1_i1;
+  *sizep = (phys_clicks)M.m1_i2;
+#endif
+}
+
+
+PUBLIC sys_getsp(proc, newsp)
+int proc;			/* which proc has enabled signals */
+vir_bytes *newsp;		/* place to put sp read from kernel */
+{
+/* Ask the kernel what the sp is. */
+
+
+  callm1(SYSTASK, SYS_GETSP, proc, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  *newsp = (vir_bytes) M.STACK_PTR;
+}
+
+
+PUBLIC sys_sig(proc, sig, sighandler)
+int proc;			/* which proc has exited */
+int sig;			/* signal number: 1 - 16 */
+int (*sighandler)();		/* pointer to signal handler in user space */
+{
+/* A proc has to be signaled.  Tell the kernel. */
+
+  M.m6_i1 = proc;
+  M.m6_i2 = sig;
+  M.m6_f1 = sighandler;
+  callx(SYSTASK, SYS_SIG);
+}
+
+
+#ifdef ATARI_ST
+PUBLIC sys_fork(parent, child, pid, shadow)
+#ifdef ALCYON_C_BUG_FIXED
+phys_clicks shadow;		/* memory allocated for shadow */
+#endif
+#else
+PUBLIC sys_fork(parent, child, pid)
+#endif
+int parent;			/* proc doing the fork */
+int child;			/* which proc has been created by the fork */
+int pid;			/* process id assigned by MM */
+{
+/* A proc has forked.  Tell the kernel. */
+
+#ifdef ATARI_ST
+  callm1(SYSTASK, SYS_FORK, parent, child, pid, (char *)shadow, NIL_PTR, NIL_PTR);
+#else
+  callm1(SYSTASK, SYS_FORK, parent, child, pid, NIL_PTR, NIL_PTR, NIL_PTR);
+#endif
+}
+
+
+PUBLIC sys_exec(proc, ptr)
+int proc;			/* proc that did exec */
+char *ptr;			/* new stack pointer */
+{
+/* A proc has exec'd.  Tell the kernel. */
+
+  callm1(SYSTASK, SYS_EXEC, proc, 0, 0, ptr, NIL_PTR, NIL_PTR);
+}
+
+PUBLIC sys_newmap(proc, ptr)
+int proc;			/* proc whose map is to be changed */
+char *ptr;			/* pointer to new map */
+{
+/* A proc has been assigned a new memory map.  Tell the kernel. */
+
+
+  callm1(SYSTASK, SYS_NEWMAP, proc, 0, 0, ptr, NIL_PTR, NIL_PTR);
+}
+
+PUBLIC sys_copy(mptr)
+message *mptr;			/* pointer to message */
+{
+/* A proc wants to use local copy. */
+
+  /* Make this routine better.  Also check other guys' error handling -DEBUG */
+  mptr->m_type = SYS_COPY;
+  if (sendrec(SYSTASK, mptr) != OK) panic("sys_copy can't send", NO_NUM);
+}
+
+PUBLIC sys_times(proc, ptr)
+int proc;			/* proc whose times are needed */
+real_time ptr[4];			/* pointer to time buffer */
+{
+/* Fetch the accounting info for a proc. */
+
+  callm1(SYSTASK, SYS_TIMES, proc, 0, 0, ptr, NIL_PTR, NIL_PTR);
+  ptr[0] = M.USER_TIME;
+  ptr[1] = M.SYSTEM_TIME;
+  ptr[2] = M.CHILD_UTIME;
+  ptr[3] = M.CHILD_STIME;
+}
+
+
+
+
+
+PUBLIC sys_abort()
+{
+/* Something awful has happened.  Abandon ship. */
+
+  callm1(SYSTASK, SYS_ABORT, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}
+
+#ifdef ATARI_ST
+PUBLIC sys_fresh(proc, ptr, dc, basep, sizep)
+int proc;			/* proc whose map is to be changed */
+char *ptr;			/* pointer to new map */
+phys_clicks dc;			/* size of initialized data */
+phys_clicks *basep, *sizep;	/* base and size for free_mem() */
+{
+/* Create a fresh process image for exec().  Tell the kernel. */
+
+  callm1(SYSTASK, SYS_FRESH, proc, (int)dc, 0, ptr, NIL_PTR, NIL_PTR);
+  *basep = (phys_clicks)M.m1_i1;
+  *sizep = (phys_clicks)M.m1_i2;
+}
+#endif
+
+
+PUBLIC int tell_fs(what, p1, p2, p3)
+int what, p1, p2, p3;
+{
+/* This routine is only used by MM to inform FS of certain events:
+ *      tell_fs(CHDIR, slot, dir, 0)
+ *      tell_fs(EXIT, proc, 0, 0)
+ *      tell_fs(FORK, parent, child, pid)
+ *      tell_fs(SETGID, proc, realgid, effgid)
+ *      tell_fs(SETUID, proc, realuid, effuid)
+ *      tell_fs(SYNC, 0, 0, 0)
+ *      tell_fs(UNPAUSE, proc, signr, 0)
+ *      tell_fs(SETPGRP, proc, 0, 0)
+ */
+  callm1(FS, what, p1, p2, p3, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/time.c

@@ -0,0 +1,13 @@
+#include "lib.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 != OK) {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,15 @@
+#include "lib.h"
+#include <sys/types.h>
+#include <sys/times.h>
+
+PUBLIC int times(buf)
+struct tms *buf;
+{
+  int k;
+  k = 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,7 @@
+#include "lib.h"
+
+PUBLIC int umask(complmode)
+int complmode;
+{
+  return callm1(FS, UMASK, complmode, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+}

mach/minix/libsys/umount.c

@@ -0,0 +1,7 @@
+#include "lib.h"
+
+PUBLIC int umount(name)
+char* name;
+{
+  return callm3(FS, UMOUNT, 0, name);
+}

mach/minix/libsys/unlink.c

@@ -0,0 +1,7 @@
+#include "lib.h"
+
+PUBLIC int unlink(name)
+char *name;
+{
+  return callm3(FS, UNLINK, 0, name);
+}

mach/minix/libsys/utime.c

@@ -0,0 +1,12 @@
+#include "lib.h"
+
+PUBLIC int utime(name, timp)
+char *name;
+long timp[2];
+{
+  M.m2_i1 = len(name);
+  M.m2_l1 = timp[0];
+  M.m2_l2 = timp[1];
+  M.m2_p1 = name;
+  return callx(FS, UTIME);
+}

mach/minix/libsys/wait.c

@@ -0,0 +1,10 @@
+#include "lib.h"
+
+PUBLIC int wait(status)
+int *status;
+{
+  int k;
+  k = callm1(MM, WAIT, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR);
+  if (status != 0) *status = M.m2_i1;
+  return(k);
+}

mach/minix/libsys/write.c

@@ -0,0 +1,8 @@
+#include "lib.h"
+
+PUBLIC int write(fd, buffer, nbytes)
+char *buffer;
+int nbytes;
+{
+  return callm1(FS, WRITE, fd, nbytes, 0, buffer, NIL_PTR, NIL_PTR);
+}