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