/*      $NetBSD: linux_misc_notalpha.c,v 1.115 2022/05/22 11:27:34 andvar Exp $ */

/*-
* Copyright (c) 1995, 1998, 2008, 2020 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Frank van der Linden and Eric Haszlakiewicz; by Jason R. Thorpe
* of the Numerical Aerospace Simulation Facility, NASA Ames Research Center.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: linux_misc_notalpha.c,v 1.115 2022/05/22 11:27:34 andvar Exp $");

/*
* Note that we must NOT include "opt_compat_linux32.h" here,
* the maze of ifdefs below relies on COMPAT_LINUX32 only being
* defined when this file is built for linux32.
*/

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/mman.h>
#include <sys/mount.h>
#include <sys/mbuf.h>
#include <sys/namei.h>
#include <sys/proc.h>
#include <sys/prot.h>
#include <sys/ptrace.h>
#include <sys/resource.h>
#include <sys/resourcevar.h>
#include <sys/time.h>
#include <sys/vfs_syscalls.h>
#include <sys/wait.h>
#include <sys/kauth.h>

#include <sys/syscallargs.h>

#include <compat/linux/common/linux_types.h>
#include <compat/linux/common/linux_fcntl.h>
#include <compat/linux/common/linux_misc.h>
#include <compat/linux/common/linux_mmap.h>
#include <compat/linux/common/linux_signal.h>
#include <compat/linux/common/linux_util.h>
#include <compat/linux/common/linux_ipc.h>
#include <compat/linux/common/linux_sem.h>
#include <compat/linux/common/linux_statfs.h>

#include <compat/linux/linux_syscallargs.h>

/*
* This file contains routines which are used
* on every linux architecture except the Alpha.
*/

/* Used on: arm, aarch64, i386, m68k, mips, ppc, sparc, sparc64 */
/* Not used on: alpha */

#ifdef DEBUG_LINUX
#define DPRINTF(a)      uprintf a
#else
#define DPRINTF(a)
#endif

#ifndef COMPAT_LINUX32
/*
* Alarm. This is a libc call which uses setitimer(2) in NetBSD.
* Do the same here.
*/
int
linux_sys_alarm(struct lwp *l, const struct linux_sys_alarm_args *uap, register_t *retval)
{
       /* {
               syscallarg(unsigned int) secs;
       } */
       struct proc *p = l->l_proc;
       struct itimerval itv, oitv;
       int error;

       timerclear(&itv.it_interval);
       itv.it_value.tv_sec = SCARG(uap, secs);
       itv.it_value.tv_usec = 0;
       if (itv.it_value.tv_sec < 0) {
               return EINVAL;
       }

       if ((error = dogetitimer(p, ITIMER_REAL, &oitv)) != 0) {
               return error;
       }
       if (oitv.it_value.tv_usec) {
               oitv.it_value.tv_sec++;
       }

       if ((error = dosetitimer(p, ITIMER_REAL, &itv)) != 0) {
               return error;
       }

       *retval = oitv.it_value.tv_sec;
       return 0;
}
#endif /* !COMPAT_LINUX32 */

#if !defined(__aarch64__) && !defined(__amd64__)
int
linux_sys_nice(struct lwp *l, const struct linux_sys_nice_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) incr;
       } */
       struct proc *p = l->l_proc;
       struct sys_setpriority_args bsa;
       int error;

       SCARG(&bsa, which) = PRIO_PROCESS;
       SCARG(&bsa, who) = 0;
       SCARG(&bsa, prio) = p->p_nice - NZERO + SCARG(uap, incr);

       error = sys_setpriority(l, &bsa, retval);
       return (error) ? EPERM : 0;
}
#endif /* !__aarch64__ && !__amd64__ */

#ifndef COMPAT_LINUX32
#if !defined(__aarch64__) && !defined(__amd64__)
/*
* The old Linux readdir was only able to read one entry at a time,
* even though it had a 'count' argument. In fact, the emulation
* of the old call was better than the original, because it did handle
* the count arg properly. Don't bother with it anymore now, and use
* it to distinguish between old and new. The difference is that the
* newer one actually does multiple entries, and the reclen field
* really is the reclen, not the namelength.
*/
int
linux_sys_readdir(struct lwp *l, const struct linux_sys_readdir_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) fd;
               syscallarg(struct linux_dirent *) dent;
               syscallarg(unsigned int) count;
       } */
       int error;
       struct linux_sys_getdents_args da;

       SCARG(&da, fd) = SCARG(uap, fd);
       SCARG(&da, dent) = SCARG(uap, dent);
       SCARG(&da, count) = 1;

       error = linux_sys_getdents(l, &da, retval);
       if (error == 0 && *retval > 1)
               *retval = 1;

       return error;
}
#endif /* !aarch64 && !amd64 */

#if !defined(__aarch64__)
/*
* I wonder why Linux has gettimeofday() _and_ time().. Still, we
* need to deal with it.
*/
int
linux_sys_time(struct lwp *l, const struct linux_sys_time_args *uap, register_t *retval)
{
       /* {
               syscallarg(linux_time_t) *t;
       } */
       struct timeval atv;
       linux_time_t tt;
       int error;

       microtime(&atv);

       tt = atv.tv_sec;
       if (SCARG(uap, t) && (error = copyout(&tt, SCARG(uap, t), sizeof tt)))
               return error;

       retval[0] = tt;
       return 0;
}
#endif

#if !defined(__aarch64__)
/*
* utime(). Do conversion to things that utimes() understands,
* and pass it on.
*/
int
linux_sys_utime(struct lwp *l, const struct linux_sys_utime_args *uap, register_t *retval)
{
       /* {
               syscallarg(const char *) path;
               syscallarg(struct linux_utimbuf *)times;
       } */
       int error;
       struct timeval tv[2], *tvp;
       struct linux_utimbuf lut;

       if (SCARG(uap, times) != NULL) {
               if ((error = copyin(SCARG(uap, times), &lut, sizeof lut)))
                       return error;
               tv[0].tv_usec = tv[1].tv_usec = 0;
               tv[0].tv_sec = lut.l_actime;
               tv[1].tv_sec = lut.l_modtime;
               tvp = tv;
       } else
               tvp = NULL;

       return do_sys_utimes(l, NULL, SCARG(uap, path), FOLLOW,
                          tvp,  UIO_SYSSPACE);
}
#endif

#if !defined(__aarch64__) && !defined(__amd64__)
/*
* waitpid(2).  Just forward on to linux_sys_wait4 with a NULL rusage.
*/
int
linux_sys_waitpid(struct lwp *l, const struct linux_sys_waitpid_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) pid;
               syscallarg(int *) status;
               syscallarg(int) options;
       } */
       struct linux_sys_wait4_args linux_w4a;

       SCARG(&linux_w4a, pid) = SCARG(uap, pid);
       SCARG(&linux_w4a, status) = SCARG(uap, status);
       SCARG(&linux_w4a, options) = SCARG(uap, options);
       SCARG(&linux_w4a, rusage) = NULL;

       return linux_sys_wait4(l, &linux_w4a, retval);
}
#endif /* !aarch64 && !amd64 */

int
linux_sys_setresgid(struct lwp *l, const struct linux_sys_setresgid_args *uap, register_t *retval)
{
       /* {
               syscallarg(gid_t) rgid;
               syscallarg(gid_t) egid;
               syscallarg(gid_t) sgid;
       } */

       /*
        * Note: These checks are a little different than the NetBSD
        * setregid(2) call performs.  This precisely follows the
        * behavior of the Linux kernel.
        */
       return do_setresgid(l, SCARG(uap,rgid), SCARG(uap, egid),
                           SCARG(uap, sgid),
                           ID_R_EQ_R | ID_R_EQ_E | ID_R_EQ_S |
                           ID_E_EQ_R | ID_E_EQ_E | ID_E_EQ_S |
                           ID_S_EQ_R | ID_S_EQ_E | ID_S_EQ_S );
}

int
linux_sys_getresgid(struct lwp *l, const struct linux_sys_getresgid_args *uap, register_t *retval)
{
       /* {
               syscallarg(gid_t *) rgid;
               syscallarg(gid_t *) egid;
               syscallarg(gid_t *) sgid;
       } */
       kauth_cred_t pc = l->l_cred;
       int error;
       gid_t gid;

       /*
        * Linux copies these values out to userspace like so:
        *
        *      1. Copy out rgid.
        *      2. If that succeeds, copy out egid.
        *      3. If both of those succeed, copy out sgid.
        */
       gid = kauth_cred_getgid(pc);
       if ((error = copyout(&gid, SCARG(uap, rgid), sizeof(gid_t))) != 0)
               return (error);

       gid = kauth_cred_getegid(pc);
       if ((error = copyout(&gid, SCARG(uap, egid), sizeof(gid_t))) != 0)
               return (error);

       gid = kauth_cred_getsvgid(pc);

       return (copyout(&gid, SCARG(uap, sgid), sizeof(gid_t)));
}

#if !defined(__aarch64__) && !defined(__amd64__)
/*
* I wonder why Linux has settimeofday() _and_ stime().. Still, we
* need to deal with it.
*/
int
linux_sys_stime(struct lwp *l, const struct linux_sys_stime_args *uap, register_t *retval)
{
       /* {
               syscallarg(linux_time_t) *t;
       } */
       struct timespec ats;
       linux_time_t tt;
       int error;

       if ((error = copyin(SCARG(uap, t), &tt, sizeof tt)) != 0)
               return error;

       ats.tv_sec = tt;
       ats.tv_nsec = 0;

       if ((error = settime(l->l_proc, &ats)))
               return (error);

       return 0;
}

/*
* Implement the fs stat functions. Straightforward.
*/
int
linux_sys_statfs64(struct lwp *l, const struct linux_sys_statfs64_args *uap, register_t *retval)
{
       /* {
               syscallarg(const char *) path;
               syscallarg(size_t) sz;
               syscallarg(struct linux_statfs64 *) sp;
       } */
       struct statvfs *sb;
       struct linux_statfs64 ltmp;
       int error;

       if (SCARG(uap, sz) != sizeof ltmp)
               return (EINVAL);

       sb = STATVFSBUF_GET();
       error = do_sys_pstatvfs(l, SCARG(uap, path), ST_WAIT, sb);
       if (error == 0) {
               bsd_to_linux_statfs64(sb, &ltmp);
               error = copyout(&ltmp, SCARG(uap, sp), sizeof ltmp);
       }
       STATVFSBUF_PUT(sb);
       return error;
}

int
linux_sys_fstatfs64(struct lwp *l, const struct linux_sys_fstatfs64_args *uap, register_t *retval)
{
       /* {
               syscallarg(int) fd;
               syscallarg(size_t) sz;
               syscallarg(struct linux_statfs64 *) sp;
       } */
       struct statvfs *sb;
       struct linux_statfs64 ltmp;
       int error;

       if (SCARG(uap, sz) != sizeof ltmp)
               return (EINVAL);

       sb = STATVFSBUF_GET();
       error = do_sys_fstatvfs(l, SCARG(uap, fd), ST_WAIT, sb);
       if (error == 0) {
               bsd_to_linux_statfs64(sb, &ltmp);
               error = copyout(&ltmp, SCARG(uap, sp), sizeof ltmp);
       }
       STATVFSBUF_PUT(sb);
       return error;
}
#endif /* !aarch64 && !__amd64__ */
#endif /* !COMPAT_LINUX32 */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.