rw.c

lustre 1.6.5 source code

PREPEND(_, SYSIO_INTERFACE_NAME(ireadx))(int fd,
					 const struct iovec *iov, 
					 size_t iov_count, 
					 const struct intnl_xtvec *xtv, 
					 size_t xtv_count)
{
	struct file *fil;
	int	err;
	struct ioctx *ioctx;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EBADF);

	/* Perform a check on the iov_count and xtv_count */
	if ((iov_count == 0) || (xtv_count == 0))
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EINVAL);

	err =
	    _sysio_iiox(IIOXOP_READ(fil->f_ino),
			fil,
			iov, iov_count, NULL,
			xtv, xtv_count, NULL,
			NULL,
			&ioctx);

	SYSIO_INTERFACE_RETURN(err ? IOID_FAIL : ioctx, err);
}

#ifdef _LARGEFILE64_SOURCE
#undef iread64x
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(ireadx)),
		     SYSIO_INTERFACE_NAME(iread64x))
#endif

#ifdef _LARGEFILE64_SOURCE
ioid_t
SYSIO_INTERFACE_NAME(ireadx)(int fd,
			     const struct iovec *iov, size_t iov_count,
			     const struct xtvec *xtv, size_t xtv_count)
{
	struct file *fil;
	struct intnl_xtvec *ixtv, *ixtvent;
	size_t	count;
	int	err;
	struct ioctx *ioctx;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EBADF);


	/* Perform a check on the iov_count and xtv_count */
	if ((iov_count == 0) || (xtv_count == 0))
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EINVAL);

	ixtv = ixtvent = malloc(xtv_count * sizeof(struct intnl_xtvec));
	if (!ixtv)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -ENOMEM);

	count = xtv_count;
	while (count--) {
		ixtvent->xtv_off = xtv->xtv_off;
		ixtvent->xtv_len = xtv->xtv_len;
		ixtvent++;
		xtv++;
	}

	err =
	    _sysio_iiox(IIOXOP_READ(fil->f_ino),
			fil,
			iov, iov_count, NULL,
			ixtv, xtv_count, free_xtv,
			NULL,
			&ioctx);
	if (err) {
		free(ixtv);
		SYSIO_INTERFACE_RETURN(IOID_FAIL, err);
	}
	SYSIO_INTERFACE_RETURN(ioctx, 0);
}
#else
#undef ireadx
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(ireadx)),
		     SYSIO_INTERFACE_NAME(ireadx))
#endif

ssize_t
SYSIO_INTERFACE_NAME(readx)(int fd,
			    const struct iovec *iov, size_t iov_count,
			    const struct xtvec *xtv, size_t xtv_count)
{
	ioid_t	ioid;

	if ((ioid = SYSIO_INTERFACE_NAME(ireadx)(fd, 
						 iov, 
						 iov_count, 
						 xtv, 
						 xtv_count)) == IOID_FAIL)
		return -1;
	return SYSIO_INTERFACE_NAME(iowait)(ioid);
}

#ifdef _LARGEFILE64_SOURCE
#undef iread64x
ssize_t
SYSIO_INTERFACE_NAME(read64x)(int fd,
			      const struct iovec *iov, size_t iov_count,
			      const struct xtvec64 *xtv, size_t xtv_count)
{
	ioid_t	ioid;

	if ((ioid = SYSIO_INTERFACE_NAME(iread64x)(fd, 
						   iov, 
						   iov_count, 
						   xtv, 
						   xtv_count)) == IOID_FAIL)
		return -1;
	return SYSIO_INTERFACE_NAME(iowait)(ioid);
}
#endif

#ifdef notdef
int
read_list(int fd,
	  int mem_list_count,
	  char *mem_offsets[],
	  int mem_lengths[],
	  int file_list_count,
	  int64_t file_offsets[],
	  int32_t file_lengths[])
{
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	SYSIO_INTERFACE_RETURN(-1, -ENOSYS);
}
#endif

ioid_t
SYSIO_INTERFACE_NAME(iwritev)(int fd, 
			      const struct iovec *iov, 
			      int count)
{
	struct file *fil;
	struct intnl_xtvec *xtv;
	struct ioctx *ioctx;
	int	err;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EBADF);

	xtv = malloc(sizeof(struct intnl_xtvec));
	if (!xtv)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -ENOMEM);

	err =
	    _sysio_iiov(IIOXOP_WRITE(fil->f_ino),
			fil,
			iov, count, NULL,
			xtv, free_xtv,
			&ioctx);
	if (err) {
		free(xtv);
		SYSIO_INTERFACE_RETURN(IOID_FAIL, err);
	}
	SYSIO_INTERFACE_RETURN(ioctx, 0);
}

ssize_t
SYSIO_INTERFACE_NAME(writev)(int fd, const struct iovec *iov, int count)
{
	struct file *fil;
	struct intnl_xtvec xtvector;
	struct ioctx *ioctx;
	int	err;
	ssize_t	cc;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(-1, -EBADF);

	err =
	    _sysio_iiov(IIOXOP_WRITE(fil->f_ino),
			fil,
			iov, count, NULL,
			&xtvector, NULL,
			&ioctx);
	if (!err && (cc = _sysio_ioctx_wait(ioctx)) < 0)
		err = (int )cc;

	SYSIO_INTERFACE_RETURN(err < 0 ? -1 : cc, err);
}

#ifdef __GLIBC__
#undef __writev
sysio_sym_weak_alias(SYSIO_INTERFACE_NAME(writev),
		     PREPEND(__, SYSIO_INTERFACE_NAME(writev)))
#undef __libc_writev
sysio_sym_weak_alias(SYSIO_INTERFACE_NAME(writev),
		     PREPEND(__, SYSIO_INTERFACE_NAME(libc_writev)))
#endif

ioid_t
SYSIO_INTERFACE_NAME(iwrite)(int fd, const void *buf, size_t count)
{
	struct iovec *iov;
	struct file *fil;
	struct intnl_xtvec *xtv;
	struct ioctx *ioctx;
	int	err;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EBADF);

	iov = malloc(sizeof(struct iovec));
	if (!iov)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -ENOMEM);

	iov->iov_base = (void *)buf;
	iov->iov_len = count;
	xtv = malloc(sizeof(struct intnl_xtvec));
	if (!xtv) {
		free(iov);
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -ENOMEM);
	}
	err =
	    _sysio_iiov(IIOXOP_WRITE(fil->f_ino),
			fil,
			iov, 1, free_iov,
			xtv, free_xtv,
			&ioctx);
	if (err) {
		free(xtv);
		free(iov);
		SYSIO_INTERFACE_RETURN(IOID_FAIL, err);
	}
	SYSIO_INTERFACE_RETURN(ioctx, 0);
}

ssize_t
SYSIO_INTERFACE_NAME(write)(int fd, const void *buf, size_t count)
{
	struct file *fil;
	struct iovec iovector;
	struct intnl_xtvec xtvector;
	int	err;
	struct ioctx *ioctx;
	ssize_t	cc;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(-1, -EBADF);

	iovector.iov_base = (void *)buf;
	iovector.iov_len = count;
	err =
	    _sysio_iiov(IIOXOP_WRITE(fil->f_ino),
			fil,
			&iovector, 1, NULL,
			&xtvector, NULL,
			&ioctx);
	if (!err && (cc = _sysio_ioctx_wait(ioctx)) < 0)
		err = (int )cc;

	SYSIO_INTERFACE_RETURN(err < 0 ? -1 : cc, err);
}

#ifdef __GLIBC__
#undef __write
sysio_sym_weak_alias(SYSIO_INTERFACE_NAME(write),
		     PREPEND(__, SYSIO_INTERFACE_NAME(write)))
#undef __libc_write
sysio_sym_weak_alias(SYSIO_INTERFACE_NAME(write),
		     PREPEND(__, SYSIO_INTERFACE_NAME(libc_write)))
#endif 

static ioid_t
PREPEND(_, SYSIO_INTERFACE_NAME(ipwritev))(int fd, 
					   const struct iovec *iov, 
					   size_t count, 
					   _SYSIO_OFF_T offset)
{
	struct file *fil;
	struct intnl_xtvec *xtv;
	struct ioctx *ioctx;
	int	err;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EBADF);

	xtv = malloc(sizeof(struct intnl_xtvec));
	if (!xtv)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -ENOMEM);

	err =
	    _sysio_ipiov(IIOXOP_WRITE(fil->f_ino),
			 fil,
			 iov, count, NULL,
			 offset,
			 xtv, free_xtv,
			 &ioctx);
	if (err) {
		free(xtv);
		SYSIO_INTERFACE_RETURN(IOID_FAIL, err);
	}
	SYSIO_INTERFACE_RETURN(ioctx, 0);
}

#ifdef _LARGEFILE64_SOURCE
#undef ipwrite64v
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(ipwritev)),
		     SYSIO_INTERFACE_NAME(ipwrite64v))
#endif

ioid_t
SYSIO_INTERFACE_NAME(ipwritev)(int fd, 
			       const struct iovec *iov, 
			       size_t count, 
			       off_t offset)
{

	return PREPEND(_, SYSIO_INTERFACE_NAME(ipwritev))(fd, 
							  iov, 
							  count, 
							  offset);
}

static ssize_t
PREPEND(_, SYSIO_INTERFACE_NAME(pwritev))(int fd, 
					  const struct iovec *iov, 
					  size_t count, 
					  _SYSIO_OFF_T offset)
{
	struct file *fil;
	struct intnl_xtvec xtvector;
	struct ioctx *ioctx;
	int	err;
	ssize_t	cc;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(-1, -EBADF);

	err =
	    _sysio_ipiov(IIOXOP_WRITE(fil->f_ino),
			 fil,
			 iov, count, NULL,
			 offset,
			 &xtvector, NULL,
			 &ioctx);
	if (!err && (cc = _sysio_ioctx_wait(ioctx)) < 0)
		err = (int )cc;

	SYSIO_INTERFACE_RETURN(err ? -1 : cc, err);
}

#ifdef _LARGEFILE64_SOURCE
#undef pwrite64v
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(pwritev)),
		     SYSIO_INTERFACE_NAME(pwrite64v))
#endif

ssize_t
SYSIO_INTERFACE_NAME(pwritev)(int fd, 
			      const struct iovec *iov, 
			      size_t count, 
			      off_t offset)
{

	return PREPEND(_, SYSIO_INTERFACE_NAME(pwritev))(fd, 
							 iov, 
							 count, 
							 offset);
}

static ioid_t
PREPEND(_, SYSIO_INTERFACE_NAME(ipwrite))(int fd, 
					  const void *buf, 
					  size_t count, 
					  _SYSIO_OFF_T offset)
{
	struct file *fil;
	struct intnl_xtvec *xtv;
	struct iovec *iov;
	struct ioctx *ioctx;
	int	err;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EBADF);

	xtv = malloc(sizeof(struct intnl_xtvec));
	iov = malloc(sizeof(struct iovec));
	if (!(xtv && iov)) {
		err = -errno;
		goto error;
	}
	xtv->xtv_off = offset;
	iov->iov_base = (void *)buf;
	xtv->xtv_len = iov->iov_len = count;
	err =
	    _sysio_ipiov(IIOXOP_WRITE(fil->f_ino),
			 fil,
			 iov, 1, free_iov,
			 offset,
			 xtv, free_xtv,
			 &ioctx);
error:
	if (err) {
		if (iov)
			free(iov);
		if (xtv)
			free(xtv);
		SYSIO_INTERFACE_RETURN(IOID_FAIL, err);
	}
	SYSIO_INTERFACE_RETURN(ioctx, 0);
}

#ifdef _LARGEFILE64_SOURCE
#undef ipwrite64
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(ipwrite)),
		     SYSIO_INTERFACE_NAME(ipwrite64))
#endif

ioid_t
SYSIO_INTERFACE_NAME(ipwrite)(int fd, 
			      const void *buf, 
			      size_t count, 
			      off_t offset)
{

	return PREPEND(_, SYSIO_INTERFACE_NAME(ipwrite))(fd, 
						 	 buf, 
						 	 count, 
							 offset);
}

ssize_t
PREPEND(_, SYSIO_INTERFACE_NAME(pwrite))(int fd, 
					 const void *buf, 
					 size_t count, 
					 _SYSIO_OFF_T offset)
{
	struct file *fil;
	struct intnl_xtvec xtvec;
	struct iovec iovec;
	struct ioctx *ioctx;
	int	err;
	ssize_t	cc;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(-1, -EBADF);

	xtvec.xtv_off = offset;
	iovec.iov_base = (void *)buf;
	xtvec.xtv_len = iovec.iov_len = count;
	err =
	    _sysio_ipiov(IIOXOP_WRITE(fil->f_ino),
			 fil,
			 &iovec, 1, NULL,
			 offset,
			 &xtvec, NULL,
			 &ioctx);
	if (!err && (cc = _sysio_ioctx_wait(ioctx)) < 0)
		err = (int )cc;

	SYSIO_INTERFACE_RETURN(err ? -1 : cc, err);
}

#ifdef _LARGEFILE64_SOURCE
#undef pwrite64
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(pwrite)),
		     SYSIO_INTERFACE_NAME(pwrite64))
#ifdef __GLIBC
#undef __pwrite64
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(pwrite)),
		     PREPEND(__, SYSIO_INTERFACE_NAME(pwrite64)))
#undef __libc_pwrite64
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(pwrite)),
		     PREPEND(__, SYSIO_INTERFACE_NAME(libc_pwrite64)))
#endif
#endif

ssize_t
SYSIO_INTERFACE_NAME(pwrite)(int fd, 
			     const void *buf, 
			     size_t count, 
			     off_t offset)
{

	return PREPEND(_, SYSIO_INTERFACE_NAME(pwrite))(fd, 
						        buf, 
						        count, 
						        offset);
}

#ifdef __GLIBC
#undef __libc_pwrite
sysio_sym_weak_alias(SYSIO_INTERFACE_NAME(pwrite), __libc_pwrite)
		     PREPEND(__, SYSIO_INTERFACE_NAME(libc_pwrite)))
#endif

static ioid_t
PREPEND(_, SYSIO_INTERFACE_NAME(iwritex))(int fd,
	 				  const struct iovec *iov, 
					  size_t iov_count, 
					  const struct intnl_xtvec *xtv, 
					  size_t xtv_count)
{
	struct file *fil;
	int	err;
	struct ioctx *ioctx;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!(fil && xtv_count))
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EBADF);

	err =
	    _sysio_iiox(IIOXOP_WRITE(fil->f_ino),
			fil,
			iov, iov_count, NULL,
			xtv, xtv_count, NULL,
			NULL,
			&ioctx);

	SYSIO_INTERFACE_RETURN(err ? IOID_FAIL : ioctx, err);
}

#ifdef _LARGEFILE64_SOURCE
#undef iwrite64x
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(iwritex)),
		     SYSIO_INTERFACE_NAME(iwrite64x))
#endif

#ifdef _LARGEFILE64_SOURCE
ioid_t
SYSIO_INTERFACE_NAME(iwritex)(int fd,
			      const struct iovec *iov, size_t iov_count,
			      const struct xtvec *xtv, size_t xtv_count)
{
	struct file *fil;
	struct intnl_xtvec *ixtv, *ixtvent;
	size_t	count;
	int	err;
	struct ioctx *ioctx;
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	fil = _sysio_fd_find(fd);
	if (!fil)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EBADF);

	/* Perform a check on the iov_count and xtv_count */
	if ((iov_count == 0) || (xtv_count == 0))
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -EINVAL);

	ixtv = ixtvent = malloc(xtv_count * sizeof(struct intnl_xtvec));
	if (!ixtv)
		SYSIO_INTERFACE_RETURN(IOID_FAIL, -ENOMEM);

	count = xtv_count;
	while (count--) {
		ixtvent->xtv_off = xtv->xtv_off;
		ixtvent->xtv_len = xtv->xtv_len;
		ixtvent++;
		xtv++;
	}

	err =
	    _sysio_iiox(IIOXOP_WRITE(fil->f_ino),
			fil,
			iov, iov_count, NULL,
			ixtv, xtv_count, free_xtv,
			NULL,
			&ioctx);
	if (err) {
		free(ixtv);
		SYSIO_INTERFACE_RETURN(IOID_FAIL, err);
	}
	SYSIO_INTERFACE_RETURN(ioctx, 0);
}
#else
#undef iwritex
sysio_sym_weak_alias(PREPEND(_, SYSIO_INTERFACE_NAME(iwritex)),
		     SYSIO_INTERFACE_NAME(iwritex))
#endif

#undef writex
ssize_t
SYSIO_INTERFACE_NAME(writex)(int fd,
			     const struct iovec *iov, size_t iov_count,
			     const struct xtvec *xtv, size_t xtv_count)
{
	ioid_t	ioid;

	if ((ioid = 
	     SYSIO_INTERFACE_NAME(iwritex)(fd, 
				 	   iov, 
					   iov_count, 
					   xtv, 
					   xtv_count)) == IOID_FAIL)
		return -1;
	return SYSIO_INTERFACE_NAME(iowait)(ioid);
}

#ifdef _LARGEFILE64_SOURCE
#undef write64x
ssize_t
SYSIO_INTERFACE_NAME(write64x)(int fd,
	 const struct iovec *iov, size_t iov_count,
	 const struct xtvec64 *xtv, size_t xtv_count)
{
	ioid_t	ioid;

	if ((ioid = SYSIO_INTERFACE_NAME(iwrite64x)(fd, 
		     				    iov, 
						    iov_count, 
						    xtv, 
						    xtv_count)) == IOID_FAIL)
		return -1;
	return SYSIO_INTERFACE_NAME(iowait)(ioid);
}
#endif

#ifdef notdef
int
write_list(int fd,
	   int mem_list_count,
	   char *mem_offsets[],
	   int mem_lengths[],
	   int file_list_count,
	   int64_t file_offsets[],
	   int32_t file_lengths[])
{
	SYSIO_INTERFACE_DISPLAY_BLOCK;

	SYSIO_INTERFACE_ENTER;
	SYSIO_INTERFACE_RETURN(-1, -ENOSYS);
}
#endif