v9fs_vfs.h 3.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990
  1. /* SPDX-License-Identifier: GPL-2.0-only */
  2. /*
  3. * V9FS VFS extensions.
  4. *
  5. * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
  6. * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
  7. */
  8. #ifndef FS_9P_V9FS_VFS_H
  9. #define FS_9P_V9FS_VFS_H
  10. /* plan9 semantics are that created files are implicitly opened.
  11. * But linux semantics are that you call create, then open.
  12. * the plan9 approach is superior as it provides an atomic
  13. * open.
  14. * we track the create fid here. When the file is opened, if fidopen is
  15. * non-zero, we use the fid and can skip some steps.
  16. * there may be a better way to do this, but I don't know it.
  17. * one BAD way is to clunk the fid on create, then open it again:
  18. * you lose the atomicity of file open
  19. */
  20. /* special case:
  21. * unlink calls remove, which is an implicit clunk. So we have to track
  22. * that kind of thing so that we don't try to clunk a dead fid.
  23. */
  24. #define P9_LOCK_TIMEOUT (30*HZ)
  25. /* flags for v9fs_stat2inode() & v9fs_stat2inode_dotl() */
  26. #define V9FS_STAT2INODE_KEEP_ISIZE 1
  27. extern struct file_system_type v9fs_fs_type;
  28. extern const struct address_space_operations v9fs_addr_operations;
  29. extern const struct file_operations v9fs_file_operations;
  30. extern const struct file_operations v9fs_file_operations_dotl;
  31. extern const struct file_operations v9fs_dir_operations;
  32. extern const struct file_operations v9fs_dir_operations_dotl;
  33. extern const struct dentry_operations v9fs_dentry_operations;
  34. extern const struct dentry_operations v9fs_cached_dentry_operations;
  35. extern const struct file_operations v9fs_cached_file_operations;
  36. extern const struct file_operations v9fs_cached_file_operations_dotl;
  37. extern const struct file_operations v9fs_mmap_file_operations;
  38. extern const struct file_operations v9fs_mmap_file_operations_dotl;
  39. extern struct kmem_cache *v9fs_inode_cache;
  40. struct inode *v9fs_alloc_inode(struct super_block *sb);
  41. void v9fs_free_inode(struct inode *inode);
  42. struct inode *v9fs_get_inode(struct super_block *sb, umode_t mode, dev_t);
  43. int v9fs_init_inode(struct v9fs_session_info *v9ses,
  44. struct inode *inode, umode_t mode, dev_t);
  45. void v9fs_evict_inode(struct inode *inode);
  46. ino_t v9fs_qid2ino(struct p9_qid *qid);
  47. void v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode,
  48. struct super_block *sb, unsigned int flags);
  49. void v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode,
  50. unsigned int flags);
  51. int v9fs_dir_release(struct inode *inode, struct file *filp);
  52. int v9fs_file_open(struct inode *inode, struct file *file);
  53. void v9fs_inode2stat(struct inode *inode, struct p9_wstat *stat);
  54. int v9fs_uflags2omode(int uflags, int extended);
  55. void v9fs_blank_wstat(struct p9_wstat *wstat);
  56. int v9fs_vfs_setattr_dotl(struct dentry *, struct iattr *);
  57. int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end,
  58. int datasync);
  59. int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode);
  60. int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode);
  61. static inline void v9fs_invalidate_inode_attr(struct inode *inode)
  62. {
  63. struct v9fs_inode *v9inode;
  64. v9inode = V9FS_I(inode);
  65. v9inode->cache_validity |= V9FS_INO_INVALID_ATTR;
  66. return;
  67. }
  68. int v9fs_open_to_dotl_flags(int flags);
  69. static inline void v9fs_i_size_write(struct inode *inode, loff_t i_size)
  70. {
  71. /*
  72. * 32-bit need the lock, concurrent updates could break the
  73. * sequences and make i_size_read() loop forever.
  74. * 64-bit updates are atomic and can skip the locking.
  75. */
  76. if (sizeof(i_size) > sizeof(long))
  77. spin_lock(&inode->i_lock);
  78. i_size_write(inode, i_size);
  79. if (sizeof(i_size) > sizeof(long))
  80. spin_unlock(&inode->i_lock);
  81. }
  82. #endif