1 /* 2 * V9FS VFS extensions. 3 * 4 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com> 5 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 9 * as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to: 18 * Free Software Foundation 19 * 51 Franklin Street, Fifth Floor 20 * Boston, MA 02111-1301 USA 21 * 22 */ 23 #ifndef FS_9P_V9FS_VFS_H 24 #define FS_9P_V9FS_VFS_H 25 26 /* plan9 semantics are that created files are implicitly opened. 27 * But linux semantics are that you call create, then open. 28 * the plan9 approach is superior as it provides an atomic 29 * open. 30 * we track the create fid here. When the file is opened, if fidopen is 31 * non-zero, we use the fid and can skip some steps. 32 * there may be a better way to do this, but I don't know it. 33 * one BAD way is to clunk the fid on create, then open it again: 34 * you lose the atomicity of file open 35 */ 36 37 /* special case: 38 * unlink calls remove, which is an implicit clunk. So we have to track 39 * that kind of thing so that we don't try to clunk a dead fid. 40 */ 41 #define P9_LOCK_TIMEOUT (30*HZ) 42 43 /* flags for v9fs_stat2inode() & v9fs_stat2inode_dotl() */ 44 #define V9FS_STAT2INODE_KEEP_ISIZE 1 45 46 extern struct file_system_type v9fs_fs_type; 47 extern const struct address_space_operations v9fs_addr_operations; 48 extern const struct file_operations v9fs_file_operations; 49 extern const struct file_operations v9fs_file_operations_dotl; 50 extern const struct file_operations v9fs_dir_operations; 51 extern const struct file_operations v9fs_dir_operations_dotl; 52 extern const struct dentry_operations v9fs_dentry_operations; 53 extern const struct dentry_operations v9fs_cached_dentry_operations; 54 extern const struct file_operations v9fs_cached_file_operations; 55 extern const struct file_operations v9fs_cached_file_operations_dotl; 56 extern const struct file_operations v9fs_mmap_file_operations; 57 extern const struct file_operations v9fs_mmap_file_operations_dotl; 58 extern struct kmem_cache *v9fs_inode_cache; 59 60 struct inode *v9fs_alloc_inode(struct super_block *sb); 61 void v9fs_destroy_inode(struct inode *inode); 62 struct inode *v9fs_get_inode(struct super_block *sb, umode_t mode, dev_t); 63 int v9fs_init_inode(struct v9fs_session_info *v9ses, 64 struct inode *inode, umode_t mode, dev_t); 65 void v9fs_evict_inode(struct inode *inode); 66 ino_t v9fs_qid2ino(struct p9_qid *qid); 67 void v9fs_stat2inode(struct p9_wstat *stat, struct inode *inode, 68 struct super_block *sb, unsigned int flags); 69 void v9fs_stat2inode_dotl(struct p9_stat_dotl *stat, struct inode *inode, 70 unsigned int flags); 71 int v9fs_dir_release(struct inode *inode, struct file *filp); 72 int v9fs_file_open(struct inode *inode, struct file *file); 73 void v9fs_inode2stat(struct inode *inode, struct p9_wstat *stat); 74 int v9fs_uflags2omode(int uflags, int extended); 75 76 void v9fs_blank_wstat(struct p9_wstat *wstat); 77 int v9fs_vfs_setattr_dotl(struct dentry *, struct iattr *); 78 int v9fs_file_fsync_dotl(struct file *filp, loff_t start, loff_t end, 79 int datasync); 80 int v9fs_refresh_inode(struct p9_fid *fid, struct inode *inode); 81 int v9fs_refresh_inode_dotl(struct p9_fid *fid, struct inode *inode); 82 static inline void v9fs_invalidate_inode_attr(struct inode *inode) 83 { 84 struct v9fs_inode *v9inode; 85 v9inode = V9FS_I(inode); 86 v9inode->cache_validity |= V9FS_INO_INVALID_ATTR; 87 return; 88 } 89 90 int v9fs_open_to_dotl_flags(int flags); 91 92 static inline void v9fs_i_size_write(struct inode *inode, loff_t i_size) 93 { 94 /* 95 * 32-bit need the lock, concurrent updates could break the 96 * sequences and make i_size_read() loop forever. 97 * 64-bit updates are atomic and can skip the locking. 98 */ 99 if (sizeof(i_size) > sizeof(long)) 100 spin_lock(&inode->i_lock); 101 i_size_write(inode, i_size); 102 if (sizeof(i_size) > sizeof(long)) 103 spin_unlock(&inode->i_lock); 104 } 105 #endif 106