292bfd0f51
Signed-off-by: Mikaël Urankar <mikael.urankar@gmail.com> Signed-off-by: Karim Taha <kariem.taha2.7@gmail.com> Reviewed-by: Richard Henderson <richard.henderson@linaro.org> Signed-off-by: Warner Losh <imp@bsdimp.com>
664 lines
18 KiB
C
664 lines
18 KiB
C
/*
|
|
* stat related system call shims and definitions
|
|
*
|
|
* Copyright (c) 2013 Stacey D. Son
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef BSD_USER_FREEBSD_OS_STAT_H
|
|
#define BSD_USER_FREEBSD_OS_STAT_H
|
|
|
|
int freebsd11_stat(const char *path, struct freebsd11_stat *stat);
|
|
__sym_compat(stat, freebsd11_stat, FBSD_1.0);
|
|
int freebsd11_lstat(const char *path, struct freebsd11_stat *stat);
|
|
__sym_compat(lstat, freebsd11_lstat, FBSD_1.0);
|
|
int freebsd11_fstat(int fd, struct freebsd11_stat *stat);
|
|
__sym_compat(fstat, freebsd11_fstat, FBSD_1.0);
|
|
int freebsd11_fstatat(int fd, const char *path, struct freebsd11_stat *stat,
|
|
int flag);
|
|
__sym_compat(fstatat, freebsd11_fstatat, FBSD_1.1);
|
|
|
|
int freebsd11_fhstat(const fhandle_t *fhandle, struct freebsd11_stat *stat);
|
|
__sym_compat(fhstat, freebsd11_fhstat, FBSD_1.0);
|
|
int freebsd11_getfsstat(struct freebsd11_statfs *buf, long bufsize, int mode);
|
|
__sym_compat(getfsstat, freebsd11_getfsstat, FBSD_1.0);
|
|
int freebsd11_fhstatfs(const fhandle_t *fhandle, struct freebsd11_statfs * buf);
|
|
__sym_compat(fhstatfs, freebsd11_fhstatfs, FBSD_1.0);
|
|
int freebsd11_statfs(const char *path, struct freebsd11_statfs *buf);
|
|
__sym_compat(statfs, freebsd11_statfs, FBSD_1.0);
|
|
int freebsd11_fstatfs(int fd, struct freebsd11_statfs *buf);
|
|
__sym_compat(fstatfs, freebsd11_fstatfs, FBSD_1.0);
|
|
|
|
ssize_t freebsd11_getdirentries(int fd, char *buf, size_t nbytes, off_t *basep);
|
|
__sym_compat(getdirentries, freebsd11_getdirentries, FBSD_1.0);
|
|
ssize_t freebsd11_getdents(int fd, char *buf, size_t nbytes);
|
|
__sym_compat(getdents, freebsd11_getdents, FBSD_1.0);
|
|
|
|
/* undocumented nstat system calls */
|
|
int freebsd11_nstat(const char *path, struct freebsd11_stat *sb);
|
|
__sym_compat(nstat, freebsd11_nstat, FBSD_1.0);
|
|
int freebsd11_nlstat(const char *path, struct freebsd11_stat *sb);
|
|
__sym_compat(nlstat, freebsd11_nlstat, FBSD_1.0);
|
|
int freebsd11_nfstat(int fd, struct freebsd11_stat *sb);
|
|
__sym_compat(nfstat, freebsd11_nfstat, FBSD_1.0);
|
|
|
|
/* stat(2) */
|
|
static inline abi_long do_freebsd11_stat(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
struct freebsd11_stat st;
|
|
|
|
LOCK_PATH(p, arg1);
|
|
ret = get_errno(freebsd11_stat(path(p), &st));
|
|
UNLOCK_PATH(p, arg1);
|
|
if (!is_error(ret)) {
|
|
ret = h2t_freebsd11_stat(arg2, &st);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* lstat(2) */
|
|
static inline abi_long do_freebsd11_lstat(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
struct freebsd11_stat st;
|
|
|
|
LOCK_PATH(p, arg1);
|
|
ret = get_errno(freebsd11_lstat(path(p), &st));
|
|
UNLOCK_PATH(p, arg1);
|
|
if (!is_error(ret)) {
|
|
ret = h2t_freebsd11_stat(arg2, &st);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* fstat(2) */
|
|
static inline abi_long do_freebsd11_fstat(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
struct freebsd11_stat st;
|
|
|
|
ret = get_errno(freebsd11_fstat(arg1, &st));
|
|
if (!is_error(ret)) {
|
|
ret = h2t_freebsd11_stat(arg2, &st);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* fstat(2) */
|
|
static inline abi_long do_freebsd_fstat(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
struct stat st;
|
|
|
|
ret = get_errno(fstat(arg1, &st));
|
|
if (!is_error(ret)) {
|
|
ret = h2t_freebsd_stat(arg2, &st);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* fstatat(2) */
|
|
static inline abi_long do_freebsd11_fstatat(abi_long arg1, abi_long arg2,
|
|
abi_long arg3, abi_long arg4)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
struct freebsd11_stat st;
|
|
|
|
LOCK_PATH(p, arg2);
|
|
ret = get_errno(freebsd11_fstatat(arg1, p, &st, arg4));
|
|
UNLOCK_PATH(p, arg2);
|
|
if (!is_error(ret) && arg3) {
|
|
ret = h2t_freebsd11_stat(arg3, &st);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* fstatat(2) */
|
|
static inline abi_long do_freebsd_fstatat(abi_long arg1, abi_long arg2,
|
|
abi_long arg3, abi_long arg4)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
struct stat st;
|
|
|
|
LOCK_PATH(p, arg2);
|
|
ret = get_errno(fstatat(arg1, p, &st, arg4));
|
|
UNLOCK_PATH(p, arg2);
|
|
if (!is_error(ret) && arg3) {
|
|
ret = h2t_freebsd_stat(arg3, &st);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* undocummented nstat(char *path, struct nstat *ub) syscall */
|
|
static abi_long do_freebsd11_nstat(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
struct freebsd11_stat st;
|
|
|
|
LOCK_PATH(p, arg1);
|
|
ret = get_errno(freebsd11_nstat(path(p), &st));
|
|
UNLOCK_PATH(p, arg1);
|
|
if (!is_error(ret)) {
|
|
ret = h2t_freebsd11_nstat(arg2, &st);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* undocummented nfstat(int fd, struct nstat *sb) syscall */
|
|
static abi_long do_freebsd11_nfstat(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
struct freebsd11_stat st;
|
|
|
|
ret = get_errno(freebsd11_nfstat(arg1, &st));
|
|
if (!is_error(ret)) {
|
|
ret = h2t_freebsd11_nstat(arg2, &st);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* undocummented nlstat(char *path, struct nstat *ub) syscall */
|
|
static abi_long do_freebsd11_nlstat(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
struct freebsd11_stat st;
|
|
|
|
LOCK_PATH(p, arg1);
|
|
ret = get_errno(freebsd11_nlstat(path(p), &st));
|
|
UNLOCK_PATH(p, arg1);
|
|
if (!is_error(ret)) {
|
|
ret = h2t_freebsd11_nstat(arg2, &st);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* getfh(2) */
|
|
static abi_long do_freebsd_getfh(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
fhandle_t host_fh;
|
|
|
|
LOCK_PATH(p, arg1);
|
|
ret = get_errno(getfh(path(p), &host_fh));
|
|
UNLOCK_PATH(p, arg1);
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
return h2t_freebsd_fhandle(arg2, &host_fh);
|
|
}
|
|
|
|
/* lgetfh(2) */
|
|
static inline abi_long do_freebsd_lgetfh(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
fhandle_t host_fh;
|
|
|
|
LOCK_PATH(p, arg1);
|
|
ret = get_errno(lgetfh(path(p), &host_fh));
|
|
UNLOCK_PATH(p, arg1);
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
return h2t_freebsd_fhandle(arg2, &host_fh);
|
|
}
|
|
|
|
/* fhopen(2) */
|
|
static inline abi_long do_freebsd_fhopen(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
fhandle_t host_fh;
|
|
|
|
ret = t2h_freebsd_fhandle(&host_fh, arg1);
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
|
|
return get_errno(fhopen(&host_fh, arg2));
|
|
}
|
|
|
|
/* fhstat(2) */
|
|
static inline abi_long do_freebsd11_fhstat(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
fhandle_t host_fh;
|
|
struct freebsd11_stat host_sb;
|
|
|
|
ret = t2h_freebsd_fhandle(&host_fh, arg1);
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
ret = get_errno(freebsd11_fhstat(&host_fh, &host_sb));
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
return h2t_freebsd11_stat(arg2, &host_sb);
|
|
}
|
|
|
|
/* fhstat(2) */
|
|
static inline abi_long do_freebsd_fhstat(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
fhandle_t host_fh;
|
|
struct stat host_sb;
|
|
|
|
ret = t2h_freebsd_fhandle(&host_fh, arg1);
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
ret = get_errno(fhstat(&host_fh, &host_sb));
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
return h2t_freebsd_stat(arg2, &host_sb);
|
|
}
|
|
|
|
/* fhstatfs(2) */
|
|
static inline abi_long do_freebsd11_fhstatfs(abi_ulong target_fhp_addr,
|
|
abi_ulong target_stfs_addr)
|
|
{
|
|
abi_long ret;
|
|
fhandle_t host_fh;
|
|
struct freebsd11_statfs host_stfs;
|
|
|
|
ret = t2h_freebsd_fhandle(&host_fh, target_fhp_addr);
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
ret = get_errno(freebsd11_fhstatfs(&host_fh, &host_stfs));
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
return h2t_freebsd11_statfs(target_stfs_addr, &host_stfs);
|
|
}
|
|
|
|
/* fhstatfs(2) */
|
|
static inline abi_long do_freebsd_fhstatfs(abi_ulong target_fhp_addr,
|
|
abi_ulong target_stfs_addr)
|
|
{
|
|
abi_long ret;
|
|
fhandle_t host_fh;
|
|
struct statfs host_stfs;
|
|
|
|
ret = t2h_freebsd_fhandle(&host_fh, target_fhp_addr);
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
ret = get_errno(fhstatfs(&host_fh, &host_stfs));
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
return h2t_freebsd_statfs(target_stfs_addr, &host_stfs);
|
|
}
|
|
|
|
/* statfs(2) */
|
|
static inline abi_long do_freebsd11_statfs(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
struct freebsd11_statfs host_stfs;
|
|
|
|
LOCK_PATH(p, arg1);
|
|
ret = get_errno(freebsd11_statfs(path(p), &host_stfs));
|
|
UNLOCK_PATH(p, arg1);
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
|
|
return h2t_freebsd11_statfs(arg2, &host_stfs);
|
|
}
|
|
|
|
/* statfs(2) */
|
|
static inline abi_long do_freebsd_statfs(abi_long arg1, abi_long arg2)
|
|
{
|
|
abi_long ret;
|
|
void *p;
|
|
struct statfs host_stfs;
|
|
|
|
LOCK_PATH(p, arg1);
|
|
ret = get_errno(statfs(path(p), &host_stfs));
|
|
UNLOCK_PATH(p, arg1);
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
|
|
return h2t_freebsd_statfs(arg2, &host_stfs);
|
|
}
|
|
|
|
/* fstatfs(2) */
|
|
static inline abi_long do_freebsd11_fstatfs(abi_long fd, abi_ulong target_addr)
|
|
{
|
|
abi_long ret;
|
|
struct freebsd11_statfs host_stfs;
|
|
|
|
ret = get_errno(freebsd11_fstatfs(fd, &host_stfs));
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
|
|
return h2t_freebsd11_statfs(target_addr, &host_stfs);
|
|
}
|
|
|
|
/* fstatfs(2) */
|
|
static inline abi_long do_freebsd_fstatfs(abi_long fd, abi_ulong target_addr)
|
|
{
|
|
abi_long ret;
|
|
struct statfs host_stfs;
|
|
|
|
ret = get_errno(fstatfs(fd, &host_stfs));
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
|
|
return h2t_freebsd_statfs(target_addr, &host_stfs);
|
|
}
|
|
|
|
/* getfsstat(2) */
|
|
static inline abi_long do_freebsd11_getfsstat(abi_ulong target_addr,
|
|
abi_long bufsize, abi_long flags)
|
|
{
|
|
abi_long ret;
|
|
struct freebsd11_statfs *host_stfs;
|
|
int count;
|
|
long host_bufsize;
|
|
|
|
count = bufsize / sizeof(struct target_freebsd11_statfs);
|
|
|
|
/* if user buffer is NULL then return number of mounted FS's */
|
|
if (target_addr == 0 || count == 0) {
|
|
return get_errno(freebsd11_getfsstat(NULL, 0, flags));
|
|
}
|
|
|
|
/* XXX check count to be reasonable */
|
|
host_bufsize = sizeof(struct freebsd11_statfs) * count;
|
|
host_stfs = alloca(host_bufsize);
|
|
if (!host_stfs) {
|
|
return -TARGET_EINVAL;
|
|
}
|
|
|
|
ret = count = get_errno(freebsd11_getfsstat(host_stfs, host_bufsize, flags));
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
|
|
while (count--) {
|
|
if (h2t_freebsd11_statfs((target_addr +
|
|
(count * sizeof(struct target_freebsd11_statfs))),
|
|
&host_stfs[count])) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* getfsstat(2) */
|
|
static inline abi_long do_freebsd_getfsstat(abi_ulong target_addr,
|
|
abi_long bufsize, abi_long flags)
|
|
{
|
|
abi_long ret;
|
|
struct statfs *host_stfs;
|
|
int count;
|
|
long host_bufsize;
|
|
|
|
count = bufsize / sizeof(struct target_statfs);
|
|
|
|
/* if user buffer is NULL then return number of mounted FS's */
|
|
if (target_addr == 0 || count == 0) {
|
|
return get_errno(freebsd11_getfsstat(NULL, 0, flags));
|
|
}
|
|
|
|
/* XXX check count to be reasonable */
|
|
host_bufsize = sizeof(struct statfs) * count;
|
|
host_stfs = alloca(host_bufsize);
|
|
if (!host_stfs) {
|
|
return -TARGET_EINVAL;
|
|
}
|
|
|
|
ret = count = get_errno(getfsstat(host_stfs, host_bufsize, flags));
|
|
if (is_error(ret)) {
|
|
return ret;
|
|
}
|
|
|
|
while (count--) {
|
|
if (h2t_freebsd_statfs((target_addr +
|
|
(count * sizeof(struct target_statfs))),
|
|
&host_stfs[count])) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* getdents(2) */
|
|
static inline abi_long do_freebsd11_getdents(abi_long arg1,
|
|
abi_ulong arg2, abi_long nbytes)
|
|
{
|
|
abi_long ret;
|
|
struct freebsd11_dirent *dirp;
|
|
|
|
dirp = lock_user(VERIFY_WRITE, arg2, nbytes, 0);
|
|
if (dirp == NULL) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
ret = get_errno(freebsd11_getdents(arg1, (char *)dirp, nbytes));
|
|
if (!is_error(ret)) {
|
|
struct freebsd11_dirent *de;
|
|
int len = ret;
|
|
int reclen;
|
|
|
|
de = dirp;
|
|
while (len > 0) {
|
|
reclen = de->d_reclen;
|
|
if (reclen > len) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
de->d_reclen = tswap16(reclen);
|
|
de->d_fileno = tswap32(de->d_fileno);
|
|
len -= reclen;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* getdirecentries(2) */
|
|
static inline abi_long do_freebsd11_getdirentries(abi_long arg1,
|
|
abi_ulong arg2, abi_long nbytes, abi_ulong arg4)
|
|
{
|
|
abi_long ret;
|
|
struct freebsd11_dirent *dirp;
|
|
long basep;
|
|
|
|
dirp = lock_user(VERIFY_WRITE, arg2, nbytes, 0);
|
|
if (dirp == NULL) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
ret = get_errno(freebsd11_getdirentries(arg1, (char *)dirp, nbytes, &basep));
|
|
if (!is_error(ret)) {
|
|
struct freebsd11_dirent *de;
|
|
int len = ret;
|
|
int reclen;
|
|
|
|
de = dirp;
|
|
while (len > 0) {
|
|
reclen = de->d_reclen;
|
|
if (reclen > len) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
de->d_reclen = tswap16(reclen);
|
|
de->d_fileno = tswap32(de->d_fileno);
|
|
len -= reclen;
|
|
de = (struct freebsd11_dirent *)((void *)de + reclen);
|
|
}
|
|
}
|
|
unlock_user(dirp, arg2, ret);
|
|
if (arg4) {
|
|
if (put_user(basep, arg4, abi_ulong)) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* getdirecentries(2) */
|
|
static inline abi_long do_freebsd_getdirentries(abi_long arg1,
|
|
abi_ulong arg2, abi_long nbytes, abi_ulong arg4)
|
|
{
|
|
abi_long ret;
|
|
struct dirent *dirp;
|
|
long basep;
|
|
|
|
dirp = lock_user(VERIFY_WRITE, arg2, nbytes, 0);
|
|
if (dirp == NULL) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
ret = get_errno(getdirentries(arg1, (char *)dirp, nbytes, &basep));
|
|
if (!is_error(ret)) {
|
|
struct dirent *de;
|
|
int len = ret;
|
|
int reclen;
|
|
|
|
de = dirp;
|
|
while (len > 0) {
|
|
reclen = de->d_reclen;
|
|
if (reclen > len) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
de->d_fileno = tswap64(de->d_fileno);
|
|
de->d_off = tswap64(de->d_off);
|
|
de->d_reclen = tswap16(de->d_reclen);
|
|
de->d_namlen = tswap16(de->d_namlen);
|
|
len -= reclen;
|
|
de = (struct dirent *)((void *)de + reclen);
|
|
}
|
|
}
|
|
unlock_user(dirp, arg2, ret);
|
|
if (arg4) {
|
|
if (put_user(basep, arg4, abi_ulong)) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* fcntl(2) */
|
|
static inline abi_long do_freebsd_fcntl(abi_long arg1, abi_long arg2,
|
|
abi_ulong arg3)
|
|
{
|
|
abi_long ret;
|
|
int host_cmd;
|
|
struct flock fl;
|
|
struct target_freebsd_flock *target_fl;
|
|
|
|
host_cmd = target_to_host_fcntl_cmd(arg2);
|
|
if (host_cmd < 0) {
|
|
return host_cmd;
|
|
}
|
|
switch (arg2) {
|
|
case TARGET_F_GETLK:
|
|
if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
__get_user(fl.l_type, &target_fl->l_type);
|
|
__get_user(fl.l_whence, &target_fl->l_whence);
|
|
__get_user(fl.l_start, &target_fl->l_start);
|
|
__get_user(fl.l_len, &target_fl->l_len);
|
|
__get_user(fl.l_pid, &target_fl->l_pid);
|
|
__get_user(fl.l_sysid, &target_fl->l_sysid);
|
|
unlock_user_struct(target_fl, arg3, 0);
|
|
ret = get_errno(safe_fcntl(arg1, host_cmd, &fl));
|
|
if (!is_error(ret)) {
|
|
if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0)) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
__put_user(fl.l_type, &target_fl->l_type);
|
|
__put_user(fl.l_whence, &target_fl->l_whence);
|
|
__put_user(fl.l_start, &target_fl->l_start);
|
|
__put_user(fl.l_len, &target_fl->l_len);
|
|
__put_user(fl.l_pid, &target_fl->l_pid);
|
|
__put_user(fl.l_sysid, &target_fl->l_sysid);
|
|
unlock_user_struct(target_fl, arg3, 1);
|
|
}
|
|
break;
|
|
|
|
case TARGET_F_SETLK:
|
|
case TARGET_F_SETLKW:
|
|
if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) {
|
|
return -TARGET_EFAULT;
|
|
}
|
|
__get_user(fl.l_type, &target_fl->l_type);
|
|
__get_user(fl.l_whence, &target_fl->l_whence);
|
|
__get_user(fl.l_start, &target_fl->l_start);
|
|
__get_user(fl.l_len, &target_fl->l_len);
|
|
__get_user(fl.l_pid, &target_fl->l_pid);
|
|
__get_user(fl.l_sysid, &target_fl->l_sysid);
|
|
unlock_user_struct(target_fl, arg3, 0);
|
|
ret = get_errno(safe_fcntl(arg1, host_cmd, &fl));
|
|
break;
|
|
|
|
case TARGET_F_DUPFD:
|
|
case TARGET_F_DUP2FD:
|
|
case TARGET_F_GETOWN:
|
|
case TARGET_F_SETOWN:
|
|
case TARGET_F_GETFD:
|
|
case TARGET_F_SETFD:
|
|
case TARGET_F_GETFL:
|
|
case TARGET_F_SETFL:
|
|
case TARGET_F_READAHEAD:
|
|
case TARGET_F_RDAHEAD:
|
|
case TARGET_F_ADD_SEALS:
|
|
case TARGET_F_GET_SEALS:
|
|
default:
|
|
ret = get_errno(safe_fcntl(arg1, host_cmd, arg3));
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
#if defined(__FreeBSD_version) && __FreeBSD_version >= 1300080
|
|
extern int __realpathat(int fd, const char *path, char *buf, size_t size,
|
|
int flags);
|
|
/* https://svnweb.freebsd.org/base?view=revision&revision=358172 */
|
|
/* no man page */
|
|
static inline abi_long do_freebsd_realpathat(abi_long arg1, abi_long arg2,
|
|
abi_long arg3, abi_long arg4, abi_long arg5)
|
|
{
|
|
abi_long ret;
|
|
void *p, *b;
|
|
|
|
LOCK_PATH(p, arg2);
|
|
b = lock_user(VERIFY_WRITE, arg3, arg4, 0);
|
|
if (b == NULL) {
|
|
UNLOCK_PATH(p, arg2);
|
|
return -TARGET_EFAULT;
|
|
}
|
|
|
|
ret = get_errno(__realpathat(arg1, p, b, arg4, arg5));
|
|
UNLOCK_PATH(p, arg2);
|
|
unlock_user(b, arg3, ret);
|
|
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#endif /* BSD_USER_FREEBSD_OS_STAT_H */
|