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