qemu-e2k/bsd-user/freebsd/os-stat.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

664 lines
18 KiB
C
Raw Normal View History

/*
* 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 */