1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * linux/include/linux/nfs_fs.h 4 * 5 * Copyright (C) 1992 Rick Sladkey 6 * 7 * OS-specific nfs filesystem definitions and declarations 8 */ 9 #ifndef _LINUX_NFS_FS_H 10 #define _LINUX_NFS_FS_H 11 12 #include <uapi/linux/nfs_fs.h> 13 14 15 /* 16 * Enable dprintk() debugging support for nfs client. 17 */ 18 #ifdef CONFIG_NFS_DEBUG 19 # define NFS_DEBUG 20 #endif 21 22 #include <linux/in.h> 23 #include <linux/mm.h> 24 #include <linux/pagemap.h> 25 #include <linux/rbtree.h> 26 #include <linux/refcount.h> 27 #include <linux/rwsem.h> 28 #include <linux/wait.h> 29 30 #include <linux/sunrpc/debug.h> 31 #include <linux/sunrpc/auth.h> 32 #include <linux/sunrpc/clnt.h> 33 34 #ifdef CONFIG_NFS_FSCACHE 35 #include <linux/netfs.h> 36 #endif 37 38 #include <linux/nfs.h> 39 #include <linux/nfs2.h> 40 #include <linux/nfs3.h> 41 #include <linux/nfs4.h> 42 #include <linux/nfs_xdr.h> 43 #include <linux/nfs_fs_sb.h> 44 45 #include <linux/mempool.h> 46 47 /* 48 * These are the default for number of transports to different server IPs 49 */ 50 #define NFS_MAX_TRANSPORTS 16 51 52 /* 53 * Size of the NFS directory verifier 54 */ 55 #define NFS_DIR_VERIFIER_SIZE 2 56 57 /* 58 * NFSv3/v4 Access mode cache entry 59 */ 60 struct nfs_access_entry { 61 struct rb_node rb_node; 62 struct list_head lru; 63 kuid_t fsuid; 64 kgid_t fsgid; 65 struct group_info *group_info; 66 u64 timestamp; 67 __u32 mask; 68 struct rcu_head rcu_head; 69 }; 70 71 struct nfs_lock_context { 72 refcount_t count; 73 struct list_head list; 74 struct nfs_open_context *open_context; 75 fl_owner_t lockowner; 76 atomic_t io_count; 77 struct rcu_head rcu_head; 78 }; 79 80 struct nfs_file_localio { 81 struct nfsd_file __rcu *ro_file; 82 struct nfsd_file __rcu *rw_file; 83 struct list_head list; 84 void __rcu *nfs_uuid; /* opaque pointer to 'nfs_uuid_t' */ 85 }; 86 87 static inline void nfs_localio_file_init(struct nfs_file_localio *nfl) 88 { 89 #if IS_ENABLED(CONFIG_NFS_LOCALIO) 90 nfl->ro_file = NULL; 91 nfl->rw_file = NULL; 92 INIT_LIST_HEAD(&nfl->list); 93 nfl->nfs_uuid = NULL; 94 #endif 95 } 96 97 struct nfs4_state; 98 struct nfs_open_context { 99 struct nfs_lock_context lock_context; 100 fl_owner_t flock_owner; 101 struct dentry *dentry; 102 const struct cred *cred; 103 struct rpc_cred __rcu *ll_cred; /* low-level cred - use to check for expiry */ 104 struct nfs4_state *state; 105 fmode_t mode; 106 107 int error; 108 unsigned long flags; 109 #define NFS_CONTEXT_BAD (2) 110 #define NFS_CONTEXT_UNLOCK (3) 111 #define NFS_CONTEXT_FILE_OPEN (4) 112 113 struct nfs4_threshold *mdsthreshold; 114 struct list_head list; 115 struct rcu_head rcu_head; 116 struct nfs_file_localio nfl; 117 }; 118 119 struct nfs_open_dir_context { 120 struct list_head list; 121 atomic_t cache_hits; 122 atomic_t cache_misses; 123 unsigned long attr_gencount; 124 __be32 verf[NFS_DIR_VERIFIER_SIZE]; 125 __u64 dir_cookie; 126 __u64 last_cookie; 127 pgoff_t page_index; 128 unsigned int dtsize; 129 bool force_clear; 130 bool eof; 131 struct rcu_head rcu_head; 132 }; 133 134 /* 135 * NFSv4 delegation 136 */ 137 struct nfs_delegation; 138 139 struct posix_acl; 140 141 struct nfs4_xattr_cache; 142 143 /* 144 * nfs fs inode data in memory 145 */ 146 struct nfs_inode { 147 /* 148 * The 64bit 'inode number' 149 */ 150 __u64 fileid; 151 152 /* 153 * NFS file handle 154 */ 155 struct nfs_fh fh; 156 157 /* 158 * Various flags 159 */ 160 unsigned long flags; /* atomic bit ops */ 161 unsigned long cache_validity; /* bit mask */ 162 163 /* 164 * read_cache_jiffies is when we started read-caching this inode. 165 * attrtimeo is for how long the cached information is assumed 166 * to be valid. A successful attribute revalidation doubles 167 * attrtimeo (up to acregmax/acdirmax), a failure resets it to 168 * acregmin/acdirmin. 169 * 170 * We need to revalidate the cached attrs for this inode if 171 * 172 * jiffies - read_cache_jiffies >= attrtimeo 173 * 174 * Please note the comparison is greater than or equal 175 * so that zero timeout values can be specified. 176 */ 177 unsigned long read_cache_jiffies; 178 unsigned long attrtimeo; 179 unsigned long attrtimeo_timestamp; 180 181 unsigned long attr_gencount; 182 183 struct rb_root access_cache; 184 struct list_head access_cache_entry_lru; 185 struct list_head access_cache_inode_lru; 186 187 union { 188 /* Directory */ 189 struct { 190 /* "Generation counter" for the attribute cache. 191 * This is bumped whenever we update the metadata 192 * on the server. 193 */ 194 unsigned long cache_change_attribute; 195 /* 196 * This is the cookie verifier used for NFSv3 readdir 197 * operations 198 */ 199 __be32 cookieverf[NFS_DIR_VERIFIER_SIZE]; 200 /* Readers: in-flight sillydelete RPC calls */ 201 /* Writers: rmdir */ 202 struct rw_semaphore rmdir_sem; 203 }; 204 /* Regular file */ 205 struct { 206 atomic_long_t nrequests; 207 atomic_long_t redirtied_pages; 208 struct nfs_mds_commit_info commit_info; 209 struct mutex commit_mutex; 210 }; 211 }; 212 213 /* Open contexts for shared mmap writes */ 214 struct list_head open_files; 215 216 /* Keep track of out-of-order replies. 217 * The ooo array contains start/end pairs of 218 * numbers from the changeid sequence when 219 * the inode's iversion has been updated. 220 * It also contains end/start pair (i.e. reverse order) 221 * of sections of the changeid sequence that have 222 * been seen in replies from the server. 223 * Normally these should match and when both 224 * A:B and B:A are found in ooo, they are both removed. 225 * And if a reply with A:B causes an iversion update 226 * of A:B, then neither are added. 227 * When a reply has pre_change that doesn't match 228 * iversion, then the changeid pair and any consequent 229 * change in iversion ARE added. Later replies 230 * might fill in the gaps, or possibly a gap is caused 231 * by a change from another client. 232 * When a file or directory is opened, if the ooo table 233 * is not empty, then we assume the gaps were due to 234 * another client and we invalidate the cached data. 235 * 236 * We can only track a limited number of concurrent gaps. 237 * Currently that limit is 16. 238 * We allocate the table on demand. If there is insufficient 239 * memory, then we probably cannot cache the file anyway 240 * so there is no loss. 241 */ 242 struct { 243 int cnt; 244 struct { 245 u64 start, end; 246 } gap[16]; 247 } *ooo; 248 249 #if IS_ENABLED(CONFIG_NFS_V4) 250 struct nfs4_cached_acl *nfs4_acl; 251 /* NFSv4 state */ 252 struct list_head open_states; 253 struct nfs_delegation __rcu *delegation; 254 struct rw_semaphore rwsem; 255 256 /* pNFS layout information */ 257 struct pnfs_layout_hdr *layout; 258 #endif /* CONFIG_NFS_V4*/ 259 /* how many bytes have been written/read and how many bytes queued up */ 260 __u64 write_io; 261 __u64 read_io; 262 #ifdef CONFIG_NFS_V4_2 263 struct nfs4_xattr_cache *xattr_cache; 264 #endif 265 union { 266 struct inode vfs_inode; 267 #ifdef CONFIG_NFS_FSCACHE 268 struct netfs_inode netfs; /* netfs context and VFS inode */ 269 #endif 270 }; 271 }; 272 273 struct nfs4_copy_state { 274 struct list_head copies; 275 struct list_head src_copies; 276 nfs4_stateid stateid; 277 struct completion completion; 278 uint64_t count; 279 struct nfs_writeverf verf; 280 int error; 281 int flags; 282 struct nfs4_state *parent_src_state; 283 struct nfs4_state *parent_dst_state; 284 }; 285 286 /* 287 * Access bit flags 288 */ 289 #define NFS_ACCESS_READ 0x0001 290 #define NFS_ACCESS_LOOKUP 0x0002 291 #define NFS_ACCESS_MODIFY 0x0004 292 #define NFS_ACCESS_EXTEND 0x0008 293 #define NFS_ACCESS_DELETE 0x0010 294 #define NFS_ACCESS_EXECUTE 0x0020 295 #define NFS_ACCESS_XAREAD 0x0040 296 #define NFS_ACCESS_XAWRITE 0x0080 297 #define NFS_ACCESS_XALIST 0x0100 298 299 /* 300 * Cache validity bit flags 301 */ 302 #define NFS_INO_INVALID_DATA BIT(1) /* cached data is invalid */ 303 #define NFS_INO_INVALID_ATIME BIT(2) /* cached atime is invalid */ 304 #define NFS_INO_INVALID_ACCESS BIT(3) /* cached access cred invalid */ 305 #define NFS_INO_INVALID_ACL BIT(4) /* cached acls are invalid */ 306 #define NFS_INO_REVAL_FORCED BIT(6) /* force revalidation ignoring a delegation */ 307 #define NFS_INO_INVALID_LABEL BIT(7) /* cached label is invalid */ 308 #define NFS_INO_INVALID_CHANGE BIT(8) /* cached change is invalid */ 309 #define NFS_INO_INVALID_CTIME BIT(9) /* cached ctime is invalid */ 310 #define NFS_INO_INVALID_MTIME BIT(10) /* cached mtime is invalid */ 311 #define NFS_INO_INVALID_SIZE BIT(11) /* cached size is invalid */ 312 #define NFS_INO_INVALID_OTHER BIT(12) /* other attrs are invalid */ 313 #define NFS_INO_DATA_INVAL_DEFER \ 314 BIT(13) /* Deferred cache invalidation */ 315 #define NFS_INO_INVALID_BLOCKS BIT(14) /* cached blocks are invalid */ 316 #define NFS_INO_INVALID_XATTR BIT(15) /* xattrs are invalid */ 317 #define NFS_INO_INVALID_NLINK BIT(16) /* cached nlinks is invalid */ 318 #define NFS_INO_INVALID_MODE BIT(17) /* cached mode is invalid */ 319 320 #define NFS_INO_INVALID_ATTR (NFS_INO_INVALID_CHANGE \ 321 | NFS_INO_INVALID_CTIME \ 322 | NFS_INO_INVALID_MTIME \ 323 | NFS_INO_INVALID_SIZE \ 324 | NFS_INO_INVALID_NLINK \ 325 | NFS_INO_INVALID_MODE \ 326 | NFS_INO_INVALID_OTHER) /* inode metadata is invalid */ 327 328 /* 329 * Bit offsets in flags field 330 */ 331 #define NFS_INO_STALE (1) /* possible stale inode */ 332 #define NFS_INO_ACL_LRU_SET (2) /* Inode is on the LRU list */ 333 #define NFS_INO_INVALIDATING (3) /* inode is being invalidated */ 334 #define NFS_INO_PRESERVE_UNLINKED (4) /* preserve file if removed while open */ 335 #define NFS_INO_LAYOUTCOMMIT (9) /* layoutcommit required */ 336 #define NFS_INO_LAYOUTCOMMITTING (10) /* layoutcommit inflight */ 337 #define NFS_INO_LAYOUTSTATS (11) /* layoutstats inflight */ 338 #define NFS_INO_ODIRECT (12) /* I/O setting is O_DIRECT */ 339 340 static inline struct nfs_inode *NFS_I(const struct inode *inode) 341 { 342 return container_of(inode, struct nfs_inode, vfs_inode); 343 } 344 345 static inline struct nfs_server *NFS_SB(const struct super_block *s) 346 { 347 return (struct nfs_server *)(s->s_fs_info); 348 } 349 350 static inline struct nfs_fh *NFS_FH(const struct inode *inode) 351 { 352 return &NFS_I(inode)->fh; 353 } 354 355 static inline struct nfs_server *NFS_SERVER(const struct inode *inode) 356 { 357 return NFS_SB(inode->i_sb); 358 } 359 360 static inline struct rpc_clnt *NFS_CLIENT(const struct inode *inode) 361 { 362 return NFS_SERVER(inode)->client; 363 } 364 365 static inline const struct nfs_rpc_ops *NFS_PROTO(const struct inode *inode) 366 { 367 return NFS_SERVER(inode)->nfs_client->rpc_ops; 368 } 369 370 static inline unsigned NFS_MINATTRTIMEO(const struct inode *inode) 371 { 372 struct nfs_server *nfss = NFS_SERVER(inode); 373 return S_ISDIR(inode->i_mode) ? nfss->acdirmin : nfss->acregmin; 374 } 375 376 static inline unsigned NFS_MAXATTRTIMEO(const struct inode *inode) 377 { 378 struct nfs_server *nfss = NFS_SERVER(inode); 379 return S_ISDIR(inode->i_mode) ? nfss->acdirmax : nfss->acregmax; 380 } 381 382 static inline int NFS_STALE(const struct inode *inode) 383 { 384 return test_bit(NFS_INO_STALE, &NFS_I(inode)->flags); 385 } 386 387 static inline __u64 NFS_FILEID(const struct inode *inode) 388 { 389 return NFS_I(inode)->fileid; 390 } 391 392 static inline void set_nfs_fileid(struct inode *inode, __u64 fileid) 393 { 394 NFS_I(inode)->fileid = fileid; 395 } 396 397 static inline void nfs_mark_for_revalidate(struct inode *inode) 398 { 399 struct nfs_inode *nfsi = NFS_I(inode); 400 401 spin_lock(&inode->i_lock); 402 nfsi->cache_validity |= NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL | 403 NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME | 404 NFS_INO_INVALID_SIZE; 405 if (S_ISDIR(inode->i_mode)) 406 nfsi->cache_validity |= NFS_INO_INVALID_DATA; 407 spin_unlock(&inode->i_lock); 408 } 409 410 static inline int nfs_server_capable(const struct inode *inode, int cap) 411 { 412 return NFS_SERVER(inode)->caps & cap; 413 } 414 415 /** 416 * nfs_save_change_attribute - Returns the inode attribute change cookie 417 * @dir - pointer to parent directory inode 418 * The "cache change attribute" is updated when we need to revalidate 419 * our dentry cache after a directory was seen to change on the server. 420 */ 421 static inline unsigned long nfs_save_change_attribute(struct inode *dir) 422 { 423 return NFS_I(dir)->cache_change_attribute; 424 } 425 426 /* 427 * linux/fs/nfs/inode.c 428 */ 429 extern int nfs_sync_mapping(struct address_space *mapping); 430 extern void nfs_zap_mapping(struct inode *inode, struct address_space *mapping); 431 extern void nfs_zap_caches(struct inode *); 432 extern void nfs_set_inode_stale(struct inode *inode); 433 extern void nfs_invalidate_atime(struct inode *); 434 extern struct inode *nfs_fhget(struct super_block *, struct nfs_fh *, 435 struct nfs_fattr *); 436 struct inode *nfs_ilookup(struct super_block *sb, struct nfs_fattr *, struct nfs_fh *); 437 extern int nfs_refresh_inode(struct inode *, struct nfs_fattr *); 438 extern int nfs_post_op_update_inode(struct inode *inode, struct nfs_fattr *fattr); 439 extern int nfs_post_op_update_inode_force_wcc(struct inode *inode, struct nfs_fattr *fattr); 440 extern int nfs_post_op_update_inode_force_wcc_locked(struct inode *inode, struct nfs_fattr *fattr); 441 extern int nfs_getattr(struct mnt_idmap *, const struct path *, 442 struct kstat *, u32, unsigned int); 443 extern void nfs_access_add_cache(struct inode *, struct nfs_access_entry *, const struct cred *); 444 extern void nfs_access_set_mask(struct nfs_access_entry *, u32); 445 extern int nfs_permission(struct mnt_idmap *, struct inode *, int); 446 extern int nfs_open(struct inode *, struct file *); 447 extern int nfs_attribute_cache_expired(struct inode *inode); 448 extern int nfs_revalidate_inode(struct inode *inode, unsigned long flags); 449 extern int __nfs_revalidate_inode(struct nfs_server *, struct inode *); 450 extern int nfs_clear_invalid_mapping(struct address_space *mapping); 451 extern bool nfs_mapping_need_revalidate_inode(struct inode *inode); 452 extern int nfs_revalidate_mapping(struct inode *inode, struct address_space *mapping); 453 extern int nfs_revalidate_mapping_rcu(struct inode *inode); 454 extern int nfs_setattr(struct mnt_idmap *, struct dentry *, struct iattr *); 455 extern void nfs_setattr_update_inode(struct inode *inode, struct iattr *attr, struct nfs_fattr *); 456 extern void nfs_setsecurity(struct inode *inode, struct nfs_fattr *fattr); 457 extern struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx); 458 extern void put_nfs_open_context(struct nfs_open_context *ctx); 459 extern struct nfs_open_context *nfs_find_open_context(struct inode *inode, const struct cred *cred, fmode_t mode); 460 extern struct nfs_open_context *alloc_nfs_open_context(struct dentry *dentry, fmode_t f_mode, struct file *filp); 461 extern void nfs_inode_attach_open_context(struct nfs_open_context *ctx); 462 extern void nfs_file_set_open_context(struct file *filp, struct nfs_open_context *ctx); 463 extern void nfs_file_clear_open_context(struct file *flip); 464 extern struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx); 465 extern void nfs_put_lock_context(struct nfs_lock_context *l_ctx); 466 extern u64 nfs_compat_user_ino64(u64 fileid); 467 extern void nfs_fattr_init(struct nfs_fattr *fattr); 468 extern void nfs_fattr_set_barrier(struct nfs_fattr *fattr); 469 extern unsigned long nfs_inc_attr_generation_counter(void); 470 471 extern struct nfs_fattr *nfs_alloc_fattr(void); 472 extern struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server); 473 474 static inline void nfs4_label_free(struct nfs4_label *label) 475 { 476 #ifdef CONFIG_NFS_V4_SECURITY_LABEL 477 if (label) { 478 kfree(label->label); 479 kfree(label); 480 } 481 #endif 482 } 483 484 static inline void nfs_free_fattr(const struct nfs_fattr *fattr) 485 { 486 if (fattr) 487 nfs4_label_free(fattr->label); 488 kfree(fattr); 489 } 490 491 extern struct nfs_fh *nfs_alloc_fhandle(void); 492 493 static inline void nfs_free_fhandle(const struct nfs_fh *fh) 494 { 495 kfree(fh); 496 } 497 498 #ifdef NFS_DEBUG 499 extern u32 _nfs_display_fhandle_hash(const struct nfs_fh *fh); 500 static inline u32 nfs_display_fhandle_hash(const struct nfs_fh *fh) 501 { 502 return _nfs_display_fhandle_hash(fh); 503 } 504 extern void _nfs_display_fhandle(const struct nfs_fh *fh, const char *caption); 505 #define nfs_display_fhandle(fh, caption) \ 506 do { \ 507 if (unlikely(nfs_debug & NFSDBG_FACILITY)) \ 508 _nfs_display_fhandle(fh, caption); \ 509 } while (0) 510 #else 511 static inline u32 nfs_display_fhandle_hash(const struct nfs_fh *fh) 512 { 513 return 0; 514 } 515 static inline void nfs_display_fhandle(const struct nfs_fh *fh, 516 const char *caption) 517 { 518 } 519 #endif 520 521 /* 522 * linux/fs/nfs/nfsroot.c 523 */ 524 extern int nfs_root_data(char **root_device, char **root_data); /*__init*/ 525 /* linux/net/ipv4/ipconfig.c: trims ip addr off front of name, too. */ 526 extern __be32 root_nfs_parse_addr(char *name); /*__init*/ 527 528 /* 529 * linux/fs/nfs/file.c 530 */ 531 extern const struct file_operations nfs_file_operations; 532 #if IS_ENABLED(CONFIG_NFS_V4) 533 extern const struct file_operations nfs4_file_operations; 534 #endif /* CONFIG_NFS_V4 */ 535 extern const struct address_space_operations nfs_file_aops; 536 extern const struct address_space_operations nfs_dir_aops; 537 538 static inline struct nfs_open_context *nfs_file_open_context(struct file *filp) 539 { 540 return filp->private_data; 541 } 542 543 static inline const struct cred *nfs_file_cred(struct file *file) 544 { 545 if (file != NULL) { 546 struct nfs_open_context *ctx = 547 nfs_file_open_context(file); 548 if (ctx) 549 return ctx->cred; 550 } 551 return NULL; 552 } 553 554 /* 555 * linux/fs/nfs/direct.c 556 */ 557 int nfs_swap_rw(struct kiocb *iocb, struct iov_iter *iter); 558 ssize_t nfs_file_direct_read(struct kiocb *iocb, 559 struct iov_iter *iter, bool swap); 560 ssize_t nfs_file_direct_write(struct kiocb *iocb, 561 struct iov_iter *iter, bool swap); 562 563 /* 564 * linux/fs/nfs/dir.c 565 */ 566 extern const struct file_operations nfs_dir_operations; 567 extern const struct dentry_operations nfs_dentry_operations; 568 569 extern void nfs_force_lookup_revalidate(struct inode *dir); 570 extern void nfs_set_verifier(struct dentry * dentry, unsigned long verf); 571 #if IS_ENABLED(CONFIG_NFS_V4) 572 extern void nfs_clear_verifier_delegated(struct inode *inode); 573 #endif /* IS_ENABLED(CONFIG_NFS_V4) */ 574 extern struct dentry *nfs_add_or_obtain(struct dentry *dentry, 575 struct nfs_fh *fh, struct nfs_fattr *fattr); 576 extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh, 577 struct nfs_fattr *fattr); 578 extern int nfs_may_open(struct inode *inode, const struct cred *cred, int openflags); 579 extern void nfs_access_zap_cache(struct inode *inode); 580 extern int nfs_access_get_cached(struct inode *inode, const struct cred *cred, 581 u32 *mask, bool may_block); 582 extern int nfs_atomic_open_v23(struct inode *dir, struct dentry *dentry, 583 struct file *file, unsigned int open_flags, 584 umode_t mode); 585 586 /* 587 * linux/fs/nfs/symlink.c 588 */ 589 extern const struct inode_operations nfs_symlink_inode_operations; 590 591 /* 592 * linux/fs/nfs/sysctl.c 593 */ 594 #ifdef CONFIG_SYSCTL 595 extern int nfs_register_sysctl(void); 596 extern void nfs_unregister_sysctl(void); 597 #else 598 #define nfs_register_sysctl() 0 599 #define nfs_unregister_sysctl() do { } while(0) 600 #endif 601 602 /* 603 * linux/fs/nfs/namespace.c 604 */ 605 extern const struct inode_operations nfs_mountpoint_inode_operations; 606 extern const struct inode_operations nfs_referral_inode_operations; 607 extern int nfs_mountpoint_expiry_timeout; 608 extern void nfs_release_automount_timer(void); 609 610 /* 611 * linux/fs/nfs/unlink.c 612 */ 613 extern void nfs_complete_unlink(struct dentry *dentry, struct inode *); 614 615 /* 616 * linux/fs/nfs/write.c 617 */ 618 extern int nfs_congestion_kb; 619 extern int nfs_writepages(struct address_space *, struct writeback_control *); 620 extern int nfs_flush_incompatible(struct file *file, struct folio *folio); 621 extern int nfs_update_folio(struct file *file, struct folio *folio, 622 unsigned int offset, unsigned int count); 623 624 /* 625 * Try to write back everything synchronously (but check the 626 * return value!) 627 */ 628 extern int nfs_sync_inode(struct inode *inode); 629 extern int nfs_wb_all(struct inode *inode); 630 extern int nfs_wb_folio(struct inode *inode, struct folio *folio); 631 int nfs_wb_folio_cancel(struct inode *inode, struct folio *folio); 632 extern int nfs_commit_inode(struct inode *, int); 633 extern struct nfs_commit_data *nfs_commitdata_alloc(void); 634 extern void nfs_commit_free(struct nfs_commit_data *data); 635 void nfs_commit_begin(struct nfs_mds_commit_info *cinfo); 636 bool nfs_commit_end(struct nfs_mds_commit_info *cinfo); 637 638 static inline bool nfs_have_writebacks(const struct inode *inode) 639 { 640 if (S_ISREG(inode->i_mode)) 641 return atomic_long_read(&NFS_I(inode)->nrequests) != 0; 642 return false; 643 } 644 645 /* 646 * linux/fs/nfs/read.c 647 */ 648 int nfs_read_folio(struct file *, struct folio *); 649 void nfs_readahead(struct readahead_control *); 650 651 /* 652 * inline functions 653 */ 654 655 static inline loff_t nfs_size_to_loff_t(__u64 size) 656 { 657 return min_t(u64, size, OFFSET_MAX); 658 } 659 660 static inline ino_t 661 nfs_fileid_to_ino_t(u64 fileid) 662 { 663 ino_t ino = (ino_t) fileid; 664 if (sizeof(ino_t) < sizeof(u64)) 665 ino ^= fileid >> (sizeof(u64)-sizeof(ino_t)) * 8; 666 return ino; 667 } 668 669 static inline void nfs_ooo_clear(struct nfs_inode *nfsi) 670 { 671 nfsi->cache_validity &= ~NFS_INO_DATA_INVAL_DEFER; 672 kfree(nfsi->ooo); 673 nfsi->ooo = NULL; 674 } 675 676 static inline bool nfs_ooo_test(struct nfs_inode *nfsi) 677 { 678 return (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER) || 679 (nfsi->ooo && nfsi->ooo->cnt > 0); 680 681 } 682 683 #define NFS_JUKEBOX_RETRY_TIME (5 * HZ) 684 685 /* We need to block new opens while a file is being unlinked. 686 * If it is opened *before* we decide to unlink, we will silly-rename 687 * instead. If it is opened *after*, then we need to create or will fail. 688 * If we allow the two to race, we could end up with a file that is open 689 * but deleted on the server resulting in ESTALE. 690 * So use ->d_fsdata to record when the unlink is happening 691 * and block dentry revalidation while it is set. 692 */ 693 #define NFS_FSDATA_BLOCKED ((void*)1) 694 695 # undef ifdebug 696 # ifdef NFS_DEBUG 697 # define ifdebug(fac) if (unlikely(nfs_debug & NFSDBG_##fac)) 698 # define NFS_IFDEBUG(x) x 699 # else 700 # define ifdebug(fac) if (0) 701 # define NFS_IFDEBUG(x) 702 # endif 703 #endif 704