blob: b64177d669fd938a4e419f823ea1b5e188691170 [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 Myklebust6926afd12012-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 Myklebust6926afd12012-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
Trond Myklebustf8c3cf92016-10-20 10:12:45 -0400219struct xdr_stream;
220struct nfs4_xdr_opaque_data;
221
222struct nfs4_xdr_opaque_ops {
223 void (*encode)(struct xdr_stream *, const void *args,
224 const struct nfs4_xdr_opaque_data *);
225 void (*free)(struct nfs4_xdr_opaque_data *);
226};
227
228struct nfs4_xdr_opaque_data {
229 const struct nfs4_xdr_opaque_ops *ops;
230 void *data;
231};
232
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400233#define PNFS_LAYOUT_MAXSIZE 4096
234
235struct nfs4_layoutdriver_data {
Weston Andros Adamson35124a02011-03-24 16:48:21 -0400236 struct page **pages;
237 __u32 pglen;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400238 __u32 len;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400239};
240
241struct pnfs_layout_range {
242 u32 iomode;
243 u64 offset;
244 u64 length;
245};
246
247struct nfs4_layoutget_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500248 struct nfs4_sequence_args seq_args;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400249 __u32 type;
250 struct pnfs_layout_range range;
251 __u64 minlength;
252 __u32 maxcount;
253 struct inode *inode;
254 struct nfs_open_context *ctx;
Fred Isamancf7d63f2011-01-06 11:36:25 +0000255 nfs4_stateid stateid;
Weston Andros Adamson35124a02011-03-24 16:48:21 -0400256 struct nfs4_layoutdriver_data layout;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400257};
258
259struct nfs4_layoutget_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500260 struct nfs4_sequence_res seq_res;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400261 __u32 return_on_close;
262 struct pnfs_layout_range range;
263 __u32 type;
264 nfs4_stateid stateid;
Weston Andros Adamson35124a02011-03-24 16:48:21 -0400265 struct nfs4_layoutdriver_data *layoutp;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400266};
267
268struct nfs4_layoutget {
269 struct nfs4_layoutget_args args;
270 struct nfs4_layoutget_res res;
Trond Myklebust6ab59342013-05-20 10:49:34 -0400271 struct rpc_cred *cred;
Trond Myklebusta75b9df2011-05-11 18:00:51 -0400272 gfp_t gfp_flags;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400273};
274
275struct nfs4_getdeviceinfo_args {
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400276 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -0500277 struct pnfs_device *pdev;
Trond Myklebust4e590802015-03-09 14:01:25 -0400278 __u32 notify_types;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400279};
280
281struct nfs4_getdeviceinfo_res {
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400282 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -0500283 struct pnfs_device *pdev;
Trond Myklebust4e590802015-03-09 14:01:25 -0400284 __u32 notification;
Andy Adamsonb1f69b72010-10-20 00:18:03 -0400285};
286
Andy Adamson863a3c62011-03-23 13:27:54 +0000287struct nfs4_layoutcommit_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500288 struct nfs4_sequence_args seq_args;
Andy Adamson863a3c62011-03-23 13:27:54 +0000289 nfs4_stateid stateid;
290 __u64 lastbytewritten;
291 struct inode *inode;
292 const u32 *bitmask;
Christoph Hellwig5f919c92014-08-21 11:09:25 -0500293 size_t layoutupdate_len;
294 struct page *layoutupdate_page;
295 struct page **layoutupdate_pages;
Kinglong Meec8975702016-02-01 09:39:29 +0800296 __be32 *start_p;
Andy Adamson863a3c62011-03-23 13:27:54 +0000297};
298
299struct nfs4_layoutcommit_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500300 struct nfs4_sequence_res seq_res;
Andy Adamson863a3c62011-03-23 13:27:54 +0000301 struct nfs_fattr *fattr;
302 const struct nfs_server *server;
Andy Adamsondb29c082011-07-30 20:52:38 -0400303 int status;
Andy Adamson863a3c62011-03-23 13:27:54 +0000304};
305
306struct nfs4_layoutcommit_data {
307 struct rpc_task task;
308 struct nfs_fattr fattr;
Peng Taoa9bae562011-07-30 20:52:33 -0400309 struct list_head lseg_list;
Andy Adamson863a3c62011-03-23 13:27:54 +0000310 struct rpc_cred *cred;
Trond Myklebust472e2592015-02-05 16:50:30 -0500311 struct inode *inode;
Andy Adamson863a3c62011-03-23 13:27:54 +0000312 struct nfs4_layoutcommit_args args;
313 struct nfs4_layoutcommit_res res;
314};
315
Benny Halevycbe82602011-05-22 19:52:37 +0300316struct nfs4_layoutreturn_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500317 struct nfs4_sequence_args seq_args;
Trond Myklebusta56aaa02011-06-15 11:59:10 -0400318 struct pnfs_layout_hdr *layout;
Benny Halevycbe82602011-05-22 19:52:37 +0300319 struct inode *inode;
Peng Tao15eb67c2014-11-17 09:30:36 +0800320 struct pnfs_layout_range range;
Benny Halevycbe82602011-05-22 19:52:37 +0300321 nfs4_stateid stateid;
Trond Myklebusta56aaa02011-06-15 11:59:10 -0400322 __u32 layout_type;
Trond Myklebust4d796d72016-09-23 11:38:08 -0400323 struct nfs4_xdr_opaque_data *ld_private;
Benny Halevycbe82602011-05-22 19:52:37 +0300324};
325
326struct nfs4_layoutreturn_res {
327 struct nfs4_sequence_res seq_res;
328 u32 lrs_present;
329 nfs4_stateid stateid;
330};
331
332struct nfs4_layoutreturn {
333 struct nfs4_layoutreturn_args args;
334 struct nfs4_layoutreturn_res res;
335 struct rpc_cred *cred;
336 struct nfs_client *clp;
Trond Myklebust5a0ec8ac2015-02-05 16:35:16 -0500337 struct inode *inode;
Benny Halevycbe82602011-05-22 19:52:37 +0300338 int rpc_status;
Trond Myklebust4d796d72016-09-23 11:38:08 -0400339 struct nfs4_xdr_opaque_data ld_private;
Benny Halevycbe82602011-05-22 19:52:37 +0300340};
341
Trond Myklebustbe3a5d22015-06-23 19:51:55 +0800342#define PNFS_LAYOUTSTATS_MAXSIZE 256
343
344struct nfs42_layoutstat_args;
345struct nfs42_layoutstat_devinfo;
346typedef void (*layoutstats_encode_t)(struct xdr_stream *,
347 struct nfs42_layoutstat_args *,
348 struct nfs42_layoutstat_devinfo *);
349
350/* Per file per deviceid layoutstats */
351struct nfs42_layoutstat_devinfo {
352 struct nfs4_deviceid dev_id;
353 __u64 offset;
354 __u64 length;
355 __u64 read_count;
356 __u64 read_bytes;
357 __u64 write_count;
358 __u64 write_bytes;
359 __u32 layout_type;
360 layoutstats_encode_t layoutstats_encode;
361 void *layout_private;
362};
363
364struct nfs42_layoutstat_args {
365 struct nfs4_sequence_args seq_args;
366 struct nfs_fh *fh;
367 struct inode *inode;
368 nfs4_stateid stateid;
369 int num_dev;
370 struct nfs42_layoutstat_devinfo *devinfo;
371};
372
373struct nfs42_layoutstat_res {
374 struct nfs4_sequence_res seq_res;
375 int num_dev;
376 int rpc_status;
377};
378
379struct nfs42_layoutstat_data {
380 struct inode *inode;
381 struct nfs42_layoutstat_args args;
382 struct nfs42_layoutstat_res res;
383};
384
Peng Tao36022772015-09-26 02:24:34 +0800385struct nfs42_clone_args {
386 struct nfs4_sequence_args seq_args;
387 struct nfs_fh *src_fh;
388 struct nfs_fh *dst_fh;
389 nfs4_stateid src_stateid;
390 nfs4_stateid dst_stateid;
391 __u64 src_offset;
392 __u64 dst_offset;
393 __u64 count;
394 const u32 *dst_bitmask;
395};
396
397struct nfs42_clone_res {
398 struct nfs4_sequence_res seq_res;
399 unsigned int rpc_status;
400 struct nfs_fattr *dst_fattr;
401 const struct nfs_server *server;
402};
403
Trond Myklebust95b72eb2012-04-20 19:24:51 -0400404struct stateowner_id {
405 __u64 create_time;
406 __u32 uniquifier;
407};
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409/*
410 * Arguments to the open call.
411 */
412struct nfs_openargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500413 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 const struct nfs_fh * fh;
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700415 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 int open_flags;
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500417 fmode_t fmode;
Trond Myklebust6ae37332015-01-30 14:21:14 -0500418 u32 share_access;
Weston Andros Adamson6168f622012-09-10 14:00:46 -0400419 u32 access;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 __u64 clientid;
Trond Myklebust95b72eb2012-04-20 19:24:51 -0400421 struct stateowner_id id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 union {
Trond Myklebustd77d76ff2010-06-16 09:52:27 -0400423 struct {
Kinglong Mee5334c5b2015-08-26 21:13:37 +0800424 struct iattr * attrs; /* UNCHECKED, GUARDED, EXCLUSIVE4_1 */
Trond Myklebustd77d76ff2010-06-16 09:52:27 -0400425 nfs4_verifier verifier; /* EXCLUSIVE */
426 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 nfs4_stateid delegation; /* CLAIM_DELEGATE_CUR */
Trond Myklebustbd7bf9d2008-12-23 15:21:53 -0500428 fmode_t delegation_type; /* CLAIM_PREVIOUS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 } u;
430 const struct qstr * name;
431 const struct nfs_server *server; /* Needed for ID mapping */
432 const u32 * bitmask;
Trond Myklebust1549210f2012-06-05 09:16:47 -0400433 const u32 * open_bitmap;
Trond Myklebust2a606182015-08-19 22:30:00 -0500434 enum open_claim_type4 claim;
Trond Myklebust549b19c2013-04-16 18:42:34 -0400435 enum createmode4 createmode;
Steve Dicksone058f702013-05-22 12:50:40 -0400436 const struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437};
438
439struct nfs_openres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500440 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 nfs4_stateid stateid;
442 struct nfs_fh fh;
443 struct nfs4_change_info cinfo;
444 __u32 rflags;
445 struct nfs_fattr * f_attr;
Steve Dicksone058f702013-05-22 12:50:40 -0400446 struct nfs4_label *f_label;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400447 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 const struct nfs_server *server;
Trond Myklebustbd7bf9d2008-12-23 15:21:53 -0500449 fmode_t delegation_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 nfs4_stateid delegation;
Trond Myklebust7d160a62015-09-05 19:06:57 -0400451 unsigned long pagemod_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 __u32 do_recall;
Jeff Laytonaa53ed52007-06-05 14:49:03 -0400453 __u32 attrset[NFS4_BITMAP_SIZE];
Trond Myklebust6926afd12012-01-07 13:22:46 -0500454 struct nfs4_string *owner;
455 struct nfs4_string *group_owner;
Weston Andros Adamsonae2bb032012-10-02 14:49:52 -0700456 __u32 access_request;
Weston Andros Adamson6168f622012-09-10 14:00:46 -0400457 __u32 access_supported;
458 __u32 access_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459};
460
461/*
462 * Arguments to the open_confirm call.
463 */
464struct nfs_open_confirmargs {
Trond Myklebust17ead6c2014-02-01 14:53:23 -0500465 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 const struct nfs_fh * fh;
Trond Myklebustcdd4e682006-01-03 09:55:12 +0100467 nfs4_stateid * stateid;
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700468 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469};
470
471struct nfs_open_confirmres {
Trond Myklebust17ead6c2014-02-01 14:53:23 -0500472 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 nfs4_stateid stateid;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400474 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475};
476
477/*
478 * Arguments to the close call.
479 */
480struct nfs_closeargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500481 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 struct nfs_fh * fh;
Trond Myklebust566fcec2015-01-23 15:32:46 -0500483 nfs4_stateid stateid;
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700484 struct nfs_seqid * seqid;
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500485 fmode_t fmode;
Trond Myklebust6ae37332015-01-30 14:21:14 -0500486 u32 share_access;
Trond Myklebust516a6af2005-10-27 22:12:41 -0400487 const u32 * bitmask;
Trond Myklebustcf805162016-11-15 14:56:07 -0500488 struct nfs4_layoutreturn_args *lr_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489};
490
491struct nfs_closeres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500492 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 nfs4_stateid stateid;
Trond Myklebust516a6af2005-10-27 22:12:41 -0400494 struct nfs_fattr * fattr;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400495 struct nfs_seqid * seqid;
Trond Myklebust516a6af2005-10-27 22:12:41 -0400496 const struct nfs_server *server;
Trond Myklebustcf805162016-11-15 14:56:07 -0500497 struct nfs4_layoutreturn_res *lr_res;
498 int lr_ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499};
500/*
501 * * Arguments to the lock,lockt, and locku call.
502 * */
503struct nfs_lowner {
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100504 __u64 clientid;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400505 __u64 id;
Trond Myklebustd035c362010-12-21 10:45:27 -0500506 dev_t s_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507};
508
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100509struct nfs_lock_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500510 struct nfs4_sequence_args seq_args;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100511 struct nfs_fh * fh;
512 struct file_lock * fl;
Trond Myklebust06735b32005-10-18 14:20:15 -0700513 struct nfs_seqid * lock_seqid;
Trond Myklebust425c1d42015-01-24 14:57:53 -0500514 nfs4_stateid lock_stateid;
Trond Myklebust06735b32005-10-18 14:20:15 -0700515 struct nfs_seqid * open_seqid;
Trond Myklebust425c1d42015-01-24 14:57:53 -0500516 nfs4_stateid open_stateid;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100517 struct nfs_lowner lock_owner;
518 unsigned char block : 1;
519 unsigned char reclaim : 1;
Trond Myklebustc69899a2015-01-24 16:03:52 -0500520 unsigned char new_lock : 1;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100521 unsigned char new_lock_owner : 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522};
523
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100524struct nfs_lock_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500525 struct nfs4_sequence_res seq_res;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400526 nfs4_stateid stateid;
527 struct nfs_seqid * lock_seqid;
528 struct nfs_seqid * open_seqid;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100529};
530
531struct nfs_locku_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500532 struct nfs4_sequence_args seq_args;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100533 struct nfs_fh * fh;
534 struct file_lock * fl;
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700535 struct nfs_seqid * seqid;
Trond Myklebust425c1d42015-01-24 14:57:53 -0500536 nfs4_stateid stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537};
538
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100539struct nfs_locku_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500540 struct nfs4_sequence_res seq_res;
Trond Myklebustc1d51932008-04-07 13:20:54 -0400541 nfs4_stateid stateid;
542 struct nfs_seqid * seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543};
544
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100545struct nfs_lockt_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500546 struct nfs4_sequence_args seq_args;
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100547 struct nfs_fh * fh;
548 struct file_lock * fl;
549 struct nfs_lowner lock_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550};
551
Trond Myklebust911d1aa2006-01-03 09:55:16 +0100552struct nfs_lockt_res {
Benny Halevy9ff71c32009-04-01 09:21:52 -0400553 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -0500554 struct file_lock * denied; /* LOCK, LOCKT failed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555};
556
Trond Myklebustd3c7b7c2010-07-01 12:49:01 -0400557struct nfs_release_lockowner_args {
Trond Myklebustb7e63a12014-02-26 11:19:14 -0800558 struct nfs4_sequence_args seq_args;
Trond Myklebustd3c7b7c2010-07-01 12:49:01 -0400559 struct nfs_lowner lock_owner;
560};
561
Trond Myklebustb7e63a12014-02-26 11:19:14 -0800562struct nfs_release_lockowner_res {
563 struct nfs4_sequence_res seq_res;
564};
565
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566struct nfs4_delegreturnargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500567 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 const struct nfs_fh *fhandle;
569 const nfs4_stateid *stateid;
Trond Myklebustfa178f22006-01-03 09:55:38 +0100570 const u32 * bitmask;
Trond Myklebust586f1c32016-11-15 15:03:33 -0500571 struct nfs4_layoutreturn_args *lr_args;
Trond Myklebustfa178f22006-01-03 09:55:38 +0100572};
573
574struct nfs4_delegreturnres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500575 struct nfs4_sequence_res seq_res;
Trond Myklebustfa178f22006-01-03 09:55:38 +0100576 struct nfs_fattr * fattr;
Trond Myklebust516285eb2015-09-20 16:15:24 -0400577 struct nfs_server *server;
Trond Myklebust586f1c32016-11-15 15:03:33 -0500578 struct nfs4_layoutreturn_res *lr_res;
579 int lr_ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580};
581
582/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 * Arguments to the write call.
584 */
Trond Myklebust2f2c63b2012-06-08 11:56:09 -0400585struct nfs_write_verifier {
586 char data[8];
587};
588
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589struct nfs_writeverf {
Trond Myklebust2f2c63b2012-06-08 11:56:09 -0400590 struct nfs_write_verifier verifier;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 enum nfs3_stable_how committed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592};
593
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594/*
Anna Schumaker3c6b8992014-05-06 09:12:24 -0400595 * Arguments shared by the read and write call.
596 */
597struct nfs_pgio_args {
598 struct nfs4_sequence_args seq_args;
599 struct nfs_fh * fh;
600 struct nfs_open_context *context;
601 struct nfs_lock_context *lock_context;
602 nfs4_stateid stateid;
603 __u64 offset;
604 __u32 count;
605 unsigned int pgbase;
606 struct page ** pages;
607 const u32 * bitmask; /* used by write */
608 enum nfs3_stable_how stable; /* used by write */
609};
610
Anna Schumaker9137bdf2014-05-06 09:12:25 -0400611struct nfs_pgio_res {
612 struct nfs4_sequence_res seq_res;
613 struct nfs_fattr * fattr;
614 __u32 count;
Peng Taoaabff4d2014-08-27 10:47:14 +0800615 __u32 op_status;
Anna Schumaker9137bdf2014-05-06 09:12:25 -0400616 int eof; /* used by read */
617 struct nfs_writeverf * verf; /* used by write */
618 const struct nfs_server *server; /* used by write */
619
620};
621
Anna Schumaker3c6b8992014-05-06 09:12:24 -0400622/*
Fred Isaman0b7c0152012-04-20 14:47:39 -0400623 * Arguments to the commit call.
624 */
625struct nfs_commitargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500626 struct nfs4_sequence_args seq_args;
Fred Isaman0b7c0152012-04-20 14:47:39 -0400627 struct nfs_fh *fh;
628 __u64 offset;
629 __u32 count;
630 const u32 *bitmask;
Fred Isaman0b7c0152012-04-20 14:47:39 -0400631};
632
633struct nfs_commitres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500634 struct nfs4_sequence_res seq_res;
Peng Taoaabff4d2014-08-27 10:47:14 +0800635 __u32 op_status;
Fred Isaman0b7c0152012-04-20 14:47:39 -0400636 struct nfs_fattr *fattr;
637 struct nfs_writeverf *verf;
638 const struct nfs_server *server;
Fred Isaman0b7c0152012-04-20 14:47:39 -0400639};
640
641/*
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400642 * Common arguments to the unlink call
643 */
644struct nfs_removeargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500645 struct nfs4_sequence_args seq_args;
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400646 const struct nfs_fh *fh;
647 struct qstr name;
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400648};
649
650struct nfs_removeres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500651 struct nfs4_sequence_res seq_res;
Trond Myklebust516285eb2015-09-20 16:15:24 -0400652 struct nfs_server *server;
Trond Myklebustd3468902010-04-16 16:22:50 -0400653 struct nfs_fattr *dir_attr;
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400654 struct nfs4_change_info cinfo;
Trond Myklebust4fdc17b2007-07-14 15:39:57 -0400655};
656
657/*
Jeff Layton920769f2010-09-17 17:30:25 -0400658 * Common arguments to the rename call
659 */
660struct nfs_renameargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500661 struct nfs4_sequence_args seq_args;
Jeff Layton920769f2010-09-17 17:30:25 -0400662 const struct nfs_fh *old_dir;
663 const struct nfs_fh *new_dir;
664 const struct qstr *old_name;
665 const struct qstr *new_name;
Jeff Layton920769f2010-09-17 17:30:25 -0400666};
667
Jeff Laytone8582a82010-09-17 17:31:06 -0400668struct nfs_renameres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500669 struct nfs4_sequence_res seq_res;
Trond Myklebust516285eb2015-09-20 16:15:24 -0400670 struct nfs_server *server;
Jeff Laytone8582a82010-09-17 17:31:06 -0400671 struct nfs4_change_info old_cinfo;
672 struct nfs_fattr *old_fattr;
673 struct nfs4_change_info new_cinfo;
674 struct nfs_fattr *new_fattr;
Jeff Laytone8582a82010-09-17 17:31:06 -0400675};
676
Weston Andros Adamsona3f73c22013-10-18 15:15:16 -0400677/* parsed sec= options */
Weston Andros Adamson4d4b69d2013-10-18 15:15:19 -0400678#define NFS_AUTH_INFO_MAX_FLAVORS 12 /* see fs/nfs/super.c */
Weston Andros Adamsona3f73c22013-10-18 15:15:16 -0400679struct nfs_auth_info {
680 unsigned int flavor_len;
Weston Andros Adamson4d4b69d2013-10-18 15:15:19 -0400681 rpc_authflavor_t flavors[NFS_AUTH_INFO_MAX_FLAVORS];
Weston Andros Adamsona3f73c22013-10-18 15:15:16 -0400682};
683
Jeff Layton920769f2010-09-17 17:30:25 -0400684/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 * Argument struct for decode_entry function
686 */
687struct nfs_entry {
688 __u64 ino;
689 __u64 cookie,
690 prev_cookie;
691 const char * name;
692 unsigned int len;
693 int eof;
694 struct nfs_fh * fh;
695 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -0400696 struct nfs4_label *label;
Trond Myklebust0b26a0b2010-11-20 14:26:44 -0500697 unsigned char d_type;
Chuck Lever573c4e12010-12-14 14:58:11 +0000698 struct nfs_server * server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699};
700
701/*
702 * The following types are for NFSv2 only.
703 */
704struct nfs_sattrargs {
705 struct nfs_fh * fh;
706 struct iattr * sattr;
707};
708
709struct nfs_diropargs {
710 struct nfs_fh * fh;
711 const char * name;
712 unsigned int len;
713};
714
715struct nfs_createargs {
716 struct nfs_fh * fh;
717 const char * name;
718 unsigned int len;
719 struct iattr * sattr;
720};
721
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722struct nfs_setattrargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500723 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 struct nfs_fh * fh;
725 nfs4_stateid stateid;
726 struct iattr * iap;
727 const struct nfs_server * server; /* Needed for name mapping */
728 const u32 * bitmask;
Steve Dicksone058f702013-05-22 12:50:40 -0400729 const struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730};
731
J. Bruce Fields23ec6962005-06-22 17:16:22 +0000732struct nfs_setaclargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500733 struct nfs4_sequence_args seq_args;
J. Bruce Fields23ec6962005-06-22 17:16:22 +0000734 struct nfs_fh * fh;
735 size_t acl_len;
J. Bruce Fields23ec6962005-06-22 17:16:22 +0000736 struct page ** acl_pages;
737};
738
Benny Halevy73c403a2009-04-01 09:22:01 -0400739struct nfs_setaclres {
740 struct nfs4_sequence_res seq_res;
741};
742
J. Bruce Fields029d1052005-06-22 17:16:22 +0000743struct nfs_getaclargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500744 struct nfs4_sequence_args seq_args;
J. Bruce Fields029d1052005-06-22 17:16:22 +0000745 struct nfs_fh * fh;
746 size_t acl_len;
J. Bruce Fields029d1052005-06-22 17:16:22 +0000747 struct page ** acl_pages;
748};
749
Andy Adamsonbf118a32011-12-07 11:55:27 -0500750/* getxattr ACL interface flags */
Trond Myklebust1f1ea6c2012-08-26 11:44:43 -0700751#define NFS4_ACL_TRUNC 0x0001 /* ACL was truncated */
Benny Halevy663c79b2009-04-01 09:21:59 -0400752struct nfs_getaclres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500753 struct nfs4_sequence_res seq_res;
Benny Halevy663c79b2009-04-01 09:21:59 -0400754 size_t acl_len;
Andy Adamsonbf118a32011-12-07 11:55:27 -0500755 size_t acl_data_offset;
756 int acl_flags;
Trond Myklebust331818f2012-02-03 18:30:53 -0500757 struct page * acl_scratch;
Benny Halevy663c79b2009-04-01 09:21:59 -0400758};
759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760struct nfs_setattrres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500761 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -0400763 struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 const struct nfs_server * server;
765};
766
767struct nfs_linkargs {
768 struct nfs_fh * fromfh;
769 struct nfs_fh * tofh;
770 const char * toname;
771 unsigned int tolen;
772};
773
774struct nfs_symlinkargs {
775 struct nfs_fh * fromfh;
776 const char * fromname;
777 unsigned int fromlen;
Chuck Lever94a6d752006-08-22 20:06:23 -0400778 struct page ** pages;
779 unsigned int pathlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 struct iattr * sattr;
781};
782
783struct nfs_readdirargs {
784 struct nfs_fh * fh;
785 __u32 cookie;
786 unsigned int count;
787 struct page ** pages;
788};
789
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000790struct nfs3_getaclargs {
791 struct nfs_fh * fh;
792 int mask;
793 struct page ** pages;
794};
795
796struct nfs3_setaclargs {
797 struct inode * inode;
798 int mask;
799 struct posix_acl * acl_access;
800 struct posix_acl * acl_default;
Trond Myklebustae46141f2009-03-10 20:33:18 -0400801 size_t len;
802 unsigned int npages;
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000803 struct page ** pages;
804};
805
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806struct nfs_diropok {
807 struct nfs_fh * fh;
808 struct nfs_fattr * fattr;
809};
810
811struct nfs_readlinkargs {
812 struct nfs_fh * fh;
813 unsigned int pgbase;
814 unsigned int pglen;
815 struct page ** pages;
816};
817
818struct nfs3_sattrargs {
819 struct nfs_fh * fh;
820 struct iattr * sattr;
821 unsigned int guard;
822 struct timespec guardtime;
823};
824
825struct nfs3_diropargs {
826 struct nfs_fh * fh;
827 const char * name;
828 unsigned int len;
829};
830
831struct nfs3_accessargs {
832 struct nfs_fh * fh;
833 __u32 access;
834};
835
836struct nfs3_createargs {
837 struct nfs_fh * fh;
838 const char * name;
839 unsigned int len;
840 struct iattr * sattr;
841 enum nfs3_createmode createmode;
Al Virobc4785c2006-10-19 23:28:51 -0700842 __be32 verifier[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843};
844
845struct nfs3_mkdirargs {
846 struct nfs_fh * fh;
847 const char * name;
848 unsigned int len;
849 struct iattr * sattr;
850};
851
852struct nfs3_symlinkargs {
853 struct nfs_fh * fromfh;
854 const char * fromname;
855 unsigned int fromlen;
Chuck Lever94a6d752006-08-22 20:06:23 -0400856 struct page ** pages;
857 unsigned int pathlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 struct iattr * sattr;
859};
860
861struct nfs3_mknodargs {
862 struct nfs_fh * fh;
863 const char * name;
864 unsigned int len;
865 enum nfs3_ftype type;
866 struct iattr * sattr;
867 dev_t rdev;
868};
869
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870struct nfs3_linkargs {
871 struct nfs_fh * fromfh;
872 struct nfs_fh * tofh;
873 const char * toname;
874 unsigned int tolen;
875};
876
877struct nfs3_readdirargs {
878 struct nfs_fh * fh;
879 __u64 cookie;
Al Virobc4785c2006-10-19 23:28:51 -0700880 __be32 verf[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 int plus;
882 unsigned int count;
883 struct page ** pages;
884};
885
886struct nfs3_diropres {
887 struct nfs_fattr * dir_attr;
888 struct nfs_fh * fh;
889 struct nfs_fattr * fattr;
890};
891
892struct nfs3_accessres {
893 struct nfs_fattr * fattr;
894 __u32 access;
895};
896
897struct nfs3_readlinkargs {
898 struct nfs_fh * fh;
899 unsigned int pgbase;
900 unsigned int pglen;
901 struct page ** pages;
902};
903
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904struct nfs3_linkres {
905 struct nfs_fattr * dir_attr;
906 struct nfs_fattr * fattr;
907};
908
909struct nfs3_readdirres {
910 struct nfs_fattr * dir_attr;
Al Virobc4785c2006-10-19 23:28:51 -0700911 __be32 * verf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 int plus;
913};
914
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +0000915struct nfs3_getaclres {
916 struct nfs_fattr * fattr;
917 int mask;
918 unsigned int acl_access_count;
919 unsigned int acl_default_count;
920 struct posix_acl * acl_access;
921 struct posix_acl * acl_default;
922};
923
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400924#if IS_ENABLED(CONFIG_NFS_V4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
926typedef u64 clientid4;
927
928struct nfs4_accessargs {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500929 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 const struct nfs_fh * fh;
Trond Myklebust76b32992007-08-10 17:45:11 -0400931 const u32 * bitmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 u32 access;
933};
934
935struct nfs4_accessres {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500936 struct nfs4_sequence_res seq_res;
Trond Myklebust76b32992007-08-10 17:45:11 -0400937 const struct nfs_server * server;
938 struct nfs_fattr * fattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 u32 supported;
940 u32 access;
941};
942
943struct nfs4_create_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500944 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 u32 ftype;
946 union {
Chuck Lever94a6d752006-08-22 20:06:23 -0400947 struct {
948 struct page ** pages;
949 unsigned int len;
950 } symlink; /* NF4LNK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 struct {
952 u32 specdata1;
953 u32 specdata2;
954 } device; /* NF4BLK, NF4CHR */
955 } u;
956 const struct qstr * name;
957 const struct nfs_server * server;
958 const struct iattr * attrs;
959 const struct nfs_fh * dir_fh;
960 const u32 * bitmask;
Steve Dicksone058f702013-05-22 12:50:40 -0400961 const struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962};
963
964struct nfs4_create_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500965 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 const struct nfs_server * server;
967 struct nfs_fh * fh;
968 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -0400969 struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 struct nfs4_change_info dir_cinfo;
971};
972
973struct nfs4_fsinfo_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500974 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 const struct nfs_fh * fh;
976 const u32 * bitmask;
977};
978
Benny Halevy3dda5e42009-04-01 09:21:57 -0400979struct nfs4_fsinfo_res {
Benny Halevy3dda5e42009-04-01 09:21:57 -0400980 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -0500981 struct nfs_fsinfo *fsinfo;
Benny Halevy3dda5e42009-04-01 09:21:57 -0400982};
983
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984struct nfs4_getattr_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500985 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 const struct nfs_fh * fh;
987 const u32 * bitmask;
988};
989
990struct nfs4_getattr_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500991 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 const struct nfs_server * server;
993 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -0400994 struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995};
996
997struct nfs4_link_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -0500998 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 const struct nfs_fh * fh;
1000 const struct nfs_fh * dir_fh;
1001 const struct qstr * name;
Trond Myklebust91ba2ee2005-10-27 22:12:42 -04001002 const u32 * bitmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003};
1004
Trond Myklebust91ba2ee2005-10-27 22:12:42 -04001005struct nfs4_link_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001006 struct nfs4_sequence_res seq_res;
Trond Myklebust91ba2ee2005-10-27 22:12:42 -04001007 const struct nfs_server * server;
1008 struct nfs_fattr * fattr;
Steve Dicksone058f702013-05-22 12:50:40 -04001009 struct nfs4_label *label;
Trond Myklebust91ba2ee2005-10-27 22:12:42 -04001010 struct nfs4_change_info cinfo;
1011 struct nfs_fattr * dir_attr;
1012};
1013
1014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015struct nfs4_lookup_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001016 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 const struct nfs_fh * dir_fh;
1018 const struct qstr * name;
1019 const u32 * bitmask;
1020};
1021
1022struct nfs4_lookup_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001023 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 const struct nfs_server * server;
1025 struct nfs_fattr * fattr;
1026 struct nfs_fh * fh;
Steve Dicksone058f702013-05-22 12:50:40 -04001027 struct nfs4_label *label;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028};
1029
1030struct nfs4_lookup_root_arg {
Benny Halevy9ff71c32009-04-01 09:21:52 -04001031 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001032 const u32 * bitmask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033};
1034
1035struct nfs4_pathconf_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001036 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 const struct nfs_fh * fh;
1038 const u32 * bitmask;
1039};
1040
Benny Halevyd45b2982009-04-01 09:21:58 -04001041struct nfs4_pathconf_res {
Benny Halevyd45b2982009-04-01 09:21:58 -04001042 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001043 struct nfs_pathconf *pathconf;
Benny Halevyd45b2982009-04-01 09:21:58 -04001044};
1045
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046struct nfs4_readdir_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001047 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 const struct nfs_fh * fh;
1049 u64 cookie;
1050 nfs4_verifier verifier;
1051 u32 count;
1052 struct page ** pages; /* zero-copy data */
1053 unsigned int pgbase; /* zero-copy data */
1054 const u32 * bitmask;
Bryan Schumaker82f2e542010-10-21 16:33:18 -04001055 int plus;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056};
1057
1058struct nfs4_readdir_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001059 struct nfs4_sequence_res seq_res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 nfs4_verifier verifier;
1061 unsigned int pgbase;
1062};
1063
1064struct nfs4_readlink {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001065 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 const struct nfs_fh * fh;
1067 unsigned int pgbase;
1068 unsigned int pglen; /* zero-copy data */
1069 struct page ** pages; /* zero-copy data */
1070};
1071
Benny Halevyf50c7002009-04-01 09:21:55 -04001072struct nfs4_readlink_res {
1073 struct nfs4_sequence_res seq_res;
1074};
1075
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076struct nfs4_setclientid {
Chuck Levercc38bac2007-12-10 14:56:54 -05001077 const nfs4_verifier * sc_verifier;
Chuck Levercc38bac2007-12-10 14:56:54 -05001078 u32 sc_prog;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 unsigned int sc_netid_len;
Chuck Leverd1ce02e2008-09-25 11:57:12 -04001080 char sc_netid[RPCBIND_MAXNETIDLEN + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 unsigned int sc_uaddr_len;
Chuck Leverd1ce02e2008-09-25 11:57:12 -04001082 char sc_uaddr[RPCBIND_MAXUADDRLEN + 1];
Jeff Layton3a6bb732015-06-09 19:43:57 -04001083 struct nfs_client *sc_clnt;
Jeff Laytonf11b2a12014-06-21 20:52:17 -04001084 struct rpc_cred *sc_cred;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085};
1086
Trond Myklebustbb8b27e2010-04-16 16:43:06 -04001087struct nfs4_setclientid_res {
1088 u64 clientid;
1089 nfs4_verifier confirm;
1090};
1091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092struct nfs4_statfs_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001093 struct nfs4_sequence_args seq_args;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 const struct nfs_fh * fh;
1095 const u32 * bitmask;
1096};
1097
Benny Halevy24ad1482009-04-01 09:21:56 -04001098struct nfs4_statfs_res {
Benny Halevy24ad1482009-04-01 09:21:56 -04001099 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001100 struct nfs_fsstat *fsstat;
Benny Halevy24ad1482009-04-01 09:21:56 -04001101};
1102
Benny Halevy43652ad2009-04-01 09:21:54 -04001103struct nfs4_server_caps_arg {
Benny Halevy43652ad2009-04-01 09:21:54 -04001104 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001105 struct nfs_fh *fhandle;
Kinglong Mee8c612822015-08-26 21:12:58 +08001106 const u32 * bitmask;
Benny Halevy43652ad2009-04-01 09:21:54 -04001107};
1108
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109struct nfs4_server_caps_res {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001110 struct nfs4_sequence_res seq_res;
Fred Isamandae100c2011-07-30 20:52:37 -04001111 u32 attr_bitmask[3];
Kinglong Mee8c612822015-08-26 21:12:58 +08001112 u32 exclcreat_bitmask[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 u32 acl_bitmask;
1114 u32 has_links;
1115 u32 has_symlinks;
Chuck Lever264e6352012-03-01 17:02:05 -05001116 u32 fh_expire_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117};
1118
Manoj Naik7aaa0b32006-06-09 09:34:23 -04001119#define NFS4_PATHNAME_MAXCOMPONENTS 512
1120struct nfs4_pathname {
1121 unsigned int ncomponents;
1122 struct nfs4_string components[NFS4_PATHNAME_MAXCOMPONENTS];
1123};
1124
1125#define NFS4_FS_LOCATION_MAXSERVERS 10
1126struct nfs4_fs_location {
1127 unsigned int nservers;
1128 struct nfs4_string servers[NFS4_FS_LOCATION_MAXSERVERS];
1129 struct nfs4_pathname rootpath;
1130};
1131
1132#define NFS4_FS_LOCATIONS_MAXENTRIES 10
1133struct nfs4_fs_locations {
Trond Myklebust683b57b2006-06-09 09:34:22 -04001134 struct nfs_fattr fattr;
1135 const struct nfs_server *server;
Manoj Naik7aaa0b32006-06-09 09:34:23 -04001136 struct nfs4_pathname fs_path;
Trond Myklebust683b57b2006-06-09 09:34:22 -04001137 int nlocations;
Manoj Naik7aaa0b32006-06-09 09:34:23 -04001138 struct nfs4_fs_location locations[NFS4_FS_LOCATIONS_MAXENTRIES];
Trond Myklebust683b57b2006-06-09 09:34:22 -04001139};
1140
1141struct nfs4_fs_locations_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001142 struct nfs4_sequence_args seq_args;
Trond Myklebust683b57b2006-06-09 09:34:22 -04001143 const struct nfs_fh *dir_fh;
Chuck Leverb03d7352013-10-17 14:12:50 -04001144 const struct nfs_fh *fh;
Trond Myklebust683b57b2006-06-09 09:34:22 -04001145 const struct qstr *name;
1146 struct page *page;
1147 const u32 *bitmask;
Chuck Leverb03d7352013-10-17 14:12:50 -04001148 clientid4 clientid;
1149 unsigned char migration:1, renew:1;
Trond Myklebust683b57b2006-06-09 09:34:22 -04001150};
1151
Benny Halevy22958462009-04-01 09:22:02 -04001152struct nfs4_fs_locations_res {
Benny Halevy22958462009-04-01 09:22:02 -04001153 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001154 struct nfs4_fs_locations *fs_locations;
Chuck Leverb03d7352013-10-17 14:12:50 -04001155 unsigned char migration:1, renew:1;
Benny Halevy22958462009-04-01 09:22:02 -04001156};
1157
Chuck Leverfb15b262013-03-16 15:54:34 -04001158struct nfs4_secinfo4 {
1159 u32 flavor;
1160 struct rpcsec_gss_info flavor_info;
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001161};
1162
1163struct nfs4_secinfo_flavors {
Chuck Leverfb15b262013-03-16 15:54:34 -04001164 unsigned int num_flavors;
1165 struct nfs4_secinfo4 flavors[0];
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001166};
1167
1168struct nfs4_secinfo_arg {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001169 struct nfs4_sequence_args seq_args;
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001170 const struct nfs_fh *dir_fh;
1171 const struct qstr *name;
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001172};
1173
1174struct nfs4_secinfo_res {
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001175 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001176 struct nfs4_secinfo_flavors *flavors;
Bryan Schumaker5a5ea0d2011-03-24 17:12:29 +00001177};
1178
Chuck Lever44c99932013-10-17 14:13:30 -04001179struct nfs4_fsid_present_arg {
1180 struct nfs4_sequence_args seq_args;
1181 const struct nfs_fh *fh;
1182 clientid4 clientid;
1183 unsigned char renew:1;
1184};
1185
1186struct nfs4_fsid_present_res {
1187 struct nfs4_sequence_res seq_res;
1188 struct nfs_fh *fh;
1189 unsigned char renew:1;
1190};
1191
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192#endif /* CONFIG_NFS_V4 */
1193
Benny Halevy99fe60d2009-04-01 09:22:29 -04001194struct nfstime4 {
1195 u64 seconds;
1196 u32 nseconds;
1197};
1198
1199#ifdef CONFIG_NFS_V4_1
Fred Isamanea2cf222012-04-20 14:47:53 -04001200
1201struct pnfs_commit_bucket {
1202 struct list_head written;
1203 struct list_head committing;
1204 struct pnfs_layout_segment *wlseg;
1205 struct pnfs_layout_segment *clseg;
Weston Andros Adamson5002c582014-05-15 11:56:54 -04001206 struct nfs_writeverf direct_verf;
Fred Isamanea2cf222012-04-20 14:47:53 -04001207};
1208
1209struct pnfs_ds_commit_info {
1210 int nwritten;
1211 int ncommitting;
1212 int nbuckets;
1213 struct pnfs_commit_bucket *buckets;
1214};
1215
Weston Andros Adamson2031cd12013-08-13 16:37:32 -04001216struct nfs41_state_protection {
1217 u32 how;
1218 struct nfs4_op_map enforce;
1219 struct nfs4_op_map allow;
1220};
1221
Benny Halevy99fe60d2009-04-01 09:22:29 -04001222struct nfs41_exchange_id_args {
1223 struct nfs_client *client;
1224 nfs4_verifier *verifier;
Benny Halevy99fe60d2009-04-01 09:22:29 -04001225 u32 flags;
Weston Andros Adamson2031cd12013-08-13 16:37:32 -04001226 struct nfs41_state_protection state_protect;
Benny Halevy99fe60d2009-04-01 09:22:29 -04001227};
1228
Chuck Leveracdeb692012-05-21 22:46:16 -04001229struct nfs41_server_owner {
Benny Halevy99fe60d2009-04-01 09:22:29 -04001230 uint64_t minor_id;
1231 uint32_t major_id_sz;
1232 char major_id[NFS4_OPAQUE_LIMIT];
1233};
1234
Chuck Lever79d4e1f2012-05-21 22:44:31 -04001235struct nfs41_server_scope {
Benny Halevy99fe60d2009-04-01 09:22:29 -04001236 uint32_t server_scope_sz;
1237 char server_scope[NFS4_OPAQUE_LIMIT];
1238};
1239
Weston Andros Adamson7d2ed9a2012-02-17 15:20:26 -05001240struct nfs41_impl_id {
1241 char domain[NFS4_OPAQUE_LIMIT + 1];
1242 char name[NFS4_OPAQUE_LIMIT + 1];
1243 struct nfstime4 date;
1244};
1245
Trond Myklebust71a097c2015-02-18 09:27:18 -08001246struct nfs41_bind_conn_to_session_args {
1247 struct nfs_client *client;
1248 struct nfs4_sessionid sessionid;
1249 u32 dir;
1250 bool use_conn_in_rdma_mode;
1251};
1252
Weston Andros Adamson7c44f1ae2012-05-24 13:22:50 -04001253struct nfs41_bind_conn_to_session_res {
Trond Myklebust71a097c2015-02-18 09:27:18 -08001254 struct nfs4_sessionid sessionid;
Weston Andros Adamson7c44f1ae2012-05-24 13:22:50 -04001255 u32 dir;
1256 bool use_conn_in_rdma_mode;
1257};
1258
Benny Halevy99fe60d2009-04-01 09:22:29 -04001259struct nfs41_exchange_id_res {
Trond Myklebust32b01312012-05-26 13:41:04 -04001260 u64 clientid;
1261 u32 seqid;
Benny Halevy99fe60d2009-04-01 09:22:29 -04001262 u32 flags;
Chuck Leveracdeb692012-05-21 22:46:16 -04001263 struct nfs41_server_owner *server_owner;
Chuck Lever79d4e1f2012-05-21 22:44:31 -04001264 struct nfs41_server_scope *server_scope;
Weston Andros Adamson7d2ed9a2012-02-17 15:20:26 -05001265 struct nfs41_impl_id *impl_id;
Weston Andros Adamson2031cd12013-08-13 16:37:32 -04001266 struct nfs41_state_protection state_protect;
Benny Halevy99fe60d2009-04-01 09:22:29 -04001267};
Andy Adamsonfc931582009-04-01 09:22:31 -04001268
1269struct nfs41_create_session_args {
1270 struct nfs_client *client;
Trond Myklebust79969dd2015-02-18 11:30:18 -08001271 u64 clientid;
1272 uint32_t seqid;
Andy Adamsonfc931582009-04-01 09:22:31 -04001273 uint32_t flags;
1274 uint32_t cb_program;
1275 struct nfs4_channel_attrs fc_attrs; /* Fore Channel */
1276 struct nfs4_channel_attrs bc_attrs; /* Back Channel */
1277};
1278
1279struct nfs41_create_session_res {
Trond Myklebust79969dd2015-02-18 11:30:18 -08001280 struct nfs4_sessionid sessionid;
1281 uint32_t seqid;
1282 uint32_t flags;
1283 struct nfs4_channel_attrs fc_attrs; /* Fore Channel */
1284 struct nfs4_channel_attrs bc_attrs; /* Back Channel */
Andy Adamsonfc931582009-04-01 09:22:31 -04001285};
Ricardo Labiaga180197532009-12-05 16:08:40 -05001286
1287struct nfs41_reclaim_complete_args {
Trond Myklebust62ae0822012-11-29 17:10:01 -05001288 struct nfs4_sequence_args seq_args;
Ricardo Labiaga180197532009-12-05 16:08:40 -05001289 /* In the future extend to include curr_fh for use with migration */
1290 unsigned char one_fs:1;
Ricardo Labiaga180197532009-12-05 16:08:40 -05001291};
1292
1293struct nfs41_reclaim_complete_res {
1294 struct nfs4_sequence_res seq_res;
1295};
Bryan Schumakerfca78d62011-06-02 14:59:07 -04001296
1297#define SECINFO_STYLE_CURRENT_FH 0
1298#define SECINFO_STYLE_PARENT 1
1299struct nfs41_secinfo_no_name_args {
Bryan Schumakerfca78d62011-06-02 14:59:07 -04001300 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001301 int style;
Bryan Schumakerfca78d62011-06-02 14:59:07 -04001302};
1303
Bryan Schumaker7d974792011-06-02 14:59:08 -04001304struct nfs41_test_stateid_args {
Bryan Schumaker7d974792011-06-02 14:59:08 -04001305 struct nfs4_sequence_args seq_args;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001306 nfs4_stateid *stateid;
Bryan Schumaker7d974792011-06-02 14:59:08 -04001307};
1308
1309struct nfs41_test_stateid_res {
Bryan Schumaker7d974792011-06-02 14:59:08 -04001310 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001311 unsigned int status;
Bryan Schumaker7d974792011-06-02 14:59:08 -04001312};
1313
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001314struct nfs41_free_stateid_args {
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001315 struct nfs4_sequence_args seq_args;
Trond Myklebust7c1d5fa2013-05-03 14:40:01 -04001316 nfs4_stateid stateid;
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001317};
1318
1319struct nfs41_free_stateid_res {
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001320 struct nfs4_sequence_res seq_res;
Trond Myklebust62ae0822012-11-29 17:10:01 -05001321 unsigned int status;
Bryan Schumaker9aeda352011-06-02 14:59:09 -04001322};
1323
Peng Tao8c393f92014-11-05 22:36:50 +08001324static inline void
1325nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
1326{
1327 kfree(cinfo->buckets);
1328}
1329
Trond Myklebust4f976152012-04-30 18:39:20 -04001330#else
1331
1332struct pnfs_ds_commit_info {
1333};
1334
Peng Tao8c393f92014-11-05 22:36:50 +08001335static inline void
1336nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
1337{
1338}
1339
Benny Halevy99fe60d2009-04-01 09:22:29 -04001340#endif /* CONFIG_NFS_V4_1 */
1341
Anna Schumaker1c6dcbe2014-09-26 13:58:48 -04001342#ifdef CONFIG_NFS_V4_2
Anna Schumakerf4ac1672014-11-25 13:18:15 -05001343struct nfs42_falloc_args {
1344 struct nfs4_sequence_args seq_args;
1345
1346 struct nfs_fh *falloc_fh;
1347 nfs4_stateid falloc_stateid;
1348 u64 falloc_offset;
1349 u64 falloc_length;
Anna Schumaker9a519402015-03-16 14:06:23 -04001350 const u32 *falloc_bitmask;
Anna Schumakerf4ac1672014-11-25 13:18:15 -05001351};
1352
1353struct nfs42_falloc_res {
1354 struct nfs4_sequence_res seq_res;
1355 unsigned int status;
Anna Schumaker9a519402015-03-16 14:06:23 -04001356
1357 struct nfs_fattr *falloc_fattr;
1358 const struct nfs_server *falloc_server;
Anna Schumakerf4ac1672014-11-25 13:18:15 -05001359};
1360
Anna Schumaker2e724482013-05-21 16:53:03 -04001361struct nfs42_copy_args {
1362 struct nfs4_sequence_args seq_args;
1363
1364 struct nfs_fh *src_fh;
1365 nfs4_stateid src_stateid;
1366 u64 src_pos;
1367
1368 struct nfs_fh *dst_fh;
1369 nfs4_stateid dst_stateid;
1370 u64 dst_pos;
1371
1372 u64 count;
1373};
1374
1375struct nfs42_write_res {
1376 u64 count;
1377 struct nfs_writeverf verifier;
1378};
1379
1380struct nfs42_copy_res {
1381 struct nfs4_sequence_res seq_res;
1382 struct nfs42_write_res write_res;
1383 bool consecutive;
1384 bool synchronous;
1385};
1386
Anna Schumaker1c6dcbe2014-09-26 13:58:48 -04001387struct nfs42_seek_args {
1388 struct nfs4_sequence_args seq_args;
1389
1390 struct nfs_fh *sa_fh;
1391 nfs4_stateid sa_stateid;
1392 u64 sa_offset;
1393 u32 sa_what;
1394};
1395
1396struct nfs42_seek_res {
1397 struct nfs4_sequence_res seq_res;
1398 unsigned int status;
1399
1400 u32 sr_eof;
1401 u64 sr_offset;
1402};
1403#endif
1404
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405struct nfs_page;
1406
Chuck Lever40859d72005-11-30 18:09:02 -05001407#define NFS_PAGEVEC_SIZE (8U)
1408
Fred Isaman30dd3742012-04-20 14:47:45 -04001409struct nfs_page_array {
1410 struct page **pagevec;
1411 unsigned int npages; /* Max length of pagevec */
1412 struct page *page_array[NFS_PAGEVEC_SIZE];
1413};
1414
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001415/* used as flag bits in nfs_pgio_header */
1416enum {
1417 NFS_IOHDR_ERROR = 0,
1418 NFS_IOHDR_EOF,
1419 NFS_IOHDR_REDO,
Trond Myklebust37e9ed22015-12-22 12:30:24 -05001420 NFS_IOHDR_STAT,
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001421};
1422
Fred Isamancd841602012-04-20 14:47:44 -04001423struct nfs_pgio_header {
1424 struct inode *inode;
1425 struct rpc_cred *cred;
1426 struct list_head pages;
1427 struct nfs_page *req;
Anna Schumakerf79d06f2014-05-06 09:12:28 -04001428 struct nfs_writeverf verf; /* Used for writes */
Fred Isamancd841602012-04-20 14:47:44 -04001429 struct pnfs_layout_segment *lseg;
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001430 loff_t io_start;
Fred Isamancd841602012-04-20 14:47:44 -04001431 const struct rpc_call_ops *mds_ops;
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001432 void (*release) (struct nfs_pgio_header *hdr);
Fred Isaman061ae2e2012-04-20 14:47:48 -04001433 const struct nfs_pgio_completion_ops *completion_ops;
Anna Schumaker4a0de552014-05-06 09:12:30 -04001434 const struct nfs_rw_ops *rw_ops;
Fred Isaman584aa812012-04-20 14:47:51 -04001435 struct nfs_direct_req *dreq;
Peng Taof6166382012-08-02 15:36:09 +03001436 void *layout_private;
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001437 spinlock_t lock;
1438 /* fields protected by lock */
Fred Isamancd841602012-04-20 14:47:44 -04001439 int pnfs_error;
Fred Isaman4db6e0b2012-04-20 14:47:46 -04001440 int error; /* merge with pnfs_error */
1441 unsigned long good_bytes; /* boundary of good data */
1442 unsigned long flags;
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -04001443
1444 /*
1445 * rpc data
1446 */
1447 struct rpc_task task;
1448 struct nfs_fattr fattr;
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -04001449 struct nfs_pgio_args args; /* argument struct */
1450 struct nfs_pgio_res res; /* result struct */
1451 unsigned long timestamp; /* For lease renewal */
1452 int (*pgio_done_cb)(struct rpc_task *, struct nfs_pgio_header *);
1453 __u64 mds_offset; /* Filelayout dense stripe */
1454 struct nfs_page_array page_array;
1455 struct nfs_client *ds_clp; /* pNFS data server */
Weston Andros Adamson6cccbb62014-09-16 17:35:51 -04001456 int ds_commit_idx; /* ds index if ds_clp is set */
Weston Andros Adamsona7d42dd2014-09-19 10:55:07 -04001457 int pgio_mirror_idx;/* mirror index in pgio layer */
Fred Isamancd841602012-04-20 14:47:44 -04001458};
1459
Fred Isamanea2cf222012-04-20 14:47:53 -04001460struct nfs_mds_commit_info {
1461 atomic_t rpcs_out;
1462 unsigned long ncommit;
1463 struct list_head list;
1464};
1465
Trond Myklebustb20135d2015-12-31 09:28:06 -05001466struct nfs_commit_info;
Fred Isamanf453a542012-04-20 14:47:54 -04001467struct nfs_commit_data;
1468struct nfs_inode;
1469struct nfs_commit_completion_ops {
Fred Isamanf453a542012-04-20 14:47:54 -04001470 void (*completion) (struct nfs_commit_data *data);
Trond Myklebustb20135d2015-12-31 09:28:06 -05001471 void (*resched_write) (struct nfs_commit_info *, struct nfs_page *);
Fred Isamanf453a542012-04-20 14:47:54 -04001472};
1473
Fred Isamanea2cf222012-04-20 14:47:53 -04001474struct nfs_commit_info {
Dave Wysochanskife238e62016-04-01 13:45:09 -04001475 struct inode *inode; /* Needed for inode->i_lock */
Fred Isamanea2cf222012-04-20 14:47:53 -04001476 struct nfs_mds_commit_info *mds;
1477 struct pnfs_ds_commit_info *ds;
Fred Isamanb359f9d2012-04-20 14:47:55 -04001478 struct nfs_direct_req *dreq; /* O_DIRECT request */
Fred Isamanf453a542012-04-20 14:47:54 -04001479 const struct nfs_commit_completion_ops *completion_ops;
Fred Isamanea2cf222012-04-20 14:47:53 -04001480};
1481
Fred Isaman0b7c0152012-04-20 14:47:39 -04001482struct nfs_commit_data {
1483 struct rpc_task task;
1484 struct inode *inode;
1485 struct rpc_cred *cred;
1486 struct nfs_fattr fattr;
1487 struct nfs_writeverf verf;
1488 struct list_head pages; /* Coalesced requests we wish to flush */
1489 struct list_head list; /* lists of struct nfs_write_data */
1490 struct nfs_direct_req *dreq; /* O_DIRECT request */
1491 struct nfs_commitargs args; /* argument struct */
1492 struct nfs_commitres res; /* result struct */
1493 struct nfs_open_context *context;
1494 struct pnfs_layout_segment *lseg;
1495 struct nfs_client *ds_clp; /* pNFS data server */
1496 int ds_commit_index;
Peng Tao378520b2014-08-07 10:15:02 +08001497 loff_t lwb;
Fred Isaman0b7c0152012-04-20 14:47:39 -04001498 const struct rpc_call_ops *mds_ops;
Fred Isamanf453a542012-04-20 14:47:54 -04001499 const struct nfs_commit_completion_ops *completion_ops;
Fred Isaman0b7c0152012-04-20 14:47:39 -04001500 int (*commit_done_cb) (struct rpc_task *task, struct nfs_commit_data *data);
Trond Myklebust37e9ed22015-12-22 12:30:24 -05001501 unsigned long flags;
Fred Isaman0b7c0152012-04-20 14:47:39 -04001502};
1503
Fred Isaman061ae2e2012-04-20 14:47:48 -04001504struct nfs_pgio_completion_ops {
1505 void (*error_cleanup)(struct list_head *head);
Fred Isaman584aa812012-04-20 14:47:51 -04001506 void (*init_hdr)(struct nfs_pgio_header *hdr);
Fred Isaman061ae2e2012-04-20 14:47:48 -04001507 void (*completion)(struct nfs_pgio_header *hdr);
Trond Myklebustdc602dd2015-12-31 11:44:06 -05001508 void (*reschedule_io)(struct nfs_pgio_header *hdr);
Fred Isaman061ae2e2012-04-20 14:47:48 -04001509};
1510
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001511struct nfs_unlinkdata {
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001512 struct nfs_removeargs args;
1513 struct nfs_removeres res;
Al Viro884be172016-04-28 23:56:31 -04001514 struct dentry *dentry;
1515 wait_queue_head_t wq;
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001516 struct rpc_cred *cred;
1517 struct nfs_fattr dir_attr;
NeilBrown8478eaa2014-09-18 16:09:27 +10001518 long timeout;
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001519};
1520
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -04001521struct nfs_renamedata {
1522 struct nfs_renameargs args;
1523 struct nfs_renameres res;
1524 struct rpc_cred *cred;
1525 struct inode *old_dir;
1526 struct dentry *old_dentry;
1527 struct nfs_fattr old_fattr;
1528 struct inode *new_dir;
1529 struct dentry *new_dentry;
1530 struct nfs_fattr new_fattr;
Jeff Layton96f9d8c2014-03-17 07:06:54 -04001531 void (*complete)(struct rpc_task *, struct nfs_renamedata *);
NeilBrown8478eaa2014-09-18 16:09:27 +10001532 long timeout;
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -04001533};
1534
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535struct nfs_access_entry;
Andy Adamson45a52a02011-03-01 01:34:08 +00001536struct nfs_client;
Trond Myklebuste0dca7a2011-03-14 18:20:01 -04001537struct rpc_timeout;
Bryan Schumakerff9099f22012-07-30 16:05:18 -04001538struct nfs_subversion;
1539struct nfs_mount_info;
Bryan Schumaker6663ee72012-06-20 15:53:46 -04001540struct nfs_client_initdata;
Bryan Schumaker1abb50882012-06-20 15:53:47 -04001541struct nfs_pageio_descriptor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
1543/*
1544 * RPC procedure vector for NFSv2/NFSv3 demuxing
1545 */
1546struct nfs_rpc_ops {
Chuck Leverc0e07cb2008-01-14 12:32:05 -05001547 u32 version; /* Protocol version */
Al Virof786aa92009-02-20 05:51:22 +00001548 const struct dentry_operations *dentry_ops;
Arjan van de Venc5ef1c42007-02-12 00:55:40 -08001549 const struct inode_operations *dir_inode_ops;
1550 const struct inode_operations *file_inode_ops;
Jeff Layton1788ea62011-11-04 13:31:21 -04001551 const struct file_operations *file_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
1553 int (*getroot) (struct nfs_server *, struct nfs_fh *,
1554 struct nfs_fsinfo *);
Bryan Schumaker281cad42012-04-27 13:27:45 -04001555 struct vfsmount *(*submount) (struct nfs_server *, struct dentry *,
1556 struct nfs_fh *, struct nfs_fattr *);
Bryan Schumakerff9099f22012-07-30 16:05:18 -04001557 struct dentry *(*try_mount) (int, const char *, struct nfs_mount_info *,
1558 struct nfs_subversion *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 int (*getattr) (struct nfs_server *, struct nfs_fh *,
David Quigley1775fd32013-05-22 12:50:42 -04001560 struct nfs_fattr *, struct nfs4_label *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 int (*setattr) (struct dentry *, struct nfs_fattr *,
1562 struct iattr *);
Al Virobeffb8f2016-07-20 16:34:42 -04001563 int (*lookup) (struct inode *, const struct qstr *,
David Quigley1775fd32013-05-22 12:50:42 -04001564 struct nfs_fh *, struct nfs_fattr *,
1565 struct nfs4_label *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 int (*access) (struct inode *, struct nfs_access_entry *);
1567 int (*readlink)(struct inode *, struct page *, unsigned int,
1568 unsigned int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 int (*create) (struct inode *, struct dentry *,
Miklos Szeredi8867fe52012-06-05 15:10:19 +02001570 struct iattr *, int);
Al Virobeffb8f2016-07-20 16:34:42 -04001571 int (*remove) (struct inode *, const struct qstr *);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -04001572 void (*unlink_setup) (struct rpc_message *, struct inode *dir);
Bryan Schumaker34e137c2012-03-19 14:54:41 -04001573 void (*unlink_rpc_prepare) (struct rpc_task *, struct nfs_unlinkdata *);
Trond Myklebuste4eff1a2007-07-14 15:39:58 -04001574 int (*unlink_done) (struct rpc_task *, struct inode *);
Jeff Laytond3d41522010-09-17 17:31:57 -04001575 void (*rename_setup) (struct rpc_message *msg, struct inode *dir);
Bryan Schumakerc6bfa1a2012-03-19 14:54:42 -04001576 void (*rename_rpc_prepare)(struct rpc_task *task, struct nfs_renamedata *);
Jeff Laytond3d41522010-09-17 17:31:57 -04001577 int (*rename_done) (struct rpc_task *task, struct inode *old_dir, struct inode *new_dir);
Al Virobeffb8f2016-07-20 16:34:42 -04001578 int (*link) (struct inode *, struct inode *, const struct qstr *);
Chuck Lever94a6d752006-08-22 20:06:23 -04001579 int (*symlink) (struct inode *, struct dentry *, struct page *,
1580 unsigned int, struct iattr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 int (*mkdir) (struct inode *, struct dentry *, struct iattr *);
Al Virobeffb8f2016-07-20 16:34:42 -04001582 int (*rmdir) (struct inode *, const struct qstr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 int (*readdir) (struct dentry *, struct rpc_cred *,
Bryan Schumaker56e4ebf2010-10-20 15:44:37 -04001584 u64, struct page **, unsigned int, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 int (*mknod) (struct inode *, struct dentry *, struct iattr *,
1586 dev_t);
1587 int (*statfs) (struct nfs_server *, struct nfs_fh *,
1588 struct nfs_fsstat *);
1589 int (*fsinfo) (struct nfs_server *, struct nfs_fh *,
1590 struct nfs_fsinfo *);
1591 int (*pathconf) (struct nfs_server *, struct nfs_fh *,
1592 struct nfs_pathconf *);
David Howellse9326dc2006-08-22 20:06:10 -04001593 int (*set_capabilities)(struct nfs_server *, struct nfs_fh *);
Chuck Lever573c4e12010-12-14 14:58:11 +00001594 int (*decode_dirent)(struct xdr_stream *, struct nfs_entry *, int);
Weston Andros Adamsond45f60c2014-06-09 11:48:35 -04001595 int (*pgio_rpc_prepare)(struct rpc_task *,
1596 struct nfs_pgio_header *);
1597 void (*read_setup)(struct nfs_pgio_header *, struct rpc_message *);
1598 int (*read_done)(struct rpc_task *, struct nfs_pgio_header *);
1599 void (*write_setup)(struct nfs_pgio_header *, struct rpc_message *);
1600 int (*write_done)(struct rpc_task *, struct nfs_pgio_header *);
Fred Isaman0b7c0152012-04-20 14:47:39 -04001601 void (*commit_setup) (struct nfs_commit_data *, struct rpc_message *);
1602 void (*commit_rpc_prepare)(struct rpc_task *, struct nfs_commit_data *);
1603 int (*commit_done) (struct rpc_task *, struct nfs_commit_data *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 int (*lock)(struct file *, int, struct file_lock *);
Trond Myklebust21162712008-05-20 19:34:39 -04001605 int (*lock_check_bounds)(const struct file_lock *);
Trond Myklebustada70d92005-06-22 17:16:22 +00001606 void (*clear_acl_cache)(struct inode *);
Trond Myklebust7fe5c392009-03-19 15:35:50 -04001607 void (*close_context)(struct nfs_open_context *ctx, int);
Trond Myklebust2b484292010-09-17 10:56:51 -04001608 struct inode * (*open_context) (struct inode *dir,
1609 struct nfs_open_context *ctx,
1610 int open_flags,
Trond Myklebust5bc2afc2013-09-23 18:01:28 -04001611 struct iattr *iattr,
1612 int *);
Bryan Schumaker011e2a72012-06-20 15:53:43 -04001613 int (*have_delegation)(struct inode *, fmode_t);
Bryan Schumaker57ec14c2012-06-20 15:53:44 -04001614 int (*return_delegation)(struct inode *);
Bryan Schumaker6663ee72012-06-20 15:53:46 -04001615 struct nfs_client *(*alloc_client) (const struct nfs_client_initdata *);
Trond Myklebust5c6e5b62016-06-22 14:13:12 -04001616 struct nfs_client *(*init_client) (struct nfs_client *,
1617 const struct nfs_client_initdata *);
Bryan Schumakercdb7ece2012-06-20 15:53:45 -04001618 void (*free_client) (struct nfs_client *);
Bryan Schumaker1179acc2012-07-30 16:05:19 -04001619 struct nfs_server *(*create_server)(struct nfs_mount_info *, struct nfs_subversion *);
1620 struct nfs_server *(*clone_server)(struct nfs_server *, struct nfs_fh *,
1621 struct nfs_fattr *, rpc_authflavor_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622};
1623
1624/*
1625 * NFS_CALL(getattr, inode, (fattr));
1626 * into
1627 * NFS_PROTO(inode)->getattr(fattr);
1628 */
1629#define NFS_CALL(op, inode, args) NFS_PROTO(inode)->op args
1630
1631/*
1632 * Function vectors etc. for the NFS client
1633 */
David Howells509de812006-08-22 20:06:11 -04001634extern const struct nfs_rpc_ops nfs_v2_clientops;
1635extern const struct nfs_rpc_ops nfs_v3_clientops;
1636extern const struct nfs_rpc_ops nfs_v4_clientops;
Trond Myklebusta613fa12012-01-20 13:53:56 -05001637extern const struct rpc_version nfs_version2;
1638extern const struct rpc_version nfs_version3;
1639extern const struct rpc_version nfs_version4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640
Trond Myklebusta613fa12012-01-20 13:53:56 -05001641extern const struct rpc_version nfsacl_version3;
1642extern const struct rpc_program nfsacl_program;
Andreas Gruenbacherb7fa0552005-06-22 17:16:27 +00001643
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644#endif