SUNRPC: Convert the xdr helpers and rpc_pipefs to EXPORT_SYMBOL_GPL

	wake_up(&rpci->waitq);

	return res;

}

EXPORT_SYMBOL(rpc_queue_upcall);

EXPORT_SYMBOL_GPL(rpc_queue_upcall);

static inline void

rpc_inode_setowner(struct inode *inode, void *private)

			-ENOMEM);

	goto out;

}

EXPORT_SYMBOL(rpc_mkpipe);

EXPORT_SYMBOL_GPL(rpc_mkpipe);

/**

 * rpc_unlink - remove a pipe

	dput(parent);

	return error;

}

EXPORT_SYMBOL(rpc_unlink);

EXPORT_SYMBOL_GPL(rpc_unlink);

/*

 * populate the filesystem

	memcpy(p, obj->data, obj->len);

	return p + XDR_QUADLEN(obj->len);

}

EXPORT_SYMBOL(xdr_encode_netobj);

EXPORT_SYMBOL_GPL(xdr_encode_netobj);

__be32 *

xdr_decode_netobj(__be32 *p, struct xdr_netobj *obj)

	obj->data = (u8 *) p;

	return p + XDR_QUADLEN(len);

}

EXPORT_SYMBOL(xdr_decode_netobj);

EXPORT_SYMBOL_GPL(xdr_decode_netobj);

/**

 * xdr_encode_opaque_fixed - Encode fixed length opaque data

	}

	return p;

}

EXPORT_SYMBOL(xdr_encode_opaque_fixed);

EXPORT_SYMBOL_GPL(xdr_encode_opaque_fixed);

/**

 * xdr_encode_opaque - Encode variable length opaque data

	*p++ = htonl(nbytes);

	return xdr_encode_opaque_fixed(p, ptr, nbytes);

}

EXPORT_SYMBOL(xdr_encode_opaque);

EXPORT_SYMBOL_GPL(xdr_encode_opaque);

__be32 *

xdr_encode_string(__be32 *p, const char *string)

{

	return xdr_encode_array(p, string, strlen(string));

}

EXPORT_SYMBOL(xdr_encode_string);

EXPORT_SYMBOL_GPL(xdr_encode_string);

__be32 *

xdr_decode_string_inplace(__be32 *p, char **sp,

	*sp = (char *) p;

	return p + XDR_QUADLEN(len);

}

EXPORT_SYMBOL(xdr_decode_string_inplace);

EXPORT_SYMBOL_GPL(xdr_decode_string_inplace);

void

xdr_encode_pages(struct xdr_buf *xdr, struct page **pages, unsigned int base,

	xdr->buflen += len;

	xdr->len += len;

}

EXPORT_SYMBOL(xdr_encode_pages);

EXPORT_SYMBOL_GPL(xdr_encode_pages);

void

xdr_inline_pages(struct xdr_buf *xdr, unsigned int offset,

	xdr->buflen += len;

}

EXPORT_SYMBOL(xdr_inline_pages);

EXPORT_SYMBOL_GPL(xdr_inline_pages);

/*

 * Helper routines for doing 'memmove' like operations on a struct xdr_buf

{

	xdr_shrink_bufhead(buf, len);

}

EXPORT_SYMBOL(xdr_shift_buf);

EXPORT_SYMBOL_GPL(xdr_shift_buf);

/**

 * xdr_init_encode - Initialize a struct xdr_stream for sending data.

		iov->iov_len += len;

	}

}

EXPORT_SYMBOL(xdr_init_encode);

EXPORT_SYMBOL_GPL(xdr_init_encode);

/**

 * xdr_reserve_space - Reserve buffer space for sending

	xdr->buf->len += nbytes;

	return p;

}

EXPORT_SYMBOL(xdr_reserve_space);

EXPORT_SYMBOL_GPL(xdr_reserve_space);

/**

 * xdr_write_pages - Insert a list of pages into an XDR buffer for sending

	buf->buflen += len;

	buf->len += len;

}

EXPORT_SYMBOL(xdr_write_pages);

EXPORT_SYMBOL_GPL(xdr_write_pages);

/**

 * xdr_init_decode - Initialize an xdr_stream for decoding data.

	xdr->p = p;

	xdr->end = (__be32 *)((char *)iov->iov_base + len);

}

EXPORT_SYMBOL(xdr_init_decode);

EXPORT_SYMBOL_GPL(xdr_init_decode);

/**

 * xdr_inline_decode - Retrieve non-page XDR data to decode

	xdr->p = q;

	return p;

}

EXPORT_SYMBOL(xdr_inline_decode);

EXPORT_SYMBOL_GPL(xdr_inline_decode);

/**

 * xdr_read_pages - Ensure page-based XDR data to decode is aligned at current pointer position

	xdr->p = (__be32 *)((char *)iov->iov_base + padding);

	xdr->end = (__be32 *)((char *)iov->iov_base + end);

}

EXPORT_SYMBOL(xdr_read_pages);

EXPORT_SYMBOL_GPL(xdr_read_pages);

/**

 * xdr_enter_page - decode data from the XDR page

	xdr->p = (__be32 *)(kaddr + xdr->buf->page_base);

	xdr->end = (__be32 *)((char *)xdr->p + len);

}

EXPORT_SYMBOL(xdr_enter_page);

EXPORT_SYMBOL_GPL(xdr_enter_page);

static struct kvec empty_iov = {.iov_base = NULL, .iov_len = 0};

	buf->page_len = 0;

	buf->buflen = buf->len = iov->iov_len;

}

EXPORT_SYMBOL(xdr_buf_from_iov);

EXPORT_SYMBOL_GPL(xdr_buf_from_iov);

/* Sets subbuf to the portion of buf of length len beginning base bytes

 * from the start of buf. Returns -1 if base of length are out of bounds. */

		return -1;

	return 0;

}

EXPORT_SYMBOL(xdr_buf_subsegment);

EXPORT_SYMBOL_GPL(xdr_buf_subsegment);

static void __read_bytes_from_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)

{

	__read_bytes_from_xdr_buf(&subbuf, obj, len);

	return 0;

}

EXPORT_SYMBOL(read_bytes_from_xdr_buf);

EXPORT_SYMBOL_GPL(read_bytes_from_xdr_buf);

static void __write_bytes_to_xdr_buf(struct xdr_buf *subbuf, void *obj, unsigned int len)

{

	*obj = ntohl(raw);

	return 0;

}

EXPORT_SYMBOL(xdr_decode_word);

EXPORT_SYMBOL_GPL(xdr_decode_word);

int

xdr_encode_word(struct xdr_buf *buf, unsigned int base, u32 obj)

	return write_bytes_to_xdr_buf(buf, base, &raw, sizeof(obj));

}

EXPORT_SYMBOL(xdr_encode_word);

EXPORT_SYMBOL_GPL(xdr_encode_word);

/* If the netobj starting offset bytes from the start of xdr_buf is contained

 * entirely in the head or the tail, set object to point to it; otherwise

	__read_bytes_from_xdr_buf(&subbuf, obj->data, obj->len);

	return 0;

}

EXPORT_SYMBOL(xdr_buf_read_netobj);

EXPORT_SYMBOL_GPL(xdr_buf_read_netobj);

/* Returns 0 on success, or else a negative error code. */

static int

	return xdr_xcode_array2(buf, base, desc, 0);

}

EXPORT_SYMBOL(xdr_decode_array2);

EXPORT_SYMBOL_GPL(xdr_decode_array2);

int

xdr_encode_array2(struct xdr_buf *buf, unsigned int base,

	return xdr_xcode_array2(buf, base, desc, 1);

}

EXPORT_SYMBOL(xdr_encode_array2);

EXPORT_SYMBOL_GPL(xdr_encode_array2);

int

xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,

out:

	return ret;

}

EXPORT_SYMBOL(xdr_process_buf);

EXPORT_SYMBOL_GPL(xdr_process_buf);