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