diff --git a/mach/minix/libsys/.distr b/mach/minix/libsys/.distr index 4e77ea92e..e3a61f902 100644 --- a/mach/minix/libsys/.distr +++ b/mach/minix/libsys/.distr @@ -1,7 +1,5 @@ LIST -Makefile -compmodule head_em.s end.s lib.h -libsys_s.a +libmon_s.a diff --git a/mach/minix/libsys/LIST b/mach/minix/libsys/LIST index cb64e1a44..c41248ccc 100644 --- a/mach/minix/libsys/LIST +++ b/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 diff --git a/mach/minix/libsys/_access.c b/mach/minix/libsys/_access.c new file mode 100644 index 000000000..b90aec07c --- /dev/null +++ b/mach/minix/libsys/_access.c @@ -0,0 +1,9 @@ +#include +#define access _access + +int access(name, mode) +char *name; +int mode; +{ + return(_callm3(FS, ACCESS, mode, name)); +} diff --git a/mach/minix/libsys/_alarm.c b/mach/minix/libsys/_alarm.c new file mode 100644 index 000000000..6acc6c9f7 --- /dev/null +++ b/mach/minix/libsys/_alarm.c @@ -0,0 +1,8 @@ +#include +#define alarm _alarm + +unsigned int alarm(sec) +unsigned int sec; +{ + return(_callm1(MM, ALARM, (int) sec, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_brk.c b/mach/minix/libsys/_brk.c new file mode 100644 index 000000000..1f2e565a7 --- /dev/null +++ b/mach/minix/libsys/_brk.c @@ -0,0 +1,32 @@ +#include +#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); +} diff --git a/mach/minix/libsys/_chdir.c b/mach/minix/libsys/_chdir.c new file mode 100644 index 000000000..28b6f734d --- /dev/null +++ b/mach/minix/libsys/_chdir.c @@ -0,0 +1,8 @@ +#include +#define chdir _chdir + +int chdir(name) +char *name; +{ + return(_callm3(FS, CHDIR, 0, name)); +} diff --git a/mach/minix/libsys/_chmod.c b/mach/minix/libsys/_chmod.c new file mode 100644 index 000000000..b486669a9 --- /dev/null +++ b/mach/minix/libsys/_chmod.c @@ -0,0 +1,9 @@ +#include +#define chmod _chmod + +PUBLIC int chmod(name, mode) +char *name; +mode_t mode; +{ + return(_callm3(FS, CHMOD, mode, name)); +} diff --git a/mach/minix/libsys/_chown.c b/mach/minix/libsys/_chown.c new file mode 100644 index 000000000..d4bf691a8 --- /dev/null +++ b/mach/minix/libsys/_chown.c @@ -0,0 +1,9 @@ +#include +#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)); +} diff --git a/mach/minix/libsys/_chroot.c b/mach/minix/libsys/_chroot.c new file mode 100644 index 000000000..50d1ef9ea --- /dev/null +++ b/mach/minix/libsys/_chroot.c @@ -0,0 +1,8 @@ +#include +#define chroot _chroot + +PUBLIC int chroot(name) +char *name; +{ + return(_callm3(FS, CHROOT, 0, name)); +} diff --git a/mach/minix/libsys/_close.c b/mach/minix/libsys/_close.c new file mode 100644 index 000000000..cedb28e15 --- /dev/null +++ b/mach/minix/libsys/_close.c @@ -0,0 +1,8 @@ +#include +#define close _close + +PUBLIC int close(fd) +int fd; +{ + return(_callm1(FS, CLOSE, fd, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_creat.c b/mach/minix/libsys/_creat.c new file mode 100644 index 000000000..671c87705 --- /dev/null +++ b/mach/minix/libsys/_creat.c @@ -0,0 +1,9 @@ +#include +#define creat _creat + +PUBLIC int creat(name, mode) +char *name; +mode_t mode; +{ + return(_callm3(FS, CREAT, mode, name)); +} diff --git a/mach/minix/libsys/_dup.c b/mach/minix/libsys/_dup.c new file mode 100644 index 000000000..c70134680 --- /dev/null +++ b/mach/minix/libsys/_dup.c @@ -0,0 +1,9 @@ +#include +#define dup _dup +#include + +PUBLIC int dup(fd) +int fd; +{ + return(fcntl(fd, F_DUPFD, 0)); +} diff --git a/mach/minix/libsys/_dup2.c b/mach/minix/libsys/_dup2.c new file mode 100644 index 000000000..6b7046fa0 --- /dev/null +++ b/mach/minix/libsys/_dup2.c @@ -0,0 +1,29 @@ +#include +#define dup2 _dup2 +#include +#include +#include + +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)); + } +} diff --git a/mach/minix/libsys/_exec.c b/mach/minix/libsys/_exec.c new file mode 100644 index 000000000..00287eddb --- /dev/null +++ b/mach/minix/libsys/_exec.c @@ -0,0 +1,167 @@ +#include +#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 + +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); +} diff --git a/mach/minix/libsys/_execn.c b/mach/minix/libsys/_execn.c new file mode 100644 index 000000000..e3ce35efa --- /dev/null +++ b/mach/minix/libsys/_execn.c @@ -0,0 +1,16 @@ +#include + +#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)); +} diff --git a/mach/minix/libsys/_execnl.c b/mach/minix/libsys/_execnl.c new file mode 100644 index 000000000..759cf0055 --- /dev/null +++ b/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 +#include + +#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)); +} diff --git a/mach/minix/libsys/_exit.c b/mach/minix/libsys/_exit.c index 32aa51015..3f48898c5 100644 --- a/mach/minix/libsys/_exit.c +++ b/mach/minix/libsys/_exit.c @@ -1,7 +1,7 @@ -#include "lib.h" +#include -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); } diff --git a/mach/minix/libsys/_fcntl.c b/mach/minix/libsys/_fcntl.c new file mode 100644 index 000000000..98a0f73c5 --- /dev/null +++ b/mach/minix/libsys/_fcntl.c @@ -0,0 +1,45 @@ +#include +#define fcntl _fcntl +#include +#if _ANSI +#include +#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)); +} diff --git a/mach/minix/libsys/_fork.c b/mach/minix/libsys/_fork.c new file mode 100644 index 000000000..3f0c70ac5 --- /dev/null +++ b/mach/minix/libsys/_fork.c @@ -0,0 +1,7 @@ +#include +#define fork _fork + +PUBLIC int fork() +{ + return(_callm1(MM, FORK, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_fstat.c b/mach/minix/libsys/_fstat.c new file mode 100644 index 000000000..e7f24477b --- /dev/null +++ b/mach/minix/libsys/_fstat.c @@ -0,0 +1,11 @@ +#include +#include +#define fstat _fstat +#include + +PUBLIC int fstat(fd, buffer) +int fd; +struct stat *buffer; +{ + return(_callm1(FS, FSTAT, fd, 0, 0, (char *)buffer, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_getcwd.c b/mach/minix/libsys/_getcwd.c new file mode 100644 index 000000000..b069b4826 --- /dev/null +++ b/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 +#include +#include +#include +#include +#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(".", ¤t) == -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 */ + 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'; + } +} diff --git a/mach/minix/libsys/_getegid.c b/mach/minix/libsys/_getegid.c new file mode 100644 index 000000000..7cf606457 --- /dev/null +++ b/mach/minix/libsys/_getegid.c @@ -0,0 +1,11 @@ +#include +#include +#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); +} diff --git a/mach/minix/libsys/_geteuid.c b/mach/minix/libsys/_geteuid.c new file mode 100644 index 000000000..da174682d --- /dev/null +++ b/mach/minix/libsys/_geteuid.c @@ -0,0 +1,11 @@ +#include +#include +#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); +} diff --git a/mach/minix/libsys/_getgid.c b/mach/minix/libsys/_getgid.c new file mode 100644 index 000000000..ea29a3284 --- /dev/null +++ b/mach/minix/libsys/_getgid.c @@ -0,0 +1,8 @@ +#include +#include +#define getgid _getgid + +PUBLIC gid_t getgid() +{ + return((gid_t)_callm1(MM, GETGID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_getpid.c b/mach/minix/libsys/_getpid.c new file mode 100644 index 000000000..3ba2f5c39 --- /dev/null +++ b/mach/minix/libsys/_getpid.c @@ -0,0 +1,7 @@ +#include +#define getpid _getpid + +PUBLIC int getpid() +{ + return(_callm1(MM, GETPID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_getppid.c b/mach/minix/libsys/_getppid.c new file mode 100644 index 000000000..ba128c29b --- /dev/null +++ b/mach/minix/libsys/_getppid.c @@ -0,0 +1,11 @@ +#include +#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); +} diff --git a/mach/minix/libsys/_getuid.c b/mach/minix/libsys/_getuid.c new file mode 100644 index 000000000..691863ce3 --- /dev/null +++ b/mach/minix/libsys/_getuid.c @@ -0,0 +1,8 @@ +#include +#include +#define getuid _getuid + +PUBLIC uid_t getuid() +{ + return((uid_t)_callm1(MM, GETUID, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_gtty.c b/mach/minix/libsys/_gtty.c new file mode 100644 index 000000000..943ebe34f --- /dev/null +++ b/mach/minix/libsys/_gtty.c @@ -0,0 +1,11 @@ +#include +#define gtty _gtty +#define ioctl _ioctl +#include + +PUBLIC int gtty(fd, argp) +int fd; +struct sgttyb *argp; +{ + return(ioctl(fd, TIOCGETP, argp)); +} diff --git a/mach/minix/libsys/_ioctl.c b/mach/minix/libsys/_ioctl.c new file mode 100644 index 000000000..e30bf1f5f --- /dev/null +++ b/mach/minix/libsys/_ioctl.c @@ -0,0 +1,77 @@ +#include +#include +#define ioctl _ioctl +#include + +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); + } +} diff --git a/mach/minix/libsys/_kill.c b/mach/minix/libsys/_kill.c new file mode 100644 index 000000000..47d319f9f --- /dev/null +++ b/mach/minix/libsys/_kill.c @@ -0,0 +1,10 @@ +#include +#define kill _kill +#include + +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)); +} diff --git a/mach/minix/libsys/_link.c b/mach/minix/libsys/_link.c new file mode 100644 index 000000000..81b1f61a7 --- /dev/null +++ b/mach/minix/libsys/_link.c @@ -0,0 +1,10 @@ +#include +#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)); +} diff --git a/mach/minix/libsys/_lseek.c b/mach/minix/libsys/_lseek.c new file mode 100644 index 000000000..5cc9640e2 --- /dev/null +++ b/mach/minix/libsys/_lseek.c @@ -0,0 +1,17 @@ +#include +#include +#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); +} diff --git a/mach/minix/libsys/_mkdir.c b/mach/minix/libsys/_mkdir.c new file mode 100644 index 000000000..1e0bb7d80 --- /dev/null +++ b/mach/minix/libsys/_mkdir.c @@ -0,0 +1,10 @@ +#include +#define mkdir _mkdir +#include + +PUBLIC int mkdir(name, mode) +char *name; +int mode; +{ + return(_callm1(FS, MKDIR, _len(name), mode, 0, (char *)name, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_mkfifo.c b/mach/minix/libsys/_mkfifo.c new file mode 100644 index 000000000..0cef8a7ca --- /dev/null +++ b/mach/minix/libsys/_mkfifo.c @@ -0,0 +1,13 @@ +#include +#include +#define mkfifo _mkfifo +#include + +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)); +} diff --git a/mach/minix/libsys/_mknod.c b/mach/minix/libsys/_mknod.c new file mode 100644 index 000000000..32e6c828f --- /dev/null +++ b/mach/minix/libsys/_mknod.c @@ -0,0 +1,10 @@ +#include +#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)); +} diff --git a/mach/minix/libsys/_mknod4.c b/mach/minix/libsys/_mknod4.c new file mode 100644 index 000000000..b254e37bc --- /dev/null +++ b/mach/minix/libsys/_mknod4.c @@ -0,0 +1,11 @@ +#include +#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)); +} diff --git a/mach/minix/libsys/_mount.c b/mach/minix/libsys/_mount.c new file mode 100644 index 000000000..6eb3e7489 --- /dev/null +++ b/mach/minix/libsys/_mount.c @@ -0,0 +1,9 @@ +#include +#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)); +} diff --git a/mach/minix/libsys/_open.c b/mach/minix/libsys/_open.c new file mode 100644 index 000000000..cbbaaaddd --- /dev/null +++ b/mach/minix/libsys/_open.c @@ -0,0 +1,34 @@ +#include +#include +#define open _open +#include + +#if _ANSI +#include + +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 diff --git a/mach/minix/libsys/_pause.c b/mach/minix/libsys/_pause.c new file mode 100644 index 000000000..c1cc651bb --- /dev/null +++ b/mach/minix/libsys/_pause.c @@ -0,0 +1,7 @@ +#include +#define pause _pause + +PUBLIC int pause() +{ + return(_callm1(MM, PAUSE, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_pipe.c b/mach/minix/libsys/_pipe.c new file mode 100644 index 000000000..c85f3d9d7 --- /dev/null +++ b/mach/minix/libsys/_pipe.c @@ -0,0 +1,15 @@ +#include +#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); +} diff --git a/mach/minix/libsys/_ptrace.c b/mach/minix/libsys/_ptrace.c new file mode 100644 index 000000000..890175184 --- /dev/null +++ b/mach/minix/libsys/_ptrace.c @@ -0,0 +1,18 @@ +#include +#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); +} diff --git a/mach/minix/libsys/_read.c b/mach/minix/libsys/_read.c new file mode 100644 index 000000000..5e20391ef --- /dev/null +++ b/mach/minix/libsys/_read.c @@ -0,0 +1,10 @@ +#include +#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)); +} diff --git a/mach/minix/libsys/_rename.c b/mach/minix/libsys/_rename.c new file mode 100644 index 000000000..c1c2906de --- /dev/null +++ b/mach/minix/libsys/_rename.c @@ -0,0 +1,10 @@ +#include +#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)); +} diff --git a/mach/minix/libsys/_rmdir.c b/mach/minix/libsys/_rmdir.c new file mode 100644 index 000000000..273ebbe06 --- /dev/null +++ b/mach/minix/libsys/_rmdir.c @@ -0,0 +1,8 @@ +#include +#define rmdir _rmdir + +PUBLIC int rmdir(name) +char *name; +{ + return(_callm3(FS, RMDIR, 0, name)); +} diff --git a/mach/minix/libsys/_setgid.c b/mach/minix/libsys/_setgid.c new file mode 100644 index 000000000..2f597166c --- /dev/null +++ b/mach/minix/libsys/_setgid.c @@ -0,0 +1,9 @@ +#include +#include +#define setgid _setgid + +PUBLIC int setgid(grp) +gid_t grp; +{ + return(_callm1(MM, SETGID, (int)grp, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_setuid.c b/mach/minix/libsys/_setuid.c new file mode 100644 index 000000000..c5f412017 --- /dev/null +++ b/mach/minix/libsys/_setuid.c @@ -0,0 +1,9 @@ +#include +#include +#define setuid _setuid + +PUBLIC int setuid(usr) +int usr; +{ + return(_callm1(MM, SETUID, (int)usr, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_signal.c b/mach/minix/libsys/_signal.c new file mode 100644 index 000000000..1b5e8e1e7 --- /dev/null +++ b/mach/minix/libsys/_signal.c @@ -0,0 +1,41 @@ +#include +#define signal _signal +#include + +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); +} diff --git a/mach/minix/libsys/_stat.c b/mach/minix/libsys/_stat.c new file mode 100644 index 000000000..1fcd7dd50 --- /dev/null +++ b/mach/minix/libsys/_stat.c @@ -0,0 +1,11 @@ +#include +#define stat _stat +#include + +PUBLIC int stat(name, buffer) +char *name; +struct stat *buffer; +{ + return(_callm1(FS, STAT, _len(name), 0, 0, + (char *)name, (char *)buffer, NIL_PTR)); +} diff --git a/mach/minix/libsys/_stime.c b/mach/minix/libsys/_stime.c new file mode 100644 index 000000000..8399cd2c0 --- /dev/null +++ b/mach/minix/libsys/_stime.c @@ -0,0 +1,9 @@ +#include +#define stime _stime + +PUBLIC int stime(top) +long *top; +{ + _M.m2_l1 = *top; + return(_callx(FS, STIME)); +} diff --git a/mach/minix/libsys/_stty.c b/mach/minix/libsys/_stty.c new file mode 100644 index 000000000..a213e3e86 --- /dev/null +++ b/mach/minix/libsys/_stty.c @@ -0,0 +1,11 @@ +#include +#define stty _stty +#define ioctl _ioctl +#include + +PUBLIC int stty(fd, argp) +int fd; +struct sgttyb *argp; +{ + return ioctl(fd, TIOCSETP, argp); +} diff --git a/mach/minix/libsys/_sync.c b/mach/minix/libsys/_sync.c new file mode 100644 index 000000000..36186692d --- /dev/null +++ b/mach/minix/libsys/_sync.c @@ -0,0 +1,7 @@ +#include +#define sync _sync + +PUBLIC int sync() +{ + return(_callm1(FS, SYNC, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_time.c b/mach/minix/libsys/_time.c new file mode 100644 index 000000000..22957e27d --- /dev/null +++ b/mach/minix/libsys/_time.c @@ -0,0 +1,18 @@ +#include +#define time _time +#include + +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); +} diff --git a/mach/minix/libsys/_times.c b/mach/minix/libsys/_times.c new file mode 100644 index 000000000..223c8b337 --- /dev/null +++ b/mach/minix/libsys/_times.c @@ -0,0 +1,17 @@ +#include +#include +#include +#define times _times +#include + +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); +} diff --git a/mach/minix/libsys/_umask.c b/mach/minix/libsys/_umask.c new file mode 100644 index 000000000..70c80c395 --- /dev/null +++ b/mach/minix/libsys/_umask.c @@ -0,0 +1,10 @@ +#include +#include +#define umask _umask +#include + +PUBLIC mode_t umask(complmode) +int complmode; +{ + return((mode_t)_callm1(FS, UMASK, (int)complmode, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR)); +} diff --git a/mach/minix/libsys/_umount.c b/mach/minix/libsys/_umount.c new file mode 100644 index 000000000..e4132bbc2 --- /dev/null +++ b/mach/minix/libsys/_umount.c @@ -0,0 +1,8 @@ +#include +#define umount _umount + +PUBLIC int umount(name) +char *name; +{ + return(_callm3(FS, UMOUNT, 0, name)); +} diff --git a/mach/minix/libsys/_unlink.c b/mach/minix/libsys/_unlink.c new file mode 100644 index 000000000..ebaea4ea7 --- /dev/null +++ b/mach/minix/libsys/_unlink.c @@ -0,0 +1,8 @@ +#include +#define unlink _unlink + +PUBLIC int unlink(name) +char *name; +{ + return(_callm3(FS, UNLINK, 0, name)); +} diff --git a/mach/minix/libsys/_utime.c b/mach/minix/libsys/_utime.c new file mode 100644 index 000000000..c22dbcd88 --- /dev/null +++ b/mach/minix/libsys/_utime.c @@ -0,0 +1,29 @@ +/* _utime(2) for POSIX Authors: Terrence W. Holm & Edwin L. Froese */ + +#include +#define time _time +#include +#define utime _utime +#include + +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); +} diff --git a/mach/minix/libsys/_wait.c b/mach/minix/libsys/_wait.c new file mode 100644 index 000000000..c1c2322e1 --- /dev/null +++ b/mach/minix/libsys/_wait.c @@ -0,0 +1,12 @@ +#include +#define wait _wait +#include + +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); +} diff --git a/mach/minix/libsys/_write.c b/mach/minix/libsys/_write.c new file mode 100644 index 000000000..9dd96af89 --- /dev/null +++ b/mach/minix/libsys/_write.c @@ -0,0 +1,10 @@ +#include +#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)); +} diff --git a/mach/minix/libsys/access.s b/mach/minix/libsys/access.s new file mode 100644 index 000000000..5c697683d --- /dev/null +++ b/mach/minix/libsys/access.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _access +_access: + jmp __access diff --git a/mach/minix/libsys/alarm.s b/mach/minix/libsys/alarm.s new file mode 100644 index 000000000..5d1806e78 --- /dev/null +++ b/mach/minix/libsys/alarm.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _alarm +_alarm: + jmp __alarm diff --git a/mach/minix/libsys/brk.s b/mach/minix/libsys/brk.s new file mode 100644 index 000000000..1ab5012f1 --- /dev/null +++ b/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 diff --git a/mach/minix/libsys/call.c b/mach/minix/libsys/call.c index 141620c3a..46678ef80 100644 --- a/mach/minix/libsys/call.c +++ b/mach/minix/libsys/call.c @@ -1,8 +1,6 @@ -#include "lib.h" +#include -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 - * reply contains a value (>= 0) or an error code (<0). +/* 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 */ } diff --git a/mach/minix/libsys/chdir.s b/mach/minix/libsys/chdir.s new file mode 100644 index 000000000..f3474830d --- /dev/null +++ b/mach/minix/libsys/chdir.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _chdir +_chdir: + jmp __chdir diff --git a/mach/minix/libsys/chmod.s b/mach/minix/libsys/chmod.s new file mode 100644 index 000000000..591cd3a72 --- /dev/null +++ b/mach/minix/libsys/chmod.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _chmod +_chmod: + jmp __chmod diff --git a/mach/minix/libsys/chown.s b/mach/minix/libsys/chown.s new file mode 100644 index 000000000..d559c01fc --- /dev/null +++ b/mach/minix/libsys/chown.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _chown +_chown: + jmp __chown diff --git a/mach/minix/libsys/chroot.s b/mach/minix/libsys/chroot.s new file mode 100644 index 000000000..082bee262 --- /dev/null +++ b/mach/minix/libsys/chroot.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _chroot +_chroot: + jmp __chroot diff --git a/mach/minix/libsys/close.s b/mach/minix/libsys/close.s new file mode 100644 index 000000000..6bfbbb6b3 --- /dev/null +++ b/mach/minix/libsys/close.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _close +_close: + jmp __close diff --git a/mach/minix/libsys/creat.s b/mach/minix/libsys/creat.s new file mode 100644 index 000000000..d10c18095 --- /dev/null +++ b/mach/minix/libsys/creat.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _creat +_creat: + jmp __creat diff --git a/mach/minix/libsys/dup.s b/mach/minix/libsys/dup.s new file mode 100644 index 000000000..b4987c11a --- /dev/null +++ b/mach/minix/libsys/dup.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _dup +_dup: + jmp __dup diff --git a/mach/minix/libsys/dup2.s b/mach/minix/libsys/dup2.s new file mode 100644 index 000000000..6f3966301 --- /dev/null +++ b/mach/minix/libsys/dup2.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _dup2 +_dup2: + jmp __dup2 diff --git a/mach/minix/libsys/errno.c b/mach/minix/libsys/errno.c new file mode 100644 index 000000000..538fd572f --- /dev/null +++ b/mach/minix/libsys/errno.c @@ -0,0 +1,4 @@ +#include +/* errno.c - declare variable errno Author: F. Meulenbroeks */ + +int errno = 0; diff --git a/mach/minix/libsys/exec.s b/mach/minix/libsys/exec.s new file mode 100644 index 000000000..0657aa3dc --- /dev/null +++ b/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 diff --git a/mach/minix/libsys/execn.s b/mach/minix/libsys/execn.s new file mode 100644 index 000000000..39f10cbd9 --- /dev/null +++ b/mach/minix/libsys/execn.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _execn +_execn: + jmp __execn diff --git a/mach/minix/libsys/execnl.s b/mach/minix/libsys/execnl.s new file mode 100644 index 000000000..99c77fb1f --- /dev/null +++ b/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 diff --git a/mach/minix/libsys/fcntl.s b/mach/minix/libsys/fcntl.s new file mode 100644 index 000000000..bdeb686e2 --- /dev/null +++ b/mach/minix/libsys/fcntl.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _fcntl +_fcntl: + jmp __fcntl diff --git a/mach/minix/libsys/fork.s b/mach/minix/libsys/fork.s new file mode 100644 index 000000000..281576fd9 --- /dev/null +++ b/mach/minix/libsys/fork.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _fork +_fork: + jmp __fork diff --git a/mach/minix/libsys/fpathconf.c b/mach/minix/libsys/fpathconf.c new file mode 100644 index 000000000..a1ff6f5e1 --- /dev/null +++ b/mach/minix/libsys/fpathconf.c @@ -0,0 +1,59 @@ +/* POSIX fpathconf (Sec. 5.7.1) Author: Andy Tanenbaum */ + +#include +#include +#define fstat _fstat +#include +#include +#include + +PUBLIC long fpathconf(fd, name) +int fd; /* file descriptor being interrogated */ +int name; /* property being inspected */ +{ +/* POSIX allows some of the values in 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 . + */ + + 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); + } +} diff --git a/mach/minix/libsys/fstat.s b/mach/minix/libsys/fstat.s new file mode 100644 index 000000000..7d14ae997 --- /dev/null +++ b/mach/minix/libsys/fstat.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _fstat +_fstat: + jmp __fstat diff --git a/mach/minix/libsys/getcwd.s b/mach/minix/libsys/getcwd.s new file mode 100644 index 000000000..e1afecc03 --- /dev/null +++ b/mach/minix/libsys/getcwd.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _getcwd +_getcwd: + jmp __getcwd diff --git a/mach/minix/libsys/getegid.s b/mach/minix/libsys/getegid.s new file mode 100644 index 000000000..f0f4af3c0 --- /dev/null +++ b/mach/minix/libsys/getegid.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _getegid +_getegid: + jmp __getegid diff --git a/mach/minix/libsys/geteuid.s b/mach/minix/libsys/geteuid.s new file mode 100644 index 000000000..6a9fd2545 --- /dev/null +++ b/mach/minix/libsys/geteuid.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _geteuid +_geteuid: + jmp __geteuid diff --git a/mach/minix/libsys/getgid.s b/mach/minix/libsys/getgid.s new file mode 100644 index 000000000..2e950b274 --- /dev/null +++ b/mach/minix/libsys/getgid.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _getgid +_getgid: + jmp __getgid diff --git a/mach/minix/libsys/getpid.s b/mach/minix/libsys/getpid.s new file mode 100644 index 000000000..9338723e6 --- /dev/null +++ b/mach/minix/libsys/getpid.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _getpid +_getpid: + jmp __getpid diff --git a/mach/minix/libsys/getppid.s b/mach/minix/libsys/getppid.s new file mode 100644 index 000000000..95ffedc6c --- /dev/null +++ b/mach/minix/libsys/getppid.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _getppid +_getppid: + jmp __getppid diff --git a/mach/minix/libsys/getuid.s b/mach/minix/libsys/getuid.s new file mode 100644 index 000000000..2073f73c3 --- /dev/null +++ b/mach/minix/libsys/getuid.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _getuid +_getuid: + jmp __getuid diff --git a/mach/minix/libsys/gtty.s b/mach/minix/libsys/gtty.s new file mode 100644 index 000000000..18e0c15c9 --- /dev/null +++ b/mach/minix/libsys/gtty.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _gtty +_gtty: + jmp __gtty diff --git a/mach/minix/libsys/ioctl.s b/mach/minix/libsys/ioctl.s new file mode 100644 index 000000000..ffdf4aa4b --- /dev/null +++ b/mach/minix/libsys/ioctl.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _ioctl +_ioctl: + jmp __ioctl diff --git a/mach/minix/libsys/kill.s b/mach/minix/libsys/kill.s new file mode 100644 index 000000000..97b406794 --- /dev/null +++ b/mach/minix/libsys/kill.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _kill +_kill: + jmp __kill diff --git a/mach/minix/libsys/link.s b/mach/minix/libsys/link.s new file mode 100644 index 000000000..99c8879d9 --- /dev/null +++ b/mach/minix/libsys/link.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _link +_link: + jmp __link diff --git a/mach/minix/libsys/lseek.s b/mach/minix/libsys/lseek.s new file mode 100644 index 000000000..1da13392f --- /dev/null +++ b/mach/minix/libsys/lseek.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _lseek +_lseek: + jmp __lseek diff --git a/mach/minix/libsys/message.c b/mach/minix/libsys/message.c index faaae5426..0b4980873 100644 --- a/mach/minix/libsys/message.c +++ b/mach/minix/libsys/message.c @@ -1,5 +1,4 @@ -#include -#include +#include -/* some compilers require an initializer to force storage allocation */ -message M = {0}; +/* Some compilers require an initializer to force storage allocation */ +message _M = {0}; diff --git a/mach/minix/libsys/mkdir.s b/mach/minix/libsys/mkdir.s new file mode 100644 index 000000000..da3ea01f0 --- /dev/null +++ b/mach/minix/libsys/mkdir.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _mkdir +_mkdir: + jmp __mkdir diff --git a/mach/minix/libsys/mkfifo.s b/mach/minix/libsys/mkfifo.s new file mode 100644 index 000000000..9959ff4c6 --- /dev/null +++ b/mach/minix/libsys/mkfifo.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _mkfifo +_mkfifo: + jmp __mkfifo diff --git a/mach/minix/libsys/mknod.s b/mach/minix/libsys/mknod.s new file mode 100644 index 000000000..0f99912d2 --- /dev/null +++ b/mach/minix/libsys/mknod.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _mknod +_mknod: + jmp __mknod diff --git a/mach/minix/libsys/mknod4.s b/mach/minix/libsys/mknod4.s new file mode 100644 index 000000000..37ecdbc73 --- /dev/null +++ b/mach/minix/libsys/mknod4.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _mknod4 +_mknod4: + jmp __mknod4 diff --git a/mach/minix/libsys/mount.s b/mach/minix/libsys/mount.s new file mode 100644 index 000000000..7d1ea566d --- /dev/null +++ b/mach/minix/libsys/mount.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _mount +_mount: + jmp __mount diff --git a/mach/minix/libsys/open.s b/mach/minix/libsys/open.s new file mode 100644 index 000000000..e8d1935c3 --- /dev/null +++ b/mach/minix/libsys/open.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _open +_open: + jmp __open diff --git a/mach/minix/libsys/pathconf.c b/mach/minix/libsys/pathconf.c new file mode 100644 index 000000000..c4476165e --- /dev/null +++ b/mach/minix/libsys/pathconf.c @@ -0,0 +1,27 @@ +/* POSIX pathconf (Sec. 5.7.1) Author: Andy Tanenbaum */ + +#include +#include +#define open _open +#include +#include +#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 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 . + */ + + int fd; + long val; + + if ( (fd = open(path, O_RDONLY)) < 0) return(-1L); + val = fpathconf(fd, name); + close(fd); + return(val); +} diff --git a/mach/minix/libsys/pause.s b/mach/minix/libsys/pause.s new file mode 100644 index 000000000..b50185d38 --- /dev/null +++ b/mach/minix/libsys/pause.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _pause +_pause: + jmp __pause diff --git a/mach/minix/libsys/pipe.s b/mach/minix/libsys/pipe.s new file mode 100644 index 000000000..fedc499f3 --- /dev/null +++ b/mach/minix/libsys/pipe.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _pipe +_pipe: + jmp __pipe diff --git a/mach/minix/libsys/ptrace.s b/mach/minix/libsys/ptrace.s new file mode 100644 index 000000000..81592417f --- /dev/null +++ b/mach/minix/libsys/ptrace.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _ptrace +_ptrace: + jmp __ptrace diff --git a/mach/minix/libsys/read.s b/mach/minix/libsys/read.s new file mode 100644 index 000000000..6251858cc --- /dev/null +++ b/mach/minix/libsys/read.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _read +_read: + jmp __read diff --git a/mach/minix/libsys/rename.s b/mach/minix/libsys/rename.s new file mode 100644 index 000000000..928cc9552 --- /dev/null +++ b/mach/minix/libsys/rename.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _rename +_rename: + jmp __rename diff --git a/mach/minix/libsys/rmdir.s b/mach/minix/libsys/rmdir.s new file mode 100644 index 000000000..00ae36572 --- /dev/null +++ b/mach/minix/libsys/rmdir.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _rmdir +_rmdir: + jmp __rmdir diff --git a/mach/minix/libsys/setgid.s b/mach/minix/libsys/setgid.s new file mode 100644 index 000000000..c6c25dde3 --- /dev/null +++ b/mach/minix/libsys/setgid.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _setgid +_setgid: + jmp __setgid diff --git a/mach/minix/libsys/setuid.s b/mach/minix/libsys/setuid.s new file mode 100644 index 000000000..d01684a79 --- /dev/null +++ b/mach/minix/libsys/setuid.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _setuid +_setuid: + jmp __setuid diff --git a/mach/minix/libsys/signal.s b/mach/minix/libsys/signal.s new file mode 100644 index 000000000..aa8aa37e0 --- /dev/null +++ b/mach/minix/libsys/signal.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _signal +_signal: + jmp __signal diff --git a/mach/minix/libsys/stat.s b/mach/minix/libsys/stat.s new file mode 100644 index 000000000..4df16b462 --- /dev/null +++ b/mach/minix/libsys/stat.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _stat +_stat: + jmp __stat diff --git a/mach/minix/libsys/stime.s b/mach/minix/libsys/stime.s new file mode 100644 index 000000000..f016d6c37 --- /dev/null +++ b/mach/minix/libsys/stime.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _stime +_stime: + jmp __stime diff --git a/mach/minix/libsys/stty.s b/mach/minix/libsys/stty.s new file mode 100644 index 000000000..c3ae0e8c4 --- /dev/null +++ b/mach/minix/libsys/stty.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _stty +_stty: + jmp __stty diff --git a/mach/minix/libsys/sync.s b/mach/minix/libsys/sync.s new file mode 100644 index 000000000..2ab0b5dcb --- /dev/null +++ b/mach/minix/libsys/sync.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _sync +_sync: + jmp __sync diff --git a/mach/minix/libsys/syslib.c b/mach/minix/libsys/syslib.c index 182b296ee..fe86f3b06 100644 --- a/mach/minix/libsys/syslib.c +++ b/mach/minix/libsys/syslib.c @@ -1,71 +1,95 @@ -#include -#include -#include +#include #include -#include - -#define FS FS_PROC_NR -#define MM MMPROCNR - -extern message M; - /*---------------------------------------------------------------------------- - Messages to systask (special calls) + Messages to systask (special calls) ----------------------------------------------------------------------------*/ +#if (CHIP == M68000) +PUBLIC _PROTOTYPE( void sys_xit, (int parent, int proc, + phys_clicks *basep, phys_clicks *sizep)); +#else +PUBLIC _PROTOTYPE( void sys_xit, (int parent, int proc)); +#endif +PUBLIC _PROTOTYPE( void sys_getsp, (int proc, vir_bytes *newsp)); +PUBLIC _PROTOTYPE( void sys_sig, (int proc, int sig, void (*sighandler)(int))); +#if (CHIP == M68000) +#ifdef ALCYON_C_BUG_FIXED +PUBLIC _PROTOTYPE( void sys_fork, (int prnt, int chld, int pd, phys_clicks shdw)); +#else +PUBLIC _PROTOTYPE( void sys_fork, (int parent, int child, int pid, int shadow)); +#endif +#else +PUBLIC _PROTOTYPE( void sys_fork, (int parent, int child, int pid)); +#endif +PUBLIC _PROTOTYPE( void sys_exec, (int proc, char *ptr, int traced)); +PUBLIC _PROTOTYPE( void sys_newmap, (int proc, char *ptr)); +PUBLIC _PROTOTYPE( void sys_copy, (message *mptr)); +PUBLIC _PROTOTYPE( void sys_times, (int proc, time_t ptr[4])); +PUBLIC _PROTOTYPE( void sys_abort, (void)); +#if (CHIP == M68000) +PUBLIC _PROTOTYPE( void sys_fresh, (int proc, char *ptr, phys_clicks dc, + phys_clicks *basep, phys_clicks *sizep)); +#endif +PUBLIC _PROTOTYPE( void sys_kill, (int proc, int sig)); +PUBLIC _PROTOTYPE( int sys_trace, (int req, int procnr, + long addr, long *data_p)); +PUBLIC _PROTOTYPE( void tell_fs, ( int what, int p1, int p2, int p3)); -#ifdef ATARI_ST -PUBLIC sys_xit(parent, proc, basep, sizep) + +#if (CHIP == M68000) +PUBLIC void sys_xit(parent, proc, basep, sizep) phys_clicks *basep, *sizep; #else -PUBLIC sys_xit(parent, proc) +PUBLIC void 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; + _callm1(SYSTASK, SYS_XIT, parent, proc, 0, NIL_PTR, NIL_PTR, NIL_PTR); +#if (CHIP == M68000) + *basep = (phys_clicks) _M.m1_i1; + *sizep = (phys_clicks) _M.m1_i2; #endif } -PUBLIC sys_getsp(proc, newsp) +PUBLIC void 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; + _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) +PUBLIC void 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 */ +_PROTOTYPE(void (*sighandler), (int));/* 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); + _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) +#if (CHIP == M68000) +PUBLIC void sys_fork(parent, child, pid, shadow) #ifdef ALCYON_C_BUG_FIXED phys_clicks shadow; /* memory allocated for shadow */ +#else +int shadow; #endif #else -PUBLIC sys_fork(parent, child, pid) +PUBLIC void sys_fork(parent, child, pid) #endif int parent; /* proc doing the fork */ int child; /* which proc has been created by the fork */ @@ -73,69 +97,68 @@ 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); +#if (CHIP == M68000) + _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); + _callm1(SYSTASK, SYS_FORK, parent, child, pid, NIL_PTR, NIL_PTR, NIL_PTR); #endif } -PUBLIC sys_exec(proc, ptr) +PUBLIC void sys_exec(proc, ptr, traced) int proc; /* proc that did exec */ char *ptr; /* new stack pointer */ +int traced; /* is tracing enabled? */ { /* A proc has exec'd. Tell the kernel. */ - callm1(SYSTASK, SYS_EXEC, proc, 0, 0, ptr, NIL_PTR, NIL_PTR); + _callm1(SYSTASK, SYS_EXEC, proc, traced, 0, ptr, NIL_PTR, NIL_PTR); } -PUBLIC sys_newmap(proc, ptr) +PUBLIC void 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); + _callm1(SYSTASK, SYS_NEWMAP, proc, 0, 0, ptr, NIL_PTR, NIL_PTR); } -PUBLIC sys_copy(mptr) +PUBLIC void 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 */ + /* 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); + if (_sendrec(SYSTASK, mptr) != 0) panic("sys_copy can't send", NO_NUM); } -PUBLIC sys_times(proc, ptr) +PUBLIC void sys_times(proc, ptr) int proc; /* proc whose times are needed */ -real_time ptr[4]; /* pointer to time buffer */ +time_t 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; + _callm1(SYSTASK, SYS_TIMES, proc, 0, 0, (char *)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() +PUBLIC void sys_abort() { /* Something awful has happened. Abandon ship. */ - callm1(SYSTASK, SYS_ABORT, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR); + _callm1(SYSTASK, SYS_ABORT, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR); } -#ifdef ATARI_ST -PUBLIC sys_fresh(proc, ptr, dc, basep, sizep) +#if (CHIP == M68000) +PUBLIC void 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 */ @@ -143,30 +166,46 @@ 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; + _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 sys_kill(proc, sig) +PUBLIC void sys_kill(proc, sig) int proc; /* which proc has exited */ int sig; /* signal number: 1 - 16 */ { /* A proc has to be signaled via MM. Tell the kernel. */ - M.m6_i1 = proc; - M.m6_i2 = sig; - callx(SYSTASK, SYS_KILL); + _M.m6_i1 = proc; + _M.m6_i2 = sig; + _callx(SYSTASK, SYS_KILL); } +PUBLIC int sys_trace(req, procnr, addr, data_p) +int req, procnr; +long addr, *data_p; +{ + int r; -PUBLIC int tell_fs(what, p1, p2, p3) + _M.m2_i1 = procnr; + _M.m2_i2 = req; + _M.m2_l1 = addr; + if (data_p) _M.m2_l2 = *data_p; + r = _callx(SYSTASK, SYS_TRACE); + if (data_p) *data_p = _M.m2_l2; + return(r); +} + +PUBLIC void 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(EXEC, proc, 0, 0) * tell_fs(EXIT, proc, 0, 0) * tell_fs(FORK, parent, child, pid) * tell_fs(SETGID, proc, realgid, effgid) @@ -175,5 +214,5 @@ int what, p1, p2, p3; * tell_fs(UNPAUSE, proc, signr, 0) * tell_fs(SETPGRP, proc, 0, 0) */ - callm1(FS, what, p1, p2, p3, NIL_PTR, NIL_PTR, NIL_PTR); + _callm1(FS, what, p1, p2, p3, NIL_PTR, NIL_PTR, NIL_PTR); } diff --git a/mach/minix/libsys/time.s b/mach/minix/libsys/time.s new file mode 100644 index 000000000..cc6dde202 --- /dev/null +++ b/mach/minix/libsys/time.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _time +_time: + jmp __time diff --git a/mach/minix/libsys/times.s b/mach/minix/libsys/times.s new file mode 100644 index 000000000..8085dbe7a --- /dev/null +++ b/mach/minix/libsys/times.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _times +_times: + jmp __times diff --git a/mach/minix/libsys/umask.s b/mach/minix/libsys/umask.s new file mode 100644 index 000000000..4658ef803 --- /dev/null +++ b/mach/minix/libsys/umask.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _umask +_umask: + jmp __umask diff --git a/mach/minix/libsys/umount.s b/mach/minix/libsys/umount.s new file mode 100644 index 000000000..1de496100 --- /dev/null +++ b/mach/minix/libsys/umount.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _umount +_umount: + jmp __umount diff --git a/mach/minix/libsys/unlink.s b/mach/minix/libsys/unlink.s new file mode 100644 index 000000000..f3d7d48ee --- /dev/null +++ b/mach/minix/libsys/unlink.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _unlink +_unlink: + jmp __unlink diff --git a/mach/minix/libsys/utime.s b/mach/minix/libsys/utime.s new file mode 100644 index 000000000..ce53eadcc --- /dev/null +++ b/mach/minix/libsys/utime.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _utime +_utime: + jmp __utime diff --git a/mach/minix/libsys/vectab.c b/mach/minix/libsys/vectab.c new file mode 100644 index 000000000..54eed904a --- /dev/null +++ b/mach/minix/libsys/vectab.c @@ -0,0 +1,10 @@ +/* When the signal call is made, a pointer to the function to be called + * is stored in this table. When the interrupt comes in from the kernel, + * the function is called within the user address space using _vectab[]. + */ + +#include +#include + +/* array of functions to catch signals */ +_PROTOTYPE( void (*_vectab[_NSIG]), (int)); diff --git a/mach/minix/libsys/wait.s b/mach/minix/libsys/wait.s new file mode 100644 index 000000000..cb723f554 --- /dev/null +++ b/mach/minix/libsys/wait.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _wait +_wait: + jmp __wait diff --git a/mach/minix/libsys/write.s b/mach/minix/libsys/write.s new file mode 100644 index 000000000..9ff32a732 --- /dev/null +++ b/mach/minix/libsys/write.s @@ -0,0 +1,5 @@ +.sect .text; .sect .rom; .sect .data; .sect .bss +.sect .text +.define _write +_write: + jmp __write diff --git a/mach/minixST/libsys/_exit.c b/mach/minixST/libsys/_exit.c index 32aa51015..3f48898c5 100644 --- a/mach/minixST/libsys/_exit.c +++ b/mach/minixST/libsys/_exit.c @@ -1,7 +1,7 @@ -#include "lib.h" +#include -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); } diff --git a/mach/minixST/libsys/call.c b/mach/minixST/libsys/call.c index 141620c3a..46678ef80 100644 --- a/mach/minixST/libsys/call.c +++ b/mach/minixST/libsys/call.c @@ -1,8 +1,6 @@ -#include "lib.h" +#include -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 - * reply contains a value (>= 0) or an error code (<0). +/* 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 */ } diff --git a/mach/minixST/libsys/message.c b/mach/minixST/libsys/message.c index faaae5426..0b4980873 100644 --- a/mach/minixST/libsys/message.c +++ b/mach/minixST/libsys/message.c @@ -1,5 +1,4 @@ -#include -#include +#include -/* some compilers require an initializer to force storage allocation */ -message M = {0}; +/* Some compilers require an initializer to force storage allocation */ +message _M = {0}; diff --git a/mach/minixST/libsys/syslib.c b/mach/minixST/libsys/syslib.c index 182b296ee..fe86f3b06 100644 --- a/mach/minixST/libsys/syslib.c +++ b/mach/minixST/libsys/syslib.c @@ -1,71 +1,95 @@ -#include -#include -#include +#include #include -#include - -#define FS FS_PROC_NR -#define MM MMPROCNR - -extern message M; - /*---------------------------------------------------------------------------- - Messages to systask (special calls) + Messages to systask (special calls) ----------------------------------------------------------------------------*/ +#if (CHIP == M68000) +PUBLIC _PROTOTYPE( void sys_xit, (int parent, int proc, + phys_clicks *basep, phys_clicks *sizep)); +#else +PUBLIC _PROTOTYPE( void sys_xit, (int parent, int proc)); +#endif +PUBLIC _PROTOTYPE( void sys_getsp, (int proc, vir_bytes *newsp)); +PUBLIC _PROTOTYPE( void sys_sig, (int proc, int sig, void (*sighandler)(int))); +#if (CHIP == M68000) +#ifdef ALCYON_C_BUG_FIXED +PUBLIC _PROTOTYPE( void sys_fork, (int prnt, int chld, int pd, phys_clicks shdw)); +#else +PUBLIC _PROTOTYPE( void sys_fork, (int parent, int child, int pid, int shadow)); +#endif +#else +PUBLIC _PROTOTYPE( void sys_fork, (int parent, int child, int pid)); +#endif +PUBLIC _PROTOTYPE( void sys_exec, (int proc, char *ptr, int traced)); +PUBLIC _PROTOTYPE( void sys_newmap, (int proc, char *ptr)); +PUBLIC _PROTOTYPE( void sys_copy, (message *mptr)); +PUBLIC _PROTOTYPE( void sys_times, (int proc, time_t ptr[4])); +PUBLIC _PROTOTYPE( void sys_abort, (void)); +#if (CHIP == M68000) +PUBLIC _PROTOTYPE( void sys_fresh, (int proc, char *ptr, phys_clicks dc, + phys_clicks *basep, phys_clicks *sizep)); +#endif +PUBLIC _PROTOTYPE( void sys_kill, (int proc, int sig)); +PUBLIC _PROTOTYPE( int sys_trace, (int req, int procnr, + long addr, long *data_p)); +PUBLIC _PROTOTYPE( void tell_fs, ( int what, int p1, int p2, int p3)); -#ifdef ATARI_ST -PUBLIC sys_xit(parent, proc, basep, sizep) + +#if (CHIP == M68000) +PUBLIC void sys_xit(parent, proc, basep, sizep) phys_clicks *basep, *sizep; #else -PUBLIC sys_xit(parent, proc) +PUBLIC void 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; + _callm1(SYSTASK, SYS_XIT, parent, proc, 0, NIL_PTR, NIL_PTR, NIL_PTR); +#if (CHIP == M68000) + *basep = (phys_clicks) _M.m1_i1; + *sizep = (phys_clicks) _M.m1_i2; #endif } -PUBLIC sys_getsp(proc, newsp) +PUBLIC void 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; + _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) +PUBLIC void 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 */ +_PROTOTYPE(void (*sighandler), (int));/* 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); + _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) +#if (CHIP == M68000) +PUBLIC void sys_fork(parent, child, pid, shadow) #ifdef ALCYON_C_BUG_FIXED phys_clicks shadow; /* memory allocated for shadow */ +#else +int shadow; #endif #else -PUBLIC sys_fork(parent, child, pid) +PUBLIC void sys_fork(parent, child, pid) #endif int parent; /* proc doing the fork */ int child; /* which proc has been created by the fork */ @@ -73,69 +97,68 @@ 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); +#if (CHIP == M68000) + _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); + _callm1(SYSTASK, SYS_FORK, parent, child, pid, NIL_PTR, NIL_PTR, NIL_PTR); #endif } -PUBLIC sys_exec(proc, ptr) +PUBLIC void sys_exec(proc, ptr, traced) int proc; /* proc that did exec */ char *ptr; /* new stack pointer */ +int traced; /* is tracing enabled? */ { /* A proc has exec'd. Tell the kernel. */ - callm1(SYSTASK, SYS_EXEC, proc, 0, 0, ptr, NIL_PTR, NIL_PTR); + _callm1(SYSTASK, SYS_EXEC, proc, traced, 0, ptr, NIL_PTR, NIL_PTR); } -PUBLIC sys_newmap(proc, ptr) +PUBLIC void 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); + _callm1(SYSTASK, SYS_NEWMAP, proc, 0, 0, ptr, NIL_PTR, NIL_PTR); } -PUBLIC sys_copy(mptr) +PUBLIC void 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 */ + /* 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); + if (_sendrec(SYSTASK, mptr) != 0) panic("sys_copy can't send", NO_NUM); } -PUBLIC sys_times(proc, ptr) +PUBLIC void sys_times(proc, ptr) int proc; /* proc whose times are needed */ -real_time ptr[4]; /* pointer to time buffer */ +time_t 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; + _callm1(SYSTASK, SYS_TIMES, proc, 0, 0, (char *)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() +PUBLIC void sys_abort() { /* Something awful has happened. Abandon ship. */ - callm1(SYSTASK, SYS_ABORT, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR); + _callm1(SYSTASK, SYS_ABORT, 0, 0, 0, NIL_PTR, NIL_PTR, NIL_PTR); } -#ifdef ATARI_ST -PUBLIC sys_fresh(proc, ptr, dc, basep, sizep) +#if (CHIP == M68000) +PUBLIC void 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 */ @@ -143,30 +166,46 @@ 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; + _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 sys_kill(proc, sig) +PUBLIC void sys_kill(proc, sig) int proc; /* which proc has exited */ int sig; /* signal number: 1 - 16 */ { /* A proc has to be signaled via MM. Tell the kernel. */ - M.m6_i1 = proc; - M.m6_i2 = sig; - callx(SYSTASK, SYS_KILL); + _M.m6_i1 = proc; + _M.m6_i2 = sig; + _callx(SYSTASK, SYS_KILL); } +PUBLIC int sys_trace(req, procnr, addr, data_p) +int req, procnr; +long addr, *data_p; +{ + int r; -PUBLIC int tell_fs(what, p1, p2, p3) + _M.m2_i1 = procnr; + _M.m2_i2 = req; + _M.m2_l1 = addr; + if (data_p) _M.m2_l2 = *data_p; + r = _callx(SYSTASK, SYS_TRACE); + if (data_p) *data_p = _M.m2_l2; + return(r); +} + +PUBLIC void 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(EXEC, proc, 0, 0) * tell_fs(EXIT, proc, 0, 0) * tell_fs(FORK, parent, child, pid) * tell_fs(SETGID, proc, realgid, effgid) @@ -175,5 +214,5 @@ int what, p1, p2, p3; * tell_fs(UNPAUSE, proc, signr, 0) * tell_fs(SETPGRP, proc, 0, 0) */ - callm1(FS, what, p1, p2, p3, NIL_PTR, NIL_PTR, NIL_PTR); + _callm1(FS, what, p1, p2, p3, NIL_PTR, NIL_PTR, NIL_PTR); }