[thirdparty/xfsprogs-dev.git] / libhandle / handle.c

// SPDX-License-Identifier: LGPL-2.1
/*
 * Copyright (c) 1995, 2001-2003, 2005 Silicon Graphics, Inc.
 * All Rights Reserved.
 */

#include <libgen.h>
#include "platform_defs.h"
#include "xfs.h"
#include "handle.h"
#include "parent.h"

/* just pick a value we know is more than big enough */
#define	MAXHANSIZ	64

/*
 *  The actual content of a handle is supposed to be opaque here.
 *  But, to do handle_to_fshandle, we need to know what it is.  Sigh.
 *  However we can get by with knowing only that the first 8 bytes of
 *  a file handle are the file system ID, and that a file system handle
 *  consists of only those 8 bytes.
 */

#define	FSIDSIZE	8

typedef union {
	int	fd;
	char	*path;
} comarg_t;

static int obj_to_handle(char *, int, unsigned int, comarg_t, void**, size_t*);
static int handle_to_fsfd(void *, char **);
static char *path_to_fspath(char *path);


/*
 * Filesystem Handle -> Open File Descriptor Cache
 *
 * Maps filesystem handles to a corresponding open file descriptor for that
 * filesystem. We need this because we're doing handle operations via xfsctl
 * and we need to remember the open file descriptor for each filesystem.
 */

struct fdhash {
	int	fsfd;
	char	fsh[FSIDSIZE];
	struct fdhash *fnxt;
	char	fspath[MAXPATHLEN];
};

static struct fdhash *fdhash_head = NULL;

void
fshandle_destroy(void)
{
	struct fdhash	*nexth;
	struct fdhash	*h = fdhash_head;

	while (h) {
		nexth = h->fnxt;
		free(h);
		h = nexth;
	}
	fdhash_head = NULL;
}

int
path_to_fshandle(
	char		*path,		/* input,  path to convert */
	void		**fshanp,	/* output, pointer to data */
	size_t		*fshlen)	/* output, size of returned data */
{
	int		result;
	int		fd;
	comarg_t	obj;
	struct fdhash	*fdhp;
	char		*tmppath;
	char		*fspath;

	fspath = path_to_fspath(path);
	if (fspath == NULL)
		return -1;

	fd = open(fspath, O_RDONLY);
	if (fd < 0)
		return -1;

	obj.path = path;
	result = obj_to_handle(fspath, fd, XFS_IOC_PATH_TO_FSHANDLE,
				obj, fshanp, fshlen);
	if (result < 0) {
		close(fd);
		return result;
	}

	if (handle_to_fsfd(*fshanp, &tmppath) >= 0) {
		/* this filesystem is already in the cache */
		close(fd);
	} else {
		/* new filesystem. add it to the cache */
		fdhp = malloc(sizeof(struct fdhash));
		if (fdhp == NULL) {
			free(*fshanp);
			close(fd);
			errno = ENOMEM;
			return -1;
		}

		fdhp->fsfd = fd;
		strncpy(fdhp->fspath, fspath, sizeof(fdhp->fspath));
		memcpy(fdhp->fsh, *fshanp, FSIDSIZE);

		fdhp->fnxt = fdhash_head;
		fdhash_head = fdhp;
	}

	return result;
}

int
path_to_handle(
	char		*path,		/* input,  path to convert */
	void		**hanp,		/* output, pointer to data */
	size_t		*hlen)		/* output, size of returned data */
{
	int		fd;
	int		result;
	comarg_t	obj;
	char		*fspath;

	fspath = path_to_fspath(path);
	if (fspath == NULL)
		return -1;

	fd = open(fspath, O_RDONLY);
	if (fd < 0)
		return -1;

	obj.path = path;
	result = obj_to_handle(fspath, fd, XFS_IOC_PATH_TO_HANDLE,
				obj, hanp, hlen);
	close(fd);
	return result;
}

/* Given a path, return a suitable "fspath" for use in obtaining
 * an fd for xfsctl calls. For regular files and directories the
 * input path is sufficient. For other types the parent directory
 * is used to avoid issues with opening dangling symlinks and
 * potentially blocking in an open on a named pipe. Also
 * symlinks to files on other filesystems would be a problem,
 * since an fd would be obtained for the wrong fs.
 */
static char *
path_to_fspath(char *path)
{
	static char dirpath[MAXPATHLEN];
	struct stat statbuf;

	if (lstat(path, &statbuf) != 0)
		return NULL;

	if (S_ISREG(statbuf.st_mode) || S_ISDIR(statbuf.st_mode))
		return path;

	strncpy(dirpath, path, MAXPATHLEN);
	dirpath[MAXPATHLEN-1] = '\0';
	return dirname(dirpath);
}

int
fd_to_handle (
	int		fd,		/* input,  file descriptor */
	void		**hanp,		/* output, pointer to data */
	size_t		*hlen)		/* output, size of returned data */
{
	comarg_t	obj;

	obj.fd = fd;
	return obj_to_handle(NULL, fd, XFS_IOC_FD_TO_HANDLE, obj, hanp, hlen);
}


int
handle_to_fshandle(
	void		*hanp,
	size_t		hlen,
	void		**fshanp,
	size_t		*fshlen)
{
	if (hlen < FSIDSIZE) {
		errno = EINVAL;
		return -1;
	}
	*fshanp = malloc(FSIDSIZE);
	if (*fshanp == NULL) {
		errno = ENOMEM;
		return -1;
	}
	*fshlen = FSIDSIZE;
	memcpy(*fshanp, hanp, FSIDSIZE);
	return 0;
}

static int
handle_to_fsfd(void *hanp, char **path)
{
	struct fdhash	*fdhp;

	/*
	 * Look in cache for matching fsid field in the handle
	 * (which is at the start of the handle).
	 * When found return the file descriptor and path that
	 * we have in the cache.
	 */
	for (fdhp = fdhash_head; fdhp != NULL; fdhp = fdhp->fnxt) {
		if (memcmp(fdhp->fsh, hanp, FSIDSIZE) == 0) {
			*path = fdhp->fspath;
			return fdhp->fsfd;
		}
	}
	errno = EBADF;
	return -1;
}

static int
obj_to_handle(
	char		*fspath,
	int		fsfd,
	unsigned int	opcode,
	comarg_t	obj,
	void		**hanp,
	size_t		*hlen)
{
	char		hbuf [MAXHANSIZ];
	int		ret;
	uint32_t	handlen;
	xfs_fsop_handlereq_t hreq;

	if (opcode == XFS_IOC_FD_TO_HANDLE) {
		hreq.fd      = obj.fd;
		hreq.path    = NULL;
	} else {
		hreq.fd      = 0;
		hreq.path    = obj.path;
	}

	hreq.oflags   = O_LARGEFILE;
	hreq.ihandle  = NULL;
	hreq.ihandlen = 0;
	hreq.ohandle  = hbuf;
	hreq.ohandlen = &handlen;

	ret = xfsctl(fspath, fsfd, opcode, &hreq);
	if (ret)
		return ret;

	*hanp = malloc(handlen);
	if (*hanp == NULL) {
		errno = ENOMEM;
		return -1;
	}

	memcpy(*hanp, hbuf, handlen);
	*hlen = handlen;
	return 0;
}

int
open_by_fshandle(
	void		*fshanp,
	size_t		fshlen,
	int		rw)
{
	int		fsfd;
	char		*path;
	xfs_fsop_handlereq_t hreq;

	if ((fsfd = handle_to_fsfd(fshanp, &path)) < 0)
		return -1;

	hreq.fd       = 0;
	hreq.path     = NULL;
	hreq.oflags   = rw | O_LARGEFILE;
	hreq.ihandle  = fshanp;
	hreq.ihandlen = fshlen;
	hreq.ohandle  = NULL;
	hreq.ohandlen = NULL;

	return xfsctl(path, fsfd, XFS_IOC_OPEN_BY_HANDLE, &hreq);
}

int
open_by_handle(
	void		*hanp,
	size_t		hlen,
	int		rw)
{
	int		fsfd;
	char		*path;
	xfs_fsop_handlereq_t hreq;

	if ((fsfd = handle_to_fsfd(hanp, &path)) < 0)
		return -1;

	hreq.fd       = 0;
	hreq.path     = NULL;
	hreq.oflags   = rw | O_LARGEFILE;
	hreq.ihandle  = hanp;
	hreq.ihandlen = hlen;
	hreq.ohandle  = NULL;
	hreq.ohandlen = NULL;

	return xfsctl(path, fsfd, XFS_IOC_OPEN_BY_HANDLE, &hreq);
}

int
readlink_by_handle(
	void		*hanp,
	size_t		hlen,
	void		*buf,
	size_t		bufsiz)
{
	int		fd;
	__u32		buflen = (__u32)bufsiz;
	char		*path;
	xfs_fsop_handlereq_t hreq;

	if ((fd = handle_to_fsfd(hanp, &path)) < 0)
		return -1;

	hreq.fd       = 0;
	hreq.path     = NULL;
	hreq.oflags   = O_LARGEFILE;
	hreq.ihandle  = hanp;
	hreq.ihandlen = hlen;
	hreq.ohandle  = buf;
	hreq.ohandlen = &buflen;

	return xfsctl(path, fd, XFS_IOC_READLINK_BY_HANDLE, &hreq);
}

/*ARGSUSED4*/
int
attr_multi_by_handle(
	void		*hanp,
	size_t		hlen,
	void		*buf,
	int		rtrvcnt,
	int		flags)
{
	int		fd;
	char		*path;
	xfs_fsop_attrmulti_handlereq_t amhreq;

	if ((fd = handle_to_fsfd(hanp, &path)) < 0)
		return -1;

	amhreq.hreq.fd       = 0;
	amhreq.hreq.path     = NULL;
	amhreq.hreq.oflags   = O_LARGEFILE;
	amhreq.hreq.ihandle  = hanp;
	amhreq.hreq.ihandlen = hlen;
	amhreq.hreq.ohandle  = NULL;
	amhreq.hreq.ohandlen = NULL;

	amhreq.opcount = rtrvcnt;
	amhreq.ops = buf;

	return xfsctl(path, fd, XFS_IOC_ATTRMULTI_BY_HANDLE, &amhreq);
}

int
attr_list_by_handle(
	void		*hanp,
	size_t		hlen,
	void		*buf,
	size_t		bufsize,
	int		flags,
	struct attrlist_cursor *cursor)
{
	int		error, fd;
	char		*path;
	xfs_fsop_attrlist_handlereq_t alhreq;

	if ((fd = handle_to_fsfd(hanp, &path)) < 0)
		return -1;

	alhreq.hreq.fd       = 0;
	alhreq.hreq.path     = NULL;
	alhreq.hreq.oflags   = O_LARGEFILE;
	alhreq.hreq.ihandle  = hanp;
	alhreq.hreq.ihandlen = hlen;
	alhreq.hreq.ohandle  = NULL;
	alhreq.hreq.ohandlen = NULL;

	memcpy(&alhreq.pos, cursor, sizeof(alhreq.pos));
	alhreq.flags = flags;
	alhreq.buffer = buf;
	alhreq.buflen = bufsize;
	/* prevent needless EINVAL from the kernel */
	if (alhreq.buflen > XFS_XATTR_LIST_MAX)
		alhreq.buflen = XFS_XATTR_LIST_MAX;

	error = xfsctl(path, fd, XFS_IOC_ATTRLIST_BY_HANDLE, &alhreq);

	memcpy(cursor, &alhreq.pos, sizeof(alhreq.pos));
	return error;
}

int
parents_by_handle(
	void		*hanp,
	size_t		hlen,
	parent_t	*buf,
	size_t		bufsiz,
	unsigned int	*count)

{
	errno = EOPNOTSUPP;
	return -1;
}

int
parentpaths_by_handle(
	void		*hanp,
	size_t		hlen,
	parent_t	*buf,
	size_t		bufsiz,
	unsigned int	*count)
{
	errno = EOPNOTSUPP;
	return -1;
}

int
fssetdm_by_handle(
	void		*hanp,
	size_t		hlen,
	struct fsdmidata *fsdmidata)
{
	int		fd;
	char		*path;
	xfs_fsop_setdm_handlereq_t dmhreq;

	if ((fd = handle_to_fsfd(hanp, &path)) < 0)
		return -1;

	dmhreq.hreq.fd       = 0;
	dmhreq.hreq.path     = NULL;
	dmhreq.hreq.oflags   = O_LARGEFILE;
	dmhreq.hreq.ihandle  = hanp;
	dmhreq.hreq.ihandlen = hlen;
	dmhreq.hreq.ohandle  = NULL;
	dmhreq.hreq.ohandlen = NULL;

	dmhreq.data = fsdmidata;

	return xfsctl(path, fd, XFS_IOC_FSSETDM_BY_HANDLE, &dmhreq);
}

/*ARGSUSED1*/
void
free_handle(
	void		*hanp,
	size_t		hlen)
{
	free(hanp);
}
Commit	Line	Data
959ef981	1	// SPDX-License-Identifier: LGPL-2.1
e9688c1d	2	/*
da23017d NS	3	* Copyright (c) 1995, 2001-2003, 2005 Silicon Graphics, Inc.
da23017d NS	4	* All Rights Reserved.
e9688c1d NS	5	*/
e9688c1d NS	6
a8de1cf9	7	#include <libgen.h>
dcabd4e7	8	#include "platform_defs.h"
6b803e5a CH	9	#include "xfs.h"
	10	#include "handle.h"
	11	#include "parent.h"
e9688c1d	12
e9688c1d NS	13	/* just pick a value we know is more than big enough */
	14	#define MAXHANSIZ 64
	15
	16	/*
	17	* The actual content of a handle is supposed to be opaque here.
	18	* But, to do handle_to_fshandle, we need to know what it is. Sigh.
	19	* However we can get by with knowing only that the first 8 bytes of
	20	* a file handle are the file system ID, and that a file system handle
	21	* consists of only those 8 bytes.
	22	*/
	23
	24	#define FSIDSIZE 8
	25
	26	typedef union {
	27	int fd;
	28	char *path;
	29	} comarg_t;
	30
3fbbdc85 NS	31	static int obj_to_handle(char , int, unsigned int, comarg_t, void, size_t);
3fbbdc85 NS	32	static int handle_to_fsfd(void , char *);
a8de1cf9	33	static char path_to_fspath(char path);
93d9f139	34
89184fbc AG	35
	36	/*
	37	* Filesystem Handle -> Open File Descriptor Cache
	38	*
	39	* Maps filesystem handles to a corresponding open file descriptor for that
93d9f139	40	* filesystem. We need this because we're doing handle operations via xfsctl
89184fbc AG	41	* and we need to remember the open file descriptor for each filesystem.
89184fbc AG	42	*/
e9688c1d NS	43
	44	struct fdhash {
	45	int fsfd;
	46	char fsh[FSIDSIZE];
	47	struct fdhash *fnxt;
93d9f139	48	char fspath[MAXPATHLEN];
e9688c1d NS	49	};
e9688c1d NS	50
dc987226	51	static struct fdhash *fdhash_head = NULL;
e9688c1d	52
852fe013 DW	53	void
	54	fshandle_destroy(void)
	55	{
	56	struct fdhash *nexth;
	57	struct fdhash *h = fdhash_head;
	58
	59	while (h) {
	60	nexth = h->fnxt;
	61	free(h);
	62	h = nexth;
	63	}
1ad4d3ba	64	fdhash_head = NULL;
852fe013 DW	65	}
852fe013 DW	66
e9688c1d	67	int
3fbbdc85	68	path_to_fshandle(
e9688c1d	69	char path, / input, path to convert */
a3cbe7cd MK	70	void *fshanp, / output, pointer to data */
a3cbe7cd MK	71	size_t fshlen) / output, size of returned data */
e9688c1d NS	72	{
	73	int result;
	74	int fd;
	75	comarg_t obj;
	76	struct fdhash *fdhp;
dc987226	77	char *tmppath;
a8de1cf9	78	char *fspath;
e9688c1d	79
a8de1cf9 BK	80	fspath = path_to_fspath(path);
	81	if (fspath == NULL)
	82	return -1;
	83
	84	fd = open(fspath, O_RDONLY);
3fbbdc85 NS	85	if (fd < 0)
3fbbdc85 NS	86	return -1;
e9688c1d NS	87
e9688c1d NS	88	obj.path = path;
a8de1cf9	89	result = obj_to_handle(fspath, fd, XFS_IOC_PATH_TO_FSHANDLE,
a3cbe7cd	90	obj, fshanp, fshlen);
dc987226 BK	91	if (result < 0) {
	92	close(fd);
	93	return result;
	94	}
da23017d	95
dc987226 BK	96	if (handle_to_fsfd(*fshanp, &tmppath) >= 0) {
	97	/* this filesystem is already in the cache */
	98	close(fd);
	99	} else {
	100	/* new filesystem. add it to the cache */
e9688c1d	101	fdhp = malloc(sizeof(struct fdhash));
e9688c1d	102	if (fdhp == NULL) {
8f1c8e13	103	free(*fshanp);
11e06961	104	close(fd);
e9688c1d NS	105	errno = ENOMEM;
	106	return -1;
	107	}
	108
	109	fdhp->fsfd = fd;
a8de1cf9	110	strncpy(fdhp->fspath, fspath, sizeof(fdhp->fspath));
a3cbe7cd MK	111	memcpy(fdhp->fsh, *fshanp, FSIDSIZE);
a3cbe7cd MK	112
dc987226 BK	113	fdhp->fnxt = fdhash_head;
dc987226 BK	114	fdhash_head = fdhp;
e9688c1d NS	115	}
	116
	117	return result;
	118	}
	119
e9688c1d	120	int
3fbbdc85	121	path_to_handle(
e9688c1d NS	122	char path, / input, path to convert */
	123	void *hanp, / output, pointer to data */
	124	size_t hlen) / output, size of returned data */
	125	{
	126	int fd;
	127	int result;
	128	comarg_t obj;
a8de1cf9	129	char *fspath;
e9688c1d	130
a8de1cf9 BK	131	fspath = path_to_fspath(path);
	132	if (fspath == NULL)
	133	return -1;
	134
	135	fd = open(fspath, O_RDONLY);
3fbbdc85 NS	136	if (fd < 0)
3fbbdc85 NS	137	return -1;
e9688c1d NS	138
e9688c1d NS	139	obj.path = path;
a8de1cf9	140	result = obj_to_handle(fspath, fd, XFS_IOC_PATH_TO_HANDLE,
3fbbdc85	141	obj, hanp, hlen);
e9688c1d	142	close(fd);
e9688c1d NS	143	return result;
	144	}
	145
a8de1cf9 BK	146	/* Given a path, return a suitable "fspath" for use in obtaining
	147	* an fd for xfsctl calls. For regular files and directories the
	148	* input path is sufficient. For other types the parent directory
	149	* is used to avoid issues with opening dangling symlinks and
	150	* potentially blocking in an open on a named pipe. Also
	151	* symlinks to files on other filesystems would be a problem,
	152	* since an fd would be obtained for the wrong fs.
	153	*/
	154	static char *
	155	path_to_fspath(char *path)
	156	{
	157	static char dirpath[MAXPATHLEN];
	158	struct stat statbuf;
	159
	160	if (lstat(path, &statbuf) != 0)
	161	return NULL;
	162
	163	if (S_ISREG(statbuf.st_mode) \|\| S_ISDIR(statbuf.st_mode))
	164	return path;
	165
55d1fd48 ES	166	strncpy(dirpath, path, MAXPATHLEN);
55d1fd48 ES	167	dirpath[MAXPATHLEN-1] = '\0';
a8de1cf9 BK	168	return dirname(dirpath);
a8de1cf9 BK	169	}
8967ee43 TS	170
	171	int
	172	fd_to_handle (
	173	int fd, /* input, file descriptor */
	174	void *hanp, / output, pointer to data */
	175	size_t hlen) / output, size of returned data */
	176	{
	177	comarg_t obj;
	178
	179	obj.fd = fd;
	180	return obj_to_handle(NULL, fd, XFS_IOC_FD_TO_HANDLE, obj, hanp, hlen);
	181	}
	182
	183
e9688c1d	184	int
3fbbdc85	185	handle_to_fshandle(
e9688c1d NS	186	void *hanp,
	187	size_t hlen,
	188	void **fshanp,
	189	size_t *fshlen)
	190	{
dc987226 BK	191	if (hlen < FSIDSIZE) {
	192	errno = EINVAL;
	193	return -1;
	194	}
3fbbdc85	195	*fshanp = malloc(FSIDSIZE);
dc987226 BK	196	if (*fshanp == NULL) {
	197	errno = ENOMEM;
	198	return -1;
	199	}
e9688c1d	200	*fshlen = FSIDSIZE;
e9688c1d	201	memcpy(*fshanp, hanp, FSIDSIZE);
e9688c1d NS	202	return 0;
	203	}
	204
93d9f139 NS	205	static int
93d9f139 NS	206	handle_to_fsfd(void hanp, char *path)
89184fbc AG	207	{
	208	struct fdhash *fdhp;
	209
8967ee43 TS	210	/*
	211	* Look in cache for matching fsid field in the handle
	212	* (which is at the start of the handle).
	213	* When found return the file descriptor and path that
	214	* we have in the cache.
	215	*/
89184fbc	216	for (fdhp = fdhash_head; fdhp != NULL; fdhp = fdhp->fnxt) {
93d9f139 NS	217	if (memcmp(fdhp->fsh, hanp, FSIDSIZE) == 0) {
93d9f139 NS	218	*path = fdhp->fspath;
89184fbc	219	return fdhp->fsfd;
93d9f139	220	}
89184fbc	221	}
3fbbdc85	222	errno = EBADF;
89184fbc AG	223	return -1;
	224	}
	225
93d9f139	226	static int
3fbbdc85	227	obj_to_handle(
93d9f139	228	char *fspath,
e9688c1d	229	int fsfd,
5b64e00a	230	unsigned int opcode,
e9688c1d NS	231	comarg_t obj,
	232	void **hanp,
	233	size_t *hlen)
	234	{
	235	char hbuf [MAXHANSIZ];
	236	int ret;
14f8b681	237	uint32_t handlen;
e9688c1d NS	238	xfs_fsop_handlereq_t hreq;
	239
	240	if (opcode == XFS_IOC_FD_TO_HANDLE) {
	241	hreq.fd = obj.fd;
	242	hreq.path = NULL;
	243	} else {
	244	hreq.fd = 0;
	245	hreq.path = obj.path;
	246	}
	247
489aaf4d	248	hreq.oflags = O_LARGEFILE;
e9688c1d NS	249	hreq.ihandle = NULL;
	250	hreq.ihandlen = 0;
	251	hreq.ohandle = hbuf;
ace4c158	252	hreq.ohandlen = &handlen;
fe37ab57	253
93d9f139	254	ret = xfsctl(fspath, fsfd, opcode, &hreq);
e9688c1d NS	255	if (ret)
	256	return ret;
	257
ace4c158	258	*hanp = malloc(handlen);
e9688c1d NS	259	if (*hanp == NULL) {
	260	errno = ENOMEM;
	261	return -1;
	262	}
	263
ace4c158 CH	264	memcpy(*hanp, hbuf, handlen);
ace4c158 CH	265	*hlen = handlen;
e9688c1d NS	266	return 0;
	267	}
	268
a3cbe7cd MK	269	int
	270	open_by_fshandle(
	271	void *fshanp,
	272	size_t fshlen,
	273	int rw)
	274	{
	275	int fsfd;
	276	char *path;
	277	xfs_fsop_handlereq_t hreq;
	278
	279	if ((fsfd = handle_to_fsfd(fshanp, &path)) < 0)
	280	return -1;
	281
	282	hreq.fd = 0;
	283	hreq.path = NULL;
	284	hreq.oflags = rw \| O_LARGEFILE;
	285	hreq.ihandle = fshanp;
	286	hreq.ihandlen = fshlen;
	287	hreq.ohandle = NULL;
	288	hreq.ohandlen = NULL;
	289
	290	return xfsctl(path, fsfd, XFS_IOC_OPEN_BY_HANDLE, &hreq);
	291	}
	292
e9688c1d	293	int
3fbbdc85	294	open_by_handle(
e9688c1d NS	295	void *hanp,
	296	size_t hlen,
	297	int rw)
	298	{
a3cbe7cd	299	int fsfd;
93d9f139	300	char *path;
e9688c1d NS	301	xfs_fsop_handlereq_t hreq;
e9688c1d NS	302
45243d21	303	if ((fsfd = handle_to_fsfd(hanp, &path)) < 0)
e9688c1d	304	return -1;
e9688c1d NS	305
	306	hreq.fd = 0;
	307	hreq.path = NULL;
489aaf4d	308	hreq.oflags = rw \| O_LARGEFILE;
e9688c1d NS	309	hreq.ihandle = hanp;
	310	hreq.ihandlen = hlen;
	311	hreq.ohandle = NULL;
	312	hreq.ohandlen = NULL;
	313
a3cbe7cd	314	return xfsctl(path, fsfd, XFS_IOC_OPEN_BY_HANDLE, &hreq);
e9688c1d NS	315	}
	316
	317	int
3fbbdc85	318	readlink_by_handle(
e9688c1d NS	319	void *hanp,
	320	size_t hlen,
	321	void *buf,
	322	size_t bufsiz)
	323	{
	324	int fd;
1771a6dd	325	__u32 buflen = (__u32)bufsiz;
93d9f139	326	char *path;
e9688c1d NS	327	xfs_fsop_handlereq_t hreq;
e9688c1d NS	328
3fbbdc85	329	if ((fd = handle_to_fsfd(hanp, &path)) < 0)
e9688c1d	330	return -1;
e9688c1d NS	331
	332	hreq.fd = 0;
	333	hreq.path = NULL;
489aaf4d	334	hreq.oflags = O_LARGEFILE;
e9688c1d NS	335	hreq.ihandle = hanp;
	336	hreq.ihandlen = hlen;
	337	hreq.ohandle = buf;
1771a6dd	338	hreq.ohandlen = &buflen;
e9688c1d	339
93d9f139	340	return xfsctl(path, fd, XFS_IOC_READLINK_BY_HANDLE, &hreq);
e9688c1d NS	341	}
e9688c1d NS	342
8967ee43	343	/ARGSUSED4/
14290264 NS	344	int
	345	attr_multi_by_handle(
	346	void *hanp,
	347	size_t hlen,
	348	void *buf,
	349	int rtrvcnt,
	350	int flags)
	351	{
	352	int fd;
93d9f139	353	char *path;
14290264 NS	354	xfs_fsop_attrmulti_handlereq_t amhreq;
14290264 NS	355
3fbbdc85	356	if ((fd = handle_to_fsfd(hanp, &path)) < 0)
14290264	357	return -1;
14290264 NS	358
	359	amhreq.hreq.fd = 0;
	360	amhreq.hreq.path = NULL;
489aaf4d	361	amhreq.hreq.oflags = O_LARGEFILE;
14290264 NS	362	amhreq.hreq.ihandle = hanp;
	363	amhreq.hreq.ihandlen = hlen;
	364	amhreq.hreq.ohandle = NULL;
	365	amhreq.hreq.ohandlen = NULL;
	366
	367	amhreq.opcount = rtrvcnt;
	368	amhreq.ops = buf;
	369
93d9f139	370	return xfsctl(path, fd, XFS_IOC_ATTRMULTI_BY_HANDLE, &amhreq);
14290264 NS	371	}
	372
	373	int
	374	attr_list_by_handle(
	375	void *hanp,
	376	size_t hlen,
	377	void *buf,
	378	size_t bufsize,
	379	int flags,
	380	struct attrlist_cursor *cursor)
	381	{
258b00ea	382	int error, fd;
93d9f139	383	char *path;
14290264 NS	384	xfs_fsop_attrlist_handlereq_t alhreq;
14290264 NS	385
3fbbdc85	386	if ((fd = handle_to_fsfd(hanp, &path)) < 0)
14290264	387	return -1;
14290264 NS	388
	389	alhreq.hreq.fd = 0;
	390	alhreq.hreq.path = NULL;
489aaf4d	391	alhreq.hreq.oflags = O_LARGEFILE;
14290264 NS	392	alhreq.hreq.ihandle = hanp;
	393	alhreq.hreq.ihandlen = hlen;
	394	alhreq.hreq.ohandle = NULL;
	395	alhreq.hreq.ohandlen = NULL;
	396
	397	memcpy(&alhreq.pos, cursor, sizeof(alhreq.pos));
	398	alhreq.flags = flags;
14290264	399	alhreq.buffer = buf;
aa23a327 MG	400	alhreq.buflen = bufsize;
aa23a327 MG	401	/* prevent needless EINVAL from the kernel */
54e724c0 JT	402	if (alhreq.buflen > XFS_XATTR_LIST_MAX)
54e724c0 JT	403	alhreq.buflen = XFS_XATTR_LIST_MAX;
14290264	404
258b00ea TS	405	error = xfsctl(path, fd, XFS_IOC_ATTRLIST_BY_HANDLE, &alhreq);
	406
	407	memcpy(cursor, &alhreq.pos, sizeof(alhreq.pos));
	408	return error;
	409	}
	410
	411	int
60ac13e8	412	parents_by_handle(
258b00ea TS	413	void *hanp,
	414	size_t hlen,
	415	parent_t *buf,
	416	size_t bufsiz,
60ac13e8	417	unsigned int *count)
f8149110	418
258b00ea	419	{
258b00ea TS	420	errno = EOPNOTSUPP;
258b00ea TS	421	return -1;
258b00ea TS	422	}
	423
	424	int
60ac13e8	425	parentpaths_by_handle(
258b00ea TS	426	void *hanp,
	427	size_t hlen,
	428	parent_t *buf,
	429	size_t bufsiz,
60ac13e8	430	unsigned int *count)
258b00ea	431	{
258b00ea TS	432	errno = EOPNOTSUPP;
258b00ea TS	433	return -1;
14290264 NS	434	}
14290264 NS	435
e1864286	436	int
3fbbdc85	437	fssetdm_by_handle(
e1864286 DR	438	void *hanp,
	439	size_t hlen,
	440	struct fsdmidata *fsdmidata)
	441	{
	442	int fd;
93d9f139	443	char *path;
e1864286 DR	444	xfs_fsop_setdm_handlereq_t dmhreq;
e1864286 DR	445
3fbbdc85	446	if ((fd = handle_to_fsfd(hanp, &path)) < 0)
e1864286	447	return -1;
e1864286 DR	448
	449	dmhreq.hreq.fd = 0;
	450	dmhreq.hreq.path = NULL;
489aaf4d	451	dmhreq.hreq.oflags = O_LARGEFILE;
e1864286 DR	452	dmhreq.hreq.ihandle = hanp;
	453	dmhreq.hreq.ihandlen = hlen;
	454	dmhreq.hreq.ohandle = NULL;
	455	dmhreq.hreq.ohandlen = NULL;
	456
	457	dmhreq.data = fsdmidata;
	458
93d9f139	459	return xfsctl(path, fd, XFS_IOC_FSSETDM_BY_HANDLE, &dmhreq);
e1864286 DR	460	}
e1864286 DR	461
8967ee43	462	/ARGSUSED1/
e9688c1d	463	void
3fbbdc85	464	free_handle(
e9688c1d NS	465	void *hanp,
	466	size_t hlen)
	467	{
3fbbdc85	468	free(hanp);
e9688c1d	469	}