-/*****************************************************************************\
+/*
* Copyright (c) 2008-2010 Sun Microsystems, Inc.
* Written by Ricardo Correia <Ricardo.M.Correia@Sun.COM>
*
* This file is part of the SPL, Solaris Porting Layer.
- * For details, see <http://github.com/behlendorf/spl/>.
+ * For details, see <http://zfsonlinux.org/>.
*
* The SPL is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
*
* You should have received a copy of the GNU General Public License along
* with the SPL. If not, see <http://www.gnu.org/licenses/>.
- *****************************************************************************
+ *
* Solaris Porting Layer (SPL) XDR Implementation.
-\*****************************************************************************/
+ */
#include <linux/string.h>
-
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/types.h>
-
#include <rpc/types.h>
#include <rpc/xdr.h>
xdrs->x_ops = &xdrmem_decode_ops;
break;
default:
- CWARN("Invalid op value: %d\n", op);
xdrs->x_ops = NULL; /* Let the caller know we failed */
return;
}
xdrs->x_addr_end = addr + size;
if (xdrs->x_addr_end < xdrs->x_addr) {
- CWARN("Overflow while creating xdrmem: %p, %u\n", addr, size);
xdrs->x_ops = NULL;
}
}
static bool_t
xdrmem_control(XDR *xdrs, int req, void *info)
{
- struct xdr_bytesrec *rec = (struct xdr_bytesrec *) info;
+ struct xdr_bytesrec *rec = (struct xdr_bytesrec *)info;
- if (req != XDR_GET_BYTES_AVAIL) {
- CWARN("Called with unknown request: %d\n", req);
- return FALSE;
- }
+ if (req != XDR_GET_BYTES_AVAIL)
+ return (FALSE);
rec->xc_is_last_record = TRUE; /* always TRUE in xdrmem streams */
rec->xc_num_avail = xdrs->x_addr_end - xdrs->x_addr;
- return TRUE;
+ return (TRUE);
}
static bool_t
uint_t pad;
if (size < cnt)
- return FALSE; /* Integer overflow */
+ return (FALSE); /* Integer overflow */
if (xdrs->x_addr > xdrs->x_addr_end)
- return FALSE;
+ return (FALSE);
if (xdrs->x_addr_end - xdrs->x_addr < size)
- return FALSE;
+ return (FALSE);
memcpy(xdrs->x_addr, cp, cnt);
xdrs->x_addr += pad;
}
- return TRUE;
+ return (TRUE);
}
static bool_t
uint_t pad;
if (size < cnt)
- return FALSE; /* Integer overflow */
+ return (FALSE); /* Integer overflow */
if (xdrs->x_addr > xdrs->x_addr_end)
- return FALSE;
+ return (FALSE);
if (xdrs->x_addr_end - xdrs->x_addr < size)
- return FALSE;
+ return (FALSE);
memcpy(cp, xdrs->x_addr, cnt);
xdrs->x_addr += cnt;
if (pad > 0) {
/* An inverted memchr() would be useful here... */
if (memcmp(&zero, xdrs->x_addr, pad) != 0)
- return FALSE;
+ return (FALSE);
xdrs->x_addr += pad;
}
- return TRUE;
+ return (TRUE);
}
static bool_t
xdrmem_enc_uint32(XDR *xdrs, uint32_t val)
{
- if (xdrs->x_addr + sizeof(uint32_t) > xdrs->x_addr_end)
- return FALSE;
+ if (xdrs->x_addr + sizeof (uint32_t) > xdrs->x_addr_end)
+ return (FALSE);
- *((uint32_t *) xdrs->x_addr) = cpu_to_be32(val);
+ *((uint32_t *)xdrs->x_addr) = cpu_to_be32(val);
- xdrs->x_addr += sizeof(uint32_t);
+ xdrs->x_addr += sizeof (uint32_t);
- return TRUE;
+ return (TRUE);
}
static bool_t
xdrmem_dec_uint32(XDR *xdrs, uint32_t *val)
{
- if (xdrs->x_addr + sizeof(uint32_t) > xdrs->x_addr_end)
- return FALSE;
+ if (xdrs->x_addr + sizeof (uint32_t) > xdrs->x_addr_end)
+ return (FALSE);
- *val = be32_to_cpu(*((uint32_t *) xdrs->x_addr));
+ *val = be32_to_cpu(*((uint32_t *)xdrs->x_addr));
- xdrs->x_addr += sizeof(uint32_t);
+ xdrs->x_addr += sizeof (uint32_t);
- return TRUE;
+ return (TRUE);
}
static bool_t
{
uint32_t val;
- BUILD_BUG_ON(sizeof(char) != 1);
+ BUILD_BUG_ON(sizeof (char) != 1);
val = *((unsigned char *) cp);
- return xdrmem_enc_uint32(xdrs, val);
+ return (xdrmem_enc_uint32(xdrs, val));
}
static bool_t
{
uint32_t val;
- BUILD_BUG_ON(sizeof(char) != 1);
+ BUILD_BUG_ON(sizeof (char) != 1);
if (!xdrmem_dec_uint32(xdrs, &val))
- return FALSE;
+ return (FALSE);
/*
* If any of the 3 other bytes are non-zero then val will be greater
* not have a char encoded in it.
*/
if (val > 0xff)
- return FALSE;
+ return (FALSE);
*((unsigned char *) cp) = val;
- return TRUE;
+ return (TRUE);
}
static bool_t
xdrmem_enc_ushort(XDR *xdrs, unsigned short *usp)
{
- BUILD_BUG_ON(sizeof(unsigned short) != 2);
+ BUILD_BUG_ON(sizeof (unsigned short) != 2);
- return xdrmem_enc_uint32(xdrs, *usp);
+ return (xdrmem_enc_uint32(xdrs, *usp));
}
static bool_t
{
uint32_t val;
- BUILD_BUG_ON(sizeof(unsigned short) != 2);
+ BUILD_BUG_ON(sizeof (unsigned short) != 2);
if (!xdrmem_dec_uint32(xdrs, &val))
- return FALSE;
+ return (FALSE);
/*
* Short ints are not in the RFC, but we assume similar logic as in
* xdrmem_dec_char().
*/
if (val > 0xffff)
- return FALSE;
+ return (FALSE);
*usp = val;
- return TRUE;
+ return (TRUE);
}
static bool_t
xdrmem_enc_uint(XDR *xdrs, unsigned *up)
{
- BUILD_BUG_ON(sizeof(unsigned) != 4);
+ BUILD_BUG_ON(sizeof (unsigned) != 4);
- return xdrmem_enc_uint32(xdrs, *up);
+ return (xdrmem_enc_uint32(xdrs, *up));
}
static bool_t
xdrmem_dec_uint(XDR *xdrs, unsigned *up)
{
- BUILD_BUG_ON(sizeof(unsigned) != 4);
+ BUILD_BUG_ON(sizeof (unsigned) != 4);
- return xdrmem_dec_uint32(xdrs, (uint32_t *) up);
+ return (xdrmem_dec_uint32(xdrs, (uint32_t *)up));
}
static bool_t
xdrmem_enc_ulonglong(XDR *xdrs, u_longlong_t *ullp)
{
- BUILD_BUG_ON(sizeof(u_longlong_t) != 8);
+ BUILD_BUG_ON(sizeof (u_longlong_t) != 8);
if (!xdrmem_enc_uint32(xdrs, *ullp >> 32))
- return FALSE;
+ return (FALSE);
- return xdrmem_enc_uint32(xdrs, *ullp & 0xffffffff);
+ return (xdrmem_enc_uint32(xdrs, *ullp & 0xffffffff));
}
static bool_t
{
uint32_t low, high;
- BUILD_BUG_ON(sizeof(u_longlong_t) != 8);
+ BUILD_BUG_ON(sizeof (u_longlong_t) != 8);
if (!xdrmem_dec_uint32(xdrs, &high))
- return FALSE;
+ return (FALSE);
if (!xdrmem_dec_uint32(xdrs, &low))
- return FALSE;
+ return (FALSE);
- *ullp = ((u_longlong_t) high << 32) | low;
+ *ullp = ((u_longlong_t)high << 32) | low;
- return TRUE;
+ return (TRUE);
}
static bool_t
caddr_t addr = *arrp;
if (*sizep > maxsize || *sizep > UINT_MAX / elsize)
- return FALSE;
+ return (FALSE);
if (!xdrmem_enc_uint(xdrs, sizep))
- return FALSE;
+ return (FALSE);
for (i = 0; i < *sizep; i++) {
if (!elproc(xdrs, addr))
- return FALSE;
+ return (FALSE);
addr += elsize;
}
- return TRUE;
+ return (TRUE);
}
static bool_t
caddr_t addr;
if (!xdrmem_dec_uint(xdrs, sizep))
- return FALSE;
+ return (FALSE);
size = *sizep;
if (size > maxsize || size > UINT_MAX / elsize)
- return FALSE;
+ return (FALSE);
/*
* The Solaris man page says: "If *arrp is NULL when decoding,
* xdr_array() allocates memory and *arrp points to it".
*/
if (*arrp == NULL) {
- BUILD_BUG_ON(sizeof(uint_t) > sizeof(size_t));
+ BUILD_BUG_ON(sizeof (uint_t) > sizeof (size_t));
*arrp = kmem_alloc(size * elsize, KM_NOSLEEP);
if (*arrp == NULL)
- return FALSE;
+ return (FALSE);
alloc = TRUE;
}
if (!elproc(xdrs, addr)) {
if (alloc)
kmem_free(*arrp, size * elsize);
- return FALSE;
+ return (FALSE);
}
addr += elsize;
}
- return TRUE;
+ return (TRUE);
}
static bool_t
uint_t len;
if (slen > maxsize)
- return FALSE;
+ return (FALSE);
len = slen;
if (!xdrmem_enc_uint(xdrs, &len))
- return FALSE;
+ return (FALSE);
- return xdrmem_enc_bytes(xdrs, *sp, len);
+ return (xdrmem_enc_bytes(xdrs, *sp, len));
}
static bool_t
bool_t alloc = FALSE;
if (!xdrmem_dec_uint(xdrs, &size))
- return FALSE;
+ return (FALSE);
if (size > maxsize || size > UINT_MAX - 1)
- return FALSE;
+ return (FALSE);
/*
* Solaris man page: "If *sp is NULL when decoding, xdr_string()
* allocates memory and *sp points to it".
*/
if (*sp == NULL) {
- BUILD_BUG_ON(sizeof(uint_t) > sizeof(size_t));
+ BUILD_BUG_ON(sizeof (uint_t) > sizeof (size_t));
*sp = kmem_alloc(size + 1, KM_NOSLEEP);
if (*sp == NULL)
- return FALSE;
+ return (FALSE);
alloc = TRUE;
}
(*sp)[size] = '\0';
- return TRUE;
+ return (TRUE);
fail:
if (alloc)
kmem_free(*sp, size + 1);
- return FALSE;
+ return (FALSE);
}
static struct xdr_ops xdrmem_encode_ops = {
- .xdr_control = xdrmem_control,
- .xdr_char = xdrmem_enc_char,
- .xdr_u_short = xdrmem_enc_ushort,
- .xdr_u_int = xdrmem_enc_uint,
- .xdr_u_longlong_t = xdrmem_enc_ulonglong,
- .xdr_opaque = xdrmem_enc_bytes,
- .xdr_string = xdr_enc_string,
- .xdr_array = xdr_enc_array
+ .xdr_control = xdrmem_control,
+ .xdr_char = xdrmem_enc_char,
+ .xdr_u_short = xdrmem_enc_ushort,
+ .xdr_u_int = xdrmem_enc_uint,
+ .xdr_u_longlong_t = xdrmem_enc_ulonglong,
+ .xdr_opaque = xdrmem_enc_bytes,
+ .xdr_string = xdr_enc_string,
+ .xdr_array = xdr_enc_array
};
static struct xdr_ops xdrmem_decode_ops = {
- .xdr_control = xdrmem_control,
- .xdr_char = xdrmem_dec_char,
- .xdr_u_short = xdrmem_dec_ushort,
- .xdr_u_int = xdrmem_dec_uint,
- .xdr_u_longlong_t = xdrmem_dec_ulonglong,
- .xdr_opaque = xdrmem_dec_bytes,
- .xdr_string = xdr_dec_string,
- .xdr_array = xdr_dec_array
+ .xdr_control = xdrmem_control,
+ .xdr_char = xdrmem_dec_char,
+ .xdr_u_short = xdrmem_dec_ushort,
+ .xdr_u_int = xdrmem_dec_uint,
+ .xdr_u_longlong_t = xdrmem_dec_ulonglong,
+ .xdr_opaque = xdrmem_dec_bytes,
+ .xdr_string = xdr_dec_string,
+ .xdr_array = xdr_dec_array
};
-