1 /*
2  *  pNFS client data structures.
3  *
4  *  Copyright (c) 2002
5  *  The Regents of the University of Michigan
6  *  All Rights Reserved
7  *
8  *  Dean Hildebrand <dhildebz@umich.edu>
9  *
10  *  Permission is granted to use, copy, create derivative works, and
11  *  redistribute this software and such derivative works for any purpose,
12  *  so long as the name of the University of Michigan is not used in
13  *  any advertising or publicity pertaining to the use or distribution
14  *  of this software without specific, written prior authorization. If
15  *  the above copyright notice or any other identification of the
16  *  University of Michigan is included in any copy of any portion of
17  *  this software, then the disclaimer below must also be included.
18  *
19  *  This software is provided as is, without representation or warranty
20  *  of any kind either express or implied, including without limitation
21  *  the implied warranties of merchantability, fitness for a particular
22  *  purpose, or noninfringement.  The Regents of the University of
23  *  Michigan shall not be liable for any damages, including special,
24  *  indirect, incidental, or consequential damages, with respect to any
25  *  claim arising out of or in connection with the use of the software,
26  *  even if it has been or is hereafter advised of the possibility of
27  *  such damages.
28  */
29 
30 #ifndef FS_NFS_PNFS_H
31 #define FS_NFS_PNFS_H
32 
33 #include <linux/refcount.h>
34 #include <linux/nfs_fs.h>
35 #include <linux/nfs_page.h>
36 #include <linux/workqueue.h>
37 
38 struct nfs4_opendata;
39 
40 enum {
41 	NFS_LSEG_VALID = 0,	/* cleared when lseg is recalled/returned */
42 	NFS_LSEG_ROC,		/* roc bit received from server */
43 	NFS_LSEG_LAYOUTCOMMIT,	/* layoutcommit bit set for layoutcommit */
44 	NFS_LSEG_LAYOUTRETURN,	/* layoutreturn bit set for layoutreturn */
45 	NFS_LSEG_UNAVAILABLE,	/* unavailable bit set for temporary problem */
46 };
47 
48 /* Individual ip address */
49 struct nfs4_pnfs_ds_addr {
50 	struct sockaddr_storage	da_addr;
51 	size_t			da_addrlen;
52 	struct list_head	da_node;  /* nfs4_pnfs_dev_hlist dev_dslist */
53 	char			*da_remotestr;	/* human readable addr+port */
54 };
55 
56 struct nfs4_pnfs_ds {
57 	struct list_head	ds_node;  /* nfs4_pnfs_dev_hlist dev_dslist */
58 	char			*ds_remotestr;	/* comma sep list of addrs */
59 	struct list_head	ds_addrs;
60 	struct nfs_client	*ds_clp;
61 	refcount_t		ds_count;
62 	unsigned long		ds_state;
63 #define NFS4DS_CONNECTING	0	/* ds is establishing connection */
64 };
65 
66 struct pnfs_layout_segment {
67 	struct list_head pls_list;
68 	struct list_head pls_lc_list;
69 	struct pnfs_layout_range pls_range;
70 	refcount_t pls_refcount;
71 	u32 pls_seq;
72 	unsigned long pls_flags;
73 	struct pnfs_layout_hdr *pls_layout;
74 };
75 
76 enum pnfs_try_status {
77 	PNFS_ATTEMPTED     = 0,
78 	PNFS_NOT_ATTEMPTED = 1,
79 	PNFS_TRY_AGAIN     = 2,
80 };
81 
82 #ifdef CONFIG_NFS_V4_1
83 
84 #define LAYOUT_NFSV4_1_MODULE_PREFIX "nfs-layouttype4"
85 
86 /*
87  * Default data server connection timeout and retrans vaules.
88  * Set by module parameters dataserver_timeo and dataserver_retrans.
89  */
90 #define NFS4_DEF_DS_TIMEO   600 /* in tenths of a second */
91 #define NFS4_DEF_DS_RETRANS 5
92 #define PNFS_DEVICE_RETRY_TIMEOUT (120*HZ)
93 
94 /* error codes for internal use */
95 #define NFS4ERR_RESET_TO_MDS   12001
96 #define NFS4ERR_RESET_TO_PNFS  12002
97 
98 enum {
99 	NFS_LAYOUT_RO_FAILED = 0,	/* get ro layout failed stop trying */
100 	NFS_LAYOUT_RW_FAILED,		/* get rw layout failed stop trying */
101 	NFS_LAYOUT_BULK_RECALL,		/* bulk recall affecting layout */
102 	NFS_LAYOUT_RETURN,		/* layoutreturn in progress */
103 	NFS_LAYOUT_RETURN_LOCK,		/* Serialise layoutreturn */
104 	NFS_LAYOUT_RETURN_REQUESTED,	/* Return this layout ASAP */
105 	NFS_LAYOUT_INVALID_STID,	/* layout stateid id is invalid */
106 	NFS_LAYOUT_FIRST_LAYOUTGET,	/* Serialize first layoutget */
107 	NFS_LAYOUT_INODE_FREEING,	/* The inode is being freed */
108 };
109 
110 enum layoutdriver_policy_flags {
111 	/* Should the pNFS client commit and return the layout upon truncate to
112 	 * a smaller size */
113 	PNFS_LAYOUTRET_ON_SETATTR	= 1 << 0,
114 	PNFS_LAYOUTRET_ON_ERROR		= 1 << 1,
115 	PNFS_READ_WHOLE_PAGE		= 1 << 2,
116 	PNFS_LAYOUTGET_ON_OPEN		= 1 << 3,
117 };
118 
119 struct nfs4_deviceid_node;
120 
121 /* Per-layout driver specific registration structure */
122 struct pnfs_layoutdriver_type {
123 	struct list_head pnfs_tblid;
124 	const u32 id;
125 	const char *name;
126 	struct module *owner;
127 	unsigned flags;
128 	unsigned max_deviceinfo_size;
129 
130 	int (*set_layoutdriver) (struct nfs_server *, const struct nfs_fh *);
131 	int (*clear_layoutdriver) (struct nfs_server *);
132 
133 	struct pnfs_layout_hdr * (*alloc_layout_hdr) (struct inode *inode, gfp_t gfp_flags);
134 	void (*free_layout_hdr) (struct pnfs_layout_hdr *);
135 
136 	struct pnfs_layout_segment * (*alloc_lseg) (struct pnfs_layout_hdr *layoutid, struct nfs4_layoutget_res *lgr, gfp_t gfp_flags);
137 	void (*free_lseg) (struct pnfs_layout_segment *lseg);
138 	void (*add_lseg) (struct pnfs_layout_hdr *layoutid,
139 			struct pnfs_layout_segment *lseg,
140 			struct list_head *free_me);
141 
142 	void (*return_range) (struct pnfs_layout_hdr *lo,
143 			      struct pnfs_layout_range *range);
144 
145 	/* test for nfs page cache coalescing */
146 	const struct nfs_pageio_ops *pg_read_ops;
147 	const struct nfs_pageio_ops *pg_write_ops;
148 
149 	struct pnfs_ds_commit_info *(*get_ds_info) (struct inode *inode);
150 	void (*mark_request_commit) (struct nfs_page *req,
151 				     struct pnfs_layout_segment *lseg,
152 				     struct nfs_commit_info *cinfo,
153 				     u32 ds_commit_idx);
154 	void (*clear_request_commit) (struct nfs_page *req,
155 				      struct nfs_commit_info *cinfo);
156 	int (*scan_commit_lists) (struct nfs_commit_info *cinfo,
157 				  int max);
158 	void (*recover_commit_reqs) (struct list_head *list,
159 				     struct nfs_commit_info *cinfo);
160 	struct nfs_page * (*search_commit_reqs)(struct nfs_commit_info *cinfo,
161 						struct page *page);
162 	int (*commit_pagelist)(struct inode *inode,
163 			       struct list_head *mds_pages,
164 			       int how,
165 			       struct nfs_commit_info *cinfo);
166 
167 	int (*sync)(struct inode *inode, bool datasync);
168 
169 	/*
170 	 * Return PNFS_ATTEMPTED to indicate the layout code has attempted
171 	 * I/O, else return PNFS_NOT_ATTEMPTED to fall back to normal NFS
172 	 */
173 	enum pnfs_try_status (*read_pagelist)(struct nfs_pgio_header *);
174 	enum pnfs_try_status (*write_pagelist)(struct nfs_pgio_header *, int);
175 
176 	void (*free_deviceid_node) (struct nfs4_deviceid_node *);
177 	struct nfs4_deviceid_node * (*alloc_deviceid_node)
178 			(struct nfs_server *server, struct pnfs_device *pdev,
179 			gfp_t gfp_flags);
180 
181 	int (*prepare_layoutreturn) (struct nfs4_layoutreturn_args *);
182 
183 	void (*cleanup_layoutcommit) (struct nfs4_layoutcommit_data *data);
184 	int (*prepare_layoutcommit) (struct nfs4_layoutcommit_args *args);
185 	int (*prepare_layoutstats) (struct nfs42_layoutstat_args *args);
186 };
187 
188 struct pnfs_layout_hdr {
189 	refcount_t		plh_refcount;
190 	atomic_t		plh_outstanding; /* number of RPCs out */
191 	struct list_head	plh_layouts;   /* other client layouts */
192 	struct list_head	plh_bulk_destroy;
193 	struct list_head	plh_segs;      /* layout segments list */
194 	struct list_head	plh_return_segs; /* invalid layout segments */
195 	unsigned long		plh_block_lgets; /* block LAYOUTGET if >0 */
196 	unsigned long		plh_retry_timestamp;
197 	unsigned long		plh_flags;
198 	nfs4_stateid		plh_stateid;
199 	u32			plh_barrier; /* ignore lower seqids */
200 	u32			plh_return_seq;
201 	enum pnfs_iomode	plh_return_iomode;
202 	loff_t			plh_lwb; /* last write byte for layoutcommit */
203 	struct rpc_cred		*plh_lc_cred; /* layoutcommit cred */
204 	struct inode		*plh_inode;
205 };
206 
207 struct pnfs_device {
208 	struct nfs4_deviceid dev_id;
209 	unsigned int  layout_type;
210 	unsigned int  mincount;
211 	unsigned int  maxcount;	/* gdia_maxcount */
212 	struct page **pages;
213 	unsigned int  pgbase;
214 	unsigned int  pglen;	/* reply buffer length */
215 	unsigned char nocache : 1;/* May not be cached */
216 };
217 
218 #define NFS4_PNFS_GETDEVLIST_MAXNUM 16
219 
220 struct pnfs_devicelist {
221 	unsigned int		eof;
222 	unsigned int		num_devs;
223 	struct nfs4_deviceid	dev_id[NFS4_PNFS_GETDEVLIST_MAXNUM];
224 };
225 
226 extern int pnfs_register_layoutdriver(struct pnfs_layoutdriver_type *);
227 extern void pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *);
228 extern const struct pnfs_layoutdriver_type *pnfs_find_layoutdriver(u32 id);
229 extern void pnfs_put_layoutdriver(const struct pnfs_layoutdriver_type *ld);
230 
231 /* nfs4proc.c */
232 extern size_t max_response_pages(struct nfs_server *server);
233 extern int nfs4_proc_getdeviceinfo(struct nfs_server *server,
234 				   struct pnfs_device *dev,
235 				   struct rpc_cred *cred);
236 extern struct pnfs_layout_segment* nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout);
237 extern int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync);
238 
239 /* pnfs.c */
240 void pnfs_get_layout_hdr(struct pnfs_layout_hdr *lo);
241 void pnfs_put_lseg(struct pnfs_layout_segment *lseg);
242 
243 void set_pnfs_layoutdriver(struct nfs_server *, const struct nfs_fh *, struct nfs_fsinfo *);
244 void unset_pnfs_layoutdriver(struct nfs_server *);
245 void pnfs_generic_pg_check_layout(struct nfs_pageio_descriptor *pgio);
246 void pnfs_generic_pg_init_read(struct nfs_pageio_descriptor *, struct nfs_page *);
247 int pnfs_generic_pg_readpages(struct nfs_pageio_descriptor *desc);
248 void pnfs_generic_pg_init_write(struct nfs_pageio_descriptor *pgio,
249 			        struct nfs_page *req, u64 wb_size);
250 void pnfs_generic_pg_cleanup(struct nfs_pageio_descriptor *);
251 int pnfs_generic_pg_writepages(struct nfs_pageio_descriptor *desc);
252 size_t pnfs_generic_pg_test(struct nfs_pageio_descriptor *pgio,
253 			    struct nfs_page *prev, struct nfs_page *req);
254 void pnfs_set_lo_fail(struct pnfs_layout_segment *lseg);
255 struct pnfs_layout_segment *pnfs_layout_process(struct nfs4_layoutget *lgp);
256 void pnfs_layoutget_free(struct nfs4_layoutget *lgp);
257 void pnfs_free_lseg_list(struct list_head *tmp_list);
258 void pnfs_destroy_layout(struct nfs_inode *);
259 void pnfs_destroy_layout_final(struct nfs_inode *);
260 void pnfs_destroy_all_layouts(struct nfs_client *);
261 int pnfs_destroy_layouts_byfsid(struct nfs_client *clp,
262 		struct nfs_fsid *fsid,
263 		bool is_recall);
264 int pnfs_destroy_layouts_byclid(struct nfs_client *clp,
265 		bool is_recall);
266 bool nfs4_layoutreturn_refresh_stateid(nfs4_stateid *dst,
267 		struct pnfs_layout_range *dst_range,
268 		struct inode *inode);
269 void pnfs_put_layout_hdr(struct pnfs_layout_hdr *lo);
270 void pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo,
271 			     const nfs4_stateid *new,
272 			     bool update_barrier);
273 int pnfs_mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
274 				struct list_head *tmp_list,
275 				const struct pnfs_layout_range *recall_range,
276 				u32 seq);
277 int pnfs_mark_matching_lsegs_return(struct pnfs_layout_hdr *lo,
278 				struct list_head *tmp_list,
279 				const struct pnfs_layout_range *recall_range,
280 				u32 seq);
281 int pnfs_mark_layout_stateid_invalid(struct pnfs_layout_hdr *lo,
282 		struct list_head *lseg_list);
283 bool pnfs_roc(struct inode *ino,
284 		struct nfs4_layoutreturn_args *args,
285 		struct nfs4_layoutreturn_res *res,
286 		const struct rpc_cred *cred);
287 void pnfs_roc_release(struct nfs4_layoutreturn_args *args,
288 		struct nfs4_layoutreturn_res *res,
289 		int ret);
290 bool pnfs_wait_on_layoutreturn(struct inode *ino, struct rpc_task *task);
291 void pnfs_set_layoutcommit(struct inode *, struct pnfs_layout_segment *, loff_t);
292 void pnfs_cleanup_layoutcommit(struct nfs4_layoutcommit_data *data);
293 int pnfs_layoutcommit_inode(struct inode *inode, bool sync);
294 int pnfs_generic_sync(struct inode *inode, bool datasync);
295 int pnfs_nfs_generic_sync(struct inode *inode, bool datasync);
296 int _pnfs_return_layout(struct inode *);
297 int pnfs_commit_and_return_layout(struct inode *);
298 void pnfs_ld_write_done(struct nfs_pgio_header *);
299 void pnfs_ld_read_done(struct nfs_pgio_header *);
300 void pnfs_read_resend_pnfs(struct nfs_pgio_header *);
301 struct pnfs_layout_segment *pnfs_update_layout(struct inode *ino,
302 					       struct nfs_open_context *ctx,
303 					       loff_t pos,
304 					       u64 count,
305 					       enum pnfs_iomode iomode,
306 					       bool strict_iomode,
307 					       gfp_t gfp_flags);
308 void pnfs_layoutreturn_free_lsegs(struct pnfs_layout_hdr *lo,
309 		const nfs4_stateid *arg_stateid,
310 		const struct pnfs_layout_range *range,
311 		const nfs4_stateid *stateid);
312 
313 void pnfs_generic_layout_insert_lseg(struct pnfs_layout_hdr *lo,
314 		   struct pnfs_layout_segment *lseg,
315 		   bool (*is_after)(const struct pnfs_layout_range *lseg_range,
316 			   const struct pnfs_layout_range *old),
317 		   bool (*do_merge)(struct pnfs_layout_segment *lseg,
318 			   struct pnfs_layout_segment *old),
319 		   struct list_head *free_me);
320 
321 void nfs4_deviceid_mark_client_invalid(struct nfs_client *clp);
322 int pnfs_read_done_resend_to_mds(struct nfs_pgio_header *);
323 int pnfs_write_done_resend_to_mds(struct nfs_pgio_header *);
324 struct nfs4_threshold *pnfs_mdsthreshold_alloc(void);
325 void pnfs_error_mark_layout_for_return(struct inode *inode,
326 				       struct pnfs_layout_segment *lseg);
327 /* nfs4_deviceid_flags */
328 enum {
329 	NFS_DEVICEID_INVALID = 0,       /* set when MDS clientid recalled */
330 	NFS_DEVICEID_UNAVAILABLE,	/* device temporarily unavailable */
331 	NFS_DEVICEID_NOCACHE,		/* device may not be cached */
332 };
333 
334 /* pnfs_dev.c */
335 struct nfs4_deviceid_node {
336 	struct hlist_node		node;
337 	struct hlist_node		tmpnode;
338 	const struct pnfs_layoutdriver_type *ld;
339 	const struct nfs_client		*nfs_client;
340 	unsigned long 			flags;
341 	unsigned long			timestamp_unavailable;
342 	struct nfs4_deviceid		deviceid;
343 	struct rcu_head			rcu;
344 	atomic_t			ref;
345 };
346 
347 struct nfs4_deviceid_node *
348 nfs4_find_get_deviceid(struct nfs_server *server,
349 		const struct nfs4_deviceid *id, struct rpc_cred *cred,
350 		gfp_t gfp_mask);
351 void nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *, const struct nfs_client *, const struct nfs4_deviceid *);
352 void nfs4_init_deviceid_node(struct nfs4_deviceid_node *, struct nfs_server *,
353 			     const struct nfs4_deviceid *);
354 bool nfs4_put_deviceid_node(struct nfs4_deviceid_node *);
355 void nfs4_mark_deviceid_unavailable(struct nfs4_deviceid_node *node);
356 bool nfs4_test_deviceid_unavailable(struct nfs4_deviceid_node *node);
357 void nfs4_deviceid_purge_client(const struct nfs_client *);
358 
359 /* pnfs_nfs.c */
360 void pnfs_generic_clear_request_commit(struct nfs_page *req,
361 				       struct nfs_commit_info *cinfo);
362 void pnfs_generic_commit_release(void *calldata);
363 void pnfs_generic_prepare_to_resend_writes(struct nfs_commit_data *data);
364 void pnfs_generic_rw_release(void *data);
365 void pnfs_generic_recover_commit_reqs(struct list_head *dst,
366 				      struct nfs_commit_info *cinfo);
367 int pnfs_generic_commit_pagelist(struct inode *inode,
368 				 struct list_head *mds_pages,
369 				 int how,
370 				 struct nfs_commit_info *cinfo,
371 				 int (*initiate_commit)(struct nfs_commit_data *data,
372 							int how));
373 int pnfs_generic_scan_commit_lists(struct nfs_commit_info *cinfo, int max);
374 void pnfs_generic_write_commit_done(struct rpc_task *task, void *data);
375 void nfs4_pnfs_ds_put(struct nfs4_pnfs_ds *ds);
376 struct nfs4_pnfs_ds *nfs4_pnfs_ds_add(struct list_head *dsaddrs,
377 				      gfp_t gfp_flags);
378 void nfs4_pnfs_v3_ds_connect_unload(void);
379 int nfs4_pnfs_ds_connect(struct nfs_server *mds_srv, struct nfs4_pnfs_ds *ds,
380 			  struct nfs4_deviceid_node *devid, unsigned int timeo,
381 			  unsigned int retrans, u32 version, u32 minor_version);
382 struct nfs4_pnfs_ds_addr *nfs4_decode_mp_ds_addr(struct net *net,
383 						 struct xdr_stream *xdr,
384 						 gfp_t gfp_flags);
385 void pnfs_layout_mark_request_commit(struct nfs_page *req,
386 				     struct pnfs_layout_segment *lseg,
387 				     struct nfs_commit_info *cinfo,
388 				     u32 ds_commit_idx);
389 void pnfs_lgopen_prepare(struct nfs4_opendata *data,
390 			 struct nfs_open_context *ctx);
391 void pnfs_parse_lgopen(struct inode *ino, struct nfs4_layoutget *lgp,
392 		       struct nfs_open_context *ctx);
393 void nfs4_lgopen_release(struct nfs4_layoutget *lgp);
394 
nfs_have_layout(struct inode * inode)395 static inline bool nfs_have_layout(struct inode *inode)
396 {
397 	return NFS_I(inode)->layout != NULL;
398 }
399 
pnfs_layout_is_valid(const struct pnfs_layout_hdr * lo)400 static inline bool pnfs_layout_is_valid(const struct pnfs_layout_hdr *lo)
401 {
402 	return test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) == 0;
403 }
404 
405 static inline struct nfs4_deviceid_node *
nfs4_get_deviceid(struct nfs4_deviceid_node * d)406 nfs4_get_deviceid(struct nfs4_deviceid_node *d)
407 {
408 	atomic_inc(&d->ref);
409 	return d;
410 }
411 
412 static inline struct pnfs_layout_segment *
pnfs_get_lseg(struct pnfs_layout_segment * lseg)413 pnfs_get_lseg(struct pnfs_layout_segment *lseg)
414 {
415 	if (lseg) {
416 		refcount_inc(&lseg->pls_refcount);
417 		smp_mb__after_atomic();
418 	}
419 	return lseg;
420 }
421 
422 static inline bool
pnfs_is_valid_lseg(struct pnfs_layout_segment * lseg)423 pnfs_is_valid_lseg(struct pnfs_layout_segment *lseg)
424 {
425 	return test_bit(NFS_LSEG_VALID, &lseg->pls_flags) != 0;
426 }
427 
428 /* Return true if a layout driver is being used for this mountpoint */
pnfs_enabled_sb(struct nfs_server * nfss)429 static inline int pnfs_enabled_sb(struct nfs_server *nfss)
430 {
431 	return nfss->pnfs_curr_ld != NULL;
432 }
433 
434 static inline int
pnfs_commit_list(struct inode * inode,struct list_head * mds_pages,int how,struct nfs_commit_info * cinfo)435 pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how,
436 		 struct nfs_commit_info *cinfo)
437 {
438 	if (cinfo->ds == NULL || cinfo->ds->ncommitting == 0)
439 		return PNFS_NOT_ATTEMPTED;
440 	return NFS_SERVER(inode)->pnfs_curr_ld->commit_pagelist(inode, mds_pages, how, cinfo);
441 }
442 
443 static inline struct pnfs_ds_commit_info *
pnfs_get_ds_info(struct inode * inode)444 pnfs_get_ds_info(struct inode *inode)
445 {
446 	struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
447 
448 	if (ld == NULL || ld->get_ds_info == NULL)
449 		return NULL;
450 	return ld->get_ds_info(inode);
451 }
452 
453 static inline void
pnfs_generic_mark_devid_invalid(struct nfs4_deviceid_node * node)454 pnfs_generic_mark_devid_invalid(struct nfs4_deviceid_node *node)
455 {
456 	set_bit(NFS_DEVICEID_INVALID, &node->flags);
457 }
458 
459 static inline bool
pnfs_mark_request_commit(struct nfs_page * req,struct pnfs_layout_segment * lseg,struct nfs_commit_info * cinfo,u32 ds_commit_idx)460 pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
461 			 struct nfs_commit_info *cinfo, u32 ds_commit_idx)
462 {
463 	struct inode *inode = d_inode(req->wb_context->dentry);
464 	struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
465 
466 	if (lseg == NULL || ld->mark_request_commit == NULL)
467 		return false;
468 	ld->mark_request_commit(req, lseg, cinfo, ds_commit_idx);
469 	return true;
470 }
471 
472 static inline bool
pnfs_clear_request_commit(struct nfs_page * req,struct nfs_commit_info * cinfo)473 pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
474 {
475 	struct inode *inode = d_inode(req->wb_context->dentry);
476 	struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
477 
478 	if (ld == NULL || ld->clear_request_commit == NULL)
479 		return false;
480 	ld->clear_request_commit(req, cinfo);
481 	return true;
482 }
483 
484 static inline int
pnfs_scan_commit_lists(struct inode * inode,struct nfs_commit_info * cinfo,int max)485 pnfs_scan_commit_lists(struct inode *inode, struct nfs_commit_info *cinfo,
486 		       int max)
487 {
488 	if (cinfo->ds == NULL || cinfo->ds->nwritten == 0)
489 		return 0;
490 	else
491 		return NFS_SERVER(inode)->pnfs_curr_ld->scan_commit_lists(cinfo, max);
492 }
493 
494 static inline struct nfs_page *
pnfs_search_commit_reqs(struct inode * inode,struct nfs_commit_info * cinfo,struct page * page)495 pnfs_search_commit_reqs(struct inode *inode, struct nfs_commit_info *cinfo,
496 			struct page *page)
497 {
498 	struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld;
499 
500 	if (ld == NULL || ld->search_commit_reqs == NULL)
501 		return NULL;
502 	return ld->search_commit_reqs(cinfo, page);
503 }
504 
505 /* Should the pNFS client commit and return the layout upon a setattr */
506 static inline bool
pnfs_ld_layoutret_on_setattr(struct inode * inode)507 pnfs_ld_layoutret_on_setattr(struct inode *inode)
508 {
509 	if (!pnfs_enabled_sb(NFS_SERVER(inode)))
510 		return false;
511 	return NFS_SERVER(inode)->pnfs_curr_ld->flags &
512 		PNFS_LAYOUTRET_ON_SETATTR;
513 }
514 
515 static inline bool
pnfs_ld_read_whole_page(struct inode * inode)516 pnfs_ld_read_whole_page(struct inode *inode)
517 {
518 	if (!pnfs_enabled_sb(NFS_SERVER(inode)))
519 		return false;
520 	return NFS_SERVER(inode)->pnfs_curr_ld->flags & PNFS_READ_WHOLE_PAGE;
521 }
522 
523 static inline int
pnfs_sync_inode(struct inode * inode,bool datasync)524 pnfs_sync_inode(struct inode *inode, bool datasync)
525 {
526 	if (!pnfs_enabled_sb(NFS_SERVER(inode)))
527 		return 0;
528 	return NFS_SERVER(inode)->pnfs_curr_ld->sync(inode, datasync);
529 }
530 
531 static inline bool
pnfs_layoutcommit_outstanding(struct inode * inode)532 pnfs_layoutcommit_outstanding(struct inode *inode)
533 {
534 	struct nfs_inode *nfsi = NFS_I(inode);
535 
536 	return test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags) != 0 ||
537 		test_bit(NFS_INO_LAYOUTCOMMITTING, &nfsi->flags) != 0;
538 }
539 
pnfs_return_layout(struct inode * ino)540 static inline int pnfs_return_layout(struct inode *ino)
541 {
542 	struct nfs_inode *nfsi = NFS_I(ino);
543 	struct nfs_server *nfss = NFS_SERVER(ino);
544 
545 	if (pnfs_enabled_sb(nfss) && nfsi->layout) {
546 		set_bit(NFS_LAYOUT_RETURN_REQUESTED, &nfsi->layout->plh_flags);
547 		return _pnfs_return_layout(ino);
548 	}
549 
550 	return 0;
551 }
552 
553 static inline bool
pnfs_use_threshold(struct nfs4_threshold ** dst,struct nfs4_threshold * src,struct nfs_server * nfss)554 pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,
555 		   struct nfs_server *nfss)
556 {
557 	return (dst && src && src->bm != 0 && nfss->pnfs_curr_ld &&
558 					nfss->pnfs_curr_ld->id == src->l_type);
559 }
560 
561 static inline u64
pnfs_calc_offset_end(u64 offset,u64 len)562 pnfs_calc_offset_end(u64 offset, u64 len)
563 {
564 	if (len == NFS4_MAX_UINT64 || len >= NFS4_MAX_UINT64 - offset)
565 		return NFS4_MAX_UINT64;
566 	return offset + len - 1;
567 }
568 
569 static inline u64
pnfs_calc_offset_length(u64 offset,u64 end)570 pnfs_calc_offset_length(u64 offset, u64 end)
571 {
572 	if (end == NFS4_MAX_UINT64 || end <= offset)
573 		return NFS4_MAX_UINT64;
574 	return 1 + end - offset;
575 }
576 
577 static inline void
pnfs_copy_range(struct pnfs_layout_range * dst,const struct pnfs_layout_range * src)578 pnfs_copy_range(struct pnfs_layout_range *dst,
579 		const struct pnfs_layout_range *src)
580 {
581 	memcpy(dst, src, sizeof(*dst));
582 }
583 
584 static inline u64
pnfs_end_offset(u64 start,u64 len)585 pnfs_end_offset(u64 start, u64 len)
586 {
587 	if (NFS4_MAX_UINT64 - start <= len)
588 		return NFS4_MAX_UINT64;
589 	return start + len;
590 }
591 
592 /*
593  * Are 2 ranges intersecting?
594  *   start1                             end1
595  *   [----------------------------------)
596  *                                start2           end2
597  *                                [----------------)
598  */
599 static inline bool
pnfs_is_range_intersecting(u64 start1,u64 end1,u64 start2,u64 end2)600 pnfs_is_range_intersecting(u64 start1, u64 end1, u64 start2, u64 end2)
601 {
602 	return (end1 == NFS4_MAX_UINT64 || start2 < end1) &&
603 		(end2 == NFS4_MAX_UINT64 || start1 < end2);
604 }
605 
606 static inline bool
pnfs_lseg_range_intersecting(const struct pnfs_layout_range * l1,const struct pnfs_layout_range * l2)607 pnfs_lseg_range_intersecting(const struct pnfs_layout_range *l1,
608 		const struct pnfs_layout_range *l2)
609 {
610 	u64 end1 = pnfs_end_offset(l1->offset, l1->length);
611 	u64 end2 = pnfs_end_offset(l2->offset, l2->length);
612 
613 	return pnfs_is_range_intersecting(l1->offset, end1, l2->offset, end2);
614 }
615 
616 static inline bool
pnfs_lseg_request_intersecting(struct pnfs_layout_segment * lseg,struct nfs_page * req)617 pnfs_lseg_request_intersecting(struct pnfs_layout_segment *lseg, struct nfs_page *req)
618 {
619 	u64 seg_last = pnfs_end_offset(lseg->pls_range.offset, lseg->pls_range.length);
620 	u64 req_last = req_offset(req) + req->wb_bytes;
621 
622 	return pnfs_is_range_intersecting(lseg->pls_range.offset, seg_last,
623 				req_offset(req), req_last);
624 }
625 
626 extern unsigned int layoutstats_timer;
627 
628 #ifdef NFS_DEBUG
629 void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id);
630 #else
nfs4_print_deviceid(const struct nfs4_deviceid * dev_id)631 static inline void nfs4_print_deviceid(const struct nfs4_deviceid *dev_id)
632 {
633 }
634 
635 #endif /* NFS_DEBUG */
636 #else  /* CONFIG_NFS_V4_1 */
637 
nfs_have_layout(struct inode * inode)638 static inline bool nfs_have_layout(struct inode *inode)
639 {
640 	return false;
641 }
642 
pnfs_destroy_all_layouts(struct nfs_client * clp)643 static inline void pnfs_destroy_all_layouts(struct nfs_client *clp)
644 {
645 }
646 
pnfs_destroy_layout(struct nfs_inode * nfsi)647 static inline void pnfs_destroy_layout(struct nfs_inode *nfsi)
648 {
649 }
650 
pnfs_destroy_layout_final(struct nfs_inode * nfsi)651 static inline void pnfs_destroy_layout_final(struct nfs_inode *nfsi)
652 {
653 }
654 
655 static inline struct pnfs_layout_segment *
pnfs_get_lseg(struct pnfs_layout_segment * lseg)656 pnfs_get_lseg(struct pnfs_layout_segment *lseg)
657 {
658 	return NULL;
659 }
660 
pnfs_put_lseg(struct pnfs_layout_segment * lseg)661 static inline void pnfs_put_lseg(struct pnfs_layout_segment *lseg)
662 {
663 }
664 
pnfs_return_layout(struct inode * ino)665 static inline int pnfs_return_layout(struct inode *ino)
666 {
667 	return 0;
668 }
669 
pnfs_commit_and_return_layout(struct inode * inode)670 static inline int pnfs_commit_and_return_layout(struct inode *inode)
671 {
672 	return 0;
673 }
674 
675 static inline bool
pnfs_ld_layoutret_on_setattr(struct inode * inode)676 pnfs_ld_layoutret_on_setattr(struct inode *inode)
677 {
678 	return false;
679 }
680 
681 static inline bool
pnfs_ld_read_whole_page(struct inode * inode)682 pnfs_ld_read_whole_page(struct inode *inode)
683 {
684 	return false;
685 }
686 
687 static inline int
pnfs_sync_inode(struct inode * inode,bool datasync)688 pnfs_sync_inode(struct inode *inode, bool datasync)
689 {
690 	return 0;
691 }
692 
693 static inline bool
pnfs_layoutcommit_outstanding(struct inode * inode)694 pnfs_layoutcommit_outstanding(struct inode *inode)
695 {
696 	return false;
697 }
698 
699 
700 static inline bool
pnfs_roc(struct inode * ino,struct nfs4_layoutreturn_args * args,struct nfs4_layoutreturn_res * res,const struct rpc_cred * cred)701 pnfs_roc(struct inode *ino,
702 		struct nfs4_layoutreturn_args *args,
703 		struct nfs4_layoutreturn_res *res,
704 		const struct rpc_cred *cred)
705 {
706 	return false;
707 }
708 
709 static inline void
pnfs_roc_release(struct nfs4_layoutreturn_args * args,struct nfs4_layoutreturn_res * res,int ret)710 pnfs_roc_release(struct nfs4_layoutreturn_args *args,
711 		struct nfs4_layoutreturn_res *res,
712 		int ret)
713 {
714 }
715 
716 static inline bool
pnfs_wait_on_layoutreturn(struct inode * ino,struct rpc_task * task)717 pnfs_wait_on_layoutreturn(struct inode *ino, struct rpc_task *task)
718 {
719 	return false;
720 }
721 
set_pnfs_layoutdriver(struct nfs_server * s,const struct nfs_fh * mntfh,struct nfs_fsinfo * fsinfo)722 static inline void set_pnfs_layoutdriver(struct nfs_server *s,
723 					 const struct nfs_fh *mntfh,
724 					 struct nfs_fsinfo *fsinfo)
725 {
726 }
727 
unset_pnfs_layoutdriver(struct nfs_server * s)728 static inline void unset_pnfs_layoutdriver(struct nfs_server *s)
729 {
730 }
731 
732 static inline int
pnfs_commit_list(struct inode * inode,struct list_head * mds_pages,int how,struct nfs_commit_info * cinfo)733 pnfs_commit_list(struct inode *inode, struct list_head *mds_pages, int how,
734 		 struct nfs_commit_info *cinfo)
735 {
736 	return PNFS_NOT_ATTEMPTED;
737 }
738 
739 static inline struct pnfs_ds_commit_info *
pnfs_get_ds_info(struct inode * inode)740 pnfs_get_ds_info(struct inode *inode)
741 {
742 	return NULL;
743 }
744 
745 static inline bool
pnfs_mark_request_commit(struct nfs_page * req,struct pnfs_layout_segment * lseg,struct nfs_commit_info * cinfo,u32 ds_commit_idx)746 pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg,
747 			 struct nfs_commit_info *cinfo, u32 ds_commit_idx)
748 {
749 	return false;
750 }
751 
752 static inline bool
pnfs_clear_request_commit(struct nfs_page * req,struct nfs_commit_info * cinfo)753 pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo)
754 {
755 	return false;
756 }
757 
758 static inline int
pnfs_scan_commit_lists(struct inode * inode,struct nfs_commit_info * cinfo,int max)759 pnfs_scan_commit_lists(struct inode *inode, struct nfs_commit_info *cinfo,
760 		       int max)
761 {
762 	return 0;
763 }
764 
765 static inline struct nfs_page *
pnfs_search_commit_reqs(struct inode * inode,struct nfs_commit_info * cinfo,struct page * page)766 pnfs_search_commit_reqs(struct inode *inode, struct nfs_commit_info *cinfo,
767 			struct page *page)
768 {
769 	return NULL;
770 }
771 
pnfs_layoutcommit_inode(struct inode * inode,bool sync)772 static inline int pnfs_layoutcommit_inode(struct inode *inode, bool sync)
773 {
774 	return 0;
775 }
776 
777 static inline bool
pnfs_use_threshold(struct nfs4_threshold ** dst,struct nfs4_threshold * src,struct nfs_server * nfss)778 pnfs_use_threshold(struct nfs4_threshold **dst, struct nfs4_threshold *src,
779 		   struct nfs_server *nfss)
780 {
781 	return false;
782 }
783 
pnfs_mdsthreshold_alloc(void)784 static inline struct nfs4_threshold *pnfs_mdsthreshold_alloc(void)
785 {
786 	return NULL;
787 }
788 
nfs4_pnfs_v3_ds_connect_unload(void)789 static inline void nfs4_pnfs_v3_ds_connect_unload(void)
790 {
791 }
792 
nfs4_layoutreturn_refresh_stateid(nfs4_stateid * dst,struct pnfs_layout_range * dst_range,struct inode * inode)793 static inline bool nfs4_layoutreturn_refresh_stateid(nfs4_stateid *dst,
794 		struct pnfs_layout_range *dst_range,
795 		struct inode *inode)
796 {
797 	return false;
798 }
799 
pnfs_lgopen_prepare(struct nfs4_opendata * data,struct nfs_open_context * ctx)800 static inline void pnfs_lgopen_prepare(struct nfs4_opendata *data,
801 		struct nfs_open_context *ctx)
802 {
803 }
804 
pnfs_parse_lgopen(struct inode * ino,struct nfs4_layoutget * lgp,struct nfs_open_context * ctx)805 static inline void pnfs_parse_lgopen(struct inode *ino,
806 		struct nfs4_layoutget *lgp,
807 		struct nfs_open_context *ctx)
808 {
809 }
810 
nfs4_lgopen_release(struct nfs4_layoutget * lgp)811 static inline void nfs4_lgopen_release(struct nfs4_layoutget *lgp)
812 {
813 }
814 
pnfs_layout_is_valid(const struct pnfs_layout_hdr * lo)815 static inline bool pnfs_layout_is_valid(const struct pnfs_layout_hdr *lo)
816 {
817 	return false;
818 }
819 
820 #endif /* CONFIG_NFS_V4_1 */
821 
822 #if IS_ENABLED(CONFIG_NFS_V4_2)
823 int pnfs_report_layoutstat(struct inode *inode, gfp_t gfp_flags);
824 #else
825 static inline int
pnfs_report_layoutstat(struct inode * inode,gfp_t gfp_flags)826 pnfs_report_layoutstat(struct inode *inode, gfp_t gfp_flags)
827 {
828 	return 0;
829 }
830 #endif
831 
832 #endif /* FS_NFS_PNFS_H */
833