blob: beb1e10f446ea6365a6eb810972da2edb9c31c59 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_NFS_XDR_H
2#define _LINUX_NFS_XDR_H
3
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00004#include <linux/nfsacl.h>
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00005#include <linux/sunrpc/gss_api.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006
Chuck Lever40859d72005-11-30 18:09:02 -05007/*
8 * To change the maximum rsize and wsize supported by the NFS client, adjust
9 * NFS_MAX_FILE_IO_SIZE. 64KB is a typical maximum, but some servers can
10 * support a megabyte or more. The default is left at 4096 bytes, which is
11 * reasonable for NFS over UDP.
12 */
13#define NFS_MAX_FILE_IO_SIZE (1048576U)
14#define NFS_DEF_FILE_IO_SIZE (4096U)
15#define NFS_MIN_FILE_IO_SIZE (1024U)
16
Trond Myklebust6926afd2012-01-07 13:22:46 -050017struct nfs4_string {
18 unsigned int len;
19 char *data;
20};
21
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -040022struct nfs_fsid {
23 uint64_t major;
24 uint64_t minor;
Linus Torvalds1da177e2005-04-16 15:20:36 -070025};
26
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -040027/*
28 * Helper for checking equality between 2 fsids.
29 */
30static inline int nfs_fsid_equal(const struct nfs_fsid *a, const struct nfs_fsid *b)
31{
32 return a->major == b->major && a->minor == b->minor;
33}
34
Andy Adamson88034c32012-05-23 05:02:34 -040035struct nfs4_threshold {
36 __u32 bm;
37 __u32 l_type;
38 __u64 rd_sz;
39 __u64 wr_sz;
40 __u64 rd_io_sz;
41 __u64 wr_io_sz;
42};
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044struct nfs_fattr {
Trond Myklebust9e6e70f2009-03-11 14:10:24 -040045 unsigned int valid; /* which fields are valid */
Trond Myklebustbca79472009-03-11 14:10:26 -040046 umode_t mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 __u32 nlink;
Eric W. Biederman54f834c2013-02-01 14:16:29 -080048 kuid_t uid;
49 kgid_t gid;
Richard Kennedy9fa8d662008-08-26 16:23:20 +010050 dev_t rdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 __u64 size;
52 union {
53 struct {
54 __u32 blocksize;
55 __u32 blocks;
56 } nfs2;
57 struct {
58 __u64 used;
59 } nfs3;
60 } du;
Trond Myklebust8b4bdcf2006-06-09 09:34:19 -040061 struct nfs_fsid fsid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 __u64 fileid;
Trond Myklebust28331a42011-04-27 13:47:52 -040063 __u64 mounted_on_fileid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 struct timespec atime;
65 struct timespec mtime;
66 struct timespec ctime;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 __u64 change_attr; /* NFSv4 change attribute */
68 __u64 pre_change_attr;/* pre-op NFSv4 change attribute */
Trond Myklebust1ca277d2009-03-11 14:10:25 -040069 __u64 pre_size; /* pre_op_attr.size */
70 struct timespec pre_mtime; /* pre_op_attr.mtime */
71 struct timespec pre_ctime; /* pre_op_attr.ctime */
Trond Myklebust33801142005-10-27 22:12:39 -040072 unsigned long time_start;
Trond Myklebust4704f0e2008-10-14 19:16:07 -040073 unsigned long gencount;
Trond Myklebust6926afd2012-01-07 13:22:46 -050074 struct nfs4_string *owner_name;
75 struct nfs4_string *group_name;
Andy Adamson88034c32012-05-23 05:02:34 -040076 struct nfs4_threshold *mdsthreshold; /* pNFS threshold hints */
Linus Torvalds1da177e2005-04-16 15:20:36 -070077};
78
Trond Myklebust9e6e70f2009-03-11 14:10:24 -040079#define NFS_ATTR_FATTR_TYPE (1U << 0)
80#define NFS_ATTR_FATTR_MODE (1U << 1)
81#define NFS_ATTR_FATTR_NLINK (1U << 2)
82#define NFS_ATTR_FATTR_OWNER (1U << 3)
83#define NFS_ATTR_FATTR_GROUP (1U << 4)
84#define NFS_ATTR_FATTR_RDEV (1U << 5)
85#define NFS_ATTR_FATTR_SIZE (1U << 6)
86#define NFS_ATTR_FATTR_PRESIZE (1U << 7)
87#define NFS_ATTR_FATTR_BLOCKS_USED (1U << 8)
88#define NFS_ATTR_FATTR_SPACE_USED (1U << 9)
89#define NFS_ATTR_FATTR_FSID (1U << 10)
90#define NFS_ATTR_FATTR_FILEID (1U << 11)
91#define NFS_ATTR_FATTR_ATIME (1U << 12)
92#define NFS_ATTR_FATTR_MTIME (1U << 13)
93#define NFS_ATTR_FATTR_CTIME (1U << 14)
94#define NFS_ATTR_FATTR_PREMTIME (1U << 15)
95#define NFS_ATTR_FATTR_PRECTIME (1U << 16)
96#define NFS_ATTR_FATTR_CHANGE (1U << 17)
97#define NFS_ATTR_FATTR_PRECHANGE (1U << 18)
Chuck Lever81934dd2012-03-01 17:01:57 -050098#define NFS_ATTR_FATTR_V4_LOCATIONS (1U << 19)
99#define NFS_ATTR_FATTR_V4_REFERRAL (1U << 20)
100#define NFS_ATTR_FATTR_MOUNTPOINT (1U << 21)
101#define NFS_ATTR_FATTR_MOUNTED_ON_FILEID (1U << 22)
102#define NFS_ATTR_FATTR_OWNER_NAME (1U << 23)
103#define NFS_ATTR_FATTR_GROUP_NAME (1U << 24)
David Quigleye64a4212013-05-22 12:50:39 -0400104#define NFS_ATTR_FATTR_V4_SECURITY_LABEL (1U << 25)
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400105
106#define NFS_ATTR_FATTR (NFS_ATTR_FATTR_TYPE \
107 | NFS_ATTR_FATTR_MODE \
108 | NFS_ATTR_FATTR_NLINK \
109 | NFS_ATTR_FATTR_OWNER \
110 | NFS_ATTR_FATTR_GROUP \
111 | NFS_ATTR_FATTR_RDEV \
112 | NFS_ATTR_FATTR_SIZE \
113 | NFS_ATTR_FATTR_FSID \
114 | NFS_ATTR_FATTR_FILEID \
115 | NFS_ATTR_FATTR_ATIME \
116 | NFS_ATTR_FATTR_MTIME \
Trond Myklebust3a1556e2012-04-27 13:48:18 -0400117 | NFS_ATTR_FATTR_CTIME \
118 | NFS_ATTR_FATTR_CHANGE)
Trond Myklebust9e6e70f2009-03-11 14:10:24 -0400119#define NFS_ATTR_FATTR_V2 (NFS_ATTR_FATTR \
120 | NFS_ATTR_FATTR_BLOCKS_USED)
121#define NFS_ATTR_FATTR_V3 (NFS_ATTR_FATTR \
122 | NFS_ATTR_FATTR_SPACE_USED)
123#define NFS_ATTR_FATTR_V4 (NFS_ATTR_FATTR \
David Quigleye64a4212013-05-22 12:50:39 -0400124 | NFS_ATTR_FATTR_SPACE_USED \
125 | NFS_ATTR_FATTR_V4_SECURITY_LABEL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
127/*
Jeff Layton3132e492016-08-10 15:58:24 -0400128 * Maximal number of supported layout drivers.
129 */
130#define NFS_MAX_LAYOUT_TYPES 8
131
132/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 * Info on the file system
134 */
135struct nfs_fsinfo {
136 struct nfs_fattr *fattr; /* Post-op attributes */
137 __u32 rtmax; /* max. read transfer size */
138 __u32 rtpref; /* pref. read transfer size */
139 __u32 rtmult; /* reads should be multiple of this */
140 __u32 wtmax; /* max. write transfer size */
141 __u32 wtpref; /* pref. write transfer size */
142 __u32 wtmult; /* writes should be multiple of this */
143 __u32 dtpref; /* pref. readdir transfer size */
144 __u64 maxfilesize;
Ricardo Labiaga6b967242010-10-12 16:30:05 -0700145 struct timespec time_delta; /* server time granularity */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 __u32 lease_time; /* in seconds */
Jeff Laytonca440c32016-09-15 14:40:49 -0400147 __u32 nlayouttypes; /* number of layouttypes */
Jeff Layton3132e492016-08-10 15:58:24 -0400148 __u32 layouttype[NFS_MAX_LAYOUT_TYPES]; /* supported pnfs layout driver */
Fred Isamandae100c2011-07-30 20:52:37 -0400149 __u32 blksize; /* preferred pnfs io block size */
Peng Tao2a92ee92015-09-26 02:24:37 +0800150 __u32 clone_blksize; /* granularity of a CLONE operation */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151};
152
153struct nfs_fsstat {
154 struct nfs_fattr *fattr; /* Post-op attributes */
155 __u64 tbytes; /* total size in bytes */
156 __u64 fbytes; /* # of free bytes */
157 __u64 abytes; /* # of bytes available to user */
158 __u64 tfiles; /* # of files */
159 __u64 ffiles; /* # of free files */
160 __u64 afiles; /* # of files available to user */
161};
162
163struct nfs2_fsstat {
164 __u32 tsize; /* Server transfer size */
165 __u32 bsize; /* Filesystem block size */
166 __u32 blocks; /* No. of "bsize" blocks on filesystem */
167 __u32 bfree; /* No. of free "bsize" blocks */
168 __u32 bavail; /* No. of available "bsize" blocks */
169};
170
171struct nfs_pathconf {
172 struct nfs_fattr *fattr; /* Post-op attributes */
173 __u32 max_link; /* max # of hard links */
174 __u32 max_namelen; /* max name length */
175};
176
177struct nfs4_change_info {
178 u32 atomic;
179 u64 before;
180 u64 after;
181};
182
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700183struct nfs_seqid;
Benny Halevy9ff71c32009-04-01 09:21:52 -0400184
Andy Adamson557134a2009-04-01 09:21:53 -0400185/* nfs41 sessions channel attributes */
186struct nfs4_channel_attrs {
Andy Adamson557134a2009-04-01 09:21:53 -0400187 u32 max_rqst_sz;
188 u32 max_resp_sz;
189 u32 max_resp_sz_cached;
190 u32 max_ops;
191 u32 max_reqs;
192};
193
Trond Myklebust76e697b2012-11-26 14:20:49 -0500194struct nfs4_slot;
Benny Halevy9ff71c32009-04-01 09:21:52 -0400195struct nfs4_sequence_args {
Trond Myklebust2b2fa712012-11-16 12:58:36 -0500196 struct nfs4_slot *sa_slot;
Trond Myklebust8fe72ba2012-10-29 19:02:20 -0400197 u8 sa_cache_this : 1,
198 sa_privileged : 1;
Benny Halevy9ff71c32009-04-01 09:21:52 -0400199};
200
201struct nfs4_sequence_res {
Benny Halevydfb4f3092010-09-24 09:17:01 -0400202 struct nfs4_slot *sr_slot; /* slot used to send request */
Trond Myklebust8e63b6a2012-12-15 15:21:52 -0500203 unsigned long sr_timestamp;
Andy Adamsonfbcd4ab2009-04-01 09:22:15 -0400204 int sr_status; /* sequence operation status */
Alexandros Batsakis0629e372009-12-05 13:46:14 -0500205 u32 sr_status_flags;
Trond Myklebustda0507b2012-11-20 18:10:30 -0500206 u32 sr_highest_slotid;
Trond Myklebust464ee9f2012-11-20 12:49:27 -0500207 u32 sr_target_highest_slotid;
Benny Halevy9ff71c32009-04-01 09:21:52 -0400208};
209
Andy Adamson2050f0c2009-04-01 09:22:30 -0400210struct nfs4_get_lease_time_args {
211 struct nfs4_sequence_args la_seq_args;
212};
213
214struct nfs4_get_lease_time_res {
Andy Adamson2050f0c2009-04-01 09:22:30 -0400215 struct nfs4_sequence_res lr_seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -0500216 struct nfs_fsinfo *lr_fsinfo;
Andy Adamson2050f0c2009-04-01 09:22:30 -0400217};
218
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400219#define PNFS_LAYOUT_MAXSIZE 4096
220
221struct nfs4_layoutdriver_data {
Weston Andros Adamson35124a02011-03-24 16:48:21 -0400222 struct page **pages;
223 __u32 pglen;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400224 __u32 len;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400225};
226
227struct pnfs_layout_range {
228 u32 iomode;
229 u64 offset;
230 u64 length;
231};
232
233struct nfs4_layoutget_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500234 struct nfs4_sequence_args seq_args;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400235 __u32 type;
236 struct pnfs_layout_range range;
237 __u64 minlength;
238 __u32 maxcount;
239 struct inode *inode;
240 struct nfs_open_context *ctx;
Fred Isamancf7d63f2011-01-06 11:36:25 +0000241 nfs4_stateid stateid;
Weston Andros Adamson35124a02011-03-24 16:48:21 -0400242 struct nfs4_layoutdriver_data layout;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400243};
244
245struct nfs4_layoutget_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500246 struct nfs4_sequence_res seq_res;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400247 __u32 return_on_close;
248 struct pnfs_layout_range range;
249 __u32 type;
250 nfs4_stateid stateid;
Weston Andros Adamson35124a02011-03-24 16:48:21 -0400251 struct nfs4_layoutdriver_data *layoutp;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400252};
253
254struct nfs4_layoutget {
255 struct nfs4_layoutget_args args;
256 struct nfs4_layoutget_res res;
Trond Myklebust6ab59342013-05-20 10:49:34 -0400257 struct rpc_cred *cred;
Trond Myklebusta75b9df2011-05-11 18:00:51 -0400258 gfp_t gfp_flags;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400259};
260
261struct nfs4_getdeviceinfo_args {
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400262 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -0500263 struct pnfs_device *pdev;
Trond Myklebust4e590802015-03-09 14:01:25 -0400264 __u32 notify_types;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400265};
266
267struct nfs4_getdeviceinfo_res {
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400268 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -0500269 struct pnfs_device *pdev;
Trond Myklebust4e590802015-03-09 14:01:25 -0400270 __u32 notification;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400271};
272
Andy Adamson863a3c62011-03-23 13:27:54 +0000273struct nfs4_layoutcommit_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500274 struct nfs4_sequence_args seq_args;
Andy Adamson863a3c62011-03-23 13:27:54 +0000275 nfs4_stateid stateid;
276 __u64 lastbytewritten;
277 struct inode *inode;
278 const u32 *bitmask;
Christoph Hellwig5f919c92014-08-21 11:09:25 -0500279 size_t layoutupdate_len;
280 struct page *layoutupdate_page;
281 struct page **layoutupdate_pages;
Kinglong Meec8975702016-02-01 09:39:29 +0800282 __be32 *start_p;
Andy Adamson863a3c62011-03-23 13:27:54 +0000283};
284
285struct nfs4_layoutcommit_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500286 struct nfs4_sequence_res seq_res;
Andy Adamson863a3c62011-03-23 13:27:54 +0000287 struct nfs_fattr *fattr;
288 const struct nfs_server *server;
Andy Adamsondb29c082011-07-30 20:52:38 -0400289 int status;
Andy Adamson863a3c62011-03-23 13:27:54 +0000290};
291
292struct nfs4_layoutcommit_data {
293 struct rpc_task task;
294 struct nfs_fattr fattr;
Peng Taoa9bae562011-07-30 20:52:33 -0400295 struct list_head lseg_list;
Andy Adamson863a3c62011-03-23 13:27:54 +0000296 struct rpc_cred *cred;
Trond Myklebust472e2592015-02-05 16:50:30 -0500297 struct inode *inode;
Andy Adamson863a3c62011-03-23 13:27:54 +0000298 struct nfs4_layoutcommit_args args;
299 struct nfs4_layoutcommit_res res;
300};
301
Benny Halevycbe82602011-05-22 19:52:37 +0300302struct nfs4_layoutreturn_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500303 struct nfs4_sequence_args seq_args;
Trond Myklebusta56aaa02011-06-15 11:59:10 -0400304 struct pnfs_layout_hdr *layout;
Benny Halevycbe82602011-05-22 19:52:37 +0300305 struct inode *inode;
Peng Tao15eb67c2014-11-17 09:30:36 +0800306 struct pnfs_layout_range range;
Benny Halevycbe82602011-05-22 19:52:37 +0300307 nfs4_stateid stateid;
Trond Myklebusta56aaa02011-06-15 11:59:10 -0400308 __u32 layout_type;
Benny Halevycbe82602011-05-22 19:52:37 +0300309};
310
311struct nfs4_layoutreturn_res {
312 struct nfs4_sequence_res seq_res;
313 u32 lrs_present;
314 nfs4_stateid stateid;
315};
316
317struct nfs4_layoutreturn {
318 struct nfs4_layoutreturn_args args;
319 struct nfs4_layoutreturn_res res;
320 struct rpc_cred *cred;
321 struct nfs_client *clp;
Trond Myklebust5a0ec8ac2015-02-05 16:35:16 -0500322 struct inode *inode;
Benny Halevycbe82602011-05-22 19:52:37 +0300323 int rpc_status;
324};
325
Trond Myklebustbe3a5d22015-06-23 19:51:55 +0800326#define PNFS_LAYOUTSTATS_MAXSIZE 256
327
328struct nfs42_layoutstat_args;
329struct nfs42_layoutstat_devinfo;
330typedef void (*layoutstats_encode_t)(struct xdr_stream *,
331 struct nfs42_layoutstat_args *,
332 struct nfs42_layoutstat_devinfo *);
333
334/* Per file per deviceid layoutstats */
335struct nfs42_layoutstat_devinfo {
336 struct nfs4_deviceid dev_id;
337 __u64 offset;
338 __u64 length;
339 __u64 read_count;
340 __u64 read_bytes;
341 __u64 write_count;
342 __u64 write_bytes;
343 __u32 layout_type;
344 layoutstats_encode_t layoutstats_encode;
345 void *layout_private;
346};
347
348struct nfs42_layoutstat_args {
349 struct nfs4_sequence_args seq_args;
350 struct nfs_fh *fh;
351 struct inode *inode;
352 nfs4_stateid stateid;
353 int num_dev;
354 struct nfs42_layoutstat_devinfo *devinfo;
355};
356
357struct nfs42_layoutstat_res {
358 struct nfs4_sequence_res seq_res;
359 int num_dev;
360 int rpc_status;
361};
362
363struct nfs42_layoutstat_data {
364 struct inode *inode;
365 struct nfs42_layoutstat_args args;
366 struct nfs42_layoutstat_res res;
367};
368
Peng Tao36022772015-09-26 02:24:34 +0800369struct nfs42_clone_args {
370 struct nfs4_sequence_args seq_args;
371 struct nfs_fh *src_fh;
372 struct nfs_fh *dst_fh;
373 nfs4_stateid src_stateid;
374 nfs4_stateid dst_stateid;
375 __u64 src_offset;
376 __u64 dst_offset;
377 __u64 count;
378 const u32 *dst_bitmask;
379};
380
381struct nfs42_clone_res {
382 struct nfs4_sequence_res seq_res;
383 unsigned int rpc_status;
384 struct nfs_fattr *dst_fattr;
385 const struct nfs_server *server;
386};
387
Trond Myklebust95b72eb2012-04-20 19:24:51 -0400388struct stateowner_id {
389 __u64 create_time;
390 __u32 uniquifier;
391};
392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393/*
394 * Arguments to the open call.
395 */
396struct nfs_openargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500397 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 const struct nfs_fh * fh;
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700399 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 int open_flags;
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500401 fmode_t fmode;
Trond Myklebust6ae37332015-01-30 14:21:14 -0500402 u32 share_access;
Weston Andros Adamson6168f622012-09-10 14:00:46 -0400403 u32 access;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 __u64 clientid;
Trond Myklebust95b72eb2012-04-20 19:24:51 -0400405 struct stateowner_id id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 union {
Trond Myklebustd77d76f2010-06-16 09:52:27 -0400407 struct {
Kinglong Mee5334c5b2015-08-26 21:13:37 +0800408 struct iattr * attrs; /* UNCHECKED, GUARDED, EXCLUSIVE4_1 */
Trond Myklebustd77d76f2010-06-16 09:52:27 -0400409 nfs4_verifier verifier; /* EXCLUSIVE */
410 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 nfs4_stateid delegation; /* CLAIM_DELEGATE_CUR */
Trond Myklebustbd7bf9d2008-12-23 15:21:53 -0500412 fmode_t delegation_type; /* CLAIM_PREVIOUS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 } u;
414 const struct qstr * name;
415 const struct nfs_server *server; /* Needed for ID mapping */
416 const u32 * bitmask;
Trond Myklebust1549210f2012-06-05 09:16:47 -0400417 const u32 * open_bitmap;
Trond Myklebust2a606182015-08-19 22:30:00 -0500418 enum open_claim_type4 claim;
Trond Myklebust549b19c2013-04-16 18:42:34 -0400419 enum createmode4 createmode;
Steve Dicksone058f702013-05-22 12:50:40 -0400420 const struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421};
422
423struct nfs_openres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500424 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 nfs4_stateid stateid;
426 struct nfs_fh fh;
427 struct nfs4_change_info cinfo;
428 __u32 rflags;
429 struct nfs_fattr * f_attr;
Steve Dicksone058f702013-05-22 12:50:40 -0400430 struct nfs4_label *f_label;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400431 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 const struct nfs_server *server;
Trond Myklebustbd7bf9d2008-12-23 15:21:53 -0500433 fmode_t delegation_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 nfs4_stateid delegation;
Trond Myklebust7d160a62015-09-05 19:06:57 -0400435 unsigned long pagemod_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 __u32 do_recall;
Jeff Laytonaa53ed52007-06-05 14:49:03 -0400437 __u32 attrset[NFS4_BITMAP_SIZE];
Trond Myklebust6926afd2012-01-07 13:22:46 -0500438 struct nfs4_string *owner;
439 struct nfs4_string *group_owner;
Weston Andros Adamsonae2bb032012-10-02 14:49:52 -0700440 __u32 access_request;
Weston Andros Adamson6168f622012-09-10 14:00:46 -0400441 __u32 access_supported;
442 __u32 access_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443};
444
445/*
446 * Arguments to the open_confirm call.
447 */
448struct nfs_open_confirmargs {
Trond Myklebust17ead6c2014-02-01 14:53:23 -0500449 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 const struct nfs_fh * fh;
Trond Myklebustcdd4e682006-01-03 09:55:12 +0100451 nfs4_stateid * stateid;
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700452 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453};
454
455struct nfs_open_confirmres {
Trond Myklebust17ead6c2014-02-01 14:53:23 -0500456 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 nfs4_stateid stateid;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400458 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459};
460
461/*
462 * Arguments to the close call.
463 */
464struct nfs_closeargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500465 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 struct nfs_fh * fh;
Trond Myklebust566fcec2015-01-23 15:32:46 -0500467 nfs4_stateid stateid;
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700468 struct nfs_seqid * seqid;
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500469 fmode_t fmode;
Trond Myklebust6ae37332015-01-30 14:21:14 -0500470 u32 share_access;
Trond Myklebust516a6af2005-10-27 22:12:41 -0400471 const u32 * bitmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472};
473
474struct nfs_closeres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500475 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 nfs4_stateid stateid;
Trond Myklebust516a6af2005-10-27 22:12:41 -0400477 struct nfs_fattr * fattr;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400478 struct nfs_seqid * seqid;
Trond Myklebust516a6af2005-10-27 22:12:41 -0400479 const struct nfs_server *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480};
481/*
482 * * Arguments to the lock,lockt, and locku call.
483 * */
484struct nfs_lowner {
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100485 __u64 clientid;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400486 __u64 id;
Trond Myklebustd035c362010-12-21 10:45:27 -0500487 dev_t s_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488};
489
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100490struct nfs_lock_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500491 struct nfs4_sequence_args seq_args;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100492 struct nfs_fh * fh;
493 struct file_lock * fl;
Trond Myklebust06735b32005-10-18 14:20:15 -0700494 struct nfs_seqid * lock_seqid;
Trond Myklebust425c1d42015-01-24 14:57:53 -0500495 nfs4_stateid lock_stateid;
Trond Myklebust06735b32005-10-18 14:20:15 -0700496 struct nfs_seqid * open_seqid;
Trond Myklebust425c1d42015-01-24 14:57:53 -0500497 nfs4_stateid open_stateid;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100498 struct nfs_lowner lock_owner;
499 unsigned char block : 1;
500 unsigned char reclaim : 1;
Trond Myklebustc69899a2015-01-24 16:03:52 -0500501 unsigned char new_lock : 1;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100502 unsigned char new_lock_owner : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503};
504
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100505struct nfs_lock_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500506 struct nfs4_sequence_res seq_res;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400507 nfs4_stateid stateid;
508 struct nfs_seqid * lock_seqid;
509 struct nfs_seqid * open_seqid;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100510};
511
512struct nfs_locku_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500513 struct nfs4_sequence_args seq_args;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100514 struct nfs_fh * fh;
515 struct file_lock * fl;
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700516 struct nfs_seqid * seqid;
Trond Myklebust425c1d42015-01-24 14:57:53 -0500517 nfs4_stateid stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518};
519
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100520struct nfs_locku_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500521 struct nfs4_sequence_res seq_res;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400522 nfs4_stateid stateid;
523 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524};
525
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100526struct nfs_lockt_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500527 struct nfs4_sequence_args seq_args;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100528 struct nfs_fh * fh;
529 struct file_lock * fl;
530 struct nfs_lowner lock_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531};
532
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100533struct nfs_lockt_res {
Benny Halevy9ff71c32009-04-01 09:21:52 -0400534 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -0500535 struct file_lock * denied; /* LOCK, LOCKT failed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536};
537
Trond Myklebustd3c7b7c2010-07-01 12:49:01 -0400538struct nfs_release_lockowner_args {
Trond Myklebustb7e63a12014-02-26 11:19:14 -0800539 struct nfs4_sequence_args seq_args;
Trond Myklebustd3c7b7c2010-07-01 12:49:01 -0400540 struct nfs_lowner lock_owner;
541};
542
Trond Myklebustb7e63a12014-02-26 11:19:14 -0800543struct nfs_release_lockowner_res {
544 struct nfs4_sequence_res seq_res;
545};
546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547struct nfs4_delegreturnargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500548 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 const struct nfs_fh *fhandle;
550 const nfs4_stateid *stateid;
Trond Myklebustfa178f22006-01-03 09:55:38 +0100551 const u32 * bitmask;
552};
553
554struct nfs4_delegreturnres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500555 struct nfs4_sequence_res seq_res;
Trond Myklebustfa178f22006-01-03 09:55:38 +0100556 struct nfs_fattr * fattr;
Trond Myklebust516285eb2015-09-20 16:15:24 -0400557 struct nfs_server *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558};
559
560/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 * Arguments to the write call.
562 */
Trond Myklebust2f2c63b2012-06-08 11:56:09 -0400563struct nfs_write_verifier {
564 char data[8];
565};
566
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567struct nfs_writeverf {
Trond Myklebust2f2c63b2012-06-08 11:56:09 -0400568 struct nfs_write_verifier verifier;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 enum nfs3_stable_how committed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570};
571
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572/*
Anna Schumaker3c6b8992014-05-06 09:12:24 -0400573 * Arguments shared by the read and write call.
574 */
575struct nfs_pgio_args {
576 struct nfs4_sequence_args seq_args;
577 struct nfs_fh * fh;
578 struct nfs_open_context *context;
579 struct nfs_lock_context *lock_context;
580 nfs4_stateid stateid;
581 __u64 offset;
582 __u32 count;
583 unsigned int pgbase;
584 struct page ** pages;
585 const u32 * bitmask; /* used by write */
586 enum nfs3_stable_how stable; /* used by write */
587};
588
Anna Schumaker9137bdf2014-05-06 09:12:25 -0400589struct nfs_pgio_res {
590 struct nfs4_sequence_res seq_res;
591 struct nfs_fattr * fattr;
592 __u32 count;
Peng Taoaabff4d2014-08-27 10:47:14 +0800593 __u32 op_status;
Anna Schumaker9137bdf2014-05-06 09:12:25 -0400594 int eof; /* used by read */
595 struct nfs_writeverf * verf; /* used by write */
596 const struct nfs_server *server; /* used by write */
597
598};
599
Anna Schumaker3c6b8992014-05-06 09:12:24 -0400600/*
Fred Isaman0b7c0152012-04-20 14:47:39 -0400601 * Arguments to the commit call.
602 */
603struct nfs_commitargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500604 struct nfs4_sequence_args seq_args;
Fred Isaman0b7c0152012-04-20 14:47:39 -0400605 struct nfs_fh *fh;
606 __u64 offset;
607 __u32 count;
608 const u32 *bitmask;
Fred Isaman0b7c0152012-04-20 14:47:39 -0400609};
610
611struct nfs_commitres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500612 struct nfs4_sequence_res seq_res;
Peng Taoaabff4d2014-08-27 10:47:14 +0800613 __u32 op_status;
Fred Isaman0b7c0152012-04-20 14:47:39 -0400614 struct nfs_fattr *fattr;
615 struct nfs_writeverf *verf;
616 const struct nfs_server *server;
Fred Isaman0b7c0152012-04-20 14:47:39 -0400617};
618
619/*
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400620 * Common arguments to the unlink call
621 */
622struct nfs_removeargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500623 struct nfs4_sequence_args seq_args;
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400624 const struct nfs_fh *fh;
625 struct qstr name;
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400626};
627
628struct nfs_removeres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500629 struct nfs4_sequence_res seq_res;
Trond Myklebust516285eb2015-09-20 16:15:24 -0400630 struct nfs_server *server;
Trond Myklebustd3468902010-04-16 16:22:50 -0400631 struct nfs_fattr *dir_attr;
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400632 struct nfs4_change_info cinfo;
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400633};
634
635/*
Jeff Layton920769f2010-09-17 17:30:25 -0400636 * Common arguments to the rename call
637 */
638struct nfs_renameargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500639 struct nfs4_sequence_args seq_args;
Jeff Layton920769f2010-09-17 17:30:25 -0400640 const struct nfs_fh *old_dir;
641 const struct nfs_fh *new_dir;
642 const struct qstr *old_name;
643 const struct qstr *new_name;
Jeff Layton920769f2010-09-17 17:30:25 -0400644};
645
Jeff Laytone8582a82010-09-17 17:31:06 -0400646struct nfs_renameres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500647 struct nfs4_sequence_res seq_res;
Trond Myklebust516285eb2015-09-20 16:15:24 -0400648 struct nfs_server *server;
Jeff Laytone8582a82010-09-17 17:31:06 -0400649 struct nfs4_change_info old_cinfo;
650 struct nfs_fattr *old_fattr;
651 struct nfs4_change_info new_cinfo;
652 struct nfs_fattr *new_fattr;
Jeff Laytone8582a82010-09-17 17:31:06 -0400653};
654
Weston Andros Adamsona3f73c22013-10-18 15:15:16 -0400655/* parsed sec= options */
Weston Andros Adamson4d4b69d2013-10-18 15:15:19 -0400656#define NFS_AUTH_INFO_MAX_FLAVORS 12 /* see fs/nfs/super.c */
Weston Andros Adamsona3f73c22013-10-18 15:15:16 -0400657struct nfs_auth_info {
658 unsigned int flavor_len;
Weston Andros Adamson4d4b69d2013-10-18 15:15:19 -0400659 rpc_authflavor_t flavors[NFS_AUTH_INFO_MAX_FLAVORS];
Weston Andros Adamsona3f73c22013-10-18 15:15:16 -0400660};
661
Jeff Layton920769f2010-09-17 17:30:25 -0400662/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 * Argument struct for decode_entry function
664 */
665struct nfs_entry {
666 __u64 ino;
667 __u64 cookie,
668 prev_cookie;
669 const char * name;
670 unsigned int len;
671 int eof;
672 struct nfs_fh * fh;
673 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -0400674 struct nfs4_label *label;
Trond Myklebust0b26a0b2010-11-20 14:26:44 -0500675 unsigned char d_type;
Chuck Lever573c4e12010-12-14 14:58:11 +0000676 struct nfs_server * server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677};
678
679/*
680 * The following types are for NFSv2 only.
681 */
682struct nfs_sattrargs {
683 struct nfs_fh * fh;
684 struct iattr * sattr;
685};
686
687struct nfs_diropargs {
688 struct nfs_fh * fh;
689 const char * name;
690 unsigned int len;
691};
692
693struct nfs_createargs {
694 struct nfs_fh * fh;
695 const char * name;
696 unsigned int len;
697 struct iattr * sattr;
698};
699
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700struct nfs_setattrargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500701 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 struct nfs_fh * fh;
703 nfs4_stateid stateid;
704 struct iattr * iap;
705 const struct nfs_server * server; /* Needed for name mapping */
706 const u32 * bitmask;
Steve Dicksone058f702013-05-22 12:50:40 -0400707 const struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708};
709
J. Bruce Fields23ec6962005-06-22 17:16:22 +0000710struct nfs_setaclargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500711 struct nfs4_sequence_args seq_args;
J. Bruce Fields23ec6962005-06-22 17:16:22 +0000712 struct nfs_fh * fh;
713 size_t acl_len;
J. Bruce Fields23ec6962005-06-22 17:16:22 +0000714 struct page ** acl_pages;
715};
716
Benny Halevy73c403a2009-04-01 09:22:01 -0400717struct nfs_setaclres {
718 struct nfs4_sequence_res seq_res;
719};
720
J. Bruce Fields029d1052005-06-22 17:16:22 +0000721struct nfs_getaclargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500722 struct nfs4_sequence_args seq_args;
J. Bruce Fields029d1052005-06-22 17:16:22 +0000723 struct nfs_fh * fh;
724 size_t acl_len;
J. Bruce Fields029d1052005-06-22 17:16:22 +0000725 struct page ** acl_pages;
726};
727
Andy Adamsonbf118a32011-12-07 11:55:27 -0500728/* getxattr ACL interface flags */
Trond Myklebust1f1ea6c2012-08-26 11:44:43 -0700729#define NFS4_ACL_TRUNC 0x0001 /* ACL was truncated */
Benny Halevy663c79b2009-04-01 09:21:59 -0400730struct nfs_getaclres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500731 struct nfs4_sequence_res seq_res;
Benny Halevy663c79b2009-04-01 09:21:59 -0400732 size_t acl_len;
Andy Adamsonbf118a32011-12-07 11:55:27 -0500733 size_t acl_data_offset;
734 int acl_flags;
Trond Myklebust331818f2012-02-03 18:30:53 -0500735 struct page * acl_scratch;
Benny Halevy663c79b2009-04-01 09:21:59 -0400736};
737
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738struct nfs_setattrres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500739 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -0400741 struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 const struct nfs_server * server;
743};
744
745struct nfs_linkargs {
746 struct nfs_fh * fromfh;
747 struct nfs_fh * tofh;
748 const char * toname;
749 unsigned int tolen;
750};
751
752struct nfs_symlinkargs {
753 struct nfs_fh * fromfh;
754 const char * fromname;
755 unsigned int fromlen;
Chuck Lever94a6d752006-08-22 20:06:23 -0400756 struct page ** pages;
757 unsigned int pathlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 struct iattr * sattr;
759};
760
761struct nfs_readdirargs {
762 struct nfs_fh * fh;
763 __u32 cookie;
764 unsigned int count;
765 struct page ** pages;
766};
767
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000768struct nfs3_getaclargs {
769 struct nfs_fh * fh;
770 int mask;
771 struct page ** pages;
772};
773
774struct nfs3_setaclargs {
775 struct inode * inode;
776 int mask;
777 struct posix_acl * acl_access;
778 struct posix_acl * acl_default;
Trond Myklebustae461412009-03-10 20:33:18 -0400779 size_t len;
780 unsigned int npages;
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000781 struct page ** pages;
782};
783
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784struct nfs_diropok {
785 struct nfs_fh * fh;
786 struct nfs_fattr * fattr;
787};
788
789struct nfs_readlinkargs {
790 struct nfs_fh * fh;
791 unsigned int pgbase;
792 unsigned int pglen;
793 struct page ** pages;
794};
795
796struct nfs3_sattrargs {
797 struct nfs_fh * fh;
798 struct iattr * sattr;
799 unsigned int guard;
800 struct timespec guardtime;
801};
802
803struct nfs3_diropargs {
804 struct nfs_fh * fh;
805 const char * name;
806 unsigned int len;
807};
808
809struct nfs3_accessargs {
810 struct nfs_fh * fh;
811 __u32 access;
812};
813
814struct nfs3_createargs {
815 struct nfs_fh * fh;
816 const char * name;
817 unsigned int len;
818 struct iattr * sattr;
819 enum nfs3_createmode createmode;
Al Virobc4785c2006-10-19 23:28:51 -0700820 __be32 verifier[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821};
822
823struct nfs3_mkdirargs {
824 struct nfs_fh * fh;
825 const char * name;
826 unsigned int len;
827 struct iattr * sattr;
828};
829
830struct nfs3_symlinkargs {
831 struct nfs_fh * fromfh;
832 const char * fromname;
833 unsigned int fromlen;
Chuck Lever94a6d752006-08-22 20:06:23 -0400834 struct page ** pages;
835 unsigned int pathlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 struct iattr * sattr;
837};
838
839struct nfs3_mknodargs {
840 struct nfs_fh * fh;
841 const char * name;
842 unsigned int len;
843 enum nfs3_ftype type;
844 struct iattr * sattr;
845 dev_t rdev;
846};
847
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848struct nfs3_linkargs {
849 struct nfs_fh * fromfh;
850 struct nfs_fh * tofh;
851 const char * toname;
852 unsigned int tolen;
853};
854
855struct nfs3_readdirargs {
856 struct nfs_fh * fh;
857 __u64 cookie;
Al Virobc4785c2006-10-19 23:28:51 -0700858 __be32 verf[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 int plus;
860 unsigned int count;
861 struct page ** pages;
862};
863
864struct nfs3_diropres {
865 struct nfs_fattr * dir_attr;
866 struct nfs_fh * fh;
867 struct nfs_fattr * fattr;
868};
869
870struct nfs3_accessres {
871 struct nfs_fattr * fattr;
872 __u32 access;
873};
874
875struct nfs3_readlinkargs {
876 struct nfs_fh * fh;
877 unsigned int pgbase;
878 unsigned int pglen;
879 struct page ** pages;
880};
881
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882struct nfs3_linkres {
883 struct nfs_fattr * dir_attr;
884 struct nfs_fattr * fattr;
885};
886
887struct nfs3_readdirres {
888 struct nfs_fattr * dir_attr;
Al Virobc4785c2006-10-19 23:28:51 -0700889 __be32 * verf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 int plus;
891};
892
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000893struct nfs3_getaclres {
894 struct nfs_fattr * fattr;
895 int mask;
896 unsigned int acl_access_count;
897 unsigned int acl_default_count;
898 struct posix_acl * acl_access;
899 struct posix_acl * acl_default;
900};
901
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400902#if IS_ENABLED(CONFIG_NFS_V4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
904typedef u64 clientid4;
905
906struct nfs4_accessargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500907 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 const struct nfs_fh * fh;
Trond Myklebust76b32992007-08-10 17:45:11 -0400909 const u32 * bitmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 u32 access;
911};
912
913struct nfs4_accessres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500914 struct nfs4_sequence_res seq_res;
Trond Myklebust76b32992007-08-10 17:45:11 -0400915 const struct nfs_server * server;
916 struct nfs_fattr * fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 u32 supported;
918 u32 access;
919};
920
921struct nfs4_create_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500922 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 u32 ftype;
924 union {
Chuck Lever94a6d752006-08-22 20:06:23 -0400925 struct {
926 struct page ** pages;
927 unsigned int len;
928 } symlink; /* NF4LNK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 struct {
930 u32 specdata1;
931 u32 specdata2;
932 } device; /* NF4BLK, NF4CHR */
933 } u;
934 const struct qstr * name;
935 const struct nfs_server * server;
936 const struct iattr * attrs;
937 const struct nfs_fh * dir_fh;
938 const u32 * bitmask;
Steve Dicksone058f702013-05-22 12:50:40 -0400939 const struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940};
941
942struct nfs4_create_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500943 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 const struct nfs_server * server;
945 struct nfs_fh * fh;
946 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -0400947 struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 struct nfs4_change_info dir_cinfo;
949};
950
951struct nfs4_fsinfo_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500952 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 const struct nfs_fh * fh;
954 const u32 * bitmask;
955};
956
Benny Halevy3dda5e42009-04-01 09:21:57 -0400957struct nfs4_fsinfo_res {
Benny Halevy3dda5e42009-04-01 09:21:57 -0400958 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -0500959 struct nfs_fsinfo *fsinfo;
Benny Halevy3dda5e42009-04-01 09:21:57 -0400960};
961
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962struct nfs4_getattr_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500963 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 const struct nfs_fh * fh;
965 const u32 * bitmask;
966};
967
968struct nfs4_getattr_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500969 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 const struct nfs_server * server;
971 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -0400972 struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973};
974
975struct nfs4_link_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500976 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 const struct nfs_fh * fh;
978 const struct nfs_fh * dir_fh;
979 const struct qstr * name;
Trond Myklebust91ba2ee2005-10-27 22:12:42 -0400980 const u32 * bitmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981};
982
Trond Myklebust91ba2ee2005-10-27 22:12:42 -0400983struct nfs4_link_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500984 struct nfs4_sequence_res seq_res;
Trond Myklebust91ba2ee2005-10-27 22:12:42 -0400985 const struct nfs_server * server;
986 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -0400987 struct nfs4_label *label;
Trond Myklebust91ba2ee2005-10-27 22:12:42 -0400988 struct nfs4_change_info cinfo;
989 struct nfs_fattr * dir_attr;
990};
991
992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993struct nfs4_lookup_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500994 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 const struct nfs_fh * dir_fh;
996 const struct qstr * name;
997 const u32 * bitmask;
998};
999
1000struct nfs4_lookup_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001001 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 const struct nfs_server * server;
1003 struct nfs_fattr * fattr;
1004 struct nfs_fh * fh;
Steve Dicksone058f702013-05-22 12:50:40 -04001005 struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006};
1007
1008struct nfs4_lookup_root_arg {
Benny Halevy9ff71c32009-04-01 09:21:52 -04001009 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001010 const u32 * bitmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011};
1012
1013struct nfs4_pathconf_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001014 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 const struct nfs_fh * fh;
1016 const u32 * bitmask;
1017};
1018
Benny Halevyd45b2982009-04-01 09:21:58 -04001019struct nfs4_pathconf_res {
Benny Halevyd45b2982009-04-01 09:21:58 -04001020 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001021 struct nfs_pathconf *pathconf;
Benny Halevyd45b2982009-04-01 09:21:58 -04001022};
1023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024struct nfs4_readdir_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001025 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 const struct nfs_fh * fh;
1027 u64 cookie;
1028 nfs4_verifier verifier;
1029 u32 count;
1030 struct page ** pages; /* zero-copy data */
1031 unsigned int pgbase; /* zero-copy data */
1032 const u32 * bitmask;
Bryan Schumaker82f2e542010-10-21 16:33:18 -04001033 int plus;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034};
1035
1036struct nfs4_readdir_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001037 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 nfs4_verifier verifier;
1039 unsigned int pgbase;
1040};
1041
1042struct nfs4_readlink {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001043 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 const struct nfs_fh * fh;
1045 unsigned int pgbase;
1046 unsigned int pglen; /* zero-copy data */
1047 struct page ** pages; /* zero-copy data */
1048};
1049
Benny Halevyf50c7002009-04-01 09:21:55 -04001050struct nfs4_readlink_res {
1051 struct nfs4_sequence_res seq_res;
1052};
1053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054struct nfs4_setclientid {
Chuck Levercc38bac2007-12-10 14:56:54 -05001055 const nfs4_verifier * sc_verifier;
Chuck Levercc38bac2007-12-10 14:56:54 -05001056 u32 sc_prog;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 unsigned int sc_netid_len;
Chuck Leverd1ce02e2008-09-25 11:57:12 -04001058 char sc_netid[RPCBIND_MAXNETIDLEN + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 unsigned int sc_uaddr_len;
Chuck Leverd1ce02e2008-09-25 11:57:12 -04001060 char sc_uaddr[RPCBIND_MAXUADDRLEN + 1];
Jeff Layton3a6bb732015-06-09 19:43:57 -04001061 struct nfs_client *sc_clnt;
Jeff Laytonf11b2a12014-06-21 20:52:17 -04001062 struct rpc_cred *sc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063};
1064
Trond Myklebustbb8b27e2010-04-16 16:43:06 -04001065struct nfs4_setclientid_res {
1066 u64 clientid;
1067 nfs4_verifier confirm;
1068};
1069
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070struct nfs4_statfs_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001071 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 const struct nfs_fh * fh;
1073 const u32 * bitmask;
1074};
1075
Benny Halevy24ad1482009-04-01 09:21:56 -04001076struct nfs4_statfs_res {
Benny Halevy24ad1482009-04-01 09:21:56 -04001077 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001078 struct nfs_fsstat *fsstat;
Benny Halevy24ad1482009-04-01 09:21:56 -04001079};
1080
Benny Halevy43652ad2009-04-01 09:21:54 -04001081struct nfs4_server_caps_arg {
Benny Halevy43652ad2009-04-01 09:21:54 -04001082 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001083 struct nfs_fh *fhandle;
Kinglong Mee8c612822015-08-26 21:12:58 +08001084 const u32 * bitmask;
Benny Halevy43652ad2009-04-01 09:21:54 -04001085};
1086
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087struct nfs4_server_caps_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001088 struct nfs4_sequence_res seq_res;
Fred Isamandae100c2011-07-30 20:52:37 -04001089 u32 attr_bitmask[3];
Kinglong Mee8c612822015-08-26 21:12:58 +08001090 u32 exclcreat_bitmask[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 u32 acl_bitmask;
1092 u32 has_links;
1093 u32 has_symlinks;
Chuck Lever264e6352012-03-01 17:02:05 -05001094 u32 fh_expire_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095};
1096
Manoj Naik7aaa0b32006-06-09 09:34:23 -04001097#define NFS4_PATHNAME_MAXCOMPONENTS 512
1098struct nfs4_pathname {
1099 unsigned int ncomponents;
1100 struct nfs4_string components[NFS4_PATHNAME_MAXCOMPONENTS];
1101};
1102
1103#define NFS4_FS_LOCATION_MAXSERVERS 10
1104struct nfs4_fs_location {
1105 unsigned int nservers;
1106 struct nfs4_string servers[NFS4_FS_LOCATION_MAXSERVERS];
1107 struct nfs4_pathname rootpath;
1108};
1109
1110#define NFS4_FS_LOCATIONS_MAXENTRIES 10
1111struct nfs4_fs_locations {
Trond Myklebust683b57b2006-06-09 09:34:22 -04001112 struct nfs_fattr fattr;
1113 const struct nfs_server *server;
Manoj Naik7aaa0b32006-06-09 09:34:23 -04001114 struct nfs4_pathname fs_path;
Trond Myklebust683b57b2006-06-09 09:34:22 -04001115 int nlocations;
Manoj Naik7aaa0b32006-06-09 09:34:23 -04001116 struct nfs4_fs_location locations[NFS4_FS_LOCATIONS_MAXENTRIES];
Trond Myklebust683b57b2006-06-09 09:34:22 -04001117};
1118
1119struct nfs4_fs_locations_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001120 struct nfs4_sequence_args seq_args;
Trond Myklebust683b57b2006-06-09 09:34:22 -04001121 const struct nfs_fh *dir_fh;
Chuck Leverb03d7352013-10-17 14:12:50 -04001122 const struct nfs_fh *fh;
Trond Myklebust683b57b2006-06-09 09:34:22 -04001123 const struct qstr *name;
1124 struct page *page;
1125 const u32 *bitmask;
Chuck Leverb03d7352013-10-17 14:12:50 -04001126 clientid4 clientid;
1127 unsigned char migration:1, renew:1;
Trond Myklebust683b57b2006-06-09 09:34:22 -04001128};
1129
Benny Halevy22958462009-04-01 09:22:02 -04001130struct nfs4_fs_locations_res {
Benny Halevy22958462009-04-01 09:22:02 -04001131 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001132 struct nfs4_fs_locations *fs_locations;
Chuck Leverb03d7352013-10-17 14:12:50 -04001133 unsigned char migration:1, renew:1;
Benny Halevy22958462009-04-01 09:22:02 -04001134};
1135
Chuck Leverfb15b262013-03-16 15:54:34 -04001136struct nfs4_secinfo4 {
1137 u32 flavor;
1138 struct rpcsec_gss_info flavor_info;
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001139};
1140
1141struct nfs4_secinfo_flavors {
Chuck Leverfb15b262013-03-16 15:54:34 -04001142 unsigned int num_flavors;
1143 struct nfs4_secinfo4 flavors[0];
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001144};
1145
1146struct nfs4_secinfo_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001147 struct nfs4_sequence_args seq_args;
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001148 const struct nfs_fh *dir_fh;
1149 const struct qstr *name;
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001150};
1151
1152struct nfs4_secinfo_res {
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001153 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001154 struct nfs4_secinfo_flavors *flavors;
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001155};
1156
Chuck Lever44c99932013-10-17 14:13:30 -04001157struct nfs4_fsid_present_arg {
1158 struct nfs4_sequence_args seq_args;
1159 const struct nfs_fh *fh;
1160 clientid4 clientid;
1161 unsigned char renew:1;
1162};
1163
1164struct nfs4_fsid_present_res {
1165 struct nfs4_sequence_res seq_res;
1166 struct nfs_fh *fh;
1167 unsigned char renew:1;
1168};
1169
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170#endif /* CONFIG_NFS_V4 */
1171
Benny Halevy99fe60d2009-04-01 09:22:29 -04001172struct nfstime4 {
1173 u64 seconds;
1174 u32 nseconds;
1175};
1176
1177#ifdef CONFIG_NFS_V4_1
Fred Isamanea2cf222012-04-20 14:47:53 -04001178
1179struct pnfs_commit_bucket {
1180 struct list_head written;
1181 struct list_head committing;
1182 struct pnfs_layout_segment *wlseg;
1183 struct pnfs_layout_segment *clseg;
Weston Andros Adamson5002c582014-05-15 11:56:54 -04001184 struct nfs_writeverf direct_verf;
Fred Isamanea2cf222012-04-20 14:47:53 -04001185};
1186
1187struct pnfs_ds_commit_info {
1188 int nwritten;
1189 int ncommitting;
1190 int nbuckets;
1191 struct pnfs_commit_bucket *buckets;
1192};
1193
Weston Andros Adamson2031cd12013-08-13 16:37:32 -04001194struct nfs41_state_protection {
1195 u32 how;
1196 struct nfs4_op_map enforce;
1197 struct nfs4_op_map allow;
1198};
1199
Benny Halevy99fe60d2009-04-01 09:22:29 -04001200struct nfs41_exchange_id_args {
1201 struct nfs_client *client;
1202 nfs4_verifier *verifier;
Benny Halevy99fe60d2009-04-01 09:22:29 -04001203 u32 flags;
Weston Andros Adamson2031cd12013-08-13 16:37:32 -04001204 struct nfs41_state_protection state_protect;
Benny Halevy99fe60d2009-04-01 09:22:29 -04001205};
1206
Chuck Leveracdeb692012-05-21 22:46:16 -04001207struct nfs41_server_owner {
Benny Halevy99fe60d2009-04-01 09:22:29 -04001208 uint64_t minor_id;
1209 uint32_t major_id_sz;
1210 char major_id[NFS4_OPAQUE_LIMIT];
1211};
1212
Chuck Lever79d4e1f2012-05-21 22:44:31 -04001213struct nfs41_server_scope {
Benny Halevy99fe60d2009-04-01 09:22:29 -04001214 uint32_t server_scope_sz;
1215 char server_scope[NFS4_OPAQUE_LIMIT];
1216};
1217
Weston Andros Adamson7d2ed9a2012-02-17 15:20:26 -05001218struct nfs41_impl_id {
1219 char domain[NFS4_OPAQUE_LIMIT + 1];
1220 char name[NFS4_OPAQUE_LIMIT + 1];
1221 struct nfstime4 date;
1222};
1223
Trond Myklebust71a097c2015-02-18 09:27:18 -08001224struct nfs41_bind_conn_to_session_args {
1225 struct nfs_client *client;
1226 struct nfs4_sessionid sessionid;
1227 u32 dir;
1228 bool use_conn_in_rdma_mode;
1229};
1230
Weston Andros Adamson7c44f1ae2012-05-24 13:22:50 -04001231struct nfs41_bind_conn_to_session_res {
Trond Myklebust71a097c2015-02-18 09:27:18 -08001232 struct nfs4_sessionid sessionid;
Weston Andros Adamson7c44f1ae2012-05-24 13:22:50 -04001233 u32 dir;
1234 bool use_conn_in_rdma_mode;
1235};
1236
Benny Halevy99fe60d2009-04-01 09:22:29 -04001237struct nfs41_exchange_id_res {
Trond Myklebust32b01312012-05-26 13:41:04 -04001238 u64 clientid;
1239 u32 seqid;
Benny Halevy99fe60d2009-04-01 09:22:29 -04001240 u32 flags;
Chuck Leveracdeb692012-05-21 22:46:16 -04001241 struct nfs41_server_owner *server_owner;
Chuck Lever79d4e1f2012-05-21 22:44:31 -04001242 struct nfs41_server_scope *server_scope;
Weston Andros Adamson7d2ed9a2012-02-17 15:20:26 -05001243 struct nfs41_impl_id *impl_id;
Weston Andros Adamson2031cd12013-08-13 16:37:32 -04001244 struct nfs41_state_protection state_protect;
Benny Halevy99fe60d2009-04-01 09:22:29 -04001245};
Andy Adamsonfc931582009-04-01 09:22:31 -04001246
1247struct nfs41_create_session_args {
1248 struct nfs_client *client;
Trond Myklebust79969dd2015-02-18 11:30:18 -08001249 u64 clientid;
1250 uint32_t seqid;
Andy Adamsonfc931582009-04-01 09:22:31 -04001251 uint32_t flags;
1252 uint32_t cb_program;
1253 struct nfs4_channel_attrs fc_attrs; /* Fore Channel */
1254 struct nfs4_channel_attrs bc_attrs; /* Back Channel */
1255};
1256
1257struct nfs41_create_session_res {
Trond Myklebust79969dd2015-02-18 11:30:18 -08001258 struct nfs4_sessionid sessionid;
1259 uint32_t seqid;
1260 uint32_t flags;
1261 struct nfs4_channel_attrs fc_attrs; /* Fore Channel */
1262 struct nfs4_channel_attrs bc_attrs; /* Back Channel */
Andy Adamsonfc931582009-04-01 09:22:31 -04001263};
Ricardo Labiaga180197532009-12-05 16:08:40 -05001264
1265struct nfs41_reclaim_complete_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001266 struct nfs4_sequence_args seq_args;
Ricardo Labiaga180197532009-12-05 16:08:40 -05001267 /* In the future extend to include curr_fh for use with migration */
1268 unsigned char one_fs:1;
Ricardo Labiaga180197532009-12-05 16:08:40 -05001269};
1270
1271struct nfs41_reclaim_complete_res {
1272 struct nfs4_sequence_res seq_res;
1273};
Bryan Schumakerfca78d62011-06-02 14:59:07 -04001274
1275#define SECINFO_STYLE_CURRENT_FH 0
1276#define SECINFO_STYLE_PARENT 1
1277struct nfs41_secinfo_no_name_args {
Bryan Schumakerfca78d62011-06-02 14:59:07 -04001278 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001279 int style;
Bryan Schumakerfca78d62011-06-02 14:59:07 -04001280};
1281
Bryan Schumaker7d974792011-06-02 14:59:08 -04001282struct nfs41_test_stateid_args {
Bryan Schumaker7d974792011-06-02 14:59:08 -04001283 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001284 nfs4_stateid *stateid;
Bryan Schumaker7d974792011-06-02 14:59:08 -04001285};
1286
1287struct nfs41_test_stateid_res {
Bryan Schumaker7d974792011-06-02 14:59:08 -04001288 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001289 unsigned int status;
Bryan Schumaker7d974792011-06-02 14:59:08 -04001290};
1291
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001292struct nfs41_free_stateid_args {
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001293 struct nfs4_sequence_args seq_args;
Trond Myklebust7c1d5fa2013-05-03 14:40:01 -04001294 nfs4_stateid stateid;
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001295};
1296
1297struct nfs41_free_stateid_res {
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001298 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001299 unsigned int status;
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001300};
1301
Peng Tao8c393f92014-11-05 22:36:50 +08001302static inline void
1303nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
1304{
1305 kfree(cinfo->buckets);
1306}
1307
Trond Myklebust4f976152012-04-30 18:39:20 -04001308#else
1309
1310struct pnfs_ds_commit_info {
1311};
1312
Peng Tao8c393f92014-11-05 22:36:50 +08001313static inline void
1314nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
1315{
1316}
1317
Benny Halevy99fe60d2009-04-01 09:22:29 -04001318#endif /* CONFIG_NFS_V4_1 */
1319
Anna Schumaker1c6dcbe2014-09-26 13:58:48 -04001320#ifdef CONFIG_NFS_V4_2
Anna Schumakerf4ac1672014-11-25 13:18:15 -05001321struct nfs42_falloc_args {
1322 struct nfs4_sequence_args seq_args;
1323
1324 struct nfs_fh *falloc_fh;
1325 nfs4_stateid falloc_stateid;
1326 u64 falloc_offset;
1327 u64 falloc_length;
Anna Schumaker9a519402015-03-16 14:06:23 -04001328 const u32 *falloc_bitmask;
Anna Schumakerf4ac1672014-11-25 13:18:15 -05001329};
1330
1331struct nfs42_falloc_res {
1332 struct nfs4_sequence_res seq_res;
1333 unsigned int status;
Anna Schumaker9a519402015-03-16 14:06:23 -04001334
1335 struct nfs_fattr *falloc_fattr;
1336 const struct nfs_server *falloc_server;
Anna Schumakerf4ac1672014-11-25 13:18:15 -05001337};
1338
Anna Schumaker2e724482013-05-21 16:53:03 -04001339struct nfs42_copy_args {
1340 struct nfs4_sequence_args seq_args;
1341
1342 struct nfs_fh *src_fh;
1343 nfs4_stateid src_stateid;
1344 u64 src_pos;
1345
1346 struct nfs_fh *dst_fh;
1347 nfs4_stateid dst_stateid;
1348 u64 dst_pos;
1349
1350 u64 count;
1351};
1352
1353struct nfs42_write_res {
1354 u64 count;
1355 struct nfs_writeverf verifier;
1356};
1357
1358struct nfs42_copy_res {
1359 struct nfs4_sequence_res seq_res;
1360 struct nfs42_write_res write_res;
1361 bool consecutive;
1362 bool synchronous;
1363};
1364
Anna Schumaker1c6dcbe2014-09-26 13:58:48 -04001365struct nfs42_seek_args {
1366 struct nfs4_sequence_args seq_args;
1367
1368 struct nfs_fh *sa_fh;
1369 nfs4_stateid sa_stateid;
1370 u64 sa_offset;
1371 u32 sa_what;
1372};
1373
1374struct nfs42_seek_res {
1375 struct nfs4_sequence_res seq_res;
1376 unsigned int status;
1377
1378 u32 sr_eof;
1379 u64 sr_offset;
1380};
1381#endif
1382
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383struct nfs_page;
1384
Chuck Lever40859d72005-11-30 18:09:02 -05001385#define NFS_PAGEVEC_SIZE (8U)
1386
Fred Isaman30dd3742012-04-20 14:47:45 -04001387struct nfs_page_array {
1388 struct page **pagevec;
1389 unsigned int npages; /* Max length of pagevec */
1390 struct page *page_array[NFS_PAGEVEC_SIZE];
1391};
1392
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001393/* used as flag bits in nfs_pgio_header */
1394enum {
1395 NFS_IOHDR_ERROR = 0,
1396 NFS_IOHDR_EOF,
1397 NFS_IOHDR_REDO,
Trond Myklebust37e9ed22015-12-22 12:30:24 -05001398 NFS_IOHDR_STAT,
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001399};
1400
Fred Isamancd841602012-04-20 14:47:44 -04001401struct nfs_pgio_header {
1402 struct inode *inode;
1403 struct rpc_cred *cred;
1404 struct list_head pages;
1405 struct nfs_page *req;
Anna Schumakerf79d06f2014-05-06 09:12:28 -04001406 struct nfs_writeverf verf; /* Used for writes */
Fred Isamancd841602012-04-20 14:47:44 -04001407 struct pnfs_layout_segment *lseg;
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001408 loff_t io_start;
Fred Isamancd841602012-04-20 14:47:44 -04001409 const struct rpc_call_ops *mds_ops;
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001410 void (*release) (struct nfs_pgio_header *hdr);
Fred Isaman061ae2e2012-04-20 14:47:48 -04001411 const struct nfs_pgio_completion_ops *completion_ops;
Anna Schumaker4a0de552014-05-06 09:12:30 -04001412 const struct nfs_rw_ops *rw_ops;
Fred Isaman584aa812012-04-20 14:47:51 -04001413 struct nfs_direct_req *dreq;
Peng Taof6166382012-08-02 15:36:09 +03001414 void *layout_private;
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001415 spinlock_t lock;
1416 /* fields protected by lock */
Fred Isamancd841602012-04-20 14:47:44 -04001417 int pnfs_error;
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001418 int error; /* merge with pnfs_error */
1419 unsigned long good_bytes; /* boundary of good data */
1420 unsigned long flags;
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -04001421
1422 /*
1423 * rpc data
1424 */
1425 struct rpc_task task;
1426 struct nfs_fattr fattr;
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -04001427 struct nfs_pgio_args args; /* argument struct */
1428 struct nfs_pgio_res res; /* result struct */
1429 unsigned long timestamp; /* For lease renewal */
1430 int (*pgio_done_cb)(struct rpc_task *, struct nfs_pgio_header *);
1431 __u64 mds_offset; /* Filelayout dense stripe */
1432 struct nfs_page_array page_array;
1433 struct nfs_client *ds_clp; /* pNFS data server */
Weston Andros Adamson6cccbb62014-09-16 17:35:51 -04001434 int ds_commit_idx; /* ds index if ds_clp is set */
Weston Andros Adamsona7d42dd2014-09-19 10:55:07 -04001435 int pgio_mirror_idx;/* mirror index in pgio layer */
Fred Isamancd841602012-04-20 14:47:44 -04001436};
1437
Fred Isamanea2cf222012-04-20 14:47:53 -04001438struct nfs_mds_commit_info {
1439 atomic_t rpcs_out;
1440 unsigned long ncommit;
1441 struct list_head list;
1442};
1443
Trond Myklebustb20135d2015-12-31 09:28:06 -05001444struct nfs_commit_info;
Fred Isamanf453a542012-04-20 14:47:54 -04001445struct nfs_commit_data;
1446struct nfs_inode;
1447struct nfs_commit_completion_ops {
Fred Isamanf453a542012-04-20 14:47:54 -04001448 void (*completion) (struct nfs_commit_data *data);
Trond Myklebustb20135d2015-12-31 09:28:06 -05001449 void (*resched_write) (struct nfs_commit_info *, struct nfs_page *);
Fred Isamanf453a542012-04-20 14:47:54 -04001450};
1451
Fred Isamanea2cf222012-04-20 14:47:53 -04001452struct nfs_commit_info {
Dave Wysochanskife238e62016-04-01 13:45:09 -04001453 struct inode *inode; /* Needed for inode->i_lock */
Fred Isamanea2cf222012-04-20 14:47:53 -04001454 struct nfs_mds_commit_info *mds;
1455 struct pnfs_ds_commit_info *ds;
Fred Isamanb359f9d2012-04-20 14:47:55 -04001456 struct nfs_direct_req *dreq; /* O_DIRECT request */
Fred Isamanf453a542012-04-20 14:47:54 -04001457 const struct nfs_commit_completion_ops *completion_ops;
Fred Isamanea2cf222012-04-20 14:47:53 -04001458};
1459
Fred Isaman0b7c0152012-04-20 14:47:39 -04001460struct nfs_commit_data {
1461 struct rpc_task task;
1462 struct inode *inode;
1463 struct rpc_cred *cred;
1464 struct nfs_fattr fattr;
1465 struct nfs_writeverf verf;
1466 struct list_head pages; /* Coalesced requests we wish to flush */
1467 struct list_head list; /* lists of struct nfs_write_data */
1468 struct nfs_direct_req *dreq; /* O_DIRECT request */
1469 struct nfs_commitargs args; /* argument struct */
1470 struct nfs_commitres res; /* result struct */
1471 struct nfs_open_context *context;
1472 struct pnfs_layout_segment *lseg;
1473 struct nfs_client *ds_clp; /* pNFS data server */
1474 int ds_commit_index;
Peng Tao378520b2014-08-07 10:15:02 +08001475 loff_t lwb;
Fred Isaman0b7c0152012-04-20 14:47:39 -04001476 const struct rpc_call_ops *mds_ops;
Fred Isamanf453a542012-04-20 14:47:54 -04001477 const struct nfs_commit_completion_ops *completion_ops;
Fred Isaman0b7c0152012-04-20 14:47:39 -04001478 int (*commit_done_cb) (struct rpc_task *task, struct nfs_commit_data *data);
Trond Myklebust37e9ed22015-12-22 12:30:24 -05001479 unsigned long flags;
Fred Isaman0b7c0152012-04-20 14:47:39 -04001480};
1481
Fred Isaman061ae2e2012-04-20 14:47:48 -04001482struct nfs_pgio_completion_ops {
1483 void (*error_cleanup)(struct list_head *head);
Fred Isaman584aa812012-04-20 14:47:51 -04001484 void (*init_hdr)(struct nfs_pgio_header *hdr);
Fred Isaman061ae2e2012-04-20 14:47:48 -04001485 void (*completion)(struct nfs_pgio_header *hdr);
Trond Myklebustdc602dd2015-12-31 11:44:06 -05001486 void (*reschedule_io)(struct nfs_pgio_header *hdr);
Fred Isaman061ae2e2012-04-20 14:47:48 -04001487};
1488
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001489struct nfs_unlinkdata {
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001490 struct nfs_removeargs args;
1491 struct nfs_removeres res;
Al Viro884be172016-04-28 23:56:31 -04001492 struct dentry *dentry;
1493 wait_queue_head_t wq;
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001494 struct rpc_cred *cred;
1495 struct nfs_fattr dir_attr;
NeilBrown8478eaa2014-09-18 16:09:27 +10001496 long timeout;
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001497};
1498
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -04001499struct nfs_renamedata {
1500 struct nfs_renameargs args;
1501 struct nfs_renameres res;
1502 struct rpc_cred *cred;
1503 struct inode *old_dir;
1504 struct dentry *old_dentry;
1505 struct nfs_fattr old_fattr;
1506 struct inode *new_dir;
1507 struct dentry *new_dentry;
1508 struct nfs_fattr new_fattr;
Jeff Layton96f9d8c2014-03-17 07:06:54 -04001509 void (*complete)(struct rpc_task *, struct nfs_renamedata *);
NeilBrown8478eaa2014-09-18 16:09:27 +10001510 long timeout;
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -04001511};
1512
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513struct nfs_access_entry;
Andy Adamson45a52a02011-03-01 01:34:08 +00001514struct nfs_client;
Trond Myklebuste0dca7a2011-03-14 18:20:01 -04001515struct rpc_timeout;
Bryan Schumakerff9099f22012-07-30 16:05:18 -04001516struct nfs_subversion;
1517struct nfs_mount_info;
Bryan Schumaker6663ee72012-06-20 15:53:46 -04001518struct nfs_client_initdata;
Bryan Schumaker1abb50882012-06-20 15:53:47 -04001519struct nfs_pageio_descriptor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520
1521/*
1522 * RPC procedure vector for NFSv2/NFSv3 demuxing
1523 */
1524struct nfs_rpc_ops {
Chuck Leverc0e07cb2008-01-14 12:32:05 -05001525 u32 version; /* Protocol version */
Al Virof786aa92009-02-20 05:51:22 +00001526 const struct dentry_operations *dentry_ops;
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001527 const struct inode_operations *dir_inode_ops;
1528 const struct inode_operations *file_inode_ops;
Jeff Layton1788ea62011-11-04 13:31:21 -04001529 const struct file_operations *file_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
1531 int (*getroot) (struct nfs_server *, struct nfs_fh *,
1532 struct nfs_fsinfo *);
Bryan Schumaker281cad42012-04-27 13:27:45 -04001533 struct vfsmount *(*submount) (struct nfs_server *, struct dentry *,
1534 struct nfs_fh *, struct nfs_fattr *);
Bryan Schumakerff9099f22012-07-30 16:05:18 -04001535 struct dentry *(*try_mount) (int, const char *, struct nfs_mount_info *,
1536 struct nfs_subversion *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 int (*getattr) (struct nfs_server *, struct nfs_fh *,
David Quigley1775fd32013-05-22 12:50:42 -04001538 struct nfs_fattr *, struct nfs4_label *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539 int (*setattr) (struct dentry *, struct nfs_fattr *,
1540 struct iattr *);
Al Virobeffb8f2016-07-20 16:34:42 -04001541 int (*lookup) (struct inode *, const struct qstr *,
David Quigley1775fd32013-05-22 12:50:42 -04001542 struct nfs_fh *, struct nfs_fattr *,
1543 struct nfs4_label *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 int (*access) (struct inode *, struct nfs_access_entry *);
1545 int (*readlink)(struct inode *, struct page *, unsigned int,
1546 unsigned int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 int (*create) (struct inode *, struct dentry *,
Miklos Szeredi8867fe52012-06-05 15:10:19 +02001548 struct iattr *, int);
Al Virobeffb8f2016-07-20 16:34:42 -04001549 int (*remove) (struct inode *, const struct qstr *);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -04001550 void (*unlink_setup) (struct rpc_message *, struct inode *dir);
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001551 void (*unlink_rpc_prepare) (struct rpc_task *, struct nfs_unlinkdata *);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -04001552 int (*unlink_done) (struct rpc_task *, struct inode *);
Jeff Laytond3d41522010-09-17 17:31:57 -04001553 void (*rename_setup) (struct rpc_message *msg, struct inode *dir);
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -04001554 void (*rename_rpc_prepare)(struct rpc_task *task, struct nfs_renamedata *);
Jeff Laytond3d41522010-09-17 17:31:57 -04001555 int (*rename_done) (struct rpc_task *task, struct inode *old_dir, struct inode *new_dir);
Al Virobeffb8f2016-07-20 16:34:42 -04001556 int (*link) (struct inode *, struct inode *, const struct qstr *);
Chuck Lever94a6d752006-08-22 20:06:23 -04001557 int (*symlink) (struct inode *, struct dentry *, struct page *,
1558 unsigned int, struct iattr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 int (*mkdir) (struct inode *, struct dentry *, struct iattr *);
Al Virobeffb8f2016-07-20 16:34:42 -04001560 int (*rmdir) (struct inode *, const struct qstr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 int (*readdir) (struct dentry *, struct rpc_cred *,
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -04001562 u64, struct page **, unsigned int, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 int (*mknod) (struct inode *, struct dentry *, struct iattr *,
1564 dev_t);
1565 int (*statfs) (struct nfs_server *, struct nfs_fh *,
1566 struct nfs_fsstat *);
1567 int (*fsinfo) (struct nfs_server *, struct nfs_fh *,
1568 struct nfs_fsinfo *);
1569 int (*pathconf) (struct nfs_server *, struct nfs_fh *,
1570 struct nfs_pathconf *);
David Howellse9326dc2006-08-22 20:06:10 -04001571 int (*set_capabilities)(struct nfs_server *, struct nfs_fh *);
Chuck Lever573c4e12010-12-14 14:58:11 +00001572 int (*decode_dirent)(struct xdr_stream *, struct nfs_entry *, int);
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -04001573 int (*pgio_rpc_prepare)(struct rpc_task *,
1574 struct nfs_pgio_header *);
1575 void (*read_setup)(struct nfs_pgio_header *, struct rpc_message *);
1576 int (*read_done)(struct rpc_task *, struct nfs_pgio_header *);
1577 void (*write_setup)(struct nfs_pgio_header *, struct rpc_message *);
1578 int (*write_done)(struct rpc_task *, struct nfs_pgio_header *);
Fred Isaman0b7c0152012-04-20 14:47:39 -04001579 void (*commit_setup) (struct nfs_commit_data *, struct rpc_message *);
1580 void (*commit_rpc_prepare)(struct rpc_task *, struct nfs_commit_data *);
1581 int (*commit_done) (struct rpc_task *, struct nfs_commit_data *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 int (*lock)(struct file *, int, struct file_lock *);
Trond Myklebust21162712008-05-20 19:34:39 -04001583 int (*lock_check_bounds)(const struct file_lock *);
Trond Myklebustada70d92005-06-22 17:16:22 +00001584 void (*clear_acl_cache)(struct inode *);
Trond Myklebust7fe5c392009-03-19 15:35:50 -04001585 void (*close_context)(struct nfs_open_context *ctx, int);
Trond Myklebust2b484292010-09-17 10:56:51 -04001586 struct inode * (*open_context) (struct inode *dir,
1587 struct nfs_open_context *ctx,
1588 int open_flags,
Trond Myklebust5bc2afc2013-09-23 18:01:28 -04001589 struct iattr *iattr,
1590 int *);
Bryan Schumaker011e2a72012-06-20 15:53:43 -04001591 int (*have_delegation)(struct inode *, fmode_t);
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04001592 int (*return_delegation)(struct inode *);
Bryan Schumaker6663ee72012-06-20 15:53:46 -04001593 struct nfs_client *(*alloc_client) (const struct nfs_client_initdata *);
Trond Myklebust5c6e5b62016-06-22 14:13:12 -04001594 struct nfs_client *(*init_client) (struct nfs_client *,
1595 const struct nfs_client_initdata *);
Bryan Schumakercdb7ece2012-06-20 15:53:45 -04001596 void (*free_client) (struct nfs_client *);
Bryan Schumaker1179acc2012-07-30 16:05:19 -04001597 struct nfs_server *(*create_server)(struct nfs_mount_info *, struct nfs_subversion *);
1598 struct nfs_server *(*clone_server)(struct nfs_server *, struct nfs_fh *,
1599 struct nfs_fattr *, rpc_authflavor_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600};
1601
1602/*
1603 * NFS_CALL(getattr, inode, (fattr));
1604 * into
1605 * NFS_PROTO(inode)->getattr(fattr);
1606 */
1607#define NFS_CALL(op, inode, args) NFS_PROTO(inode)->op args
1608
1609/*
1610 * Function vectors etc. for the NFS client
1611 */
David Howells509de812006-08-22 20:06:11 -04001612extern const struct nfs_rpc_ops nfs_v2_clientops;
1613extern const struct nfs_rpc_ops nfs_v3_clientops;
1614extern const struct nfs_rpc_ops nfs_v4_clientops;
Trond Myklebusta613fa12012-01-20 13:53:56 -05001615extern const struct rpc_version nfs_version2;
1616extern const struct rpc_version nfs_version3;
1617extern const struct rpc_version nfs_version4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618
Trond Myklebusta613fa12012-01-20 13:53:56 -05001619extern const struct rpc_version nfsacl_version3;
1620extern const struct rpc_program nfsacl_program;
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00001621
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622#endif