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