Use the new kern_* functions to avoid the need to store arguments
in the stack gap. This converts most VFS and signal related system calls, as well as select(). Discussed on: -arch Approved by: marcel
This commit is contained in:
Ian Dowse
parent
4982af4aa7
commit
206a5d3a0c
@ -44,6 +44,7 @@
|
||||
#include <sys/mount.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/proc.h>
|
||||
#include <sys/syscallsubr.h>
|
||||
#include <sys/sysproto.h>
|
||||
#include <sys/tty.h>
|
||||
#include <sys/vnode.h>
|
||||
@ -60,82 +61,68 @@
|
||||
int
|
||||
linux_creat(struct thread *td, struct linux_creat_args *args)
|
||||
{
|
||||
struct open_args /* {
|
||||
char *path;
|
||||
int flags;
|
||||
int mode;
|
||||
} */ bsd_open_args;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTCREAT(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(creat))
|
||||
printf(ARGS(creat, "%s, %d"), args->path, args->mode);
|
||||
printf(ARGS(creat, "%s, %d"), path, args->mode);
|
||||
#endif
|
||||
bsd_open_args.path = args->path;
|
||||
bsd_open_args.mode = args->mode;
|
||||
bsd_open_args.flags = O_WRONLY | O_CREAT | O_TRUNC;
|
||||
return open(td, &bsd_open_args);
|
||||
error = kern_open(td, path, UIO_SYSSPACE, O_WRONLY | O_CREAT | O_TRUNC,
|
||||
args->mode);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
#endif /*!__alpha__*/
|
||||
|
||||
int
|
||||
linux_open(struct thread *td, struct linux_open_args *args)
|
||||
{
|
||||
struct open_args /* {
|
||||
char *path;
|
||||
int flags;
|
||||
int mode;
|
||||
} */ bsd_open_args;
|
||||
struct proc *p = td->td_proc;
|
||||
int error;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int bsd_flags, error;
|
||||
|
||||
sg = stackgap_init();
|
||||
|
||||
if (args->flags & LINUX_O_CREAT)
|
||||
CHECKALTCREAT(td, &sg, args->path);
|
||||
LCONVPATHCREAT(td, args->path, &path);
|
||||
else
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(open))
|
||||
printf(ARGS(open, "%s, 0x%x, 0x%x"),
|
||||
args->path, args->flags, args->mode);
|
||||
path, args->flags, args->mode);
|
||||
#endif
|
||||
bsd_open_args.flags = 0;
|
||||
bsd_flags = 0;
|
||||
if (args->flags & LINUX_O_RDONLY)
|
||||
bsd_open_args.flags |= O_RDONLY;
|
||||
bsd_flags |= O_RDONLY;
|
||||
if (args->flags & LINUX_O_WRONLY)
|
||||
bsd_open_args.flags |= O_WRONLY;
|
||||
bsd_flags |= O_WRONLY;
|
||||
if (args->flags & LINUX_O_RDWR)
|
||||
bsd_open_args.flags |= O_RDWR;
|
||||
bsd_flags |= O_RDWR;
|
||||
if (args->flags & LINUX_O_NDELAY)
|
||||
bsd_open_args.flags |= O_NONBLOCK;
|
||||
bsd_flags |= O_NONBLOCK;
|
||||
if (args->flags & LINUX_O_APPEND)
|
||||
bsd_open_args.flags |= O_APPEND;
|
||||
bsd_flags |= O_APPEND;
|
||||
if (args->flags & LINUX_O_SYNC)
|
||||
bsd_open_args.flags |= O_FSYNC;
|
||||
bsd_flags |= O_FSYNC;
|
||||
if (args->flags & LINUX_O_NONBLOCK)
|
||||
bsd_open_args.flags |= O_NONBLOCK;
|
||||
bsd_flags |= O_NONBLOCK;
|
||||
if (args->flags & LINUX_FASYNC)
|
||||
bsd_open_args.flags |= O_ASYNC;
|
||||
bsd_flags |= O_ASYNC;
|
||||
if (args->flags & LINUX_O_CREAT)
|
||||
bsd_open_args.flags |= O_CREAT;
|
||||
bsd_flags |= O_CREAT;
|
||||
if (args->flags & LINUX_O_TRUNC)
|
||||
bsd_open_args.flags |= O_TRUNC;
|
||||
bsd_flags |= O_TRUNC;
|
||||
if (args->flags & LINUX_O_EXCL)
|
||||
bsd_open_args.flags |= O_EXCL;
|
||||
bsd_flags |= O_EXCL;
|
||||
if (args->flags & LINUX_O_NOCTTY)
|
||||
bsd_open_args.flags |= O_NOCTTY;
|
||||
bsd_open_args.path = args->path;
|
||||
bsd_open_args.mode = args->mode;
|
||||
bsd_flags |= O_NOCTTY;
|
||||
|
||||
error = open(td, &bsd_open_args);
|
||||
error = kern_open(td, path, UIO_SYSSPACE, bsd_flags, args->mode);
|
||||
PROC_LOCK(p);
|
||||
if (!error && !(bsd_open_args.flags & O_NOCTTY) &&
|
||||
if (!error && !(bsd_flags & O_NOCTTY) &&
|
||||
SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
|
||||
struct file *fp;
|
||||
|
||||
@ -154,6 +141,7 @@ linux_open(struct thread *td, struct linux_open_args *args)
|
||||
printf(LMSG("open returns error %d"), error);
|
||||
#endif
|
||||
}
|
||||
LFREEPATH(path);
|
||||
return error;
|
||||
}
|
||||
|
||||
@ -493,214 +481,213 @@ linux_getdents64(struct thread *td, struct linux_getdents64_args *args)
|
||||
int
|
||||
linux_access(struct thread *td, struct linux_access_args *args)
|
||||
{
|
||||
struct access_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(access))
|
||||
printf(ARGS(access, "%s, %d"), args->path, args->flags);
|
||||
printf(ARGS(access, "%s, %d"), path, args->flags);
|
||||
#endif
|
||||
bsd.path = args->path;
|
||||
bsd.flags = args->flags;
|
||||
|
||||
return access(td, &bsd);
|
||||
error = kern_access(td, path, UIO_SYSSPACE, args->flags);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_unlink(struct thread *td, struct linux_unlink_args *args)
|
||||
{
|
||||
struct unlink_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(unlink))
|
||||
printf(ARGS(unlink, "%s"), args->path);
|
||||
printf(ARGS(unlink, "%s"), path);
|
||||
#endif
|
||||
bsd.path = args->path;
|
||||
|
||||
return unlink(td, &bsd);
|
||||
error = kern_unlink(td, path, UIO_SYSSPACE);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_chdir(struct thread *td, struct linux_chdir_args *args)
|
||||
{
|
||||
struct chdir_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(chdir))
|
||||
printf(ARGS(chdir, "%s"), args->path);
|
||||
printf(ARGS(chdir, "%s"), path);
|
||||
#endif
|
||||
bsd.path = args->path;
|
||||
|
||||
return chdir(td, &bsd);
|
||||
error = kern_chdir(td, path, UIO_SYSSPACE);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_chmod(struct thread *td, struct linux_chmod_args *args)
|
||||
{
|
||||
struct chmod_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(chmod))
|
||||
printf(ARGS(chmod, "%s, %d"), args->path, args->mode);
|
||||
printf(ARGS(chmod, "%s, %d"), path, args->mode);
|
||||
#endif
|
||||
bsd.path = args->path;
|
||||
bsd.mode = args->mode;
|
||||
|
||||
return chmod(td, &bsd);
|
||||
error = kern_chmod(td, path, UIO_SYSSPACE, args->mode);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_mkdir(struct thread *td, struct linux_mkdir_args *args)
|
||||
{
|
||||
struct mkdir_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTCREAT(td, &sg, args->path);
|
||||
LCONVPATHCREAT(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(mkdir))
|
||||
printf(ARGS(mkdir, "%s, %d"), args->path, args->mode);
|
||||
printf(ARGS(mkdir, "%s, %d"), path, args->mode);
|
||||
#endif
|
||||
bsd.path = args->path;
|
||||
bsd.mode = args->mode;
|
||||
|
||||
return mkdir(td, &bsd);
|
||||
error = kern_mkdir(td, path, UIO_SYSSPACE, args->mode);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_rmdir(struct thread *td, struct linux_rmdir_args *args)
|
||||
{
|
||||
struct rmdir_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(rmdir))
|
||||
printf(ARGS(rmdir, "%s"), args->path);
|
||||
printf(ARGS(rmdir, "%s"), path);
|
||||
#endif
|
||||
bsd.path = args->path;
|
||||
|
||||
return rmdir(td, &bsd);
|
||||
error = kern_rmdir(td, path, UIO_SYSSPACE);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_rename(struct thread *td, struct linux_rename_args *args)
|
||||
{
|
||||
struct rename_args bsd;
|
||||
caddr_t sg;
|
||||
char *from, *to;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->from);
|
||||
CHECKALTCREAT(td, &sg, args->to);
|
||||
LCONVPATHEXIST(td, args->from, &from);
|
||||
/* Expand LCONVPATHCREATE so that `from' can be freed on errors */
|
||||
error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1);
|
||||
if (to == NULL) {
|
||||
LFREEPATH(from);
|
||||
return (error);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(rename))
|
||||
printf(ARGS(rename, "%s, %s"), args->from, args->to);
|
||||
printf(ARGS(rename, "%s, %s"), from, to);
|
||||
#endif
|
||||
bsd.from = args->from;
|
||||
bsd.to = args->to;
|
||||
|
||||
return rename(td, &bsd);
|
||||
error = kern_rename(td, from, to, UIO_SYSSPACE);
|
||||
LFREEPATH(from);
|
||||
LFREEPATH(to);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_symlink(struct thread *td, struct linux_symlink_args *args)
|
||||
{
|
||||
struct symlink_args bsd;
|
||||
caddr_t sg;
|
||||
char *path, *to;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
CHECKALTCREAT(td, &sg, args->to);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
/* Expand LCONVPATHCREATE so that `path' can be freed on errors */
|
||||
error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1);
|
||||
if (to == NULL) {
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(symlink))
|
||||
printf(ARGS(symlink, "%s, %s"), args->path, args->to);
|
||||
printf(ARGS(symlink, "%s, %s"), path, to);
|
||||
#endif
|
||||
bsd.path = args->path;
|
||||
bsd.link = args->to;
|
||||
|
||||
return symlink(td, &bsd);
|
||||
error = kern_symlink(td, path, to, UIO_SYSSPACE);
|
||||
LFREEPATH(path);
|
||||
LFREEPATH(to);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_readlink(struct thread *td, struct linux_readlink_args *args)
|
||||
{
|
||||
struct readlink_args bsd;
|
||||
caddr_t sg;
|
||||
char *name;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->name);
|
||||
LCONVPATHEXIST(td, args->name, &name);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(readlink))
|
||||
printf(ARGS(readlink, "%s, %p, %d"),
|
||||
args->name, (void *)args->buf, args->count);
|
||||
printf(ARGS(readlink, "%s, %p, %d"), name, (void *)args->buf,
|
||||
args->count);
|
||||
#endif
|
||||
bsd.path = args->name;
|
||||
bsd.buf = args->buf;
|
||||
bsd.count = args->count;
|
||||
|
||||
return readlink(td, &bsd);
|
||||
error = kern_readlink(td, name, UIO_SYSSPACE, args->buf, UIO_USERSPACE,
|
||||
args->count);
|
||||
LFREEPATH(name);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_truncate(struct thread *td, struct linux_truncate_args *args)
|
||||
{
|
||||
struct truncate_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(truncate))
|
||||
printf(ARGS(truncate, "%s, %ld"), args->path,
|
||||
(long)args->length);
|
||||
printf(ARGS(truncate, "%s, %ld"), path, (long)args->length);
|
||||
#endif
|
||||
bsd.path = args->path;
|
||||
bsd.length = args->length;
|
||||
|
||||
return truncate(td, &bsd);
|
||||
error = kern_truncate(td, path, UIO_SYSSPACE, args->length);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_link(struct thread *td, struct linux_link_args *args)
|
||||
{
|
||||
struct link_args bsd;
|
||||
caddr_t sg;
|
||||
char *path, *to;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
CHECKALTCREAT(td, &sg, args->to);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
/* Expand LCONVPATHCREATE so that `path' can be freed on errors */
|
||||
error = linux_emul_convpath(td, args->to, UIO_USERSPACE, &to, 1);
|
||||
if (to == NULL) {
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(link))
|
||||
printf(ARGS(link, "%s, %s"), args->path, args->to);
|
||||
printf(ARGS(link, "%s, %s"), path, to);
|
||||
#endif
|
||||
|
||||
bsd.path = args->path;
|
||||
bsd.link = args->to;
|
||||
|
||||
return link(td, &bsd);
|
||||
error = kern_link(td, path, to, UIO_SYSSPACE);
|
||||
LFREEPATH(path);
|
||||
LFREEPATH(to);
|
||||
return (error);
|
||||
}
|
||||
|
||||
#ifndef __alpha__
|
||||
@ -1158,41 +1145,33 @@ linux_fcntl64(struct thread *td, struct linux_fcntl64_args *args)
|
||||
int
|
||||
linux_chown(struct thread *td, struct linux_chown_args *args)
|
||||
{
|
||||
struct chown_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(chown))
|
||||
printf(ARGS(chown, "%s, %d, %d"), args->path, args->uid,
|
||||
args->gid);
|
||||
printf(ARGS(chown, "%s, %d, %d"), path, args->uid, args->gid);
|
||||
#endif
|
||||
|
||||
bsd.path = args->path;
|
||||
bsd.uid = args->uid;
|
||||
bsd.gid = args->gid;
|
||||
return (chown(td, &bsd));
|
||||
error = kern_chown(td, path, UIO_SYSSPACE, args->uid, args->gid);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_lchown(struct thread *td, struct linux_lchown_args *args)
|
||||
{
|
||||
struct lchown_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(lchown))
|
||||
printf(ARGS(lchown, "%s, %d, %d"), args->path, args->uid,
|
||||
args->gid);
|
||||
printf(ARGS(lchown, "%s, %d, %d"), path, args->uid, args->gid);
|
||||
#endif
|
||||
|
||||
bsd.path = args->path;
|
||||
bsd.uid = args->uid;
|
||||
bsd.gid = args->gid;
|
||||
return (lchown(td, &bsd));
|
||||
error = kern_lchown(td, path, UIO_SYSSPACE, args->uid, args->gid);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
@ -50,6 +50,7 @@
|
||||
#include <sys/resourcevar.h>
|
||||
#include <sys/signalvar.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/syscallsubr.h>
|
||||
#include <sys/sysctl.h>
|
||||
#include <sys/sysproto.h>
|
||||
#include <sys/time.h>
|
||||
@ -235,16 +236,15 @@ linux_uselib(struct thread *td, struct linux_uselib_args *args)
|
||||
unsigned long file_offset;
|
||||
vm_offset_t buffer;
|
||||
unsigned long bss_size;
|
||||
char *library;
|
||||
int error;
|
||||
caddr_t sg;
|
||||
int locked;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->library);
|
||||
LCONVPATHEXIST(td, args->library, &library);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(uselib))
|
||||
printf(ARGS(uselib, "%s"), args->library);
|
||||
printf(ARGS(uselib, "%s"), library);
|
||||
#endif
|
||||
|
||||
a_out = NULL;
|
||||
@ -255,8 +255,9 @@ linux_uselib(struct thread *td, struct linux_uselib_args *args)
|
||||
* XXX: This code should make use of vn_open(), rather than doing
|
||||
* all this stuff itself.
|
||||
*/
|
||||
NDINIT(&ni, LOOKUP, FOLLOW|LOCKLEAF, UIO_USERSPACE, args->library, td);
|
||||
NDINIT(&ni, LOOKUP, FOLLOW|LOCKLEAF, UIO_SYSSPACE, library, td);
|
||||
error = namei(&ni);
|
||||
LFREEPATH(library);
|
||||
if (error)
|
||||
goto cleanup;
|
||||
|
||||
@ -476,9 +477,7 @@ linux_uselib(struct thread *td, struct linux_uselib_args *args)
|
||||
int
|
||||
linux_select(struct thread *td, struct linux_select_args *args)
|
||||
{
|
||||
struct select_args bsa;
|
||||
struct timeval tv0, tv1, utv, *tvp;
|
||||
caddr_t sg;
|
||||
int error;
|
||||
|
||||
#ifdef DEBUG
|
||||
@ -488,13 +487,6 @@ linux_select(struct thread *td, struct linux_select_args *args)
|
||||
(void *)args->exceptfds, (void *)args->timeout);
|
||||
#endif
|
||||
|
||||
error = 0;
|
||||
bsa.nd = args->nfds;
|
||||
bsa.in = args->readfds;
|
||||
bsa.ou = args->writefds;
|
||||
bsa.ex = args->exceptfds;
|
||||
bsa.tv = (struct timeval *)args->timeout;
|
||||
|
||||
/*
|
||||
* Store current time for computation of the amount of
|
||||
* time left.
|
||||
@ -514,8 +506,6 @@ linux_select(struct thread *td, struct linux_select_args *args)
|
||||
* The timeval was invalid. Convert it to something
|
||||
* valid that will act as it does under Linux.
|
||||
*/
|
||||
sg = stackgap_init();
|
||||
tvp = stackgap_alloc(&sg, sizeof(utv));
|
||||
utv.tv_sec += utv.tv_usec / 1000000;
|
||||
utv.tv_usec %= 1000000;
|
||||
if (utv.tv_usec < 0) {
|
||||
@ -524,14 +514,15 @@ linux_select(struct thread *td, struct linux_select_args *args)
|
||||
}
|
||||
if (utv.tv_sec < 0)
|
||||
timevalclear(&utv);
|
||||
if ((error = copyout(&utv, tvp, sizeof(utv))))
|
||||
goto select_out;
|
||||
bsa.tv = tvp;
|
||||
}
|
||||
microtime(&tv0);
|
||||
}
|
||||
tvp = &utv;
|
||||
} else
|
||||
tvp = NULL;
|
||||
|
||||
error = kern_select(td, args->nfds, args->readfds, args->writefds,
|
||||
args->exceptfds, tvp);
|
||||
|
||||
error = select(td, &bsa);
|
||||
#ifdef DEBUG
|
||||
if (ldebug(select))
|
||||
printf(LMSG("real select returns %d"), error);
|
||||
@ -729,42 +720,34 @@ struct l_utimbuf {
|
||||
int
|
||||
linux_utime(struct thread *td, struct linux_utime_args *args)
|
||||
{
|
||||
struct utimes_args /* {
|
||||
char *path;
|
||||
struct timeval *tptr;
|
||||
} */ bsdutimes;
|
||||
struct timeval tv[2], *tvp;
|
||||
struct l_utimbuf lut;
|
||||
char *fname;
|
||||
int error;
|
||||
caddr_t sg;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->fname);
|
||||
LCONVPATHEXIST(td, args->fname, &fname);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(utime))
|
||||
printf(ARGS(utime, "%s, *"), args->fname);
|
||||
printf(ARGS(utime, "%s, *"), fname);
|
||||
#endif
|
||||
|
||||
if (args->times) {
|
||||
if ((error = copyin((caddr_t)args->times, &lut, sizeof lut)))
|
||||
if ((error = copyin((caddr_t)args->times, &lut, sizeof lut))) {
|
||||
LFREEPATH(fname);
|
||||
return error;
|
||||
}
|
||||
tv[0].tv_sec = lut.l_actime;
|
||||
tv[0].tv_usec = 0;
|
||||
tv[1].tv_sec = lut.l_modtime;
|
||||
tv[1].tv_usec = 0;
|
||||
/* so that utimes can copyin */
|
||||
tvp = (struct timeval *)stackgap_alloc(&sg, sizeof(tv));
|
||||
if (tvp == NULL)
|
||||
return (ENAMETOOLONG);
|
||||
if ((error = copyout(tv, tvp, sizeof(tv))))
|
||||
return error;
|
||||
bsdutimes.tptr = tvp;
|
||||
tvp = tv;
|
||||
} else
|
||||
bsdutimes.tptr = NULL;
|
||||
tvp = NULL;
|
||||
|
||||
bsdutimes.path = args->fname;
|
||||
return utimes(td, &bsdutimes);
|
||||
error = kern_utimes(td, fname, UIO_SYSSPACE, tvp, UIO_SYSSPACE);
|
||||
LFREEPATH(fname);
|
||||
return (error);
|
||||
}
|
||||
#endif /* __i386__ */
|
||||
|
||||
@ -868,30 +851,23 @@ linux_wait4(struct thread *td, struct linux_wait4_args *args)
|
||||
int
|
||||
linux_mknod(struct thread *td, struct linux_mknod_args *args)
|
||||
{
|
||||
caddr_t sg;
|
||||
struct mknod_args bsd_mknod;
|
||||
struct mkfifo_args bsd_mkfifo;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
|
||||
CHECKALTCREAT(td, &sg, args->path);
|
||||
LCONVPATHCREAT(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(mknod))
|
||||
printf(ARGS(mknod, "%s, %d, %d"),
|
||||
args->path, args->mode, args->dev);
|
||||
printf(ARGS(mknod, "%s, %d, %d"), path, args->mode, args->dev);
|
||||
#endif
|
||||
|
||||
if (args->mode & S_IFIFO) {
|
||||
bsd_mkfifo.path = args->path;
|
||||
bsd_mkfifo.mode = args->mode;
|
||||
return mkfifo(td, &bsd_mkfifo);
|
||||
} else {
|
||||
bsd_mknod.path = args->path;
|
||||
bsd_mknod.mode = args->mode;
|
||||
bsd_mknod.dev = args->dev;
|
||||
return mknod(td, &bsd_mknod);
|
||||
}
|
||||
if (args->mode & S_IFIFO)
|
||||
error = kern_mkfifo(td, path, UIO_SYSSPACE, args->mode);
|
||||
else
|
||||
error = kern_mknod(td, path, UIO_SYSSPACE, args->mode,
|
||||
args->dev);
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1071,10 +1047,10 @@ linux_getgroups(struct thread *td, struct linux_getgroups_args *args)
|
||||
int
|
||||
linux_setrlimit(struct thread *td, struct linux_setrlimit_args *args)
|
||||
{
|
||||
struct __setrlimit_args bsd;
|
||||
struct rlimit bsd_rlim;
|
||||
struct l_rlimit rlim;
|
||||
u_int which;
|
||||
int error;
|
||||
caddr_t sg = stackgap_init();
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(setrlimit))
|
||||
@ -1085,27 +1061,26 @@ linux_setrlimit(struct thread *td, struct linux_setrlimit_args *args)
|
||||
if (args->resource >= LINUX_RLIM_NLIMITS)
|
||||
return (EINVAL);
|
||||
|
||||
bsd.which = linux_to_bsd_resource[args->resource];
|
||||
if (bsd.which == -1)
|
||||
which = linux_to_bsd_resource[args->resource];
|
||||
if (which == -1)
|
||||
return (EINVAL);
|
||||
|
||||
error = copyin((caddr_t)args->rlim, &rlim, sizeof(rlim));
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
bsd.rlp = stackgap_alloc(&sg, sizeof(struct rlimit));
|
||||
bsd.rlp->rlim_cur = (rlim_t)rlim.rlim_cur;
|
||||
bsd.rlp->rlim_max = (rlim_t)rlim.rlim_max;
|
||||
return (setrlimit(td, &bsd));
|
||||
bsd_rlim.rlim_cur = (rlim_t)rlim.rlim_cur;
|
||||
bsd_rlim.rlim_max = (rlim_t)rlim.rlim_max;
|
||||
return (dosetrlimit(td, which, &bsd_rlim));
|
||||
}
|
||||
|
||||
int
|
||||
linux_old_getrlimit(struct thread *td, struct linux_old_getrlimit_args *args)
|
||||
{
|
||||
struct __getrlimit_args bsd;
|
||||
struct l_rlimit rlim;
|
||||
int error;
|
||||
caddr_t sg = stackgap_init();
|
||||
struct proc *p = td->td_proc;
|
||||
struct rlimit *bsd_rlp;
|
||||
u_int which;
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(old_getrlimit))
|
||||
@ -1116,19 +1091,15 @@ linux_old_getrlimit(struct thread *td, struct linux_old_getrlimit_args *args)
|
||||
if (args->resource >= LINUX_RLIM_NLIMITS)
|
||||
return (EINVAL);
|
||||
|
||||
bsd.which = linux_to_bsd_resource[args->resource];
|
||||
if (bsd.which == -1)
|
||||
which = linux_to_bsd_resource[args->resource];
|
||||
if (which == -1)
|
||||
return (EINVAL);
|
||||
bsd_rlp = &p->p_rlimit[which];
|
||||
|
||||
bsd.rlp = stackgap_alloc(&sg, sizeof(struct rlimit));
|
||||
error = getrlimit(td, &bsd);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
rlim.rlim_cur = (unsigned long)bsd.rlp->rlim_cur;
|
||||
rlim.rlim_cur = (unsigned long)bsd_rlp->rlim_cur;
|
||||
if (rlim.rlim_cur == ULONG_MAX)
|
||||
rlim.rlim_cur = LONG_MAX;
|
||||
rlim.rlim_max = (unsigned long)bsd.rlp->rlim_max;
|
||||
rlim.rlim_max = (unsigned long)bsd_rlp->rlim_max;
|
||||
if (rlim.rlim_max == ULONG_MAX)
|
||||
rlim.rlim_max = LONG_MAX;
|
||||
return (copyout(&rlim, (caddr_t)args->rlim, sizeof(rlim)));
|
||||
@ -1137,10 +1108,10 @@ linux_old_getrlimit(struct thread *td, struct linux_old_getrlimit_args *args)
|
||||
int
|
||||
linux_getrlimit(struct thread *td, struct linux_getrlimit_args *args)
|
||||
{
|
||||
struct __getrlimit_args bsd;
|
||||
struct l_rlimit rlim;
|
||||
int error;
|
||||
caddr_t sg = stackgap_init();
|
||||
struct proc *p = td->td_proc;
|
||||
struct rlimit *bsd_rlp;
|
||||
u_int which;
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(getrlimit))
|
||||
@ -1151,17 +1122,13 @@ linux_getrlimit(struct thread *td, struct linux_getrlimit_args *args)
|
||||
if (args->resource >= LINUX_RLIM_NLIMITS)
|
||||
return (EINVAL);
|
||||
|
||||
bsd.which = linux_to_bsd_resource[args->resource];
|
||||
if (bsd.which == -1)
|
||||
which = linux_to_bsd_resource[args->resource];
|
||||
if (which == -1)
|
||||
return (EINVAL);
|
||||
bsd_rlp = &p->p_rlimit[which];
|
||||
|
||||
bsd.rlp = stackgap_alloc(&sg, sizeof(struct rlimit));
|
||||
error = getrlimit(td, &bsd);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
rlim.rlim_cur = (l_ulong)bsd.rlp->rlim_cur;
|
||||
rlim.rlim_max = (l_ulong)bsd.rlp->rlim_max;
|
||||
rlim.rlim_cur = (l_ulong)bsd_rlp->rlim_cur;
|
||||
rlim.rlim_max = (l_ulong)bsd_rlp->rlim_max;
|
||||
return (copyout(&rlim, (caddr_t)args->rlim, sizeof(rlim)));
|
||||
}
|
||||
#endif /*!__alpha__*/
|
||||
|
||||
@ -34,6 +34,7 @@
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/proc.h>
|
||||
#include <sys/signalvar.h>
|
||||
#include <sys/syscallsubr.h>
|
||||
#include <sys/sysproto.h>
|
||||
|
||||
#include <machine/../linux/linux.h>
|
||||
@ -134,36 +135,27 @@ int
|
||||
linux_do_sigaction(struct thread *td, int linux_sig, l_sigaction_t *linux_nsa,
|
||||
l_sigaction_t *linux_osa)
|
||||
{
|
||||
struct sigaction *nsa, *osa;
|
||||
struct sigaction_args sa_args;
|
||||
int error;
|
||||
caddr_t sg = stackgap_init();
|
||||
struct sigaction act, oact, *nsa, *osa;
|
||||
int error, sig;
|
||||
|
||||
if (linux_sig <= 0 || linux_sig > LINUX_NSIG)
|
||||
return (EINVAL);
|
||||
|
||||
if (linux_osa != NULL)
|
||||
osa = stackgap_alloc(&sg, sizeof(struct sigaction));
|
||||
else
|
||||
osa = NULL;
|
||||
|
||||
osa = (linux_osa != NULL) ? &oact : NULL;
|
||||
if (linux_nsa != NULL) {
|
||||
nsa = stackgap_alloc(&sg, sizeof(struct sigaction));
|
||||
nsa = &act;
|
||||
linux_to_bsd_sigaction(linux_nsa, nsa);
|
||||
}
|
||||
else
|
||||
} else
|
||||
nsa = NULL;
|
||||
|
||||
#ifndef __alpha__
|
||||
if (linux_sig <= LINUX_SIGTBLSZ)
|
||||
sa_args.sig = linux_to_bsd_signal[_SIG_IDX(linux_sig)];
|
||||
sig = linux_to_bsd_signal[_SIG_IDX(linux_sig)];
|
||||
else
|
||||
#endif
|
||||
sa_args.sig = linux_sig;
|
||||
sig = linux_sig;
|
||||
|
||||
sa_args.act = nsa;
|
||||
sa_args.oact = osa;
|
||||
error = sigaction(td, &sa_args);
|
||||
error = kern_sigaction(td, sig, nsa, osa, 0);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
|
||||
@ -94,20 +94,19 @@ linux_newstat(struct thread *td, struct linux_newstat_args *args)
|
||||
{
|
||||
struct stat buf;
|
||||
struct nameidata nd;
|
||||
char *path;
|
||||
int error;
|
||||
caddr_t sg;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(newstat))
|
||||
printf(ARGS(newstat, "%s, *"), args->path);
|
||||
printf(ARGS(newstat, "%s, *"), path);
|
||||
#endif
|
||||
|
||||
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
|
||||
args->path, td);
|
||||
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_SYSSPACE, path, td);
|
||||
error = namei(&nd);
|
||||
LFREEPATH(path);
|
||||
if (error)
|
||||
return (error);
|
||||
NDFREE(&nd, NDF_ONLY_PNBUF);
|
||||
@ -126,19 +125,19 @@ linux_newlstat(struct thread *td, struct linux_newlstat_args *args)
|
||||
int error;
|
||||
struct stat sb;
|
||||
struct nameidata nd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(newlstat))
|
||||
printf(ARGS(newlstat, "%s, *"), args->path);
|
||||
printf(ARGS(newlstat, "%s, *"), path);
|
||||
#endif
|
||||
|
||||
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
|
||||
args->path, td);
|
||||
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_SYSSPACE, path,
|
||||
td);
|
||||
error = namei(&nd);
|
||||
LFREEPATH(path);
|
||||
if (error)
|
||||
return (error);
|
||||
NDFREE(&nd, NDF_ONLY_PNBUF);
|
||||
@ -231,19 +230,19 @@ linux_statfs(struct thread *td, struct linux_statfs_args *args)
|
||||
struct statfs *bsd_statfs;
|
||||
struct nameidata nd;
|
||||
struct l_statfs linux_statfs;
|
||||
char *path;
|
||||
int error;
|
||||
caddr_t sg;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(statfs))
|
||||
printf(ARGS(statfs, "%s, *"), args->path);
|
||||
printf(ARGS(statfs, "%s, *"), path);
|
||||
#endif
|
||||
ndp = &nd;
|
||||
NDINIT(ndp, LOOKUP, FOLLOW, UIO_USERSPACE, args->path, curthread);
|
||||
NDINIT(ndp, LOOKUP, FOLLOW, UIO_SYSSPACE, path, td);
|
||||
error = namei(ndp);
|
||||
LFREEPATH(path);
|
||||
if (error)
|
||||
return error;
|
||||
NDFREE(ndp, NDF_ONLY_PNBUF);
|
||||
@ -416,19 +415,19 @@ linux_stat64(struct thread *td, struct linux_stat64_args *args)
|
||||
struct stat buf;
|
||||
struct nameidata nd;
|
||||
int error;
|
||||
caddr_t sg;
|
||||
char *filename;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->filename);
|
||||
LCONVPATHEXIST(td, args->filename, &filename);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(stat64))
|
||||
printf(ARGS(stat64, "%s, *"), args->filename);
|
||||
printf(ARGS(stat64, "%s, *"), filename);
|
||||
#endif
|
||||
|
||||
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
|
||||
args->filename, td);
|
||||
NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | NOOBJ, UIO_SYSSPACE, filename,
|
||||
td);
|
||||
error = namei(&nd);
|
||||
LFREEPATH(filename);
|
||||
if (error)
|
||||
return (error);
|
||||
NDFREE(&nd, NDF_ONLY_PNBUF);
|
||||
@ -447,19 +446,19 @@ linux_lstat64(struct thread *td, struct linux_lstat64_args *args)
|
||||
int error;
|
||||
struct stat sb;
|
||||
struct nameidata nd;
|
||||
caddr_t sg;
|
||||
char *filename;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->filename);
|
||||
LCONVPATHEXIST(td, args->filename, &filename);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(lstat64))
|
||||
printf(ARGS(lstat64, "%s, *"), args->filename);
|
||||
#endif
|
||||
|
||||
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_USERSPACE,
|
||||
args->filename, td);
|
||||
NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF | NOOBJ, UIO_SYSSPACE, filename,
|
||||
td);
|
||||
error = namei(&nd);
|
||||
LFREEPATH(filename);
|
||||
if (error)
|
||||
return (error);
|
||||
NDFREE(&nd, NDF_ONLY_PNBUF);
|
||||
|
||||
@ -80,20 +80,20 @@ linux_sysctl(struct thread *td, struct linux_sysctl_args *args)
|
||||
struct l___sysctl_args la;
|
||||
l_int *mib;
|
||||
int error, i;
|
||||
caddr_t sg;
|
||||
|
||||
error = copyin((caddr_t)args->args, &la, sizeof(la));
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
if (la.nlen == 0 || la.nlen > LINUX_CTL_MAXNAME)
|
||||
if (la.nlen <= 0 || la.nlen > LINUX_CTL_MAXNAME)
|
||||
return (ENOTDIR);
|
||||
|
||||
sg = stackgap_init();
|
||||
mib = stackgap_alloc(&sg, la.nlen * sizeof(l_int));
|
||||
mib = malloc(la.nlen * sizeof(l_int), M_TEMP, M_WAITOK);
|
||||
error = copyin(la.name, mib, la.nlen * sizeof(l_int));
|
||||
if (error)
|
||||
if (error) {
|
||||
free(mib, M_TEMP);
|
||||
return (error);
|
||||
}
|
||||
|
||||
switch (mib[0]) {
|
||||
case LINUX_CTL_KERN:
|
||||
@ -102,7 +102,9 @@ linux_sysctl(struct thread *td, struct linux_sysctl_args *args)
|
||||
|
||||
switch (mib[1]) {
|
||||
case LINUX_KERN_VERSION:
|
||||
return (handle_string(&la, version));
|
||||
error = handle_string(&la, version);
|
||||
free(mib, M_TEMP);
|
||||
return (error);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -116,5 +118,6 @@ linux_sysctl(struct thread *td, struct linux_sysctl_args *args)
|
||||
printf("%c%d", (i) ? ',' : '{', mib[i]);
|
||||
printf("}\n");
|
||||
|
||||
free(mib, M_TEMP);
|
||||
return (ENOTDIR);
|
||||
}
|
||||
|
||||
@ -33,6 +33,7 @@
|
||||
#include <sys/lock.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/proc.h>
|
||||
#include <sys/syscallsubr.h>
|
||||
#include <sys/sysproto.h>
|
||||
|
||||
#include <machine/../linux/linux.h>
|
||||
@ -44,48 +45,43 @@ DUMMY(setfsgid16);
|
||||
DUMMY(getresuid16);
|
||||
DUMMY(getresgid16);
|
||||
|
||||
#define CAST_NOCHG(x) (x == 0xFFFF) ? -1 : x;
|
||||
#define CAST_NOCHG(x) ((x == 0xFFFF) ? -1 : x)
|
||||
|
||||
int
|
||||
linux_chown16(struct thread *td, struct linux_chown16_args *args)
|
||||
{
|
||||
struct chown_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(chown16))
|
||||
printf(ARGS(chown16, "%s, %d, %d"), args->path, args->uid,
|
||||
args->gid);
|
||||
printf(ARGS(chown16, "%s, %d, %d"), path, args->uid, args->gid);
|
||||
#endif
|
||||
|
||||
bsd.path = args->path;
|
||||
bsd.uid = CAST_NOCHG(args->uid);
|
||||
bsd.gid = CAST_NOCHG(args->gid);
|
||||
return (chown(td, &bsd));
|
||||
error = kern_chown(td, path, UIO_SYSSPACE, CAST_NOCHG(args->uid),
|
||||
CAST_NOCHG(args->gid));
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
linux_lchown16(struct thread *td, struct linux_lchown16_args *args)
|
||||
{
|
||||
struct lchown_args bsd;
|
||||
caddr_t sg;
|
||||
char *path;
|
||||
int error;
|
||||
|
||||
sg = stackgap_init();
|
||||
CHECKALTEXIST(td, &sg, args->path);
|
||||
LCONVPATHEXIST(td, args->path, &path);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(lchown16))
|
||||
printf(ARGS(lchown16, "%s, %d, %d"), args->path, args->uid,
|
||||
printf(ARGS(lchown16, "%s, %d, %d"), path, args->uid,
|
||||
args->gid);
|
||||
#endif
|
||||
|
||||
bsd.path = args->path;
|
||||
bsd.uid = CAST_NOCHG(args->uid);
|
||||
bsd.gid = CAST_NOCHG(args->gid);
|
||||
return (lchown(td, &bsd));
|
||||
error = kern_lchown(td, path, UIO_SYSSPACE, CAST_NOCHG(args->uid),
|
||||
CAST_NOCHG(args->gid));
|
||||
LFREEPATH(path);
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
|
||||
@ -36,6 +36,7 @@
|
||||
#include <sys/proc.h>
|
||||
#include <sys/resource.h>
|
||||
#include <sys/resourcevar.h>
|
||||
#include <sys/syscallsubr.h>
|
||||
#include <sys/sysproto.h>
|
||||
#include <sys/unistd.h>
|
||||
|
||||
@ -685,22 +686,18 @@ linux_sigaction(struct thread *td, struct linux_sigaction_args *args)
|
||||
int
|
||||
linux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args)
|
||||
{
|
||||
struct sigsuspend_args bsd;
|
||||
sigset_t *sigmask;
|
||||
sigset_t sigmask;
|
||||
l_sigset_t mask;
|
||||
caddr_t sg = stackgap_init();
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(sigsuspend))
|
||||
printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask);
|
||||
#endif
|
||||
|
||||
sigmask = stackgap_alloc(&sg, sizeof(sigset_t));
|
||||
LINUX_SIGEMPTYSET(mask);
|
||||
mask.__bits[0] = args->mask;
|
||||
linux_to_bsd_sigset(&mask, sigmask);
|
||||
bsd.sigmask = sigmask;
|
||||
return (sigsuspend(td, &bsd));
|
||||
linux_to_bsd_sigset(&mask, &sigmask);
|
||||
return (kern_sigsuspend(td, sigmask));
|
||||
}
|
||||
|
||||
int
|
||||
@ -709,9 +706,7 @@ linux_rt_sigsuspend(td, uap)
|
||||
struct linux_rt_sigsuspend_args *uap;
|
||||
{
|
||||
l_sigset_t lmask;
|
||||
sigset_t *bmask;
|
||||
struct sigsuspend_args bsd;
|
||||
caddr_t sg = stackgap_init();
|
||||
sigset_t sigmask;
|
||||
int error;
|
||||
|
||||
#ifdef DEBUG
|
||||
@ -727,71 +722,54 @@ linux_rt_sigsuspend(td, uap)
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
bmask = stackgap_alloc(&sg, sizeof(sigset_t));
|
||||
linux_to_bsd_sigset(&lmask, bmask);
|
||||
bsd.sigmask = bmask;
|
||||
return (sigsuspend(td, &bsd));
|
||||
linux_to_bsd_sigset(&lmask, &sigmask);
|
||||
return (kern_sigsuspend(td, sigmask));
|
||||
}
|
||||
|
||||
int
|
||||
linux_pause(struct thread *td, struct linux_pause_args *args)
|
||||
{
|
||||
struct proc *p = td->td_proc;
|
||||
struct sigsuspend_args bsd;
|
||||
sigset_t *sigmask;
|
||||
caddr_t sg = stackgap_init();
|
||||
sigset_t sigmask;
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(pause))
|
||||
printf(ARGS(pause, ""));
|
||||
#endif
|
||||
|
||||
sigmask = stackgap_alloc(&sg, sizeof(sigset_t));
|
||||
PROC_LOCK(p);
|
||||
*sigmask = p->p_sigmask;
|
||||
sigmask = p->p_sigmask;
|
||||
PROC_UNLOCK(p);
|
||||
bsd.sigmask = sigmask;
|
||||
return (sigsuspend(td, &bsd));
|
||||
return (kern_sigsuspend(td, sigmask));
|
||||
}
|
||||
|
||||
int
|
||||
linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap)
|
||||
{
|
||||
struct sigaltstack_args bsd;
|
||||
stack_t *ss, *oss;
|
||||
stack_t ss, oss;
|
||||
l_stack_t lss;
|
||||
int error;
|
||||
caddr_t sg = stackgap_init();
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(sigaltstack))
|
||||
printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss);
|
||||
#endif
|
||||
|
||||
if (uap->uss == NULL) {
|
||||
ss = NULL;
|
||||
} else {
|
||||
if (uap->uss != NULL) {
|
||||
error = copyin(uap->uss, &lss, sizeof(l_stack_t));
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
ss = stackgap_alloc(&sg, sizeof(stack_t));
|
||||
ss->ss_sp = lss.ss_sp;
|
||||
ss->ss_size = lss.ss_size;
|
||||
ss->ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
|
||||
ss.ss_sp = lss.ss_sp;
|
||||
ss.ss_size = lss.ss_size;
|
||||
ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
|
||||
}
|
||||
oss = (uap->uoss != NULL)
|
||||
? stackgap_alloc(&sg, sizeof(stack_t))
|
||||
: NULL;
|
||||
|
||||
bsd.ss = ss;
|
||||
bsd.oss = oss;
|
||||
error = sigaltstack(td, &bsd);
|
||||
|
||||
if (!error && oss != NULL) {
|
||||
lss.ss_sp = oss->ss_sp;
|
||||
lss.ss_size = oss->ss_size;
|
||||
lss.ss_flags = bsd_to_linux_sigaltstack(oss->ss_flags);
|
||||
error = kern_sigaltstack(td, (uap->uoss != NULL) ? &oss : NULL,
|
||||
(uap->uss != NULL) ? &ss : NULL);
|
||||
if (!error && uap->uoss != NULL) {
|
||||
lss.ss_sp = oss.ss_sp;
|
||||
lss.ss_size = oss.ss_size;
|
||||
lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags);
|
||||
error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
|
||||
}
|
||||
|
||||
|
||||
@ -45,6 +45,7 @@
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/proc.h>
|
||||
#include <sys/signalvar.h>
|
||||
#include <sys/syscallsubr.h>
|
||||
#include <sys/sysent.h>
|
||||
#include <sys/sysproto.h>
|
||||
|
||||
@ -597,14 +598,12 @@ linux_rt_sigreturn(td, args)
|
||||
struct linux_rt_sigreturn_args *args;
|
||||
{
|
||||
struct proc *p = td->td_proc;
|
||||
struct sigaltstack_args sasargs;
|
||||
struct l_ucontext uc;
|
||||
struct l_sigcontext *context;
|
||||
l_stack_t *lss;
|
||||
stack_t *ss;
|
||||
stack_t ss;
|
||||
register struct trapframe *regs;
|
||||
int eflags;
|
||||
caddr_t sg = stackgap_init();
|
||||
|
||||
regs = td->td_frame;
|
||||
|
||||
@ -681,20 +680,17 @@ linux_rt_sigreturn(td, args)
|
||||
/*
|
||||
* call sigaltstack & ignore results..
|
||||
*/
|
||||
ss = stackgap_alloc(&sg, sizeof(stack_t));
|
||||
lss = &uc.uc_stack;
|
||||
ss->ss_sp = lss->ss_sp;
|
||||
ss->ss_size = lss->ss_size;
|
||||
ss->ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
|
||||
ss.ss_sp = lss->ss_sp;
|
||||
ss.ss_size = lss->ss_size;
|
||||
ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
|
||||
|
||||
#ifdef DEBUG
|
||||
if (ldebug(rt_sigreturn))
|
||||
printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
|
||||
ss->ss_flags, ss->ss_sp, ss->ss_size, context->sc_mask);
|
||||
ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
|
||||
#endif
|
||||
sasargs.ss = ss;
|
||||
sasargs.oss = NULL;
|
||||
(void) sigaltstack(td, &sasargs);
|
||||
(void)kern_sigaltstack(td, &ss, NULL);
|
||||
|
||||
return (EJUSTRETURN);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user