1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * FUSE inode io modes. 4 * 5 * Copyright (c) 2024 CTERA Networks. 6 */ 7 8 #include "fuse_i.h" 9 10 #include <linux/kernel.h> 11 #include <linux/sched.h> 12 #include <linux/file.h> 13 #include <linux/fs.h> 14 15 /* 16 * Return true if need to wait for new opens in caching mode. 17 */ 18 static inline bool fuse_is_io_cache_wait(struct fuse_inode *fi) 19 { 20 return READ_ONCE(fi->iocachectr) < 0 && !fuse_inode_backing(fi); 21 } 22 23 /* 24 * Start cached io mode. 25 * 26 * Blocks new parallel dio writes and waits for the in-progress parallel dio 27 * writes to complete. 28 */ 29 int fuse_file_cached_io_start(struct inode *inode, struct fuse_file *ff) 30 { 31 struct fuse_inode *fi = get_fuse_inode(inode); 32 33 /* There are no io modes if server does not implement open */ 34 if (!ff->args) 35 return 0; 36 37 spin_lock(&fi->lock); 38 /* 39 * Setting the bit advises new direct-io writes to use an exclusive 40 * lock - without it the wait below might be forever. 41 */ 42 while (fuse_is_io_cache_wait(fi)) { 43 set_bit(FUSE_I_CACHE_IO_MODE, &fi->state); 44 spin_unlock(&fi->lock); 45 wait_event(fi->direct_io_waitq, !fuse_is_io_cache_wait(fi)); 46 spin_lock(&fi->lock); 47 } 48 49 /* 50 * Check if inode entered passthrough io mode while waiting for parallel 51 * dio write completion. 52 */ 53 if (fuse_inode_backing(fi)) { 54 clear_bit(FUSE_I_CACHE_IO_MODE, &fi->state); 55 spin_unlock(&fi->lock); 56 return -ETXTBSY; 57 } 58 59 WARN_ON(ff->iomode == IOM_UNCACHED); 60 if (ff->iomode == IOM_NONE) { 61 ff->iomode = IOM_CACHED; 62 if (fi->iocachectr == 0) 63 set_bit(FUSE_I_CACHE_IO_MODE, &fi->state); 64 fi->iocachectr++; 65 } 66 spin_unlock(&fi->lock); 67 return 0; 68 } 69 70 static void fuse_file_cached_io_end(struct inode *inode, struct fuse_file *ff) 71 { 72 struct fuse_inode *fi = get_fuse_inode(inode); 73 74 spin_lock(&fi->lock); 75 WARN_ON(fi->iocachectr <= 0); 76 WARN_ON(ff->iomode != IOM_CACHED); 77 ff->iomode = IOM_NONE; 78 fi->iocachectr--; 79 if (fi->iocachectr == 0) 80 clear_bit(FUSE_I_CACHE_IO_MODE, &fi->state); 81 spin_unlock(&fi->lock); 82 } 83 84 /* Start strictly uncached io mode where cache access is not allowed */ 85 int fuse_file_uncached_io_start(struct inode *inode, struct fuse_file *ff, struct fuse_backing *fb) 86 { 87 struct fuse_inode *fi = get_fuse_inode(inode); 88 struct fuse_backing *oldfb; 89 int err = 0; 90 91 spin_lock(&fi->lock); 92 /* deny conflicting backing files on same fuse inode */ 93 oldfb = fuse_inode_backing(fi); 94 if (oldfb && oldfb != fb) { 95 err = -EBUSY; 96 goto unlock; 97 } 98 if (fi->iocachectr > 0) { 99 err = -ETXTBSY; 100 goto unlock; 101 } 102 WARN_ON(ff->iomode != IOM_NONE); 103 fi->iocachectr--; 104 ff->iomode = IOM_UNCACHED; 105 106 /* fuse inode holds a single refcount of backing file */ 107 if (!oldfb) { 108 oldfb = fuse_inode_backing_set(fi, fb); 109 WARN_ON_ONCE(oldfb != NULL); 110 } else { 111 fuse_backing_put(fb); 112 } 113 unlock: 114 spin_unlock(&fi->lock); 115 return err; 116 } 117 118 void fuse_file_uncached_io_end(struct inode *inode, struct fuse_file *ff) 119 { 120 struct fuse_inode *fi = get_fuse_inode(inode); 121 struct fuse_backing *oldfb = NULL; 122 123 spin_lock(&fi->lock); 124 WARN_ON(fi->iocachectr >= 0); 125 WARN_ON(ff->iomode != IOM_UNCACHED); 126 ff->iomode = IOM_NONE; 127 fi->iocachectr++; 128 if (!fi->iocachectr) { 129 wake_up(&fi->direct_io_waitq); 130 oldfb = fuse_inode_backing_set(fi, NULL); 131 } 132 spin_unlock(&fi->lock); 133 if (oldfb) 134 fuse_backing_put(oldfb); 135 } 136 137 /* 138 * Open flags that are allowed in combination with FOPEN_PASSTHROUGH. 139 * A combination of FOPEN_PASSTHROUGH and FOPEN_DIRECT_IO means that read/write 140 * operations go directly to the server, but mmap is done on the backing file. 141 * FOPEN_PASSTHROUGH mode should not co-exist with any users of the fuse inode 142 * page cache, so FOPEN_KEEP_CACHE is a strange and undesired combination. 143 */ 144 #define FOPEN_PASSTHROUGH_MASK \ 145 (FOPEN_PASSTHROUGH | FOPEN_DIRECT_IO | FOPEN_PARALLEL_DIRECT_WRITES | \ 146 FOPEN_NOFLUSH) 147 148 static int fuse_file_passthrough_open(struct inode *inode, struct file *file) 149 { 150 struct fuse_file *ff = file->private_data; 151 struct fuse_conn *fc = get_fuse_conn(inode); 152 struct fuse_backing *fb; 153 int err; 154 155 /* Check allowed conditions for file open in passthrough mode */ 156 if (!IS_ENABLED(CONFIG_FUSE_PASSTHROUGH) || !fc->passthrough || 157 (ff->open_flags & ~FOPEN_PASSTHROUGH_MASK)) 158 return -EINVAL; 159 160 fb = fuse_passthrough_open(file, inode, 161 ff->args->open_outarg.backing_id); 162 if (IS_ERR(fb)) 163 return PTR_ERR(fb); 164 165 /* First passthrough file open denies caching inode io mode */ 166 err = fuse_file_uncached_io_start(inode, ff, fb); 167 if (!err) 168 return 0; 169 170 fuse_passthrough_release(ff, fb); 171 fuse_backing_put(fb); 172 173 return err; 174 } 175 176 /* Request access to submit new io to inode via open file */ 177 int fuse_file_io_open(struct file *file, struct inode *inode) 178 { 179 struct fuse_file *ff = file->private_data; 180 struct fuse_inode *fi = get_fuse_inode(inode); 181 int err; 182 183 /* 184 * io modes are not relevant with DAX and with server that does not 185 * implement open. 186 */ 187 if (FUSE_IS_DAX(inode) || !ff->args) 188 return 0; 189 190 /* 191 * Server is expected to use FOPEN_PASSTHROUGH for all opens of an inode 192 * which is already open for passthrough. 193 */ 194 err = -EINVAL; 195 if (fuse_inode_backing(fi) && !(ff->open_flags & FOPEN_PASSTHROUGH)) 196 goto fail; 197 198 /* 199 * FOPEN_PARALLEL_DIRECT_WRITES requires FOPEN_DIRECT_IO. 200 */ 201 if (!(ff->open_flags & FOPEN_DIRECT_IO)) 202 ff->open_flags &= ~FOPEN_PARALLEL_DIRECT_WRITES; 203 204 /* 205 * First passthrough file open denies caching inode io mode. 206 * First caching file open enters caching inode io mode. 207 * 208 * Note that if user opens a file open with O_DIRECT, but server did 209 * not specify FOPEN_DIRECT_IO, a later fcntl() could remove O_DIRECT, 210 * so we put the inode in caching mode to prevent parallel dio. 211 */ 212 if ((ff->open_flags & FOPEN_DIRECT_IO) && 213 !(ff->open_flags & FOPEN_PASSTHROUGH)) 214 return 0; 215 216 if (ff->open_flags & FOPEN_PASSTHROUGH) 217 err = fuse_file_passthrough_open(inode, file); 218 else 219 err = fuse_file_cached_io_start(inode, ff); 220 if (err) 221 goto fail; 222 223 return 0; 224 225 fail: 226 pr_debug("failed to open file in requested io mode (open_flags=0x%x, err=%i).\n", 227 ff->open_flags, err); 228 /* 229 * The file open mode determines the inode io mode. 230 * Using incorrect open mode is a server mistake, which results in 231 * user visible failure of open() with EIO error. 232 */ 233 return -EIO; 234 } 235 236 /* No more pending io and no new io possible to inode via open/mmapped file */ 237 void fuse_file_io_release(struct fuse_file *ff, struct inode *inode) 238 { 239 /* 240 * Last parallel dio close allows caching inode io mode. 241 * Last caching file close exits caching inode io mode. 242 */ 243 switch (ff->iomode) { 244 case IOM_NONE: 245 /* Nothing to do */ 246 break; 247 case IOM_UNCACHED: 248 fuse_file_uncached_io_end(inode, ff); 249 break; 250 case IOM_CACHED: 251 fuse_file_cached_io_end(inode, ff); 252 break; 253 } 254 } 255