[thirdparty/xfsprogs-dev.git] / include / irix.h

/*
 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
#ifndef __XFS_IRIX_H__
#define __XFS_IRIX_H__

#include <stdlib.h>
#include <unistd.h>
#include <libgen.h>
#include <values.h>
#include <strings.h>
#include <inttypes.h>
#include <limits.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/uuid.h>
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/statfs.h>
#include <sys/statvfs.h>
#include <sys/syssgi.h>
#include <sys/sysmacros.h>
#include <sys/fs/xfs_fsops.h>
#include <sys/fs/xfs_itable.h>

#define __int8_t	char
#define __int16_t	short
#define __uint8_t	unsigned char
#define __uint16_t	unsigned short
#define loff_t		off64_t
typedef off64_t		xfs_off_t;
typedef __int64_t	xfs_ino_t;
typedef __int32_t	xfs_dev_t;
typedef __int64_t	xfs_daddr_t;
typedef char*		xfs_caddr_t;

#define xfs_flock64	flock64
#define xfs_flock64_t	struct flock64

typedef struct xfs_error_injection {
	__int32_t	fd;
	__int32_t	errtag;
} xfs_error_injection_t;

/* --- xfs_fsop_*req - request data structures --- */

typedef struct xfs_fsop_bulkreq {
	ino64_t	*lastip;
	__int32_t	icount;
	xfs_bstat_t	*ubuffer;
	__int32_t	*ocount;
} xfs_fsop_bulkreq_t;

typedef struct xfs_fsop_handlereq {
	__u32		fd;		/* fd for FD_TO_HANDLE		*/
	void		*path;		/* user pathname		*/
	__u32		oflags;		/* open flags			*/
	void		*ihandle;	/* user supplied handle		*/
	__u32		ihandlen;	/* user supplied length		*/
	void		*ohandle;	/* user buffer for handle	*/
	__u32		*ohandlen;	/* user buffer length		*/
} xfs_fsop_handlereq_t;

typedef struct xfs_fsop_setdm_handlereq {
	struct xfs_fsop_handlereq	hreq;	/* handle information	*/
	struct fsdmidata		*data;	/* DMAPI data	*/
} xfs_fsop_setdm_handlereq_t;

typedef struct xfs_attrlist_cursor {
	__u32		opaque[4];
} xfs_attrlist_cursor_t;

typedef struct xfs_fsop_attrlist_handlereq {
	struct xfs_fsop_handlereq	hreq; /* handle interface structure */
	struct xfs_attrlist_cursor	pos; /* opaque cookie, list offset */
	__u32				flags;	/* which namespace to use */
	__u32				buflen;	/* length of buffer supplied */
	void				*buffer;	/* returned names */
} xfs_fsop_attrlist_handlereq_t;

typedef struct xfs_fsop_getparents_handlereq {
	struct xfs_fsop_handlereq	hreq; /* handle interface structure */
	struct xfs_attrlist_cursor	pos; /* opaque cookie, list offset */
	__u32				buflen;	/* length of buffer supplied */
	void				*buffer; /* returned data */
	__u32				*ocount; /* return number of links */
	__u32				*omore; /* return whether more to come */
} xfs_fsop_getparents_handlereq_t;

typedef struct xfs_attr_multiop {
	__u32		am_opcode;
	__s32		am_error;
	void		*am_attrname;
	void		*am_attrvalue;
	__u32		am_length;
	__u32		am_flags;
} xfs_attr_multiop_t;

typedef struct xfs_fsop_attrmulti_handlereq {
	struct xfs_fsop_handlereq	hreq; /* handle interface structure */
	__u32				opcount;/* count of following multiop */
	struct xfs_attr_multiop		*ops; /* attr_multi data */
} xfs_fsop_attrmulti_handlereq_t;

/* start doing packed stuctures here */
#define HAVE_FORMAT32	1
#pragma pack 1
typedef struct xfs_inode_log_format_32 {
	__u16			ilf_type;	/* inode log item type */
	__u16			ilf_size;	/* size of this item */
	__u32			ilf_fields;	/* flags for fields logged */
	__u16			ilf_asize;	/* size of attr d/ext/root */
	__u16			ilf_dsize;	/* size of data/ext/root */
	__u64			ilf_ino;	/* inode number */
	union {
		__u32		ilfu_rdev;	/* rdev value for dev inode*/
		uuid_t		ilfu_uuid;	/* mount point value */
	} ilf_u;
	__s64			ilf_blkno;	/* blkno of inode buffer */
	__s32			ilf_len;	/* len of inode buffer */
	__s32			ilf_boffset;	/* off of inode in buffer */
} xfs_inode_log_format_32_t;

typedef struct xfs_extent_32 {
	__u64	ext_start;
	__u32	ext_len;
} xfs_extent_32_t;

typedef struct xfs_efi_log_format_32 {
	__u16			efi_type;	/* efi log item type */
	__u16			efi_size;	/* size of this item */
	__u32			efi_nextents;	/* # extents to free */
	__u64			efi_id;		/* efi identifier */
	xfs_extent_32_t		efi_extents[1];	/* array of extents to free */
} xfs_efi_log_format_32_t;

typedef struct xfs_efd_log_format_32 {
	__u16			efd_type;	/* efd log item type */
	__u16			efd_size;	/* size of this item */
	__u32			efd_nextents;	/* # of extents freed */
	__u64			efd_efi_id;	/* id of corresponding efi */
	xfs_extent_32_t		efd_extents[1];	/* array of extents freed */
} xfs_efd_log_format_32_t;

#pragma pack 0
/* end of packed stuctures */

#include <sys/endian.h>
#define __BYTE_ORDER	BYTE_ORDER
#define __BIG_ENDIAN	BIG_ENDIAN
#define __LITTLE_ENDIAN	LITTLE_ENDIAN

/* Map some gcc macros for the MipsPRO compiler */
#ifndef __GNUC__
#define __builtin_constant_p(x)	(0)
#define __FUNCTION__	"XFS"
#define __sgi__		__sgi
#define __inline__	__inline
#define inline		__inline
#endif

#define constpp		char * const *

/*ARGSUSED*/
static __inline__ int xfsctl(const char *path, int fd, int cmd, void *arg)
{
	if (cmd >= 0 && cmd < XFS_FSOPS_COUNT) {
		/*
		 * We have a problem in that xfsctl takes 1 arg but
		 * some sgi xfs ops take an input arg and/or an output arg
		 * So have to special case the ops to decide if xfsctl arg
		 * is an input or an output argument.
		 */
		if (cmd == XFS_FS_GOINGDOWN)
			return syssgi(SGI_XFS_FSOPERATIONS, fd, cmd, arg, 0);
		return syssgi(SGI_XFS_FSOPERATIONS, fd, cmd, 0, arg);
	}
	switch (cmd) {
		case SGI_FS_INUMBERS:
		case SGI_FS_BULKSTAT:
			return syssgi(cmd, fd,
					((xfs_fsop_bulkreq_t*)arg)->lastip,
					((xfs_fsop_bulkreq_t*)arg)->icount,
					((xfs_fsop_bulkreq_t*)arg)->ubuffer,
					((xfs_fsop_bulkreq_t*)arg)->ocount);
		case SGI_FS_BULKSTAT_SINGLE:
			return syssgi(SGI_FS_BULKSTAT_SINGLE, fd,
					((xfs_fsop_bulkreq_t*)arg)->lastip,
					((xfs_fsop_bulkreq_t*)arg)->ubuffer);
		case SGI_XFS_INJECT_ERROR:
			return syssgi(SGI_XFS_INJECT_ERROR,
					((xfs_error_injection_t*)arg)->errtag,
					fd);
		case SGI_XFS_CLEARALL_ERROR:
			return syssgi(SGI_XFS_CLEARALL_ERROR, fd);
		case SGI_PATH_TO_HANDLE:
		case SGI_PATH_TO_FSHANDLE:
			return syssgi(cmd,
					((xfs_fsop_handlereq_t*)arg)->path,
					((xfs_fsop_handlereq_t*)arg)->ohandle,
					((xfs_fsop_handlereq_t*)arg)->ohandlen);
		case SGI_FD_TO_HANDLE:
			return syssgi(cmd,
					((xfs_fsop_handlereq_t*)arg)->fd,
					((xfs_fsop_handlereq_t*)arg)->ohandle,
					((xfs_fsop_handlereq_t*)arg)->ohandlen);
		case SGI_OPEN_BY_HANDLE:
			return syssgi(cmd,
					((xfs_fsop_handlereq_t*)arg)->ihandle,
					((xfs_fsop_handlereq_t*)arg)->ihandlen,
					((xfs_fsop_handlereq_t*)arg)->oflags);
		case SGI_READLINK_BY_HANDLE:
			return syssgi(cmd,
					((xfs_fsop_handlereq_t*)arg)->ihandle,
					((xfs_fsop_handlereq_t*)arg)->ihandlen,
					((xfs_fsop_handlereq_t*)arg)->ohandle,
					((xfs_fsop_handlereq_t*)arg)->ohandlen);
		case SGI_ATTR_LIST_BY_HANDLE:
			return syssgi(cmd,
					((xfs_fsop_attrlist_handlereq_t*)arg)->hreq.ihandle,
					((xfs_fsop_attrlist_handlereq_t*)arg)->hreq.ihandlen,
					((xfs_fsop_attrlist_handlereq_t*)arg)->buffer,
					((xfs_fsop_attrlist_handlereq_t*)arg)->buflen,
					((xfs_fsop_attrlist_handlereq_t*)arg)->flags,
					&(((xfs_fsop_attrlist_handlereq_t*)arg)->pos));
		case SGI_XFS_GETPARENTS:
		case SGI_XFS_GETPARENTPATHS:
			return syssgi(cmd,
					((xfs_fsop_getparents_handlereq_t*)arg)->hreq.ihandle,
					((xfs_fsop_getparents_handlereq_t*)arg)->hreq.ihandlen,
					((xfs_fsop_getparents_handlereq_t*)arg)->buffer,
					((xfs_fsop_getparents_handlereq_t*)arg)->buflen,
					&(((xfs_fsop_getparents_handlereq_t*)arg)->pos),
					((xfs_fsop_getparents_handlereq_t*)arg)->ocount,
					((xfs_fsop_getparents_handlereq_t*)arg)->omore);
		case SGI_ATTR_MULTI_BY_HANDLE:
			return syssgi(cmd,
					((xfs_fsop_attrmulti_handlereq_t*)arg)->hreq.ihandle,
					((xfs_fsop_attrmulti_handlereq_t*)arg)->hreq.ihandlen,
					((xfs_fsop_attrmulti_handlereq_t*)arg)->ops,
					((xfs_fsop_attrmulti_handlereq_t*)arg)->opcount,
					((xfs_fsop_attrmulti_handlereq_t*)arg)->hreq.oflags);
		case SGI_FSSETDM_BY_HANDLE:
			return syssgi(cmd,
					((xfs_fsop_setdm_handlereq_t*)arg)->hreq.ihandle,
					((xfs_fsop_setdm_handlereq_t*)arg)->hreq.ihandlen,
					((xfs_fsop_setdm_handlereq_t*)arg)->data);
	}
	return fcntl(fd, cmd, arg);
}

static __inline__ int platform_test_xfs_fd(int fd)
{
	struct statvfs sbuf;
	if (fstatvfs(fd, &sbuf) < 0)
		return 0;
	return strncmp(sbuf.f_basetype, "xfs", 4) == 0;
}

static __inline__ int platform_test_xfs_path(const char *path)
{
	struct statvfs sbuf;
	if (statvfs(path, &sbuf) < 0)
		return 0;
	return strncmp(sbuf.f_basetype, "xfs", 4) == 0;
}

static __inline__ int platform_fstatfs(int fd, struct statfs *buf)
{
	return fstatfs(fd, buf, sizeof(struct statfs), 0);
}

static __inline__ void platform_getoptreset(void)
{
	getoptreset();
}

static __inline__ int platform_uuid_compare(uuid_t *uu1, uuid_t *uu2)
{
	uint_t status;
	return uuid_compare(uu1, uu2, &status);
}

static __inline__ void platform_uuid_unparse(uuid_t *uu, char *buffer)
{
	uint_t status;
	char *s;
	uuid_to_string(uu, &s, &status);
	if (status == uuid_s_ok)
		strcpy(buffer, s);
	else buffer[0] = '\0';
	free(s);
}

static __inline__ int platform_uuid_parse(char *buffer, uuid_t *uu)
{
	uint_t status;
	uuid_from_string(buffer, uu, &status);
	return (status == uuid_s_ok);
}

static __inline__ int platform_uuid_is_null(uuid_t *uu)
{
	uint status;
	return uuid_is_nil(uu, &status);
}

static __inline__ void platform_uuid_generate(uuid_t *uu)
{
	uint_t status;
	uuid_create(uu, &status);
}

static __inline__ void platform_uuid_clear(uuid_t *uu)
{
	uint_t status;
	uuid_create_nil(uu, &status);
}

static __inline__ void platform_uuid_copy(uuid_t *dst, uuid_t *src)
{
	memcpy(dst, src, sizeof(uuid_t));
}

static __inline__ char * strsep(char **s, const char *ct)
{
	char *sbegin = *s, *end;

	if (!sbegin)
		return NULL;
	end = strpbrk(sbegin, ct);
	if (end)
		*end++ = '\0';
	*s = end;
	return sbegin;
}

#define HAVE_DIOATTR	1
#define HAVE_FSXATTR	1
#define HAVE_GETBMAP	1
#define HAVE_GETBMAPX	1
#define HAVE_FSDMIDATA	1
#define HAVE_FID	1
#define HAVE_IOCMACROS	1
#define HAVE_BBMACROS	1

#define __XFS_FS_H__	1

#define XFS_IOC_DIOINFO			F_DIOINFO
#define XFS_IOC_FSGETXATTR		F_FSGETXATTR
#define XFS_IOC_FSSETXATTR		F_FSSETXATTR
#define XFS_IOC_ALLOCSP64		F_ALLOCSP64
#define XFS_IOC_FREESP64		F_FREESP64
#define XFS_IOC_GETBMAP			F_GETBMAP
#define XFS_IOC_FSSETDM			F_FSSETDM
#define XFS_IOC_RESVSP			F_RESVSP
#define XFS_IOC_RESVSP64		F_RESVSP64
#define XFS_IOC_UNRESVSP		F_UNRESVSP
#define XFS_IOC_UNRESVSP64		F_UNRESVSP64
#define XFS_IOC_GETBMAPA		F_GETBMAPA
#define XFS_IOC_FSGETXATTRA		F_FSGETXATTRA
#define XFS_IOC_GETBMAPX		F_GETBMAPX

#define XFS_IOC_FSGEOMETRY_V1		XFS_FS_GEOMETRY
#define XFS_IOC_FSBULKSTAT		SGI_FS_BULKSTAT
#define XFS_IOC_FSBULKSTAT_SINGLE	SGI_FS_BULKSTAT_SINGLE
#define XFS_IOC_FSINUMBERS		SGI_FS_INUMBERS
#define XFS_IOC_PATH_TO_FSHANDLE	SGI_PATH_TO_FSHANDLE
#define XFS_IOC_PATH_TO_HANDLE		SGI_PATH_TO_HANDLE
#define XFS_IOC_FD_TO_HANDLE		SGI_FD_TO_HANDLE
#define XFS_IOC_OPEN_BY_HANDLE		SGI_OPEN_BY_HANDLE
#define XFS_IOC_READLINK_BY_HANDLE	SGI_READLINK_BY_HANDLE
#define XFS_IOC_SWAPEXT			/* TODO */
#define XFS_IOC_FSGROWFSDATA		XFS_GROWFS_DATA
#define XFS_IOC_FSGROWFSLOG		XFS_GROWFS_LOG
#define XFS_IOC_FSGROWFSRT		XFS_GROWFS_RT
#define XFS_IOC_FSCOUNTS		XFS_FS_COUNTS
#define XFS_IOC_SET_RESBLKS		XFS_SET_RESBLKS
#define XFS_IOC_GET_RESBLKS		XFS_GET_RESBLKS
#define XFS_IOC_ERROR_INJECTION		SGI_XFS_INJECT_ERROR
#define XFS_IOC_ERROR_CLEARALL		SGI_XFS_CLEARALL_ERROR
#define XFS_IOC_FREEZE			XFS_FS_FREEZE
#define XFS_IOC_THAW			XFS_FS_THAW
#define XFS_IOC_FSSETDM_BY_HANDLE	SGI_FSSETDM_BY_HANDLE
#define XFS_IOC_ATTRLIST_BY_HANDLE	SGI_ATTR_LIST_BY_HANDLE
#define XFS_IOC_ATTRMULTI_BY_HANDLE	SGI_ATTR_MULTI_BY_HANDLE
#define XFS_IOC_FSGEOMETRY		XFS_FS_GEOMETRY
#define XFS_IOC_GOINGDOWN		XFS_FS_GOINGDOWN
#define XFS_IOC_GETPARENTS		SGI_XFS_GETPARENTS
#define XFS_IOC_GETPARENTPATHS		SGI_XFS_GETPARENTPATHS

#define	_AIOCB64_T_DEFINED		1

#define	XFS_XFLAG_NODEFRAG		0x00002000

#endif	/* __XFS_IRIX_H__ */
Commit	Line	Data
c0211f67	1	/*
714bd9e5	2	* Copyright (c) 2000-2006 Silicon Graphics, Inc.
f302e9e4	3	* All Rights Reserved.
c0211f67	4	*
f302e9e4 NS	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Lesser General Public License
	7	* as published by the Free Software Foundation.
c0211f67	8	*
f302e9e4 NS	9	* This program is distributed in the hope that it would be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU Lesser General Public License for more details.
c0211f67	13	*
f302e9e4 NS	14	* You should have received a copy of the GNU Lesser General Public License
	15	* along with this program; if not, write the Free Software Foundation,
	16	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
c0211f67 NS	17	*/
	18	#ifndef __XFS_IRIX_H__
	19	#define __XFS_IRIX_H__
	20
eb0c6f87 TS	21	#include <stdlib.h>
eb0c6f87 TS	22	#include <unistd.h>
c0211f67 NS	23	#include <libgen.h>
	24	#include <values.h>
	25	#include <strings.h>
	26	#include <inttypes.h>
eb0c6f87 TS	27	#include <limits.h>
eb0c6f87 TS	28	#include <fcntl.h>
c0211f67 NS	29	#include <sys/stat.h>
	30	#include <sys/uuid.h>
	31	#include <sys/param.h>
	32	#include <sys/ioctl.h>
	33	#include <sys/types.h>
	34	#include <sys/statfs.h>
	35	#include <sys/statvfs.h>
	36	#include <sys/syssgi.h>
	37	#include <sys/sysmacros.h>
	38	#include <sys/fs/xfs_fsops.h>
5ecb3de2	39	#include <sys/fs/xfs_itable.h>
c0211f67	40
c0211f67 NS	41	#define __int8_t char
	42	#define __int16_t short
	43	#define __uint8_t unsigned char
	44	#define __uint16_t unsigned short
	45	#define loff_t off64_t
	46	typedef off64_t xfs_off_t;
	47	typedef __int64_t xfs_ino_t;
	48	typedef __int32_t xfs_dev_t;
	49	typedef __int64_t xfs_daddr_t;
	50	typedef char* xfs_caddr_t;
eb0c6f87 TS	51
	52	#define xfs_flock64 flock64
	53	#define xfs_flock64_t struct flock64
	54
	55	typedef struct xfs_error_injection {
8967ee43 TS	56	__int32_t fd;
8967ee43 TS	57	__int32_t errtag;
eb0c6f87 TS	58	} xfs_error_injection_t;
eb0c6f87 TS	59
8967ee43	60	/* --- xfs_fsop_req - request data structures --- /
eb0c6f87 TS	61
eb0c6f87 TS	62	typedef struct xfs_fsop_bulkreq {
8967ee43 TS	63	ino64_t *lastip;
	64	__int32_t icount;
	65	xfs_bstat_t *ubuffer;
	66	__int32_t *ocount;
eb0c6f87	67	} xfs_fsop_bulkreq_t;
c0211f67	68
8967ee43 TS	69	typedef struct xfs_fsop_handlereq {
	70	__u32 fd; /* fd for FD_TO_HANDLE */
	71	void path; / user pathname */
	72	__u32 oflags; /* open flags */
	73	void ihandle; / user supplied handle */
	74	__u32 ihandlen; /* user supplied length */
	75	void ohandle; / user buffer for handle */
	76	__u32 ohandlen; / user buffer length */
	77	} xfs_fsop_handlereq_t;
	78
	79	typedef struct xfs_fsop_setdm_handlereq {
	80	struct xfs_fsop_handlereq hreq; /* handle information */
	81	struct fsdmidata data; / DMAPI data */
	82	} xfs_fsop_setdm_handlereq_t;
	83
	84	typedef struct xfs_attrlist_cursor {
	85	__u32 opaque[4];
	86	} xfs_attrlist_cursor_t;
	87
	88	typedef struct xfs_fsop_attrlist_handlereq {
	89	struct xfs_fsop_handlereq hreq; /* handle interface structure */
	90	struct xfs_attrlist_cursor pos; /* opaque cookie, list offset */
	91	__u32 flags; /* which namespace to use */
	92	__u32 buflen; /* length of buffer supplied */
	93	void buffer; / returned names */
	94	} xfs_fsop_attrlist_handlereq_t;
	95
258b00ea TS	96	typedef struct xfs_fsop_getparents_handlereq {
	97	struct xfs_fsop_handlereq hreq; /* handle interface structure */
	98	struct xfs_attrlist_cursor pos; /* opaque cookie, list offset */
	99	__u32 buflen; /* length of buffer supplied */
	100	void buffer; / returned data */
	101	__u32 ocount; / return number of links */
	102	__u32 omore; / return whether more to come */
	103	} xfs_fsop_getparents_handlereq_t;
	104
8967ee43 TS	105	typedef struct xfs_attr_multiop {
	106	__u32 am_opcode;
	107	__s32 am_error;
	108	void *am_attrname;
	109	void *am_attrvalue;
	110	__u32 am_length;
	111	__u32 am_flags;
	112	} xfs_attr_multiop_t;
	113
	114	typedef struct xfs_fsop_attrmulti_handlereq {
	115	struct xfs_fsop_handlereq hreq; /* handle interface structure */
	116	__u32 opcount;/* count of following multiop */
	117	struct xfs_attr_multiop ops; / attr_multi data */
	118	} xfs_fsop_attrmulti_handlereq_t;
	119
d3a8db8a TS	120	/* start doing packed stuctures here */
	121	#define HAVE_FORMAT32 1
	122	#pragma pack 1
	123	typedef struct xfs_inode_log_format_32 {
	124	__u16 ilf_type; /* inode log item type */
	125	__u16 ilf_size; /* size of this item */
	126	__u32 ilf_fields; /* flags for fields logged */
	127	__u16 ilf_asize; /* size of attr d/ext/root */
	128	__u16 ilf_dsize; /* size of data/ext/root */
	129	__u64 ilf_ino; /* inode number */
	130	union {
	131	__u32 ilfu_rdev; /* rdev value for dev inode*/
	132	uuid_t ilfu_uuid; /* mount point value */
	133	} ilf_u;
	134	__s64 ilf_blkno; /* blkno of inode buffer */
	135	__s32 ilf_len; /* len of inode buffer */
	136	__s32 ilf_boffset; /* off of inode in buffer */
	137	} xfs_inode_log_format_32_t;
	138
	139	typedef struct xfs_extent_32 {
	140	__u64 ext_start;
	141	__u32 ext_len;
	142	} xfs_extent_32_t;
	143
	144	typedef struct xfs_efi_log_format_32 {
	145	__u16 efi_type; /* efi log item type */
	146	__u16 efi_size; /* size of this item */
	147	__u32 efi_nextents; /* # extents to free */
	148	__u64 efi_id; /* efi identifier */
	149	xfs_extent_32_t efi_extents[1]; /* array of extents to free */
	150	} xfs_efi_log_format_32_t;
	151
	152	typedef struct xfs_efd_log_format_32 {
	153	__u16 efd_type; /* efd log item type */
	154	__u16 efd_size; /* size of this item */
	155	__u32 efd_nextents; /* # of extents freed */
	156	__u64 efd_efi_id; /* id of corresponding efi */
	157	xfs_extent_32_t efd_extents[1]; /* array of extents freed */
	158	} xfs_efd_log_format_32_t;
	159
	160	#pragma pack 0
	161	/* end of packed stuctures */
8967ee43	162
c0211f67 NS	163	#include <sys/endian.h>
	164	#define __BYTE_ORDER BYTE_ORDER
	165	#define __BIG_ENDIAN BIG_ENDIAN
	166	#define __LITTLE_ENDIAN LITTLE_ENDIAN
5ecb3de2 NS	167
	168	/* Map some gcc macros for the MipsPRO compiler */
	169	#ifndef __GNUC__
1552a820 NS	170	#define __builtin_constant_p(x) (0)
1552a820 NS	171	#define __FUNCTION__ "XFS"
5ecb3de2 NS	172	#define __sgi__ __sgi
5ecb3de2 NS	173	#define __inline__ __inline
2a1888c5	174	#define inline __inline
5ecb3de2	175	#endif
c0211f67	176
c0211f67	177	#define constpp char * const *
c0211f67	178
8967ee43	179	/ARGSUSED/
eb0c6f87	180	static __inline__ int xfsctl(const char path, int fd, int cmd, void arg)
c0211f67	181	{
eb0c6f87 TS	182	if (cmd >= 0 && cmd < XFS_FSOPS_COUNT) {
	183	/*
	184	* We have a problem in that xfsctl takes 1 arg but
	185	* some sgi xfs ops take an input arg and/or an output arg
	186	* So have to special case the ops to decide if xfsctl arg
	187	* is an input or an output argument.
	188	*/
	189	if (cmd == XFS_FS_GOINGDOWN)
	190	return syssgi(SGI_XFS_FSOPERATIONS, fd, cmd, arg, 0);
	191	return syssgi(SGI_XFS_FSOPERATIONS, fd, cmd, 0, arg);
	192	}
	193	switch (cmd) {
9527f2d5	194	case SGI_FS_INUMBERS:
eb0c6f87	195	case SGI_FS_BULKSTAT:
8967ee43	196	return syssgi(cmd, fd,
eb0c6f87 TS	197	((xfs_fsop_bulkreq_t*)arg)->lastip,
	198	((xfs_fsop_bulkreq_t*)arg)->icount,
	199	((xfs_fsop_bulkreq_t*)arg)->ubuffer,
	200	((xfs_fsop_bulkreq_t*)arg)->ocount);
	201	case SGI_FS_BULKSTAT_SINGLE:
8967ee43	202	return syssgi(SGI_FS_BULKSTAT_SINGLE, fd,
eb0c6f87 TS	203	((xfs_fsop_bulkreq_t*)arg)->lastip,
	204	((xfs_fsop_bulkreq_t*)arg)->ubuffer);
	205	case SGI_XFS_INJECT_ERROR:
	206	return syssgi(SGI_XFS_INJECT_ERROR,
	207	((xfs_error_injection_t*)arg)->errtag,
	208	fd);
	209	case SGI_XFS_CLEARALL_ERROR:
	210	return syssgi(SGI_XFS_CLEARALL_ERROR, fd);
8967ee43 TS	211	case SGI_PATH_TO_HANDLE:
	212	case SGI_PATH_TO_FSHANDLE:
	213	return syssgi(cmd,
	214	((xfs_fsop_handlereq_t*)arg)->path,
	215	((xfs_fsop_handlereq_t*)arg)->ohandle,
	216	((xfs_fsop_handlereq_t*)arg)->ohandlen);
	217	case SGI_FD_TO_HANDLE:
	218	return syssgi(cmd,
	219	((xfs_fsop_handlereq_t*)arg)->fd,
	220	((xfs_fsop_handlereq_t*)arg)->ohandle,
	221	((xfs_fsop_handlereq_t*)arg)->ohandlen);
	222	case SGI_OPEN_BY_HANDLE:
	223	return syssgi(cmd,
	224	((xfs_fsop_handlereq_t*)arg)->ihandle,
	225	((xfs_fsop_handlereq_t*)arg)->ihandlen,
	226	((xfs_fsop_handlereq_t*)arg)->oflags);
	227	case SGI_READLINK_BY_HANDLE:
	228	return syssgi(cmd,
	229	((xfs_fsop_handlereq_t*)arg)->ihandle,
	230	((xfs_fsop_handlereq_t*)arg)->ihandlen,
	231	((xfs_fsop_handlereq_t*)arg)->ohandle,
	232	((xfs_fsop_handlereq_t*)arg)->ohandlen);
	233	case SGI_ATTR_LIST_BY_HANDLE:
	234	return syssgi(cmd,
	235	((xfs_fsop_attrlist_handlereq_t*)arg)->hreq.ihandle,
	236	((xfs_fsop_attrlist_handlereq_t*)arg)->hreq.ihandlen,
	237	((xfs_fsop_attrlist_handlereq_t*)arg)->buffer,
	238	((xfs_fsop_attrlist_handlereq_t*)arg)->buflen,
	239	((xfs_fsop_attrlist_handlereq_t*)arg)->flags,
	240	&(((xfs_fsop_attrlist_handlereq_t*)arg)->pos));
258b00ea TS	241	case SGI_XFS_GETPARENTS:
	242	case SGI_XFS_GETPARENTPATHS:
	243	return syssgi(cmd,
	244	((xfs_fsop_getparents_handlereq_t*)arg)->hreq.ihandle,
	245	((xfs_fsop_getparents_handlereq_t*)arg)->hreq.ihandlen,
	246	((xfs_fsop_getparents_handlereq_t*)arg)->buffer,
	247	((xfs_fsop_getparents_handlereq_t*)arg)->buflen,
	248	&(((xfs_fsop_getparents_handlereq_t*)arg)->pos),
	249	((xfs_fsop_getparents_handlereq_t*)arg)->ocount,
	250	((xfs_fsop_getparents_handlereq_t*)arg)->omore);
8967ee43 TS	251	case SGI_ATTR_MULTI_BY_HANDLE:
	252	return syssgi(cmd,
	253	((xfs_fsop_attrmulti_handlereq_t*)arg)->hreq.ihandle,
	254	((xfs_fsop_attrmulti_handlereq_t*)arg)->hreq.ihandlen,
	255	((xfs_fsop_attrmulti_handlereq_t*)arg)->ops,
	256	((xfs_fsop_attrmulti_handlereq_t*)arg)->opcount,
	257	((xfs_fsop_attrmulti_handlereq_t*)arg)->hreq.oflags);
	258	case SGI_FSSETDM_BY_HANDLE:
	259	return syssgi(cmd,
	260	((xfs_fsop_setdm_handlereq_t*)arg)->hreq.ihandle,
	261	((xfs_fsop_setdm_handlereq_t*)arg)->hreq.ihandlen,
	262	((xfs_fsop_setdm_handlereq_t*)arg)->data);
eb0c6f87 TS	263	}
eb0c6f87 TS	264	return fcntl(fd, cmd, arg);
c0211f67 NS	265	}
	266
	267	static __inline__ int platform_test_xfs_fd(int fd)
	268	{
	269	struct statvfs sbuf;
	270	if (fstatvfs(fd, &sbuf) < 0)
	271	return 0;
714bd9e5	272	return strncmp(sbuf.f_basetype, "xfs", 4) == 0;
c0211f67 NS	273	}
	274
	275	static __inline__ int platform_test_xfs_path(const char *path)
	276	{
	277	struct statvfs sbuf;
	278	if (statvfs(path, &sbuf) < 0)
	279	return 0;
714bd9e5	280	return strncmp(sbuf.f_basetype, "xfs", 4) == 0;
c0211f67 NS	281	}
	282
	283	static __inline__ int platform_fstatfs(int fd, struct statfs *buf)
	284	{
	285	return fstatfs(fd, buf, sizeof(struct statfs), 0);
	286	}
	287
	288	static __inline__ void platform_getoptreset(void)
	289	{
	290	getoptreset();
	291	}
	292
1552a820 NS	293	static __inline__ int platform_uuid_compare(uuid_t uu1, uuid_t uu2)
	294	{
	295	uint_t status;
	296	return uuid_compare(uu1, uu2, &status);
	297	}
	298
4d32d744	299	static __inline__ void platform_uuid_unparse(uuid_t uu, char buffer)
1552a820 NS	300	{
	301	uint_t status;
	302	char *s;
	303	uuid_to_string(uu, &s, &status);
	304	if (status == uuid_s_ok)
4d32d744 NS	305	strcpy(buffer, s);
4d32d744 NS	306	else buffer[0] = '\0';
1552a820 NS	307	free(s);
	308	}
	309
	310	static __inline__ int platform_uuid_parse(char buffer, uuid_t uu)
	311	{
	312	uint_t status;
	313	uuid_from_string(buffer, uu, &status);
	314	return (status == uuid_s_ok);
	315	}
	316
	317	static __inline__ int platform_uuid_is_null(uuid_t *uu)
	318	{
	319	uint status;
	320	return uuid_is_nil(uu, &status);
	321	}
	322
	323	static __inline__ void platform_uuid_generate(uuid_t *uu)
	324	{
	325	uint_t status;
	326	uuid_create(uu, &status);
	327	}
	328
	329	static __inline__ void platform_uuid_clear(uuid_t *uu)
	330	{
	331	uint_t status;
	332	uuid_create_nil(uu, &status);
	333	}
	334
	335	static __inline__ void platform_uuid_copy(uuid_t dst, uuid_t src)
	336	{
	337	memcpy(dst, src, sizeof(uuid_t));
	338	}
	339
c0211f67 NS	340	static __inline__ char * strsep(char *s, const char ct)
	341	{
	342	char sbegin = s, *end;
	343
	344	if (!sbegin)
	345	return NULL;
	346	end = strpbrk(sbegin, ct);
	347	if (end)
	348	*end++ = '\0';
	349	*s = end;
	350	return sbegin;
	351	}
	352
	353	#define HAVE_DIOATTR 1
	354	#define HAVE_FSXATTR 1
	355	#define HAVE_GETBMAP 1
	356	#define HAVE_GETBMAPX 1
	357	#define HAVE_FSDMIDATA 1
	358	#define HAVE_FID 1
	359	#define HAVE_IOCMACROS 1
	360	#define HAVE_BBMACROS 1
	361
5ecb3de2	362	#define __XFS_FS_H__ 1
c0211f67 NS	363
	364	#define XFS_IOC_DIOINFO F_DIOINFO
	365	#define XFS_IOC_FSGETXATTR F_FSGETXATTR
	366	#define XFS_IOC_FSSETXATTR F_FSSETXATTR
	367	#define XFS_IOC_ALLOCSP64 F_ALLOCSP64
	368	#define XFS_IOC_FREESP64 F_FREESP64
	369	#define XFS_IOC_GETBMAP F_GETBMAP
	370	#define XFS_IOC_FSSETDM F_FSSETDM
8967ee43	371	#define XFS_IOC_RESVSP F_RESVSP
c0211f67	372	#define XFS_IOC_RESVSP64 F_RESVSP64
8967ee43	373	#define XFS_IOC_UNRESVSP F_UNRESVSP
c0211f67 NS	374	#define XFS_IOC_UNRESVSP64 F_UNRESVSP64
	375	#define XFS_IOC_GETBMAPA F_GETBMAPA
	376	#define XFS_IOC_FSGETXATTRA F_FSGETXATTRA
	377	#define XFS_IOC_GETBMAPX F_GETBMAPX
	378
	379	#define XFS_IOC_FSGEOMETRY_V1 XFS_FS_GEOMETRY
8967ee43	380	#define XFS_IOC_FSBULKSTAT SGI_FS_BULKSTAT
eb0c6f87	381	#define XFS_IOC_FSBULKSTAT_SINGLE SGI_FS_BULKSTAT_SINGLE
9527f2d5	382	#define XFS_IOC_FSINUMBERS SGI_FS_INUMBERS
8967ee43 TS	383	#define XFS_IOC_PATH_TO_FSHANDLE SGI_PATH_TO_FSHANDLE
	384	#define XFS_IOC_PATH_TO_HANDLE SGI_PATH_TO_HANDLE
	385	#define XFS_IOC_FD_TO_HANDLE SGI_FD_TO_HANDLE
	386	#define XFS_IOC_OPEN_BY_HANDLE SGI_OPEN_BY_HANDLE
	387	#define XFS_IOC_READLINK_BY_HANDLE SGI_READLINK_BY_HANDLE
c0211f67 NS	388	#define XFS_IOC_SWAPEXT /* TODO */
	389	#define XFS_IOC_FSGROWFSDATA XFS_GROWFS_DATA
	390	#define XFS_IOC_FSGROWFSLOG XFS_GROWFS_LOG
	391	#define XFS_IOC_FSGROWFSRT XFS_GROWFS_RT
	392	#define XFS_IOC_FSCOUNTS XFS_FS_COUNTS
	393	#define XFS_IOC_SET_RESBLKS XFS_SET_RESBLKS
	394	#define XFS_IOC_GET_RESBLKS XFS_GET_RESBLKS
eb0c6f87 TS	395	#define XFS_IOC_ERROR_INJECTION SGI_XFS_INJECT_ERROR
eb0c6f87 TS	396	#define XFS_IOC_ERROR_CLEARALL SGI_XFS_CLEARALL_ERROR
c0211f67 NS	397	#define XFS_IOC_FREEZE XFS_FS_FREEZE
c0211f67 NS	398	#define XFS_IOC_THAW XFS_FS_THAW
8967ee43 TS	399	#define XFS_IOC_FSSETDM_BY_HANDLE SGI_FSSETDM_BY_HANDLE
	400	#define XFS_IOC_ATTRLIST_BY_HANDLE SGI_ATTR_LIST_BY_HANDLE
	401	#define XFS_IOC_ATTRMULTI_BY_HANDLE SGI_ATTR_MULTI_BY_HANDLE
c0211f67 NS	402	#define XFS_IOC_FSGEOMETRY XFS_FS_GEOMETRY
c0211f67 NS	403	#define XFS_IOC_GOINGDOWN XFS_FS_GOINGDOWN
258b00ea TS	404	#define XFS_IOC_GETPARENTS SGI_XFS_GETPARENTS
258b00ea TS	405	#define XFS_IOC_GETPARENTPATHS SGI_XFS_GETPARENTPATHS
c0211f67	406
cb5b3ef4 MV	407	#define _AIOCB64_T_DEFINED 1
cb5b3ef4 MV	408
d3a8db8a TS	409	#define XFS_XFLAG_NODEFRAG 0x00002000
d3a8db8a TS	410
c0211f67	411	#endif /* __XFS_IRIX_H__ */