Minix/minix
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Clean up interface to PM and VFS

Browse Source 
- introduce new call numbers, names, and field aliases;
- initialize request messages to zero for all ABI calls;
- format callnr.h in the same way as com.h;
- redo call tables in both servers;
- remove param.h namespace pollution in the servers;
- make brk(2) go to VM directly, rather than through PM;
- remove obsolete BRK, UTIME, and WAIT calls;
- clean up path copying routine in VFS;
- move remaining system calls from libminlib to libc;
- correct some errno-related mistakes in libc routines.

Change-Id: I2d8ec5d061cd7e0b30c51ffd77aa72ebf84e2565
This commit is contained in:
David van Moolenbroek
2013-11-04 22:48:08 +01:00
committed by Lionel Sambuc
parent 2c8310fce6
commit 24ec0d73b5
164 changed files with 1615 additions and 1778 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
lib/libc/gen/minix/utime.c
View File

@@ -1,28 +0,0 @@
/* utime(2) for POSIX Authors: Terrence W. Holm & Edwin L. Froese */
#include <sys/cdefs.h>
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <utime.h>
int utime(const char *name, const struct utimbuf *timp)
{
message m;
if (timp == NULL) {
m.m2_i1 = 0; /* name size 0 means NULL `timp' */
m.m2_i2 = strlen(name) + 1; /* actual size here */
} else {
m.m2_l1 = timp->actime;
m.m2_l2 = timp->modtime;
m.m2_i1 = strlen(name) + 1;
}
m.m2_p1 = (char *) __UNCONST(name);
return(_syscall(VFS_PROC_NR, UTIME, &m));
}
#if defined(__minix) && defined(__weak_alias)
__weak_alias(utime, __utime50)
#endif

8
lib/libc/gen/minix/wait.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <sys/wait.h>
#ifdef __weak_alias
@@ -12,7 +13,10 @@ pid_t wait(int * status)
{
message m;
if (_syscall(PM_PROC_NR, WAIT, &m) < 0) return(-1);
if (status != 0) *status = m.m2_i1;
memset(&m, 0, sizeof(m));
m.PM_WAITPID_PID = -1;
m.PM_WAITPID_OPTIONS = 0;
if (_syscall(PM_PROC_NR, PM_WAITPID, &m) < 0) return(-1);
if (status != 0) *status = m.PM_WAITPID_STATUS;
return(m.m_type);
}

10
lib/libc/gen/minix/waitpid.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <sys/wait.h>
#ifdef __weak_alias
@@ -12,9 +13,10 @@ pid_t waitpid(pid_t pid, int *status, int options)
{
message m;
m.m1_i1 = pid;
m.m1_i2 = options;
if (_syscall(PM_PROC_NR, WAITPID, &m) < 0) return(-1);
if (status != 0) *status = m.m2_i1;
memset(&m, 0, sizeof(m));
m.PM_WAITPID_PID = pid;
m.PM_WAITPID_OPTIONS = options;
if (_syscall(PM_PROC_NR, PM_WAITPID, &m) < 0) return(-1);
if (status != 0) *status = m.PM_WAITPID_STATUS;
return m.m_type;
}

6
lib/libc/sys-minix/Makefile.inc
View File

@@ -4,7 +4,8 @@ SRCS+= accept.c access.c adjtime.c bind.c brk.c sbrk.c m_closefrom.c getsid.c \
chdir.c chmod.c fchmod.c chown.c fchown.c chroot.c close.c \
clock_getres.c clock_gettime.c clock_settime.c \
connect.c dup.c dup2.c execve.c fcntl.c flock.c fpathconf.c fork.c \
fstatfs.c fstatvfs.c fsync.c ftruncate.c getdents.c getegid.c getgid.c \
fstatfs.c fstatvfs.c fsync.c ftruncate.c gcov_flush.c getdents.c \
getegid.c getgid.c \
getgroups.c getitimer.c setitimer.c __getlogin.c getpeername.c \
getpgrp.c getpid.c getppid.c priority.c getrlimit.c getsockname.c \
getsockopt.c setsockopt.c gettimeofday.c geteuid.c getuid.c \
@@ -16,7 +17,8 @@ SRCS+= accept.c access.c adjtime.c bind.c brk.c sbrk.c m_closefrom.c getsid.c \
rmdir.c select.c sem.c sendmsg.c sendto.c setgroups.c setsid.c \
setgid.c settimeofday.c setuid.c shmat.c shmctl.c shmget.c stime.c \
vectorio.c shutdown.c sigaction.c sigpending.c sigreturn.c sigsuspend.c\
sigprocmask.c socket.c socketpair.c stat.c statvfs.c symlink.c \
sigprocmask.c socket.c socketpair.c stat.c statvfs.c svrctl.c \
symlink.c \
sync.c syscall.c sysuname.c truncate.c umask.c unlink.c write.c \
utimensat.c utimes.c futimes.c lutimes.c futimens.c \
_exit.c _ucontext.c environ.c __getcwd.c vfork.c sizeup.c init.c \

6
lib/libc/sys-minix/_exit.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -14,8 +15,9 @@ int status;
void (*suicide)(void);
message m;
m.m1_i1 = status;
_syscall(PM_PROC_NR, EXIT, &m);
memset(&m, 0, sizeof(m));
m.PM_EXIT_STATUS = status;
_syscall(PM_PROC_NR, PM_EXIT, &m);
/* If exiting nicely through PM fails for some reason, try to
* commit suicide. E.g., message to PM might fail due to deadlock.

11
lib/libc/sys-minix/_mcontext.c
View File

@@ -5,6 +5,7 @@
#include <lib.h>
#include <namespace.h>
#include <string.h>
#include <ucontext.h>
#include <unistd.h>
@@ -12,9 +13,10 @@ int setmcontext(const mcontext_t *mcp)
{
message m;
m.m1_p1 = (char *) __UNCONST(mcp);
memset(&m, 0, sizeof(m));
m.PM_MCONTEXT_CTX = (char *) __UNCONST(mcp);
return(_syscall(PM_PROC_NR, SETMCONTEXT, &m));
return(_syscall(PM_PROC_NR, PM_SETMCONTEXT, &m));
}
@@ -22,8 +24,9 @@ int getmcontext(mcontext_t *mcp)
{
message m;
m.m1_p1 = (char *) mcp;
memset(&m, 0, sizeof(m));
m.PM_MCONTEXT_CTX = (char *) mcp;
return(_syscall(PM_PROC_NR, GETMCONTEXT, &m));
return(_syscall(PM_PROC_NR, PM_GETMCONTEXT, &m));
}

6
lib/libc/sys-minix/access.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -14,7 +15,8 @@ int mode;
{
message m;
m.m3_i2 = mode;
memset(&m, 0, sizeof(m));
m.VFS_PATH_MODE = mode;
_loadname(name, &m);
return(_syscall(VFS_PROC_NR, ACCESS, &m));
return(_syscall(VFS_PROC_NR, VFS_ACCESS, &m));
}

12
lib/libc/sys-minix/adjtime.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <sys/time.h>
#include <time.h>
@@ -13,12 +14,13 @@ int adjtime(const struct timeval *delta, struct timeval *olddelta)
{
message m;
m.m2_i2 = 0; /* use adjtime() method to slowly adjust the clock. */
m.m2_i1 = (clockid_t) CLOCK_REALTIME;
m.m2_l1 = (time_t) delta->tv_sec;
m.m2_l2 = (long) delta->tv_usec * 1000; /* convert usec to nsec */
memset(&m, 0, sizeof(m));
m.PM_TIME_CLK_ID = (clockid_t) CLOCK_REALTIME;
m.PM_TIME_NOW = 0; /* use adjtime() method to slowly adjust the clock. */
m.PM_TIME_SEC = (time_t) delta->tv_sec;
m.PM_TIME_NSEC = (long) delta->tv_usec * 1000; /* convert usec to nsec */
if (_syscall(PM_PROC_NR, CLOCK_SETTIME, &m) < 0)
if (_syscall(PM_PROC_NR, PM_CLOCK_SETTIME, &m) < 0)
return -1;
if (olddelta != NULL) {

9
lib/libc/sys-minix/brk.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -13,7 +14,6 @@ extern char *_brksize;
/* Both OSF/1 and SYSVR4 man pages specify that brk(2) returns int.
* However, BSD4.3 specifies that brk() returns char*. POSIX omits
* brk() on the grounds that it imposes a memory model on an architecture.
* For this reason, brk() and sbrk() are not in the lib/posix directory.
* On the other hand, they are so crucial to correct operation of so many
* parts of the system, that we have chosen to hide the name brk using _brk,
* as with system calls. In this way, if a user inadvertently defines a
@@ -25,9 +25,10 @@ void *addr;
message m;
if (addr != _brksize) {
m.PMBRK_ADDR = addr;
if (_syscall(PM_PROC_NR, BRK, &m) < 0) return(-1);
_brksize = m.m2_p1;
memset(&m, 0, sizeof(m));
m.VMB_ADDR = addr;
if (_syscall(VM_PROC_NR, VM_BRK, &m) < 0) return(-1);
_brksize = addr;
}
return(0);
}

9
lib/libc/sys-minix/chdir.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -14,8 +15,9 @@ const char *name;
{
message m;
memset(&m, 0, sizeof(m));
_loadname(name, &m);
return(_syscall(VFS_PROC_NR, CHDIR, &m));
return(_syscall(VFS_PROC_NR, VFS_CHDIR, &m));
}
int fchdir(fd)
@@ -23,6 +25,7 @@ int fd;
{
message m;
m.m1_i1 = fd;
return(_syscall(VFS_PROC_NR, FCHDIR, &m));
memset(&m, 0, sizeof(m));
m.VFS_FCHDIR_FD = fd;
return(_syscall(VFS_PROC_NR, VFS_FCHDIR, &m));
}

6
lib/libc/sys-minix/chmod.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/stat.h>
#ifdef __weak_alias
@@ -12,7 +13,8 @@ int chmod(const char *name, mode_t mode)
{
message m;
m.m3_i2 = mode;
memset(&m, 0, sizeof(m));
m.VFS_PATH_MODE = mode;
_loadname(name, &m);
return(_syscall(VFS_PROC_NR, CHMOD, &m));
return(_syscall(VFS_PROC_NR, VFS_CHMOD, &m));
}

11
lib/libc/sys-minix/chown.c
View File

@@ -13,9 +13,10 @@ int chown(const char *name, uid_t owner, gid_t grp)
{
message m;
m.m1_i1 = strlen(name) + 1;
m.m1_i2 = owner;
m.m1_i3 = grp;
m.m1_p1 = (char *) __UNCONST(name);
return(_syscall(VFS_PROC_NR, CHOWN, &m));
memset(&m, 0, sizeof(m));
m.VFS_CHOWN_LEN = strlen(name) + 1;
m.VFS_CHOWN_OWNER = owner;
m.VFS_CHOWN_GROUP = grp;
m.VFS_CHOWN_NAME = (char *) __UNCONST(name);
return(_syscall(VFS_PROC_NR, VFS_CHOWN, &m));
}

4
lib/libc/sys-minix/chroot.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -13,6 +14,7 @@ const char *name;
{
message m;
memset(&m, 0, sizeof(m));
_loadname(name, &m);
return(_syscall(VFS_PROC_NR, CHROOT, &m));
return(_syscall(VFS_PROC_NR, VFS_CHROOT, &m));
}

10
lib/libc/sys-minix/clock_getres.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <sys/time.h>
#ifdef __weak_alias
@@ -12,13 +13,14 @@ int clock_getres(clockid_t clock_id, struct timespec *res)
{
message m;
m.m2_i1 = (clockid_t) clock_id;
memset(&m, 0, sizeof(m));
m.PM_TIME_CLK_ID = (clockid_t) clock_id;
if (_syscall(PM_PROC_NR, CLOCK_GETRES, &m) < 0)
if (_syscall(PM_PROC_NR, PM_CLOCK_GETRES, &m) < 0)
return -1;
res->tv_sec = (time_t) m.m2_l1;
res->tv_nsec = (long) m.m2_l2;
res->tv_sec = (time_t) m.PM_TIME_SEC;
res->tv_nsec = (long) m.PM_TIME_NSEC;
return 0;
}

10
lib/libc/sys-minix/clock_gettime.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <sys/time.h>
#ifdef __weak_alias
@@ -12,13 +13,14 @@ int clock_gettime(clockid_t clock_id, struct timespec *res)
{
message m;
m.m2_i1 = (clockid_t) clock_id;
memset(&m, 0, sizeof(m));
m.PM_TIME_CLK_ID = (clockid_t) clock_id;
if (_syscall(PM_PROC_NR, CLOCK_GETTIME, &m) < 0)
if (_syscall(PM_PROC_NR, PM_CLOCK_GETTIME, &m) < 0)
return -1;
res->tv_sec = (time_t) m.m2_l1;
res->tv_nsec = (long) m.m2_l2;
res->tv_sec = (time_t) m.PM_TIME_SEC;
res->tv_nsec = (long) m.PM_TIME_USEC;
return 0;
}

12
lib/libc/sys-minix/clock_settime.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <time.h>
#ifdef __weak_alias
@@ -12,12 +13,13 @@ int clock_settime(clockid_t clock_id, const struct timespec *ts)
{
message m;
m.m2_i2 = 1; /* set time immediately. don't use adjtime() method. */
m.m2_i1 = (clockid_t) clock_id;
m.m2_l1 = (time_t) ts->tv_sec;
m.m2_l2 = (long) ts->tv_nsec;
memset(&m, 0, sizeof(m));
m.PM_TIME_CLK_ID = (clockid_t) clock_id;
m.PM_TIME_NOW = 1; /* set time immediately. don't use adjtime() method. */
m.PM_TIME_SEC = (time_t) ts->tv_sec;
m.PM_TIME_NSEC = (long) ts->tv_nsec;
if (_syscall(PM_PROC_NR, CLOCK_SETTIME, &m) < 0)
if (_syscall(PM_PROC_NR, PM_CLOCK_SETTIME, &m) < 0)
return -1;
return 0;

6
lib/libc/sys-minix/close.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -13,6 +14,7 @@ int fd;
{
message m;
m.m1_i1 = fd;
return(_syscall(VFS_PROC_NR, CLOSE, &m));
memset(&m, 0, sizeof(m));
m.VFS_CLOSE_FD = fd;
return(_syscall(VFS_PROC_NR, VFS_CLOSE, &m));
}

4
lib/libc/sys-minix/cprofile.c
View File

@@ -7,17 +7,19 @@ __weak_alias(cprofile, _cprofile)
#endif
#include <lib.h>
#include <string.h>
#include <minix/profile.h>
int cprofile(int action, int size, void *ctl_ptr, void *mem_ptr)
{
message m;
memset(&m, 0, sizeof(m));
m.PROF_ACTION = action;
m.PROF_MEM_SIZE = size;
m.PROF_CTL_PTR = (void *) ctl_ptr;
m.PROF_MEM_PTR = (void *) mem_ptr;
return _syscall(PM_PROC_NR, CPROF, &m);
return _syscall(PM_PROC_NR, PM_CPROF, &m);
}

12
lib/libc/sys-minix/execve.c
View File

@@ -48,13 +48,13 @@ int execve(const char *path, char * const *argv, char * const *envp)
memset(&m, 0, sizeof(m));
/* We can finally make the system call. */
m.m1_i1 = strlen(path) + 1;
m.m1_i2 = frame_size;
m.m1_p1 = (char *) __UNCONST(path);
m.m1_p2 = frame;
m.m1_p4 = (char *)(vsp + ((char *)psp - frame));
m.PM_EXEC_NAME = (char *) __UNCONST(path);
m.PM_EXEC_NAMELEN = strlen(path) + 1;
m.PM_EXEC_FRAME = frame;
m.PM_EXEC_FRAMELEN = frame_size;
m.PM_EXEC_PS_STR = (char *)(vsp + ((char *)psp - frame));
(void) _syscall(PM_PROC_NR, EXEC, &m);
(void) _syscall(PM_PROC_NR, PM_EXEC, &m);
/* Failure, return the memory used for the frame and exit. */
(void) sbrk(-frame_size);

8
lib/libc/sys-minix/fchmod.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/stat.h>
#ifdef __weak_alias
@@ -12,7 +13,8 @@ int fchmod(int fd, mode_t mode)
{
message m;
m.m1_i1 = fd;
m.m1_i2 = mode;
return(_syscall(VFS_PROC_NR, FCHMOD, &m));
memset(&m, 0, sizeof(m));
m.VFS_FCHMOD_FD = fd;
m.VFS_FCHMOD_MODE = mode;
return(_syscall(VFS_PROC_NR, VFS_FCHMOD, &m));
}

9
lib/libc/sys-minix/fchown.c
View File

@@ -13,8 +13,9 @@ int fchown(int fd, uid_t owner, gid_t grp)
{
message m;
m.m1_i1 = fd;
m.m1_i2 = owner;
m.m1_i3 = grp;
return(_syscall(VFS_PROC_NR, FCHOWN, &m));
memset(&m, 0, sizeof(m));
m.VFS_CHOWN_FD = fd;
m.VFS_CHOWN_OWNER = owner;
m.VFS_CHOWN_GROUP = grp;
return(_syscall(VFS_PROC_NR, VFS_FCHOWN, &m));
}

14
lib/libc/sys-minix/fcntl.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <fcntl.h>
#include <stdarg.h>
@@ -19,27 +20,26 @@ int fcntl(int fd, int cmd, ...)
/* Set up for the sensible case where there is no variable parameter. This
* covers F_GETFD, F_GETFL and invalid commands.
*/
m.m1_i3 = 0;
m.m1_p1 = NULL;
memset(&m, 0, sizeof(m));
/* Adjust for the stupid cases. */
switch(cmd) {
case F_DUPFD:
case F_SETFD:
case F_SETFL:
m.m1_i3 = va_arg(argp, int);
m.VFS_FCNTL_ARG_INT = va_arg(argp, int);
break;
case F_GETLK:
case F_SETLK:
case F_SETLKW:
case F_FREESP:
m.m1_p1 = (char *) va_arg(argp, struct flock *);
m.VFS_FCNTL_ARG_PTR = (char *) va_arg(argp, struct flock *);
break;
}
/* Clean up and make the system call. */
va_end(argp);
m.m1_i1 = fd;
m.m1_i2 = cmd;
return(_syscall(VFS_PROC_NR, FCNTL, &m));
m.VFS_FCNTL_FD = fd;
m.VFS_FCNTL_CMD = cmd;
return(_syscall(VFS_PROC_NR, VFS_FCNTL, &m));
}

6
lib/libc/sys-minix/fork.c
View File

@@ -2,15 +2,17 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(fork, _fork)
#endif
pid_t fork()
pid_t fork(void)
{
message m;
return(_syscall(PM_PROC_NR, FORK, &m));
memset(&m, 0, sizeof(m));
return(_syscall(PM_PROC_NR, PM_FORK, &m));
}

10
lib/libc/sys-minix/fstatvfs.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/statvfs.h>
#ifdef __weak_alias
@@ -13,10 +14,11 @@ int fstatvfs1(int fd, struct statvfs *buffer, int flags)
{
message m;
m.VFS_FSTATVFS1_FD = fd;
m.VFS_FSTATVFS1_BUF = (char *) buffer;
m.VFS_FSTATVFS1_FLAGS = flags;
return(_syscall(VFS_PROC_NR, FSTATVFS1, &m));
memset(&m, 0, sizeof(m));
m.VFS_STATVFS1_FD = fd;
m.VFS_STATVFS1_BUF = (char *) buffer;
m.VFS_STATVFS1_FLAGS = flags;
return(_syscall(VFS_PROC_NR, VFS_FSTATVFS1, &m));
}
int fstatvfs(int fd, struct statvfs *buffer)

6
lib/libc/sys-minix/fsync.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -12,7 +13,8 @@ int fsync(int fd)
{
message m;
m.m1_i1 = fd;
memset(&m, 0, sizeof(m));
m.VFS_FSYNC_FD = fd;
return(_syscall(VFS_PROC_NR, FSYNC, &m));
return(_syscall(VFS_PROC_NR, VFS_FSYNC, &m));
}

9
lib/libc/sys-minix/ftruncate.c
View File

@@ -14,9 +14,10 @@ int ftruncate(int _fd, off_t _length)
{
message m;
m.m2_l1 = ex64lo(_length);
m.m2_l2 = ex64hi(_length);
m.m2_i1 = _fd;
memset(&m, 0, sizeof(m));
m.VFS_TRUNCATE_OFF_LO = ex64lo(_length);
m.VFS_TRUNCATE_OFF_HI = ex64hi(_length);
m.VFS_TRUNCATE_FD = _fd;
return(_syscall(VFS_PROC_NR, FTRUNCATE, &m));
return(_syscall(VFS_PROC_NR, VFS_FTRUNCATE, &m));
}

18
lib/libc/sys-minix/futimens.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/stat.h>
int futimens(int fd, const struct timespec tv[2])
@@ -11,13 +12,14 @@ int futimens(int fd, const struct timespec tv[2])
if (tv == NULL) tv = now;
m.m2_i1 = fd;
m.m2_l1 = tv[0].tv_sec;
m.m2_l2 = tv[1].tv_sec;
m.m2_i2 = tv[0].tv_nsec;
m.m2_i3 = tv[1].tv_nsec;
m.m2_p1 = NULL;
m.m2_s1 = 0;
memset(&m, 0, sizeof(m));
m.VFS_UTIMENS_FD = fd;
m.VFS_UTIMENS_ATIME = tv[0].tv_sec;
m.VFS_UTIMENS_MTIME = tv[1].tv_sec;
m.VFS_UTIMENS_ANSEC = tv[0].tv_nsec;
m.VFS_UTIMENS_MNSEC = tv[1].tv_nsec;
m.VFS_UTIMENS_NAME = NULL;
m.VFS_UTIMENS_FLAGS = 0;
return(_syscall(VFS_PROC_NR, UTIMENS, &m));
return(_syscall(VFS_PROC_NR, VFS_UTIMENS, &m));
}

22
lib/libc/sys-minix/futimes.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/time.h>
@@ -13,19 +14,20 @@ int futimes(int fd, const struct timeval tv[2])
{
message m;
m.m2_i1 = fd;
memset(&m, 0, sizeof(m));
m.VFS_UTIMENS_FD = fd;
if (tv == NULL) {
m.m2_l1 = m.m2_l2 = 0;
m.m2_i2 = m.m2_i3 = UTIME_NOW;
m.VFS_UTIMENS_ATIME = m.VFS_UTIMENS_MTIME = 0;
m.VFS_UTIMENS_ANSEC = m.VFS_UTIMENS_MNSEC = UTIME_NOW;
}
else {
m.m2_l1 = tv[0].tv_sec;
m.m2_l2 = tv[1].tv_sec;
m.m2_i2 = tv[0].tv_usec * 1000;
m.m2_i3 = tv[1].tv_usec * 1000;
m.VFS_UTIMENS_ATIME = tv[0].tv_sec;
m.VFS_UTIMENS_MTIME = tv[1].tv_sec;
m.VFS_UTIMENS_ANSEC = tv[0].tv_usec * 1000;
m.VFS_UTIMENS_MNSEC = tv[1].tv_usec * 1000;
}
m.m2_p1 = NULL;
m.m2_s1 = 0;
m.VFS_UTIMENS_NAME = NULL;
m.VFS_UTIMENS_FLAGS = 0;
return(_syscall(VFS_PROC_NR, UTIMENS, &m));
return(_syscall(VFS_PROC_NR, VFS_UTIMENS, &m));
}

19
lib/libc/sys-minix/gcov_flush.c Normal file
View File

@@ -0,0 +1,19 @@
#include <lib.h>
#include <string.h>
#include <minix/gcov.h>
int gcov_flush_svr(char *buff, int buff_sz, int server_nr)
{
message m;
memset(&m, 0, sizeof(m));
m.GCOV_BUFF_P = buff;
m.GCOV_BUFF_SZ = buff_sz;
m.GCOV_PID = server_nr;
/* Make the call to server. It will call the gcov library,
* buffer the stdio requests, and copy the buffer to this user
* space
*/
return _syscall(VFS_PROC_NR, VFS_GCOV_FLUSH, &m);
}

10
lib/libc/sys-minix/getdents.c
View File

@@ -2,16 +2,18 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <dirent.h>
ssize_t getdents(int fd, char *buffer, size_t nbytes)
{
message m;
m.m1_i1 = fd;
m.m1_i2 = nbytes;
m.m1_p1 = (char *) buffer;
return _syscall(VFS_PROC_NR, GETDENTS, &m);
memset(&m, 0, sizeof(m));
m.VFS_READWRITE_FD = fd;
m.VFS_READWRITE_LEN = nbytes;
m.VFS_READWRITE_BUF = (char *) buffer;
return _syscall(VFS_PROC_NR, VFS_GETDENTS, &m);
}
#if defined(__minix) && defined(__weak_alias)

8
lib/libc/sys-minix/getegid.c
View File

@@ -2,21 +2,23 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(getegid, _getegid)
#endif
gid_t getegid()
gid_t getegid(void)
{
message m;
memset(&m, 0, sizeof(m));
/* POSIX says that this function is always successful and that no
* return value is reserved to indicate an error. Minix syscalls
* are not always successful and Minix returns the unreserved value
* (gid_t) -1 when there is an error.
*/
if (_syscall(PM_PROC_NR, GETGID, &m) < 0) return ( (gid_t) -1);
return( (gid_t) m.m2_i1);
if (_syscall(PM_PROC_NR, PM_GETGID, &m) < 0) return ( (gid_t) -1);
return( (gid_t) m.PM_GETGID_EGID);
}

8
lib/libc/sys-minix/geteuid.c
View File

@@ -2,21 +2,23 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(geteuid, _geteuid)
#endif
uid_t geteuid()
uid_t geteuid(void)
{
message m;
memset(&m, 0, sizeof(m));
/* POSIX says that this function is always successful and that no
* return value is reserved to indicate an error. Minix syscalls
* are not always successful and Minix returns the unreserved value
* (uid_t) -1 when there is an error.
*/
if (_syscall(PM_PROC_NR, GETUID, &m) < 0) return ( (uid_t) -1);
return( (uid_t) m.m2_i1);
if (_syscall(PM_PROC_NR, PM_GETUID, &m) < 0) return ( (uid_t) -1);
return( (uid_t) m.PM_GETUID_EUID);
}

6
lib/libc/sys-minix/getgid.c
View File

@@ -2,15 +2,17 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(getgid, _getgid)
#endif
gid_t getgid()
gid_t getgid(void)
{
message m;
return( (gid_t) _syscall(PM_PROC_NR, GETGID, &m));
memset(&m, 0, sizeof(m));
return( (gid_t) _syscall(PM_PROC_NR, PM_GETGID, &m));
}

9
lib/libc/sys-minix/getgroups.c
View File

@@ -6,6 +6,7 @@ getgroups.c
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -16,9 +17,11 @@ __weak_alias(getgroups, _getgroups)
int getgroups(int ngroups, gid_t *arr)
{
message m;
m.m1_i1 = ngroups;
m.m1_p1 = (char *) arr;
return(_syscall(PM_PROC_NR, GETGROUPS, &m));
memset(&m, 0, sizeof(m));
m.PM_GROUPS_NUM = ngroups;
m.PM_GROUPS_PTR = (char *) arr;
return(_syscall(PM_PROC_NR, PM_GETGROUPS, &m));
}

10
lib/libc/sys-minix/getitimer.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/time.h>
/*
@@ -12,11 +13,12 @@ int getitimer(int which, struct itimerval *value)
{
message m;
m.m1_i1 = which;
m.m1_p1 = NULL; /* only retrieve the timer */
m.m1_p2 = (char *) value;
memset(&m, 0, sizeof(m));
m.PM_ITIMER_WHICH = which;
m.PM_ITIMER_VALUE = NULL; /* only retrieve the timer */
m.PM_ITIMER_OVALUE = (char *) value;
return _syscall(PM_PROC_NR, ITIMER, &m);
return _syscall(PM_PROC_NR, PM_ITIMER, &m);
}
#if defined(__minix) && defined(__weak_alias)

6
lib/libc/sys-minix/getpgrp.c
View File

@@ -2,15 +2,17 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(getpgrp, _getpgrp)
#endif
pid_t getpgrp()
pid_t getpgrp(void)
{
message m;
return(_syscall(PM_PROC_NR, GETPGRP, &m));
memset(&m, 0, sizeof(m));
return(_syscall(PM_PROC_NR, PM_GETPGRP, &m));
}

6
lib/libc/sys-minix/getpid.c
View File

@@ -2,15 +2,17 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(getpid, _getpid)
#endif
pid_t getpid()
pid_t getpid(void)
{
message m;
return(_syscall(PM_PROC_NR, MINIX_GETPID, &m));
memset(&m, 0, sizeof(m));
return(_syscall(PM_PROC_NR, PM_GETPID, &m));
}

8
lib/libc/sys-minix/getppid.c
View File

@@ -2,21 +2,23 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(getppid, _getppid)
#endif
pid_t getppid()
pid_t getppid(void)
{
message m;
memset(&m, 0, sizeof(m));
/* POSIX says that this function is always successful and that no
* return value is reserved to indicate an error. Minix syscalls
* are not always successful and Minix returns the reserved value
* (pid_t) -1 when there is an error.
*/
if (_syscall(PM_PROC_NR, MINIX_GETPID, &m) < 0) return ( (pid_t) -1);
return( (pid_t) m.m2_i1);
if (_syscall(PM_PROC_NR, PM_GETPID, &m) < 0) return ( (pid_t) -1);
return( (pid_t) m.PM_GETPID_PARENT);
}

13
lib/libc/sys-minix/getrusage.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#include <sys/resource.h>
@@ -9,8 +10,10 @@ int getrusage(int who, struct rusage *r_usage)
{
int rc;
message m;
memset(&m, 0, sizeof(m));
m.RU_WHO = who;
m.RU_RUSAGE_ADDR = r_usage;
m.RU_RUSAGE_ADDR = (char *) r_usage;
if (r_usage == NULL) {
errno = EFAULT;
@@ -24,9 +27,13 @@ int getrusage(int who, struct rusage *r_usage)
memset(r_usage, 0, sizeof(struct rusage));
if ((rc = _syscall(PM_PROC_NR, PM_GETRUSAGE, &m)) < 0)
return rc;
m.RU_RUSAGE_ADDR = r_usage;
memset(&m, 0, sizeof(m));
m.RU_RUSAGE_ADDR = (char *) r_usage;
if ((rc = _syscall(VFS_PROC_NR, VFS_GETRUSAGE, &m)) < 0)
return rc;
m.RU_RUSAGE_ADDR = r_usage;
memset(&m, 0, sizeof(m));
m.RU_RUSAGE_ADDR = (char *) r_usage;
return _syscall(VM_PROC_NR, VM_GETRUSAGE, &m);
}

9
lib/libc/sys-minix/gettimeofday.c
View File

@@ -6,6 +6,7 @@ gettimeofday.c
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/time.h>
#ifdef __weak_alias
@@ -16,11 +17,13 @@ int gettimeofday(struct timeval *__restrict tp, void *__restrict tzp)
{
message m;
if (_syscall(PM_PROC_NR, GETTIMEOFDAY, &m) < 0)
memset(&m, 0, sizeof(m));
if (_syscall(PM_PROC_NR, PM_GETTIMEOFDAY, &m) < 0)
return -1;
tp->tv_sec = m.m2_l1;
tp->tv_usec = m.m2_l2;
tp->tv_sec = m.PM_TIME_SEC;
tp->tv_usec = m.PM_TIME_USEC;
return 0;
}

6
lib/libc/sys-minix/getuid.c
View File

@@ -2,15 +2,17 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(getuid, _getuid)
#endif
uid_t getuid()
uid_t getuid(void)
{
message m;
return( (uid_t) _syscall(PM_PROC_NR, GETUID, &m));
memset(&m, 0, sizeof(m));
return( (uid_t) _syscall(PM_PROC_NR, PM_GETUID, &m));
}

6
lib/libc/sys-minix/getvfsstat.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <sys/statvfs.h>
#ifdef __weak_alias
@@ -12,8 +13,9 @@ int getvfsstat(struct statvfs *buf, size_t bufsize, int flags)
{
message m;
memset(&m, 0, sizeof(m));
m.VFS_GETVFSSTAT_BUF = (char *) buf;
m.VFS_GETVFSSTAT_SIZE = bufsize;
m.VFS_GETVFSSTAT_LEN = bufsize;
m.VFS_GETVFSSTAT_FLAGS = flags;
return(_syscall(VFS_PROC_NR, GETVFSSTAT, &m));
return(_syscall(VFS_PROC_NR, VFS_GETVFSSTAT, &m));
}

3
lib/libc/sys-minix/ioctl.c
View File

@@ -73,11 +73,12 @@ void *data;
break;
}
memset(&m, 0, sizeof(m));
m.VFS_IOCTL_FD = fd;
m.VFS_IOCTL_REQ = request;
m.VFS_IOCTL_ARG = (char *) addr;
r = _syscall(VFS_PROC_NR, IOCTL, &m);
r = _syscall(VFS_PROC_NR, VFS_IOCTL, &m);
/* Translate back to original form */
switch (request_save) {

7
lib/libc/sys-minix/issetugid.c
View File

@@ -2,14 +2,13 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
int issetugid(void)
{
int r;
message m;
r = _syscall(PM_PROC_NR, ISSETUGID, &m);
if (r == -1) return 0; /* Default to old behavior */
return(r);
memset(&m, 0, sizeof(m));
return _syscall(PM_PROC_NR, PM_ISSETUGID, &m);
}

10
lib/libc/sys-minix/kill.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <signal.h>
#ifdef __weak_alias
@@ -9,12 +10,13 @@ __weak_alias(kill, _kill)
#endif
int kill(proc, sig)
int proc; /* which process is to be sent the signal */
pid_t proc; /* which process is to be sent the signal */
int sig; /* signal number */
{
message m;
m.m1_i1 = proc;
m.m1_i2 = sig;
return(_syscall(PM_PROC_NR, KILL, &m));
memset(&m, 0, sizeof(m));
m.PM_SIG_PID = proc;
m.PM_SIG_NR = sig;
return(_syscall(PM_PROC_NR, PM_KILL, &m));
}

11
lib/libc/sys-minix/link.c
View File

@@ -13,9 +13,10 @@ int link(const char *name, const char *name2)
{
message m;
m.m1_i1 = strlen(name) + 1;
m.m1_i2 = strlen(name2) + 1;
m.m1_p1 = (char *) __UNCONST(name);
m.m1_p2 = (char *) __UNCONST(name2);
return(_syscall(VFS_PROC_NR, LINK, &m));
memset(&m, 0, sizeof(m));
m.VFS_LINK_LEN1 = strlen(name) + 1;
m.VFS_LINK_LEN2 = strlen(name2) + 1;
m.VFS_LINK_NAME1 = (char *) __UNCONST(name);
m.VFS_LINK_NAME2 = (char *) __UNCONST(name2);
return(_syscall(VFS_PROC_NR, VFS_LINK, &m));
}

7
lib/libc/sys-minix/loadname.c
View File

@@ -10,11 +10,10 @@ void _loadname(const char *name, message *msgptr)
* string fits in the message, it is copied there. If not, a pointer to
* it is passed.
*/
register size_t k;
k = strlen(name) + 1;
msgptr->m3_i1 = k;
msgptr->m3_p1 = (char *) __UNCONST(name);
if (k <= M3_STRING) strcpy(msgptr->m3_ca1, name);
msgptr->VFS_PATH_LEN = k;
msgptr->VFS_PATH_NAME = (char *) __UNCONST(name);
if (k <= M3_STRING) strcpy(msgptr->VFS_PATH_BUF, name);
}

17
lib/libc/sys-minix/lseek.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <minix/u64.h>
#include <unistd.h>
@@ -14,13 +15,11 @@ lseek(int fd, off_t offset, int whence)
{
message m;
m.m2_i1 = fd;
m.m2_l1 = ex64lo(offset);
m.m2_l2 = ex64hi(offset);
m.m2_i2 = whence;
if (_syscall(VFS_PROC_NR, LSEEK, &m) < 0)
return( (off_t) -1);
return( (off_t) make64(m.m2_l1, m.m2_l2));
memset(&m, 0, sizeof(m));
m.VFS_LSEEK_FD = fd;
m.VFS_LSEEK_OFF_LO = ex64lo(offset);
m.VFS_LSEEK_OFF_HI = ex64hi(offset);
m.VFS_LSEEK_WHENCE = whence;
if (_syscall(VFS_PROC_NR, VFS_LSEEK, &m) < 0) return( (off_t) -1);
return( (off_t) make64(m.VFS_LSEEK_OFF_LO, m.VFS_LSEEK_OFF_HI));
}

14
lib/libc/sys-minix/lseek64.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#include <minix/u64.h>
@@ -13,12 +14,13 @@ u64_t *newpos;
{
message m;
m.m2_i1 = fd;
m.m2_l1 = ex64lo(offset);
m.m2_l2 = ex64hi(offset);
m.m2_i2 = whence;
if (_syscall(VFS_PROC_NR, LLSEEK, &m) < 0) return -1;
memset(&m, 0, sizeof(m));
m.VFS_LSEEK_FD = fd;
m.VFS_LSEEK_OFF_LO = ex64lo(offset);
m.VFS_LSEEK_OFF_HI = ex64hi(offset);
m.VFS_LSEEK_WHENCE = whence;
if (_syscall(VFS_PROC_NR, VFS_LSEEK, &m) < 0) return -1;
if (newpos)
*newpos= make64(m.m2_l1, m.m2_l2);
*newpos= make64(m.VFS_LSEEK_OFF_LO, m.VFS_LSEEK_OFF_HI);
return 0;
}

31
lib/libc/sys-minix/lutimes.c
View File

@@ -16,21 +16,28 @@ int lutimes(const char *name, const struct timeval tv[2])
{
message m;
if (name == NULL) return EINVAL;
if (name[0] == '\0') return ENOENT; /* X/Open requirement */
m.m2_i1 = strlen(name) + 1;
m.m2_p1 = (char *) __UNCONST(name);
if (name == NULL) {
errno = EINVAL;
return -1;
}
if (name[0] == '\0') { /* X/Open requirement */
errno = ENOENT;
return -1;
}
memset(&m, 0, sizeof(m));
m.VFS_UTIMENS_FD = strlen(name) + 1;
m.VFS_UTIMENS_NAME = (char *) __UNCONST(name);
if (tv == NULL) {
m.m2_l1 = m.m2_l2 = 0;
m.m2_i2 = m.m2_i3 = UTIME_NOW;
m.VFS_UTIMENS_ATIME = m.VFS_UTIMENS_MTIME = 0;
m.VFS_UTIMENS_ANSEC = m.VFS_UTIMENS_MNSEC = UTIME_NOW;
}
else {
m.m2_l1 = tv[0].tv_sec;
m.m2_l2 = tv[1].tv_sec;
m.m2_i2 = tv[0].tv_usec * 1000;
m.m2_i3 = tv[1].tv_usec * 1000;
m.VFS_UTIMENS_ATIME = tv[0].tv_sec;
m.VFS_UTIMENS_MTIME = tv[1].tv_sec;
m.VFS_UTIMENS_ANSEC = tv[0].tv_usec * 1000;
m.VFS_UTIMENS_MNSEC = tv[1].tv_usec * 1000;
}
m.m2_s1 = AT_SYMLINK_NOFOLLOW;
m.VFS_UTIMENS_FLAGS = AT_SYMLINK_NOFOLLOW;
return(_syscall(VFS_PROC_NR, UTIMENS, &m));
return(_syscall(VFS_PROC_NR, VFS_UTIMENS, &m));
}

2
lib/libc/sys-minix/minix_rs.c
View File

@@ -2,7 +2,6 @@
#include <sys/cdefs.h>
#include <minix/callnr.h>
#include <minix/com.h>
#include <minix/config.h>
#include <minix/ipc.h>
@@ -27,6 +26,7 @@ int minix_rs_lookup(const char *name, endpoint_t *value)
len_key = strlen(name)+1;
memset(&m, 0, sizeof(m));
m.RS_NAME = (char *) __UNCONST(name);
m.RS_NAME_LEN = len_key;

8
lib/libc/sys-minix/mkdir.c
View File

@@ -13,8 +13,8 @@ int mkdir(const char *name, mode_t mode)
{
message m;
m.m1_i1 = strlen(name) + 1;
m.m1_i2 = mode;
m.m1_p1 = (char *) __UNCONST(name);
return(_syscall(VFS_PROC_NR, MKDIR, &m));
memset(&m, 0, sizeof(m));
m.VFS_PATH_MODE = mode;
_loadname(name, &m);
return(_syscall(VFS_PROC_NR, VFS_MKDIR, &m));
}

12
lib/libc/sys-minix/mknod.c
View File

@@ -11,12 +11,12 @@ int mknod(const char *name, mode_t mode, dev_t dev)
{
message m;
m.m1_i1 = strlen(name) + 1;
m.m1_i2 = mode;
m.m1_i3 = dev;
m.m1_p1 = (char *) __UNCONST(name);
m.m1_p2 = (char *) ((int) 0); /* obsolete size field */
return(_syscall(VFS_PROC_NR, MKNOD, &m));
memset(&m, 0, sizeof(m));
m.VFS_MKNOD_LEN = strlen(name) + 1;
m.VFS_MKNOD_MODE = mode;
m.VFS_MKNOD_DEV = dev;
m.VFS_MKNOD_NAME = (char *) __UNCONST(name);
return(_syscall(VFS_PROC_NR, VFS_MKNOD, &m));
}
#if defined(__minix) && defined(__weak_alias)

7
lib/libc/sys-minix/mmap.c
View File

@@ -28,6 +28,7 @@ void *minix_mmap_for(endpoint_t forwhom,
message m;
int r;
memset(&m, 0, sizeof(m));
m.VMM_ADDR = (vir_bytes) addr;
m.VMM_LEN = len;
m.VMM_PROT = prot;
@@ -87,6 +88,7 @@ int minix_munmap(void *addr, size_t len)
{
message m;
memset(&m, 0, sizeof(m));
m.VMUM_ADDR = addr;
m.VMUM_LEN = len;
@@ -103,6 +105,7 @@ void *vm_remap(endpoint_t d,
message m;
int r;
memset(&m, 0, sizeof(m));
m.VMRE_D = d;
m.VMRE_S = s;
m.VMRE_DA = (char *) da;
@@ -124,6 +127,7 @@ void *vm_remap_ro(endpoint_t d,
message m;
int r;
memset(&m, 0, sizeof(m));
m.VMRE_D = d;
m.VMRE_S = s;
m.VMRE_DA = (char *) da;
@@ -140,6 +144,7 @@ int vm_unmap(endpoint_t endpt, void *addr)
{
message m;
memset(&m, 0, sizeof(m));
m.VMUN_ENDPT = endpt;
m.VMUN_ADDR = (long) addr;
@@ -151,6 +156,7 @@ unsigned long vm_getphys(endpoint_t endpt, void *addr)
message m;
int r;
memset(&m, 0, sizeof(m));
m.VMPHYS_ENDPT = endpt;
m.VMPHYS_ADDR = (long) addr;
@@ -165,6 +171,7 @@ u8_t vm_getrefcount(endpoint_t endpt, void *addr)
message m;
int r;
memset(&m, 0, sizeof(m));
m.VMREFCNT_ENDPT = endpt;
m.VMREFCNT_ADDR = (long) addr;

6
lib/libc/sys-minix/mount.c
View File

@@ -148,6 +148,7 @@ int mountflags, srvflags;
}
/* Now perform mount(). */
memset(&m, 0, sizeof(m));
m.VFS_MOUNT_FLAGS = mountflags;
m.VFS_MOUNT_DEVLEN = special ? strlen(special) + 1 : 0;
m.VFS_MOUNT_PATHLEN = strlen(name) + 1;
@@ -157,7 +158,7 @@ int mountflags, srvflags;
m.VFS_MOUNT_PATH = name;
m.VFS_MOUNT_TYPE = type;
m.VFS_MOUNT_LABEL = label;
r = _syscall(VFS_PROC_NR, MOUNT, &m);
r = _syscall(VFS_PROC_NR, VFS_MOUNT, &m);
if (r != OK && !use_existing) {
/* If mount() failed, tell RS to shutdown FS process.
@@ -177,11 +178,12 @@ int srvflags;
message m;
int r;
memset(&m, 0, sizeof(m));
m.VFS_UMOUNT_NAME = __UNCONST(name);
m.VFS_UMOUNT_NAMELEN = strlen(name) + 1;
m.VFS_UMOUNT_LABEL = label;
m.VFS_UMOUNT_LABELLEN = sizeof(label);
r = _syscall(VFS_PROC_NR, UMOUNT, &m);
r = _syscall(VFS_PROC_NR, VFS_UMOUNT, &m);
/* don't shut down the driver when exist flag is set */
if (!(srvflags & MS_EXISTING)) {

12
lib/libc/sys-minix/nanosleep.c
View File

@@ -26,13 +26,17 @@ int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
struct timespec rqt;
/* check parameters */
if (!rqtp)
return EFAULT;
if (!rqtp) {
errno = EFAULT;
return -1;
}
if (rqtp->tv_sec < 0 ||
rqtp->tv_nsec < 0 ||
rqtp->tv_nsec >= NSEC_PER_SEC)
return EINVAL;
rqtp->tv_nsec >= NSEC_PER_SEC) {
errno = EINVAL;
return -1;
}
/* store *rqtp to make sure it is not overwritten */
rqt = *rqtp;

22
lib/libc/sys-minix/open.c
View File

@@ -14,20 +14,24 @@ int open(const char *name, int flags, ...)
{
va_list argp;
message m;
int call;
memset(&m, 0, sizeof(m));
va_start(argp, flags);
/* Depending on whether O_CREAT is set, a different message layout is used,
* and therefore a different call number as well.
*/
if (flags & O_CREAT) {
m.m1_i1 = strlen(name) + 1;
m.m1_i2 = flags;
/* Since it's a vararg parameter that is smaller than
* an int, the mode was passed as an int.
*/
m.m1_i3 = va_arg(argp, int);
m.m1_p1 = (char *) __UNCONST(name);
m.VFS_CREAT_LEN = strlen(name) + 1;
m.VFS_CREAT_FLAGS = flags;
m.VFS_CREAT_MODE = va_arg(argp, int);
m.VFS_CREAT_NAME = (char *) __UNCONST(name);
call = VFS_CREAT;
} else {
_loadname(name, &m);
m.m3_i2 = flags;
m.VFS_PATH_FLAGS = flags;
call = VFS_OPEN;
}
va_end(argp);
return (_syscall(VFS_PROC_NR, OPEN, &m));
return (_syscall(VFS_PROC_NR, call, &m));
}

27
lib/libc/sys-minix/pipe.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -9,26 +10,22 @@ __weak_alias(pipe, _pipe)
__weak_alias(pipe2, _pipe2)
#endif
int
pipe(int fild[2])
{
message m;
if (_syscall(VFS_PROC_NR, PIPE, &m) < 0) return(-1);
fild[0] = m.m1_i1;
fild[1] = m.m1_i2;
return(0);
}
int
pipe2(int fild[2], int flags)
{
message m;
m.m1_i3 = flags;
memset(&m, 0, sizeof(m));
m.VFS_PIPE2_FLAGS = flags;
if (_syscall(VFS_PROC_NR, PIPE2, &m) < 0) return(-1);
fild[0] = m.m1_i1;
fild[1] = m.m1_i2;
if (_syscall(VFS_PROC_NR, VFS_PIPE2, &m) < 0) return(-1);
fild[0] = m.VFS_PIPE2_FD0;
fild[1] = m.VFS_PIPE2_FD1;
return(0);
}
int
pipe(int fild[2])
{
return pipe2(fild, 0);
}

16
lib/libc/sys-minix/priority.c
View File

@@ -18,8 +18,9 @@ int getpriority(int which, int who)
int v;
message m;
m.m1_i1 = which;
m.m1_i2 = who;
memset(&m, 0, sizeof(m));
m.PM_PRIORITY_WHICH = which;
m.PM_PRIORITY_WHO = who;
/* GETPRIORITY returns negative for error.
* Otherwise, it returns the priority plus the minimum
@@ -28,7 +29,7 @@ int getpriority(int which, int who)
* to see if something really went wrong.)
*/
if((v = _syscall(PM_PROC_NR, GETPRIORITY, &m)) < 0) {
if((v = _syscall(PM_PROC_NR, PM_GETPRIORITY, &m)) < 0) {
return v;
}
@@ -39,10 +40,11 @@ int setpriority(int which, int who, int prio)
{
message m;
m.m1_i1 = which;
m.m1_i2 = who;
m.m1_i3 = prio;
memset(&m, 0, sizeof(m));
m.PM_PRIORITY_WHICH = which;
m.PM_PRIORITY_WHO = who;
m.PM_PRIORITY_PRIO = prio;
return _syscall(PM_PROC_NR, SETPRIORITY, &m);
return _syscall(PM_PROC_NR, PM_SETPRIORITY, &m);
}

16
lib/libc/sys-minix/ptrace.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/ptrace.h>
#ifdef __weak_alias
@@ -12,16 +13,17 @@ long ptrace(int req, pid_t pid, long addr, long data)
{
message m;
m.m2_i1 = pid;
m.m2_i2 = req;
m.PMTRACE_ADDR = addr;
m.m2_l2 = data;
if (_syscall(PM_PROC_NR, PTRACE, &m) < 0) return(-1);
memset(&m, 0, sizeof(m));
m.PM_PTRACE_PID = pid;
m.PM_PTRACE_REQ = req;
m.PM_PTRACE_ADDR = addr;
m.PM_PTRACE_DATA = data;
if (_syscall(PM_PROC_NR, PM_PTRACE, &m) < 0) return(-1);
/* There was no error, but -1 is a legal return value. Clear errno if
* necessary to distinguish this case. _syscall has set errno to nonzero
* for the error case.
*/
if (m.m2_l2 == -1) errno = 0;
return(m.m2_l2);
if (m.PM_PTRACE_DATA == -1) errno = 0;
return(m.PM_PTRACE_DATA);
}

10
lib/libc/sys-minix/read.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -12,8 +13,9 @@ ssize_t read(int fd, void *buffer, size_t nbytes)
{
message m;
m.m1_i1 = fd;
m.m1_i2 = nbytes;
m.m1_p1 = (char *) buffer;
return(_syscall(VFS_PROC_NR, READ, &m));
memset(&m, 0, sizeof(m));
m.VFS_READWRITE_FD = fd;
m.VFS_READWRITE_LEN = nbytes;
m.VFS_READWRITE_BUF = (char *) buffer;
return(_syscall(VFS_PROC_NR, VFS_READ, &m));
}

11
lib/libc/sys-minix/readlink.c
View File

@@ -13,10 +13,11 @@ ssize_t readlink(const char *name, char *buffer, size_t bufsiz)
{
message m;
m.m1_i1 = strlen(name) + 1;
m.m1_i2 = bufsiz;
m.m1_p1 = (char *) __UNCONST(name);
m.m1_p2 = (char *) buffer;
memset(&m, 0, sizeof(m));
m.VFS_READLINK_NAMELEN = strlen(name) + 1;
m.VFS_READLINK_BUFSIZE = bufsiz;
m.VFS_READLINK_NAME = (char *) __UNCONST(name);
m.VFS_READLINK_BUF = (char *) buffer;
return(_syscall(VFS_PROC_NR, RDLNK, &m));
return(_syscall(VFS_PROC_NR, VFS_READLINK, &m));
}

10
lib/libc/sys-minix/reboot.c
View File

@@ -1,4 +1,4 @@
/* reboot.c - Systemcall interface to mm/signal.c::do_reboot()
/* reboot.c
author: Edvard Tuinder v892231@si.hhs.NL
*/
@@ -8,14 +8,14 @@
#include <unistd.h>
#include "namespace.h"
#include <unistd.h>
#include <string.h>
#include <sys/reboot.h>
#include <stdarg.h>
int reboot(int how)
{
message m;
m.m1_i1 = how;
return _syscall(PM_PROC_NR, REBOOT, &m);
memset(&m, 0, sizeof(m));
m.PM_REBOOT_HOW = how;
return _syscall(PM_PROC_NR, PM_REBOOT, &m);
}

11
lib/libc/sys-minix/rename.c
View File

@@ -9,9 +9,10 @@ int rename(const char *name, const char *name2)
{
message m;
m.m1_i1 = strlen(name) + 1;
m.m1_i2 = strlen(name2) + 1;
m.m1_p1 = (char *) __UNCONST(name);
m.m1_p2 = (char *) __UNCONST(name2);
return(_syscall(VFS_PROC_NR, RENAME, &m));
memset(&m, 0, sizeof(m));
m.VFS_LINK_LEN1 = strlen(name) + 1;
m.VFS_LINK_LEN2 = strlen(name2) + 1;
m.VFS_LINK_NAME1 = (char *) __UNCONST(name);
m.VFS_LINK_NAME2 = (char *) __UNCONST(name2);
return(_syscall(VFS_PROC_NR, VFS_RENAME, &m));
}

4
lib/libc/sys-minix/rmdir.c
View File

@@ -6,6 +6,7 @@
__weak_alias(rmdir, _rmdir)
#endif
#include <string.h>
#include <unistd.h>
int rmdir(name)
@@ -13,6 +14,7 @@ const char *name;
{
message m;
memset(&m, 0, sizeof(m));
_loadname(name, &m);
return(_syscall(VFS_PROC_NR, RMDIR, &m));
return(_syscall(VFS_PROC_NR, VFS_RMDIR, &m));
}

14
lib/libc/sys-minix/select.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <sys/time.h>
#include <sys/select.h>
@@ -11,13 +12,14 @@ int select(int nfds,
{
message m;
m.SEL_NFDS = nfds;
m.SEL_READFDS = (char *) readfds;
m.SEL_WRITEFDS = (char *) writefds;
m.SEL_ERRORFDS = (char *) errorfds;
m.SEL_TIMEOUT = (char *) timeout;
memset(&m, 0, sizeof(m));
m.VFS_SELECT_NFDS = nfds;
m.VFS_SELECT_READFDS = (char *) readfds;
m.VFS_SELECT_WRITEFDS = (char *) writefds;
m.VFS_SELECT_ERRORFDS = (char *) errorfds;
m.VFS_SELECT_TIMEOUT = (char *) timeout;
return (_syscall(VFS_PROC_NR, SELECT, &m));
return (_syscall(VFS_PROC_NR, VFS_SELECT, &m));
}

4
lib/libc/sys-minix/sem.c
View File

@@ -14,6 +14,7 @@
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <string.h>
static int get_ipc_endpt(endpoint_t *pt)
{
@@ -32,6 +33,7 @@ int semget(key_t key, int nsems, int semflag)
return -1;
}
memset(&m, 0, sizeof(m));
m.SEMGET_KEY = key;
m.SEMGET_NR = nsems;
m.SEMGET_FLAG = semflag;
@@ -56,6 +58,7 @@ int semctl(int semid, int semnum, int cmd, ...)
return -1;
}
memset(&m, 0, sizeof(m));
m.SEMCTL_ID = semid;
m.SEMCTL_NUM = semnum;
m.SEMCTL_CMD = cmd;
@@ -85,6 +88,7 @@ int semop(int semid, struct sembuf *sops, size_t nsops)
return -1;
}
memset(&m, 0, sizeof(m));
m.SEMOP_ID = semid;
m.SEMOP_OPS = (long) sops;
m.SEMOP_SIZE = nsops;

12
lib/libc/sys-minix/setgid.c
View File

@@ -2,6 +2,8 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#ifdef __weak_alias
__weak_alias(setgid, _setgid)
__weak_alias(setegid, _setegid)
@@ -13,14 +15,16 @@ int setgid(gid_t grp)
{
message m;
m.m1_i1 = (int) grp;
return(_syscall(PM_PROC_NR, SETGID, &m));
memset(&m, 0, sizeof(m));
m.PM_SETGID_GID = (int) grp;
return(_syscall(PM_PROC_NR, PM_SETGID, &m));
}
int setegid(gid_t grp)
{
message m;
m.m1_i1 = (int) grp;
return(_syscall(PM_PROC_NR, SETEGID, &m));
memset(&m, 0, sizeof(m));
m.PM_SETGID_GID = (int) grp;
return(_syscall(PM_PROC_NR, PM_SETEGID, &m));
}

11
lib/libc/sys-minix/setgroups.c
View File

@@ -2,6 +2,8 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#ifdef __weak_alias
__weak_alias(setgroups, _setgroups)
#endif
@@ -12,10 +14,9 @@ int setgroups(int ngroups, const gid_t *gidset)
{
message m;
m.m1_p1 = (char *) __UNCONST(gidset);
m.m1_i1 = ngroups;
memset(&m, 0, sizeof(m));
m.PM_GROUPS_PTR = (char *) __UNCONST(gidset);
m.PM_GROUPS_NUM = ngroups;
return(_syscall(PM_PROC_NR, SETGROUPS, &m));
return(_syscall(PM_PROC_NR, PM_SETGROUPS, &m));
}

15
lib/libc/sys-minix/setitimer.c
View File

@@ -2,6 +2,7 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/time.h>
/*
@@ -16,13 +17,17 @@ int setitimer(int which, const struct itimerval *__restrict value,
/* A null pointer for 'value' would make setitimer behave like getitimer,
* which is not according to the specification, so disallow null pointers.
*/
if (value == NULL) return(EINVAL);
if (value == NULL) {
errno = EINVAL;
return -1;
}
m.m1_i1 = which;
m.m1_p1 = (char *) __UNCONST(value);
m.m1_p2 = (char *) ovalue;
memset(&m, 0, sizeof(m));
m.PM_ITIMER_WHICH = which;
m.PM_ITIMER_VALUE = (char *) __UNCONST(value);
m.PM_ITIMER_OVALUE = (char *) ovalue;
return _syscall(PM_PROC_NR, ITIMER, &m);
return _syscall(PM_PROC_NR, PM_ITIMER, &m);
}
#if defined(__minix) && defined(__weak_alias)

6
lib/libc/sys-minix/setsid.c
View File

@@ -2,15 +2,17 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(setsid, _setsid)
#endif
pid_t setsid()
pid_t setsid(void)
{
message m;
return(_syscall(PM_PROC_NR, SETSID, &m));
memset(&m, 0, sizeof(m));
return(_syscall(PM_PROC_NR, PM_SETSID, &m));
}

11
lib/libc/sys-minix/setuid.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -13,14 +14,16 @@ int setuid(uid_t usr)
{
message m;
m.m1_i1 = usr;
return(_syscall(PM_PROC_NR, SETUID, &m));
memset(&m, 0, sizeof(m));
m.PM_SETUID_UID = usr;
return(_syscall(PM_PROC_NR, PM_SETUID, &m));
}
int seteuid(uid_t usr)
{
message m;
m.m1_i1 = usr;
return(_syscall(PM_PROC_NR, SETEUID, &m));
memset(&m, 0, sizeof(m));
m.PM_SETUID_UID = usr;
return(_syscall(PM_PROC_NR, PM_SETEUID, &m));
}

3
lib/libc/sys-minix/shmat.c
View File

@@ -12,6 +12,7 @@
#include <sys/shm.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#ifdef __weak_alias
__weak_alias(shmat, _shmat)
@@ -36,6 +37,7 @@ void *shmat(int shmid, const void *shmaddr, int shmflg)
return NULL;
}
memset(&m, 0, sizeof(m));
m.SHMAT_ID = shmid;
m.SHMAT_ADDR = (long) shmaddr;
m.SHMAT_FLAG = shmflg;
@@ -57,6 +59,7 @@ int shmdt(const void *shmaddr)
return -1;
}
memset(&m, 0, sizeof(m));
m.SHMDT_ADDR = (long) shmaddr;
return _syscall(ipc_pt, IPC_SHMDT, &m);

2
lib/libc/sys-minix/shmctl.c
View File

@@ -11,6 +11,7 @@
#include <sys/shm.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
static int get_ipc_endpt(endpoint_t *pt)
{
@@ -29,6 +30,7 @@ int shmctl(int shmid, int cmd, struct shmid_ds *buf)
return -1;
}
memset(&m, 0, sizeof(m));
m.SHMCTL_ID = shmid;
m.SHMCTL_CMD = cmd;
m.SHMCTL_BUF = (long) buf;

3
lib/libc/sys-minix/shmget.c
View File

@@ -10,7 +10,7 @@
#include <sys/shm.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#ifdef __weak_alias
__weak_alias(shmget, _shmget)
@@ -33,6 +33,7 @@ int shmget(key_t key, size_t size, int shmflg)
return -1;
}
memset(&m, 0, sizeof(m));
m.SHMGET_KEY = key;
m.SHMGET_SIZE = size;
m.SHMGET_FLAG = shmflg;

13
lib/libc/sys-minix/sigaction.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <signal.h>
int __sigreturn(void);
@@ -10,13 +11,13 @@ int sigaction(int sig, const struct sigaction *act, struct sigaction *oact)
{
message m;
m.m1_i2 = sig;
memset(&m, 0, sizeof(m));
m.PM_SIG_NR = sig;
m.PM_SIG_ACT = (char *) __UNCONST(act);
m.PM_SIG_OACT = (char *) oact;
m.PM_SIG_RET = (char *) __sigreturn;
m.m1_p1 = (char *) __UNCONST(act);
m.m1_p2 = (char *) oact;
m.m1_p3 = (char *) __sigreturn;
return(_syscall(PM_PROC_NR, SIGACTION, &m));
return(_syscall(PM_PROC_NR, PM_SIGACTION, &m));
}
#if defined(__minix) && defined(__weak_alias)

6
lib/libc/sys-minix/sigpending.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <signal.h>
int sigpending(set)
@@ -9,8 +10,9 @@ sigset_t *set;
{
message m;
if (_syscall(PM_PROC_NR, SIGPENDING, &m) < 0) return(-1);
*set = (sigset_t) m.m2_l1;
memset(&m, 0, sizeof(m));
if (_syscall(PM_PROC_NR, PM_SIGPENDING, &m) < 0) return(-1);
*set = (sigset_t) m.PM_SIG_SET;
return(m.m_type);
}

14
lib/libc/sys-minix/sigprocmask.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <signal.h>
int sigprocmask(how, set, oset)
@@ -11,15 +12,16 @@ sigset_t *oset;
{
message m;
memset(&m, 0, sizeof(m));
if (set == (sigset_t *) NULL) {
m.m2_i1 = SIG_INQUIRE;
m.m2_l1 = 0;
m.PM_SIG_HOW = SIG_INQUIRE;
m.PM_SIG_SET = 0;
} else {
m.m2_i1 = how;
m.m2_l1 = (long) *set;
m.PM_SIG_HOW = how;
m.PM_SIG_SET = (long) *set;
}
if (_syscall(PM_PROC_NR, SIGPROCMASK, &m) < 0) return(-1);
if (oset != (sigset_t *) NULL) *oset = (sigset_t) (m.m2_l1);
if (_syscall(PM_PROC_NR, PM_SIGPROCMASK, &m) < 0) return(-1);
if (oset != (sigset_t *) NULL) *oset = (sigset_t) (m.PM_SIG_SET);
return(m.m_type);
}

9
lib/libc/sys-minix/sigreturn.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <signal.h>
#include <sys/signal.h>
@@ -25,8 +26,8 @@ register struct sigcontext *scp;
sigfillset(&set); /* splhi */
sigprocmask(SIG_SETMASK, &set, (sigset_t *) NULL);
m.m2_l1 = scp->sc_mask;
m.m2_i2 = scp->sc_flags;
m.m2_p1 = (char *) scp;
return(_syscall(PM_PROC_NR, SIGRETURN, &m)); /* normally this doesn't return */
memset(&m, 0, sizeof(m));
m.PM_SIG_SET = scp->sc_mask;
m.PM_SIG_CTX = (char *) scp;
return(_syscall(PM_PROC_NR, PM_SIGRETURN, &m)); /* normally doesn't return */
}

6
lib/libc/sys-minix/sigsuspend.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <signal.h>
int sigsuspend(set)
@@ -9,8 +10,9 @@ const sigset_t *set;
{
message m;
m.m2_l1 = (long) *set;
return(_syscall(PM_PROC_NR, SIGSUSPEND, &m));
memset(&m, 0, sizeof(m));
m.PM_SIG_SET = (long) *set;
return(_syscall(PM_PROC_NR, PM_SIGSUSPEND, &m));
}
#if defined(__minix) && defined(__weak_alias)

4
lib/libc/sys-minix/sprofile.c
View File

@@ -7,6 +7,7 @@ __weak_alias(sprofile, _sprofile)
#endif
#include <lib.h>
#include <string.h>
#include <minix/profile.h>
int sprofile(int action,
@@ -18,6 +19,7 @@ int sprofile(int action,
{
message m;
memset(&m, 0, sizeof(m));
m.PROF_ACTION = action;
m.PROF_MEM_SIZE = size;
m.PROF_FREQ = freq;
@@ -25,6 +27,6 @@ int sprofile(int action,
m.PROF_CTL_PTR = (void *) ctl_ptr;
m.PROF_MEM_PTR = (void *) mem_ptr;
return _syscall(PM_PROC_NR, SPROF, &m);
return _syscall(PM_PROC_NR, PM_SPROF, &m);
}

25
lib/libc/sys-minix/stat.c
View File

@@ -23,11 +23,12 @@ int stat(const char *name, struct stat *buffer)
{
message m;
m.m1_i1 = strlen(name) + 1;
m.m1_p1 = (char *) __UNCONST(name);
m.m1_p2 = (char *) buffer;
memset(&m, 0, sizeof(m));
m.VFS_STAT_LEN = strlen(name) + 1;
m.VFS_STAT_NAME = (char *) __UNCONST(name);
m.VFS_STAT_BUF = (char *) buffer;
return _syscall(VFS_PROC_NR, STAT, &m);
return _syscall(VFS_PROC_NR, VFS_STAT, &m);
}
int _fstat(int fd, struct stat *buffer) { return fstat(fd, buffer); }
@@ -36,10 +37,11 @@ int fstat(int fd, struct stat *buffer)
{
message m;
m.m1_i1 = fd;
m.m1_p1 = (char *) buffer;
memset(&m, 0, sizeof(m));
m.VFS_FSTAT_FD = fd;
m.VFS_FSTAT_BUF = (char *) buffer;
return _syscall(VFS_PROC_NR, FSTAT, &m);
return _syscall(VFS_PROC_NR, VFS_FSTAT, &m);
}
int _lstat(const char *name, struct stat *buffer) { return lstat(name, buffer); }
@@ -48,9 +50,10 @@ int lstat(const char *name, struct stat *buffer)
{
message m;
m.m1_i1 = strlen(name) + 1;
m.m1_p1 = (char *) __UNCONST(name);
m.m1_p2 = (char *) buffer;
memset(&m, 0, sizeof(m));
m.VFS_STAT_LEN = strlen(name) + 1;
m.VFS_STAT_NAME = (char *) __UNCONST(name);
m.VFS_STAT_BUF = (char *) buffer;
return _syscall(VFS_PROC_NR, LSTAT, &m);
return _syscall(VFS_PROC_NR, VFS_LSTAT, &m);
}

3
lib/libc/sys-minix/statvfs.c
View File

@@ -14,11 +14,12 @@ int statvfs1(const char *name, struct statvfs *buffer, int flags)
{
message m;
memset(&m, 0, sizeof(m));
m.VFS_STATVFS1_LEN = strlen(name) + 1;
m.VFS_STATVFS1_NAME = (char *) __UNCONST(name);
m.VFS_STATVFS1_BUF = (char *) buffer;
m.VFS_STATVFS1_FLAGS = flags;
return(_syscall(VFS_PROC_NR, STATVFS1, &m));
return(_syscall(VFS_PROC_NR, VFS_STATVFS1, &m));
}
int statvfs(const char *name, struct statvfs *buffer)

6
lib/libc/sys-minix/stime.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <time.h>
#ifdef __weak_alias
@@ -12,6 +13,7 @@ int stime(time_t *top)
{
message m;
m.m2_l1 = (long)*top;
return(_syscall(PM_PROC_NR, STIME, &m));
memset(&m, 0, sizeof(m));
m.PM_TIME_SEC = (long)*top;
return(_syscall(PM_PROC_NR, PM_STIME, &m));
}

6
lib/libminlib/svrctl.c → lib/libc/sys-minix/svrctl.c
View File

@@ -3,14 +3,16 @@
*/
#include <lib.h>
#include <stdio.h>
#include <string.h>
#include <sys/svrctl.h>
int svrctl(int request, void *argp)
{
message m;
m.m2_i1 = request;
m.m2_p1 = argp;
memset(&m, 0, sizeof(m));
m.SVRCTL_REQ = request;
m.SVRCTL_ARG = argp;
switch ((request >> 8) & 0xFF) {
case 'M':

11
lib/libc/sys-minix/symlink.c
View File

@@ -13,9 +13,10 @@ int symlink(const char *name, const char *name2)
{
message m;
m.m1_i1 = strlen(name) + 1;
m.m1_i2 = strlen(name2) + 1;
m.m1_p1 = (char *) __UNCONST(name);
m.m1_p2 = (char *) __UNCONST(name2);
return(_syscall(VFS_PROC_NR, SYMLINK, &m));
memset(&m, 0, sizeof(m));
m.VFS_LINK_LEN1 = strlen(name) + 1;
m.VFS_LINK_LEN2 = strlen(name2) + 1;
m.VFS_LINK_NAME1 = (char *) __UNCONST(name);
m.VFS_LINK_NAME2 = (char *) __UNCONST(name2);
return(_syscall(VFS_PROC_NR, VFS_SYMLINK, &m));
}

7
lib/libc/sys-minix/sync.c
View File

@@ -2,15 +2,18 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#ifdef __weak_alias
__weak_alias(sync, _sync)
#endif
#include <unistd.h>
void sync()
void sync(void)
{
message m;
(void)(_syscall(VFS_PROC_NR, SYNC, &m));
memset(&m, 0, sizeof(m));
(void)(_syscall(VFS_PROC_NR, VFS_SYNC, &m));
}

16
lib/libc/sys-minix/sysuname.c
View File

@@ -5,22 +5,20 @@
#include <sys/cdefs.h>
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <sys/utsname.h>
int sysuname(int req, int field, char *value, size_t len)
{
message m;
m.m1_i1 = req;
m.m1_i2 = field;
m.m1_i3 = len;
m.m1_p1 = value;
memset(&m, 0, sizeof(m));
m.PM_SYSUNAME_REQ = req;
m.PM_SYSUNAME_FIELD = field;
m.PM_SYSUNAME_LEN = len;
m.PM_SYSUNAME_VALUE = value;
/* Clear unused fields */
m.m1_p2 = NULL;
m.m1_p3 = NULL;
return _syscall(PM_PROC_NR, SYSUNAME, &m);
return _syscall(PM_PROC_NR, PM_SYSUNAME, &m);
}
/*

11
lib/libc/sys-minix/truncate.c
View File

@@ -14,10 +14,11 @@ int truncate(const char *_path, off_t _length)
{
message m;
m.m2_p1 = (char *) __UNCONST(_path);
m.m2_i1 = strlen(_path)+1;
m.m2_l1 = ex64lo(_length);
m.m2_l2 = ex64hi(_length);
memset(&m, 0, sizeof(m));
m.VFS_TRUNCATE_NAME = (char *) __UNCONST(_path);
m.VFS_TRUNCATE_LEN = strlen(_path)+1;
m.VFS_TRUNCATE_OFF_LO = ex64lo(_length);
m.VFS_TRUNCATE_OFF_HI = ex64hi(_length);
return(_syscall(VFS_PROC_NR, TRUNCATE, &m));
return(_syscall(VFS_PROC_NR, VFS_TRUNCATE, &m));
}

6
lib/libc/sys-minix/umask.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <sys/stat.h>
#ifdef __weak_alias
@@ -12,6 +13,7 @@ mode_t umask(mode_t complmode)
{
message m;
m.m1_i1 = complmode;
return( (mode_t) _syscall(VFS_PROC_NR, UMASK, &m));
memset(&m, 0, sizeof(m));
m.VFS_UMASK_MASK = complmode;
return( (mode_t) _syscall(VFS_PROC_NR, VFS_UMASK, &m));
}

4
lib/libc/sys-minix/unlink.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -13,6 +14,7 @@ const char *name;
{
message m;
memset(&m, 0, sizeof(m));
_loadname(name, &m);
return(_syscall(VFS_PROC_NR, UNLINK, &m));
return(_syscall(VFS_PROC_NR, VFS_UNLINK, &m));
}

41
lib/libc/sys-minix/utimensat.c
View File

@@ -25,19 +25,32 @@ int utimensat(int fd, const char *name, const struct timespec tv[2],
if (tv == NULL) tv = now;
if (name == NULL) return EINVAL;
if (name[0] == '\0') return ENOENT; /* POSIX requirement */
if (fd != AT_FDCWD && name[0] != '/') return EINVAL; /* Not supported */
m.m2_i1 = strlen(name) + 1;
m.m2_p1 = (char *) __UNCONST(name);
m.m2_l1 = tv[0].tv_sec;
m.m2_l2 = tv[1].tv_sec;
m.m2_i2 = tv[0].tv_nsec;
m.m2_i3 = tv[1].tv_nsec;
if ((unsigned)flags > SHRT_MAX)
return EINVAL;
else
m.m2_s1 = flags;
if (name == NULL) {
errno = EINVAL;
return -1;
}
if (name[0] == '\0') { /* POSIX requirement */
errno = ENOENT;
return -1;
}
if (fd != AT_FDCWD && name[0] != '/') { /* Not supported */
errno = EINVAL;
return -1;
}
return(_syscall(VFS_PROC_NR, UTIMENS, &m));
if ((unsigned)flags > SHRT_MAX) {
errno = EINVAL;
return -1;
}
memset(&m, 0, sizeof(m));
m.VFS_UTIMENS_LEN = strlen(name) + 1;
m.VFS_UTIMENS_NAME = (char *) __UNCONST(name);
m.VFS_UTIMENS_ATIME = tv[0].tv_sec;
m.VFS_UTIMENS_MTIME = tv[1].tv_sec;
m.VFS_UTIMENS_ANSEC = tv[0].tv_nsec;
m.VFS_UTIMENS_MNSEC = tv[1].tv_nsec;
m.VFS_UTIMENS_FLAGS = flags;
return(_syscall(VFS_PROC_NR, VFS_UTIMENS, &m));
}

31
lib/libc/sys-minix/utimes.c
View File

@@ -15,21 +15,28 @@ int utimes(const char *name, const struct timeval tv[2])
{
message m;
if (name == NULL) return EINVAL;
if (name[0] == '\0') return ENOENT; /* X/Open requirement */
m.m2_i1 = strlen(name) + 1;
m.m2_p1 = (char *) __UNCONST(name);
if (name == NULL) {
errno = EINVAL;
return -1;
}
if (name[0] == '\0') { /* X/Open requirement */
errno = ENOENT;
return -1;
}
memset(&m, 0, sizeof(m));
m.VFS_UTIMENS_LEN = strlen(name) + 1;
m.VFS_UTIMENS_NAME = (char *) __UNCONST(name);
if (tv == NULL) {
m.m2_l1 = m.m2_l2 = 0;
m.m2_i2 = m.m2_i3 = UTIME_NOW;
m.VFS_UTIMENS_ATIME = m.VFS_UTIMENS_MTIME = 0;
m.VFS_UTIMENS_ANSEC = m.VFS_UTIMENS_MNSEC = UTIME_NOW;
}
else {
m.m2_l1 = tv[0].tv_sec;
m.m2_l2 = tv[1].tv_sec;
m.m2_i2 = tv[0].tv_usec * 1000;
m.m2_i3 = tv[1].tv_usec * 1000;
m.VFS_UTIMENS_ATIME = tv[0].tv_sec;
m.VFS_UTIMENS_MTIME = tv[1].tv_sec;
m.VFS_UTIMENS_ANSEC = tv[0].tv_usec * 1000;
m.VFS_UTIMENS_MNSEC = tv[1].tv_usec * 1000;
}
m.m2_s1 = 0;
m.VFS_UTIMENS_FLAGS = 0;
return(_syscall(VFS_PROC_NR, UTIMENS, &m));
return(_syscall(VFS_PROC_NR, VFS_UTIMENS, &m));
}

6
lib/libc/sys-minix/vfork.c
View File

@@ -2,15 +2,17 @@
#include "namespace.h"
#include <lib.h>
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
__weak_alias(vfork, __vfork14)
#endif
pid_t vfork()
pid_t vfork(void)
{
message m;
return(_syscall(PM_PROC_NR, FORK, &m));
memset(&m, 0, sizeof(m));
return(_syscall(PM_PROC_NR, PM_FORK, &m));
}

10
lib/libc/sys-minix/write.c
View File

@@ -2,6 +2,7 @@
#include <lib.h>
#include "namespace.h"
#include <string.h>
#include <unistd.h>
#ifdef __weak_alias
@@ -12,9 +13,10 @@ ssize_t write(int fd, const void *buffer, size_t nbytes)
{
message m;
m.m1_i1 = fd;
m.m1_i2 = nbytes;
m.m1_p1 = (char *) __UNCONST(buffer);
return(_syscall(VFS_PROC_NR, WRITE, &m));
memset(&m, 0, sizeof(m));
m.VFS_READWRITE_FD = fd;
m.VFS_READWRITE_LEN = nbytes;
m.VFS_READWRITE_BUF = (char *) __UNCONST(buffer);
return(_syscall(VFS_PROC_NR, VFS_WRITE, &m));
}

9
lib/libexec/exec_general.c
View File

@@ -80,12 +80,13 @@ int libexec_pm_newexec(endpoint_t proc_e, struct exec_info *e)
int r;
message m;
m.m_type = PM_NEWEXEC;
m.EXC_NM_PROC = proc_e;
m.EXC_NM_PTR = (char *)e;
memset(&m, 0, sizeof(m));
m.m_type = PM_EXEC_NEW;
m.PM_EXEC_NEW_ENDPT = proc_e;
m.PM_EXEC_NEW_PTR = (char *)e;
if ((r = sendrec(PM_PROC_NR, &m)) != OK) return(r);
e->allow_setuid = !!(m.m1_i2 & EXC_NM_RF_ALLOW_SETUID);
e->allow_setuid = !!m.PM_EXEC_NEW_SUID;
return(m.m_type);
}

3
lib/libminlib/Makefile
View File

@@ -21,9 +21,6 @@ SRCS+= gcov.c gcov_flush.c
# Various utils
SRCS+= itoa.c u64util.c read_tsc_64.c
# svrctl
SRCS+= svrctl.c
# servxcheck
SRCS+= servxcheck.c

16
lib/libminlib/gcov.c
View File

@@ -4,22 +4,6 @@
#include <minix/gcov.h>
int gcov_flush_svr(char *buff, int buff_sz, int server_nr)
{
message msg;
msg.GCOV_BUFF_P = buff;
msg.GCOV_BUFF_SZ = buff_sz;
msg.GCOV_PID = server_nr;
/* Make the call to server. It will call the gcov library,
* buffer the stdio requests, and copy the buffer to this user
* space
*/
return _syscall(VFS_PROC_NR, GCOV_FLUSH, &msg);
}
/* wrappers for file system calls from gcc libgcov library.
Default calls are wrapped. In libsys, an alternative
implementation for servers is used.

1
lib/libsys/Makefile
View File

@@ -85,7 +85,6 @@ SRCS+= \
taskcall.c \
tickdelay.c \
timers.c \
vm_brk.c \
vm_cache.c \
vm_exit.c \
vm_fork.c \

2
lib/libsys/copyfd.c
View File

@@ -12,5 +12,5 @@ copyfd(endpoint_t endpt, int fd, int what)
m.VFS_COPYFD_FD = fd;
m.VFS_COPYFD_WHAT = what;
return _taskcall(VFS_PROC_NR, COPYFD, &m);
return _taskcall(VFS_PROC_NR, VFS_COPYFD, &m);
}

Some files were not shown because too many files have changed in this diff Show More