fs/cachefiles/io.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* kiocb-using read/write
   3  *
   4  * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells ([email protected])
   6  */
   7
   8 #include <linux/mount.h>
   9 #include <linux/slab.h>
  10 #include <linux/file.h>
  11 #include <linux/uio.h>
  12 #include <linux/bio.h>
  13 #include <linux/falloc.h>
  14 #include <linux/sched/mm.h>
  15 #include <trace/events/fscache.h>
  16 #include "internal.h"
  17
  18 struct cachefiles_kiocb {
  19         struct kiocb            iocb;
  20         refcount_t              ki_refcnt;
  21         loff_t                  start;
  22         union {
  23                 size_t          skipped;
  24                 size_t          len;
  25         };
  26         struct cachefiles_object *object;
  27         netfs_io_terminated_t   term_func;
  28         void                    *term_func_priv;
  29         bool                    was_async;
  30         unsigned int            inval_counter;  /* Copy of cookie->inval_counter */
  31         u64                     b_writing;
  32 };
  33
  34 static inline void cachefiles_put_kiocb(struct cachefiles_kiocb *ki)
  35 {
  36         if (refcount_dec_and_test(&ki->ki_refcnt)) {
  37                 cachefiles_put_object(ki->object, cachefiles_obj_put_ioreq);
  38                 fput(ki->iocb.ki_filp);
  39                 kfree(ki);
  40         }
  41 }
  42
  43 /*
  44  * Handle completion of a read from the cache.
  45  */
  46 static void cachefiles_read_complete(struct kiocb *iocb, long ret)
  47 {
  48         struct cachefiles_kiocb *ki = container_of(iocb, struct cachefiles_kiocb, iocb);
  49         struct inode *inode = file_inode(ki->iocb.ki_filp);
  50
  51         _enter("%ld", ret);
  52
  53         if (ret < 0)
  54                 trace_cachefiles_io_error(ki->object, inode, ret,
  55                                           cachefiles_trace_read_error);
  56
  57         if (ki->term_func) {
  58                 if (ret >= 0) {
  59                         if (ki->object->cookie->inval_counter == ki->inval_counter)
  60                                 ki->skipped += ret;
  61                         else
  62                                 ret = -ESTALE;
  63                 }
  64
  65                 ki->term_func(ki->term_func_priv, ret, ki->was_async);
  66         }
  67
  68         cachefiles_put_kiocb(ki);
  69 }
  70
  71 /*
  72  * Initiate a read from the cache.
  73  */
  74 static int cachefiles_read(struct netfs_cache_resources *cres,
  75                            loff_t start_pos,
  76                            struct iov_iter *iter,
  77                            enum netfs_read_from_hole read_hole,
  78                            netfs_io_terminated_t term_func,
  79                            void *term_func_priv)
  80 {
  81         struct cachefiles_object *object;
  82         struct cachefiles_kiocb *ki;
  83         struct file *file;
  84         unsigned int old_nofs;
  85         ssize_t ret = -ENOBUFS;
  86         size_t len = iov_iter_count(iter), skipped = 0;
  87
  88         if (!fscache_wait_for_operation(cres, FSCACHE_WANT_READ))
  89                 goto presubmission_error;
  90
  91         fscache_count_read();
  92         object = cachefiles_cres_object(cres);
  93         file = cachefiles_cres_file(cres);
  94
  95         _enter("%pD,%li,%llx,%zx/%llx",
  96                file, file_inode(file)->i_ino, start_pos, len,
  97                i_size_read(file_inode(file)));
  98
  99         /* If the caller asked us to seek for data before doing the read, then
 100          * we should do that now.  If we find a gap, we fill it with zeros.
 101          */
 102         if (read_hole != NETFS_READ_HOLE_IGNORE) {
 103                 loff_t off = start_pos, off2;
 104
 105                 off2 = cachefiles_inject_read_error();
 106                 if (off2 == 0)
 107                         off2 = vfs_llseek(file, off, SEEK_DATA);
 108                 if (off2 < 0 && off2 >= (loff_t)-MAX_ERRNO && off2 != -ENXIO) {
 109                         skipped = 0;
 110                         ret = off2;
 111                         goto presubmission_error;
 112                 }
 113
 114                 if (off2 == -ENXIO || off2 >= start_pos + len) {
 115                         /* The region is beyond the EOF or there's no more data
 116                          * in the region, so clear the rest of the buffer and
 117                          * return success.
 118                          */
 119                         ret = -ENODATA;
 120                         if (read_hole == NETFS_READ_HOLE_FAIL)
 121                                 goto presubmission_error;
 122
 123                         iov_iter_zero(len, iter);
 124                         skipped = len;
 125                         ret = 0;
 126                         goto presubmission_error;
 127                 }
 128
 129                 skipped = off2 - off;
 130                 iov_iter_zero(skipped, iter);
 131         }
 132
 133         ret = -ENOMEM;
 134         ki = kzalloc(sizeof(struct cachefiles_kiocb), GFP_KERNEL);
 135         if (!ki)
 136                 goto presubmission_error;
 137
 138         refcount_set(&ki->ki_refcnt, 2);
 139         ki->iocb.ki_filp        = file;
 140         ki->iocb.ki_pos         = start_pos + skipped;
 141         ki->iocb.ki_flags       = IOCB_DIRECT;
 142         ki->iocb.ki_ioprio      = get_current_ioprio();
 143         ki->skipped             = skipped;
 144         ki->object              = object;
 145         ki->inval_counter       = cres->inval_counter;
 146         ki->term_func           = term_func;
 147         ki->term_func_priv      = term_func_priv;
 148         ki->was_async           = true;
 149
 150         if (ki->term_func)
 151                 ki->iocb.ki_complete = cachefiles_read_complete;
 152
 153         get_file(ki->iocb.ki_filp);
 154         cachefiles_grab_object(object, cachefiles_obj_get_ioreq);
 155
 156         trace_cachefiles_read(object, file_inode(file), ki->iocb.ki_pos, len - skipped);
 157         old_nofs = memalloc_nofs_save();
 158         ret = cachefiles_inject_read_error();
 159         if (ret == 0)
 160                 ret = vfs_iocb_iter_read(file, &ki->iocb, iter);
 161         memalloc_nofs_restore(old_nofs);
 162         switch (ret) {
 163         case -EIOCBQUEUED:
 164                 goto in_progress;
 165
 166         case -ERESTARTSYS:
 167         case -ERESTARTNOINTR:
 168         case -ERESTARTNOHAND:
 169         case -ERESTART_RESTARTBLOCK:
 170                 /* There's no easy way to restart the syscall since other AIO's
 171                  * may be already running. Just fail this IO with EINTR.
 172                  */
 173                 ret = -EINTR;
 174                 fallthrough;
 175         default:
 176                 ki->was_async = false;
 177                 cachefiles_read_complete(&ki->iocb, ret);
 178                 if (ret > 0)
 179                         ret = 0;
 180                 break;
 181         }
 182
 183 in_progress:
 184         cachefiles_put_kiocb(ki);
 185         _leave(" = %zd", ret);
 186         return ret;
 187
 188 presubmission_error:
 189         if (term_func)
 190                 term_func(term_func_priv, ret < 0 ? ret : skipped, false);
 191         return ret;
 192 }
 193
 194 /*
 195  * Query the occupancy of the cache in a region, returning where the next chunk
 196  * of data starts and how long it is.
 197  */
 198 static int cachefiles_query_occupancy(struct netfs_cache_resources *cres,
 199                                       loff_t start, size_t len, size_t granularity,
 200                                       loff_t *_data_start, size_t *_data_len)
 201 {
 202         struct cachefiles_object *object;
 203         struct file *file;
 204         loff_t off, off2;
 205
 206         *_data_start = -1;
 207         *_data_len = 0;
 208
 209         if (!fscache_wait_for_operation(cres, FSCACHE_WANT_READ))
 210                 return -ENOBUFS;
 211
 212         object = cachefiles_cres_object(cres);
 213         file = cachefiles_cres_file(cres);
 214         granularity = max_t(size_t, object->volume->cache->bsize, granularity);
 215
 216         _enter("%pD,%li,%llx,%zx/%llx",
 217                file, file_inode(file)->i_ino, start, len,
 218                i_size_read(file_inode(file)));
 219
 220         off = cachefiles_inject_read_error();
 221         if (off == 0)
 222                 off = vfs_llseek(file, start, SEEK_DATA);
 223         if (off == -ENXIO)
 224                 return -ENODATA; /* Beyond EOF */
 225         if (off < 0 && off >= (loff_t)-MAX_ERRNO)
 226                 return -ENOBUFS; /* Error. */
 227         if (round_up(off, granularity) >= start + len)
 228                 return -ENODATA; /* No data in range */
 229
 230         off2 = cachefiles_inject_read_error();
 231         if (off2 == 0)
 232                 off2 = vfs_llseek(file, off, SEEK_HOLE);
 233         if (off2 == -ENXIO)
 234                 return -ENODATA; /* Beyond EOF */
 235         if (off2 < 0 && off2 >= (loff_t)-MAX_ERRNO)
 236                 return -ENOBUFS; /* Error. */
 237
 238         /* Round away partial blocks */
 239         off = round_up(off, granularity);
 240         off2 = round_down(off2, granularity);
 241         if (off2 <= off)
 242                 return -ENODATA;
 243
 244         *_data_start = off;
 245         if (off2 > start + len)
 246                 *_data_len = len;
 247         else
 248                 *_data_len = off2 - off;
 249         return 0;
 250 }
 251
 252 /*
 253  * Handle completion of a write to the cache.
 254  */
 255 static void cachefiles_write_complete(struct kiocb *iocb, long ret)
 256 {
 257         struct cachefiles_kiocb *ki = container_of(iocb, struct cachefiles_kiocb, iocb);
 258         struct cachefiles_object *object = ki->object;
 259         struct inode *inode = file_inode(ki->iocb.ki_filp);
 260
 261         _enter("%ld", ret);
 262
 263         if (ki->was_async)
 264                 kiocb_end_write(iocb);
 265
 266         if (ret < 0)
 267                 trace_cachefiles_io_error(object, inode, ret,
 268                                           cachefiles_trace_write_error);
 269
 270         atomic_long_sub(ki->b_writing, &object->volume->cache->b_writing);
 271         set_bit(FSCACHE_COOKIE_HAVE_DATA, &object->cookie->flags);
 272         if (ki->term_func)
 273                 ki->term_func(ki->term_func_priv, ret, ki->was_async);
 274         cachefiles_put_kiocb(ki);
 275 }
 276
 277 /*
 278  * Initiate a write to the cache.
 279  */
 280 int __cachefiles_write(struct cachefiles_object *object,
 281                        struct file *file,
 282                        loff_t start_pos,
 283                        struct iov_iter *iter,
 284                        netfs_io_terminated_t term_func,
 285                        void *term_func_priv)
 286 {
 287         struct cachefiles_cache *cache;
 288         struct cachefiles_kiocb *ki;
 289         unsigned int old_nofs;
 290         ssize_t ret;
 291         size_t len = iov_iter_count(iter);
 292
 293         fscache_count_write();
 294         cache = object->volume->cache;
 295
 296         _enter("%pD,%li,%llx,%zx/%llx",
 297                file, file_inode(file)->i_ino, start_pos, len,
 298                i_size_read(file_inode(file)));
 299
 300         ki = kzalloc(sizeof(struct cachefiles_kiocb), GFP_KERNEL);
 301         if (!ki) {
 302                 if (term_func)
 303                         term_func(term_func_priv, -ENOMEM, false);
 304                 return -ENOMEM;
 305         }
 306
 307         refcount_set(&ki->ki_refcnt, 2);
 308         ki->iocb.ki_filp        = file;
 309         ki->iocb.ki_pos         = start_pos;
 310         ki->iocb.ki_flags       = IOCB_DIRECT | IOCB_WRITE;
 311         ki->iocb.ki_ioprio      = get_current_ioprio();
 312         ki->object              = object;
 313         ki->start               = start_pos;
 314         ki->len                 = len;
 315         ki->term_func           = term_func;
 316         ki->term_func_priv      = term_func_priv;
 317         ki->was_async           = true;
 318         ki->b_writing           = (len + (1 << cache->bshift) - 1) >> cache->bshift;
 319
 320         if (ki->term_func)
 321                 ki->iocb.ki_complete = cachefiles_write_complete;
 322         atomic_long_add(ki->b_writing, &cache->b_writing);
 323
 324         get_file(ki->iocb.ki_filp);
 325         cachefiles_grab_object(object, cachefiles_obj_get_ioreq);
 326
 327         trace_cachefiles_write(object, file_inode(file), ki->iocb.ki_pos, len);
 328         old_nofs = memalloc_nofs_save();
 329         ret = cachefiles_inject_write_error();
 330         if (ret == 0)
 331                 ret = vfs_iocb_iter_write(file, &ki->iocb, iter);
 332         memalloc_nofs_restore(old_nofs);
 333         switch (ret) {
 334         case -EIOCBQUEUED:
 335                 goto in_progress;
 336
 337         case -ERESTARTSYS:
 338         case -ERESTARTNOINTR:
 339         case -ERESTARTNOHAND:
 340         case -ERESTART_RESTARTBLOCK:
 341                 /* There's no easy way to restart the syscall since other AIO's
 342                  * may be already running. Just fail this IO with EINTR.
 343                  */
 344                 ret = -EINTR;
 345                 fallthrough;
 346         default:
 347                 ki->was_async = false;
 348                 cachefiles_write_complete(&ki->iocb, ret);
 349                 if (ret > 0)
 350                         ret = 0;
 351                 break;
 352         }
 353
 354 in_progress:
 355         cachefiles_put_kiocb(ki);
 356         _leave(" = %zd", ret);
 357         return ret;
 358 }
 359
 360 static int cachefiles_write(struct netfs_cache_resources *cres,
 361                             loff_t start_pos,
 362                             struct iov_iter *iter,
 363                             netfs_io_terminated_t term_func,
 364                             void *term_func_priv)
 365 {
 366         if (!fscache_wait_for_operation(cres, FSCACHE_WANT_WRITE)) {
 367                 if (term_func)
 368                         term_func(term_func_priv, -ENOBUFS, false);
 369                 return -ENOBUFS;
 370         }
 371
 372         return __cachefiles_write(cachefiles_cres_object(cres),
 373                                   cachefiles_cres_file(cres),
 374                                   start_pos, iter,
 375                                   term_func, term_func_priv);
 376 }
 377
 378 static inline enum netfs_io_source
 379 cachefiles_do_prepare_read(struct netfs_cache_resources *cres,
 380                            loff_t start, size_t *_len, loff_t i_size,
 381                            unsigned long *_flags, ino_t netfs_ino)
 382 {
 383         enum cachefiles_prepare_read_trace why;
 384         struct cachefiles_object *object = NULL;
 385         struct cachefiles_cache *cache;
 386         struct fscache_cookie *cookie = fscache_cres_cookie(cres);
 387         const struct cred *saved_cred;
 388         struct file *file = cachefiles_cres_file(cres);
 389         enum netfs_io_source ret = NETFS_DOWNLOAD_FROM_SERVER;
 390         size_t len = *_len;
 391         loff_t off, to;
 392         ino_t ino = file ? file_inode(file)->i_ino : 0;
 393         int rc;
 394
 395         _enter("%zx @%llx/%llx", len, start, i_size);
 396
 397         if (start >= i_size) {
 398                 ret = NETFS_FILL_WITH_ZEROES;
 399                 why = cachefiles_trace_read_after_eof;
 400                 goto out_no_object;
 401         }
 402
 403         if (test_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags)) {
 404                 __set_bit(NETFS_SREQ_COPY_TO_CACHE, _flags);
 405                 why = cachefiles_trace_read_no_data;
 406                 if (!test_bit(NETFS_SREQ_ONDEMAND, _flags))
 407                         goto out_no_object;
 408         }
 409
 410         /* The object and the file may be being created in the background. */
 411         if (!file) {
 412                 why = cachefiles_trace_read_no_file;
 413                 if (!fscache_wait_for_operation(cres, FSCACHE_WANT_READ))
 414                         goto out_no_object;
 415                 file = cachefiles_cres_file(cres);
 416                 if (!file)
 417                         goto out_no_object;
 418                 ino = file_inode(file)->i_ino;
 419         }
 420
 421         object = cachefiles_cres_object(cres);
 422         cache = object->volume->cache;
 423         cachefiles_begin_secure(cache, &saved_cred);
 424 retry:
 425         off = cachefiles_inject_read_error();
 426         if (off == 0)
 427                 off = vfs_llseek(file, start, SEEK_DATA);
 428         if (off < 0 && off >= (loff_t)-MAX_ERRNO) {
 429                 if (off == (loff_t)-ENXIO) {
 430                         why = cachefiles_trace_read_seek_nxio;
 431                         goto download_and_store;
 432                 }
 433                 trace_cachefiles_io_error(object, file_inode(file), off,
 434                                           cachefiles_trace_seek_error);
 435                 why = cachefiles_trace_read_seek_error;
 436                 goto out;
 437         }
 438
 439         if (off >= start + len) {
 440                 why = cachefiles_trace_read_found_hole;
 441                 goto download_and_store;
 442         }
 443
 444         if (off > start) {
 445                 off = round_up(off, cache->bsize);
 446                 len = off - start;
 447                 *_len = len;
 448                 why = cachefiles_trace_read_found_part;
 449                 goto download_and_store;
 450         }
 451
 452         to = cachefiles_inject_read_error();
 453         if (to == 0)
 454                 to = vfs_llseek(file, start, SEEK_HOLE);
 455         if (to < 0 && to >= (loff_t)-MAX_ERRNO) {
 456                 trace_cachefiles_io_error(object, file_inode(file), to,
 457                                           cachefiles_trace_seek_error);
 458                 why = cachefiles_trace_read_seek_error;
 459                 goto out;
 460         }
 461
 462         if (to < start + len) {
 463                 if (start + len >= i_size)
 464                         to = round_up(to, cache->bsize);
 465                 else
 466                         to = round_down(to, cache->bsize);
 467                 len = to - start;
 468                 *_len = len;
 469         }
 470
 471         why = cachefiles_trace_read_have_data;
 472         ret = NETFS_READ_FROM_CACHE;
 473         goto out;
 474
 475 download_and_store:
 476         __set_bit(NETFS_SREQ_COPY_TO_CACHE, _flags);
 477         if (test_bit(NETFS_SREQ_ONDEMAND, _flags)) {
 478                 rc = cachefiles_ondemand_read(object, start, len);
 479                 if (!rc) {
 480                         __clear_bit(NETFS_SREQ_ONDEMAND, _flags);
 481                         goto retry;
 482                 }
 483                 ret = NETFS_INVALID_READ;
 484         }
 485 out:
 486         cachefiles_end_secure(cache, saved_cred);
 487 out_no_object:
 488         trace_cachefiles_prep_read(object, start, len, *_flags, ret, why, ino, netfs_ino);
 489         return ret;
 490 }
 491
 492 /*
 493  * Prepare a read operation, shortening it to a cached/uncached
 494  * boundary as appropriate.
 495  */
 496 static enum netfs_io_source cachefiles_prepare_read(struct netfs_io_subrequest *subreq,
 497                                                     unsigned long long i_size)
 498 {
 499         return cachefiles_do_prepare_read(&subreq->rreq->cache_resources,
 500                                           subreq->start, &subreq->len, i_size,
 501                                           &subreq->flags, subreq->rreq->inode->i_ino);
 502 }
 503
 504 /*
 505  * Prepare an on-demand read operation, shortening it to a cached/uncached
 506  * boundary as appropriate.
 507  */
 508 static enum netfs_io_source
 509 cachefiles_prepare_ondemand_read(struct netfs_cache_resources *cres,
 510                                  loff_t start, size_t *_len, loff_t i_size,
 511                                  unsigned long *_flags, ino_t ino)
 512 {
 513         return cachefiles_do_prepare_read(cres, start, _len, i_size, _flags, ino);
 514 }
 515
 516 /*
 517  * Prepare for a write to occur.
 518  */
 519 int __cachefiles_prepare_write(struct cachefiles_object *object,
 520                                struct file *file,
 521                                loff_t *_start, size_t *_len, size_t upper_len,
 522                                bool no_space_allocated_yet)
 523 {
 524         struct cachefiles_cache *cache = object->volume->cache;
 525         loff_t start = *_start, pos;
 526         size_t len = *_len;
 527         int ret;
 528
 529         /* Round to DIO size */
 530         start = round_down(*_start, PAGE_SIZE);
 531         if (start != *_start || *_len > upper_len) {
 532                 /* Probably asked to cache a streaming write written into the
 533                  * pagecache when the cookie was temporarily out of service to
 534                  * culling.
 535                  */
 536                 fscache_count_dio_misfit();
 537                 return -ENOBUFS;
 538         }
 539
 540         *_len = round_up(len, PAGE_SIZE);
 541
 542         /* We need to work out whether there's sufficient disk space to perform
 543          * the write - but we can skip that check if we have space already
 544          * allocated.
 545          */
 546         if (no_space_allocated_yet)
 547                 goto check_space;
 548
 549         pos = cachefiles_inject_read_error();
 550         if (pos == 0)
 551                 pos = vfs_llseek(file, start, SEEK_DATA);
 552         if (pos < 0 && pos >= (loff_t)-MAX_ERRNO) {
 553                 if (pos == -ENXIO)
 554                         goto check_space; /* Unallocated tail */
 555                 trace_cachefiles_io_error(object, file_inode(file), pos,
 556                                           cachefiles_trace_seek_error);
 557                 return pos;
 558         }
 559         if ((u64)pos >= (u64)start + *_len)
 560                 goto check_space; /* Unallocated region */
 561
 562         /* We have a block that's at least partially filled - if we're low on
 563          * space, we need to see if it's fully allocated.  If it's not, we may
 564          * want to cull it.
 565          */
 566         if (cachefiles_has_space(cache, 0, *_len / PAGE_SIZE,
 567                                  cachefiles_has_space_check) == 0)
 568                 return 0; /* Enough space to simply overwrite the whole block */
 569
 570         pos = cachefiles_inject_read_error();
 571         if (pos == 0)
 572                 pos = vfs_llseek(file, start, SEEK_HOLE);
 573         if (pos < 0 && pos >= (loff_t)-MAX_ERRNO) {
 574                 trace_cachefiles_io_error(object, file_inode(file), pos,
 575                                           cachefiles_trace_seek_error);
 576                 return pos;
 577         }
 578         if ((u64)pos >= (u64)start + *_len)
 579                 return 0; /* Fully allocated */
 580
 581         /* Partially allocated, but insufficient space: cull. */
 582         fscache_count_no_write_space();
 583         ret = cachefiles_inject_remove_error();
 584         if (ret == 0)
 585                 ret = vfs_fallocate(file, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
 586                                     start, *_len);
 587         if (ret < 0) {
 588                 trace_cachefiles_io_error(object, file_inode(file), ret,
 589                                           cachefiles_trace_fallocate_error);
 590                 cachefiles_io_error_obj(object,
 591                                         "CacheFiles: fallocate failed (%d)\n", ret);
 592                 ret = -EIO;
 593         }
 594
 595         return ret;
 596
 597 check_space:
 598         return cachefiles_has_space(cache, 0, *_len / PAGE_SIZE,
 599                                     cachefiles_has_space_for_write);
 600 }
 601
 602 static int cachefiles_prepare_write(struct netfs_cache_resources *cres,
 603                                     loff_t *_start, size_t *_len, size_t upper_len,
 604                                     loff_t i_size, bool no_space_allocated_yet)
 605 {
 606         struct cachefiles_object *object = cachefiles_cres_object(cres);
 607         struct cachefiles_cache *cache = object->volume->cache;
 608         const struct cred *saved_cred;
 609         int ret;
 610
 611         if (!cachefiles_cres_file(cres)) {
 612                 if (!fscache_wait_for_operation(cres, FSCACHE_WANT_WRITE))
 613                         return -ENOBUFS;
 614                 if (!cachefiles_cres_file(cres))
 615                         return -ENOBUFS;
 616         }
 617
 618         cachefiles_begin_secure(cache, &saved_cred);
 619         ret = __cachefiles_prepare_write(object, cachefiles_cres_file(cres),
 620                                          _start, _len, upper_len,
 621                                          no_space_allocated_yet);
 622         cachefiles_end_secure(cache, saved_cred);
 623         return ret;
 624 }
 625
 626 static void cachefiles_prepare_write_subreq(struct netfs_io_subrequest *subreq)
 627 {
 628         struct netfs_io_request *wreq = subreq->rreq;
 629         struct netfs_cache_resources *cres = &wreq->cache_resources;
 630
 631         _enter("W=%x[%x] %llx", wreq->debug_id, subreq->debug_index, subreq->start);
 632
 633         subreq->max_len = ULONG_MAX;
 634         subreq->max_nr_segs = BIO_MAX_VECS;
 635
 636         if (!cachefiles_cres_file(cres)) {
 637                 if (!fscache_wait_for_operation(cres, FSCACHE_WANT_WRITE))
 638                         return netfs_prepare_write_failed(subreq);
 639                 if (!cachefiles_cres_file(cres))
 640                         return netfs_prepare_write_failed(subreq);
 641         }
 642 }
 643
 644 static void cachefiles_issue_write(struct netfs_io_subrequest *subreq)
 645 {
 646         struct netfs_io_request *wreq = subreq->rreq;
 647         struct netfs_cache_resources *cres = &wreq->cache_resources;
 648         struct cachefiles_object *object = cachefiles_cres_object(cres);
 649         struct cachefiles_cache *cache = object->volume->cache;
 650         const struct cred *saved_cred;
 651         size_t off, pre, post, len = subreq->len;
 652         loff_t start = subreq->start;
 653         int ret;
 654
 655         _enter("W=%x[%x] %llx-%llx",
 656                wreq->debug_id, subreq->debug_index, start, start + len - 1);
 657
 658         /* We need to start on the cache granularity boundary */
 659         off = start & (CACHEFILES_DIO_BLOCK_SIZE - 1);
 660         if (off) {
 661                 pre = CACHEFILES_DIO_BLOCK_SIZE - off;
 662                 if (pre >= len) {
 663                         netfs_write_subrequest_terminated(subreq, len, false);
 664                         return;
 665                 }
 666                 subreq->transferred += pre;
 667                 start += pre;
 668                 len -= pre;
 669                 iov_iter_advance(&subreq->io_iter, pre);
 670         }
 671
 672         /* We also need to end on the cache granularity boundary */
 673         post = len & (CACHEFILES_DIO_BLOCK_SIZE - 1);
 674         if (post) {
 675                 len -= post;
 676                 if (len == 0) {
 677                         netfs_write_subrequest_terminated(subreq, post, false);
 678                         return;
 679                 }
 680                 iov_iter_truncate(&subreq->io_iter, len);
 681         }
 682
 683         cachefiles_begin_secure(cache, &saved_cred);
 684         ret = __cachefiles_prepare_write(object, cachefiles_cres_file(cres),
 685                                          &start, &len, len, true);
 686         cachefiles_end_secure(cache, saved_cred);
 687         if (ret < 0) {
 688                 netfs_write_subrequest_terminated(subreq, ret, false);
 689                 return;
 690         }
 691
 692         cachefiles_write(&subreq->rreq->cache_resources,
 693                          subreq->start, &subreq->io_iter,
 694                          netfs_write_subrequest_terminated, subreq);
 695 }
 696
 697 /*
 698  * Clean up an operation.
 699  */
 700 static void cachefiles_end_operation(struct netfs_cache_resources *cres)
 701 {
 702         struct file *file = cachefiles_cres_file(cres);
 703
 704         if (file)
 705                 fput(file);
 706         fscache_end_cookie_access(fscache_cres_cookie(cres), fscache_access_io_end);
 707 }
 708
 709 static const struct netfs_cache_ops cachefiles_netfs_cache_ops = {
 710         .end_operation          = cachefiles_end_operation,
 711         .read                   = cachefiles_read,
 712         .write                  = cachefiles_write,
 713         .issue_write            = cachefiles_issue_write,
 714         .prepare_read           = cachefiles_prepare_read,
 715         .prepare_write          = cachefiles_prepare_write,
 716         .prepare_write_subreq   = cachefiles_prepare_write_subreq,
 717         .prepare_ondemand_read  = cachefiles_prepare_ondemand_read,
 718         .query_occupancy        = cachefiles_query_occupancy,
 719 };
 720
 721 /*
 722  * Open the cache file when beginning a cache operation.
 723  */
 724 bool cachefiles_begin_operation(struct netfs_cache_resources *cres,
 725                                 enum fscache_want_state want_state)
 726 {
 727         struct cachefiles_object *object = cachefiles_cres_object(cres);
 728
 729         if (!cachefiles_cres_file(cres)) {
 730                 cres->ops = &cachefiles_netfs_cache_ops;
 731                 if (object->file) {
 732                         spin_lock(&object->lock);
 733                         if (!cres->cache_priv2 && object->file)
 734                                 cres->cache_priv2 = get_file(object->file);
 735                         spin_unlock(&object->lock);
 736                 }
 737         }
 738
 739         if (!cachefiles_cres_file(cres) && want_state != FSCACHE_WANT_PARAMS) {
 740                 pr_err("failed to get cres->file\n");
 741                 return false;
 742         }
 743
 744         return true;
 745 }