2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* 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>
|
2008-12-23 22:06:15 +01:00
|
|
|
*
|
2005-04-17 00:20:36 +02:00
|
|
|
* 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/slab.h>
|
|
|
|
#include <linux/utsname.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/nfs.h>
|
|
|
|
#include <linux/nfs4.h>
|
|
|
|
#include <linux/nfs_fs.h>
|
|
|
|
#include <linux/nfs_idmap.h>
|
2005-06-22 19:16:21 +02:00
|
|
|
#include "nfs4_fs.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#define NFSDBG_FACILITY NFSDBG_XDR
|
|
|
|
|
|
|
|
/* Mapping from NFS error code to "errno" error code. */
|
|
|
|
#define errno_NFSERR_IO EIO
|
|
|
|
|
2006-08-23 02:06:08 +02:00
|
|
|
static int nfs4_stat_to_errno(int);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* NFSv4 COMPOUND tags are only wanted for debugging purposes */
|
|
|
|
#ifdef DEBUG
|
|
|
|
#define NFS4_MAXTAGLEN 20
|
|
|
|
#else
|
|
|
|
#define NFS4_MAXTAGLEN 0
|
|
|
|
#endif
|
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
/* lock,open owner id:
|
2007-07-02 19:58:33 +02:00
|
|
|
* we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT >> 2)
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2007-07-02 19:58:33 +02:00
|
|
|
#define open_owner_id_maxsz (1 + 4)
|
|
|
|
#define lock_owner_id_maxsz (1 + 4)
|
2007-07-18 03:52:42 +02:00
|
|
|
#define decode_lockowner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
|
2005-04-17 00:20:36 +02:00
|
|
|
#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)
|
2007-07-18 03:52:42 +02:00
|
|
|
#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))
|
2005-04-17 00:20:36 +02:00
|
|
|
#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))
|
2005-06-22 19:16:22 +02:00
|
|
|
#define nfs4_fattr_bitmap_maxsz 3
|
|
|
|
#define encode_getattr_maxsz (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define nfs4_name_maxsz (1 + ((3 + NFS4_MAXNAMLEN) >> 2))
|
|
|
|
#define nfs4_path_maxsz (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
|
2007-07-09 00:38:23 +02:00
|
|
|
#define nfs4_owner_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
|
|
|
|
#define nfs4_group_maxsz (1 + XDR_QUADLEN(IDMAP_NAMESZ))
|
2005-06-22 19:16:22 +02:00
|
|
|
/* 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 + \
|
2007-07-09 00:38:23 +02:00
|
|
|
3 + 3 + 3 + nfs4_owner_maxsz + nfs4_group_maxsz))
|
2005-06-22 19:16:22 +02:00
|
|
|
#define nfs4_fattr_maxsz (nfs4_fattr_bitmap_maxsz + \
|
|
|
|
nfs4_fattr_value_maxsz)
|
|
|
|
#define decode_getattr_maxsz (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
|
2007-07-18 03:52:42 +02:00
|
|
|
#define encode_attrs_maxsz (nfs4_fattr_bitmap_maxsz + \
|
|
|
|
1 + 2 + 1 + \
|
|
|
|
nfs4_owner_maxsz + \
|
|
|
|
nfs4_group_maxsz + \
|
|
|
|
4 + 4)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define encode_savefh_maxsz (op_encode_hdr_maxsz)
|
|
|
|
#define decode_savefh_maxsz (op_decode_hdr_maxsz)
|
2005-10-28 04:12:40 +02:00
|
|
|
#define encode_restorefh_maxsz (op_encode_hdr_maxsz)
|
|
|
|
#define decode_restorefh_maxsz (op_decode_hdr_maxsz)
|
2008-03-13 14:26:30 +01:00
|
|
|
#define encode_fsinfo_maxsz (encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define decode_fsinfo_maxsz (op_decode_hdr_maxsz + 11)
|
|
|
|
#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 + \
|
2007-12-10 20:56:54 +01:00
|
|
|
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 */
|
2005-04-17 00:20:36 +02:00
|
|
|
#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)
|
2007-07-02 19:58:30 +02:00
|
|
|
#define encode_lookup_maxsz (op_encode_hdr_maxsz + nfs4_name_maxsz)
|
|
|
|
#define decode_lookup_maxsz (op_decode_hdr_maxsz)
|
2007-07-02 19:57:28 +02:00
|
|
|
#define encode_share_access_maxsz \
|
|
|
|
(2)
|
2007-07-18 03:52:42 +02:00
|
|
|
#define encode_createmode_maxsz (1 + encode_attrs_maxsz)
|
2007-07-02 19:57:28 +02:00
|
|
|
#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)
|
2007-07-18 03:52:42 +02:00
|
|
|
#define decode_delegation_maxsz (1 + decode_stateid_maxsz + 1 + \
|
2007-07-02 19:57:28 +02:00
|
|
|
decode_ace_maxsz)
|
|
|
|
#define decode_change_info_maxsz (5)
|
|
|
|
#define decode_open_maxsz (op_decode_hdr_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_stateid_maxsz + \
|
2007-07-02 19:57:28 +02:00
|
|
|
decode_change_info_maxsz + 1 + \
|
|
|
|
nfs4_fattr_bitmap_maxsz + \
|
|
|
|
decode_delegation_maxsz)
|
2007-07-18 03:52:42 +02:00
|
|
|
#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)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define encode_remove_maxsz (op_encode_hdr_maxsz + \
|
|
|
|
nfs4_name_maxsz)
|
|
|
|
#define encode_rename_maxsz (op_encode_hdr_maxsz + \
|
|
|
|
2 * nfs4_name_maxsz)
|
|
|
|
#define decode_rename_maxsz (op_decode_hdr_maxsz + 5 + 5)
|
|
|
|
#define encode_link_maxsz (op_encode_hdr_maxsz + \
|
|
|
|
nfs4_name_maxsz)
|
|
|
|
#define decode_link_maxsz (op_decode_hdr_maxsz + 5)
|
2007-07-18 03:52:42 +02:00
|
|
|
#define encode_lock_maxsz (op_encode_hdr_maxsz + \
|
|
|
|
7 + \
|
|
|
|
1 + encode_stateid_maxsz + 8)
|
|
|
|
#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 + 12)
|
|
|
|
#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_access_maxsz (op_encode_hdr_maxsz + 1)
|
|
|
|
#define decode_access_maxsz (op_decode_hdr_maxsz + 2)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define encode_symlink_maxsz (op_encode_hdr_maxsz + \
|
|
|
|
1 + nfs4_name_maxsz + \
|
2006-08-23 02:06:23 +02:00
|
|
|
1 + \
|
2005-06-22 19:16:22 +02:00
|
|
|
nfs4_fattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define decode_symlink_maxsz (op_decode_hdr_maxsz + 8)
|
|
|
|
#define encode_create_maxsz (op_encode_hdr_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
1 + 2 + nfs4_name_maxsz + \
|
|
|
|
encode_attrs_maxsz)
|
2007-07-02 19:57:28 +02:00
|
|
|
#define decode_create_maxsz (op_decode_hdr_maxsz + \
|
|
|
|
decode_change_info_maxsz + \
|
|
|
|
nfs4_fattr_bitmap_maxsz)
|
2007-07-18 03:52:42 +02:00
|
|
|
#define encode_statfs_maxsz (encode_getattr_maxsz)
|
|
|
|
#define decode_statfs_maxsz (decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
|
|
|
|
#define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
|
2007-07-18 03:52:42 +02:00
|
|
|
#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)
|
2007-07-02 19:58:30 +02:00
|
|
|
#define encode_fs_locations_maxsz \
|
|
|
|
(encode_getattr_maxsz)
|
|
|
|
#define decode_fs_locations_maxsz \
|
|
|
|
(0)
|
2005-04-17 00:20:36 +02:00
|
|
|
#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_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_read_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_read_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_read_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_readlink_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_readlink_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_readlink_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_readlink_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_readdir_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_readdir_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_readdir_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_readdir_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_write_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_write_maxsz + \
|
2005-10-28 04:12:44 +02:00
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_write_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_write_maxsz + \
|
2005-10-28 04:12:44 +02:00
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_commit_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_commit_maxsz + \
|
2005-10-28 04:12:44 +02:00
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_commit_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_commit_maxsz + \
|
2005-10-28 04:12:44 +02:00
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_open_sz (compound_encode_hdr_maxsz + \
|
2007-07-02 19:57:28 +02:00
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_savefh_maxsz + \
|
|
|
|
encode_open_maxsz + \
|
|
|
|
encode_getfh_maxsz + \
|
|
|
|
encode_getattr_maxsz + \
|
|
|
|
encode_restorefh_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_open_sz (compound_decode_hdr_maxsz + \
|
2007-07-02 19:57:28 +02:00
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_savefh_maxsz + \
|
|
|
|
decode_open_maxsz + \
|
|
|
|
decode_getfh_maxsz + \
|
|
|
|
decode_getattr_maxsz + \
|
|
|
|
decode_restorefh_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
2007-07-18 03:52:42 +02:00
|
|
|
#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)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-02 19:57:28 +02:00
|
|
|
encode_open_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-02 19:57:28 +02:00
|
|
|
decode_open_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_open_downgrade_sz \
|
|
|
|
(compound_encode_hdr_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_open_downgrade_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_open_downgrade_sz \
|
|
|
|
(compound_decode_hdr_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_open_downgrade_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
|
|
|
#define NFS4_enc_close_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_close_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
|
|
|
#define NFS4_dec_close_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_close_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
|
|
|
#define NFS4_enc_setattr_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_setattr_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
|
|
|
#define NFS4_dec_setattr_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_setattr_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_fsinfo_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_fsinfo_maxsz)
|
|
|
|
#define NFS4_dec_fsinfo_sz (compound_decode_hdr_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_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_lock_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_lock_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_lock_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_lockt_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_lockt_maxsz)
|
|
|
|
#define NFS4_dec_lockt_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_lockt_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_locku_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_locku_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_locku_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_locku_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_access_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-08-10 23:45:11 +02:00
|
|
|
encode_access_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_access_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-08-10 23:45:11 +02:00
|
|
|
decode_access_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_getattr_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
|
|
|
#define NFS4_dec_getattr_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
|
|
|
#define NFS4_enc_lookup_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_lookup_maxsz + \
|
|
|
|
encode_getattr_maxsz + \
|
|
|
|
encode_getfh_maxsz)
|
|
|
|
#define NFS4_dec_lookup_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-02 19:58:30 +02:00
|
|
|
decode_lookup_maxsz + \
|
2005-04-17 00:20:36 +02:00
|
|
|
decode_getattr_maxsz + \
|
|
|
|
decode_getfh_maxsz)
|
|
|
|
#define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putrootfh_maxsz + \
|
|
|
|
encode_getattr_maxsz + \
|
|
|
|
encode_getfh_maxsz)
|
|
|
|
#define NFS4_dec_lookup_root_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putrootfh_maxsz + \
|
|
|
|
decode_getattr_maxsz + \
|
|
|
|
decode_getfh_maxsz)
|
|
|
|
#define NFS4_enc_remove_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2005-10-28 04:12:44 +02:00
|
|
|
encode_remove_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_remove_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2005-10-28 04:12:44 +02:00
|
|
|
op_decode_hdr_maxsz + 5 + \
|
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_rename_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_savefh_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2005-10-28 04:12:43 +02:00
|
|
|
encode_rename_maxsz + \
|
|
|
|
encode_getattr_maxsz + \
|
|
|
|
encode_restorefh_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_rename_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_savefh_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2005-10-28 04:12:43 +02:00
|
|
|
decode_rename_maxsz + \
|
|
|
|
decode_getattr_maxsz + \
|
|
|
|
decode_restorefh_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_link_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_savefh_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2005-10-28 04:12:42 +02:00
|
|
|
encode_link_maxsz + \
|
|
|
|
decode_getattr_maxsz + \
|
|
|
|
encode_restorefh_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_link_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_savefh_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2005-10-28 04:12:42 +02:00
|
|
|
decode_link_maxsz + \
|
|
|
|
decode_getattr_maxsz + \
|
|
|
|
decode_restorefh_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_symlink_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_symlink_maxsz + \
|
|
|
|
encode_getattr_maxsz + \
|
|
|
|
encode_getfh_maxsz)
|
|
|
|
#define NFS4_dec_symlink_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_symlink_maxsz + \
|
|
|
|
decode_getattr_maxsz + \
|
|
|
|
decode_getfh_maxsz)
|
|
|
|
#define NFS4_enc_create_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2005-10-28 04:12:40 +02:00
|
|
|
encode_savefh_maxsz + \
|
2005-04-17 00:20:36 +02:00
|
|
|
encode_create_maxsz + \
|
2005-10-28 04:12:40 +02:00
|
|
|
encode_getfh_maxsz + \
|
2005-04-17 00:20:36 +02:00
|
|
|
encode_getattr_maxsz + \
|
2005-10-28 04:12:40 +02:00
|
|
|
encode_restorefh_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_create_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2005-10-28 04:12:40 +02:00
|
|
|
decode_savefh_maxsz + \
|
2005-04-17 00:20:36 +02:00
|
|
|
decode_create_maxsz + \
|
2005-10-28 04:12:40 +02:00
|
|
|
decode_getfh_maxsz + \
|
2005-04-17 00:20:36 +02:00
|
|
|
decode_getattr_maxsz + \
|
2005-10-28 04:12:40 +02:00
|
|
|
decode_restorefh_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_pathconf_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
|
|
|
#define NFS4_dec_pathconf_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
|
|
|
#define NFS4_enc_statfs_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_statfs_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_statfs_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_statfs_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_enc_server_caps_sz (compound_encode_hdr_maxsz + \
|
2007-02-02 23:47:17 +01:00
|
|
|
encode_putfh_maxsz + \
|
2005-04-17 00:20:36 +02:00
|
|
|
encode_getattr_maxsz)
|
|
|
|
#define NFS4_dec_server_caps_sz (compound_decode_hdr_maxsz + \
|
2007-02-02 23:47:17 +01:00
|
|
|
decode_putfh_maxsz + \
|
2005-04-17 00:20:36 +02:00
|
|
|
decode_getattr_maxsz)
|
|
|
|
#define NFS4_enc_delegreturn_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2006-01-03 09:55:38 +01:00
|
|
|
encode_delegreturn_maxsz + \
|
|
|
|
encode_getattr_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
#define NFS4_dec_delegreturn_sz (compound_decode_hdr_maxsz + \
|
2006-01-03 09:55:38 +01:00
|
|
|
decode_delegreturn_maxsz + \
|
|
|
|
decode_getattr_maxsz)
|
2005-06-22 19:16:22 +02:00
|
|
|
#define NFS4_enc_getacl_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_getacl_maxsz)
|
2005-06-22 19:16:22 +02:00
|
|
|
#define NFS4_dec_getacl_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_getacl_maxsz)
|
2005-06-22 19:16:22 +02:00
|
|
|
#define NFS4_enc_setacl_sz (compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
encode_setacl_maxsz)
|
2005-06-22 19:16:22 +02:00
|
|
|
#define NFS4_dec_setacl_sz (compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-18 03:52:42 +02:00
|
|
|
decode_setacl_maxsz)
|
2006-06-09 15:34:22 +02:00
|
|
|
#define NFS4_enc_fs_locations_sz \
|
|
|
|
(compound_encode_hdr_maxsz + \
|
|
|
|
encode_putfh_maxsz + \
|
2007-07-02 19:58:30 +02:00
|
|
|
encode_lookup_maxsz + \
|
|
|
|
encode_fs_locations_maxsz)
|
2006-06-09 15:34:22 +02:00
|
|
|
#define NFS4_dec_fs_locations_sz \
|
|
|
|
(compound_decode_hdr_maxsz + \
|
|
|
|
decode_putfh_maxsz + \
|
2007-07-02 19:58:30 +02:00
|
|
|
decode_lookup_maxsz + \
|
|
|
|
decode_fs_locations_maxsz)
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-03-11 19:10:26 +01:00
|
|
|
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,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct compound_hdr {
|
|
|
|
int32_t status;
|
|
|
|
uint32_t nops;
|
2008-12-23 22:06:17 +01:00
|
|
|
__be32 * nops_p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t taglen;
|
|
|
|
char * tag;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* START OF "GENERIC" ENCODE ROUTINES.
|
|
|
|
* These may look a little ugly since they are imported from a "generic"
|
|
|
|
* set of XDR encode/decode routines which are intended to be shared by
|
|
|
|
* all of our NFSv4 implementations (OpenBSD, MacOS X...).
|
|
|
|
*
|
|
|
|
* If the pain of reading these is too great, it should be a straightforward
|
|
|
|
* task to translate them into Linux-specific versions which are more
|
|
|
|
* consistent with the style used in NFSv2/v3...
|
|
|
|
*/
|
|
|
|
#define WRITE32(n) *p++ = htonl(n)
|
|
|
|
#define WRITE64(n) do { \
|
|
|
|
*p++ = htonl((uint32_t)((n) >> 32)); \
|
|
|
|
*p++ = htonl((uint32_t)(n)); \
|
|
|
|
} while (0)
|
|
|
|
#define WRITEMEM(ptr,nbytes) do { \
|
|
|
|
p = xdr_encode_opaque_fixed(p, ptr, nbytes); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define RESERVE_SPACE(nbytes) do { \
|
|
|
|
p = xdr_reserve_space(xdr, nbytes); \
|
|
|
|
BUG_ON(!p); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static void encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, 4 + len);
|
|
|
|
BUG_ON(p == NULL);
|
|
|
|
xdr_encode_opaque(p, str, len);
|
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:17 +01:00
|
|
|
static void encode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
dprintk("encode_compound: tag=%.*s\n", (int)hdr->taglen, hdr->tag);
|
|
|
|
BUG_ON(hdr->taglen > NFS4_MAXTAGLEN);
|
|
|
|
RESERVE_SPACE(12+(XDR_QUADLEN(hdr->taglen)<<2));
|
|
|
|
WRITE32(hdr->taglen);
|
|
|
|
WRITEMEM(hdr->tag, hdr->taglen);
|
|
|
|
WRITE32(NFS4_MINOR_VERSION);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops_p = p;
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(hdr->nops);
|
2008-12-23 22:06:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void encode_nops(struct compound_hdr *hdr)
|
|
|
|
{
|
|
|
|
*hdr->nops_p = htonl(hdr->nops);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void encode_nfs4_verifier(struct xdr_stream *xdr, const nfs4_verifier *verf)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
|
|
|
|
BUG_ON(p == NULL);
|
|
|
|
xdr_encode_opaque_fixed(p, verf->data, NFS4_VERIFIER_SIZE);
|
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_attrs(struct xdr_stream *xdr, const struct iattr *iap, const struct nfs_server *server)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
char owner_name[IDMAP_NAMESZ];
|
|
|
|
char owner_group[IDMAP_NAMESZ];
|
|
|
|
int owner_namelen = 0;
|
|
|
|
int owner_grouplen = 0;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
|
|
|
__be32 *q;
|
2005-04-17 00:20:36 +02:00
|
|
|
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
|
2005-06-22 19:16:22 +02:00
|
|
|
* such as owner/group.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
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) {
|
2006-08-23 02:06:09 +02:00
|
|
|
owner_namelen = nfs_map_uid_to_name(server->nfs_client, iap->ia_uid, owner_name);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (owner_namelen < 0) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("nfs: couldn't resolve uid %d to string\n",
|
|
|
|
iap->ia_uid);
|
2005-04-17 00:20:36 +02:00
|
|
|
/* 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) {
|
2006-08-23 02:06:09 +02:00
|
|
|
owner_grouplen = nfs_map_gid_to_group(server->nfs_client, iap->ia_gid, owner_group);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (owner_grouplen < 0) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("nfs: couldn't resolve gid %d to string\n",
|
|
|
|
iap->ia_gid);
|
2005-04-17 00:20:36 +02:00
|
|
|
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;
|
|
|
|
RESERVE_SPACE(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.
|
|
|
|
*/
|
|
|
|
WRITE32(2);
|
|
|
|
q = p;
|
|
|
|
p += 3;
|
|
|
|
|
|
|
|
if (iap->ia_valid & ATTR_SIZE) {
|
|
|
|
bmval0 |= FATTR4_WORD0_SIZE;
|
|
|
|
WRITE64(iap->ia_size);
|
|
|
|
}
|
|
|
|
if (iap->ia_valid & ATTR_MODE) {
|
|
|
|
bmval1 |= FATTR4_WORD1_MODE;
|
2006-01-03 09:55:53 +01:00
|
|
|
WRITE32(iap->ia_mode & S_IALLUGO);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
if (iap->ia_valid & ATTR_UID) {
|
|
|
|
bmval1 |= FATTR4_WORD1_OWNER;
|
|
|
|
WRITE32(owner_namelen);
|
|
|
|
WRITEMEM(owner_name, owner_namelen);
|
|
|
|
}
|
|
|
|
if (iap->ia_valid & ATTR_GID) {
|
|
|
|
bmval1 |= FATTR4_WORD1_OWNER_GROUP;
|
|
|
|
WRITE32(owner_grouplen);
|
|
|
|
WRITEMEM(owner_group, owner_grouplen);
|
|
|
|
}
|
|
|
|
if (iap->ia_valid & ATTR_ATIME_SET) {
|
|
|
|
bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
|
|
|
|
WRITE32(NFS4_SET_TO_CLIENT_TIME);
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(iap->ia_mtime.tv_sec);
|
|
|
|
WRITE32(iap->ia_mtime.tv_nsec);
|
|
|
|
}
|
|
|
|
else if (iap->ia_valid & ATTR_ATIME) {
|
|
|
|
bmval1 |= FATTR4_WORD1_TIME_ACCESS_SET;
|
|
|
|
WRITE32(NFS4_SET_TO_SERVER_TIME);
|
|
|
|
}
|
|
|
|
if (iap->ia_valid & ATTR_MTIME_SET) {
|
|
|
|
bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
|
|
|
|
WRITE32(NFS4_SET_TO_CLIENT_TIME);
|
|
|
|
WRITE32(0);
|
|
|
|
WRITE32(iap->ia_mtime.tv_sec);
|
|
|
|
WRITE32(iap->ia_mtime.tv_nsec);
|
|
|
|
}
|
|
|
|
else if (iap->ia_valid & ATTR_MTIME) {
|
|
|
|
bmval1 |= FATTR4_WORD1_TIME_MODIFY_SET;
|
|
|
|
WRITE32(NFS4_SET_TO_SERVER_TIME);
|
|
|
|
}
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Now we backfill the bitmap and the attribute buffer length.
|
|
|
|
*/
|
|
|
|
if (len != ((char *)p - (char *)q) + 4) {
|
2007-09-12 00:01:10 +02:00
|
|
|
printk(KERN_ERR "nfs: Attr length error, %u != %Zu\n",
|
2005-04-17 00:20:36 +02:00
|
|
|
len, ((char *)p - (char *)q) + 4);
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
len = (char *)p - (char *)q - 12;
|
|
|
|
*q++ = htonl(bmval0);
|
|
|
|
*q++ = htonl(bmval1);
|
|
|
|
*q++ = htonl(len);
|
|
|
|
|
|
|
|
/* out: */
|
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_access(struct xdr_stream *xdr, u32 access, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(8);
|
|
|
|
WRITE32(OP_ACCESS);
|
|
|
|
WRITE32(access);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_close(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(8+NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(OP_CLOSE);
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 23:20:12 +02:00
|
|
|
WRITE32(arg->seqid->sequence->counter);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_commit(struct xdr_stream *xdr, const struct nfs_writeargs *args, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
RESERVE_SPACE(16);
|
|
|
|
WRITE32(OP_COMMIT);
|
|
|
|
WRITE64(args->offset);
|
|
|
|
WRITE32(args->count);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_create(struct xdr_stream *xdr, const struct nfs4_create_arg *create, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
RESERVE_SPACE(8);
|
|
|
|
WRITE32(OP_CREATE);
|
|
|
|
WRITE32(create->ftype);
|
|
|
|
|
|
|
|
switch (create->ftype) {
|
|
|
|
case NF4LNK:
|
2006-08-23 02:06:23 +02:00
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(create->u.symlink.len);
|
|
|
|
xdr_write_pages(xdr, create->u.symlink.pages, 0, create->u.symlink.len);
|
2005-04-17 00:20:36 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case NF4BLK: case NF4CHR:
|
|
|
|
RESERVE_SPACE(8);
|
|
|
|
WRITE32(create->u.device.specdata1);
|
|
|
|
WRITE32(create->u.device.specdata2);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
RESERVE_SPACE(4 + create->name->len);
|
|
|
|
WRITE32(create->name->len);
|
|
|
|
WRITEMEM(create->name->name, create->name->len);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_attrs(xdr, create->attrs, create->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_getattr_one(struct xdr_stream *xdr, uint32_t bitmap, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
RESERVE_SPACE(12);
|
|
|
|
WRITE32(OP_GETATTR);
|
|
|
|
WRITE32(1);
|
|
|
|
WRITE32(bitmap);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_getattr_two(struct xdr_stream *xdr, uint32_t bm0, uint32_t bm1, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
RESERVE_SPACE(16);
|
|
|
|
WRITE32(OP_GETATTR);
|
|
|
|
WRITE32(2);
|
|
|
|
WRITE32(bm0);
|
|
|
|
WRITE32(bm1);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_getfattr(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_getattr_two(xdr, bitmask[0] & nfs4_fattr_bitmap[0],
|
|
|
|
bitmask[1] & nfs4_fattr_bitmap[1], hdr);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_fsinfo(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_getattr_two(xdr, bitmask[0] & nfs4_fsinfo_bitmap[0],
|
|
|
|
bitmask[1] & nfs4_fsinfo_bitmap[1], hdr);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_fs_locations(struct xdr_stream *xdr, const u32* bitmask, struct compound_hdr *hdr)
|
2006-06-09 15:34:25 +02:00
|
|
|
{
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_getattr_two(xdr, bitmask[0] & nfs4_fs_locations_bitmap[0],
|
|
|
|
bitmask[1] & nfs4_fs_locations_bitmap[1], hdr);
|
2006-06-09 15:34:25 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_getfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(OP_GETFH);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_link(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(8 + name->len);
|
|
|
|
WRITE32(OP_LINK);
|
|
|
|
WRITE32(name->len);
|
|
|
|
WRITEMEM(name->name, name->len);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-01-03 09:55:16 +01:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* opcode,type,reclaim,offset,length,new_lock_owner = 32
|
|
|
|
* open_seqid,open_stateid,lock_seqid,lock_owner.clientid, lock_owner.id = 40
|
|
|
|
*/
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(32);
|
|
|
|
WRITE32(OP_LOCK);
|
2006-01-03 09:55:16 +01:00
|
|
|
WRITE32(nfs4_lock_type(args->fl, args->block));
|
|
|
|
WRITE32(args->reclaim);
|
|
|
|
WRITE64(args->fl->fl_start);
|
|
|
|
WRITE64(nfs4_lock_length(args->fl));
|
|
|
|
WRITE32(args->new_lock_owner);
|
|
|
|
if (args->new_lock_owner){
|
2007-07-02 19:58:33 +02:00
|
|
|
RESERVE_SPACE(4+NFS4_STATEID_SIZE+32);
|
2006-01-03 09:55:16 +01:00
|
|
|
WRITE32(args->open_seqid->sequence->counter);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(args->open_stateid->data, NFS4_STATEID_SIZE);
|
2006-01-03 09:55:16 +01:00
|
|
|
WRITE32(args->lock_seqid->sequence->counter);
|
|
|
|
WRITE64(args->lock_owner.clientid);
|
2007-07-02 19:58:33 +02:00
|
|
|
WRITE32(16);
|
|
|
|
WRITEMEM("lock id:", 8);
|
|
|
|
WRITE64(args->lock_owner.id);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
else {
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(NFS4_STATEID_SIZE+4);
|
|
|
|
WRITEMEM(args->lock_stateid->data, NFS4_STATEID_SIZE);
|
2006-01-03 09:55:16 +01:00
|
|
|
WRITE32(args->lock_seqid->sequence->counter);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *args, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-07-02 19:58:33 +02:00
|
|
|
RESERVE_SPACE(52);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(OP_LOCKT);
|
2006-01-03 09:55:16 +01:00
|
|
|
WRITE32(nfs4_lock_type(args->fl, 0));
|
|
|
|
WRITE64(args->fl->fl_start);
|
|
|
|
WRITE64(nfs4_lock_length(args->fl));
|
|
|
|
WRITE64(args->lock_owner.clientid);
|
2007-07-02 19:58:33 +02:00
|
|
|
WRITE32(16);
|
|
|
|
WRITEMEM("lock id:", 8);
|
|
|
|
WRITE64(args->lock_owner.id);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_locku(struct xdr_stream *xdr, const struct nfs_locku_args *args, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(12+NFS4_STATEID_SIZE+16);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(OP_LOCKU);
|
2006-01-03 09:55:16 +01:00
|
|
|
WRITE32(nfs4_lock_type(args->fl, 0));
|
|
|
|
WRITE32(args->seqid->sequence->counter);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(args->stateid->data, NFS4_STATEID_SIZE);
|
2006-01-03 09:55:16 +01:00
|
|
|
WRITE64(args->fl->fl_start);
|
|
|
|
WRITE64(nfs4_lock_length(args->fl));
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_lookup(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int len = name->len;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(8 + len);
|
|
|
|
WRITE32(OP_LOOKUP);
|
|
|
|
WRITE32(len);
|
|
|
|
WRITEMEM(name->name, len);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 21:21:56 +01:00
|
|
|
static void encode_share_access(struct xdr_stream *xdr, fmode_t fmode)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(8);
|
2008-12-23 21:21:56 +01:00
|
|
|
switch (fmode & (FMODE_READ|FMODE_WRITE)) {
|
2008-12-23 22:06:15 +01:00
|
|
|
case FMODE_READ:
|
|
|
|
WRITE32(NFS4_SHARE_ACCESS_READ);
|
|
|
|
break;
|
|
|
|
case FMODE_WRITE:
|
|
|
|
WRITE32(NFS4_SHARE_ACCESS_WRITE);
|
|
|
|
break;
|
|
|
|
case FMODE_READ|FMODE_WRITE:
|
|
|
|
WRITE32(NFS4_SHARE_ACCESS_BOTH);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WRITE32(0);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
WRITE32(0); /* for linux, share_deny = 0 always */
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_openargs *arg)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* opcode 4, seqid 4, share_access 4, share_deny 4, clientid 8, ownerlen 4,
|
|
|
|
* owner 4 = 32
|
|
|
|
*/
|
|
|
|
RESERVE_SPACE(8);
|
|
|
|
WRITE32(OP_OPEN);
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 23:20:12 +02:00
|
|
|
WRITE32(arg->seqid->sequence->counter);
|
2008-12-23 21:21:56 +01:00
|
|
|
encode_share_access(xdr, arg->fmode);
|
2007-07-02 19:58:33 +02:00
|
|
|
RESERVE_SPACE(28);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE64(arg->clientid);
|
2007-07-02 19:58:33 +02:00
|
|
|
WRITE32(16);
|
|
|
|
WRITEMEM("open id:", 8);
|
|
|
|
WRITE64(arg->id);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
switch(arg->open_flags & O_EXCL) {
|
2008-12-23 22:06:15 +01:00
|
|
|
case 0:
|
|
|
|
WRITE32(NFS4_CREATE_UNCHECKED);
|
|
|
|
encode_attrs(xdr, arg->u.attrs, arg->server);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WRITE32(NFS4_CREATE_EXCLUSIVE);
|
|
|
|
encode_nfs4_verifier(xdr, &arg->u.verifier);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void encode_opentype(struct xdr_stream *xdr, const struct nfs_openargs *arg)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
switch (arg->open_flags & O_CREAT) {
|
2008-12-23 22:06:15 +01:00
|
|
|
case 0:
|
|
|
|
WRITE32(NFS4_OPEN_NOCREATE);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG_ON(arg->claim != NFS4_OPEN_CLAIM_NULL);
|
|
|
|
WRITE32(NFS4_OPEN_CREATE);
|
|
|
|
encode_createmode(xdr, arg);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-23 21:21:53 +01:00
|
|
|
static inline void encode_delegation_type(struct xdr_stream *xdr, fmode_t delegation_type)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
switch (delegation_type) {
|
2008-12-23 22:06:15 +01:00
|
|
|
case 0:
|
|
|
|
WRITE32(NFS4_OPEN_DELEGATE_NONE);
|
|
|
|
break;
|
|
|
|
case FMODE_READ:
|
|
|
|
WRITE32(NFS4_OPEN_DELEGATE_READ);
|
|
|
|
break;
|
|
|
|
case FMODE_WRITE|FMODE_READ:
|
|
|
|
WRITE32(NFS4_OPEN_DELEGATE_WRITE);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
BUG();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void encode_claim_null(struct xdr_stream *xdr, const struct qstr *name)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(NFS4_OPEN_CLAIM_NULL);
|
|
|
|
encode_string(xdr, name->len, name->name);
|
|
|
|
}
|
|
|
|
|
2008-12-23 21:21:53 +01:00
|
|
|
static inline void encode_claim_previous(struct xdr_stream *xdr, fmode_t type)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(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)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(4+NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(NFS4_OPEN_CLAIM_DELEGATE_CUR);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
encode_string(xdr, name->len, name->name);
|
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_open(struct xdr_stream *xdr, const struct nfs_openargs *arg, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
encode_openhdr(xdr, arg);
|
|
|
|
encode_opentype(xdr, arg);
|
|
|
|
switch (arg->claim) {
|
2008-12-23 22:06:15 +01:00
|
|
|
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();
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_open_confirm(struct xdr_stream *xdr, const struct nfs_open_confirmargs *arg, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(OP_OPEN_CONFIRM);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 23:20:12 +02:00
|
|
|
WRITE32(arg->seqid->sequence->counter);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_open_downgrade(struct xdr_stream *xdr, const struct nfs_closeargs *arg, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(4+NFS4_STATEID_SIZE+4);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(OP_OPEN_DOWNGRADE);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(arg->stateid->data, NFS4_STATEID_SIZE);
|
NFSv4: Add functions to order RPC calls
NFSv4 file state-changing functions such as OPEN, CLOSE, LOCK,... are all
labelled with "sequence identifiers" in order to prevent the server from
reordering RPC requests, as this could cause its file state to
become out of sync with the client.
Currently the NFS client code enforces this ordering locally using
semaphores to restrict access to structures until the RPC call is done.
This, of course, only works with synchronous RPC calls, since the
user process must first grab the semaphore.
By dropping semaphores, and instead teaching the RPC engine to hold
the RPC calls until they are ready to be sent, we can extend this
process to work nicely with asynchronous RPC calls too.
This patch adds a new list called "rpc_sequence" that defines the order
of the RPC calls to be sent. We add one such list for each state_owner.
When an RPC call is ready to be sent, it checks if it is top of the
rpc_sequence list. If so, it proceeds. If not, it goes back to sleep,
and loops until it hits top of the list.
Once the RPC call has completed, it can then bump the sequence id counter,
and remove itself from the rpc_sequence list, and then wake up the next
sleeper.
Note that the state_owner sequence ids and lock_owner sequence ids are
all indexed to the same rpc_sequence list, so OPEN, LOCK,... requests
are all ordered w.r.t. each other.
Signed-off-by: Trond Myklebust <Trond.Myklebust@netapp.com>
2005-10-18 23:20:12 +02:00
|
|
|
WRITE32(arg->seqid->sequence->counter);
|
2008-12-23 21:21:56 +01:00
|
|
|
encode_share_access(xdr, arg->fmode);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_putfh(struct xdr_stream *xdr, const struct nfs_fh *fh, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int len = fh->size;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(8 + len);
|
|
|
|
WRITE32(OP_PUTFH);
|
|
|
|
WRITE32(len);
|
|
|
|
WRITEMEM(fh->data, len);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_putrootfh(struct xdr_stream *xdr, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
__be32 *p;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(OP_PUTROOTFH);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void encode_stateid(struct xdr_stream *xdr, const struct nfs_open_context *ctx)
|
|
|
|
{
|
|
|
|
nfs4_stateid stateid;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (ctx->state != NULL) {
|
|
|
|
nfs4_copy_stateid(&stateid, ctx->state, ctx->lockowner);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(stateid.data, NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(OP_READ);
|
|
|
|
|
|
|
|
encode_stateid(xdr, args->context);
|
|
|
|
|
|
|
|
RESERVE_SPACE(12);
|
|
|
|
WRITE64(args->offset);
|
|
|
|
WRITE32(args->count);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2005-06-22 19:16:39 +02:00
|
|
|
uint32_t attrs[2] = {
|
|
|
|
FATTR4_WORD0_RDATTR_ERROR|FATTR4_WORD0_FILEID,
|
|
|
|
FATTR4_WORD1_MOUNTED_ON_FILEID,
|
|
|
|
};
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(12+NFS4_VERIFIER_SIZE+20);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(OP_READDIR);
|
|
|
|
WRITE64(readdir->cookie);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(readdir->verifier.data, NFS4_VERIFIER_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(readdir->count >> 1); /* We're not doing readdirplus */
|
|
|
|
WRITE32(readdir->count);
|
|
|
|
WRITE32(2);
|
2005-06-22 19:16:39 +02:00
|
|
|
/* Switch to mounted_on_fileid if the server supports it */
|
|
|
|
if (readdir->bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
|
|
|
|
attrs[0] &= ~FATTR4_WORD0_FILEID;
|
|
|
|
else
|
|
|
|
attrs[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
|
|
|
|
WRITE32(attrs[0] & readdir->bitmask[0]);
|
|
|
|
WRITE32(attrs[1] & readdir->bitmask[1]);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2008-04-02 14:21:15 +02:00
|
|
|
dprintk("%s: cookie = %Lu, verifier = %08x:%08x, bitmap = %08x:%08x\n",
|
|
|
|
__func__,
|
2005-06-22 19:16:39 +02:00
|
|
|
(unsigned long long)readdir->cookie,
|
|
|
|
((u32 *)readdir->verifier.data)[0],
|
|
|
|
((u32 *)readdir->verifier.data)[1],
|
|
|
|
attrs[0] & readdir->bitmask[0],
|
|
|
|
attrs[1] & readdir->bitmask[1]);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(OP_READLINK);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_remove(struct xdr_stream *xdr, const struct qstr *name, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(8 + name->len);
|
|
|
|
WRITE32(OP_REMOVE);
|
|
|
|
WRITE32(name->len);
|
|
|
|
WRITEMEM(name->name, name->len);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_rename(struct xdr_stream *xdr, const struct qstr *oldname, const struct qstr *newname, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(8 + oldname->len);
|
|
|
|
WRITE32(OP_RENAME);
|
|
|
|
WRITE32(oldname->len);
|
|
|
|
WRITEMEM(oldname->name, oldname->len);
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
RESERVE_SPACE(4 + newname->len);
|
|
|
|
WRITE32(newname->len);
|
|
|
|
WRITEMEM(newname->name, newname->len);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_renew(struct xdr_stream *xdr, const struct nfs_client *client_stateid, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(12);
|
|
|
|
WRITE32(OP_RENEW);
|
|
|
|
WRITE64(client_stateid->cl_clientid);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_restorefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
|
2005-10-28 04:12:40 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-10-28 04:12:40 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(OP_RESTOREFH);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-10-28 04:12:40 +02:00
|
|
|
}
|
|
|
|
|
2005-06-22 19:16:22 +02:00
|
|
|
static int
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_setacl(struct xdr_stream *xdr, struct nfs_setaclargs *arg, struct compound_hdr *hdr)
|
2005-06-22 19:16:22 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-06-22 19:16:22 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(4+NFS4_STATEID_SIZE);
|
2005-06-22 19:16:22 +02:00
|
|
|
WRITE32(OP_SETATTR);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(zero_stateid.data, NFS4_STATEID_SIZE);
|
2005-06-22 19:16:22 +02:00
|
|
|
RESERVE_SPACE(2*4);
|
|
|
|
WRITE32(1);
|
|
|
|
WRITE32(FATTR4_WORD0_ACL);
|
|
|
|
if (arg->acl_len % 4)
|
|
|
|
return -EINVAL;
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(arg->acl_len);
|
|
|
|
xdr_write_pages(xdr, arg->acl_pages, arg->acl_pgbase, arg->acl_len);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-06-22 19:16:22 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_savefh(struct xdr_stream *xdr, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(OP_SAVEFH);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_setattr(struct xdr_stream *xdr, const struct nfs_setattrargs *arg, const struct nfs_server *server, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
RESERVE_SPACE(4+NFS4_STATEID_SIZE);
|
|
|
|
WRITE32(OP_SETATTR);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(arg->stateid.data, NFS4_STATEID_SIZE);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_attrs(xdr, arg->iap, server);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_setclientid(struct xdr_stream *xdr, const struct nfs4_setclientid *setclientid, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(4 + NFS4_VERIFIER_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
WRITE32(OP_SETCLIENTID);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(setclientid->sc_verifier->data, NFS4_VERIFIER_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
encode_string(xdr, setclientid->sc_name_len, setclientid->sc_name);
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(setclientid->sc_prog);
|
|
|
|
encode_string(xdr, setclientid->sc_netid_len, setclientid->sc_netid);
|
|
|
|
encode_string(xdr, setclientid->sc_uaddr_len, setclientid->sc_uaddr);
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(setclientid->sc_cb_ident);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_setclientid_confirm(struct xdr_stream *xdr, const struct nfs_client *client_state, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
RESERVE_SPACE(12 + NFS4_VERIFIER_SIZE);
|
|
|
|
WRITE32(OP_SETCLIENTID_CONFIRM);
|
|
|
|
WRITE64(client_state->cl_clientid);
|
|
|
|
WRITEMEM(client_state->cl_confirm.data, NFS4_VERIFIER_SIZE);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_write(struct xdr_stream *xdr, const struct nfs_writeargs *args, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
RESERVE_SPACE(4);
|
|
|
|
WRITE32(OP_WRITE);
|
|
|
|
|
|
|
|
encode_stateid(xdr, args->context);
|
|
|
|
|
|
|
|
RESERVE_SPACE(16);
|
|
|
|
WRITE64(args->offset);
|
|
|
|
WRITE32(args->stable);
|
|
|
|
WRITE32(args->count);
|
|
|
|
|
|
|
|
xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:18 +01:00
|
|
|
static void encode_delegreturn(struct xdr_stream *xdr, const nfs4_stateid *stateid, struct compound_hdr *hdr)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-05-14 22:50:45 +02:00
|
|
|
RESERVE_SPACE(4+NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
WRITE32(OP_DELEGRETURN);
|
2007-05-14 22:50:45 +02:00
|
|
|
WRITEMEM(stateid->data, NFS4_STATEID_SIZE);
|
2008-12-23 22:06:17 +01:00
|
|
|
hdr->nops++;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* END OF "GENERIC" ENCODE ROUTINES.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode an ACCESS request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_access(struct rpc_rqst *req, __be32 *p, const struct nfs4_accessargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_access(&xdr, args->access, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode LOOKUP request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_lookup(struct rpc_rqst *req, __be32 *p, const struct nfs4_lookup_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->dir_fh, &hdr);
|
|
|
|
encode_lookup(&xdr, args->name, &hdr);
|
|
|
|
encode_getfh(&xdr, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode LOOKUP_ROOT request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_lookup_root(struct rpc_rqst *req, __be32 *p, const struct nfs4_lookup_root_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putrootfh(&xdr, &hdr);
|
|
|
|
encode_getfh(&xdr, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode REMOVE request
|
|
|
|
*/
|
2007-07-14 21:39:57 +02:00
|
|
|
static int nfs4_xdr_enc_remove(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_remove(&xdr, &args->name, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode RENAME request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_rename(struct rpc_rqst *req, __be32 *p, const struct nfs4_rename_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->old_dir, &hdr);
|
|
|
|
encode_savefh(&xdr, &hdr);
|
|
|
|
encode_putfh(&xdr, args->new_dir, &hdr);
|
|
|
|
encode_rename(&xdr, args->old_name, args->new_name, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
|
|
|
encode_restorefh(&xdr, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode LINK request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_link(struct rpc_rqst *req, __be32 *p, const struct nfs4_link_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_savefh(&xdr, &hdr);
|
|
|
|
encode_putfh(&xdr, args->dir_fh, &hdr);
|
|
|
|
encode_link(&xdr, args->name, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
|
|
|
encode_restorefh(&xdr, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode CREATE request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_create(struct rpc_rqst *req, __be32 *p, const struct nfs4_create_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->dir_fh, &hdr);
|
|
|
|
encode_savefh(&xdr, &hdr);
|
|
|
|
encode_create(&xdr, args, &hdr);
|
|
|
|
encode_getfh(&xdr, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
|
|
|
encode_restorefh(&xdr, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode SYMLINK request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_symlink(struct rpc_rqst *req, __be32 *p, const struct nfs4_create_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
return nfs4_xdr_enc_create(req, p, args);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode GETATTR request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_getattr(struct rpc_rqst *req, __be32 *p, const struct nfs4_getattr_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode a CLOSE request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_close(struct rpc_rqst *req, __be32 *p, struct nfs_closeargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2008-12-23 22:06:15 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_close(&xdr, args, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode an OPEN request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_open(struct rpc_rqst *req, __be32 *p, struct nfs_openargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_savefh(&xdr, &hdr);
|
|
|
|
encode_open(&xdr, args, &hdr);
|
|
|
|
encode_getfh(&xdr, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
|
|
|
encode_restorefh(&xdr, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode an OPEN_CONFIRM request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_open_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_open_confirmargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_open_confirm(&xdr, args, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode an OPEN request with no attributes.
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_open_noattr(struct rpc_rqst *req, __be32 *p, struct nfs_openargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_open(&xdr, args, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode an OPEN_DOWNGRADE request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_open_downgrade(struct rpc_rqst *req, __be32 *p, struct nfs_closeargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_open_downgrade(&xdr, args, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode a LOCK request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_lock(struct rpc_rqst *req, __be32 *p, struct nfs_lock_args *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_lock(&xdr, args, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode a LOCKT request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_lockt(struct rpc_rqst *req, __be32 *p, struct nfs_lockt_args *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_lockt(&xdr, args, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode a LOCKU request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_locku(struct rpc_rqst *req, __be32 *p, struct nfs_locku_args *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_locku(&xdr, args, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode a READLINK request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_readlink(struct rpc_rqst *req, __be32 *p, const struct nfs4_readlink *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
2007-07-19 16:03:38 +02:00
|
|
|
struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
|
|
|
|
unsigned int replen;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_readlink(&xdr, args, req, &hdr);
|
2007-07-19 16:03:38 +02:00
|
|
|
|
|
|
|
/* set up reply kvec
|
|
|
|
* toplevel_status + taglen + rescount + OP_PUTFH + status
|
|
|
|
* + OP_READLINK + status + string length = 8
|
|
|
|
*/
|
|
|
|
replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_readlink_sz) << 2;
|
|
|
|
xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages,
|
|
|
|
args->pgbase, args->pglen);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode a READDIR request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nfs4_readdir_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
2007-07-19 16:03:37 +02:00
|
|
|
struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
|
|
|
|
int replen;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_readdir(&xdr, args, req, &hdr);
|
2007-07-19 16:03:37 +02:00
|
|
|
|
|
|
|
/* set up reply kvec
|
|
|
|
* toplevel_status + taglen + rescount + OP_PUTFH + status
|
|
|
|
* + OP_READDIR + status + verifer(2) = 9
|
|
|
|
*/
|
|
|
|
replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_readdir_sz) << 2;
|
|
|
|
xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages,
|
|
|
|
args->pgbase, args->count);
|
|
|
|
dprintk("%s: inlined page args = (%u, %p, %u, %u)\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__, replen, args->pages,
|
2007-07-19 16:03:37 +02:00
|
|
|
args->pgbase, args->count);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode a READ request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2007-06-27 20:29:04 +02:00
|
|
|
struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
2008-12-23 22:06:18 +01:00
|
|
|
int replen;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_read(&xdr, args, &hdr);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* set up reply kvec
|
|
|
|
* toplevel status + taglen=0 + rescount + OP_PUTFH + status
|
|
|
|
* + OP_READ + status + eof + datalen = 9
|
|
|
|
*/
|
|
|
|
replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_read_sz) << 2;
|
|
|
|
xdr_inline_pages(&req->rq_rcv_buf, replen,
|
|
|
|
args->pages, args->pgbase, args->count);
|
2007-09-10 19:44:58 +02:00
|
|
|
req->rq_rcv_buf.flags |= XDRBUF_READ;
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Encode an SETATTR request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_setattr(struct rpc_rqst *req, __be32 *p, struct nfs_setattrargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2008-12-23 22:06:15 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_setattr(&xdr, args, args->server, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-06-22 19:16:22 +02:00
|
|
|
/*
|
|
|
|
* Encode a GETACL request
|
|
|
|
*/
|
|
|
|
static int
|
2006-10-20 08:28:48 +02:00
|
|
|
nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p,
|
2005-06-22 19:16:22 +02:00
|
|
|
struct nfs_getaclargs *args)
|
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
2007-06-27 20:29:04 +02:00
|
|
|
struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
|
2005-06-22 19:16:22 +02:00
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-06-22 19:16:22 +02:00
|
|
|
};
|
2008-12-23 22:06:18 +01:00
|
|
|
int replen;
|
2005-06-22 19:16:22 +02:00
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_getattr_two(&xdr, FATTR4_WORD0_ACL, 0, &hdr);
|
|
|
|
|
2005-06-22 19:16:22 +02:00
|
|
|
/* set up reply buffer: */
|
|
|
|
replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS4_dec_getacl_sz) << 2;
|
|
|
|
xdr_inline_pages(&req->rq_rcv_buf, replen,
|
|
|
|
args->acl_pages, args->acl_pgbase, args->acl_len);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-06-22 19:16:22 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Encode a WRITE request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_write(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_write(&xdr, args, &hdr);
|
2007-09-10 19:44:58 +02:00
|
|
|
req->rq_snd_buf.flags |= XDRBUF_WRITE;
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* a COMMIT request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_commit(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_commit(&xdr, args, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FSINFO request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs4_fsinfo_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_fsinfo(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* a PATHCONF request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_pathconf(struct rpc_rqst *req, __be32 *p, const struct nfs4_pathconf_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_getattr_one(&xdr, args->bitmask[0] & nfs4_pathconf_bitmap[0],
|
|
|
|
&hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* a STATFS request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_statfs(struct rpc_rqst *req, __be32 *p, const struct nfs4_statfs_arg *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
|
|
|
encode_getattr_two(&xdr, args->bitmask[0] & nfs4_statfs_bitmap[0],
|
|
|
|
args->bitmask[1] & nfs4_statfs_bitmap[1], &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GETATTR_BITMAP request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_server_caps(struct rpc_rqst *req, __be32 *p, const struct nfs_fh *fhandle)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, fhandle, &hdr);
|
|
|
|
encode_getattr_one(&xdr, FATTR4_WORD0_SUPPORTED_ATTRS|
|
|
|
|
FATTR4_WORD0_LINK_SUPPORT|
|
|
|
|
FATTR4_WORD0_SYMLINK_SUPPORT|
|
|
|
|
FATTR4_WORD0_ACLSUPPORT, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* a RENEW request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_renew(struct rpc_rqst *req, __be32 *p, struct nfs_client *clp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_renew(&xdr, clp, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* a SETCLIENTID request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_setclientid(struct rpc_rqst *req, __be32 *p, struct nfs4_setclientid *sc)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_setclientid(&xdr, sc, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* a SETCLIENTID_CONFIRM request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_setclientid_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_client *clp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
const u32 lease_bitmap[2] = { FATTR4_WORD0_LEASE_TIME, 0 };
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_setclientid_confirm(&xdr, clp, &hdr);
|
|
|
|
encode_putrootfh(&xdr, &hdr);
|
|
|
|
encode_fsinfo(&xdr, lease_bitmap, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DELEGRETURN request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_delegreturn(struct rpc_rqst *req, __be32 *p, const struct nfs4_delegreturnargs *args)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fhandle, &hdr);
|
|
|
|
encode_delegreturn(&xdr, args->stateid, &hdr);
|
|
|
|
encode_getfattr(&xdr, args->bitmask, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-06-09 15:34:22 +02:00
|
|
|
/*
|
|
|
|
* Encode FS_LOCATIONS request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs4_fs_locations_arg *args)
|
2006-06-09 15:34:22 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2006-06-09 15:34:22 +02:00
|
|
|
};
|
2007-06-27 20:29:04 +02:00
|
|
|
struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
|
2006-06-09 15:34:22 +02:00
|
|
|
int replen;
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->dir_fh, &hdr);
|
|
|
|
encode_lookup(&xdr, args->name, &hdr);
|
|
|
|
encode_fs_locations(&xdr, args->bitmask, &hdr);
|
|
|
|
|
2006-06-09 15:34:22 +02:00
|
|
|
/* set up reply
|
2006-06-09 15:34:25 +02:00
|
|
|
* toplevel_status + OP_PUTFH + status
|
2006-06-09 15:34:22 +02:00
|
|
|
* + OP_LOOKUP + status + OP_GETATTR + status = 7
|
|
|
|
*/
|
|
|
|
replen = (RPC_REPHDRSIZE + auth->au_rslack + 7) << 2;
|
|
|
|
xdr_inline_pages(&req->rq_rcv_buf, replen, &args->page,
|
|
|
|
0, PAGE_SIZE);
|
2008-12-23 22:06:17 +01:00
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
return 0;
|
2006-06-09 15:34:22 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* START OF "GENERIC" DECODE ROUTINES.
|
|
|
|
* These may look a little ugly since they are imported from a "generic"
|
|
|
|
* set of XDR encode/decode routines which are intended to be shared by
|
|
|
|
* all of our NFSv4 implementations (OpenBSD, MacOS X...).
|
|
|
|
*
|
|
|
|
* If the pain of reading these is too great, it should be a straightforward
|
|
|
|
* task to translate them into Linux-specific versions which are more
|
|
|
|
* consistent with the style used in NFSv2/v3...
|
|
|
|
*/
|
|
|
|
#define READ32(x) (x) = ntohl(*p++)
|
|
|
|
#define READ64(x) do { \
|
|
|
|
(x) = (u64)ntohl(*p++) << 32; \
|
|
|
|
(x) |= ntohl(*p++); \
|
|
|
|
} while (0)
|
|
|
|
#define READTIME(x) do { \
|
|
|
|
p++; \
|
|
|
|
(x.tv_sec) = ntohl(*p++); \
|
|
|
|
(x.tv_nsec) = ntohl(*p++); \
|
|
|
|
} while (0)
|
|
|
|
#define COPYMEM(x,nbytes) do { \
|
|
|
|
memcpy((x), p, nbytes); \
|
|
|
|
p += XDR_QUADLEN(nbytes); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define READ_BUF(nbytes) do { \
|
|
|
|
p = xdr_inline_decode(xdr, nbytes); \
|
2007-05-09 00:23:28 +02:00
|
|
|
if (unlikely(!p)) { \
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("nfs: %s: prematurely hit end of receive" \
|
2008-05-02 22:42:44 +02:00
|
|
|
" buffer\n", __func__); \
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("nfs: %s: xdr->p=%p, bytes=%u, xdr->end=%p\n", \
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__, xdr->p, nbytes, xdr->end); \
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EIO; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2006-06-09 15:34:22 +02:00
|
|
|
static int decode_opaque_inline(struct xdr_stream *xdr, unsigned int *len, char **string)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*len);
|
|
|
|
READ_BUF(*len);
|
|
|
|
*string = (char *)p;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_compound_hdr(struct xdr_stream *xdr, struct compound_hdr *hdr)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
READ_BUF(8);
|
|
|
|
READ32(hdr->status);
|
|
|
|
READ32(hdr->taglen);
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
READ_BUF(hdr->taglen + 4);
|
|
|
|
hdr->tag = (char *)p;
|
|
|
|
p += XDR_QUADLEN(hdr->taglen);
|
|
|
|
READ32(hdr->nops);
|
2008-12-23 22:06:13 +01:00
|
|
|
if (unlikely(hdr->nops < 1))
|
|
|
|
return nfs4_stat_to_errno(hdr->status);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_op_hdr(struct xdr_stream *xdr, enum nfs_opnum4 expected)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t opnum;
|
|
|
|
int32_t nfserr;
|
|
|
|
|
|
|
|
READ_BUF(8);
|
|
|
|
READ32(opnum);
|
|
|
|
if (opnum != expected) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("nfs: Server returned operation"
|
|
|
|
" %d but we issued a request for %d\n",
|
2005-04-17 00:20:36 +02:00
|
|
|
opnum, expected);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
READ32(nfserr);
|
|
|
|
if (nfserr != NFS_OK)
|
2008-03-31 16:39:06 +02:00
|
|
|
return nfs4_stat_to_errno(nfserr);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Dummy routine */
|
2006-08-23 02:06:08 +02:00
|
|
|
static int decode_ace(struct xdr_stream *xdr, void *ace, struct nfs_client *clp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2006-06-09 15:34:22 +02:00
|
|
|
unsigned int strlen;
|
2005-04-17 00:20:36 +02:00
|
|
|
char *str;
|
|
|
|
|
|
|
|
READ_BUF(12);
|
|
|
|
return decode_opaque_inline(xdr, &strlen, &str);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
uint32_t bmlen;
|
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(bmlen);
|
|
|
|
|
|
|
|
bitmap[0] = bitmap[1] = 0;
|
|
|
|
READ_BUF((bmlen << 2));
|
|
|
|
if (bmlen > 0) {
|
|
|
|
READ32(bitmap[0]);
|
|
|
|
if (bmlen > 1)
|
|
|
|
READ32(bitmap[1]);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:48 +02:00
|
|
|
static inline int decode_attr_length(struct xdr_stream *xdr, uint32_t *attrlen, __be32 **savep)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*attrlen);
|
|
|
|
*savep = xdr->p;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_supported(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *bitmask)
|
|
|
|
{
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_SUPPORTED_ATTRS)) {
|
|
|
|
decode_attr_bitmap(xdr, bitmask);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_SUPPORTED_ATTRS;
|
|
|
|
} else
|
|
|
|
bitmask[0] = bitmask[1] = 0;
|
2008-04-02 14:21:15 +02:00
|
|
|
dprintk("%s: bitmask=%08x:%08x\n", __func__, bitmask[0], bitmask[1]);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *type)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*type = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_TYPE - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_TYPE)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*type);
|
|
|
|
if (*type < NF4REG || *type > NF4NAMEDATTR) {
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: bad type %d\n", __func__, *type);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_TYPE;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_TYPE;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2009-03-11 19:10:26 +01:00
|
|
|
dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type]);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *change)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*change = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_CHANGE - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_CHANGE)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*change);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_CHANGE;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_CHANGE;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: change attribute=%Lu\n", __func__,
|
2005-04-17 00:20:36 +02:00
|
|
|
(unsigned long long)*change);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *size)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*size = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_SIZE - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_SIZE)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*size);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_SIZE;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_SIZE;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*res = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_LINK_SUPPORT - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_LINK_SUPPORT)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*res);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*res = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_SYMLINK_SUPPORT - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_SYMLINK_SUPPORT)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*res);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-09 15:34:19 +02:00
|
|
|
static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_fsid *fsid)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
fsid->major = 0;
|
|
|
|
fsid->minor = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_FSID - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_FSID)) {
|
|
|
|
READ_BUF(16);
|
|
|
|
READ64(fsid->major);
|
|
|
|
READ64(fsid->minor);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_FSID;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_FSID;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
|
2005-04-17 00:20:36 +02:00
|
|
|
(unsigned long long)fsid->major,
|
|
|
|
(unsigned long long)fsid->minor);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*res = 60;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_LEASE_TIME - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_LEASE_TIME)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*res);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: file size=%u\n", __func__, (unsigned int)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*res = ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_ACLSUPPORT - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_ACLSUPPORT)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*res);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*fileid = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_FILEID - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_FILEID)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*fileid);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_FILEID;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_FILEID;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-06-09 15:34:24 +02:00
|
|
|
static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *fileid)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2006-06-09 15:34:24 +02:00
|
|
|
|
|
|
|
*fileid = 0;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_MOUNTED_ON_FILEID - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*fileid);
|
|
|
|
bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_FILEID;
|
2006-06-09 15:34:24 +02:00
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2006-06-09 15:34:24 +02:00
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*res = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_AVAIL - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_FILES_AVAIL)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*res);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*res = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_FREE - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_FILES_FREE)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*res);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*res = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_FILES_TOTAL - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_FILES_TOTAL)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*res);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-06-09 15:34:23 +02:00
|
|
|
static int decode_pathname(struct xdr_stream *xdr, struct nfs4_pathname *path)
|
|
|
|
{
|
2007-10-26 19:32:08 +02:00
|
|
|
u32 n;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2006-06-09 15:34:23 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(n);
|
2006-06-09 15:34:30 +02:00
|
|
|
if (n == 0)
|
|
|
|
goto root_path;
|
2006-06-09 15:34:23 +02:00
|
|
|
dprintk("path ");
|
|
|
|
path->ncomponents = 0;
|
|
|
|
while (path->ncomponents < n) {
|
|
|
|
struct nfs4_string *component = &path->components[path->ncomponents];
|
|
|
|
status = decode_opaque_inline(xdr, &component->len, &component->data);
|
|
|
|
if (unlikely(status != 0))
|
|
|
|
goto out_eio;
|
|
|
|
if (path->ncomponents != n)
|
|
|
|
dprintk("/");
|
|
|
|
dprintk("%s", component->data);
|
|
|
|
if (path->ncomponents < NFS4_PATHNAME_MAXCOMPONENTS)
|
|
|
|
path->ncomponents++;
|
|
|
|
else {
|
|
|
|
dprintk("cannot parse %d components in path\n", n);
|
|
|
|
goto out_eio;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
dprintk("\n");
|
|
|
|
return status;
|
2006-06-09 15:34:30 +02:00
|
|
|
root_path:
|
|
|
|
/* a root pathname is sent as a zero component4 */
|
|
|
|
path->ncomponents = 1;
|
|
|
|
path->components[0].len=0;
|
|
|
|
path->components[0].data=NULL;
|
|
|
|
dprintk("path /\n");
|
|
|
|
goto out;
|
2006-06-09 15:34:23 +02:00
|
|
|
out_eio:
|
|
|
|
dprintk(" status %d", status);
|
|
|
|
status = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)
|
2006-06-09 15:34:22 +02:00
|
|
|
{
|
|
|
|
int n;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2006-06-09 15:34:22 +02:00
|
|
|
int status = -EIO;
|
|
|
|
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_FS_LOCATIONS -1U)))
|
|
|
|
goto out;
|
|
|
|
status = 0;
|
|
|
|
if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))
|
|
|
|
goto out;
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: fsroot ", __func__);
|
2006-06-09 15:34:23 +02:00
|
|
|
status = decode_pathname(xdr, &res->fs_path);
|
2006-06-09 15:34:22 +02:00
|
|
|
if (unlikely(status != 0))
|
|
|
|
goto out;
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(n);
|
|
|
|
if (n <= 0)
|
|
|
|
goto out_eio;
|
|
|
|
res->nlocations = 0;
|
|
|
|
while (res->nlocations < n) {
|
2007-10-26 19:32:08 +02:00
|
|
|
u32 m;
|
2006-06-09 15:34:23 +02:00
|
|
|
struct nfs4_fs_location *loc = &res->locations[res->nlocations];
|
2006-06-09 15:34:22 +02:00
|
|
|
|
2006-06-09 15:34:23 +02:00
|
|
|
READ_BUF(4);
|
|
|
|
READ32(m);
|
|
|
|
|
|
|
|
loc->nservers = 0;
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: servers ", __func__);
|
2006-06-09 15:34:23 +02:00
|
|
|
while (loc->nservers < m) {
|
|
|
|
struct nfs4_string *server = &loc->servers[loc->nservers];
|
|
|
|
status = decode_opaque_inline(xdr, &server->len, &server->data);
|
|
|
|
if (unlikely(status != 0))
|
|
|
|
goto out_eio;
|
|
|
|
dprintk("%s ", server->data);
|
|
|
|
if (loc->nservers < NFS4_FS_LOCATION_MAXSERVERS)
|
|
|
|
loc->nservers++;
|
|
|
|
else {
|
2007-10-26 19:32:08 +02:00
|
|
|
unsigned int i;
|
|
|
|
dprintk("%s: using first %u of %u servers "
|
|
|
|
"returned for location %u\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__,
|
2007-10-26 19:32:08 +02:00
|
|
|
NFS4_FS_LOCATION_MAXSERVERS,
|
|
|
|
m, res->nlocations);
|
2006-06-09 15:34:23 +02:00
|
|
|
for (i = loc->nservers; i < m; i++) {
|
2007-05-14 23:20:41 +02:00
|
|
|
unsigned int len;
|
2006-06-09 15:34:23 +02:00
|
|
|
char *data;
|
|
|
|
status = decode_opaque_inline(xdr, &len, &data);
|
|
|
|
if (unlikely(status != 0))
|
|
|
|
goto out_eio;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
status = decode_pathname(xdr, &loc->rootpath);
|
2006-06-09 15:34:22 +02:00
|
|
|
if (unlikely(status != 0))
|
|
|
|
goto out_eio;
|
2006-06-09 15:34:23 +02:00
|
|
|
if (res->nlocations < NFS4_FS_LOCATIONS_MAXENTRIES)
|
2006-06-09 15:34:22 +02:00
|
|
|
res->nlocations++;
|
|
|
|
}
|
2009-03-11 19:10:27 +01:00
|
|
|
if (res->nlocations != 0)
|
|
|
|
status = NFS_ATTR_FATTR_V4_REFERRAL;
|
2006-06-09 15:34:22 +02:00
|
|
|
out:
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: fs_locations done, error = %d\n", __func__, status);
|
2006-06-09 15:34:22 +02:00
|
|
|
return status;
|
|
|
|
out_eio:
|
|
|
|
status = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*res = 0;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXFILESIZE - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_MAXFILESIZE)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*res);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxlink)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*maxlink = 1;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXLINK - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_MAXLINK)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*maxlink);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: maxlink=%u\n", __func__, *maxlink);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *maxname)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*maxname = 1024;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXNAME - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_MAXNAME)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*maxname);
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: maxname=%u\n", __func__, *maxname);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*res = 1024;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXREAD - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_MAXREAD)) {
|
|
|
|
uint64_t maxread;
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(maxread);
|
|
|
|
if (maxread > 0x7FFFFFFF)
|
|
|
|
maxread = 0x7FFFFFFF;
|
|
|
|
*res = (uint32_t)maxread;
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*res = 1024;
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_MAXWRITE - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_MAXWRITE)) {
|
|
|
|
uint64_t maxwrite;
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(maxwrite);
|
|
|
|
if (maxwrite > 0x7FFFFFFF)
|
|
|
|
maxwrite = 0x7FFFFFFF;
|
|
|
|
*res = (uint32_t)maxwrite;
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2009-03-11 19:10:26 +01:00
|
|
|
static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, umode_t *mode)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2009-03-11 19:10:26 +01:00
|
|
|
uint32_t tmp;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*mode = 0;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_MODE - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_MODE)) {
|
|
|
|
READ_BUF(4);
|
2009-03-11 19:10:26 +01:00
|
|
|
READ32(tmp);
|
|
|
|
*mode = tmp & ~S_IFMT;
|
2005-04-17 00:20:36 +02:00
|
|
|
bitmap[1] &= ~FATTR4_WORD1_MODE;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_MODE;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *nlink)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*nlink = 1;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_NUMLINKS - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_NUMLINKS)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(*nlink);
|
|
|
|
bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_NLINK;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-05-14 23:20:41 +02:00
|
|
|
static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *uid)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
uint32_t len;
|
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*uid = -2;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_OWNER)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(len);
|
|
|
|
READ_BUF(len);
|
|
|
|
if (len < XDR_MAX_NETOBJ) {
|
2009-03-11 19:10:27 +01:00
|
|
|
if (nfs_map_name_to_uid(clp, (char *)p, len, uid) == 0)
|
|
|
|
ret = NFS_ATTR_FATTR_OWNER;
|
|
|
|
else
|
2005-04-17 00:20:36 +02:00
|
|
|
dprintk("%s: nfs_map_name_to_uid failed!\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("%s: name too long (%u)!\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__, len);
|
2005-04-17 00:20:36 +02:00
|
|
|
bitmap[1] &= ~FATTR4_WORD1_OWNER;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: uid=%d\n", __func__, (int)*uid);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-05-14 23:20:41 +02:00
|
|
|
static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs_client *clp, uint32_t *gid)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
uint32_t len;
|
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*gid = -2;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_OWNER_GROUP - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_OWNER_GROUP)) {
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(len);
|
|
|
|
READ_BUF(len);
|
|
|
|
if (len < XDR_MAX_NETOBJ) {
|
2009-03-11 19:10:27 +01:00
|
|
|
if (nfs_map_group_to_gid(clp, (char *)p, len, gid) == 0)
|
|
|
|
ret = NFS_ATTR_FATTR_GROUP;
|
|
|
|
else
|
2005-04-17 00:20:36 +02:00
|
|
|
dprintk("%s: nfs_map_group_to_gid failed!\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("%s: name too long (%u)!\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__, len);
|
2005-04-17 00:20:36 +02:00
|
|
|
bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: gid=%d\n", __func__, (int)*gid);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rdev)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
uint32_t major = 0, minor = 0;
|
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*rdev = MKDEV(0,0);
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_RAWDEV - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_RAWDEV)) {
|
|
|
|
dev_t tmp;
|
|
|
|
|
|
|
|
READ_BUF(8);
|
|
|
|
READ32(major);
|
|
|
|
READ32(minor);
|
|
|
|
tmp = MKDEV(major, minor);
|
|
|
|
if (MAJOR(tmp) == major && MINOR(tmp) == minor)
|
|
|
|
*rdev = tmp;
|
|
|
|
bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_RDEV;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*res = 0;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_AVAIL - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_SPACE_AVAIL)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*res);
|
|
|
|
bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*res = 0;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_FREE - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_SPACE_FREE)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*res);
|
|
|
|
bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
*res = 0;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_TOTAL - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_SPACE_TOTAL)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*res);
|
|
|
|
bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *used)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2009-03-11 19:10:27 +01:00
|
|
|
int ret = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
*used = 0;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_SPACE_USED - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_SPACE_USED)) {
|
|
|
|
READ_BUF(8);
|
|
|
|
READ64(*used);
|
|
|
|
bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
|
2009-03-11 19:10:27 +01:00
|
|
|
ret = NFS_ATTR_FATTR_SPACE_USED;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: space used=%Lu\n", __func__,
|
2005-04-17 00:20:36 +02:00
|
|
|
(unsigned long long)*used);
|
2009-03-11 19:10:27 +01:00
|
|
|
return ret;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_time(struct xdr_stream *xdr, struct timespec *time)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint64_t sec;
|
|
|
|
uint32_t nsec;
|
|
|
|
|
|
|
|
READ_BUF(12);
|
|
|
|
READ64(sec);
|
|
|
|
READ32(nsec);
|
|
|
|
time->tv_sec = (time_t)sec;
|
|
|
|
time->tv_nsec = (long)nsec;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
|
|
|
|
{
|
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
time->tv_sec = 0;
|
|
|
|
time->tv_nsec = 0;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_ACCESS - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_TIME_ACCESS)) {
|
|
|
|
status = decode_attr_time(xdr, time);
|
2009-03-11 19:10:27 +01:00
|
|
|
if (status == 0)
|
|
|
|
status = NFS_ATTR_FATTR_ATIME;
|
2005-04-17 00:20:36 +02:00
|
|
|
bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
|
|
|
|
{
|
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
time->tv_sec = 0;
|
|
|
|
time->tv_nsec = 0;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_METADATA - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_TIME_METADATA)) {
|
|
|
|
status = decode_attr_time(xdr, time);
|
2009-03-11 19:10:27 +01:00
|
|
|
if (status == 0)
|
|
|
|
status = NFS_ATTR_FATTR_CTIME;
|
2005-04-17 00:20:36 +02:00
|
|
|
bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, struct timespec *time)
|
|
|
|
{
|
|
|
|
int status = 0;
|
|
|
|
|
|
|
|
time->tv_sec = 0;
|
|
|
|
time->tv_nsec = 0;
|
|
|
|
if (unlikely(bitmap[1] & (FATTR4_WORD1_TIME_MODIFY - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[1] & FATTR4_WORD1_TIME_MODIFY)) {
|
|
|
|
status = decode_attr_time(xdr, time);
|
2009-03-11 19:10:27 +01:00
|
|
|
if (status == 0)
|
|
|
|
status = NFS_ATTR_FATTR_MTIME;
|
2005-04-17 00:20:36 +02:00
|
|
|
bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
|
|
|
|
}
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:48 +02:00
|
|
|
static int verify_attr_len(struct xdr_stream *xdr, __be32 *savep, uint32_t attrlen)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned int attrwords = XDR_QUADLEN(attrlen);
|
|
|
|
unsigned int nwords = xdr->p - savep;
|
|
|
|
|
|
|
|
if (unlikely(attrwords != nwords)) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("%s: server returned incorrect attribute length: "
|
|
|
|
"%u %c %u\n",
|
2008-05-02 22:42:44 +02:00
|
|
|
__func__,
|
2005-04-17 00:20:36 +02:00
|
|
|
attrwords << 2,
|
|
|
|
(attrwords < nwords) ? '<' : '>',
|
|
|
|
nwords << 2);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_change_info(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
READ_BUF(20);
|
|
|
|
READ32(cinfo->atomic);
|
|
|
|
READ64(cinfo->before);
|
|
|
|
READ64(cinfo->after);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_access(struct xdr_stream *xdr, struct nfs4_accessres *access)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t supp, acc;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_ACCESS);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(8);
|
|
|
|
READ32(supp);
|
|
|
|
READ32(acc);
|
|
|
|
access->supported = supp;
|
|
|
|
access->access = acc;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_CLOSE);
|
2008-04-07 19:20:54 +02:00
|
|
|
if (status != -EIO)
|
|
|
|
nfs_increment_open_seqid(status, res->seqid);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (status)
|
|
|
|
return status;
|
2007-05-14 22:50:45 +02:00
|
|
|
READ_BUF(NFS4_STATEID_SIZE);
|
|
|
|
COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_commit(struct xdr_stream *xdr, struct nfs_writeres *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_COMMIT);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(8);
|
|
|
|
COPYMEM(res->verf->verifier, 8);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_create(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t bmlen;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_CREATE);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
if ((status = decode_change_info(xdr, cinfo)))
|
|
|
|
return status;
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(bmlen);
|
|
|
|
READ_BUF(bmlen << 2);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *savep;
|
2008-12-23 22:06:15 +01:00
|
|
|
uint32_t attrlen, bitmap[2] = {0};
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
|
|
|
|
|
|
|
if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
status = verify_attr_len(xdr, savep, attrlen);
|
|
|
|
xdr_error:
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: xdr returned %d!\n", __func__, -status);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *savep;
|
2008-12-23 22:06:15 +01:00
|
|
|
uint32_t attrlen, bitmap[2] = {0};
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
if ((status = decode_attr_files_avail(xdr, bitmap, &fsstat->afiles)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_files_free(xdr, bitmap, &fsstat->ffiles)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_files_total(xdr, bitmap, &fsstat->tfiles)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_space_avail(xdr, bitmap, &fsstat->abytes)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_space_free(xdr, bitmap, &fsstat->fbytes)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_space_total(xdr, bitmap, &fsstat->tbytes)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
status = verify_attr_len(xdr, savep, attrlen);
|
|
|
|
xdr_error:
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: xdr returned %d!\n", __func__, -status);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *savep;
|
2008-12-23 22:06:15 +01:00
|
|
|
uint32_t attrlen, bitmap[2] = {0};
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
if ((status = decode_attr_maxlink(xdr, bitmap, &pathconf->max_link)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_maxname(xdr, bitmap, &pathconf->max_namelen)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
status = verify_attr_len(xdr, savep, attrlen);
|
|
|
|
xdr_error:
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: xdr returned %d!\n", __func__, -status);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, const struct nfs_server *server)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *savep;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t attrlen,
|
|
|
|
bitmap[2] = {0},
|
|
|
|
type;
|
2009-03-11 19:10:26 +01:00
|
|
|
int status;
|
|
|
|
umode_t fmode = 0;
|
2006-06-09 15:34:24 +02:00
|
|
|
uint64_t fileid;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-03-11 19:10:26 +01:00
|
|
|
status = decode_op_hdr(xdr, OP_GETATTR);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_bitmap(xdr, bitmap);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
|
|
|
|
2009-03-11 19:10:26 +01:00
|
|
|
status = decode_attr_length(xdr, &attrlen, &savep);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
|
2009-03-11 19:10:26 +01:00
|
|
|
status = decode_attr_type(xdr, bitmap, &type);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->mode = 0;
|
|
|
|
if (status != 0) {
|
|
|
|
fattr->mode |= nfs_type2fmt[type];
|
|
|
|
fattr->valid |= status;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2009-03-11 19:10:26 +01:00
|
|
|
status = decode_attr_change(xdr, bitmap, &fattr->change_attr);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_size(xdr, bitmap, &fattr->size);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_fsid(xdr, bitmap, &fattr->fsid);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_fileid(xdr, bitmap, &fattr->fileid);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_fs_locations(xdr, bitmap, container_of(fattr,
|
2006-06-09 15:34:23 +02:00
|
|
|
struct nfs4_fs_locations,
|
2009-03-11 19:10:26 +01:00
|
|
|
fattr));
|
|
|
|
if (status < 0)
|
2006-06-09 15:34:22 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_mode(xdr, bitmap, &fmode);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
if (status != 0) {
|
|
|
|
fattr->mode |= fmode;
|
|
|
|
fattr->valid |= status;
|
|
|
|
}
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_nlink(xdr, bitmap, &fattr->nlink);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_owner(xdr, bitmap, server->nfs_client, &fattr->uid);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_group(xdr, bitmap, server->nfs_client, &fattr->gid);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_rdev(xdr, bitmap, &fattr->rdev);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_space_used(xdr, bitmap, &fattr->du.nfs3.used);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_time_access(xdr, bitmap, &fattr->atime);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_time_metadata(xdr, bitmap, &fattr->ctime);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_time_modify(xdr, bitmap, &fattr->mtime);
|
|
|
|
if (status < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = decode_attr_mounted_on_fileid(xdr, bitmap, &fileid);
|
|
|
|
if (status < 0)
|
2006-06-09 15:34:24 +02:00
|
|
|
goto xdr_error;
|
2009-03-11 19:10:27 +01:00
|
|
|
if (status != 0 && !(fattr->valid & status)) {
|
2006-06-09 15:34:24 +02:00
|
|
|
fattr->fileid = fileid;
|
2009-03-11 19:10:27 +01:00
|
|
|
fattr->valid |= status;
|
|
|
|
}
|
2009-03-11 19:10:26 +01:00
|
|
|
|
|
|
|
status = verify_attr_len(xdr, savep, attrlen);
|
2005-04-17 00:20:36 +02:00
|
|
|
xdr_error:
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: xdr returned %d\n", __func__, -status);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *savep;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t attrlen, bitmap[2];
|
|
|
|
int status;
|
|
|
|
|
|
|
|
if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
|
|
|
|
fsinfo->rtmult = fsinfo->wtmult = 512; /* ??? */
|
|
|
|
|
|
|
|
if ((status = decode_attr_lease_time(xdr, bitmap, &fsinfo->lease_time)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_maxfilesize(xdr, bitmap, &fsinfo->maxfilesize)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
if ((status = decode_attr_maxread(xdr, bitmap, &fsinfo->rtmax)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
fsinfo->rtpref = fsinfo->dtpref = fsinfo->rtmax;
|
|
|
|
if ((status = decode_attr_maxwrite(xdr, bitmap, &fsinfo->wtmax)) != 0)
|
|
|
|
goto xdr_error;
|
|
|
|
fsinfo->wtpref = fsinfo->wtmax;
|
|
|
|
|
|
|
|
status = verify_attr_len(xdr, savep, attrlen);
|
|
|
|
xdr_error:
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: xdr returned %d!\n", __func__, -status);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_getfh(struct xdr_stream *xdr, struct nfs_fh *fh)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t len;
|
|
|
|
int status;
|
|
|
|
|
2007-07-18 03:52:41 +02:00
|
|
|
/* Zero handle first to allow comparisons */
|
|
|
|
memset(fh, 0, sizeof(*fh));
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
status = decode_op_hdr(xdr, OP_GETFH);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(len);
|
|
|
|
if (len > NFS4_FHSIZE)
|
|
|
|
return -EIO;
|
|
|
|
fh->size = len;
|
|
|
|
READ_BUF(len);
|
|
|
|
COPYMEM(fh->data, len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_link(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
|
|
|
|
{
|
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
status = decode_op_hdr(xdr, OP_LINK);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
return decode_change_info(xdr, cinfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We create the owner, so we know a proper owner.id length is 4.
|
|
|
|
*/
|
2006-01-03 09:55:16 +01:00
|
|
|
static int decode_lock_denied (struct xdr_stream *xdr, struct file_lock *fl)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-01-03 09:55:16 +01:00
|
|
|
uint64_t offset, length, clientid;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2006-01-03 09:55:16 +01:00
|
|
|
uint32_t namelen, type;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
READ_BUF(32);
|
2006-01-03 09:55:16 +01:00
|
|
|
READ64(offset);
|
|
|
|
READ64(length);
|
|
|
|
READ32(type);
|
|
|
|
if (fl != NULL) {
|
|
|
|
fl->fl_start = (loff_t)offset;
|
|
|
|
fl->fl_end = fl->fl_start + (loff_t)length - 1;
|
|
|
|
if (length == ~(uint64_t)0)
|
|
|
|
fl->fl_end = OFFSET_MAX;
|
|
|
|
fl->fl_type = F_WRLCK;
|
|
|
|
if (type & 1)
|
|
|
|
fl->fl_type = F_RDLCK;
|
|
|
|
fl->fl_pid = 0;
|
|
|
|
}
|
|
|
|
READ64(clientid);
|
2005-04-17 00:20:36 +02:00
|
|
|
READ32(namelen);
|
|
|
|
READ_BUF(namelen);
|
|
|
|
return -NFS4ERR_DENIED;
|
|
|
|
}
|
|
|
|
|
2006-01-03 09:55:16 +01:00
|
|
|
static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_LOCK);
|
2008-04-07 19:20:54 +02:00
|
|
|
if (status == -EIO)
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
if (status == 0) {
|
2007-05-14 22:50:45 +02:00
|
|
|
READ_BUF(NFS4_STATEID_SIZE);
|
|
|
|
COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else if (status == -NFS4ERR_DENIED)
|
2008-04-07 19:20:54 +02:00
|
|
|
status = decode_lock_denied(xdr, NULL);
|
|
|
|
if (res->open_seqid != NULL)
|
|
|
|
nfs_increment_open_seqid(status, res->open_seqid);
|
|
|
|
nfs_increment_lock_seqid(status, res->lock_seqid);
|
|
|
|
out:
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-01-03 09:55:16 +01:00
|
|
|
static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int status;
|
|
|
|
status = decode_op_hdr(xdr, OP_LOCKT);
|
|
|
|
if (status == -NFS4ERR_DENIED)
|
2006-01-03 09:55:16 +01:00
|
|
|
return decode_lock_denied(xdr, res->denied);
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-01-03 09:55:16 +01:00
|
|
|
static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_LOCKU);
|
2008-04-07 19:20:54 +02:00
|
|
|
if (status != -EIO)
|
|
|
|
nfs_increment_lock_seqid(status, res->seqid);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (status == 0) {
|
2007-05-14 22:50:45 +02:00
|
|
|
READ_BUF(NFS4_STATEID_SIZE);
|
|
|
|
COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_lookup(struct xdr_stream *xdr)
|
|
|
|
{
|
|
|
|
return decode_op_hdr(xdr, OP_LOOKUP);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is too sick! */
|
|
|
|
static int decode_space_limit(struct xdr_stream *xdr, u64 *maxsize)
|
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t limit_type, nblocks, blocksize;
|
|
|
|
|
|
|
|
READ_BUF(12);
|
|
|
|
READ32(limit_type);
|
|
|
|
switch (limit_type) {
|
2008-12-23 22:06:15 +01:00
|
|
|
case 1:
|
|
|
|
READ64(*maxsize);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
READ32(nblocks);
|
|
|
|
READ32(blocksize);
|
|
|
|
*maxsize = (uint64_t)nblocks * (uint64_t)blocksize;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
|
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
__be32 *p;
|
|
|
|
uint32_t delegation_type;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(delegation_type);
|
|
|
|
if (delegation_type == NFS4_OPEN_DELEGATE_NONE) {
|
|
|
|
res->delegation_type = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
2007-05-14 22:50:45 +02:00
|
|
|
READ_BUF(NFS4_STATEID_SIZE+4);
|
|
|
|
COPYMEM(res->delegation.data, NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
READ32(res->do_recall);
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
switch (delegation_type) {
|
2008-12-23 22:06:15 +01:00
|
|
|
case NFS4_OPEN_DELEGATE_READ:
|
|
|
|
res->delegation_type = FMODE_READ;
|
|
|
|
break;
|
|
|
|
case NFS4_OPEN_DELEGATE_WRITE:
|
|
|
|
res->delegation_type = FMODE_WRITE|FMODE_READ;
|
|
|
|
if (decode_space_limit(xdr, &res->maxsize) < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EIO;
|
|
|
|
}
|
2006-08-23 02:06:09 +02:00
|
|
|
return decode_ace(xdr, NULL, res->server->nfs_client);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
|
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
__be32 *p;
|
2007-06-05 20:49:03 +02:00
|
|
|
uint32_t savewords, bmlen, i;
|
2008-12-23 22:06:15 +01:00
|
|
|
int status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
status = decode_op_hdr(xdr, OP_OPEN);
|
2008-04-07 19:20:54 +02:00
|
|
|
if (status != -EIO)
|
|
|
|
nfs_increment_open_seqid(status, res->seqid);
|
2008-12-23 22:06:15 +01:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(NFS4_STATEID_SIZE);
|
|
|
|
COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
decode_change_info(xdr, &res->cinfo);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
READ_BUF(8);
|
|
|
|
READ32(res->rflags);
|
|
|
|
READ32(bmlen);
|
|
|
|
if (bmlen > 10)
|
|
|
|
goto xdr_error;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
READ_BUF(bmlen << 2);
|
2007-06-05 20:49:03 +02:00
|
|
|
savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE);
|
|
|
|
for (i = 0; i < savewords; ++i)
|
|
|
|
READ32(res->attrset[i]);
|
|
|
|
for (; i < NFS4_BITMAP_SIZE; i++)
|
|
|
|
res->attrset[i] = 0;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return decode_delegation(xdr, res);
|
|
|
|
xdr_error:
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
|
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
|
|
|
|
2008-12-23 22:06:15 +01:00
|
|
|
status = decode_op_hdr(xdr, OP_OPEN_CONFIRM);
|
2008-04-07 19:20:54 +02:00
|
|
|
if (status != -EIO)
|
|
|
|
nfs_increment_open_seqid(status, res->seqid);
|
2008-12-23 22:06:15 +01:00
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(NFS4_STATEID_SIZE);
|
|
|
|
COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
|
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_OPEN_DOWNGRADE);
|
2008-04-07 19:20:54 +02:00
|
|
|
if (status != -EIO)
|
|
|
|
nfs_increment_open_seqid(status, res->seqid);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (status)
|
|
|
|
return status;
|
2007-05-14 22:50:45 +02:00
|
|
|
READ_BUF(NFS4_STATEID_SIZE);
|
|
|
|
COPYMEM(res->stateid.data, NFS4_STATEID_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_putfh(struct xdr_stream *xdr)
|
|
|
|
{
|
|
|
|
return decode_op_hdr(xdr, OP_PUTFH);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_putrootfh(struct xdr_stream *xdr)
|
|
|
|
{
|
|
|
|
return decode_op_hdr(xdr, OP_PUTROOTFH);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_read(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs_readres *res)
|
|
|
|
{
|
|
|
|
struct kvec *iov = req->rq_rcv_buf.head;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t count, eof, recvd, hdrlen;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_READ);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(8);
|
|
|
|
READ32(eof);
|
|
|
|
READ32(count);
|
|
|
|
hdrlen = (u8 *) p - (u8 *) iov->iov_base;
|
|
|
|
recvd = req->rq_rcv_buf.len - hdrlen;
|
|
|
|
if (count > recvd) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("NFS: server cheating in read reply: "
|
2005-04-17 00:20:36 +02:00
|
|
|
"count %u > recvd %u\n", count, recvd);
|
|
|
|
count = recvd;
|
|
|
|
eof = 0;
|
|
|
|
}
|
|
|
|
xdr_read_pages(xdr, count);
|
|
|
|
res->eof = eof;
|
|
|
|
res->count = count;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_readdir(struct xdr_stream *xdr, struct rpc_rqst *req, struct nfs4_readdir_res *readdir)
|
|
|
|
{
|
|
|
|
struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
|
|
|
|
struct page *page = *rcvbuf->pages;
|
|
|
|
struct kvec *iov = rcvbuf->head;
|
2007-10-26 19:32:03 +02:00
|
|
|
size_t hdrlen;
|
|
|
|
u32 recvd, pglen = rcvbuf->page_len;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *end, *entry, *p, *kaddr;
|
2008-02-22 20:50:01 +01:00
|
|
|
unsigned int nr = 0;
|
2007-10-26 19:32:03 +02:00
|
|
|
int status;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_READDIR);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(8);
|
|
|
|
COPYMEM(readdir->verifier.data, 8);
|
2008-04-02 14:21:15 +02:00
|
|
|
dprintk("%s: verifier = %08x:%08x\n",
|
|
|
|
__func__,
|
2005-06-22 19:16:39 +02:00
|
|
|
((u32 *)readdir->verifier.data)[0],
|
|
|
|
((u32 *)readdir->verifier.data)[1]);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
hdrlen = (char *) p - (char *) iov->iov_base;
|
|
|
|
recvd = rcvbuf->len - hdrlen;
|
|
|
|
if (pglen > recvd)
|
|
|
|
pglen = recvd;
|
|
|
|
xdr_read_pages(xdr, pglen);
|
|
|
|
|
|
|
|
BUG_ON(pglen + readdir->pgbase > PAGE_CACHE_SIZE);
|
2006-10-20 08:28:48 +02:00
|
|
|
kaddr = p = kmap_atomic(page, KM_USER0);
|
2006-08-24 21:44:19 +02:00
|
|
|
end = p + ((pglen + readdir->pgbase) >> 2);
|
2005-04-17 00:20:36 +02:00
|
|
|
entry = p;
|
2008-02-22 20:50:01 +01:00
|
|
|
|
|
|
|
/* Make sure the packet actually has a value_follows and EOF entry */
|
|
|
|
if ((entry + 1) > end)
|
|
|
|
goto short_pkt;
|
|
|
|
|
|
|
|
for (; *p++; nr++) {
|
2007-10-26 19:32:03 +02:00
|
|
|
u32 len, attrlen, xlen;
|
2006-08-24 21:44:19 +02:00
|
|
|
if (end - p < 3)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto short_pkt;
|
2005-06-22 19:16:39 +02:00
|
|
|
dprintk("cookie = %Lu, ", *((unsigned long long *)p));
|
2005-04-17 00:20:36 +02:00
|
|
|
p += 2; /* cookie */
|
|
|
|
len = ntohl(*p++); /* filename length */
|
|
|
|
if (len > NFS4_MAXNAMLEN) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("NFS: giant filename in readdir (len 0x%x)\n",
|
|
|
|
len);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto err_unmap;
|
|
|
|
}
|
2006-08-24 21:44:19 +02:00
|
|
|
xlen = XDR_QUADLEN(len);
|
|
|
|
if (end - p < xlen + 1)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto short_pkt;
|
2006-08-24 21:44:19 +02:00
|
|
|
dprintk("filename = %*s\n", len, (char *)p);
|
|
|
|
p += xlen;
|
2005-04-17 00:20:36 +02:00
|
|
|
len = ntohl(*p++); /* bitmap length */
|
2006-08-24 21:44:19 +02:00
|
|
|
if (end - p < len + 1)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto short_pkt;
|
2006-08-24 21:44:19 +02:00
|
|
|
p += len;
|
2005-04-17 00:20:36 +02:00
|
|
|
attrlen = XDR_QUADLEN(ntohl(*p++));
|
2006-08-24 21:44:19 +02:00
|
|
|
if (end - p < attrlen + 2)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto short_pkt;
|
2006-08-24 21:44:19 +02:00
|
|
|
p += attrlen; /* attributes */
|
2005-04-17 00:20:36 +02:00
|
|
|
entry = p;
|
|
|
|
}
|
2008-02-22 20:50:01 +01:00
|
|
|
/*
|
|
|
|
* Apparently some server sends responses that are a valid size, but
|
|
|
|
* contain no entries, and have value_follows==0 and EOF==0. For
|
|
|
|
* those, just set the EOF marker.
|
|
|
|
*/
|
|
|
|
if (!nr && entry[1] == 0) {
|
|
|
|
dprintk("NFS: readdir reply truncated!\n");
|
|
|
|
entry[1] = 1;
|
|
|
|
}
|
2008-12-23 22:06:15 +01:00
|
|
|
out:
|
2005-04-17 00:20:36 +02:00
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
|
|
|
return 0;
|
|
|
|
short_pkt:
|
2008-02-22 20:50:01 +01:00
|
|
|
/*
|
|
|
|
* When we get a short packet there are 2 possibilities. We can
|
|
|
|
* return an error, or fix up the response to look like a valid
|
|
|
|
* response and return what we have so far. If there are no
|
|
|
|
* entries and the packet was short, then return -EIO. If there
|
|
|
|
* are valid entries in the response, return them and pretend that
|
|
|
|
* the call was successful, but incomplete. The caller can retry the
|
|
|
|
* readdir starting at the last cookie.
|
|
|
|
*/
|
2008-05-02 22:42:44 +02:00
|
|
|
dprintk("%s: short packet at entry %d\n", __func__, nr);
|
2005-04-17 00:20:36 +02:00
|
|
|
entry[0] = entry[1] = 0;
|
2008-02-22 20:50:01 +01:00
|
|
|
if (nr)
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
err_unmap:
|
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
|
|
|
return -errno_NFSERR_IO;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req)
|
|
|
|
{
|
|
|
|
struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
|
|
|
|
struct kvec *iov = rcvbuf->head;
|
2007-10-26 19:32:03 +02:00
|
|
|
size_t hdrlen;
|
|
|
|
u32 len, recvd;
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
char *kaddr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_READLINK);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
/* Convert length of symlink */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(len);
|
|
|
|
if (len >= rcvbuf->page_len || len <= 0) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("nfs: server returned giant symlink!\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
return -ENAMETOOLONG;
|
|
|
|
}
|
|
|
|
hdrlen = (char *) xdr->p - (char *) iov->iov_base;
|
|
|
|
recvd = req->rq_rcv_buf.len - hdrlen;
|
|
|
|
if (recvd < len) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("NFS: server cheating in readlink reply: "
|
2005-04-17 00:20:36 +02:00
|
|
|
"count %u > recvd %u\n", len, recvd);
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
xdr_read_pages(xdr, len);
|
|
|
|
/*
|
|
|
|
* The XDR encode routine has set things up so that
|
|
|
|
* the link text will be copied directly into the
|
|
|
|
* buffer. We just have to do overflow-checking,
|
|
|
|
* and and null-terminate the text (the VFS expects
|
|
|
|
* null-termination).
|
|
|
|
*/
|
|
|
|
kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
|
|
|
|
kaddr[len+rcvbuf->page_base] = '\0';
|
|
|
|
kunmap_atomic(kaddr, KM_USER0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_remove(struct xdr_stream *xdr, struct nfs4_change_info *cinfo)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_REMOVE);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_change_info(xdr, cinfo);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_rename(struct xdr_stream *xdr, struct nfs4_change_info *old_cinfo,
|
|
|
|
struct nfs4_change_info *new_cinfo)
|
|
|
|
{
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_RENAME);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_change_info(xdr, old_cinfo)))
|
|
|
|
goto out;
|
|
|
|
status = decode_change_info(xdr, new_cinfo);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_renew(struct xdr_stream *xdr)
|
|
|
|
{
|
|
|
|
return decode_op_hdr(xdr, OP_RENEW);
|
|
|
|
}
|
|
|
|
|
2005-10-28 04:12:40 +02:00
|
|
|
static int
|
|
|
|
decode_restorefh(struct xdr_stream *xdr)
|
|
|
|
{
|
|
|
|
return decode_op_hdr(xdr, OP_RESTOREFH);
|
|
|
|
}
|
|
|
|
|
2005-06-22 19:16:22 +02:00
|
|
|
static int decode_getacl(struct xdr_stream *xdr, struct rpc_rqst *req,
|
|
|
|
size_t *acl_len)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *savep;
|
2005-06-22 19:16:22 +02:00
|
|
|
uint32_t attrlen,
|
|
|
|
bitmap[2] = {0};
|
|
|
|
struct kvec *iov = req->rq_rcv_buf.head;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
*acl_len = 0;
|
|
|
|
if ((status = decode_op_hdr(xdr, OP_GETATTR)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_attr_bitmap(xdr, bitmap)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_attr_length(xdr, &attrlen, &savep)) != 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (unlikely(bitmap[0] & (FATTR4_WORD0_ACL - 1U)))
|
|
|
|
return -EIO;
|
|
|
|
if (likely(bitmap[0] & FATTR4_WORD0_ACL)) {
|
2007-10-26 19:32:03 +02:00
|
|
|
size_t hdrlen;
|
|
|
|
u32 recvd;
|
2005-06-22 19:16:22 +02:00
|
|
|
|
|
|
|
/* We ignore &savep and don't do consistency checks on
|
|
|
|
* the attr length. Let userspace figure it out.... */
|
|
|
|
hdrlen = (u8 *)xdr->p - (u8 *)iov->iov_base;
|
|
|
|
recvd = req->rq_rcv_buf.len - hdrlen;
|
|
|
|
if (attrlen > recvd) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("NFS: server cheating in getattr"
|
2005-06-22 19:16:22 +02:00
|
|
|
" acl reply: attrlen %u > recvd %u\n",
|
|
|
|
attrlen, recvd);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2006-05-30 22:28:58 +02:00
|
|
|
xdr_read_pages(xdr, attrlen);
|
2005-06-22 19:16:22 +02:00
|
|
|
*acl_len = attrlen;
|
2005-10-13 22:54:27 +02:00
|
|
|
} else
|
|
|
|
status = -EOPNOTSUPP;
|
2005-06-22 19:16:22 +02:00
|
|
|
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int
|
|
|
|
decode_savefh(struct xdr_stream *xdr)
|
|
|
|
{
|
|
|
|
return decode_op_hdr(xdr, OP_SAVEFH);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_setattr(struct xdr_stream *xdr, struct nfs_setattrres *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t bmlen;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_SETATTR);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(bmlen);
|
|
|
|
READ_BUF(bmlen << 2);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-23 02:06:08 +02:00
|
|
|
static int decode_setclientid(struct xdr_stream *xdr, struct nfs_client *clp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
uint32_t opnum;
|
|
|
|
int32_t nfserr;
|
|
|
|
|
|
|
|
READ_BUF(8);
|
|
|
|
READ32(opnum);
|
|
|
|
if (opnum != OP_SETCLIENTID) {
|
2007-09-12 00:01:10 +02:00
|
|
|
dprintk("nfs: decode_setclientid: Server returned operation"
|
2008-12-23 22:06:15 +01:00
|
|
|
" %d\n", opnum);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
READ32(nfserr);
|
|
|
|
if (nfserr == NFS_OK) {
|
2007-05-14 22:50:45 +02:00
|
|
|
READ_BUF(8 + NFS4_VERIFIER_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
READ64(clp->cl_clientid);
|
2007-05-14 22:50:45 +02:00
|
|
|
COPYMEM(clp->cl_confirm.data, NFS4_VERIFIER_SIZE);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else if (nfserr == NFSERR_CLID_INUSE) {
|
|
|
|
uint32_t len;
|
|
|
|
|
|
|
|
/* skip netid string */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(len);
|
|
|
|
READ_BUF(len);
|
|
|
|
|
|
|
|
/* skip uaddr string */
|
|
|
|
READ_BUF(4);
|
|
|
|
READ32(len);
|
|
|
|
READ_BUF(len);
|
|
|
|
return -NFSERR_CLID_INUSE;
|
|
|
|
} else
|
2008-03-31 16:39:06 +02:00
|
|
|
return nfs4_stat_to_errno(nfserr);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_setclientid_confirm(struct xdr_stream *xdr)
|
|
|
|
{
|
|
|
|
return decode_op_hdr(xdr, OP_SETCLIENTID_CONFIRM);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_write(struct xdr_stream *xdr, struct nfs_writeres *res)
|
|
|
|
{
|
2006-10-20 08:28:48 +02:00
|
|
|
__be32 *p;
|
2005-04-17 00:20:36 +02:00
|
|
|
int status;
|
|
|
|
|
|
|
|
status = decode_op_hdr(xdr, OP_WRITE);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
READ_BUF(16);
|
|
|
|
READ32(res->count);
|
|
|
|
READ32(res->verf->committed);
|
|
|
|
COPYMEM(res->verf->verifier, 8);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int decode_delegreturn(struct xdr_stream *xdr)
|
|
|
|
{
|
|
|
|
return decode_op_hdr(xdr, OP_DELEGRETURN);
|
|
|
|
}
|
|
|
|
|
2008-12-23 22:06:16 +01:00
|
|
|
/*
|
|
|
|
* END OF "GENERIC" DECODE ROUTINES.
|
|
|
|
*/
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Decode OPEN_DOWNGRADE response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_open_downgrade(struct rpc_rqst *rqstp, __be32 *p, struct nfs_closeres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_open_downgrade(&xdr, res);
|
2005-10-28 04:12:41 +02:00
|
|
|
if (status != 0)
|
|
|
|
goto out;
|
|
|
|
decode_getfattr(&xdr, res->fattr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2008-12-23 22:06:15 +01:00
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode ACCESS response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_access(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_accessres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
|
|
|
|
goto out;
|
2007-08-10 23:45:11 +02:00
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status != 0)
|
|
|
|
goto out;
|
|
|
|
status = decode_access(&xdr, res);
|
|
|
|
if (status != 0)
|
|
|
|
goto out;
|
|
|
|
decode_getfattr(&xdr, res->fattr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode LOOKUP response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_lookup(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_lookup_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_putfh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_lookup(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_getfh(&xdr, res->fh)) != 0)
|
|
|
|
goto out;
|
|
|
|
status = decode_getfattr(&xdr, res->fattr, res->server);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode LOOKUP_ROOT response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_lookup_root(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_lookup_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_putrootfh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_getfh(&xdr, res->fh)) == 0)
|
|
|
|
status = decode_getfattr(&xdr, res->fattr, res->server);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode REMOVE response
|
|
|
|
*/
|
2007-07-14 21:39:57 +02:00
|
|
|
static int nfs4_xdr_dec_remove(struct rpc_rqst *rqstp, __be32 *p, struct nfs_removeres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
|
|
|
|
goto out;
|
2005-10-28 04:12:44 +02:00
|
|
|
if ((status = decode_putfh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_remove(&xdr, &res->cinfo)) != 0)
|
|
|
|
goto out;
|
2007-07-14 21:39:57 +02:00
|
|
|
decode_getfattr(&xdr, &res->dir_attr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode RENAME response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_rename(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_rename_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_putfh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_savefh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_putfh(&xdr)) != 0)
|
|
|
|
goto out;
|
2005-10-28 04:12:43 +02:00
|
|
|
if ((status = decode_rename(&xdr, &res->old_cinfo, &res->new_cinfo)) != 0)
|
|
|
|
goto out;
|
|
|
|
/* Current FH is target directory */
|
|
|
|
if (decode_getfattr(&xdr, res->new_fattr, res->server) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_restorefh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
decode_getfattr(&xdr, res->old_fattr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode LINK response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_link(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_link_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_putfh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_savefh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_putfh(&xdr)) != 0)
|
|
|
|
goto out;
|
2005-10-28 04:12:42 +02:00
|
|
|
if ((status = decode_link(&xdr, &res->cinfo)) != 0)
|
|
|
|
goto out;
|
|
|
|
/*
|
|
|
|
* Note order: OP_LINK leaves the directory as the current
|
|
|
|
* filehandle.
|
|
|
|
*/
|
|
|
|
if (decode_getfattr(&xdr, res->dir_attr, res->server) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_restorefh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
decode_getfattr(&xdr, res->fattr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode CREATE response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_create(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_create_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_putfh(&xdr)) != 0)
|
|
|
|
goto out;
|
2005-10-28 04:12:40 +02:00
|
|
|
if ((status = decode_savefh(&xdr)) != 0)
|
|
|
|
goto out;
|
2005-04-17 00:20:36 +02:00
|
|
|
if ((status = decode_create(&xdr,&res->dir_cinfo)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_getfh(&xdr, res->fh)) != 0)
|
|
|
|
goto out;
|
2005-10-28 04:12:40 +02:00
|
|
|
if (decode_getfattr(&xdr, res->fattr, res->server) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_restorefh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
decode_getfattr(&xdr, res->dir_fattr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode SYMLINK response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_symlink(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_create_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
return nfs4_xdr_dec_create(rqstp, p, res);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode GETATTR response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_getattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_getattr_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_getfattr(&xdr, res->fattr, res->server);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-06-22 19:16:22 +02:00
|
|
|
/*
|
|
|
|
* Encode an SETACL request
|
|
|
|
*/
|
|
|
|
static int
|
2006-10-20 08:28:48 +02:00
|
|
|
nfs4_xdr_enc_setacl(struct rpc_rqst *req, __be32 *p, struct nfs_setaclargs *args)
|
2005-06-22 19:16:22 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr = {
|
2008-12-23 22:06:17 +01:00
|
|
|
.nops = 0,
|
2008-12-23 22:06:15 +01:00
|
|
|
};
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_encode(&xdr, &req->rq_snd_buf, p);
|
|
|
|
encode_compound_hdr(&xdr, &hdr);
|
2008-12-23 22:06:18 +01:00
|
|
|
encode_putfh(&xdr, args->fh, &hdr);
|
2008-12-23 22:06:17 +01:00
|
|
|
status = encode_setacl(&xdr, args, &hdr);
|
|
|
|
encode_nops(&hdr);
|
2008-12-23 22:06:15 +01:00
|
|
|
return status;
|
2005-06-22 19:16:22 +02:00
|
|
|
}
|
2008-12-23 22:06:15 +01:00
|
|
|
|
2005-06-22 19:16:22 +02:00
|
|
|
/*
|
|
|
|
* Decode SETACL response
|
|
|
|
*/
|
|
|
|
static int
|
2006-10-20 08:28:48 +02:00
|
|
|
nfs4_xdr_dec_setacl(struct rpc_rqst *rqstp, __be32 *p, void *res)
|
2005-06-22 19:16:22 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_setattr(&xdr, res);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-06-22 19:16:22 +02:00
|
|
|
/*
|
|
|
|
* Decode GETACL response
|
|
|
|
*/
|
|
|
|
static int
|
2006-10-20 08:28:48 +02:00
|
|
|
nfs4_xdr_dec_getacl(struct rpc_rqst *rqstp, __be32 *p, size_t *acl_len)
|
2005-06-22 19:16:22 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_getacl(&xdr, rqstp, acl_len);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Decode CLOSE response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_close(struct rpc_rqst *rqstp, __be32 *p, struct nfs_closeres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_close(&xdr, res);
|
2005-10-28 04:12:41 +02:00
|
|
|
if (status != 0)
|
|
|
|
goto out;
|
|
|
|
/*
|
|
|
|
* Note: Server may do delete on close for this file
|
|
|
|
* in which case the getattr call will fail with
|
|
|
|
* an ESTALE error. Shouldn't be a problem,
|
|
|
|
* though, since fattr->valid will remain unset.
|
|
|
|
*/
|
|
|
|
decode_getfattr(&xdr, res->fattr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2008-12-23 22:06:15 +01:00
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode OPEN response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_open(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_savefh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_open(&xdr, res);
|
2005-10-28 04:12:40 +02:00
|
|
|
if (status)
|
|
|
|
goto out;
|
2007-07-18 03:52:41 +02:00
|
|
|
if (decode_getfh(&xdr, &res->fh) != 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
goto out;
|
2005-10-28 04:12:40 +02:00
|
|
|
if (decode_getfattr(&xdr, res->f_attr, res->server) != 0)
|
|
|
|
goto out;
|
2007-07-18 03:52:37 +02:00
|
|
|
if (decode_restorefh(&xdr) != 0)
|
2005-10-28 04:12:40 +02:00
|
|
|
goto out;
|
|
|
|
decode_getfattr(&xdr, res->dir_attr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2008-12-23 22:06:15 +01:00
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode OPEN_CONFIRM response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_open_confirm(struct rpc_rqst *rqstp, __be32 *p, struct nfs_open_confirmres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_open_confirm(&xdr, res);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2008-12-23 22:06:15 +01:00
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode OPEN response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_open_noattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_openres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_open(&xdr, res);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2006-01-03 09:55:15 +01:00
|
|
|
decode_getfattr(&xdr, res->f_attr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2008-12-23 22:06:15 +01:00
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode SETATTR response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_setattr(struct rpc_rqst *rqstp, __be32 *p, struct nfs_setattrres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-12-23 22:06:15 +01:00
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_setattr(&xdr, res);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
2009-03-11 19:10:23 +01:00
|
|
|
decode_getfattr(&xdr, res->fattr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
2008-12-23 22:06:15 +01:00
|
|
|
return status;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode LOCK response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_lock(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lock_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_lock(&xdr, res);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode LOCKT response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_lockt(struct rpc_rqst *rqstp, __be32 *p, struct nfs_lockt_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_lockt(&xdr, res);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode LOCKU response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_locku(struct rpc_rqst *rqstp, __be32 *p, struct nfs_locku_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_locku(&xdr, res);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode READLINK response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_readlink(struct rpc_rqst *rqstp, __be32 *p, void *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_readlink(&xdr, rqstp);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode READDIR response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_readdir(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_readdir_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_readdir(&xdr, rqstp, res);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode Read response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_read(struct rpc_rqst *rqstp, __be32 *p, struct nfs_readres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_read(&xdr, rqstp, res);
|
|
|
|
if (!status)
|
|
|
|
status = res->count;
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode WRITE response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_write(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writeres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_write(&xdr, res);
|
2005-10-28 04:12:44 +02:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
decode_getfattr(&xdr, res->fattr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!status)
|
|
|
|
status = res->count;
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode COMMIT response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_commit(struct rpc_rqst *rqstp, __be32 *p, struct nfs_writeres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
status = decode_commit(&xdr, res);
|
2005-10-28 04:12:44 +02:00
|
|
|
if (status)
|
|
|
|
goto out;
|
|
|
|
decode_getfattr(&xdr, res->fattr, res->server);
|
2005-04-17 00:20:36 +02:00
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* FSINFO request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_fsinfo(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *fsinfo)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_fsinfo(&xdr, fsinfo);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* PATHCONF request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_pathconf(struct rpc_rqst *req, __be32 *p, struct nfs_pathconf *pathconf)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_pathconf(&xdr, pathconf);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* STATFS request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_statfs(struct rpc_rqst *req, __be32 *p, struct nfs_fsstat *fsstat)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_statfs(&xdr, fsstat);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GETATTR_BITMAP request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_server_caps(struct rpc_rqst *req, __be32 *p, struct nfs4_server_caps_res *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
|
|
|
|
if ((status = decode_compound_hdr(&xdr, &hdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_putfh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
status = decode_server_caps(&xdr, res);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode RENEW response
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_renew(struct rpc_rqst *rqstp, __be32 *p, void *dummy)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_renew(&xdr);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* a SETCLIENTID request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_setclientid(struct rpc_rqst *req, __be32 *p,
|
2006-08-23 02:06:08 +02:00
|
|
|
struct nfs_client *clp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_setclientid(&xdr, clp);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* a SETCLIENTID_CONFIRM request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_setclientid_confirm(struct rpc_rqst *req, __be32 *p, struct nfs_fsinfo *fsinfo)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_setclientid_confirm(&xdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_putrootfh(&xdr);
|
|
|
|
if (!status)
|
|
|
|
status = decode_fsinfo(&xdr, fsinfo);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DELEGRETURN request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_delegreturn(struct rpc_rqst *rqstp, __be32 *p, struct nfs4_delegreturnres *res)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &rqstp->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
2006-01-03 09:55:38 +01:00
|
|
|
if (status != 0)
|
|
|
|
goto out;
|
|
|
|
status = decode_putfh(&xdr);
|
|
|
|
if (status != 0)
|
|
|
|
goto out;
|
|
|
|
status = decode_delegreturn(&xdr);
|
|
|
|
decode_getfattr(&xdr, res->fattr, res->server);
|
|
|
|
out:
|
2005-04-17 00:20:36 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-06-09 15:34:22 +02:00
|
|
|
/*
|
|
|
|
* FS_LOCATIONS request
|
|
|
|
*/
|
2006-10-20 08:28:48 +02:00
|
|
|
static int nfs4_xdr_dec_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs4_fs_locations *res)
|
2006-06-09 15:34:22 +02:00
|
|
|
{
|
|
|
|
struct xdr_stream xdr;
|
|
|
|
struct compound_hdr hdr;
|
|
|
|
int status;
|
|
|
|
|
|
|
|
xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
|
|
|
|
status = decode_compound_hdr(&xdr, &hdr);
|
|
|
|
if (status != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_putfh(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
if ((status = decode_lookup(&xdr)) != 0)
|
|
|
|
goto out;
|
|
|
|
xdr_enter_page(&xdr, PAGE_SIZE);
|
|
|
|
status = decode_getfattr(&xdr, &res->fattr, res->server);
|
|
|
|
out:
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2006-10-20 08:28:49 +02:00
|
|
|
__be32 *nfs4_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
uint32_t bitmap[2] = {0};
|
|
|
|
uint32_t len;
|
|
|
|
|
|
|
|
if (!*p++) {
|
|
|
|
if (!*p)
|
|
|
|
return ERR_PTR(-EAGAIN);
|
|
|
|
entry->eof = 1;
|
|
|
|
return ERR_PTR(-EBADCOOKIE);
|
|
|
|
}
|
|
|
|
|
|
|
|
entry->prev_cookie = entry->cookie;
|
|
|
|
p = xdr_decode_hyper(p, &entry->cookie);
|
|
|
|
entry->len = ntohl(*p++);
|
|
|
|
entry->name = (const char *) p;
|
|
|
|
p += XDR_QUADLEN(entry->len);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In case the server doesn't return an inode number,
|
|
|
|
* we fake one here. (We don't use inode number 0,
|
|
|
|
* since glibc seems to choke on it...)
|
|
|
|
*/
|
|
|
|
entry->ino = 1;
|
|
|
|
|
|
|
|
len = ntohl(*p++); /* bitmap length */
|
|
|
|
if (len-- > 0) {
|
|
|
|
bitmap[0] = ntohl(*p++);
|
|
|
|
if (len-- > 0) {
|
|
|
|
bitmap[1] = ntohl(*p++);
|
|
|
|
p += len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
len = XDR_QUADLEN(ntohl(*p++)); /* attribute buffer length */
|
|
|
|
if (len > 0) {
|
2005-06-22 19:16:39 +02:00
|
|
|
if (bitmap[0] & FATTR4_WORD0_RDATTR_ERROR) {
|
|
|
|
bitmap[0] &= ~FATTR4_WORD0_RDATTR_ERROR;
|
|
|
|
/* Ignore the return value of rdattr_error for now */
|
|
|
|
p++;
|
|
|
|
len--;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
if (bitmap[0] == 0 && bitmap[1] == FATTR4_WORD1_MOUNTED_ON_FILEID)
|
|
|
|
xdr_decode_hyper(p, &entry->ino);
|
|
|
|
else if (bitmap[0] == FATTR4_WORD0_FILEID)
|
|
|
|
xdr_decode_hyper(p, &entry->ino);
|
|
|
|
p += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
entry->eof = !p[0] && p[1];
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to translate between nfs status return values and
|
|
|
|
* the local errno values which may not be the same.
|
|
|
|
*/
|
|
|
|
static struct {
|
|
|
|
int stat;
|
|
|
|
int errno;
|
|
|
|
} nfs_errtbl[] = {
|
|
|
|
{ NFS4_OK, 0 },
|
2008-03-31 16:39:06 +02:00
|
|
|
{ NFS4ERR_PERM, -EPERM },
|
|
|
|
{ NFS4ERR_NOENT, -ENOENT },
|
|
|
|
{ NFS4ERR_IO, -errno_NFSERR_IO},
|
|
|
|
{ NFS4ERR_NXIO, -ENXIO },
|
|
|
|
{ NFS4ERR_ACCESS, -EACCES },
|
|
|
|
{ NFS4ERR_EXIST, -EEXIST },
|
|
|
|
{ NFS4ERR_XDEV, -EXDEV },
|
|
|
|
{ NFS4ERR_NOTDIR, -ENOTDIR },
|
|
|
|
{ NFS4ERR_ISDIR, -EISDIR },
|
|
|
|
{ NFS4ERR_INVAL, -EINVAL },
|
|
|
|
{ NFS4ERR_FBIG, -EFBIG },
|
|
|
|
{ NFS4ERR_NOSPC, -ENOSPC },
|
|
|
|
{ NFS4ERR_ROFS, -EROFS },
|
|
|
|
{ NFS4ERR_MLINK, -EMLINK },
|
|
|
|
{ NFS4ERR_NAMETOOLONG, -ENAMETOOLONG },
|
|
|
|
{ NFS4ERR_NOTEMPTY, -ENOTEMPTY },
|
|
|
|
{ NFS4ERR_DQUOT, -EDQUOT },
|
|
|
|
{ NFS4ERR_STALE, -ESTALE },
|
|
|
|
{ NFS4ERR_BADHANDLE, -EBADHANDLE },
|
|
|
|
{ NFS4ERR_BADOWNER, -EINVAL },
|
|
|
|
{ NFS4ERR_BADNAME, -EINVAL },
|
|
|
|
{ NFS4ERR_BAD_COOKIE, -EBADCOOKIE },
|
|
|
|
{ NFS4ERR_NOTSUPP, -ENOTSUPP },
|
|
|
|
{ NFS4ERR_TOOSMALL, -ETOOSMALL },
|
|
|
|
{ NFS4ERR_SERVERFAULT, -ESERVERFAULT },
|
|
|
|
{ NFS4ERR_BADTYPE, -EBADTYPE },
|
|
|
|
{ NFS4ERR_LOCKED, -EAGAIN },
|
|
|
|
{ NFS4ERR_RESOURCE, -EREMOTEIO },
|
|
|
|
{ NFS4ERR_SYMLINK, -ELOOP },
|
|
|
|
{ NFS4ERR_OP_ILLEGAL, -EOPNOTSUPP },
|
|
|
|
{ NFS4ERR_DEADLOCK, -EDEADLK },
|
|
|
|
{ NFS4ERR_WRONGSEC, -EPERM }, /* FIXME: this needs
|
2005-04-17 00:20:36 +02:00
|
|
|
* to be handled by a
|
|
|
|
* middle-layer.
|
|
|
|
*/
|
2008-03-31 16:39:06 +02:00
|
|
|
{ -1, -EIO }
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert an NFS error code to a local one.
|
|
|
|
* This one is used jointly by NFSv2 and NFSv3.
|
|
|
|
*/
|
|
|
|
static int
|
2006-08-23 02:06:08 +02:00
|
|
|
nfs4_stat_to_errno(int stat)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; nfs_errtbl[i].stat != -1; i++) {
|
|
|
|
if (nfs_errtbl[i].stat == stat)
|
|
|
|
return nfs_errtbl[i].errno;
|
|
|
|
}
|
|
|
|
if (stat <= 10000 || stat > 10100) {
|
|
|
|
/* The server is looney tunes. */
|
2008-03-31 16:39:06 +02:00
|
|
|
return -ESERVERFAULT;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
/* If we cannot translate the error, the recovery routines should
|
|
|
|
* handle it.
|
|
|
|
* Note: remaining NFSv4 error codes have values > 10000, so should
|
|
|
|
* not conflict with native Linux error codes.
|
|
|
|
*/
|
2008-03-31 16:39:06 +02:00
|
|
|
return -stat;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#define PROC(proc, argtype, restype) \
|
|
|
|
[NFSPROC4_CLNT_##proc] = { \
|
|
|
|
.p_proc = NFSPROC4_COMPOUND, \
|
|
|
|
.p_encode = (kxdrproc_t) nfs4_xdr_##argtype, \
|
|
|
|
.p_decode = (kxdrproc_t) nfs4_xdr_##restype, \
|
2007-03-29 22:47:53 +02:00
|
|
|
.p_arglen = NFS4_##argtype##_sz, \
|
|
|
|
.p_replen = NFS4_##restype##_sz, \
|
2006-03-20 19:44:22 +01:00
|
|
|
.p_statidx = NFSPROC4_CLNT_##proc, \
|
|
|
|
.p_name = #proc, \
|
2008-12-23 22:06:15 +01:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
struct rpc_procinfo nfs4_procedures[] = {
|
|
|
|
PROC(READ, enc_read, dec_read),
|
|
|
|
PROC(WRITE, enc_write, dec_write),
|
|
|
|
PROC(COMMIT, enc_commit, dec_commit),
|
|
|
|
PROC(OPEN, enc_open, dec_open),
|
|
|
|
PROC(OPEN_CONFIRM, enc_open_confirm, dec_open_confirm),
|
|
|
|
PROC(OPEN_NOATTR, enc_open_noattr, dec_open_noattr),
|
|
|
|
PROC(OPEN_DOWNGRADE, enc_open_downgrade, dec_open_downgrade),
|
|
|
|
PROC(CLOSE, enc_close, dec_close),
|
|
|
|
PROC(SETATTR, enc_setattr, dec_setattr),
|
|
|
|
PROC(FSINFO, enc_fsinfo, dec_fsinfo),
|
|
|
|
PROC(RENEW, enc_renew, dec_renew),
|
|
|
|
PROC(SETCLIENTID, enc_setclientid, dec_setclientid),
|
|
|
|
PROC(SETCLIENTID_CONFIRM, enc_setclientid_confirm, dec_setclientid_confirm),
|
|
|
|
PROC(LOCK, enc_lock, dec_lock),
|
|
|
|
PROC(LOCKT, enc_lockt, dec_lockt),
|
|
|
|
PROC(LOCKU, enc_locku, dec_locku),
|
|
|
|
PROC(ACCESS, enc_access, dec_access),
|
|
|
|
PROC(GETATTR, enc_getattr, dec_getattr),
|
|
|
|
PROC(LOOKUP, enc_lookup, dec_lookup),
|
|
|
|
PROC(LOOKUP_ROOT, enc_lookup_root, dec_lookup_root),
|
|
|
|
PROC(REMOVE, enc_remove, dec_remove),
|
|
|
|
PROC(RENAME, enc_rename, dec_rename),
|
|
|
|
PROC(LINK, enc_link, dec_link),
|
|
|
|
PROC(SYMLINK, enc_symlink, dec_symlink),
|
|
|
|
PROC(CREATE, enc_create, dec_create),
|
|
|
|
PROC(PATHCONF, enc_pathconf, dec_pathconf),
|
|
|
|
PROC(STATFS, enc_statfs, dec_statfs),
|
|
|
|
PROC(READLINK, enc_readlink, dec_readlink),
|
|
|
|
PROC(READDIR, enc_readdir, dec_readdir),
|
|
|
|
PROC(SERVER_CAPS, enc_server_caps, dec_server_caps),
|
|
|
|
PROC(DELEGRETURN, enc_delegreturn, dec_delegreturn),
|
2005-06-22 19:16:22 +02:00
|
|
|
PROC(GETACL, enc_getacl, dec_getacl),
|
2005-06-22 19:16:22 +02:00
|
|
|
PROC(SETACL, enc_setacl, dec_setacl),
|
2006-06-09 15:34:22 +02:00
|
|
|
PROC(FS_LOCATIONS, enc_fs_locations, dec_fs_locations),
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
struct rpc_version nfs_version4 = {
|
|
|
|
.number = 4,
|
2006-03-24 12:15:34 +01:00
|
|
|
.nrprocs = ARRAY_SIZE(nfs4_procedures),
|
2005-04-17 00:20:36 +02:00
|
|
|
.procs = nfs4_procedures
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* c-basic-offset: 8
|
|
|
|
* End:
|
|
|
|
*/
|