LCOV - code coverage report
Current view: top level - include/linux - nfs_xdr.h (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 2 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 0 -
Branches: 0 8 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _LINUX_NFS_XDR_H
       3                 :            : #define _LINUX_NFS_XDR_H
       4                 :            : 
       5                 :            : #include <linux/nfsacl.h>
       6                 :            : #include <linux/sunrpc/gss_api.h>
       7                 :            : 
       8                 :            : /*
       9                 :            :  * To change the maximum rsize and wsize supported by the NFS client, adjust
      10                 :            :  * NFS_MAX_FILE_IO_SIZE.  64KB is a typical maximum, but some servers can
      11                 :            :  * support a megabyte or more.  The default is left at 4096 bytes, which is
      12                 :            :  * reasonable for NFS over UDP.
      13                 :            :  */
      14                 :            : #define NFS_MAX_FILE_IO_SIZE    (1048576U)
      15                 :            : #define NFS_DEF_FILE_IO_SIZE    (4096U)
      16                 :            : #define NFS_MIN_FILE_IO_SIZE    (1024U)
      17                 :            : 
      18                 :            : struct nfs4_string {
      19                 :            :         unsigned int len;
      20                 :            :         char *data;
      21                 :            : };
      22                 :            : 
      23                 :            : struct nfs_fsid {
      24                 :            :         uint64_t                major;
      25                 :            :         uint64_t                minor;
      26                 :            : };
      27                 :            : 
      28                 :            : /*
      29                 :            :  * Helper for checking equality between 2 fsids.
      30                 :            :  */
      31                 :            : static inline int nfs_fsid_equal(const struct nfs_fsid *a, const struct nfs_fsid *b)
      32                 :            : {
      33   [ #  #  #  #  :          0 :         return a->major == b->major && a->minor == b->minor;
             #  #  #  # ]
      34                 :            : }
      35                 :            : 
      36                 :            : struct nfs4_threshold {
      37                 :            :         __u32   bm;
      38                 :            :         __u32   l_type;
      39                 :            :         __u64   rd_sz;
      40                 :            :         __u64   wr_sz;
      41                 :            :         __u64   rd_io_sz;
      42                 :            :         __u64   wr_io_sz;
      43                 :            : };
      44                 :            : 
      45                 :            : struct nfs_fattr {
      46                 :            :         unsigned int            valid;          /* which fields are valid */
      47                 :            :         umode_t                 mode;
      48                 :            :         __u32                   nlink;
      49                 :            :         kuid_t                  uid;
      50                 :            :         kgid_t                  gid;
      51                 :            :         dev_t                   rdev;
      52                 :            :         __u64                   size;
      53                 :            :         union {
      54                 :            :                 struct {
      55                 :            :                         __u32   blocksize;
      56                 :            :                         __u32   blocks;
      57                 :            :                 } nfs2;
      58                 :            :                 struct {
      59                 :            :                         __u64   used;
      60                 :            :                 } nfs3;
      61                 :            :         } du;
      62                 :            :         struct nfs_fsid         fsid;
      63                 :            :         __u64                   fileid;
      64                 :            :         __u64                   mounted_on_fileid;
      65                 :            :         struct timespec         atime;
      66                 :            :         struct timespec         mtime;
      67                 :            :         struct timespec         ctime;
      68                 :            :         __u64                   change_attr;    /* NFSv4 change attribute */
      69                 :            :         __u64                   pre_change_attr;/* pre-op NFSv4 change attribute */
      70                 :            :         __u64                   pre_size;       /* pre_op_attr.size       */
      71                 :            :         struct timespec         pre_mtime;      /* pre_op_attr.mtime      */
      72                 :            :         struct timespec         pre_ctime;      /* pre_op_attr.ctime      */
      73                 :            :         unsigned long           time_start;
      74                 :            :         unsigned long           gencount;
      75                 :            :         struct nfs4_string      *owner_name;
      76                 :            :         struct nfs4_string      *group_name;
      77                 :            :         struct nfs4_threshold   *mdsthreshold;  /* pNFS threshold hints */
      78                 :            : };
      79                 :            : 
      80                 :            : #define NFS_ATTR_FATTR_TYPE             (1U << 0)
      81                 :            : #define NFS_ATTR_FATTR_MODE             (1U << 1)
      82                 :            : #define NFS_ATTR_FATTR_NLINK            (1U << 2)
      83                 :            : #define NFS_ATTR_FATTR_OWNER            (1U << 3)
      84                 :            : #define NFS_ATTR_FATTR_GROUP            (1U << 4)
      85                 :            : #define NFS_ATTR_FATTR_RDEV             (1U << 5)
      86                 :            : #define NFS_ATTR_FATTR_SIZE             (1U << 6)
      87                 :            : #define NFS_ATTR_FATTR_PRESIZE          (1U << 7)
      88                 :            : #define NFS_ATTR_FATTR_BLOCKS_USED      (1U << 8)
      89                 :            : #define NFS_ATTR_FATTR_SPACE_USED       (1U << 9)
      90                 :            : #define NFS_ATTR_FATTR_FSID             (1U << 10)
      91                 :            : #define NFS_ATTR_FATTR_FILEID           (1U << 11)
      92                 :            : #define NFS_ATTR_FATTR_ATIME            (1U << 12)
      93                 :            : #define NFS_ATTR_FATTR_MTIME            (1U << 13)
      94                 :            : #define NFS_ATTR_FATTR_CTIME            (1U << 14)
      95                 :            : #define NFS_ATTR_FATTR_PREMTIME         (1U << 15)
      96                 :            : #define NFS_ATTR_FATTR_PRECTIME         (1U << 16)
      97                 :            : #define NFS_ATTR_FATTR_CHANGE           (1U << 17)
      98                 :            : #define NFS_ATTR_FATTR_PRECHANGE        (1U << 18)
      99                 :            : #define NFS_ATTR_FATTR_V4_LOCATIONS     (1U << 19)
     100                 :            : #define NFS_ATTR_FATTR_V4_REFERRAL      (1U << 20)
     101                 :            : #define NFS_ATTR_FATTR_MOUNTPOINT       (1U << 21)
     102                 :            : #define NFS_ATTR_FATTR_MOUNTED_ON_FILEID (1U << 22)
     103                 :            : #define NFS_ATTR_FATTR_OWNER_NAME       (1U << 23)
     104                 :            : #define NFS_ATTR_FATTR_GROUP_NAME       (1U << 24)
     105                 :            : #define NFS_ATTR_FATTR_V4_SECURITY_LABEL (1U << 25)
     106                 :            : 
     107                 :            : #define NFS_ATTR_FATTR (NFS_ATTR_FATTR_TYPE \
     108                 :            :                 | NFS_ATTR_FATTR_MODE \
     109                 :            :                 | NFS_ATTR_FATTR_NLINK \
     110                 :            :                 | NFS_ATTR_FATTR_OWNER \
     111                 :            :                 | NFS_ATTR_FATTR_GROUP \
     112                 :            :                 | NFS_ATTR_FATTR_RDEV \
     113                 :            :                 | NFS_ATTR_FATTR_SIZE \
     114                 :            :                 | NFS_ATTR_FATTR_FSID \
     115                 :            :                 | NFS_ATTR_FATTR_FILEID \
     116                 :            :                 | NFS_ATTR_FATTR_ATIME \
     117                 :            :                 | NFS_ATTR_FATTR_MTIME \
     118                 :            :                 | NFS_ATTR_FATTR_CTIME \
     119                 :            :                 | NFS_ATTR_FATTR_CHANGE)
     120                 :            : #define NFS_ATTR_FATTR_V2 (NFS_ATTR_FATTR \
     121                 :            :                 | NFS_ATTR_FATTR_BLOCKS_USED)
     122                 :            : #define NFS_ATTR_FATTR_V3 (NFS_ATTR_FATTR \
     123                 :            :                 | NFS_ATTR_FATTR_SPACE_USED)
     124                 :            : #define NFS_ATTR_FATTR_V4 (NFS_ATTR_FATTR \
     125                 :            :                 | NFS_ATTR_FATTR_SPACE_USED \
     126                 :            :                 | NFS_ATTR_FATTR_V4_SECURITY_LABEL)
     127                 :            : 
     128                 :            : /*
     129                 :            :  * Maximal number of supported layout drivers.
     130                 :            :  */
     131                 :            : #define NFS_MAX_LAYOUT_TYPES 8
     132                 :            : 
     133                 :            : /*
     134                 :            :  * Info on the file system
     135                 :            :  */
     136                 :            : struct nfs_fsinfo {
     137                 :            :         struct nfs_fattr        *fattr; /* Post-op attributes */
     138                 :            :         __u32                   rtmax;  /* max.  read transfer size */
     139                 :            :         __u32                   rtpref; /* pref. read transfer size */
     140                 :            :         __u32                   rtmult; /* reads should be multiple of this */
     141                 :            :         __u32                   wtmax;  /* max.  write transfer size */
     142                 :            :         __u32                   wtpref; /* pref. write transfer size */
     143                 :            :         __u32                   wtmult; /* writes should be multiple of this */
     144                 :            :         __u32                   dtpref; /* pref. readdir transfer size */
     145                 :            :         __u64                   maxfilesize;
     146                 :            :         struct timespec         time_delta; /* server time granularity */
     147                 :            :         __u32                   lease_time; /* in seconds */
     148                 :            :         __u32                   nlayouttypes; /* number of layouttypes */
     149                 :            :         __u32                   layouttype[NFS_MAX_LAYOUT_TYPES]; /* supported pnfs layout driver */
     150                 :            :         __u32                   blksize; /* preferred pnfs io block size */
     151                 :            :         __u32                   clone_blksize; /* granularity of a CLONE operation */
     152                 :            : };
     153                 :            : 
     154                 :            : struct nfs_fsstat {
     155                 :            :         struct nfs_fattr        *fattr; /* Post-op attributes */
     156                 :            :         __u64                   tbytes; /* total size in bytes */
     157                 :            :         __u64                   fbytes; /* # of free bytes */
     158                 :            :         __u64                   abytes; /* # of bytes available to user */
     159                 :            :         __u64                   tfiles; /* # of files */
     160                 :            :         __u64                   ffiles; /* # of free files */
     161                 :            :         __u64                   afiles; /* # of files available to user */
     162                 :            : };
     163                 :            : 
     164                 :            : struct nfs2_fsstat {
     165                 :            :         __u32                   tsize;  /* Server transfer size */
     166                 :            :         __u32                   bsize;  /* Filesystem block size */
     167                 :            :         __u32                   blocks; /* No. of "bsize" blocks on filesystem */
     168                 :            :         __u32                   bfree;  /* No. of free "bsize" blocks */
     169                 :            :         __u32                   bavail; /* No. of available "bsize" blocks */
     170                 :            : };
     171                 :            : 
     172                 :            : struct nfs_pathconf {
     173                 :            :         struct nfs_fattr        *fattr; /* Post-op attributes */
     174                 :            :         __u32                   max_link; /* max # of hard links */
     175                 :            :         __u32                   max_namelen; /* max name length */
     176                 :            : };
     177                 :            : 
     178                 :            : struct nfs4_change_info {
     179                 :            :         u32                     atomic;
     180                 :            :         u64                     before;
     181                 :            :         u64                     after;
     182                 :            : };
     183                 :            : 
     184                 :            : struct nfs_seqid;
     185                 :            : 
     186                 :            : /* nfs41 sessions channel attributes */
     187                 :            : struct nfs4_channel_attrs {
     188                 :            :         u32                     max_rqst_sz;
     189                 :            :         u32                     max_resp_sz;
     190                 :            :         u32                     max_resp_sz_cached;
     191                 :            :         u32                     max_ops;
     192                 :            :         u32                     max_reqs;
     193                 :            : };
     194                 :            : 
     195                 :            : struct nfs4_slot;
     196                 :            : struct nfs4_sequence_args {
     197                 :            :         struct nfs4_slot        *sa_slot;
     198                 :            :         u8                      sa_cache_this : 1,
     199                 :            :                                 sa_privileged : 1;
     200                 :            : };
     201                 :            : 
     202                 :            : struct nfs4_sequence_res {
     203                 :            :         struct nfs4_slot        *sr_slot;       /* slot used to send request */
     204                 :            :         unsigned long           sr_timestamp;
     205                 :            :         int                     sr_status;      /* sequence operation status */
     206                 :            :         u32                     sr_status_flags;
     207                 :            :         u32                     sr_highest_slotid;
     208                 :            :         u32                     sr_target_highest_slotid;
     209                 :            : };
     210                 :            : 
     211                 :            : struct nfs4_get_lease_time_args {
     212                 :            :         struct nfs4_sequence_args       la_seq_args;
     213                 :            : };
     214                 :            : 
     215                 :            : struct nfs4_get_lease_time_res {
     216                 :            :         struct nfs4_sequence_res        lr_seq_res;
     217                 :            :         struct nfs_fsinfo              *lr_fsinfo;
     218                 :            : };
     219                 :            : 
     220                 :            : struct xdr_stream;
     221                 :            : struct nfs4_xdr_opaque_data;
     222                 :            : 
     223                 :            : struct nfs4_xdr_opaque_ops {
     224                 :            :         void (*encode)(struct xdr_stream *, const void *args,
     225                 :            :                         const struct nfs4_xdr_opaque_data *);
     226                 :            :         void (*free)(struct nfs4_xdr_opaque_data *);
     227                 :            : };
     228                 :            : 
     229                 :            : struct nfs4_xdr_opaque_data {
     230                 :            :         const struct nfs4_xdr_opaque_ops *ops;
     231                 :            :         void *data;
     232                 :            : };
     233                 :            : 
     234                 :            : #define PNFS_LAYOUT_MAXSIZE 4096
     235                 :            : 
     236                 :            : struct nfs4_layoutdriver_data {
     237                 :            :         struct page **pages;
     238                 :            :         __u32 pglen;
     239                 :            :         __u32 len;
     240                 :            : };
     241                 :            : 
     242                 :            : struct pnfs_layout_range {
     243                 :            :         u32 iomode;
     244                 :            :         u64 offset;
     245                 :            :         u64 length;
     246                 :            : };
     247                 :            : 
     248                 :            : struct nfs4_layoutget_args {
     249                 :            :         struct nfs4_sequence_args seq_args;
     250                 :            :         __u32 type;
     251                 :            :         struct pnfs_layout_range range;
     252                 :            :         __u64 minlength;
     253                 :            :         __u32 maxcount;
     254                 :            :         struct inode *inode;
     255                 :            :         struct nfs_open_context *ctx;
     256                 :            :         nfs4_stateid stateid;
     257                 :            :         struct nfs4_layoutdriver_data layout;
     258                 :            : };
     259                 :            : 
     260                 :            : struct nfs4_layoutget_res {
     261                 :            :         struct nfs4_sequence_res seq_res;
     262                 :            :         int status;
     263                 :            :         __u32 return_on_close;
     264                 :            :         struct pnfs_layout_range range;
     265                 :            :         __u32 type;
     266                 :            :         nfs4_stateid stateid;
     267                 :            :         struct nfs4_layoutdriver_data *layoutp;
     268                 :            : };
     269                 :            : 
     270                 :            : struct nfs4_layoutget {
     271                 :            :         struct nfs4_layoutget_args args;
     272                 :            :         struct nfs4_layoutget_res res;
     273                 :            :         const struct cred *cred;
     274                 :            :         gfp_t gfp_flags;
     275                 :            : };
     276                 :            : 
     277                 :            : struct nfs4_getdeviceinfo_args {
     278                 :            :         struct nfs4_sequence_args seq_args;
     279                 :            :         struct pnfs_device *pdev;
     280                 :            :         __u32 notify_types;
     281                 :            : };
     282                 :            : 
     283                 :            : struct nfs4_getdeviceinfo_res {
     284                 :            :         struct nfs4_sequence_res seq_res;
     285                 :            :         struct pnfs_device *pdev;
     286                 :            :         __u32 notification;
     287                 :            : };
     288                 :            : 
     289                 :            : struct nfs4_layoutcommit_args {
     290                 :            :         struct nfs4_sequence_args seq_args;
     291                 :            :         nfs4_stateid stateid;
     292                 :            :         __u64 lastbytewritten;
     293                 :            :         struct inode *inode;
     294                 :            :         const u32 *bitmask;
     295                 :            :         size_t layoutupdate_len;
     296                 :            :         struct page *layoutupdate_page;
     297                 :            :         struct page **layoutupdate_pages;
     298                 :            :         __be32 *start_p;
     299                 :            : };
     300                 :            : 
     301                 :            : struct nfs4_layoutcommit_res {
     302                 :            :         struct nfs4_sequence_res seq_res;
     303                 :            :         struct nfs_fattr *fattr;
     304                 :            :         const struct nfs_server *server;
     305                 :            :         int status;
     306                 :            : };
     307                 :            : 
     308                 :            : struct nfs4_layoutcommit_data {
     309                 :            :         struct rpc_task task;
     310                 :            :         struct nfs_fattr fattr;
     311                 :            :         struct list_head lseg_list;
     312                 :            :         const struct cred *cred;
     313                 :            :         struct inode *inode;
     314                 :            :         struct nfs4_layoutcommit_args args;
     315                 :            :         struct nfs4_layoutcommit_res res;
     316                 :            : };
     317                 :            : 
     318                 :            : struct nfs4_layoutreturn_args {
     319                 :            :         struct nfs4_sequence_args seq_args;
     320                 :            :         struct pnfs_layout_hdr *layout;
     321                 :            :         struct inode *inode;
     322                 :            :         struct pnfs_layout_range range;
     323                 :            :         nfs4_stateid stateid;
     324                 :            :         __u32   layout_type;
     325                 :            :         struct nfs4_xdr_opaque_data *ld_private;
     326                 :            : };
     327                 :            : 
     328                 :            : struct nfs4_layoutreturn_res {
     329                 :            :         struct nfs4_sequence_res seq_res;
     330                 :            :         u32 lrs_present;
     331                 :            :         nfs4_stateid stateid;
     332                 :            : };
     333                 :            : 
     334                 :            : struct nfs4_layoutreturn {
     335                 :            :         struct nfs4_layoutreturn_args args;
     336                 :            :         struct nfs4_layoutreturn_res res;
     337                 :            :         const struct cred *cred;
     338                 :            :         struct nfs_client *clp;
     339                 :            :         struct inode *inode;
     340                 :            :         int rpc_status;
     341                 :            :         struct nfs4_xdr_opaque_data ld_private;
     342                 :            : };
     343                 :            : 
     344                 :            : #define PNFS_LAYOUTSTATS_MAXSIZE 256
     345                 :            : 
     346                 :            : struct nfs42_layoutstat_args;
     347                 :            : struct nfs42_layoutstat_devinfo;
     348                 :            : typedef void (*layoutstats_encode_t)(struct xdr_stream *,
     349                 :            :                 struct nfs42_layoutstat_args *,
     350                 :            :                 struct nfs42_layoutstat_devinfo *);
     351                 :            : 
     352                 :            : /* Per file per deviceid layoutstats */
     353                 :            : struct nfs42_layoutstat_devinfo {
     354                 :            :         struct nfs4_deviceid dev_id;
     355                 :            :         __u64 offset;
     356                 :            :         __u64 length;
     357                 :            :         __u64 read_count;
     358                 :            :         __u64 read_bytes;
     359                 :            :         __u64 write_count;
     360                 :            :         __u64 write_bytes;
     361                 :            :         __u32 layout_type;
     362                 :            :         struct nfs4_xdr_opaque_data ld_private;
     363                 :            : };
     364                 :            : 
     365                 :            : struct nfs42_layoutstat_args {
     366                 :            :         struct nfs4_sequence_args seq_args;
     367                 :            :         struct nfs_fh *fh;
     368                 :            :         struct inode *inode;
     369                 :            :         nfs4_stateid stateid;
     370                 :            :         int num_dev;
     371                 :            :         struct nfs42_layoutstat_devinfo *devinfo;
     372                 :            : };
     373                 :            : 
     374                 :            : struct nfs42_layoutstat_res {
     375                 :            :         struct nfs4_sequence_res seq_res;
     376                 :            :         int num_dev;
     377                 :            :         int rpc_status;
     378                 :            : };
     379                 :            : 
     380                 :            : struct nfs42_layoutstat_data {
     381                 :            :         struct inode *inode;
     382                 :            :         struct nfs42_layoutstat_args args;
     383                 :            :         struct nfs42_layoutstat_res res;
     384                 :            : };
     385                 :            : 
     386                 :            : struct nfs42_device_error {
     387                 :            :         struct nfs4_deviceid dev_id;
     388                 :            :         int status;
     389                 :            :         enum nfs_opnum4 opnum;
     390                 :            : };
     391                 :            : 
     392                 :            : struct nfs42_layout_error {
     393                 :            :         __u64 offset;
     394                 :            :         __u64 length;
     395                 :            :         nfs4_stateid stateid;
     396                 :            :         struct nfs42_device_error errors[1];
     397                 :            : };
     398                 :            : 
     399                 :            : #define NFS42_LAYOUTERROR_MAX 5
     400                 :            : 
     401                 :            : struct nfs42_layouterror_args {
     402                 :            :         struct nfs4_sequence_args seq_args;
     403                 :            :         struct inode *inode;
     404                 :            :         unsigned int num_errors;
     405                 :            :         struct nfs42_layout_error errors[NFS42_LAYOUTERROR_MAX];
     406                 :            : };
     407                 :            : 
     408                 :            : struct nfs42_layouterror_res {
     409                 :            :         struct nfs4_sequence_res seq_res;
     410                 :            :         unsigned int num_errors;
     411                 :            :         int rpc_status;
     412                 :            : };
     413                 :            : 
     414                 :            : struct nfs42_layouterror_data {
     415                 :            :         struct nfs42_layouterror_args args;
     416                 :            :         struct nfs42_layouterror_res res;
     417                 :            :         struct inode *inode;
     418                 :            :         struct pnfs_layout_segment *lseg;
     419                 :            : };
     420                 :            : 
     421                 :            : struct nfs42_clone_args {
     422                 :            :         struct nfs4_sequence_args       seq_args;
     423                 :            :         struct nfs_fh                   *src_fh;
     424                 :            :         struct nfs_fh                   *dst_fh;
     425                 :            :         nfs4_stateid                    src_stateid;
     426                 :            :         nfs4_stateid                    dst_stateid;
     427                 :            :         __u64                           src_offset;
     428                 :            :         __u64                           dst_offset;
     429                 :            :         __u64                           count;
     430                 :            :         const u32                       *dst_bitmask;
     431                 :            : };
     432                 :            : 
     433                 :            : struct nfs42_clone_res {
     434                 :            :         struct nfs4_sequence_res        seq_res;
     435                 :            :         unsigned int                    rpc_status;
     436                 :            :         struct nfs_fattr                *dst_fattr;
     437                 :            :         const struct nfs_server         *server;
     438                 :            : };
     439                 :            : 
     440                 :            : struct stateowner_id {
     441                 :            :         __u64   create_time;
     442                 :            :         __u32   uniquifier;
     443                 :            : };
     444                 :            : 
     445                 :            : /*
     446                 :            :  * Arguments to the open call.
     447                 :            :  */
     448                 :            : struct nfs_openargs {
     449                 :            :         struct nfs4_sequence_args       seq_args;
     450                 :            :         const struct nfs_fh *   fh;
     451                 :            :         struct nfs_seqid *      seqid;
     452                 :            :         int                     open_flags;
     453                 :            :         fmode_t                 fmode;
     454                 :            :         u32                     share_access;
     455                 :            :         u32                     access;
     456                 :            :         __u64                   clientid;
     457                 :            :         struct stateowner_id    id;
     458                 :            :         union {
     459                 :            :                 struct {
     460                 :            :                         struct iattr *  attrs;    /* UNCHECKED, GUARDED, EXCLUSIVE4_1 */
     461                 :            :                         nfs4_verifier   verifier; /* EXCLUSIVE */
     462                 :            :                 };
     463                 :            :                 nfs4_stateid    delegation;             /* CLAIM_DELEGATE_CUR */
     464                 :            :                 fmode_t         delegation_type;        /* CLAIM_PREVIOUS */
     465                 :            :         } u;
     466                 :            :         const struct qstr *     name;
     467                 :            :         const struct nfs_server *server;         /* Needed for ID mapping */
     468                 :            :         const u32 *             bitmask;
     469                 :            :         const u32 *             open_bitmap;
     470                 :            :         enum open_claim_type4   claim;
     471                 :            :         enum createmode4        createmode;
     472                 :            :         const struct nfs4_label *label;
     473                 :            :         umode_t                 umask;
     474                 :            :         struct nfs4_layoutget_args *lg_args;
     475                 :            : };
     476                 :            : 
     477                 :            : struct nfs_openres {
     478                 :            :         struct nfs4_sequence_res        seq_res;
     479                 :            :         nfs4_stateid            stateid;
     480                 :            :         struct nfs_fh           fh;
     481                 :            :         struct nfs4_change_info cinfo;
     482                 :            :         __u32                   rflags;
     483                 :            :         struct nfs_fattr *      f_attr;
     484                 :            :         struct nfs4_label       *f_label;
     485                 :            :         struct nfs_seqid *      seqid;
     486                 :            :         const struct nfs_server *server;
     487                 :            :         fmode_t                 delegation_type;
     488                 :            :         nfs4_stateid            delegation;
     489                 :            :         unsigned long           pagemod_limit;
     490                 :            :         __u32                   do_recall;
     491                 :            :         __u32                   attrset[NFS4_BITMAP_SIZE];
     492                 :            :         struct nfs4_string      *owner;
     493                 :            :         struct nfs4_string      *group_owner;
     494                 :            :         __u32                   access_request;
     495                 :            :         __u32                   access_supported;
     496                 :            :         __u32                   access_result;
     497                 :            :         struct nfs4_layoutget_res *lg_res;
     498                 :            : };
     499                 :            : 
     500                 :            : /*
     501                 :            :  * Arguments to the open_confirm call.
     502                 :            :  */
     503                 :            : struct nfs_open_confirmargs {
     504                 :            :         struct nfs4_sequence_args       seq_args;
     505                 :            :         const struct nfs_fh *   fh;
     506                 :            :         nfs4_stateid *          stateid;
     507                 :            :         struct nfs_seqid *      seqid;
     508                 :            : };
     509                 :            : 
     510                 :            : struct nfs_open_confirmres {
     511                 :            :         struct nfs4_sequence_res        seq_res;
     512                 :            :         nfs4_stateid            stateid;
     513                 :            :         struct nfs_seqid *      seqid;
     514                 :            : };
     515                 :            : 
     516                 :            : /*
     517                 :            :  * Arguments to the close call.
     518                 :            :  */
     519                 :            : struct nfs_closeargs {
     520                 :            :         struct nfs4_sequence_args       seq_args;
     521                 :            :         struct nfs_fh *         fh;
     522                 :            :         nfs4_stateid            stateid;
     523                 :            :         struct nfs_seqid *      seqid;
     524                 :            :         fmode_t                 fmode;
     525                 :            :         u32                     share_access;
     526                 :            :         const u32 *             bitmask;
     527                 :            :         struct nfs4_layoutreturn_args *lr_args;
     528                 :            : };
     529                 :            : 
     530                 :            : struct nfs_closeres {
     531                 :            :         struct nfs4_sequence_res        seq_res;
     532                 :            :         nfs4_stateid            stateid;
     533                 :            :         struct nfs_fattr *      fattr;
     534                 :            :         struct nfs_seqid *      seqid;
     535                 :            :         const struct nfs_server *server;
     536                 :            :         struct nfs4_layoutreturn_res *lr_res;
     537                 :            :         int lr_ret;
     538                 :            : };
     539                 :            : /*
     540                 :            :  *  * Arguments to the lock,lockt, and locku call.
     541                 :            :  *   */
     542                 :            : struct nfs_lowner {
     543                 :            :         __u64                   clientid;
     544                 :            :         __u64                   id;
     545                 :            :         dev_t                   s_dev;
     546                 :            : };
     547                 :            : 
     548                 :            : struct nfs_lock_args {
     549                 :            :         struct nfs4_sequence_args       seq_args;
     550                 :            :         struct nfs_fh *         fh;
     551                 :            :         struct file_lock *      fl;
     552                 :            :         struct nfs_seqid *      lock_seqid;
     553                 :            :         nfs4_stateid            lock_stateid;
     554                 :            :         struct nfs_seqid *      open_seqid;
     555                 :            :         nfs4_stateid            open_stateid;
     556                 :            :         struct nfs_lowner       lock_owner;
     557                 :            :         unsigned char           block : 1;
     558                 :            :         unsigned char           reclaim : 1;
     559                 :            :         unsigned char           new_lock : 1;
     560                 :            :         unsigned char           new_lock_owner : 1;
     561                 :            : };
     562                 :            : 
     563                 :            : struct nfs_lock_res {
     564                 :            :         struct nfs4_sequence_res        seq_res;
     565                 :            :         nfs4_stateid            stateid;
     566                 :            :         struct nfs_seqid *      lock_seqid;
     567                 :            :         struct nfs_seqid *      open_seqid;
     568                 :            : };
     569                 :            : 
     570                 :            : struct nfs_locku_args {
     571                 :            :         struct nfs4_sequence_args       seq_args;
     572                 :            :         struct nfs_fh *         fh;
     573                 :            :         struct file_lock *      fl;
     574                 :            :         struct nfs_seqid *      seqid;
     575                 :            :         nfs4_stateid            stateid;
     576                 :            : };
     577                 :            : 
     578                 :            : struct nfs_locku_res {
     579                 :            :         struct nfs4_sequence_res        seq_res;
     580                 :            :         nfs4_stateid            stateid;
     581                 :            :         struct nfs_seqid *      seqid;
     582                 :            : };
     583                 :            : 
     584                 :            : struct nfs_lockt_args {
     585                 :            :         struct nfs4_sequence_args       seq_args;
     586                 :            :         struct nfs_fh *         fh;
     587                 :            :         struct file_lock *      fl;
     588                 :            :         struct nfs_lowner       lock_owner;
     589                 :            : };
     590                 :            : 
     591                 :            : struct nfs_lockt_res {
     592                 :            :         struct nfs4_sequence_res        seq_res;
     593                 :            :         struct file_lock *      denied; /* LOCK, LOCKT failed */
     594                 :            : };
     595                 :            : 
     596                 :            : struct nfs_release_lockowner_args {
     597                 :            :         struct nfs4_sequence_args       seq_args;
     598                 :            :         struct nfs_lowner       lock_owner;
     599                 :            : };
     600                 :            : 
     601                 :            : struct nfs_release_lockowner_res {
     602                 :            :         struct nfs4_sequence_res        seq_res;
     603                 :            : };
     604                 :            : 
     605                 :            : struct nfs4_delegreturnargs {
     606                 :            :         struct nfs4_sequence_args       seq_args;
     607                 :            :         const struct nfs_fh *fhandle;
     608                 :            :         const nfs4_stateid *stateid;
     609                 :            :         const u32 * bitmask;
     610                 :            :         struct nfs4_layoutreturn_args *lr_args;
     611                 :            : };
     612                 :            : 
     613                 :            : struct nfs4_delegreturnres {
     614                 :            :         struct nfs4_sequence_res        seq_res;
     615                 :            :         struct nfs_fattr * fattr;
     616                 :            :         struct nfs_server *server;
     617                 :            :         struct nfs4_layoutreturn_res *lr_res;
     618                 :            :         int lr_ret;
     619                 :            : };
     620                 :            : 
     621                 :            : /*
     622                 :            :  * Arguments to the write call.
     623                 :            :  */
     624                 :            : struct nfs_write_verifier {
     625                 :            :         char                    data[8];
     626                 :            : };
     627                 :            : 
     628                 :            : struct nfs_writeverf {
     629                 :            :         struct nfs_write_verifier verifier;
     630                 :            :         enum nfs3_stable_how    committed;
     631                 :            : };
     632                 :            : 
     633                 :            : /*
     634                 :            :  * Arguments shared by the read and write call.
     635                 :            :  */
     636                 :            : struct nfs_pgio_args {
     637                 :            :         struct nfs4_sequence_args       seq_args;
     638                 :            :         struct nfs_fh *         fh;
     639                 :            :         struct nfs_open_context *context;
     640                 :            :         struct nfs_lock_context *lock_context;
     641                 :            :         nfs4_stateid            stateid;
     642                 :            :         __u64                   offset;
     643                 :            :         __u32                   count;
     644                 :            :         unsigned int            pgbase;
     645                 :            :         struct page **          pages;
     646                 :            :         union {
     647                 :            :                 unsigned int            replen;                 /* used by read */
     648                 :            :                 struct {
     649                 :            :                         const u32 *             bitmask;        /* used by write */
     650                 :            :                         enum nfs3_stable_how    stable;         /* used by write */
     651                 :            :                 };
     652                 :            :         };
     653                 :            : };
     654                 :            : 
     655                 :            : struct nfs_pgio_res {
     656                 :            :         struct nfs4_sequence_res        seq_res;
     657                 :            :         struct nfs_fattr *      fattr;
     658                 :            :         __u32                   count;
     659                 :            :         __u32                   op_status;
     660                 :            :         union {
     661                 :            :                 struct {
     662                 :            :                         unsigned int            replen;         /* used by read */
     663                 :            :                         int                     eof;            /* used by read */
     664                 :            :                 };
     665                 :            :                 struct {
     666                 :            :                         struct nfs_writeverf *  verf;           /* used by write */
     667                 :            :                         const struct nfs_server *server;        /* used by write */
     668                 :            :                 };
     669                 :            :         };
     670                 :            : };
     671                 :            : 
     672                 :            : /*
     673                 :            :  * Arguments to the commit call.
     674                 :            :  */
     675                 :            : struct nfs_commitargs {
     676                 :            :         struct nfs4_sequence_args       seq_args;
     677                 :            :         struct nfs_fh           *fh;
     678                 :            :         __u64                   offset;
     679                 :            :         __u32                   count;
     680                 :            :         const u32               *bitmask;
     681                 :            : };
     682                 :            : 
     683                 :            : struct nfs_commitres {
     684                 :            :         struct nfs4_sequence_res        seq_res;
     685                 :            :         __u32                   op_status;
     686                 :            :         struct nfs_fattr        *fattr;
     687                 :            :         struct nfs_writeverf    *verf;
     688                 :            :         const struct nfs_server *server;
     689                 :            : };
     690                 :            : 
     691                 :            : /*
     692                 :            :  * Common arguments to the unlink call
     693                 :            :  */
     694                 :            : struct nfs_removeargs {
     695                 :            :         struct nfs4_sequence_args       seq_args;
     696                 :            :         const struct nfs_fh     *fh;
     697                 :            :         struct qstr             name;
     698                 :            : };
     699                 :            : 
     700                 :            : struct nfs_removeres {
     701                 :            :         struct nfs4_sequence_res        seq_res;
     702                 :            :         struct nfs_server *server;
     703                 :            :         struct nfs_fattr        *dir_attr;
     704                 :            :         struct nfs4_change_info cinfo;
     705                 :            : };
     706                 :            : 
     707                 :            : /*
     708                 :            :  * Common arguments to the rename call
     709                 :            :  */
     710                 :            : struct nfs_renameargs {
     711                 :            :         struct nfs4_sequence_args       seq_args;
     712                 :            :         const struct nfs_fh             *old_dir;
     713                 :            :         const struct nfs_fh             *new_dir;
     714                 :            :         const struct qstr               *old_name;
     715                 :            :         const struct qstr               *new_name;
     716                 :            : };
     717                 :            : 
     718                 :            : struct nfs_renameres {
     719                 :            :         struct nfs4_sequence_res        seq_res;
     720                 :            :         struct nfs_server               *server;
     721                 :            :         struct nfs4_change_info         old_cinfo;
     722                 :            :         struct nfs_fattr                *old_fattr;
     723                 :            :         struct nfs4_change_info         new_cinfo;
     724                 :            :         struct nfs_fattr                *new_fattr;
     725                 :            : };
     726                 :            : 
     727                 :            : /* parsed sec= options */
     728                 :            : #define NFS_AUTH_INFO_MAX_FLAVORS 12 /* see fs/nfs/super.c */
     729                 :            : struct nfs_auth_info {
     730                 :            :         unsigned int            flavor_len;
     731                 :            :         rpc_authflavor_t        flavors[NFS_AUTH_INFO_MAX_FLAVORS];
     732                 :            : };
     733                 :            : 
     734                 :            : /*
     735                 :            :  * Argument struct for decode_entry function
     736                 :            :  */
     737                 :            : struct nfs_entry {
     738                 :            :         __u64                   ino;
     739                 :            :         __u64                   cookie,
     740                 :            :                                 prev_cookie;
     741                 :            :         const char *            name;
     742                 :            :         unsigned int            len;
     743                 :            :         int                     eof;
     744                 :            :         struct nfs_fh *         fh;
     745                 :            :         struct nfs_fattr *      fattr;
     746                 :            :         struct nfs4_label  *label;
     747                 :            :         unsigned char           d_type;
     748                 :            :         struct nfs_server *     server;
     749                 :            : };
     750                 :            : 
     751                 :            : /*
     752                 :            :  * The following types are for NFSv2 only.
     753                 :            :  */
     754                 :            : struct nfs_sattrargs {
     755                 :            :         struct nfs_fh *         fh;
     756                 :            :         struct iattr *          sattr;
     757                 :            : };
     758                 :            : 
     759                 :            : struct nfs_diropargs {
     760                 :            :         struct nfs_fh *         fh;
     761                 :            :         const char *            name;
     762                 :            :         unsigned int            len;
     763                 :            : };
     764                 :            : 
     765                 :            : struct nfs_createargs {
     766                 :            :         struct nfs_fh *         fh;
     767                 :            :         const char *            name;
     768                 :            :         unsigned int            len;
     769                 :            :         struct iattr *          sattr;
     770                 :            : };
     771                 :            : 
     772                 :            : struct nfs_setattrargs {
     773                 :            :         struct nfs4_sequence_args       seq_args;
     774                 :            :         struct nfs_fh *                 fh;
     775                 :            :         nfs4_stateid                    stateid;
     776                 :            :         struct iattr *                  iap;
     777                 :            :         const struct nfs_server *       server; /* Needed for name mapping */
     778                 :            :         const u32 *                     bitmask;
     779                 :            :         const struct nfs4_label         *label;
     780                 :            : };
     781                 :            : 
     782                 :            : struct nfs_setaclargs {
     783                 :            :         struct nfs4_sequence_args       seq_args;
     784                 :            :         struct nfs_fh *                 fh;
     785                 :            :         size_t                          acl_len;
     786                 :            :         struct page **                  acl_pages;
     787                 :            : };
     788                 :            : 
     789                 :            : struct nfs_setaclres {
     790                 :            :         struct nfs4_sequence_res        seq_res;
     791                 :            : };
     792                 :            : 
     793                 :            : struct nfs_getaclargs {
     794                 :            :         struct nfs4_sequence_args       seq_args;
     795                 :            :         struct nfs_fh *                 fh;
     796                 :            :         size_t                          acl_len;
     797                 :            :         struct page **                  acl_pages;
     798                 :            : };
     799                 :            : 
     800                 :            : /* getxattr ACL interface flags */
     801                 :            : #define NFS4_ACL_TRUNC          0x0001  /* ACL was truncated */
     802                 :            : struct nfs_getaclres {
     803                 :            :         struct nfs4_sequence_res        seq_res;
     804                 :            :         size_t                          acl_len;
     805                 :            :         size_t                          acl_data_offset;
     806                 :            :         int                             acl_flags;
     807                 :            :         struct page *                   acl_scratch;
     808                 :            : };
     809                 :            : 
     810                 :            : struct nfs_setattrres {
     811                 :            :         struct nfs4_sequence_res        seq_res;
     812                 :            :         struct nfs_fattr *              fattr;
     813                 :            :         struct nfs4_label               *label;
     814                 :            :         const struct nfs_server *       server;
     815                 :            : };
     816                 :            : 
     817                 :            : struct nfs_linkargs {
     818                 :            :         struct nfs_fh *         fromfh;
     819                 :            :         struct nfs_fh *         tofh;
     820                 :            :         const char *            toname;
     821                 :            :         unsigned int            tolen;
     822                 :            : };
     823                 :            : 
     824                 :            : struct nfs_symlinkargs {
     825                 :            :         struct nfs_fh *         fromfh;
     826                 :            :         const char *            fromname;
     827                 :            :         unsigned int            fromlen;
     828                 :            :         struct page **          pages;
     829                 :            :         unsigned int            pathlen;
     830                 :            :         struct iattr *          sattr;
     831                 :            : };
     832                 :            : 
     833                 :            : struct nfs_readdirargs {
     834                 :            :         struct nfs_fh *         fh;
     835                 :            :         __u32                   cookie;
     836                 :            :         unsigned int            count;
     837                 :            :         struct page **          pages;
     838                 :            : };
     839                 :            : 
     840                 :            : struct nfs3_getaclargs {
     841                 :            :         struct nfs_fh *         fh;
     842                 :            :         int                     mask;
     843                 :            :         struct page **          pages;
     844                 :            : };
     845                 :            : 
     846                 :            : struct nfs3_setaclargs {
     847                 :            :         struct inode *          inode;
     848                 :            :         int                     mask;
     849                 :            :         struct posix_acl *      acl_access;
     850                 :            :         struct posix_acl *      acl_default;
     851                 :            :         size_t                  len;
     852                 :            :         unsigned int            npages;
     853                 :            :         struct page **          pages;
     854                 :            : };
     855                 :            : 
     856                 :            : struct nfs_diropok {
     857                 :            :         struct nfs_fh *         fh;
     858                 :            :         struct nfs_fattr *      fattr;
     859                 :            : };
     860                 :            : 
     861                 :            : struct nfs_readlinkargs {
     862                 :            :         struct nfs_fh *         fh;
     863                 :            :         unsigned int            pgbase;
     864                 :            :         unsigned int            pglen;
     865                 :            :         struct page **          pages;
     866                 :            : };
     867                 :            : 
     868                 :            : struct nfs3_sattrargs {
     869                 :            :         struct nfs_fh *         fh;
     870                 :            :         struct iattr *          sattr;
     871                 :            :         unsigned int            guard;
     872                 :            :         struct timespec         guardtime;
     873                 :            : };
     874                 :            : 
     875                 :            : struct nfs3_diropargs {
     876                 :            :         struct nfs_fh *         fh;
     877                 :            :         const char *            name;
     878                 :            :         unsigned int            len;
     879                 :            : };
     880                 :            : 
     881                 :            : struct nfs3_accessargs {
     882                 :            :         struct nfs_fh *         fh;
     883                 :            :         __u32                   access;
     884                 :            : };
     885                 :            : 
     886                 :            : struct nfs3_createargs {
     887                 :            :         struct nfs_fh *         fh;
     888                 :            :         const char *            name;
     889                 :            :         unsigned int            len;
     890                 :            :         struct iattr *          sattr;
     891                 :            :         enum nfs3_createmode    createmode;
     892                 :            :         __be32                  verifier[2];
     893                 :            : };
     894                 :            : 
     895                 :            : struct nfs3_mkdirargs {
     896                 :            :         struct nfs_fh *         fh;
     897                 :            :         const char *            name;
     898                 :            :         unsigned int            len;
     899                 :            :         struct iattr *          sattr;
     900                 :            : };
     901                 :            : 
     902                 :            : struct nfs3_symlinkargs {
     903                 :            :         struct nfs_fh *         fromfh;
     904                 :            :         const char *            fromname;
     905                 :            :         unsigned int            fromlen;
     906                 :            :         struct page **          pages;
     907                 :            :         unsigned int            pathlen;
     908                 :            :         struct iattr *          sattr;
     909                 :            : };
     910                 :            : 
     911                 :            : struct nfs3_mknodargs {
     912                 :            :         struct nfs_fh *         fh;
     913                 :            :         const char *            name;
     914                 :            :         unsigned int            len;
     915                 :            :         enum nfs3_ftype         type;
     916                 :            :         struct iattr *          sattr;
     917                 :            :         dev_t                   rdev;
     918                 :            : };
     919                 :            : 
     920                 :            : struct nfs3_linkargs {
     921                 :            :         struct nfs_fh *         fromfh;
     922                 :            :         struct nfs_fh *         tofh;
     923                 :            :         const char *            toname;
     924                 :            :         unsigned int            tolen;
     925                 :            : };
     926                 :            : 
     927                 :            : struct nfs3_readdirargs {
     928                 :            :         struct nfs_fh *         fh;
     929                 :            :         __u64                   cookie;
     930                 :            :         __be32                  verf[2];
     931                 :            :         bool                    plus;
     932                 :            :         unsigned int            count;
     933                 :            :         struct page **          pages;
     934                 :            : };
     935                 :            : 
     936                 :            : struct nfs3_diropres {
     937                 :            :         struct nfs_fattr *      dir_attr;
     938                 :            :         struct nfs_fh *         fh;
     939                 :            :         struct nfs_fattr *      fattr;
     940                 :            : };
     941                 :            : 
     942                 :            : struct nfs3_accessres {
     943                 :            :         struct nfs_fattr *      fattr;
     944                 :            :         __u32                   access;
     945                 :            : };
     946                 :            : 
     947                 :            : struct nfs3_readlinkargs {
     948                 :            :         struct nfs_fh *         fh;
     949                 :            :         unsigned int            pgbase;
     950                 :            :         unsigned int            pglen;
     951                 :            :         struct page **          pages;
     952                 :            : };
     953                 :            : 
     954                 :            : struct nfs3_linkres {
     955                 :            :         struct nfs_fattr *      dir_attr;
     956                 :            :         struct nfs_fattr *      fattr;
     957                 :            : };
     958                 :            : 
     959                 :            : struct nfs3_readdirres {
     960                 :            :         struct nfs_fattr *      dir_attr;
     961                 :            :         __be32 *                verf;
     962                 :            :         bool                    plus;
     963                 :            : };
     964                 :            : 
     965                 :            : struct nfs3_getaclres {
     966                 :            :         struct nfs_fattr *      fattr;
     967                 :            :         int                     mask;
     968                 :            :         unsigned int            acl_access_count;
     969                 :            :         unsigned int            acl_default_count;
     970                 :            :         struct posix_acl *      acl_access;
     971                 :            :         struct posix_acl *      acl_default;
     972                 :            : };
     973                 :            : 
     974                 :            : #if IS_ENABLED(CONFIG_NFS_V4)
     975                 :            : 
     976                 :            : typedef u64 clientid4;
     977                 :            : 
     978                 :            : struct nfs4_accessargs {
     979                 :            :         struct nfs4_sequence_args       seq_args;
     980                 :            :         const struct nfs_fh *           fh;
     981                 :            :         const u32 *                     bitmask;
     982                 :            :         u32                             access;
     983                 :            : };
     984                 :            : 
     985                 :            : struct nfs4_accessres {
     986                 :            :         struct nfs4_sequence_res        seq_res;
     987                 :            :         const struct nfs_server *       server;
     988                 :            :         struct nfs_fattr *              fattr;
     989                 :            :         u32                             supported;
     990                 :            :         u32                             access;
     991                 :            : };
     992                 :            : 
     993                 :            : struct nfs4_create_arg {
     994                 :            :         struct nfs4_sequence_args       seq_args;
     995                 :            :         u32                             ftype;
     996                 :            :         union {
     997                 :            :                 struct {
     998                 :            :                         struct page **  pages;
     999                 :            :                         unsigned int    len;
    1000                 :            :                 } symlink;   /* NF4LNK */
    1001                 :            :                 struct {
    1002                 :            :                         u32             specdata1;
    1003                 :            :                         u32             specdata2;
    1004                 :            :                 } device;    /* NF4BLK, NF4CHR */
    1005                 :            :         } u;
    1006                 :            :         const struct qstr *             name;
    1007                 :            :         const struct nfs_server *       server;
    1008                 :            :         const struct iattr *            attrs;
    1009                 :            :         const struct nfs_fh *           dir_fh;
    1010                 :            :         const u32 *                     bitmask;
    1011                 :            :         const struct nfs4_label         *label;
    1012                 :            :         umode_t                         umask;
    1013                 :            : };
    1014                 :            : 
    1015                 :            : struct nfs4_create_res {
    1016                 :            :         struct nfs4_sequence_res        seq_res;
    1017                 :            :         const struct nfs_server *       server;
    1018                 :            :         struct nfs_fh *                 fh;
    1019                 :            :         struct nfs_fattr *              fattr;
    1020                 :            :         struct nfs4_label               *label;
    1021                 :            :         struct nfs4_change_info         dir_cinfo;
    1022                 :            : };
    1023                 :            : 
    1024                 :            : struct nfs4_fsinfo_arg {
    1025                 :            :         struct nfs4_sequence_args       seq_args;
    1026                 :            :         const struct nfs_fh *           fh;
    1027                 :            :         const u32 *                     bitmask;
    1028                 :            : };
    1029                 :            : 
    1030                 :            : struct nfs4_fsinfo_res {
    1031                 :            :         struct nfs4_sequence_res        seq_res;
    1032                 :            :         struct nfs_fsinfo              *fsinfo;
    1033                 :            : };
    1034                 :            : 
    1035                 :            : struct nfs4_getattr_arg {
    1036                 :            :         struct nfs4_sequence_args       seq_args;
    1037                 :            :         const struct nfs_fh *           fh;
    1038                 :            :         const u32 *                     bitmask;
    1039                 :            : };
    1040                 :            : 
    1041                 :            : struct nfs4_getattr_res {
    1042                 :            :         struct nfs4_sequence_res        seq_res;
    1043                 :            :         const struct nfs_server *       server;
    1044                 :            :         struct nfs_fattr *              fattr;
    1045                 :            :         struct nfs4_label               *label;
    1046                 :            : };
    1047                 :            : 
    1048                 :            : struct nfs4_link_arg {
    1049                 :            :         struct nfs4_sequence_args       seq_args;
    1050                 :            :         const struct nfs_fh *           fh;
    1051                 :            :         const struct nfs_fh *           dir_fh;
    1052                 :            :         const struct qstr *             name;
    1053                 :            :         const u32 *                     bitmask;
    1054                 :            : };
    1055                 :            : 
    1056                 :            : struct nfs4_link_res {
    1057                 :            :         struct nfs4_sequence_res        seq_res;
    1058                 :            :         const struct nfs_server *       server;
    1059                 :            :         struct nfs_fattr *              fattr;
    1060                 :            :         struct nfs4_label               *label;
    1061                 :            :         struct nfs4_change_info         cinfo;
    1062                 :            :         struct nfs_fattr *              dir_attr;
    1063                 :            : };
    1064                 :            : 
    1065                 :            : struct nfs4_lookup_arg {
    1066                 :            :         struct nfs4_sequence_args       seq_args;
    1067                 :            :         const struct nfs_fh *           dir_fh;
    1068                 :            :         const struct qstr *             name;
    1069                 :            :         const u32 *                     bitmask;
    1070                 :            : };
    1071                 :            : 
    1072                 :            : struct nfs4_lookup_res {
    1073                 :            :         struct nfs4_sequence_res        seq_res;
    1074                 :            :         const struct nfs_server *       server;
    1075                 :            :         struct nfs_fattr *              fattr;
    1076                 :            :         struct nfs_fh *                 fh;
    1077                 :            :         struct nfs4_label               *label;
    1078                 :            : };
    1079                 :            : 
    1080                 :            : struct nfs4_lookupp_arg {
    1081                 :            :         struct nfs4_sequence_args       seq_args;
    1082                 :            :         const struct nfs_fh             *fh;
    1083                 :            :         const u32                       *bitmask;
    1084                 :            : };
    1085                 :            : 
    1086                 :            : struct nfs4_lookupp_res {
    1087                 :            :         struct nfs4_sequence_res        seq_res;
    1088                 :            :         const struct nfs_server         *server;
    1089                 :            :         struct nfs_fattr                *fattr;
    1090                 :            :         struct nfs_fh                   *fh;
    1091                 :            :         struct nfs4_label               *label;
    1092                 :            : };
    1093                 :            : 
    1094                 :            : struct nfs4_lookup_root_arg {
    1095                 :            :         struct nfs4_sequence_args       seq_args;
    1096                 :            :         const u32 *                     bitmask;
    1097                 :            : };
    1098                 :            : 
    1099                 :            : struct nfs4_pathconf_arg {
    1100                 :            :         struct nfs4_sequence_args       seq_args;
    1101                 :            :         const struct nfs_fh *           fh;
    1102                 :            :         const u32 *                     bitmask;
    1103                 :            : };
    1104                 :            : 
    1105                 :            : struct nfs4_pathconf_res {
    1106                 :            :         struct nfs4_sequence_res        seq_res;
    1107                 :            :         struct nfs_pathconf            *pathconf;
    1108                 :            : };
    1109                 :            : 
    1110                 :            : struct nfs4_readdir_arg {
    1111                 :            :         struct nfs4_sequence_args       seq_args;
    1112                 :            :         const struct nfs_fh *           fh;
    1113                 :            :         u64                             cookie;
    1114                 :            :         nfs4_verifier                   verifier;
    1115                 :            :         u32                             count;
    1116                 :            :         struct page **                  pages;  /* zero-copy data */
    1117                 :            :         unsigned int                    pgbase; /* zero-copy data */
    1118                 :            :         const u32 *                     bitmask;
    1119                 :            :         bool                            plus;
    1120                 :            : };
    1121                 :            : 
    1122                 :            : struct nfs4_readdir_res {
    1123                 :            :         struct nfs4_sequence_res        seq_res;
    1124                 :            :         nfs4_verifier                   verifier;
    1125                 :            :         unsigned int                    pgbase;
    1126                 :            : };
    1127                 :            : 
    1128                 :            : struct nfs4_readlink {
    1129                 :            :         struct nfs4_sequence_args       seq_args;
    1130                 :            :         const struct nfs_fh *           fh;
    1131                 :            :         unsigned int                    pgbase;
    1132                 :            :         unsigned int                    pglen;   /* zero-copy data */
    1133                 :            :         struct page **                  pages;   /* zero-copy data */
    1134                 :            : };
    1135                 :            : 
    1136                 :            : struct nfs4_readlink_res {
    1137                 :            :         struct nfs4_sequence_res        seq_res;
    1138                 :            : };
    1139                 :            : 
    1140                 :            : struct nfs4_setclientid {
    1141                 :            :         const nfs4_verifier *           sc_verifier;
    1142                 :            :         u32                             sc_prog;
    1143                 :            :         unsigned int                    sc_netid_len;
    1144                 :            :         char                            sc_netid[RPCBIND_MAXNETIDLEN + 1];
    1145                 :            :         unsigned int                    sc_uaddr_len;
    1146                 :            :         char                            sc_uaddr[RPCBIND_MAXUADDRLEN + 1];
    1147                 :            :         struct nfs_client               *sc_clnt;
    1148                 :            :         struct rpc_cred                 *sc_cred;
    1149                 :            : };
    1150                 :            : 
    1151                 :            : struct nfs4_setclientid_res {
    1152                 :            :         u64                             clientid;
    1153                 :            :         nfs4_verifier                   confirm;
    1154                 :            : };
    1155                 :            : 
    1156                 :            : struct nfs4_statfs_arg {
    1157                 :            :         struct nfs4_sequence_args       seq_args;
    1158                 :            :         const struct nfs_fh *           fh;
    1159                 :            :         const u32 *                     bitmask;
    1160                 :            : };
    1161                 :            : 
    1162                 :            : struct nfs4_statfs_res {
    1163                 :            :         struct nfs4_sequence_res        seq_res;
    1164                 :            :         struct nfs_fsstat              *fsstat;
    1165                 :            : };
    1166                 :            : 
    1167                 :            : struct nfs4_server_caps_arg {
    1168                 :            :         struct nfs4_sequence_args       seq_args;
    1169                 :            :         struct nfs_fh                  *fhandle;
    1170                 :            :         const u32 *                     bitmask;
    1171                 :            : };
    1172                 :            : 
    1173                 :            : struct nfs4_server_caps_res {
    1174                 :            :         struct nfs4_sequence_res        seq_res;
    1175                 :            :         u32                             attr_bitmask[3];
    1176                 :            :         u32                             exclcreat_bitmask[3];
    1177                 :            :         u32                             acl_bitmask;
    1178                 :            :         u32                             has_links;
    1179                 :            :         u32                             has_symlinks;
    1180                 :            :         u32                             fh_expire_type;
    1181                 :            : };
    1182                 :            : 
    1183                 :            : #define NFS4_PATHNAME_MAXCOMPONENTS 512
    1184                 :            : struct nfs4_pathname {
    1185                 :            :         unsigned int ncomponents;
    1186                 :            :         struct nfs4_string components[NFS4_PATHNAME_MAXCOMPONENTS];
    1187                 :            : };
    1188                 :            : 
    1189                 :            : #define NFS4_FS_LOCATION_MAXSERVERS 10
    1190                 :            : struct nfs4_fs_location {
    1191                 :            :         unsigned int nservers;
    1192                 :            :         struct nfs4_string servers[NFS4_FS_LOCATION_MAXSERVERS];
    1193                 :            :         struct nfs4_pathname rootpath;
    1194                 :            : };
    1195                 :            : 
    1196                 :            : #define NFS4_FS_LOCATIONS_MAXENTRIES 10
    1197                 :            : struct nfs4_fs_locations {
    1198                 :            :         struct nfs_fattr fattr;
    1199                 :            :         const struct nfs_server *server;
    1200                 :            :         struct nfs4_pathname fs_path;
    1201                 :            :         int nlocations;
    1202                 :            :         struct nfs4_fs_location locations[NFS4_FS_LOCATIONS_MAXENTRIES];
    1203                 :            : };
    1204                 :            : 
    1205                 :            : struct nfs4_fs_locations_arg {
    1206                 :            :         struct nfs4_sequence_args       seq_args;
    1207                 :            :         const struct nfs_fh *dir_fh;
    1208                 :            :         const struct nfs_fh *fh;
    1209                 :            :         const struct qstr *name;
    1210                 :            :         struct page *page;
    1211                 :            :         const u32 *bitmask;
    1212                 :            :         clientid4 clientid;
    1213                 :            :         unsigned char migration:1, renew:1;
    1214                 :            : };
    1215                 :            : 
    1216                 :            : struct nfs4_fs_locations_res {
    1217                 :            :         struct nfs4_sequence_res        seq_res;
    1218                 :            :         struct nfs4_fs_locations       *fs_locations;
    1219                 :            :         unsigned char                   migration:1, renew:1;
    1220                 :            : };
    1221                 :            : 
    1222                 :            : struct nfs4_secinfo4 {
    1223                 :            :         u32                     flavor;
    1224                 :            :         struct rpcsec_gss_info  flavor_info;
    1225                 :            : };
    1226                 :            : 
    1227                 :            : struct nfs4_secinfo_flavors {
    1228                 :            :         unsigned int            num_flavors;
    1229                 :            :         struct nfs4_secinfo4    flavors[0];
    1230                 :            : };
    1231                 :            : 
    1232                 :            : struct nfs4_secinfo_arg {
    1233                 :            :         struct nfs4_sequence_args       seq_args;
    1234                 :            :         const struct nfs_fh             *dir_fh;
    1235                 :            :         const struct qstr               *name;
    1236                 :            : };
    1237                 :            : 
    1238                 :            : struct nfs4_secinfo_res {
    1239                 :            :         struct nfs4_sequence_res        seq_res;
    1240                 :            :         struct nfs4_secinfo_flavors     *flavors;
    1241                 :            : };
    1242                 :            : 
    1243                 :            : struct nfs4_fsid_present_arg {
    1244                 :            :         struct nfs4_sequence_args       seq_args;
    1245                 :            :         const struct nfs_fh             *fh;
    1246                 :            :         clientid4                       clientid;
    1247                 :            :         unsigned char                   renew:1;
    1248                 :            : };
    1249                 :            : 
    1250                 :            : struct nfs4_fsid_present_res {
    1251                 :            :         struct nfs4_sequence_res        seq_res;
    1252                 :            :         struct nfs_fh                   *fh;
    1253                 :            :         unsigned char                   renew:1;
    1254                 :            : };
    1255                 :            : 
    1256                 :            : #endif /* CONFIG_NFS_V4 */
    1257                 :            : 
    1258                 :            : struct nfstime4 {
    1259                 :            :         u64     seconds;
    1260                 :            :         u32     nseconds;
    1261                 :            : };
    1262                 :            : 
    1263                 :            : #ifdef CONFIG_NFS_V4_1
    1264                 :            : 
    1265                 :            : struct pnfs_commit_bucket {
    1266                 :            :         struct list_head written;
    1267                 :            :         struct list_head committing;
    1268                 :            :         struct pnfs_layout_segment *wlseg;
    1269                 :            :         struct pnfs_layout_segment *clseg;
    1270                 :            :         struct nfs_writeverf direct_verf;
    1271                 :            : };
    1272                 :            : 
    1273                 :            : struct pnfs_ds_commit_info {
    1274                 :            :         int nwritten;
    1275                 :            :         int ncommitting;
    1276                 :            :         int nbuckets;
    1277                 :            :         struct pnfs_commit_bucket *buckets;
    1278                 :            : };
    1279                 :            : 
    1280                 :            : struct nfs41_state_protection {
    1281                 :            :         u32 how;
    1282                 :            :         struct nfs4_op_map enforce;
    1283                 :            :         struct nfs4_op_map allow;
    1284                 :            : };
    1285                 :            : 
    1286                 :            : struct nfs41_exchange_id_args {
    1287                 :            :         struct nfs_client               *client;
    1288                 :            :         nfs4_verifier                   verifier;
    1289                 :            :         u32                             flags;
    1290                 :            :         struct nfs41_state_protection   state_protect;
    1291                 :            : };
    1292                 :            : 
    1293                 :            : struct nfs41_server_owner {
    1294                 :            :         uint64_t                        minor_id;
    1295                 :            :         uint32_t                        major_id_sz;
    1296                 :            :         char                            major_id[NFS4_OPAQUE_LIMIT];
    1297                 :            : };
    1298                 :            : 
    1299                 :            : struct nfs41_server_scope {
    1300                 :            :         uint32_t                        server_scope_sz;
    1301                 :            :         char                            server_scope[NFS4_OPAQUE_LIMIT];
    1302                 :            : };
    1303                 :            : 
    1304                 :            : struct nfs41_impl_id {
    1305                 :            :         char                            domain[NFS4_OPAQUE_LIMIT + 1];
    1306                 :            :         char                            name[NFS4_OPAQUE_LIMIT + 1];
    1307                 :            :         struct nfstime4                 date;
    1308                 :            : };
    1309                 :            : 
    1310                 :            : #define MAX_BIND_CONN_TO_SESSION_RETRIES 3
    1311                 :            : struct nfs41_bind_conn_to_session_args {
    1312                 :            :         struct nfs_client               *client;
    1313                 :            :         struct nfs4_sessionid           sessionid;
    1314                 :            :         u32                             dir;
    1315                 :            :         bool                            use_conn_in_rdma_mode;
    1316                 :            :         int                             retries;
    1317                 :            : };
    1318                 :            : 
    1319                 :            : struct nfs41_bind_conn_to_session_res {
    1320                 :            :         struct nfs4_sessionid           sessionid;
    1321                 :            :         u32                             dir;
    1322                 :            :         bool                            use_conn_in_rdma_mode;
    1323                 :            : };
    1324                 :            : 
    1325                 :            : struct nfs41_exchange_id_res {
    1326                 :            :         u64                             clientid;
    1327                 :            :         u32                             seqid;
    1328                 :            :         u32                             flags;
    1329                 :            :         struct nfs41_server_owner       *server_owner;
    1330                 :            :         struct nfs41_server_scope       *server_scope;
    1331                 :            :         struct nfs41_impl_id            *impl_id;
    1332                 :            :         struct nfs41_state_protection   state_protect;
    1333                 :            : };
    1334                 :            : 
    1335                 :            : struct nfs41_create_session_args {
    1336                 :            :         struct nfs_client              *client;
    1337                 :            :         u64                             clientid;
    1338                 :            :         uint32_t                        seqid;
    1339                 :            :         uint32_t                        flags;
    1340                 :            :         uint32_t                        cb_program;
    1341                 :            :         struct nfs4_channel_attrs       fc_attrs;       /* Fore Channel */
    1342                 :            :         struct nfs4_channel_attrs       bc_attrs;       /* Back Channel */
    1343                 :            : };
    1344                 :            : 
    1345                 :            : struct nfs41_create_session_res {
    1346                 :            :         struct nfs4_sessionid           sessionid;
    1347                 :            :         uint32_t                        seqid;
    1348                 :            :         uint32_t                        flags;
    1349                 :            :         struct nfs4_channel_attrs       fc_attrs;       /* Fore Channel */
    1350                 :            :         struct nfs4_channel_attrs       bc_attrs;       /* Back Channel */
    1351                 :            : };
    1352                 :            : 
    1353                 :            : struct nfs41_reclaim_complete_args {
    1354                 :            :         struct nfs4_sequence_args       seq_args;
    1355                 :            :         /* In the future extend to include curr_fh for use with migration */
    1356                 :            :         unsigned char                   one_fs:1;
    1357                 :            : };
    1358                 :            : 
    1359                 :            : struct nfs41_reclaim_complete_res {
    1360                 :            :         struct nfs4_sequence_res        seq_res;
    1361                 :            : };
    1362                 :            : 
    1363                 :            : #define SECINFO_STYLE_CURRENT_FH 0
    1364                 :            : #define SECINFO_STYLE_PARENT 1
    1365                 :            : struct nfs41_secinfo_no_name_args {
    1366                 :            :         struct nfs4_sequence_args       seq_args;
    1367                 :            :         int                             style;
    1368                 :            : };
    1369                 :            : 
    1370                 :            : struct nfs41_test_stateid_args {
    1371                 :            :         struct nfs4_sequence_args       seq_args;
    1372                 :            :         nfs4_stateid                    *stateid;
    1373                 :            : };
    1374                 :            : 
    1375                 :            : struct nfs41_test_stateid_res {
    1376                 :            :         struct nfs4_sequence_res        seq_res;
    1377                 :            :         unsigned int                    status;
    1378                 :            : };
    1379                 :            : 
    1380                 :            : struct nfs41_free_stateid_args {
    1381                 :            :         struct nfs4_sequence_args       seq_args;
    1382                 :            :         nfs4_stateid                    stateid;
    1383                 :            : };
    1384                 :            : 
    1385                 :            : struct nfs41_free_stateid_res {
    1386                 :            :         struct nfs4_sequence_res        seq_res;
    1387                 :            :         unsigned int                    status;
    1388                 :            : };
    1389                 :            : 
    1390                 :            : static inline void
    1391                 :            : nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
    1392                 :            : {
    1393                 :          0 :         kfree(cinfo->buckets);
    1394                 :            : }
    1395                 :            : 
    1396                 :            : #else
    1397                 :            : 
    1398                 :            : struct pnfs_ds_commit_info {
    1399                 :            : };
    1400                 :            : 
    1401                 :            : static inline void
    1402                 :            : nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
    1403                 :            : {
    1404                 :            : }
    1405                 :            : 
    1406                 :            : #endif /* CONFIG_NFS_V4_1 */
    1407                 :            : 
    1408                 :            : #ifdef CONFIG_NFS_V4_2
    1409                 :            : struct nfs42_falloc_args {
    1410                 :            :         struct nfs4_sequence_args       seq_args;
    1411                 :            : 
    1412                 :            :         struct nfs_fh                   *falloc_fh;
    1413                 :            :         nfs4_stateid                     falloc_stateid;
    1414                 :            :         u64                              falloc_offset;
    1415                 :            :         u64                              falloc_length;
    1416                 :            :         const u32                       *falloc_bitmask;
    1417                 :            : };
    1418                 :            : 
    1419                 :            : struct nfs42_falloc_res {
    1420                 :            :         struct nfs4_sequence_res        seq_res;
    1421                 :            :         unsigned int                    status;
    1422                 :            : 
    1423                 :            :         struct nfs_fattr                *falloc_fattr;
    1424                 :            :         const struct nfs_server         *falloc_server;
    1425                 :            : };
    1426                 :            : 
    1427                 :            : struct nfs42_copy_args {
    1428                 :            :         struct nfs4_sequence_args       seq_args;
    1429                 :            : 
    1430                 :            :         struct nfs_fh                   *src_fh;
    1431                 :            :         nfs4_stateid                    src_stateid;
    1432                 :            :         u64                             src_pos;
    1433                 :            : 
    1434                 :            :         struct nfs_fh                   *dst_fh;
    1435                 :            :         nfs4_stateid                    dst_stateid;
    1436                 :            :         u64                             dst_pos;
    1437                 :            : 
    1438                 :            :         u64                             count;
    1439                 :            :         bool                            sync;
    1440                 :            : };
    1441                 :            : 
    1442                 :            : struct nfs42_write_res {
    1443                 :            :         nfs4_stateid            stateid;
    1444                 :            :         u64                     count;
    1445                 :            :         struct nfs_writeverf    verifier;
    1446                 :            : };
    1447                 :            : 
    1448                 :            : struct nfs42_copy_res {
    1449                 :            :         struct nfs4_sequence_res        seq_res;
    1450                 :            :         struct nfs42_write_res          write_res;
    1451                 :            :         bool                            consecutive;
    1452                 :            :         bool                            synchronous;
    1453                 :            :         struct nfs_commitres            commit_res;
    1454                 :            : };
    1455                 :            : 
    1456                 :            : struct nfs42_offload_status_args {
    1457                 :            :         struct nfs4_sequence_args       osa_seq_args;
    1458                 :            :         struct nfs_fh                   *osa_src_fh;
    1459                 :            :         nfs4_stateid                    osa_stateid;
    1460                 :            : };
    1461                 :            : 
    1462                 :            : struct nfs42_offload_status_res {
    1463                 :            :         struct nfs4_sequence_res        osr_seq_res;
    1464                 :            :         uint64_t                        osr_count;
    1465                 :            :         int                             osr_status;
    1466                 :            : };
    1467                 :            : 
    1468                 :            : struct nfs42_seek_args {
    1469                 :            :         struct nfs4_sequence_args       seq_args;
    1470                 :            : 
    1471                 :            :         struct nfs_fh                   *sa_fh;
    1472                 :            :         nfs4_stateid                    sa_stateid;
    1473                 :            :         u64                             sa_offset;
    1474                 :            :         u32                             sa_what;
    1475                 :            : };
    1476                 :            : 
    1477                 :            : struct nfs42_seek_res {
    1478                 :            :         struct nfs4_sequence_res        seq_res;
    1479                 :            :         unsigned int                    status;
    1480                 :            : 
    1481                 :            :         u32     sr_eof;
    1482                 :            :         u64     sr_offset;
    1483                 :            : };
    1484                 :            : #endif
    1485                 :            : 
    1486                 :            : struct nfs_page;
    1487                 :            : 
    1488                 :            : #define NFS_PAGEVEC_SIZE        (8U)
    1489                 :            : 
    1490                 :            : struct nfs_page_array {
    1491                 :            :         struct page             **pagevec;
    1492                 :            :         unsigned int            npages;         /* Max length of pagevec */
    1493                 :            :         struct page             *page_array[NFS_PAGEVEC_SIZE];
    1494                 :            : };
    1495                 :            : 
    1496                 :            : /* used as flag bits in nfs_pgio_header */
    1497                 :            : enum {
    1498                 :            :         NFS_IOHDR_ERROR = 0,
    1499                 :            :         NFS_IOHDR_EOF,
    1500                 :            :         NFS_IOHDR_REDO,
    1501                 :            :         NFS_IOHDR_STAT,
    1502                 :            :         NFS_IOHDR_RESEND_PNFS,
    1503                 :            :         NFS_IOHDR_RESEND_MDS,
    1504                 :            : };
    1505                 :            : 
    1506                 :            : struct nfs_io_completion;
    1507                 :            : struct nfs_pgio_header {
    1508                 :            :         struct inode            *inode;
    1509                 :            :         const struct cred               *cred;
    1510                 :            :         struct list_head        pages;
    1511                 :            :         struct nfs_page         *req;
    1512                 :            :         struct nfs_writeverf    verf;           /* Used for writes */
    1513                 :            :         fmode_t                 rw_mode;
    1514                 :            :         struct pnfs_layout_segment *lseg;
    1515                 :            :         loff_t                  io_start;
    1516                 :            :         const struct rpc_call_ops *mds_ops;
    1517                 :            :         void (*release) (struct nfs_pgio_header *hdr);
    1518                 :            :         const struct nfs_pgio_completion_ops *completion_ops;
    1519                 :            :         const struct nfs_rw_ops *rw_ops;
    1520                 :            :         struct nfs_io_completion *io_completion;
    1521                 :            :         struct nfs_direct_req   *dreq;
    1522                 :            : 
    1523                 :            :         int                     pnfs_error;
    1524                 :            :         int                     error;          /* merge with pnfs_error */
    1525                 :            :         unsigned int            good_bytes;     /* boundary of good data */
    1526                 :            :         unsigned long           flags;
    1527                 :            : 
    1528                 :            :         /*
    1529                 :            :          * rpc data
    1530                 :            :          */
    1531                 :            :         struct rpc_task         task;
    1532                 :            :         struct nfs_fattr        fattr;
    1533                 :            :         struct nfs_pgio_args    args;           /* argument struct */
    1534                 :            :         struct nfs_pgio_res     res;            /* result struct */
    1535                 :            :         unsigned long           timestamp;      /* For lease renewal */
    1536                 :            :         int (*pgio_done_cb)(struct rpc_task *, struct nfs_pgio_header *);
    1537                 :            :         __u64                   mds_offset;     /* Filelayout dense stripe */
    1538                 :            :         struct nfs_page_array   page_array;
    1539                 :            :         struct nfs_client       *ds_clp;        /* pNFS data server */
    1540                 :            :         int                     ds_commit_idx;  /* ds index if ds_clp is set */
    1541                 :            :         int                     pgio_mirror_idx;/* mirror index in pgio layer */
    1542                 :            : };
    1543                 :            : 
    1544                 :            : struct nfs_mds_commit_info {
    1545                 :            :         atomic_t rpcs_out;
    1546                 :            :         atomic_long_t           ncommit;
    1547                 :            :         struct list_head        list;
    1548                 :            : };
    1549                 :            : 
    1550                 :            : struct nfs_commit_info;
    1551                 :            : struct nfs_commit_data;
    1552                 :            : struct nfs_inode;
    1553                 :            : struct nfs_commit_completion_ops {
    1554                 :            :         void (*completion) (struct nfs_commit_data *data);
    1555                 :            :         void (*resched_write) (struct nfs_commit_info *, struct nfs_page *);
    1556                 :            : };
    1557                 :            : 
    1558                 :            : struct nfs_commit_info {
    1559                 :            :         struct inode                    *inode; /* Needed for inode->i_lock */
    1560                 :            :         struct nfs_mds_commit_info      *mds;
    1561                 :            :         struct pnfs_ds_commit_info      *ds;
    1562                 :            :         struct nfs_direct_req           *dreq;  /* O_DIRECT request */
    1563                 :            :         const struct nfs_commit_completion_ops *completion_ops;
    1564                 :            : };
    1565                 :            : 
    1566                 :            : struct nfs_commit_data {
    1567                 :            :         struct rpc_task         task;
    1568                 :            :         struct inode            *inode;
    1569                 :            :         const struct cred               *cred;
    1570                 :            :         struct nfs_fattr        fattr;
    1571                 :            :         struct nfs_writeverf    verf;
    1572                 :            :         struct list_head        pages;          /* Coalesced requests we wish to flush */
    1573                 :            :         struct list_head        list;           /* lists of struct nfs_write_data */
    1574                 :            :         struct nfs_direct_req   *dreq;          /* O_DIRECT request */
    1575                 :            :         struct nfs_commitargs   args;           /* argument struct */
    1576                 :            :         struct nfs_commitres    res;            /* result struct */
    1577                 :            :         struct nfs_open_context *context;
    1578                 :            :         struct pnfs_layout_segment *lseg;
    1579                 :            :         struct nfs_client       *ds_clp;        /* pNFS data server */
    1580                 :            :         int                     ds_commit_index;
    1581                 :            :         loff_t                  lwb;
    1582                 :            :         const struct rpc_call_ops *mds_ops;
    1583                 :            :         const struct nfs_commit_completion_ops *completion_ops;
    1584                 :            :         int (*commit_done_cb) (struct rpc_task *task, struct nfs_commit_data *data);
    1585                 :            :         unsigned long           flags;
    1586                 :            : };
    1587                 :            : 
    1588                 :            : struct nfs_pgio_completion_ops {
    1589                 :            :         void    (*error_cleanup)(struct list_head *head, int);
    1590                 :            :         void    (*init_hdr)(struct nfs_pgio_header *hdr);
    1591                 :            :         void    (*completion)(struct nfs_pgio_header *hdr);
    1592                 :            :         void    (*reschedule_io)(struct nfs_pgio_header *hdr);
    1593                 :            : };
    1594                 :            : 
    1595                 :            : struct nfs_unlinkdata {
    1596                 :            :         struct nfs_removeargs args;
    1597                 :            :         struct nfs_removeres res;
    1598                 :            :         struct dentry *dentry;
    1599                 :            :         wait_queue_head_t wq;
    1600                 :            :         const struct cred *cred;
    1601                 :            :         struct nfs_fattr dir_attr;
    1602                 :            :         long timeout;
    1603                 :            : };
    1604                 :            : 
    1605                 :            : struct nfs_renamedata {
    1606                 :            :         struct nfs_renameargs   args;
    1607                 :            :         struct nfs_renameres    res;
    1608                 :            :         const struct cred       *cred;
    1609                 :            :         struct inode            *old_dir;
    1610                 :            :         struct dentry           *old_dentry;
    1611                 :            :         struct nfs_fattr        old_fattr;
    1612                 :            :         struct inode            *new_dir;
    1613                 :            :         struct dentry           *new_dentry;
    1614                 :            :         struct nfs_fattr        new_fattr;
    1615                 :            :         void (*complete)(struct rpc_task *, struct nfs_renamedata *);
    1616                 :            :         long timeout;
    1617                 :            :         bool cancelled;
    1618                 :            : };
    1619                 :            : 
    1620                 :            : struct nfs_access_entry;
    1621                 :            : struct nfs_client;
    1622                 :            : struct rpc_timeout;
    1623                 :            : struct nfs_subversion;
    1624                 :            : struct nfs_mount_info;
    1625                 :            : struct nfs_client_initdata;
    1626                 :            : struct nfs_pageio_descriptor;
    1627                 :            : 
    1628                 :            : /*
    1629                 :            :  * RPC procedure vector for NFSv2/NFSv3 demuxing
    1630                 :            :  */
    1631                 :            : struct nfs_rpc_ops {
    1632                 :            :         u32     version;                /* Protocol version */
    1633                 :            :         const struct dentry_operations *dentry_ops;
    1634                 :            :         const struct inode_operations *dir_inode_ops;
    1635                 :            :         const struct inode_operations *file_inode_ops;
    1636                 :            :         const struct file_operations *file_ops;
    1637                 :            :         const struct nlmclnt_operations *nlmclnt_ops;
    1638                 :            : 
    1639                 :            :         int     (*getroot) (struct nfs_server *, struct nfs_fh *,
    1640                 :            :                             struct nfs_fsinfo *);
    1641                 :            :         struct vfsmount *(*submount) (struct nfs_server *, struct dentry *,
    1642                 :            :                                       struct nfs_fh *, struct nfs_fattr *);
    1643                 :            :         struct dentry *(*try_mount) (int, const char *, struct nfs_mount_info *,
    1644                 :            :                                      struct nfs_subversion *);
    1645                 :            :         int     (*getattr) (struct nfs_server *, struct nfs_fh *,
    1646                 :            :                             struct nfs_fattr *, struct nfs4_label *,
    1647                 :            :                             struct inode *);
    1648                 :            :         int     (*setattr) (struct dentry *, struct nfs_fattr *,
    1649                 :            :                             struct iattr *);
    1650                 :            :         int     (*lookup)  (struct inode *, const struct qstr *,
    1651                 :            :                             struct nfs_fh *, struct nfs_fattr *,
    1652                 :            :                             struct nfs4_label *);
    1653                 :            :         int     (*lookupp) (struct inode *, struct nfs_fh *,
    1654                 :            :                             struct nfs_fattr *, struct nfs4_label *);
    1655                 :            :         int     (*access)  (struct inode *, struct nfs_access_entry *);
    1656                 :            :         int     (*readlink)(struct inode *, struct page *, unsigned int,
    1657                 :            :                             unsigned int);
    1658                 :            :         int     (*create)  (struct inode *, struct dentry *,
    1659                 :            :                             struct iattr *, int);
    1660                 :            :         int     (*remove)  (struct inode *, struct dentry *);
    1661                 :            :         void    (*unlink_setup)  (struct rpc_message *, struct dentry *, struct inode *);
    1662                 :            :         void    (*unlink_rpc_prepare) (struct rpc_task *, struct nfs_unlinkdata *);
    1663                 :            :         int     (*unlink_done) (struct rpc_task *, struct inode *);
    1664                 :            :         void    (*rename_setup)  (struct rpc_message *msg,
    1665                 :            :                         struct dentry *old_dentry,
    1666                 :            :                         struct dentry *new_dentry);
    1667                 :            :         void    (*rename_rpc_prepare)(struct rpc_task *task, struct nfs_renamedata *);
    1668                 :            :         int     (*rename_done) (struct rpc_task *task, struct inode *old_dir, struct inode *new_dir);
    1669                 :            :         int     (*link)    (struct inode *, struct inode *, const struct qstr *);
    1670                 :            :         int     (*symlink) (struct inode *, struct dentry *, struct page *,
    1671                 :            :                             unsigned int, struct iattr *);
    1672                 :            :         int     (*mkdir)   (struct inode *, struct dentry *, struct iattr *);
    1673                 :            :         int     (*rmdir)   (struct inode *, const struct qstr *);
    1674                 :            :         int     (*readdir) (struct dentry *, const struct cred *,
    1675                 :            :                             u64, struct page **, unsigned int, bool);
    1676                 :            :         int     (*mknod)   (struct inode *, struct dentry *, struct iattr *,
    1677                 :            :                             dev_t);
    1678                 :            :         int     (*statfs)  (struct nfs_server *, struct nfs_fh *,
    1679                 :            :                             struct nfs_fsstat *);
    1680                 :            :         int     (*fsinfo)  (struct nfs_server *, struct nfs_fh *,
    1681                 :            :                             struct nfs_fsinfo *);
    1682                 :            :         int     (*pathconf) (struct nfs_server *, struct nfs_fh *,
    1683                 :            :                              struct nfs_pathconf *);
    1684                 :            :         int     (*set_capabilities)(struct nfs_server *, struct nfs_fh *);
    1685                 :            :         int     (*decode_dirent)(struct xdr_stream *, struct nfs_entry *, bool);
    1686                 :            :         int     (*pgio_rpc_prepare)(struct rpc_task *,
    1687                 :            :                                     struct nfs_pgio_header *);
    1688                 :            :         void    (*read_setup)(struct nfs_pgio_header *, struct rpc_message *);
    1689                 :            :         int     (*read_done)(struct rpc_task *, struct nfs_pgio_header *);
    1690                 :            :         void    (*write_setup)(struct nfs_pgio_header *, struct rpc_message *,
    1691                 :            :                                 struct rpc_clnt **);
    1692                 :            :         int     (*write_done)(struct rpc_task *, struct nfs_pgio_header *);
    1693                 :            :         void    (*commit_setup) (struct nfs_commit_data *, struct rpc_message *,
    1694                 :            :                                 struct rpc_clnt **);
    1695                 :            :         void    (*commit_rpc_prepare)(struct rpc_task *, struct nfs_commit_data *);
    1696                 :            :         int     (*commit_done) (struct rpc_task *, struct nfs_commit_data *);
    1697                 :            :         int     (*lock)(struct file *, int, struct file_lock *);
    1698                 :            :         int     (*lock_check_bounds)(const struct file_lock *);
    1699                 :            :         void    (*clear_acl_cache)(struct inode *);
    1700                 :            :         void    (*close_context)(struct nfs_open_context *ctx, int);
    1701                 :            :         struct inode * (*open_context) (struct inode *dir,
    1702                 :            :                                 struct nfs_open_context *ctx,
    1703                 :            :                                 int open_flags,
    1704                 :            :                                 struct iattr *iattr,
    1705                 :            :                                 int *);
    1706                 :            :         int (*have_delegation)(struct inode *, fmode_t);
    1707                 :            :         struct nfs_client *(*alloc_client) (const struct nfs_client_initdata *);
    1708                 :            :         struct nfs_client *(*init_client) (struct nfs_client *,
    1709                 :            :                                 const struct nfs_client_initdata *);
    1710                 :            :         void    (*free_client) (struct nfs_client *);
    1711                 :            :         struct nfs_server *(*create_server)(struct nfs_mount_info *, struct nfs_subversion *);
    1712                 :            :         struct nfs_server *(*clone_server)(struct nfs_server *, struct nfs_fh *,
    1713                 :            :                                            struct nfs_fattr *, rpc_authflavor_t);
    1714                 :            : };
    1715                 :            : 
    1716                 :            : /*
    1717                 :            :  *      NFS_CALL(getattr, inode, (fattr));
    1718                 :            :  * into
    1719                 :            :  *      NFS_PROTO(inode)->getattr(fattr);
    1720                 :            :  */
    1721                 :            : #define NFS_CALL(op, inode, args)       NFS_PROTO(inode)->op args
    1722                 :            : 
    1723                 :            : /*
    1724                 :            :  * Function vectors etc. for the NFS client
    1725                 :            :  */
    1726                 :            : extern const struct nfs_rpc_ops nfs_v2_clientops;
    1727                 :            : extern const struct nfs_rpc_ops nfs_v3_clientops;
    1728                 :            : extern const struct nfs_rpc_ops nfs_v4_clientops;
    1729                 :            : extern const struct rpc_version nfs_version2;
    1730                 :            : extern const struct rpc_version nfs_version3;
    1731                 :            : extern const struct rpc_version nfs_version4;
    1732                 :            : 
    1733                 :            : extern const struct rpc_version nfsacl_version3;
    1734                 :            : extern const struct rpc_program nfsacl_program;
    1735                 :            : 
    1736                 :            : #endif

Generated by: LCOV version 1.14