fs/fuse/iomode.c

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