/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <utime.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/poll.h>
#include <sys/file.h>
#include <sys/syscall.h>

#include <s10_brand.h>
#include <brand_misc.h>
#include <s10_misc.h>

/*
 * This file contains the emulation functions for all of the
 * obsolete system call traps that existed in Solaris 10 but
 * that have been deleted in the current version of Solaris.
 */

static int
s10_fstatat(sysret_t *rval,
    int fd, const char *path, struct stat *sb, int flags)
{
	return (__systemcall(rval, SYS_fstatat + 1024,
	    fd, path, sb, flags));
}

int
s10_stat(sysret_t *rval, const char *path, struct stat *sb)
{
	return (__systemcall(rval, SYS_fstatat + 1024,
	    AT_FDCWD, path, sb, 0));
}

int
s10_lstat(sysret_t *rval, const char *path, struct stat *sb)
{
	return (__systemcall(rval, SYS_fstatat + 1024,
	    AT_FDCWD, path, sb, AT_SYMLINK_NOFOLLOW));
}

int
s10_fstat(sysret_t *rval, int filedes, struct stat *sb)
{
	return (__systemcall(rval, SYS_fstatat + 1024,
	    filedes, NULL, sb, 0));
}

#if !defined(_LP64)

static int
s10_fstatat64(sysret_t *rval,
    int fd, const char *path, struct stat64 *sb, int flags)
{
	return (__systemcall(rval, SYS_fstatat64 + 1024,
	    fd, path, sb, flags));
}

int
s10_stat64(sysret_t *rval, const char *path, struct stat64 *sb)
{
	return (__systemcall(rval, SYS_fstatat64 + 1024,
	    AT_FDCWD, path, sb, 0));
}

int
s10_lstat64(sysret_t *rval, const char *path, struct stat64 *sb)
{
	return (__systemcall(rval, SYS_fstatat64 + 1024,
	    AT_FDCWD, path, sb, AT_SYMLINK_NOFOLLOW));
}

int
s10_fstat64(sysret_t *rval, int filedes, struct stat64 *sb)
{
	return (__systemcall(rval, SYS_fstatat64 + 1024,
	    filedes, NULL, sb, 0));
}

#endif	/* !_LP64 */

static int
s10_openat(sysret_t *rval, int fd, const char *path, int oflag, mode_t mode)
{
	return (__systemcall(rval, SYS_openat + 1024,
	    fd, path, oflag, mode));
}

int
s10_open(sysret_t *rval, char *path, int oflag, mode_t mode)
{
	return (__systemcall(rval, SYS_openat + 1024,
	    AT_FDCWD, path, oflag, mode));
}

int
s10_creat(sysret_t *rval, char *path, mode_t mode)
{
	return (__systemcall(rval, SYS_openat + 1024,
	    AT_FDCWD, path, O_WRONLY | O_CREAT | O_TRUNC, mode));
}

#if !defined(_LP64)

static int
s10_openat64(sysret_t *rval, int fd, const char *path, int oflag, mode_t mode)
{
	return (__systemcall(rval, SYS_openat64 + 1024,
	    fd, path, oflag, mode));
}

int
s10_open64(sysret_t *rval, char *path, int oflag, mode_t mode)
{
	return (__systemcall(rval, SYS_openat64 + 1024,
	    AT_FDCWD, path, oflag, mode));
}

int
s10_creat64(sysret_t *rval, char *path, mode_t mode)
{
	return (__systemcall(rval, SYS_openat64 + 1024,
	    AT_FDCWD, path, O_WRONLY | O_CREAT | O_TRUNC, mode));
}

#endif	/* !_LP64 */

int
s10_fork1(sysret_t *rval)
{
	return (__systemcall(rval, SYS_forksys + 1024, 0, 0));
}

int
s10_forkall(sysret_t *rval)
{
	return (__systemcall(rval, SYS_forksys + 1024, 1, 0));
}

int
s10_dup(sysret_t *rval, int fd)
{
	return (__systemcall(rval, SYS_fcntl + 1024, fd, F_DUPFD, 0));
}

int
s10_poll(sysret_t *rval, struct pollfd *fds, nfds_t nfd, int timeout)
{
	timespec_t ts;
	timespec_t *tsp;

	if (timeout < 0)
		tsp = NULL;
	else {
		ts.tv_sec = timeout / MILLISEC;
		ts.tv_nsec = (timeout % MILLISEC) * MICROSEC;
		tsp = &ts;
	}

	return (__systemcall(rval, SYS_pollsys + 1024,
	    fds, nfd, tsp, NULL));
}

int
s10_lwp_mutex_lock(sysret_t *rval, void *mp)
{
	return (__systemcall(rval, SYS_lwp_mutex_timedlock + 1024,
	    mp, NULL, 0));
}

int
s10_lwp_sema_wait(sysret_t *rval, void *sp)
{
	return (__systemcall(rval, SYS_lwp_sema_timedwait + 1024,
	    sp, NULL, 0));
}

int
s10_chmod(sysret_t *rval, const char *name, mode_t mode)
{
	return (__systemcall(rval, SYS_fchmodat + 1024,
	    AT_FDCWD, name, mode, 0));
}

int
s10_fchmod(sysret_t *rval, int filedes, mode_t mode)
{
	return (__systemcall(rval, SYS_fchmodat + 1024,
	    filedes, NULL, mode, 0));
}

static int
s10_fchownat(sysret_t *rval,
    int fd, const char *name, uid_t uid, gid_t gid, int flag)
{
	return (__systemcall(rval, SYS_fchownat + 1024,
	    fd, name, uid, gid, flag));
}

int
s10_chown(sysret_t *rval, const char *name, uid_t uid, gid_t gid)
{
	return (__systemcall(rval, SYS_fchownat + 1024,
	    AT_FDCWD, name, uid, gid, 0));
}

int
s10_lchown(sysret_t *rval, const char *name, uid_t uid, gid_t gid)
{
	return (__systemcall(rval, SYS_fchownat + 1024,
	    AT_FDCWD, name, uid, gid, AT_SYMLINK_NOFOLLOW));
}

int
s10_fchown(sysret_t *rval, int filedes, uid_t uid, gid_t gid)
{
	return (__systemcall(rval, SYS_fchownat + 1024,
	    filedes, NULL, uid, gid, 0));
}

int
s10_mkdir(sysret_t *rval, const char *dname, int dmode)
{
	return (__systemcall(rval, SYS_mkdirat + 1024,
	    AT_FDCWD, dname, dmode));
}

int
s10_mknod(sysret_t *rval, const char *fname, int fmode, dev_t dev)
{
	return (__systemcall(rval, SYS_mknodat + 1024,
	    AT_FDCWD, fname, fmode, dev));
}

int
s10_link(sysret_t *rval, const char *path1, const char *path2)
{
	return (__systemcall(rval, SYS_linkat + 1024,
	    AT_FDCWD, path1, AT_FDCWD, path2, 0));
}

static int
s10_unlinkat(sysret_t *rval, int fd, const char *name, int flags)
{
	return (__systemcall(rval, SYS_unlinkat + 1024,
	    fd, name, flags));
}

int
s10_unlink(sysret_t *rval, const char *name)
{
	return (__systemcall(rval, SYS_unlinkat + 1024,
	    AT_FDCWD, name, 0));
}

int
s10_rmdir(sysret_t *rval, const char *name)
{
	return (__systemcall(rval, SYS_unlinkat + 1024,
	    AT_FDCWD, name, AT_REMOVEDIR));
}

static int
s10_renameat(sysret_t *rval,
    int oldfd, const char *oldname, int newfd, const char *newname)
{
	return (__systemcall(rval, SYS_renameat + 1024,
	    oldfd, oldname, newfd, newname));
}

int
s10_rename(sysret_t *rval, const char *oldname, const char *newname)
{
	return (__systemcall(rval, SYS_renameat + 1024,
	    AT_FDCWD, oldname, AT_FDCWD, newname));
}

int
s10_symlink(sysret_t *rval, const char *path1, const char *path2)
{
	return (__systemcall(rval, SYS_symlinkat +  1024,
	    path1, AT_FDCWD, path2));
}

int
s10_readlink(sysret_t *rval, const char *path, char *buf, size_t bufsize)
{
	return (__systemcall(rval, SYS_readlinkat +  1024,
	    AT_FDCWD, path, buf, bufsize));
}

static int
s10_faccessat(sysret_t *rval, int fd, const char *fname, int amode, int flag)
{
	return (__systemcall(rval, SYS_faccessat + 1024,
	    fd, fname, amode, flag));
}

int
s10_access(sysret_t *rval, const char *fname, int amode)
{
	return (__systemcall(rval, SYS_faccessat + 1024,
	    AT_FDCWD, fname, amode, 0));
}

int
s10_utime(sysret_t *rval, const char *path, const struct utimbuf *times)
{
	struct utimbuf ltimes;
	timespec_t ts[2];
	timespec_t *tsp;

	if (times == NULL) {
		tsp = NULL;
	} else {
		if (brand_uucopy(times, &ltimes, sizeof (ltimes)) != 0)
			return (EFAULT);
		ts[0].tv_sec = ltimes.actime;
		ts[0].tv_nsec = 0;
		ts[1].tv_sec = ltimes.modtime;
		ts[1].tv_nsec = 0;
		tsp = ts;
	}

	return (__systemcall(rval, SYS_utimesys + 1024, 1,
	    AT_FDCWD, path, tsp, 0));
}

int
s10_utimes(sysret_t *rval, const char *path, const struct timeval times[2])
{
	struct timeval ltimes[2];
	timespec_t ts[2];
	timespec_t *tsp;

	if (times == NULL) {
		tsp = NULL;
	} else {
		if (brand_uucopy(times, ltimes, sizeof (ltimes)) != 0)
			return (EFAULT);
		ts[0].tv_sec = ltimes[0].tv_sec;
		ts[0].tv_nsec = ltimes[0].tv_usec * 1000;
		ts[1].tv_sec = ltimes[1].tv_sec;
		ts[1].tv_nsec = ltimes[1].tv_usec * 1000;
		tsp = ts;
	}

	return (__systemcall(rval, SYS_utimesys + 1024, 1,
	    AT_FDCWD, path, tsp, 0));
}

static int
s10_futimesat(sysret_t *rval,
    int fd, const char *path, const struct timeval times[2])
{
	struct timeval ltimes[2];
	timespec_t ts[2];
	timespec_t *tsp;

	if (times == NULL) {
		tsp = NULL;
	} else {
		if (brand_uucopy(times, ltimes, sizeof (ltimes)) != 0)
			return (EFAULT);
		ts[0].tv_sec = ltimes[0].tv_sec;
		ts[0].tv_nsec = ltimes[0].tv_usec * 1000;
		ts[1].tv_sec = ltimes[1].tv_sec;
		ts[1].tv_nsec = ltimes[1].tv_usec * 1000;
		tsp = ts;
	}

	if (path == NULL)
		return (__systemcall(rval, SYS_utimesys + 1024, 0, fd, tsp));

	return (__systemcall(rval, SYS_utimesys + 1024, 1, fd, path, tsp, 0));
}

#if defined(__x86)

/* ARGSUSED */
int
s10_xstat(sysret_t *rval, int version, const char *path, struct stat *statb)
{
#if defined(__amd64)
	return (EINVAL);
#else
	if (version != _STAT_VER)
		return (EINVAL);
	return (__systemcall(rval, SYS_fstatat + 1024,
	    AT_FDCWD, path, statb, 0));
#endif
}

/* ARGSUSED */
int
s10_lxstat(sysret_t *rval, int version, const char *path, struct stat *statb)
{
#if defined(__amd64)
	return (EINVAL);
#else
	if (version != _STAT_VER)
		return (EINVAL);
	return (__systemcall(rval, SYS_fstatat + 1024,
	    AT_FDCWD, path, statb, AT_SYMLINK_NOFOLLOW));
#endif
}

/* ARGSUSED */
int
s10_fxstat(sysret_t *rval, int version, int fd, struct stat *statb)
{
#if defined(__amd64)
	return (EINVAL);
#else
	if (version != _STAT_VER)
		return (EINVAL);
	return (__systemcall(rval, SYS_fstatat + 1024,
	    fd, NULL, statb, 0));
#endif
}

/* ARGSUSED */
int
s10_xmknod(sysret_t *rval, int version, const char *path,
    mode_t mode, dev_t dev)
{
#if defined(__amd64)
	return (EINVAL);
#else
	if (version != _MKNOD_VER)
		return (EINVAL);
	return (__systemcall(rval, SYS_mknodat + 1024,
	    AT_FDCWD, path, mode, dev));
#endif
}

#endif	/* __x86 */

/*
 * This is the fsat() system call trap in s10.
 * It has been removed in the current system.
 */
int
s10_fsat(sysret_t *rval,
    int code, uintptr_t arg1, uintptr_t arg2,
    uintptr_t arg3, uintptr_t arg4, uintptr_t arg5)
{
	switch (code) {
	case 0:		/* openat */
		return (s10_openat(rval, (int)arg1,
		    (const char *)arg2, (int)arg3, (mode_t)arg4));
	case 1:		/* openat64 */
#if defined(_LP64)
		return (EINVAL);
#else
		return (s10_openat64(rval, (int)arg1,
		    (const char *)arg2, (int)arg3, (mode_t)arg4));
#endif
	case 2:		/* fstatat64 */
#if defined(_LP64)
		return (EINVAL);
#else
		return (s10_fstatat64(rval, (int)arg1,
		    (const char *)arg2, (struct stat64 *)arg3, (int)arg4));
#endif
	case 3:		/* fstatat */
		return (s10_fstatat(rval, (int)arg1,
		    (const char *)arg2, (struct stat *)arg3, (int)arg4));
	case 4:		/* fchownat */
		return (s10_fchownat(rval, (int)arg1, (char *)arg2,
		    (uid_t)arg3, (gid_t)arg4, (int)arg5));
	case 5:		/* unlinkat */
		return (s10_unlinkat(rval, (int)arg1, (char *)arg2,
		    (int)arg3));
	case 6:		/* futimesat */
		return (s10_futimesat(rval, (int)arg1,
		    (const char *)arg2, (const struct timeval *)arg3));
	case 7:		/* renameat */
		return (s10_renameat(rval, (int)arg1, (char *)arg2,
		    (int)arg3, (char *)arg4));
	case 8:		/* faccessat */
		return (s10_faccessat(rval, (int)arg1, (char *)arg2,
		    (int)arg3, (int)arg4));
	case 9:		/* openattrdirat */
		return (s10_openat(rval, (int)arg1,
		    (const char *)arg2, FXATTRDIROPEN, 0));
	}
	return (EINVAL);
}

/*
 * Interposition upon SYS_umount
 */
int
s10_umount(sysret_t *rval, const char *path)
{
	return (__systemcall(rval, SYS_umount2 + 1024, path, 0));
}