[mirror_qemu.git] / bsd-user / syscall_defs.h

/*
 *  System call related declarations
 *
 *  Copyright (c) 2013-15 Stacey D. Son (sson at FreeBSD)
 *
 *  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 SYSCALL_DEFS_H
#define SYSCALL_DEFS_H

#include <sys/syscall.h>
#include <sys/resource.h>

#include "errno_defs.h"

#include "freebsd/syscall_nr.h"
#include "netbsd/syscall_nr.h"
#include "openbsd/syscall_nr.h"

/*
 * machine/_types.h
 * or x86/_types.h
 */

/*
 * time_t seems to be very inconsistly defined for the different *BSD's...
 *
 * FreeBSD uses a 64bits time_t except on i386
 * so we have to add a special case here.
 *
 * On NetBSD time_t is always defined as an int64_t.  On OpenBSD time_t
 * is always defined as an int.
 *
 */
#if (!defined(TARGET_I386))
typedef int64_t target_time_t;
#else
typedef int32_t target_time_t;
#endif

struct target_iovec {
    abi_long iov_base;   /* Starting address */
    abi_long iov_len;   /* Number of bytes */
};

/*
 *  sys/mman.h
 */
#define TARGET_FREEBSD_MAP_RESERVED0080 0x0080  /* previously misimplemented */
                                                /* MAP_INHERIT */
#define TARGET_FREEBSD_MAP_RESERVED0100 0x0100  /* previously unimplemented */
                                                /* MAP_NOEXTEND */
#define TARGET_FREEBSD_MAP_STACK        0x0400  /* region grows down, like a */
                                                /* stack */
#define TARGET_FREEBSD_MAP_NOSYNC       0x0800  /* page to but do not sync */
                                                /* underlying file */

#define TARGET_FREEBSD_MAP_FLAGMASK     0x1ff7

#define TARGET_NETBSD_MAP_INHERIT       0x0080  /* region is retained after */
                                                /* exec */
#define TARGET_NETBSD_MAP_TRYFIXED      0x0400  /* attempt hint address, even */
                                                /* within break */
#define TARGET_NETBSD_MAP_WIRED         0x0800  /* mlock() mapping when it is */
                                                /* established */

#define TARGET_NETBSD_MAP_STACK         0x2000  /* allocated from memory, */
                                                /* swap space (stack) */

#define TARGET_NETBSD_MAP_FLAGMASK      0x3ff7

#define TARGET_OPENBSD_MAP_INHERIT      0x0080  /* region is retained after */
                                                /* exec */
#define TARGET_OPENBSD_MAP_NOEXTEND     0x0100  /* for MAP_FILE, don't change */
                                                /* file size */
#define TARGET_OPENBSD_MAP_TRYFIXED     0x0400  /* attempt hint address, */
                                                /* even within heap */

#define TARGET_OPENBSD_MAP_FLAGMASK     0x17f7

/* XXX */
#define TARGET_BSD_MAP_FLAGMASK         0x3ff7

/*
 * sys/time.h
 * sys/timex.h
 */

typedef abi_long target_freebsd_suseconds_t;

/* compare to sys/timespec.h */
struct target_freebsd_timespec {
    target_time_t   tv_sec;     /* seconds */
    abi_long                tv_nsec;    /* and nanoseconds */
#if !defined(TARGET_I386) && TARGET_ABI_BITS == 32
    abi_long _pad;
#endif
};

#define TARGET_CPUCLOCK_WHICH_PID   0
#define TARGET_CPUCLOCK_WHICH_TID   1

/* sys/umtx.h */
struct target_freebsd__umtx_time {
    struct target_freebsd_timespec  _timeout;
    uint32_t    _flags;
    uint32_t    _clockid;
};

struct target_freebsd_timeval {
    target_time_t       tv_sec; /* seconds */
    target_freebsd_suseconds_t  tv_usec;/* and microseconds */
#if !defined(TARGET_I386) && TARGET_ABI_BITS == 32
    abi_long _pad;
#endif
};

/*
 *  sys/resource.h
 */
#if defined(__FreeBSD__)
#define TARGET_RLIM_INFINITY    RLIM_INFINITY
#else
#define TARGET_RLIM_INFINITY    ((abi_ulong)-1)
#endif

#define TARGET_RLIMIT_CPU       0
#define TARGET_RLIMIT_FSIZE     1
#define TARGET_RLIMIT_DATA      2
#define TARGET_RLIMIT_STACK     3
#define TARGET_RLIMIT_CORE      4
#define TARGET_RLIMIT_RSS       5
#define TARGET_RLIMIT_MEMLOCK   6
#define TARGET_RLIMIT_NPROC     7
#define TARGET_RLIMIT_NOFILE    8
#define TARGET_RLIMIT_SBSIZE    9
#define TARGET_RLIMIT_AS        10
#define TARGET_RLIMIT_NPTS      11
#define TARGET_RLIMIT_SWAP      12

struct target_rlimit {
    uint64_t rlim_cur;
    uint64_t rlim_max;
};

struct target_freebsd_rusage {
    struct target_freebsd_timeval ru_utime; /* user time used */
    struct target_freebsd_timeval ru_stime; /* system time used */
    abi_long    ru_maxrss;      /* maximum resident set size */
    abi_long    ru_ixrss;       /* integral shared memory size */
    abi_long    ru_idrss;       /* integral unshared data size */
    abi_long    ru_isrss;       /* integral unshared stack size */
    abi_long    ru_minflt;      /* page reclaims */
    abi_long    ru_majflt;      /* page faults */
    abi_long    ru_nswap;       /* swaps */
    abi_long    ru_inblock;     /* block input operations */
    abi_long    ru_oublock;     /* block output operations */
    abi_long    ru_msgsnd;      /* messages sent */
    abi_long    ru_msgrcv;      /* messages received */
    abi_long    ru_nsignals;    /* signals received */
    abi_long    ru_nvcsw;       /* voluntary context switches */
    abi_long    ru_nivcsw;      /* involuntary context switches */
};

struct target_freebsd__wrusage {
    struct target_freebsd_rusage wru_self;
    struct target_freebsd_rusage wru_children;
};

/*
 * sys/stat.h
 */
struct target_freebsd11_stat {
    uint32_t  st_dev;       /* inode's device */
    uint32_t  st_ino;       /* inode's number */
    int16_t   st_mode;      /* inode protection mode */
    int16_t   st_nlink;     /* number of hard links */
    uint32_t  st_uid;       /* user ID of the file's owner */
    uint32_t  st_gid;       /* group ID of the file's group */
    uint32_t  st_rdev;      /* device type */
    struct  target_freebsd_timespec st_atim; /* time last accessed */
    struct  target_freebsd_timespec st_mtim; /* time last data modification */
    struct  target_freebsd_timespec st_ctim; /* time last file status change */
    int64_t    st_size;     /* file size, in bytes */
    int64_t    st_blocks;   /* blocks allocated for file */
    uint32_t   st_blksize;  /* optimal blocksize for I/O */
    uint32_t   st_flags;    /* user defined flags for file */
    uint32_t   st_gen;      /* file generation number */
    int32_t    st_lspare;
    struct target_freebsd_timespec st_birthtim; /* time of file creation */
    /*
     * Explicitly pad st_birthtim to 16 bytes so that the size of
     * struct stat is backwards compatible.  We use bitfields instead
     * of an array of chars so that this doesn't require a C99 compiler
     * to compile if the size of the padding is 0.  We use 2 bitfields
     * to cover up to 64 bits on 32-bit machines.  We assume that
     * CHAR_BIT is 8...
     */
    unsigned int:(8 / 2) * (16 - (int)sizeof(struct target_freebsd_timespec));
    unsigned int:(8 / 2) * (16 - (int)sizeof(struct target_freebsd_timespec));
} __packed;

#if defined(__i386__)
#define TARGET_HAS_STAT_TIME_T_EXT       1
#endif

struct target_stat {
    uint64_t  st_dev;               /* inode's device */
    uint64_t  st_ino;               /* inode's number */
    uint64_t  st_nlink;             /* number of hard links */
    int16_t   st_mode;              /* inode protection mode */
    int16_t   st_padding0;
    uint32_t  st_uid;               /* user ID of the file's owner */
    uint32_t  st_gid;               /* group ID of the file's group */
    int32_t   st_padding1;
    uint64_t  st_rdev;              /* device type */
#ifdef TARGET_HAS_STAT_TIME_T_EXT
    int32_t   st_atim_ext;
#endif
    struct  target_freebsd_timespec st_atim; /* time of last access */
#ifdef TARGET_HAS_STAT_TIME_T_EXT
    int32_t   st_mtim_ext;
#endif
    struct  target_freebsd_timespec st_mtim; /* time of last data modification */
#ifdef TARGET_HAS_STAT_TIME_T_EXT
    int32_t st_ctim_ext;
#endif
    struct  target_freebsd_timespec st_ctim;/* time of last file status change */
#ifdef TARGET_HAS_STAT_TIME_T_EXT
    int32_t st_btim_ext;
#endif
    struct  target_freebsd_timespec st_birthtim;   /* time of file creation */
    int64_t   st_size;              /* file size, in bytes */
    int64_t   st_blocks;            /* blocks allocated for file */
    uint32_t  st_blksize;           /* optimal blocksize for I/O */
    uint32_t  st_flags;             /* user defined flags for file */
    uint64_t  st_gen;               /* file generation number */
    uint64_t  st_spare[10];
};


/* struct nstat is the same as stat above but without the st_lspare field */
struct target_freebsd11_nstat {
    uint32_t  st_dev;       /* inode's device */
    uint32_t  st_ino;       /* inode's number */
    int16_t   st_mode;      /* inode protection mode */
    int16_t   st_nlink;     /* number of hard links */
    uint32_t  st_uid;       /* user ID of the file's owner */
    uint32_t  st_gid;       /* group ID of the file's group */
    uint32_t  st_rdev;      /* device type */
    struct  target_freebsd_timespec st_atim; /* time last accessed */
    struct  target_freebsd_timespec st_mtim; /* time last data modification */
    struct  target_freebsd_timespec st_ctim; /* time last file status change */
    int64_t    st_size;     /* file size, in bytes */
    int64_t    st_blocks;   /* blocks allocated for file */
    uint32_t   st_blksize;  /* optimal blocksize for I/O */
    uint32_t   st_flags;    /* user defined flags for file */
    uint32_t   st_gen;      /* file generation number */
    struct target_freebsd_timespec st_birthtim; /* time of file creation */
    /*
     * Explicitly pad st_birthtim to 16 bytes so that the size of
     * struct stat is backwards compatible.  We use bitfields instead
     * of an array of chars so that this doesn't require a C99 compiler
     * to compile if the size of the padding is 0.  We use 2 bitfields
     * to cover up to 64 bits on 32-bit machines.  We assume that
     * CHAR_BIT is 8...
     */
    unsigned int:(8 / 2) * (16 - (int)sizeof(struct target_freebsd_timespec));
    unsigned int:(8 / 2) * (16 - (int)sizeof(struct target_freebsd_timespec));
} __packed;

/*
 * sys/mount.h
 */

/* filesystem id type */
typedef struct target_freebsd_fsid { int32_t val[2]; } target_freebsd_fsid_t;

/* filesystem statistics */
struct target_freebsd11_statfs {
    uint32_t f_version; /* structure version number */
    uint32_t f_type;    /* type of filesystem */
    uint64_t f_flags;   /* copy of mount exported flags */
    uint64_t f_bsize;   /* filesystem fragment size */
    uint64_t f_iosize;  /* optimal transfer block size */
    uint64_t f_blocks;  /* total data blocks in filesystem */
    uint64_t f_bfree;   /* free blocks in filesystem */
    int64_t  f_bavail;  /* free blocks avail to non-superuser */
    uint64_t f_files;   /* total file nodes in filesystem */
    int64_t  f_ffree;   /* free nodes avail to non-superuser */
    uint64_t f_syncwrites;  /* count of sync writes since mount */
    uint64_t f_asyncwrites; /* count of async writes since mount */
    uint64_t f_syncreads;   /* count of sync reads since mount */
    uint64_t f_asyncreads;  /* count of async reads since mount */
    uint64_t f_spare[10];   /* unused spare */
    uint32_t f_namemax; /* maximum filename length */
    uint32_t f_owner;   /* user that mounted the filesystem */
    target_freebsd_fsid_t   f_fsid; /* filesystem id */
    char     f_charspare[80];           /* spare string space */
    char     f_fstypename[16];   /* filesys type name */
    char     f_mntfromname[88];    /* mount filesystem */
    char     f_mntonname[88];      /* dir on which mounted*/
};

struct target_statfs {
    uint32_t f_version;             /* structure version number */
    uint32_t f_type;                /* type of filesystem */
    uint64_t f_flags;               /* copy of mount exported flags */
    uint64_t f_bsize;               /* filesystem fragment size */
    uint64_t f_iosize;              /* optimal transfer block size */
    uint64_t f_blocks;              /* total data blocks in filesystem */
    uint64_t f_bfree;               /* free blocks in filesystem */
    int64_t  f_bavail;              /* free blocks avail to non-superuser */
    uint64_t f_files;               /* total file nodes in filesystem */
    int64_t  f_ffree;               /* free nodes avail to non-superuser */
    uint64_t f_syncwrites;          /* count of sync writes since mount */
    uint64_t f_asyncwrites;         /* count of async writes since mount */
    uint64_t f_syncreads;           /* count of sync reads since mount */
    uint64_t f_asyncreads;          /* count of async reads since mount */
    uint64_t f_spare[10];           /* unused spare */
    uint32_t f_namemax;             /* maximum filename length */
    uint32_t f_owner;               /* user that mounted the filesystem */
    target_freebsd_fsid_t f_fsid;   /* filesystem id */
    char      f_charspare[80];      /* spare string space */
    char      f_fstypename[16];     /* filesystem type name */
    char      f_mntfromname[1024];  /* mounted filesystem */
    char      f_mntonname[1024];    /* directory on which mounted */
};

/* File identifier. These are unique per filesystem on a single machine. */
#define TARGET_MAXFIDSZ     16

struct target_freebsd_fid {
    uint16_t    fid_len;            /* len of data in bytes */
    uint16_t    fid_data0;          /* force longword align */
    char        fid_data[TARGET_MAXFIDSZ];  /* data (variable len) */
};

/* Generic file handle */
struct target_freebsd_fhandle {
    target_freebsd_fsid_t   fh_fsid;    /* Filesystem id of mount point */
    struct target_freebsd_fid fh_fid;   /* Filesys specific id */
};
typedef struct target_freebsd_fhandle target_freebsd_fhandle_t;

/*
 * sys/fcntl.h
 */
#define TARGET_F_DUPFD              0
#define TARGET_F_GETFD              1
#define TARGET_F_SETFD              2
#define TARGET_F_GETFL              3
#define TARGET_F_SETFL              4
#define TARGET_F_GETOWN             5
#define TARGET_F_SETOWN             6
#define TARGET_F_OGETLK             7
#define TARGET_F_OSETLK             8
#define TARGET_F_OSETLKW            9
#define TARGET_F_DUP2FD             10
#define TARGET_F_GETLK              11
#define TARGET_F_SETLK              12
#define TARGET_F_SETLKW             13
#define TARGET_F_SETLK_REMOTE       14
#define TARGET_F_READAHEAD          15
#define TARGET_F_RDAHEAD            16
#define TARGET_F_DUPFD_CLOEXEC     17
#define TARGET_F_DUP2FD_CLOEXEC    18
/* FreeBSD-specific */
#define TARGET_F_ADD_SEALS          19
#define TARGET_F_GET_SEALS          20

struct target_freebsd_flock {
    int64_t l_start;
    int64_t l_len;
    int32_t l_pid;
    int16_t l_type;
    int16_t l_whence;
    int32_t l_sysid;
} QEMU_PACKED;

#define safe_syscall0(type, name) \
type safe_##name(void) \
{ \
    return safe_syscall(SYS_##name); \
}

#define safe_syscall1(type, name, type1, arg1) \
type safe_##name(type1 arg1) \
{ \
    return safe_syscall(SYS_##name, arg1); \
}

#define safe_syscall2(type, name, type1, arg1, type2, arg2) \
type safe_##name(type1 arg1, type2 arg2) \
{ \
    return safe_syscall(SYS_##name, arg1, arg2); \
}

#define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
{ \
    return safe_syscall(SYS_##name, arg1, arg2, arg3); \
}

#define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
    type4, arg4) \
type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
{ \
    return safe_syscall(SYS_##name, arg1, arg2, arg3, arg4); \
}

#define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
    type4, arg4, type5, arg5) \
type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
    type5 arg5) \
{ \
    return safe_syscall(SYS_##name, arg1, arg2, arg3, arg4, arg5); \
}

#define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
    type4, arg4, type5, arg5, type6, arg6) \
type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
    type5 arg5, type6 arg6) \
{ \
    return safe_syscall(SYS_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
}

#define safe_fcntl(...) safe_syscall(SYS_fcntl, __VA_ARGS__)

/* So far all target and host bitmasks are the same */
#undef  target_to_host_bitmask
#define target_to_host_bitmask(x, tbl) (x)
#undef  host_to_target_bitmask
#define host_to_target_bitmask(x, tbl) (x)

#endif /* SYSCALL_DEFS_H */
Commit	Line	Data
84778508	1	/*
366c5c9f	2	* System call related declarations
84778508	3	*
366c5c9f	4	* Copyright (c) 2013-15 Stacey D. Son (sson at FreeBSD)
84778508	5	*
366c5c9f WL	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
84778508	10	*
366c5c9f WL	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, see <http://www.gnu.org/licenses/>.
84778508	18	*/
84778508	19
9c092804 MA	20	#ifndef SYSCALL_DEFS_H
9c092804 MA	21	#define SYSCALL_DEFS_H
84778508	22
366c5c9f	23	#include <sys/syscall.h>
37714547	24	#include <sys/resource.h>
84778508 BS	25
	26	#include "errno_defs.h"
	27
	28	#include "freebsd/syscall_nr.h"
	29	#include "netbsd/syscall_nr.h"
	30	#include "openbsd/syscall_nr.h"
78cfb07f	31
366c5c9f WL	32	/*
	33	* machine/_types.h
	34	* or x86/_types.h
	35	*/
	36
	37	/*
	38	* time_t seems to be very inconsistly defined for the different *BSD's...
	39	*
	40	* FreeBSD uses a 64bits time_t except on i386
	41	* so we have to add a special case here.
	42	*
	43	* On NetBSD time_t is always defined as an int64_t. On OpenBSD time_t
	44	* is always defined as an int.
	45	*
	46	*/
	47	#if (!defined(TARGET_I386))
a0c20b1b	48	typedef int64_t target_time_t;
366c5c9f	49	#else
a0c20b1b	50	typedef int32_t target_time_t;
366c5c9f WL	51	#endif
366c5c9f WL	52
78cfb07f JL	53	struct target_iovec {
	54	abi_long iov_base; /* Starting address */
	55	abi_long iov_len; /* Number of bytes */
	56	};
	57
366c5c9f WL	58	/*
	59	* sys/mman.h
	60	*/
	61	#define TARGET_FREEBSD_MAP_RESERVED0080 0x0080 /* previously misimplemented */
	62	/* MAP_INHERIT */
	63	#define TARGET_FREEBSD_MAP_RESERVED0100 0x0100 /* previously unimplemented */
	64	/* MAP_NOEXTEND */
	65	#define TARGET_FREEBSD_MAP_STACK 0x0400 /* region grows down, like a */
	66	/* stack */
	67	#define TARGET_FREEBSD_MAP_NOSYNC 0x0800 /* page to but do not sync */
	68	/* underlying file */
	69
	70	#define TARGET_FREEBSD_MAP_FLAGMASK 0x1ff7
	71
	72	#define TARGET_NETBSD_MAP_INHERIT 0x0080 /* region is retained after */
	73	/* exec */
	74	#define TARGET_NETBSD_MAP_TRYFIXED 0x0400 /* attempt hint address, even */
	75	/* within break */
	76	#define TARGET_NETBSD_MAP_WIRED 0x0800 /* mlock() mapping when it is */
	77	/* established */
	78
	79	#define TARGET_NETBSD_MAP_STACK 0x2000 /* allocated from memory, */
	80	/* swap space (stack) */
	81
	82	#define TARGET_NETBSD_MAP_FLAGMASK 0x3ff7
	83
	84	#define TARGET_OPENBSD_MAP_INHERIT 0x0080 /* region is retained after */
	85	/* exec */
	86	#define TARGET_OPENBSD_MAP_NOEXTEND 0x0100 /* for MAP_FILE, don't change */
	87	/* file size */
	88	#define TARGET_OPENBSD_MAP_TRYFIXED 0x0400 /* attempt hint address, */
	89	/* even within heap */
	90
	91	#define TARGET_OPENBSD_MAP_FLAGMASK 0x17f7
	92
	93	/* XXX */
	94	#define TARGET_BSD_MAP_FLAGMASK 0x3ff7
	95
	96	/*
	97	* sys/time.h
	98	* sys/timex.h
	99	*/
	100
	101	typedef abi_long target_freebsd_suseconds_t;
	102
	103	/* compare to sys/timespec.h */
	104	struct target_freebsd_timespec {
a0c20b1b	105	target_time_t tv_sec; /* seconds */
366c5c9f WL	106	abi_long tv_nsec; /* and nanoseconds */
	107	#if !defined(TARGET_I386) && TARGET_ABI_BITS == 32
	108	abi_long _pad;
	109	#endif
	110	};
	111
	112	#define TARGET_CPUCLOCK_WHICH_PID 0
	113	#define TARGET_CPUCLOCK_WHICH_TID 1
	114
	115	/* sys/umtx.h */
	116	struct target_freebsd__umtx_time {
	117	struct target_freebsd_timespec _timeout;
	118	uint32_t _flags;
	119	uint32_t _clockid;
	120	};
	121
	122	struct target_freebsd_timeval {
a0c20b1b	123	target_time_t tv_sec; /* seconds */
366c5c9f WL	124	target_freebsd_suseconds_t tv_usec;/* and microseconds */
	125	#if !defined(TARGET_I386) && TARGET_ABI_BITS == 32
	126	abi_long _pad;
	127	#endif
	128	};
	129
	130	/*
	131	* sys/resource.h
	132	*/
	133	#if defined(__FreeBSD__)
	134	#define TARGET_RLIM_INFINITY RLIM_INFINITY
	135	#else
	136	#define TARGET_RLIM_INFINITY ((abi_ulong)-1)
	137	#endif
	138
	139	#define TARGET_RLIMIT_CPU 0
	140	#define TARGET_RLIMIT_FSIZE 1
	141	#define TARGET_RLIMIT_DATA 2
	142	#define TARGET_RLIMIT_STACK 3
	143	#define TARGET_RLIMIT_CORE 4
	144	#define TARGET_RLIMIT_RSS 5
	145	#define TARGET_RLIMIT_MEMLOCK 6
	146	#define TARGET_RLIMIT_NPROC 7
	147	#define TARGET_RLIMIT_NOFILE 8
	148	#define TARGET_RLIMIT_SBSIZE 9
	149	#define TARGET_RLIMIT_AS 10
	150	#define TARGET_RLIMIT_NPTS 11
	151	#define TARGET_RLIMIT_SWAP 12
	152
	153	struct target_rlimit {
	154	uint64_t rlim_cur;
	155	uint64_t rlim_max;
	156	};
	157
	158	struct target_freebsd_rusage {
	159	struct target_freebsd_timeval ru_utime; /* user time used */
	160	struct target_freebsd_timeval ru_stime; /* system time used */
	161	abi_long ru_maxrss; /* maximum resident set size */
	162	abi_long ru_ixrss; /* integral shared memory size */
	163	abi_long ru_idrss; /* integral unshared data size */
	164	abi_long ru_isrss; /* integral unshared stack size */
	165	abi_long ru_minflt; /* page reclaims */
	166	abi_long ru_majflt; /* page faults */
	167	abi_long ru_nswap; /* swaps */
	168	abi_long ru_inblock; /* block input operations */
	169	abi_long ru_oublock; /* block output operations */
	170	abi_long ru_msgsnd; /* messages sent */
	171	abi_long ru_msgrcv; /* messages received */
	172	abi_long ru_nsignals; /* signals received */
	173	abi_long ru_nvcsw; /* voluntary context switches */
	174	abi_long ru_nivcsw; /* involuntary context switches */
	175	};
	176
	177	struct target_freebsd__wrusage {
	178	struct target_freebsd_rusage wru_self;
	179	struct target_freebsd_rusage wru_children;
	180	};
	181
40f5e298 SS	182	/*
	183	* sys/stat.h
	184	*/
	185	struct target_freebsd11_stat {
	186	uint32_t st_dev; /* inode's device */
	187	uint32_t st_ino; /* inode's number */
	188	int16_t st_mode; /* inode protection mode */
	189	int16_t st_nlink; /* number of hard links */
	190	uint32_t st_uid; /* user ID of the file's owner */
	191	uint32_t st_gid; /* group ID of the file's group */
	192	uint32_t st_rdev; /* device type */
	193	struct target_freebsd_timespec st_atim; /* time last accessed */
	194	struct target_freebsd_timespec st_mtim; /* time last data modification */
	195	struct target_freebsd_timespec st_ctim; /* time last file status change */
	196	int64_t st_size; /* file size, in bytes */
	197	int64_t st_blocks; /* blocks allocated for file */
	198	uint32_t st_blksize; /* optimal blocksize for I/O */
	199	uint32_t st_flags; /* user defined flags for file */
	200	uint32_t st_gen; /* file generation number */
	201	int32_t st_lspare;
	202	struct target_freebsd_timespec st_birthtim; /* time of file creation */
	203	/*
	204	* Explicitly pad st_birthtim to 16 bytes so that the size of
	205	* struct stat is backwards compatible. We use bitfields instead
	206	* of an array of chars so that this doesn't require a C99 compiler
	207	* to compile if the size of the padding is 0. We use 2 bitfields
	208	* to cover up to 64 bits on 32-bit machines. We assume that
	209	* CHAR_BIT is 8...
	210	*/
	211	unsigned int:(8 / 2) * (16 - (int)sizeof(struct target_freebsd_timespec));
	212	unsigned int:(8 / 2) * (16 - (int)sizeof(struct target_freebsd_timespec));
	213	} __packed;
	214
ad805a77 MM	215	#if defined(__i386__)
	216	#define TARGET_HAS_STAT_TIME_T_EXT 1
	217	#endif
	218
	219	struct target_stat {
	220	uint64_t st_dev; /* inode's device */
	221	uint64_t st_ino; /* inode's number */
	222	uint64_t st_nlink; /* number of hard links */
	223	int16_t st_mode; /* inode protection mode */
	224	int16_t st_padding0;
	225	uint32_t st_uid; /* user ID of the file's owner */
	226	uint32_t st_gid; /* group ID of the file's group */
	227	int32_t st_padding1;
	228	uint64_t st_rdev; /* device type */
	229	#ifdef TARGET_HAS_STAT_TIME_T_EXT
	230	int32_t st_atim_ext;
	231	#endif
	232	struct target_freebsd_timespec st_atim; /* time of last access */
	233	#ifdef TARGET_HAS_STAT_TIME_T_EXT
	234	int32_t st_mtim_ext;
	235	#endif
	236	struct target_freebsd_timespec st_mtim; /* time of last data modification */
	237	#ifdef TARGET_HAS_STAT_TIME_T_EXT
	238	int32_t st_ctim_ext;
	239	#endif
	240	struct target_freebsd_timespec st_ctim;/* time of last file status change */
	241	#ifdef TARGET_HAS_STAT_TIME_T_EXT
	242	int32_t st_btim_ext;
	243	#endif
	244	struct target_freebsd_timespec st_birthtim; /* time of file creation */
	245	int64_t st_size; /* file size, in bytes */
	246	int64_t st_blocks; /* blocks allocated for file */
	247	uint32_t st_blksize; /* optimal blocksize for I/O */
	248	uint32_t st_flags; /* user defined flags for file */
	249	uint64_t st_gen; /* file generation number */
	250	uint64_t st_spare[10];
	251	};
	252
1de075a0 SS	253
	254	/* struct nstat is the same as stat above but without the st_lspare field */
	255	struct target_freebsd11_nstat {
	256	uint32_t st_dev; /* inode's device */
	257	uint32_t st_ino; /* inode's number */
	258	int16_t st_mode; /* inode protection mode */
	259	int16_t st_nlink; /* number of hard links */
	260	uint32_t st_uid; /* user ID of the file's owner */
	261	uint32_t st_gid; /* group ID of the file's group */
	262	uint32_t st_rdev; /* device type */
	263	struct target_freebsd_timespec st_atim; /* time last accessed */
	264	struct target_freebsd_timespec st_mtim; /* time last data modification */
	265	struct target_freebsd_timespec st_ctim; /* time last file status change */
	266	int64_t st_size; /* file size, in bytes */
	267	int64_t st_blocks; /* blocks allocated for file */
	268	uint32_t st_blksize; /* optimal blocksize for I/O */
	269	uint32_t st_flags; /* user defined flags for file */
	270	uint32_t st_gen; /* file generation number */
	271	struct target_freebsd_timespec st_birthtim; /* time of file creation */
	272	/*
	273	* Explicitly pad st_birthtim to 16 bytes so that the size of
	274	* struct stat is backwards compatible. We use bitfields instead
	275	* of an array of chars so that this doesn't require a C99 compiler
	276	* to compile if the size of the padding is 0. We use 2 bitfields
	277	* to cover up to 64 bits on 32-bit machines. We assume that
	278	* CHAR_BIT is 8...
	279	*/
	280	unsigned int:(8 / 2) * (16 - (int)sizeof(struct target_freebsd_timespec));
	281	unsigned int:(8 / 2) * (16 - (int)sizeof(struct target_freebsd_timespec));
	282	} __packed;
	283
	284	/*
	285	* sys/mount.h
	286	*/
	287
	288	/* filesystem id type */
	289	typedef struct target_freebsd_fsid { int32_t val[2]; } target_freebsd_fsid_t;
	290
	291	/* filesystem statistics */
	292	struct target_freebsd11_statfs {
	293	uint32_t f_version; /* structure version number */
	294	uint32_t f_type; /* type of filesystem */
	295	uint64_t f_flags; /* copy of mount exported flags */
	296	uint64_t f_bsize; /* filesystem fragment size */
	297	uint64_t f_iosize; /* optimal transfer block size */
	298	uint64_t f_blocks; /* total data blocks in filesystem */
	299	uint64_t f_bfree; /* free blocks in filesystem */
	300	int64_t f_bavail; /* free blocks avail to non-superuser */
	301	uint64_t f_files; /* total file nodes in filesystem */
	302	int64_t f_ffree; /* free nodes avail to non-superuser */
	303	uint64_t f_syncwrites; /* count of sync writes since mount */
	304	uint64_t f_asyncwrites; /* count of async writes since mount */
	305	uint64_t f_syncreads; /* count of sync reads since mount */
	306	uint64_t f_asyncreads; /* count of async reads since mount */
	307	uint64_t f_spare[10]; /* unused spare */
	308	uint32_t f_namemax; /* maximum filename length */
	309	uint32_t f_owner; /* user that mounted the filesystem */
	310	target_freebsd_fsid_t f_fsid; /* filesystem id */
	311	char f_charspare[80]; /* spare string space */
	312	char f_fstypename[16]; /* filesys type name */
	313	char f_mntfromname[88]; /* mount filesystem */
	314	char f_mntonname[88]; /* dir on which mounted*/
	315	};
	316
25efcda4 MM	317	struct target_statfs {
	318	uint32_t f_version; /* structure version number */
	319	uint32_t f_type; /* type of filesystem */
	320	uint64_t f_flags; /* copy of mount exported flags */
	321	uint64_t f_bsize; /* filesystem fragment size */
	322	uint64_t f_iosize; /* optimal transfer block size */
	323	uint64_t f_blocks; /* total data blocks in filesystem */
	324	uint64_t f_bfree; /* free blocks in filesystem */
	325	int64_t f_bavail; /* free blocks avail to non-superuser */
	326	uint64_t f_files; /* total file nodes in filesystem */
	327	int64_t f_ffree; /* free nodes avail to non-superuser */
	328	uint64_t f_syncwrites; /* count of sync writes since mount */
	329	uint64_t f_asyncwrites; /* count of async writes since mount */
	330	uint64_t f_syncreads; /* count of sync reads since mount */
	331	uint64_t f_asyncreads; /* count of async reads since mount */
	332	uint64_t f_spare[10]; /* unused spare */
	333	uint32_t f_namemax; /* maximum filename length */
	334	uint32_t f_owner; /* user that mounted the filesystem */
	335	target_freebsd_fsid_t f_fsid; /* filesystem id */
	336	char f_charspare[80]; /* spare string space */
	337	char f_fstypename[16]; /* filesystem type name */
	338	char f_mntfromname[1024]; /* mounted filesystem */
	339	char f_mntonname[1024]; /* directory on which mounted */
	340	};
	341
54d07b44 SS	342	/* File identifier. These are unique per filesystem on a single machine. */
	343	#define TARGET_MAXFIDSZ 16
	344
	345	struct target_freebsd_fid {
	346	uint16_t fid_len; /* len of data in bytes */
	347	uint16_t fid_data0; /* force longword align */
	348	char fid_data[TARGET_MAXFIDSZ]; /* data (variable len) */
	349	};
	350
	351	/* Generic file handle */
	352	struct target_freebsd_fhandle {
	353	target_freebsd_fsid_t fh_fsid; /* Filesystem id of mount point */
	354	struct target_freebsd_fid fh_fid; /* Filesys specific id */
	355	};
	356	typedef struct target_freebsd_fhandle target_freebsd_fhandle_t;
	357
	358	/*
	359	* sys/fcntl.h
	360	*/
	361	#define TARGET_F_DUPFD 0
	362	#define TARGET_F_GETFD 1
	363	#define TARGET_F_SETFD 2
	364	#define TARGET_F_GETFL 3
	365	#define TARGET_F_SETFL 4
	366	#define TARGET_F_GETOWN 5
	367	#define TARGET_F_SETOWN 6
	368	#define TARGET_F_OGETLK 7
	369	#define TARGET_F_OSETLK 8
	370	#define TARGET_F_OSETLKW 9
	371	#define TARGET_F_DUP2FD 10
	372	#define TARGET_F_GETLK 11
	373	#define TARGET_F_SETLK 12
	374	#define TARGET_F_SETLKW 13
	375	#define TARGET_F_SETLK_REMOTE 14
	376	#define TARGET_F_READAHEAD 15
	377	#define TARGET_F_RDAHEAD 16
	378	#define TARGET_F_DUPFD_CLOEXEC 17
	379	#define TARGET_F_DUP2FD_CLOEXEC 18
	380	/* FreeBSD-specific */
	381	#define TARGET_F_ADD_SEALS 19
	382	#define TARGET_F_GET_SEALS 20
	383
	384	struct target_freebsd_flock {
	385	int64_t l_start;
	386	int64_t l_len;
	387	int32_t l_pid;
	388	int16_t l_type;
	389	int16_t l_whence;
	390	int32_t l_sysid;
	391	} QEMU_PACKED;
	392
a5b88166 WL	393	#define safe_syscall0(type, name) \
	394	type safe_##name(void) \
	395	{ \
	396	return safe_syscall(SYS_##name); \
	397	}
	398
	399	#define safe_syscall1(type, name, type1, arg1) \
	400	type safe_##name(type1 arg1) \
	401	{ \
	402	return safe_syscall(SYS_##name, arg1); \
	403	}
	404
	405	#define safe_syscall2(type, name, type1, arg1, type2, arg2) \
	406	type safe_##name(type1 arg1, type2 arg2) \
	407	{ \
	408	return safe_syscall(SYS_##name, arg1, arg2); \
	409	}
	410
	411	#define safe_syscall3(type, name, type1, arg1, type2, arg2, type3, arg3) \
	412	type safe_##name(type1 arg1, type2 arg2, type3 arg3) \
	413	{ \
	414	return safe_syscall(SYS_##name, arg1, arg2, arg3); \
	415	}
	416
	417	#define safe_syscall4(type, name, type1, arg1, type2, arg2, type3, arg3, \
	418	type4, arg4) \
	419	type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
	420	{ \
	421	return safe_syscall(SYS_##name, arg1, arg2, arg3, arg4); \
	422	}
	423
	424	#define safe_syscall5(type, name, type1, arg1, type2, arg2, type3, arg3, \
	425	type4, arg4, type5, arg5) \
	426	type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
	427	type5 arg5) \
	428	{ \
	429	return safe_syscall(SYS_##name, arg1, arg2, arg3, arg4, arg5); \
	430	}
	431
	432	#define safe_syscall6(type, name, type1, arg1, type2, arg2, type3, arg3, \
	433	type4, arg4, type5, arg5, type6, arg6) \
	434	type safe_##name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, \
	435	type5 arg5, type6 arg6) \
	436	{ \
	437	return safe_syscall(SYS_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
	438	}
	439
243c725f KE	440	#define safe_fcntl(...) safe_syscall(SYS_fcntl, __VA_ARGS__)
243c725f KE	441
77d3522b	442	/* So far all target and host bitmasks are the same */
a05cee93	443	#undef target_to_host_bitmask
77d3522b	444	#define target_to_host_bitmask(x, tbl) (x)
a05cee93	445	#undef host_to_target_bitmask
77d3522b WL	446	#define host_to_target_bitmask(x, tbl) (x)
77d3522b WL	447
9c092804	448	#endif /* SYSCALL_DEFS_H */