/*
   *  fs/nfs/nfs4xdr.c
   *
   *  Client-side XDR for NFSv4.
   *
   *  Copyright (c) 2002 The Regents of the University of Michigan.
   *  All rights reserved.
   *
   *  Kendrick Smith <kmsmith@umich.edu>
   *  Andy Adamson   <andros@umich.edu>

   *

   *  Redistribution and use in source and binary forms, with or without
   *  modification, are permitted provided that the following conditions
   *  are met:
   *
   *  1. Redistributions of source code must retain the above copyright
   *     notice, this list of conditions and the following disclaimer.
   *  2. Redistributions in binary form must reproduce the above copyright
   *     notice, this list of conditions and the following disclaimer in the
   *     documentation and/or other materials provided with the distribution.
   *  3. Neither the name of the University nor the names of its
   *     contributors may be used to endorse or promote products derived
   *     from this software without specific prior written permission.
   *
   *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
   *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
   *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
   *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
   *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
   *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  #include <linux/param.h>
  #include <linux/time.h>
  #include <linux/mm.h>

  #include <linux/errno.h>
  #include <linux/string.h>
  #include <linux/in.h>
  #include <linux/pagemap.h>
  #include <linux/proc_fs.h>
  #include <linux/kdev_t.h>
  #include <linux/sunrpc/clnt.h>

  #include <linux/sunrpc/msg_prot.h>

  #include <linux/sunrpc/gss_api.h>

  #include <linux/nfs.h>
  #include <linux/nfs4.h>
  #include <linux/nfs_fs.h>
  #include <linux/nfs_idmap.h>

  #include "nfs4_fs.h"

  #include "internal.h"

  #include "pnfs.h"

  
  #define NFSDBG_FACILITY		NFSDBG_XDR
  
  /* Mapping from NFS error code to "errno" error code. */
  #define errno_NFSERR_IO		EIO

  static int nfs4_stat_to_errno(int);

  
  /* NFSv4 COMPOUND tags are only wanted for debugging purposes */
  #ifdef DEBUG
  #define NFS4_MAXTAGLEN		20
  #else
  #define NFS4_MAXTAGLEN		0
  #endif

  /* lock,open owner id:

   * we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT  >> 2)

   */

  #define open_owner_id_maxsz	(1 + 1 + 4)
  #define lock_owner_id_maxsz	(1 + 1 + 4)

  #define decode_lockowner_maxsz	(1 + XDR_QUADLEN(IDMAP_NAMESZ))

  #define compound_encode_hdr_maxsz	(3 + (NFS4_MAXTAGLEN >> 2))
  #define compound_decode_hdr_maxsz	(3 + (NFS4_MAXTAGLEN >> 2))
  #define op_encode_hdr_maxsz	(1)
  #define op_decode_hdr_maxsz	(2)

  #define encode_stateid_maxsz	(XDR_QUADLEN(NFS4_STATEID_SIZE))
  #define decode_stateid_maxsz	(XDR_QUADLEN(NFS4_STATEID_SIZE))
  #define encode_verifier_maxsz	(XDR_QUADLEN(NFS4_VERIFIER_SIZE))
  #define decode_verifier_maxsz	(XDR_QUADLEN(NFS4_VERIFIER_SIZE))

  #define encode_putfh_maxsz	(op_encode_hdr_maxsz + 1 + \
  				(NFS4_FHSIZE >> 2))
  #define decode_putfh_maxsz	(op_decode_hdr_maxsz)
  #define encode_putrootfh_maxsz	(op_encode_hdr_maxsz)
  #define decode_putrootfh_maxsz	(op_decode_hdr_maxsz)
  #define encode_getfh_maxsz      (op_encode_hdr_maxsz)
  #define decode_getfh_maxsz      (op_decode_hdr_maxsz + 1 + \
  				((3+NFS4_FHSIZE) >> 2))

  #define nfs4_fattr_bitmap_maxsz 4

  #define encode_getattr_maxsz    (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)

  #define nfs4_name_maxsz		(1 + ((3 + NFS4_MAXNAMLEN) >> 2))
  #define nfs4_path_maxsz		(1 + ((3 + NFS4_MAXPATHLEN) >> 2))

  #define nfs4_owner_maxsz	(1 + XDR_QUADLEN(IDMAP_NAMESZ))
  #define nfs4_group_maxsz	(1 + XDR_QUADLEN(IDMAP_NAMESZ))

  /* This is based on getfattr, which uses the most attributes: */
  #define nfs4_fattr_value_maxsz	(1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \

  				3 + 3 + 3 + nfs4_owner_maxsz + nfs4_group_maxsz))

  #define nfs4_fattr_maxsz	(nfs4_fattr_bitmap_maxsz + \
  				nfs4_fattr_value_maxsz)
  #define decode_getattr_maxsz    (op_decode_hdr_maxsz + nfs4_fattr_maxsz)

  #define encode_attrs_maxsz	(nfs4_fattr_bitmap_maxsz + \
  				 1 + 2 + 1 + \
  				nfs4_owner_maxsz + \
  				nfs4_group_maxsz + \
  				4 + 4)

  #define encode_savefh_maxsz     (op_encode_hdr_maxsz)
  #define decode_savefh_maxsz     (op_decode_hdr_maxsz)

  #define encode_restorefh_maxsz  (op_encode_hdr_maxsz)
  #define decode_restorefh_maxsz  (op_decode_hdr_maxsz)

  #define encode_fsinfo_maxsz	(encode_getattr_maxsz)

  /* The 5 accounts for the PNFS attributes, and assumes that at most three
   * layout types will be returned.
   */
  #define decode_fsinfo_maxsz	(op_decode_hdr_maxsz + \
  				 nfs4_fattr_bitmap_maxsz + 4 + 8 + 5)

  #define encode_renew_maxsz	(op_encode_hdr_maxsz + 3)
  #define decode_renew_maxsz	(op_decode_hdr_maxsz)
  #define encode_setclientid_maxsz \
  				(op_encode_hdr_maxsz + \

  				XDR_QUADLEN(NFS4_VERIFIER_SIZE) + \
  				XDR_QUADLEN(NFS4_SETCLIENTID_NAMELEN) + \
  				1 /* sc_prog */ + \
  				XDR_QUADLEN(RPCBIND_MAXNETIDLEN) + \
  				XDR_QUADLEN(RPCBIND_MAXUADDRLEN) + \
  				1) /* sc_cb_ident */

  #define decode_setclientid_maxsz \
  				(op_decode_hdr_maxsz + \
  				2 + \
  				1024) /* large value for CLID_INUSE */
  #define encode_setclientid_confirm_maxsz \
  				(op_encode_hdr_maxsz + \
  				3 + (NFS4_VERIFIER_SIZE >> 2))
  #define decode_setclientid_confirm_maxsz \
  				(op_decode_hdr_maxsz)

  #define encode_lookup_maxsz	(op_encode_hdr_maxsz + nfs4_name_maxsz)
  #define decode_lookup_maxsz	(op_decode_hdr_maxsz)

  #define encode_share_access_maxsz \
  				(2)

  #define encode_createmode_maxsz	(1 + encode_attrs_maxsz + encode_verifier_maxsz)

  #define encode_opentype_maxsz	(1 + encode_createmode_maxsz)
  #define encode_claim_null_maxsz	(1 + nfs4_name_maxsz)
  #define encode_open_maxsz	(op_encode_hdr_maxsz + \
  				2 + encode_share_access_maxsz + 2 + \
  				open_owner_id_maxsz + \
  				encode_opentype_maxsz + \
  				encode_claim_null_maxsz)
  #define decode_ace_maxsz	(3 + nfs4_owner_maxsz)

  #define decode_delegation_maxsz	(1 + decode_stateid_maxsz + 1 + \

  				decode_ace_maxsz)
  #define decode_change_info_maxsz	(5)
  #define decode_open_maxsz	(op_decode_hdr_maxsz + \

  				decode_stateid_maxsz + \

  				decode_change_info_maxsz + 1 + \
  				nfs4_fattr_bitmap_maxsz + \
  				decode_delegation_maxsz)

  #define encode_open_confirm_maxsz \
  				(op_encode_hdr_maxsz + \
  				 encode_stateid_maxsz + 1)
  #define decode_open_confirm_maxsz \
  				(op_decode_hdr_maxsz + \
  				 decode_stateid_maxsz)
  #define encode_open_downgrade_maxsz \
  				(op_encode_hdr_maxsz + \
  				 encode_stateid_maxsz + 1 + \
  				 encode_share_access_maxsz)
  #define decode_open_downgrade_maxsz \
  				(op_decode_hdr_maxsz + \
  				 decode_stateid_maxsz)
  #define encode_close_maxsz	(op_encode_hdr_maxsz + \
  				 1 + encode_stateid_maxsz)
  #define decode_close_maxsz	(op_decode_hdr_maxsz + \
  				 decode_stateid_maxsz)
  #define encode_setattr_maxsz	(op_encode_hdr_maxsz + \
  				 encode_stateid_maxsz + \
  				 encode_attrs_maxsz)
  #define decode_setattr_maxsz	(op_decode_hdr_maxsz + \
  				 nfs4_fattr_bitmap_maxsz)
  #define encode_read_maxsz	(op_encode_hdr_maxsz + \
  				 encode_stateid_maxsz + 3)
  #define decode_read_maxsz	(op_decode_hdr_maxsz + 2)
  #define encode_readdir_maxsz	(op_encode_hdr_maxsz + \
  				 2 + encode_verifier_maxsz + 5)
  #define decode_readdir_maxsz	(op_decode_hdr_maxsz + \
  				 decode_verifier_maxsz)
  #define encode_readlink_maxsz	(op_encode_hdr_maxsz)
  #define decode_readlink_maxsz	(op_decode_hdr_maxsz + 1)
  #define encode_write_maxsz	(op_encode_hdr_maxsz + \
  				 encode_stateid_maxsz + 4)
  #define decode_write_maxsz	(op_decode_hdr_maxsz + \
  				 2 + decode_verifier_maxsz)
  #define encode_commit_maxsz	(op_encode_hdr_maxsz + 3)
  #define decode_commit_maxsz	(op_decode_hdr_maxsz + \
  				 decode_verifier_maxsz)

  #define encode_remove_maxsz	(op_encode_hdr_maxsz + \
  				nfs4_name_maxsz)

  #define decode_remove_maxsz	(op_decode_hdr_maxsz + \
  				 decode_change_info_maxsz)

  #define encode_rename_maxsz	(op_encode_hdr_maxsz + \
  				2 * nfs4_name_maxsz)

  #define decode_rename_maxsz	(op_decode_hdr_maxsz + \
  				 decode_change_info_maxsz + \
  				 decode_change_info_maxsz)

  #define encode_link_maxsz	(op_encode_hdr_maxsz + \
  				nfs4_name_maxsz)

  #define decode_link_maxsz	(op_decode_hdr_maxsz + decode_change_info_maxsz)

  #define encode_lockowner_maxsz	(7)

  #define encode_lock_maxsz	(op_encode_hdr_maxsz + \
  				 7 + \

  				 1 + encode_stateid_maxsz + 1 + \
  				 encode_lockowner_maxsz)

  #define decode_lock_denied_maxsz \
  				(8 + decode_lockowner_maxsz)
  #define decode_lock_maxsz	(op_decode_hdr_maxsz + \
  				 decode_lock_denied_maxsz)

  #define encode_lockt_maxsz	(op_encode_hdr_maxsz + 5 + \
  				encode_lockowner_maxsz)

  #define decode_lockt_maxsz	(op_decode_hdr_maxsz + \
  				 decode_lock_denied_maxsz)
  #define encode_locku_maxsz	(op_encode_hdr_maxsz + 3 + \
  				 encode_stateid_maxsz + \
  				 4)
  #define decode_locku_maxsz	(op_decode_hdr_maxsz + \
  				 decode_stateid_maxsz)

  #define encode_release_lockowner_maxsz \
  				(op_encode_hdr_maxsz + \
  				 encode_lockowner_maxsz)
  #define decode_release_lockowner_maxsz \
  				(op_decode_hdr_maxsz)

  #define encode_access_maxsz	(op_encode_hdr_maxsz + 1)
  #define decode_access_maxsz	(op_decode_hdr_maxsz + 2)

  #define encode_symlink_maxsz	(op_encode_hdr_maxsz + \
  				1 + nfs4_name_maxsz + \

  				1 + \

  				nfs4_fattr_maxsz)

  #define decode_symlink_maxsz	(op_decode_hdr_maxsz + 8)
  #define encode_create_maxsz	(op_encode_hdr_maxsz + \

  				1 + 2 + nfs4_name_maxsz + \
  				encode_attrs_maxsz)

  #define decode_create_maxsz	(op_decode_hdr_maxsz + \
  				decode_change_info_maxsz + \
  				nfs4_fattr_bitmap_maxsz)

  #define encode_statfs_maxsz	(encode_getattr_maxsz)
  #define decode_statfs_maxsz	(decode_getattr_maxsz)

  #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
  #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)

  #define encode_getacl_maxsz	(encode_getattr_maxsz)
  #define decode_getacl_maxsz	(op_decode_hdr_maxsz + \
  				 nfs4_fattr_bitmap_maxsz + 1)
  #define encode_setacl_maxsz	(op_encode_hdr_maxsz + \
  				 encode_stateid_maxsz + 3)
  #define decode_setacl_maxsz	(decode_setattr_maxsz)

  #define encode_fs_locations_maxsz \
  				(encode_getattr_maxsz)
  #define decode_fs_locations_maxsz \
  				(0)

  #define encode_secinfo_maxsz	(op_encode_hdr_maxsz + nfs4_name_maxsz)

  #define decode_secinfo_maxsz	(op_decode_hdr_maxsz + 1 + ((NFS_MAX_SECFLAVORS * (16 + GSS_OID_MAX_LEN)) / 4))

  
  #if defined(CONFIG_NFS_V4_1)

  #define NFS4_MAX_MACHINE_NAME_LEN (64)

  #define encode_exchange_id_maxsz (op_encode_hdr_maxsz + \
  				encode_verifier_maxsz + \
  				1 /* co_ownerid.len */ + \
  				XDR_QUADLEN(NFS4_EXCHANGE_ID_LEN) + \
  				1 /* flags */ + \
  				1 /* spa_how */ + \
  				0 /* SP4_NONE (for now) */ + \
  				1 /* zero implemetation id array */)
  #define decode_exchange_id_maxsz (op_decode_hdr_maxsz + \
  				2 /* eir_clientid */ + \
  				1 /* eir_sequenceid */ + \
  				1 /* eir_flags */ + \
  				1 /* spr_how */ + \
  				0 /* SP4_NONE (for now) */ + \
  				2 /* eir_server_owner.so_minor_id */ + \
  				/* eir_server_owner.so_major_id<> */ \
  				XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
  				/* eir_server_scope<> */ \
  				XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 + \
  				1 /* eir_server_impl_id array length */ + \
  				0 /* ignored eir_server_impl_id contents */)

  #define encode_channel_attrs_maxsz  (6 + 1 /* ca_rdma_ird.len (0) */)
  #define decode_channel_attrs_maxsz  (6 + \
  				     1 /* ca_rdma_ird.len */ + \
  				     1 /* ca_rdma_ird */)
  #define encode_create_session_maxsz  (op_encode_hdr_maxsz + \
  				     2 /* csa_clientid */ + \
  				     1 /* csa_sequence */ + \
  				     1 /* csa_flags */ + \
  				     encode_channel_attrs_maxsz + \
  				     encode_channel_attrs_maxsz + \
  				     1 /* csa_cb_program */ + \
  				     1 /* csa_sec_parms.len (1) */ + \
  				     1 /* cb_secflavor (AUTH_SYS) */ + \
  				     1 /* stamp */ + \
  				     1 /* machinename.len */ + \
  				     XDR_QUADLEN(NFS4_MAX_MACHINE_NAME_LEN) + \
  				     1 /* uid */ + \
  				     1 /* gid */ + \
  				     1 /* gids.len (0) */)
  #define decode_create_session_maxsz  (op_decode_hdr_maxsz +	\
  				     XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
  				     1 /* csr_sequence */ + \
  				     1 /* csr_flags */ + \
  				     decode_channel_attrs_maxsz + \
  				     decode_channel_attrs_maxsz)

  #define encode_destroy_session_maxsz    (op_encode_hdr_maxsz + 4)
  #define decode_destroy_session_maxsz    (op_decode_hdr_maxsz)

  #define encode_sequence_maxsz	(op_encode_hdr_maxsz + \
  				XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 4)
  #define decode_sequence_maxsz	(op_decode_hdr_maxsz + \
  				XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5)

  #define encode_reclaim_complete_maxsz	(op_encode_hdr_maxsz + 4)
  #define decode_reclaim_complete_maxsz	(op_decode_hdr_maxsz + 4)

  #define encode_getdevicelist_maxsz (op_encode_hdr_maxsz + 4 + \
  				encode_verifier_maxsz)
  #define decode_getdevicelist_maxsz (op_decode_hdr_maxsz + \
  				2 /* nfs_cookie4 gdlr_cookie */ + \
  				decode_verifier_maxsz \
  				  /* verifier4 gdlr_verifier */ + \
  				1 /* gdlr_deviceid_list count */ + \
  				XDR_QUADLEN(NFS4_PNFS_GETDEVLIST_MAXNUM * \
  					    NFS4_DEVICEID4_SIZE) \
  				  /* gdlr_deviceid_list */ + \
  				1 /* bool gdlr_eof */)

  #define encode_getdeviceinfo_maxsz (op_encode_hdr_maxsz + 4 + \
  				XDR_QUADLEN(NFS4_DEVICEID4_SIZE))
  #define decode_getdeviceinfo_maxsz (op_decode_hdr_maxsz + \
  				1 /* layout type */ + \
  				1 /* opaque devaddr4 length */ + \
  				  /* devaddr4 payload is read into page */ \
  				1 /* notification bitmap length */ + \
  				1 /* notification bitmap */)
  #define encode_layoutget_maxsz	(op_encode_hdr_maxsz + 10 + \
  				encode_stateid_maxsz)
  #define decode_layoutget_maxsz	(op_decode_hdr_maxsz + 8 + \
  				decode_stateid_maxsz + \
  				XDR_QUADLEN(PNFS_LAYOUT_MAXSIZE))

  #define encode_layoutcommit_maxsz (op_encode_hdr_maxsz +          \
  				2 /* offset */ + \
  				2 /* length */ + \
  				1 /* reclaim */ + \
  				encode_stateid_maxsz + \
  				1 /* new offset (true) */ + \
  				2 /* last byte written */ + \
  				1 /* nt_timechanged (false) */ + \
  				1 /* layoutupdate4 layout type */ + \
  				1 /* NULL filelayout layoutupdate4 payload */)
  #define decode_layoutcommit_maxsz (op_decode_hdr_maxsz + 3)

  #define encode_layoutreturn_maxsz (8 + op_encode_hdr_maxsz + \
  				encode_stateid_maxsz + \
  				1 /* FIXME: opaque lrf_body always empty at the moment */)
  #define decode_layoutreturn_maxsz (op_decode_hdr_maxsz + \
  				1 + decode_stateid_maxsz)

  #define encode_secinfo_no_name_maxsz (op_encode_hdr_maxsz + 1)
  #define decode_secinfo_no_name_maxsz decode_secinfo_maxsz

  #define encode_test_stateid_maxsz	(op_encode_hdr_maxsz + 2 + \
  					 XDR_QUADLEN(NFS4_STATEID_SIZE))
  #define decode_test_stateid_maxsz	(op_decode_hdr_maxsz + 2 + 1)

  #define encode_free_stateid_maxsz	(op_encode_hdr_maxsz + 1 + \
  					 XDR_QUADLEN(NFS4_STATEID_SIZE))
  #define decode_free_stateid_maxsz	(op_decode_hdr_maxsz + 1)

  #else /* CONFIG_NFS_V4_1 */
  #define encode_sequence_maxsz	0
  #define decode_sequence_maxsz	0
  #endif /* CONFIG_NFS_V4_1 */

  #define NFS4_enc_compound_sz	(1024)  /* XXX: large enough? */
  #define NFS4_dec_compound_sz	(1024)  /* XXX: large enough? */
  #define NFS4_enc_read_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_read_maxsz)

  #define NFS4_dec_read_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_read_maxsz)

  #define NFS4_enc_readlink_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_readlink_maxsz)

  #define NFS4_dec_readlink_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_readlink_maxsz)

  #define NFS4_enc_readdir_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_readdir_maxsz)

  #define NFS4_dec_readdir_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_readdir_maxsz)

  #define NFS4_enc_write_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_write_maxsz + \

  				encode_getattr_maxsz)

  #define NFS4_dec_write_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_write_maxsz + \

  				decode_getattr_maxsz)

  #define NFS4_enc_commit_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_commit_maxsz + \

  				encode_getattr_maxsz)

  #define NFS4_dec_commit_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_commit_maxsz + \

  				decode_getattr_maxsz)

  #define NFS4_enc_open_sz        (compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \
  				encode_savefh_maxsz + \
  				encode_open_maxsz + \
  				encode_getfh_maxsz + \
  				encode_getattr_maxsz + \
  				encode_restorefh_maxsz + \
  				encode_getattr_maxsz)

  #define NFS4_dec_open_sz        (compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \
  				decode_savefh_maxsz + \
  				decode_open_maxsz + \
  				decode_getfh_maxsz + \
  				decode_getattr_maxsz + \
  				decode_restorefh_maxsz + \
  				decode_getattr_maxsz)

  #define NFS4_enc_open_confirm_sz \
  				(compound_encode_hdr_maxsz + \
  				 encode_putfh_maxsz + \
  				 encode_open_confirm_maxsz)
  #define NFS4_dec_open_confirm_sz \
  				(compound_decode_hdr_maxsz + \
  				 decode_putfh_maxsz + \
  				 decode_open_confirm_maxsz)

  #define NFS4_enc_open_noattr_sz	(compound_encode_hdr_maxsz + \

  					encode_sequence_maxsz + \

  					encode_putfh_maxsz + \

  					encode_open_maxsz + \
  					encode_getattr_maxsz)

  #define NFS4_dec_open_noattr_sz	(compound_decode_hdr_maxsz + \

  					decode_sequence_maxsz + \

  					decode_putfh_maxsz + \

  					decode_open_maxsz + \
  					decode_getattr_maxsz)

  #define NFS4_enc_open_downgrade_sz \
  				(compound_encode_hdr_maxsz + \

  				 encode_sequence_maxsz + \

  				 encode_putfh_maxsz + \
  				 encode_open_downgrade_maxsz + \
  				 encode_getattr_maxsz)

  #define NFS4_dec_open_downgrade_sz \
  				(compound_decode_hdr_maxsz + \

  				 decode_sequence_maxsz + \

  				 decode_putfh_maxsz + \
  				 decode_open_downgrade_maxsz + \
  				 decode_getattr_maxsz)
  #define NFS4_enc_close_sz	(compound_encode_hdr_maxsz + \

  				 encode_sequence_maxsz + \

  				 encode_putfh_maxsz + \
  				 encode_close_maxsz + \
  				 encode_getattr_maxsz)
  #define NFS4_dec_close_sz	(compound_decode_hdr_maxsz + \

  				 decode_sequence_maxsz + \

  				 decode_putfh_maxsz + \
  				 decode_close_maxsz + \
  				 decode_getattr_maxsz)
  #define NFS4_enc_setattr_sz	(compound_encode_hdr_maxsz + \

  				 encode_sequence_maxsz + \

  				 encode_putfh_maxsz + \
  				 encode_setattr_maxsz + \
  				 encode_getattr_maxsz)
  #define NFS4_dec_setattr_sz	(compound_decode_hdr_maxsz + \

  				 decode_sequence_maxsz + \

  				 decode_putfh_maxsz + \
  				 decode_setattr_maxsz + \
  				 decode_getattr_maxsz)

  #define NFS4_enc_fsinfo_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \
  				encode_fsinfo_maxsz)
  #define NFS4_dec_fsinfo_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \
  				decode_fsinfo_maxsz)
  #define NFS4_enc_renew_sz	(compound_encode_hdr_maxsz + \
  				encode_renew_maxsz)
  #define NFS4_dec_renew_sz	(compound_decode_hdr_maxsz + \
  				decode_renew_maxsz)
  #define NFS4_enc_setclientid_sz	(compound_encode_hdr_maxsz + \
  				encode_setclientid_maxsz)
  #define NFS4_dec_setclientid_sz	(compound_decode_hdr_maxsz + \
  				decode_setclientid_maxsz)
  #define NFS4_enc_setclientid_confirm_sz \
  				(compound_encode_hdr_maxsz + \
  				encode_setclientid_confirm_maxsz + \
  				encode_putrootfh_maxsz + \
  				encode_fsinfo_maxsz)
  #define NFS4_dec_setclientid_confirm_sz \
  				(compound_decode_hdr_maxsz + \
  				decode_setclientid_confirm_maxsz + \
  				decode_putrootfh_maxsz + \
  				decode_fsinfo_maxsz)
  #define NFS4_enc_lock_sz        (compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_lock_maxsz)

  #define NFS4_dec_lock_sz        (compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_lock_maxsz)

  #define NFS4_enc_lockt_sz       (compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_lockt_maxsz)
  #define NFS4_dec_lockt_sz       (compound_decode_hdr_maxsz + \

  				 decode_sequence_maxsz + \

  				 decode_putfh_maxsz + \
  				 decode_lockt_maxsz)

  #define NFS4_enc_locku_sz       (compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_locku_maxsz)

  #define NFS4_dec_locku_sz       (compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_locku_maxsz)

  #define NFS4_enc_release_lockowner_sz \
  				(compound_encode_hdr_maxsz + \
  				 encode_lockowner_maxsz)
  #define NFS4_dec_release_lockowner_sz \
  				(compound_decode_hdr_maxsz + \
  				 decode_lockowner_maxsz)

  #define NFS4_enc_access_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_access_maxsz + \
  				encode_getattr_maxsz)

  #define NFS4_dec_access_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_access_maxsz + \
  				decode_getattr_maxsz)

  #define NFS4_enc_getattr_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \
  				encode_getattr_maxsz)
  #define NFS4_dec_getattr_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \
  				decode_getattr_maxsz)
  #define NFS4_enc_lookup_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \
  				encode_lookup_maxsz + \
  				encode_getattr_maxsz + \
  				encode_getfh_maxsz)
  #define NFS4_dec_lookup_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_lookup_maxsz + \

  				decode_getattr_maxsz + \
  				decode_getfh_maxsz)
  #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putrootfh_maxsz + \
  				encode_getattr_maxsz + \
  				encode_getfh_maxsz)
  #define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putrootfh_maxsz + \
  				decode_getattr_maxsz + \
  				decode_getfh_maxsz)
  #define NFS4_enc_remove_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_remove_maxsz + \
  				encode_getattr_maxsz)

  #define NFS4_dec_remove_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_remove_maxsz + \

  				decode_getattr_maxsz)

  #define NFS4_enc_rename_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \
  				encode_savefh_maxsz + \
  				encode_putfh_maxsz + \

  				encode_rename_maxsz + \
  				encode_getattr_maxsz + \
  				encode_restorefh_maxsz + \
  				encode_getattr_maxsz)

  #define NFS4_dec_rename_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \
  				decode_savefh_maxsz + \
  				decode_putfh_maxsz + \

  				decode_rename_maxsz + \
  				decode_getattr_maxsz + \
  				decode_restorefh_maxsz + \
  				decode_getattr_maxsz)

  #define NFS4_enc_link_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \
  				encode_savefh_maxsz + \
  				encode_putfh_maxsz + \

  				encode_link_maxsz + \
  				decode_getattr_maxsz + \
  				encode_restorefh_maxsz + \
  				decode_getattr_maxsz)

  #define NFS4_dec_link_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \
  				decode_savefh_maxsz + \
  				decode_putfh_maxsz + \

  				decode_link_maxsz + \
  				decode_getattr_maxsz + \
  				decode_restorefh_maxsz + \
  				decode_getattr_maxsz)

  #define NFS4_enc_symlink_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \
  				encode_symlink_maxsz + \
  				encode_getattr_maxsz + \
  				encode_getfh_maxsz)
  #define NFS4_dec_symlink_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \
  				decode_symlink_maxsz + \
  				decode_getattr_maxsz + \
  				decode_getfh_maxsz)
  #define NFS4_enc_create_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_savefh_maxsz + \

  				encode_create_maxsz + \

  				encode_getfh_maxsz + \

  				encode_getattr_maxsz + \

  				encode_restorefh_maxsz + \
  				encode_getattr_maxsz)

  #define NFS4_dec_create_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_savefh_maxsz + \

  				decode_create_maxsz + \

  				decode_getfh_maxsz + \

  				decode_getattr_maxsz + \

  				decode_restorefh_maxsz + \
  				decode_getattr_maxsz)

  #define NFS4_enc_pathconf_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \
  				encode_getattr_maxsz)
  #define NFS4_dec_pathconf_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \
  				decode_getattr_maxsz)
  #define NFS4_enc_statfs_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_statfs_maxsz)

  #define NFS4_dec_statfs_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_statfs_maxsz)

  #define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_getattr_maxsz)
  #define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_getattr_maxsz)
  #define NFS4_enc_delegreturn_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_delegreturn_maxsz + \
  				encode_getattr_maxsz)

  #define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_delegreturn_maxsz + \
  				decode_getattr_maxsz)

  #define NFS4_enc_getacl_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_getacl_maxsz)

  #define NFS4_dec_getacl_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_getacl_maxsz)

  #define NFS4_enc_setacl_sz	(compound_encode_hdr_maxsz + \

  				encode_sequence_maxsz + \

  				encode_putfh_maxsz + \

  				encode_setacl_maxsz)

  #define NFS4_dec_setacl_sz	(compound_decode_hdr_maxsz + \

  				decode_sequence_maxsz + \

  				decode_putfh_maxsz + \

  				decode_setacl_maxsz)

  #define NFS4_enc_fs_locations_sz \
  				(compound_encode_hdr_maxsz + \

  				 encode_sequence_maxsz + \

  				 encode_putfh_maxsz + \

  				 encode_lookup_maxsz + \
  				 encode_fs_locations_maxsz)

  #define NFS4_dec_fs_locations_sz \
  				(compound_decode_hdr_maxsz + \

  				 decode_sequence_maxsz + \

  				 decode_putfh_maxsz + \

  				 decode_lookup_maxsz + \
  				 decode_fs_locations_maxsz)

  #define NFS4_enc_secinfo_sz 	(compound_encode_hdr_maxsz + \
  				encode_sequence_maxsz + \
  				encode_putfh_maxsz + \
  				encode_secinfo_maxsz)
  #define NFS4_dec_secinfo_sz	(compound_decode_hdr_maxsz + \
  				decode_sequence_maxsz + \
  				decode_putfh_maxsz + \
  				decode_secinfo_maxsz)

  #if defined(CONFIG_NFS_V4_1)
  #define NFS4_enc_exchange_id_sz \
  				(compound_encode_hdr_maxsz + \
  				 encode_exchange_id_maxsz)
  #define NFS4_dec_exchange_id_sz \
  				(compound_decode_hdr_maxsz + \
  				 decode_exchange_id_maxsz)

  #define NFS4_enc_create_session_sz \
  				(compound_encode_hdr_maxsz + \
  				 encode_create_session_maxsz)
  #define NFS4_dec_create_session_sz \
  				(compound_decode_hdr_maxsz + \
  				 decode_create_session_maxsz)

  #define NFS4_enc_destroy_session_sz	(compound_encode_hdr_maxsz + \
  					 encode_destroy_session_maxsz)
  #define NFS4_dec_destroy_session_sz	(compound_decode_hdr_maxsz + \
  					 decode_destroy_session_maxsz)

  #define NFS4_enc_sequence_sz \
  				(compound_decode_hdr_maxsz + \
  				 encode_sequence_maxsz)
  #define NFS4_dec_sequence_sz \
  				(compound_decode_hdr_maxsz + \
  				 decode_sequence_maxsz)

  #define NFS4_enc_get_lease_time_sz	(compound_encode_hdr_maxsz + \
  					 encode_sequence_maxsz + \
  					 encode_putrootfh_maxsz + \
  					 encode_fsinfo_maxsz)
  #define NFS4_dec_get_lease_time_sz	(compound_decode_hdr_maxsz + \
  					 decode_sequence_maxsz + \
  					 decode_putrootfh_maxsz + \
  					 decode_fsinfo_maxsz)

  #define NFS4_enc_reclaim_complete_sz	(compound_encode_hdr_maxsz + \
  					 encode_sequence_maxsz + \
  					 encode_reclaim_complete_maxsz)
  #define NFS4_dec_reclaim_complete_sz	(compound_decode_hdr_maxsz + \
  					 decode_sequence_maxsz + \
  					 decode_reclaim_complete_maxsz)

  #define NFS4_enc_getdevicelist_sz (compound_encode_hdr_maxsz + \
  				encode_sequence_maxsz + \
  				encode_putfh_maxsz + \
  				encode_getdevicelist_maxsz)
  #define NFS4_dec_getdevicelist_sz (compound_decode_hdr_maxsz + \
  				decode_sequence_maxsz + \
  				decode_putfh_maxsz + \
  				decode_getdevicelist_maxsz)

  #define NFS4_enc_getdeviceinfo_sz (compound_encode_hdr_maxsz +    \
  				encode_sequence_maxsz +\
  				encode_getdeviceinfo_maxsz)
  #define NFS4_dec_getdeviceinfo_sz (compound_decode_hdr_maxsz +    \
  				decode_sequence_maxsz + \
  				decode_getdeviceinfo_maxsz)
  #define NFS4_enc_layoutget_sz	(compound_encode_hdr_maxsz + \
  				encode_sequence_maxsz + \
  				encode_putfh_maxsz +        \
  				encode_layoutget_maxsz)
  #define NFS4_dec_layoutget_sz	(compound_decode_hdr_maxsz + \
  				decode_sequence_maxsz + \
  				decode_putfh_maxsz +        \
  				decode_layoutget_maxsz)

  #define NFS4_enc_layoutcommit_sz (compound_encode_hdr_maxsz + \
  				encode_sequence_maxsz +\
  				encode_putfh_maxsz + \
  				encode_layoutcommit_maxsz + \
  				encode_getattr_maxsz)
  #define NFS4_dec_layoutcommit_sz (compound_decode_hdr_maxsz + \
  				decode_sequence_maxsz + \
  				decode_putfh_maxsz + \
  				decode_layoutcommit_maxsz + \
  				decode_getattr_maxsz)

  #define NFS4_enc_layoutreturn_sz (compound_encode_hdr_maxsz + \
  				encode_sequence_maxsz + \
  				encode_putfh_maxsz + \
  				encode_layoutreturn_maxsz)
  #define NFS4_dec_layoutreturn_sz (compound_decode_hdr_maxsz + \
  				decode_sequence_maxsz + \
  				decode_putfh_maxsz + \
  				decode_layoutreturn_maxsz)

  #define NFS4_enc_secinfo_no_name_sz	(compound_encode_hdr_maxsz + \
  					encode_sequence_maxsz + \
  					encode_putrootfh_maxsz +\
  					encode_secinfo_no_name_maxsz)
  #define NFS4_dec_secinfo_no_name_sz	(compound_decode_hdr_maxsz + \
  					decode_sequence_maxsz + \
  					decode_putrootfh_maxsz + \
  					decode_secinfo_no_name_maxsz)

  #define NFS4_enc_test_stateid_sz	(compound_encode_hdr_maxsz + \
  					 encode_sequence_maxsz + \
  					 encode_test_stateid_maxsz)
  #define NFS4_dec_test_stateid_sz	(compound_decode_hdr_maxsz + \
  					 decode_sequence_maxsz + \
  					 decode_test_stateid_maxsz)

  #define NFS4_enc_free_stateid_sz	(compound_encode_hdr_maxsz + \
  					 encode_sequence_maxsz + \
  					 encode_free_stateid_maxsz)
  #define NFS4_dec_free_stateid_sz	(compound_decode_hdr_maxsz + \
  					 decode_sequence_maxsz + \
  					 decode_free_stateid_maxsz)

  
  const u32 nfs41_maxwrite_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
  				      compound_encode_hdr_maxsz +
  				      encode_sequence_maxsz +
  				      encode_putfh_maxsz +
  				      encode_getattr_maxsz) *
  				     XDR_UNIT);
  
  const u32 nfs41_maxread_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
  				     compound_decode_hdr_maxsz +
  				     decode_sequence_maxsz +
  				     decode_putfh_maxsz) *
  				    XDR_UNIT);

  #endif /* CONFIG_NFS_V4_1 */

  static const umode_t nfs_type2fmt[] = {
  	[NF4BAD] = 0,
  	[NF4REG] = S_IFREG,
  	[NF4DIR] = S_IFDIR,
  	[NF4BLK] = S_IFBLK,
  	[NF4CHR] = S_IFCHR,
  	[NF4LNK] = S_IFLNK,
  	[NF4SOCK] = S_IFSOCK,
  	[NF4FIFO] = S_IFIFO,
  	[NF4ATTRDIR] = 0,
  	[NF4NAMEDATTR] = 0,

  };
  
  struct compound_hdr {
  	int32_t		status;
  	uint32_t	nops;

  	__be32 *	nops_p;

  	uint32_t	taglen;
  	char *		tag;

  	uint32_t	replen;		/* expected reply words */

  	u32		minorversion;

  };

  static __be32 *reserve_space(struct xdr_stream *xdr, size_t nbytes)
  {
  	__be32 *p = xdr_reserve_space(xdr, nbytes);
  	BUG_ON(!p);
  	return p;
  }

  
  static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
  {

  	__be32 *p;

  
  	p = xdr_reserve_space(xdr, 4 + len);
  	BUG_ON(p == NULL);
  	xdr_encode_opaque(p, str, len);
  }

  static void encode_compound_hdr(struct xdr_stream *xdr,
  				struct rpc_rqst *req,
  				struct compound_hdr *hdr)

  {

  	__be32 *p;

  	struct rpc_auth *auth = req->rq_cred->cr_auth;

  
  	/* initialize running count of expected bytes in reply.
  	 * NOTE: the replied tag SHOULD be the same is the one sent,
  	 * but this is not required as a MUST for the server to do so. */
  	hdr->replen = RPC_REPHDRSIZE + auth->au_rslack + 3 + hdr->taglen;

  
  	dprintk("encode_compound: tag=%.*s
  ", (int)hdr->taglen, hdr->tag);
  	BUG_ON(hdr->taglen > NFS4_MAXTAGLEN);

  	p = reserve_space(xdr, 4 + hdr->taglen + 8);
  	p = xdr_encode_opaque(p, hdr->tag, hdr->taglen);

  	*p++ = cpu_to_be32(hdr->minorversion);

  	hdr->nops_p = p;

  	*p = cpu_to_be32(hdr->nops);

  }
  
  static void encode_nops(struct compound_hdr *hdr)
  {

  	BUG_ON(hdr->nops > NFS4_MAX_OPS);

  	*hdr->nops_p = htonl(hdr->nops);

  }
  
  static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)
  {

  	__be32 *p;

  
  	p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
  	BUG_ON(p == NULL);
  	xdr_encode_opaque_fixed(p, verf->data, NFS4_VERIFIER_SIZE);
  }

  static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)

  {
  	char owner_name[IDMAP_NAMESZ];
  	char owner_group[IDMAP_NAMESZ];
  	int owner_namelen = 0;
  	int owner_grouplen = 0;

  	__be32 *p;
  	__be32 *q;

  	int len;
  	uint32_t bmval0 = 0;
  	uint32_t bmval1 = 0;

  
  	/*
  	 * We reserve enough space to write the entire attribute buffer at once.
  	 * In the worst-case, this would be
  	 *   12(bitmap) + 4(attrlen) + 8(size) + 4(mode) + 4(atime) + 4(mtime)
  	 *          = 36 bytes, plus any contribution from variable-length fields

  	 *            such as owner/group.

  	 */
  	len = 16;
  
  	/* Sigh */
  	if (iap->ia_valid & ATTR_SIZE)
  		len += 8;
  	if (iap->ia_valid & ATTR_MODE)
  		len += 4;
  	if (iap->ia_valid & ATTR_UID) {

  		owner_namelen = nfs_map_uid_to_name(server, iap->ia_uid, owner_name, IDMAP_NAMESZ);

  		if (owner_namelen < 0) {

  			dprintk("nfs: couldn't resolve uid %d to string
  ",
  					iap->ia_uid);

  			/* XXX */
  			strcpy(owner_name, "nobody");
  			owner_namelen = sizeof("nobody") - 1;
  			/* goto out; */
  		}
  		len += 4 + (XDR_QUADLEN(owner_namelen) << 2);
  	}
  	if (iap->ia_valid & ATTR_GID) {

  		owner_grouplen = nfs_map_gid_to_group(server, iap->ia_gid, owner_group, IDMAP_NAMESZ);

  		if (owner_grouplen < 0) {

  			dprintk("nfs: couldn't resolve gid %d to string
  ",
  					iap->ia_gid);

  			strcpy(owner_group, "nobody");
  			owner_grouplen = sizeof("nobody") - 1;
  			/* goto out; */
  		}
  		len += 4 + (XDR_QUADLEN(owner_grouplen) << 2);
  	}
  	if (iap->ia_valid & ATTR_ATIME_SET)
  		len += 16;
  	else if (iap->ia_valid & ATTR_ATIME)
  		len += 4;
  	if (iap->ia_valid & ATTR_MTIME_SET)
  		len += 16;
  	else if (iap->ia_valid & ATTR_MTIME)
  		len += 4;

  	p = reserve_space(xdr, len);

  
  	/*
  	 * We write the bitmap length now, but leave the bitmap and the attribute
  	 * buffer length to be backfilled at the end of this routine.
  	 */

  	*p++ = cpu_to_be32(2);

  	q = p;
  	p += 3;
  
  	if (iap->ia_valid & ATTR_SIZE) {
  		bmval0 |= FATTR4_WORD0_SIZE;

  		p = xdr_encode_hyper(p, iap->ia_size);

  	}
  	if (iap->ia_valid & ATTR_MODE) {
  		bmval1 |= FATTR4_WORD1_MODE;

  		*p++ = cpu_to_be32(iap->ia_mode & S_IALLUGO);

  	}
  	if (iap->ia_valid & ATTR_UID) {
  		bmval1 |= FATTR4_WORD1_OWNER;

  		p = xdr_encode_opaque(p, owner_name, owner_namelen);

  	}
  	if (iap->ia_valid & ATTR_GID) {
  		bmval1 |= FATTR4_WORD1_OWNER_GROUP;

  		p = xdr_encode_opaque(p, owner_group, owner_grouplen);

  	}
  	if (iap->ia_valid & ATTR_ATIME_SET) {
  		bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;

  		*p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
  		*p++ = cpu_to_be32(0);

  		*p++ = cpu_to_be32(iap->ia_atime.tv_sec);
  		*p++ = cpu_to_be32(iap->ia_atime.tv_nsec);

  	}
  	else if (iap->ia_valid & ATTR_ATIME) {
  		bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;

  		*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);

  	}
  	if (iap->ia_valid & ATTR_MTIME_SET) {
  		bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;

  		*p++ = cpu_to_be32(NFS4_SET_TO_CLIENT_TIME);
  		*p++ = cpu_to_be32(0);
  		*p++ = cpu_to_be32(iap->ia_mtime.tv_sec);
  		*p++ = cpu_to_be32(iap->ia_mtime.tv_nsec);

  	}
  	else if (iap->ia_valid & ATTR_MTIME) {
  		bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;

  		*p++ = cpu_to_be32(NFS4_SET_TO_SERVER_TIME);

  	}

  	/*
  	 * Now we backfill the bitmap and the attribute buffer length.
  	 */
  	if (len != ((char *)p - (char *)q) + 4) {

  		printk(KERN_ERR "nfs: Attr length error, %u != %Zu
  ",

  				len, ((char *)p - (char *)q) + 4);
  		BUG();
  	}
  	len = (char *)p - (char *)q - 12;
  	*q++ = htonl(bmval0);
  	*q++ = htonl(bmval1);

  	*q = htonl(len);

  /* out: */

  }

  static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 8);

  	*p++ = cpu_to_be32(OP_ACCESS);

  	*p = cpu_to_be32(access);

  	hdr->nops++;

  	hdr->replen += decode_access_maxsz;

  }

  static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 8+NFS4_STATEID_SIZE);

  	*p++ = cpu_to_be32(OP_CLOSE);
  	*p++ = cpu_to_be32(arg->seqid->sequence->counter);

  	xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);

  	hdr->nops++;

  	hdr->replen += decode_close_maxsz;

  }

  static void encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *args, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 16);

  	*p++ = cpu_to_be32(OP_COMMIT);

  	p = xdr_encode_hyper(p, args->offset);

  	*p = cpu_to_be32(args->count);

  	hdr->nops++;

  	hdr->replen += decode_commit_maxsz;

  }

  static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 8);

  	*p++ = cpu_to_be32(OP_CREATE);

  	*p = cpu_to_be32(create->ftype);

  
  	switch (create->ftype) {
  	case NF4LNK:

  		p = reserve_space(xdr, 4);

  		*p = cpu_to_be32(create->u.symlink.len);

  		xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len);

  		break;
  
  	case NF4BLK: case NF4CHR:

  		p = reserve_space(xdr, 8);

  		*p++ = cpu_to_be32(create->u.device.specdata1);

  		*p = cpu_to_be32(create->u.device.specdata2);

  		break;
  
  	default:
  		break;
  	}

  	encode_string(xdr, create->name->len, create->name->name);

  	hdr->nops++;

  	hdr->replen += decode_create_maxsz;

  	encode_attrs(xdr, create->attrs, create->server);

  }

  static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 12);

  	*p++ = cpu_to_be32(OP_GETATTR);
  	*p++ = cpu_to_be32(1);

  	*p = cpu_to_be32(bitmap);

  	hdr->nops++;

  	hdr->replen += decode_getattr_maxsz;

  }

  static void encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 16);

  	*p++ = cpu_to_be32(OP_GETATTR);
  	*p++ = cpu_to_be32(2);
  	*p++ = cpu_to_be32(bm0);

  	*p = cpu_to_be32(bm1);

  	hdr->nops++;

  	hdr->replen += decode_getattr_maxsz;

  }

  static void
  encode_getattr_three(struct xdr_stream *xdr,
  		     uint32_t bm0, uint32_t bm1, uint32_t bm2,
  		     struct compound_hdr *hdr)
  {
  	__be32 *p;
  
  	p = reserve_space(xdr, 4);
  	*p = cpu_to_be32(OP_GETATTR);
  	if (bm2) {
  		p = reserve_space(xdr, 16);
  		*p++ = cpu_to_be32(3);
  		*p++ = cpu_to_be32(bm0);
  		*p++ = cpu_to_be32(bm1);
  		*p = cpu_to_be32(bm2);
  	} else if (bm1) {
  		p = reserve_space(xdr, 12);
  		*p++ = cpu_to_be32(2);
  		*p++ = cpu_to_be32(bm0);
  		*p = cpu_to_be32(bm1);
  	} else {
  		p = reserve_space(xdr, 8);
  		*p++ = cpu_to_be32(1);
  		*p = cpu_to_be32(bm0);
  	}
  	hdr->nops++;
  	hdr->replen += decode_getattr_maxsz;
  }

  static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)

  {

  	encode_getattr_two(xdr, bitmask[0] & nfs4_fattr_bitmap[0],
  			   bitmask[1] & nfs4_fattr_bitmap[1], hdr);

  }

  static void encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)

  {

  	encode_getattr_three(xdr,
  			     bitmask[0] & nfs4_fsinfo_bitmap[0],
  			     bitmask[1] & nfs4_fsinfo_bitmap[1],
  			     bitmask[2] & nfs4_fsinfo_bitmap[2],
  			     hdr);

  }

  static void encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)

  {

  	encode_getattr_two(xdr, bitmask[0] & nfs4_fs_locations_bitmap[0],
  			   bitmask[1] & nfs4_fs_locations_bitmap[1], hdr);

  }

  static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 4);

  	*p = cpu_to_be32(OP_GETFH);

  	hdr->nops++;

  	hdr->replen += decode_getfh_maxsz;

  }

  static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 8 + name->len);

  	*p++ = cpu_to_be32(OP_LINK);

  	xdr_encode_opaque(p, name->name, name->len);

  	hdr->nops++;

  	hdr->replen += decode_link_maxsz;

  }

  static inline int nfs4_lock_type(struct file_lock *fl, int block)
  {
  	if ((fl->fl_type & (F_RDLCK|F_WRLCK|F_UNLCK)) == F_RDLCK)
  		return block ? NFS4_READW_LT : NFS4_READ_LT;
  	return block ? NFS4_WRITEW_LT : NFS4_WRITE_LT;
  }
  
  static inline uint64_t nfs4_lock_length(struct file_lock *fl)
  {
  	if (fl->fl_end == OFFSET_MAX)
  		return ~(uint64_t)0;
  	return fl->fl_end - fl->fl_start + 1;
  }

  static void encode_lockowner(struct xdr_stream *xdr, const struct nfs_lowner *lowner)
  {
  	__be32 *p;

  	p = reserve_space(xdr, 32);

  	p = xdr_encode_hyper(p, lowner->clientid);

  	*p++ = cpu_to_be32(20);

  	p = xdr_encode_opaque_fixed(p, "lock id:", 8);

  	*p++ = cpu_to_be32(lowner->s_dev);

  	xdr_encode_hyper(p, lowner->id);
  }

  /*
   * opcode,type,reclaim,offset,length,new_lock_owner = 32
   * open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
   */

  static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 32);

  	*p++ = cpu_to_be32(OP_LOCK);
  	*p++ = cpu_to_be32(nfs4_lock_type(args->fl, args->block));
  	*p++ = cpu_to_be32(args->reclaim);

  	p = xdr_encode_hyper(p, args->fl->fl_start);
  	p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));

  	*p = cpu_to_be32(args->new_lock_owner);

  	if (args->new_lock_owner){

  		p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4);

  		*p++ = cpu_to_be32(args->open_seqid->sequence->counter);

  		p = xdr_encode_opaque_fixed(p, args->open_stateid->data, NFS4_STATEID_SIZE);

  		*p++ = cpu_to_be32(args->lock_seqid->sequence->counter);

  		encode_lockowner(xdr, &args->lock_owner);

  	}
  	else {

  		p = reserve_space(xdr, NFS4_STATEID_SIZE+4);

  		p = xdr_encode_opaque_fixed(p, args->lock_stateid->data, NFS4_STATEID_SIZE);

  		*p = cpu_to_be32(args->lock_seqid->sequence->counter);

  	}

  	hdr->nops++;

  	hdr->replen += decode_lock_maxsz;

  }

  static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 24);

  	*p++ = cpu_to_be32(OP_LOCKT);
  	*p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0));

  	p = xdr_encode_hyper(p, args->fl->fl_start);
  	p = xdr_encode_hyper(p, nfs4_lock_length(args->fl));

  	encode_lockowner(xdr, &args->lock_owner);

  	hdr->nops++;

  	hdr->replen += decode_lockt_maxsz;

  }

  static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 12+NFS4_STATEID_SIZE+16);

  	*p++ = cpu_to_be32(OP_LOCKU);
  	*p++ = cpu_to_be32(nfs4_lock_type(args->fl, 0));
  	*p++ = cpu_to_be32(args->seqid->sequence->counter);

  	p = xdr_encode_opaque_fixed(p, args->stateid->data, NFS4_STATEID_SIZE);

  	p = xdr_encode_hyper(p, args->fl->fl_start);

  	xdr_encode_hyper(p, nfs4_lock_length(args->fl));

  	hdr->nops++;

  	hdr->replen += decode_locku_maxsz;

  }

  static void encode_release_lockowner(struct xdr_stream *xdr, const struct nfs_lowner *lowner, struct compound_hdr *hdr)
  {
  	__be32 *p;
  
  	p = reserve_space(xdr, 4);
  	*p = cpu_to_be32(OP_RELEASE_LOCKOWNER);
  	encode_lockowner(xdr, lowner);
  	hdr->nops++;
  	hdr->replen += decode_release_lockowner_maxsz;
  }

  static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)

  {
  	int len = name->len;

  	__be32 *p;

  	p = reserve_space(xdr, 8 + len);

  	*p++ = cpu_to_be32(OP_LOOKUP);

  	xdr_encode_opaque(p, name->name, len);

  	hdr->nops++;

  	hdr->replen += decode_lookup_maxsz;

  }

  static void encode_share_access(struct xdr_stream *xdr, fmode_t fmode)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 8);

  	switch (fmode & (FMODE_READ|FMODE_WRITE)) {

  	case FMODE_READ:

  		*p++ = cpu_to_be32(NFS4_SHARE_ACCESS_READ);

  		break;
  	case FMODE_WRITE:

  		*p++ = cpu_to_be32(NFS4_SHARE_ACCESS_WRITE);

  		break;
  	case FMODE_READ|FMODE_WRITE:

  		*p++ = cpu_to_be32(NFS4_SHARE_ACCESS_BOTH);

  		break;
  	default:

  		*p++ = cpu_to_be32(0);

  	}

  	*p = cpu_to_be32(0);		/* for linux, share_deny = 0 always */

  }
  
  static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
  {

  	__be32 *p;

   /*
   * opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
   * owner 4 = 32
   */

  	p = reserve_space(xdr, 8);

  	*p++ = cpu_to_be32(OP_OPEN);

  	*p = cpu_to_be32(arg->seqid->sequence->counter);

  	encode_share_access(xdr, arg->fmode);

  	p = reserve_space(xdr, 32);

  	p = xdr_encode_hyper(p, arg->clientid);

  	*p++ = cpu_to_be32(20);

  	p = xdr_encode_opaque_fixed(p, "open id:", 8);

  	*p++ = cpu_to_be32(arg->server->s_dev);

  	xdr_encode_hyper(p, arg->id);

  }
  
  static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
  {

  	__be32 *p;

  	struct nfs_client *clp;

  	p = reserve_space(xdr, 4);

  	switch(arg->open_flags & O_EXCL) {

  	case 0:

  		*p = cpu_to_be32(NFS4_CREATE_UNCHECKED);

  		encode_attrs(xdr, arg->u.attrs, arg->server);
  		break;
  	default:

  		clp = arg->server->nfs_client;

  		if (clp->cl_mvops->minor_version > 0) {

  			if (nfs4_has_persistent_session(clp)) {
  				*p = cpu_to_be32(NFS4_CREATE_GUARDED);
  				encode_attrs(xdr, arg->u.attrs, arg->server);
  			} else {
  				struct iattr dummy;
  
  				*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE4_1);
  				encode_nfs4_verifier(xdr, &arg->u.verifier);
  				dummy.ia_valid = 0;
  				encode_attrs(xdr, &dummy, arg->server);
  			}
  		} else {
  			*p = cpu_to_be32(NFS4_CREATE_EXCLUSIVE);
  			encode_nfs4_verifier(xdr, &arg->u.verifier);
  		}

  	}
  }
  
  static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg)
  {

  	__be32 *p;

  	p = reserve_space(xdr, 4);

  	switch (arg->open_flags & O_CREAT) {

  	case 0:

  		*p = cpu_to_be32(NFS4_OPEN_NOCREATE);

  		break;
  	default:
  		BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL);

  		*p = cpu_to_be32(NFS4_OPEN_CREATE);

  		encode_createmode(xdr, arg);

  	}
  }

  static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delegation_type)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 4);

  	switch (delegation_type) {

  	case 0:

  		*p = cpu_to_be32(NFS4_OPEN_DELEGATE_NONE);

  		break;
  	case FMODE_READ:

  		*p = cpu_to_be32(NFS4_OPEN_DELEGATE_READ);

  		break;
  	case FMODE_WRITE|FMODE_READ:

  		*p = cpu_to_be32(NFS4_OPEN_DELEGATE_WRITE);

  		break;
  	default:
  		BUG();

  	}
  }
  
  static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name)
  {

  	__be32 *p;

  	p = reserve_space(xdr, 4);

  	*p = cpu_to_be32(NFS4_OPEN_CLAIM_NULL);

  	encode_string(xdr, name->len, name->name);
  }

  static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 4);

  	*p = cpu_to_be32(NFS4_OPEN_CLAIM_PREVIOUS);

  	encode_delegation_type(xdr, type);
  }
  
  static inline void encode_claim_delegate_cur(struct xdr_stream *xdr, const struct qstr *name, const nfs4_stateid *stateid)
  {

  	__be32 *p;

  	p = reserve_space(xdr, 4+NFS4_STATEID_SIZE);

  	*p++ = cpu_to_be32(NFS4_OPEN_CLAIM_DELEGATE_CUR);

  	xdr_encode_opaque_fixed(p, stateid->data, NFS4_STATEID_SIZE);

  	encode_string(xdr, name->len, name->name);
  }

  static void encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg, struct compound_hdr *hdr)

  {
  	encode_openhdr(xdr, arg);
  	encode_opentype(xdr, arg);
  	switch (arg->claim) {

  	case NFS4_OPEN_CLAIM_NULL:
  		encode_claim_null(xdr, arg->name);
  		break;
  	case NFS4_OPEN_CLAIM_PREVIOUS:
  		encode_claim_previous(xdr, arg->u.delegation_type);
  		break;
  	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
  		encode_claim_delegate_cur(xdr, arg->name, &arg->u.delegation);
  		break;
  	default:
  		BUG();

  	}

  	hdr->nops++;

  	hdr->replen += decode_open_maxsz;

  }

  static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg, struct compound_hdr *hdr)

  {

  	__be32 *p;

  	p = reserve_space(xdr, 4+NFS4_STATEID_SIZE+4);

  	*p++ = cpu_to_be32(OP_OPEN_CONFIRM);

  	p = xdr_encode_opaque_fixed(p, arg->stateid->data, NFS4_STATEID_SIZE);

  	*p = cpu_to_be32(arg->seqid->sequence->counter);

  	hdr->nops++;

  	hdr->replen += decode_open_confirm_maxsz;

  }

  static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)