Commit | Line | Data |
---|---|---|
287fd611 DH |
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/falloc.h> | |
13 | #include <linux/sched/mm.h> | |
14 | #include <trace/events/fscache.h> | |
15 | #include "internal.h" | |
16 | ||
047487c9 DH |
17 | struct cachefiles_kiocb { |
18 | struct kiocb iocb; | |
19 | refcount_t ki_refcnt; | |
20 | loff_t start; | |
21 | union { | |
22 | size_t skipped; | |
23 | size_t len; | |
24 | }; | |
25 | struct cachefiles_object *object; | |
26 | netfs_io_terminated_t term_func; | |
27 | void *term_func_priv; | |
28 | bool was_async; | |
29 | unsigned int inval_counter; /* Copy of cookie->inval_counter */ | |
30 | u64 b_writing; | |
31 | }; | |
32 | ||
33 | static inline void cachefiles_put_kiocb(struct cachefiles_kiocb *ki) | |
34 | { | |
35 | if (refcount_dec_and_test(&ki->ki_refcnt)) { | |
36 | cachefiles_put_object(ki->object, cachefiles_obj_put_ioreq); | |
37 | fput(ki->iocb.ki_filp); | |
38 | kfree(ki); | |
39 | } | |
40 | } | |
41 | ||
42 | /* | |
43 | * Handle completion of a read from the cache. | |
44 | */ | |
45 | static void cachefiles_read_complete(struct kiocb *iocb, long ret) | |
46 | { | |
47 | struct cachefiles_kiocb *ki = container_of(iocb, struct cachefiles_kiocb, iocb); | |
48 | struct inode *inode = file_inode(ki->iocb.ki_filp); | |
49 | ||
50 | _enter("%ld", ret); | |
51 | ||
52 | if (ret < 0) | |
53 | trace_cachefiles_io_error(ki->object, inode, ret, | |
54 | cachefiles_trace_read_error); | |
55 | ||
56 | if (ki->term_func) { | |
57 | if (ret >= 0) { | |
58 | if (ki->object->cookie->inval_counter == ki->inval_counter) | |
59 | ki->skipped += ret; | |
60 | else | |
61 | ret = -ESTALE; | |
62 | } | |
63 | ||
64 | ki->term_func(ki->term_func_priv, ret, ki->was_async); | |
65 | } | |
66 | ||
67 | cachefiles_put_kiocb(ki); | |
68 | } | |
69 | ||
70 | /* | |
71 | * Initiate a read from the cache. | |
72 | */ | |
73 | static int cachefiles_read(struct netfs_cache_resources *cres, | |
74 | loff_t start_pos, | |
75 | struct iov_iter *iter, | |
76 | enum netfs_read_from_hole read_hole, | |
77 | netfs_io_terminated_t term_func, | |
78 | void *term_func_priv) | |
79 | { | |
80 | struct cachefiles_object *object; | |
81 | struct cachefiles_kiocb *ki; | |
82 | struct file *file; | |
83 | unsigned int old_nofs; | |
84 | ssize_t ret = -ENOBUFS; | |
85 | size_t len = iov_iter_count(iter), skipped = 0; | |
86 | ||
87 | if (!fscache_wait_for_operation(cres, FSCACHE_WANT_READ)) | |
88 | goto presubmission_error; | |
89 | ||
90 | fscache_count_read(); | |
91 | object = cachefiles_cres_object(cres); | |
92 | file = cachefiles_cres_file(cres); | |
93 | ||
94 | _enter("%pD,%li,%llx,%zx/%llx", | |
95 | file, file_inode(file)->i_ino, start_pos, len, | |
96 | i_size_read(file_inode(file))); | |
97 | ||
98 | /* If the caller asked us to seek for data before doing the read, then | |
99 | * we should do that now. If we find a gap, we fill it with zeros. | |
100 | */ | |
101 | if (read_hole != NETFS_READ_HOLE_IGNORE) { | |
102 | loff_t off = start_pos, off2; | |
103 | ||
104 | off2 = cachefiles_inject_read_error(); | |
105 | if (off2 == 0) | |
106 | off2 = vfs_llseek(file, off, SEEK_DATA); | |
107 | if (off2 < 0 && off2 >= (loff_t)-MAX_ERRNO && off2 != -ENXIO) { | |
108 | skipped = 0; | |
109 | ret = off2; | |
110 | goto presubmission_error; | |
111 | } | |
112 | ||
113 | if (off2 == -ENXIO || off2 >= start_pos + len) { | |
114 | /* The region is beyond the EOF or there's no more data | |
115 | * in the region, so clear the rest of the buffer and | |
116 | * return success. | |
117 | */ | |
118 | ret = -ENODATA; | |
119 | if (read_hole == NETFS_READ_HOLE_FAIL) | |
120 | goto presubmission_error; | |
121 | ||
122 | iov_iter_zero(len, iter); | |
123 | skipped = len; | |
124 | ret = 0; | |
125 | goto presubmission_error; | |
126 | } | |
127 | ||
128 | skipped = off2 - off; | |
129 | iov_iter_zero(skipped, iter); | |
130 | } | |
131 | ||
132 | ret = -ENOMEM; | |
133 | ki = kzalloc(sizeof(struct cachefiles_kiocb), GFP_KERNEL); | |
134 | if (!ki) | |
135 | goto presubmission_error; | |
136 | ||
137 | refcount_set(&ki->ki_refcnt, 2); | |
138 | ki->iocb.ki_filp = file; | |
139 | ki->iocb.ki_pos = start_pos + skipped; | |
140 | ki->iocb.ki_flags = IOCB_DIRECT; | |
047487c9 DH |
141 | ki->iocb.ki_ioprio = get_current_ioprio(); |
142 | ki->skipped = skipped; | |
143 | ki->object = object; | |
144 | ki->inval_counter = cres->inval_counter; | |
145 | ki->term_func = term_func; | |
146 | ki->term_func_priv = term_func_priv; | |
147 | ki->was_async = true; | |
148 | ||
149 | if (ki->term_func) | |
150 | ki->iocb.ki_complete = cachefiles_read_complete; | |
151 | ||
152 | get_file(ki->iocb.ki_filp); | |
153 | cachefiles_grab_object(object, cachefiles_obj_get_ioreq); | |
154 | ||
155 | trace_cachefiles_read(object, file_inode(file), ki->iocb.ki_pos, len - skipped); | |
156 | old_nofs = memalloc_nofs_save(); | |
157 | ret = cachefiles_inject_read_error(); | |
158 | if (ret == 0) | |
159 | ret = vfs_iocb_iter_read(file, &ki->iocb, iter); | |
160 | memalloc_nofs_restore(old_nofs); | |
161 | switch (ret) { | |
162 | case -EIOCBQUEUED: | |
163 | goto in_progress; | |
164 | ||
165 | case -ERESTARTSYS: | |
166 | case -ERESTARTNOINTR: | |
167 | case -ERESTARTNOHAND: | |
168 | case -ERESTART_RESTARTBLOCK: | |
169 | /* There's no easy way to restart the syscall since other AIO's | |
170 | * may be already running. Just fail this IO with EINTR. | |
171 | */ | |
172 | ret = -EINTR; | |
173 | fallthrough; | |
174 | default: | |
175 | ki->was_async = false; | |
176 | cachefiles_read_complete(&ki->iocb, ret); | |
177 | if (ret > 0) | |
178 | ret = 0; | |
179 | break; | |
180 | } | |
181 | ||
182 | in_progress: | |
183 | cachefiles_put_kiocb(ki); | |
184 | _leave(" = %zd", ret); | |
185 | return ret; | |
186 | ||
187 | presubmission_error: | |
188 | if (term_func) | |
189 | term_func(term_func_priv, ret < 0 ? ret : skipped, false); | |
190 | return ret; | |
191 | } | |
192 | ||
bee9f655 DH |
193 | /* |
194 | * Query the occupancy of the cache in a region, returning where the next chunk | |
195 | * of data starts and how long it is. | |
196 | */ | |
197 | static int cachefiles_query_occupancy(struct netfs_cache_resources *cres, | |
198 | loff_t start, size_t len, size_t granularity, | |
199 | loff_t *_data_start, size_t *_data_len) | |
200 | { | |
201 | struct cachefiles_object *object; | |
202 | struct file *file; | |
203 | loff_t off, off2; | |
204 | ||
205 | *_data_start = -1; | |
206 | *_data_len = 0; | |
207 | ||
208 | if (!fscache_wait_for_operation(cres, FSCACHE_WANT_READ)) | |
209 | return -ENOBUFS; | |
210 | ||
211 | object = cachefiles_cres_object(cres); | |
212 | file = cachefiles_cres_file(cres); | |
213 | granularity = max_t(size_t, object->volume->cache->bsize, granularity); | |
214 | ||
215 | _enter("%pD,%li,%llx,%zx/%llx", | |
216 | file, file_inode(file)->i_ino, start, len, | |
217 | i_size_read(file_inode(file))); | |
218 | ||
219 | off = cachefiles_inject_read_error(); | |
220 | if (off == 0) | |
221 | off = vfs_llseek(file, start, SEEK_DATA); | |
222 | if (off == -ENXIO) | |
223 | return -ENODATA; /* Beyond EOF */ | |
224 | if (off < 0 && off >= (loff_t)-MAX_ERRNO) | |
225 | return -ENOBUFS; /* Error. */ | |
226 | if (round_up(off, granularity) >= start + len) | |
227 | return -ENODATA; /* No data in range */ | |
228 | ||
229 | off2 = cachefiles_inject_read_error(); | |
230 | if (off2 == 0) | |
231 | off2 = vfs_llseek(file, off, SEEK_HOLE); | |
232 | if (off2 == -ENXIO) | |
233 | return -ENODATA; /* Beyond EOF */ | |
234 | if (off2 < 0 && off2 >= (loff_t)-MAX_ERRNO) | |
235 | return -ENOBUFS; /* Error. */ | |
236 | ||
237 | /* Round away partial blocks */ | |
238 | off = round_up(off, granularity); | |
239 | off2 = round_down(off2, granularity); | |
240 | if (off2 <= off) | |
241 | return -ENODATA; | |
242 | ||
243 | *_data_start = off; | |
244 | if (off2 > start + len) | |
245 | *_data_len = len; | |
246 | else | |
247 | *_data_len = off2 - off; | |
248 | return 0; | |
249 | } | |
250 | ||
047487c9 DH |
251 | /* |
252 | * Handle completion of a write to the cache. | |
253 | */ | |
254 | static void cachefiles_write_complete(struct kiocb *iocb, long ret) | |
255 | { | |
256 | struct cachefiles_kiocb *ki = container_of(iocb, struct cachefiles_kiocb, iocb); | |
257 | struct cachefiles_object *object = ki->object; | |
258 | struct inode *inode = file_inode(ki->iocb.ki_filp); | |
259 | ||
260 | _enter("%ld", ret); | |
261 | ||
262 | /* Tell lockdep we inherited freeze protection from submission thread */ | |
263 | __sb_writers_acquired(inode->i_sb, SB_FREEZE_WRITE); | |
264 | __sb_end_write(inode->i_sb, SB_FREEZE_WRITE); | |
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 | */ | |
a06fac15 JX |
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) | |
047487c9 | 286 | { |
047487c9 DH |
287 | struct cachefiles_cache *cache; |
288 | struct cachefiles_kiocb *ki; | |
289 | struct inode *inode; | |
047487c9 | 290 | unsigned int old_nofs; |
a06fac15 | 291 | ssize_t ret; |
047487c9 DH |
292 | size_t len = iov_iter_count(iter); |
293 | ||
047487c9 | 294 | fscache_count_write(); |
047487c9 | 295 | cache = object->volume->cache; |
047487c9 DH |
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 | ||
047487c9 | 301 | ki = kzalloc(sizeof(struct cachefiles_kiocb), GFP_KERNEL); |
a06fac15 JX |
302 | if (!ki) { |
303 | if (term_func) | |
304 | term_func(term_func_priv, -ENOMEM, false); | |
305 | return -ENOMEM; | |
306 | } | |
047487c9 DH |
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; | |
047487c9 DH |
312 | ki->iocb.ki_ioprio = get_current_ioprio(); |
313 | ki->object = object; | |
047487c9 DH |
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; | |
5638b067 | 319 | ki->b_writing = (len + (1 << cache->bshift) - 1) >> cache->bshift; |
047487c9 DH |
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 | /* Open-code file_start_write here to grab freeze protection, which | |
326 | * will be released by another thread in aio_complete_rw(). Fool | |
327 | * lockdep by telling it the lock got released so that it doesn't | |
328 | * complain about the held lock when we return to userspace. | |
329 | */ | |
330 | inode = file_inode(file); | |
331 | __sb_start_write(inode->i_sb, SB_FREEZE_WRITE); | |
332 | __sb_writers_release(inode->i_sb, SB_FREEZE_WRITE); | |
333 | ||
334 | get_file(ki->iocb.ki_filp); | |
335 | cachefiles_grab_object(object, cachefiles_obj_get_ioreq); | |
336 | ||
337 | trace_cachefiles_write(object, inode, ki->iocb.ki_pos, len); | |
338 | old_nofs = memalloc_nofs_save(); | |
339 | ret = cachefiles_inject_write_error(); | |
340 | if (ret == 0) | |
341 | ret = vfs_iocb_iter_write(file, &ki->iocb, iter); | |
342 | memalloc_nofs_restore(old_nofs); | |
343 | switch (ret) { | |
344 | case -EIOCBQUEUED: | |
345 | goto in_progress; | |
346 | ||
347 | case -ERESTARTSYS: | |
348 | case -ERESTARTNOINTR: | |
349 | case -ERESTARTNOHAND: | |
350 | case -ERESTART_RESTARTBLOCK: | |
351 | /* There's no easy way to restart the syscall since other AIO's | |
352 | * may be already running. Just fail this IO with EINTR. | |
353 | */ | |
354 | ret = -EINTR; | |
355 | fallthrough; | |
356 | default: | |
357 | ki->was_async = false; | |
358 | cachefiles_write_complete(&ki->iocb, ret); | |
359 | if (ret > 0) | |
360 | ret = 0; | |
361 | break; | |
362 | } | |
363 | ||
364 | in_progress: | |
365 | cachefiles_put_kiocb(ki); | |
366 | _leave(" = %zd", ret); | |
367 | return ret; | |
a06fac15 | 368 | } |
047487c9 | 369 | |
a06fac15 JX |
370 | static int cachefiles_write(struct netfs_cache_resources *cres, |
371 | loff_t start_pos, | |
372 | struct iov_iter *iter, | |
373 | netfs_io_terminated_t term_func, | |
374 | void *term_func_priv) | |
375 | { | |
376 | if (!fscache_wait_for_operation(cres, FSCACHE_WANT_WRITE)) { | |
377 | if (term_func) | |
378 | term_func(term_func_priv, -ENOBUFS, false); | |
379 | return -ENOBUFS; | |
380 | } | |
381 | ||
382 | return __cachefiles_write(cachefiles_cres_object(cres), | |
383 | cachefiles_cres_file(cres), | |
384 | start_pos, iter, | |
385 | term_func, term_func_priv); | |
047487c9 DH |
386 | } |
387 | ||
86692475 JX |
388 | static inline enum netfs_io_source |
389 | cachefiles_do_prepare_read(struct netfs_cache_resources *cres, | |
390 | loff_t start, size_t *_len, loff_t i_size, | |
391 | unsigned long *_flags, ino_t netfs_ino) | |
047487c9 DH |
392 | { |
393 | enum cachefiles_prepare_read_trace why; | |
86692475 | 394 | struct cachefiles_object *object = NULL; |
047487c9 DH |
395 | struct cachefiles_cache *cache; |
396 | struct fscache_cookie *cookie = fscache_cres_cookie(cres); | |
397 | const struct cred *saved_cred; | |
398 | struct file *file = cachefiles_cres_file(cres); | |
6a19114b | 399 | enum netfs_io_source ret = NETFS_DOWNLOAD_FROM_SERVER; |
86692475 | 400 | size_t len = *_len; |
047487c9 DH |
401 | loff_t off, to; |
402 | ino_t ino = file ? file_inode(file)->i_ino : 0; | |
9032b6e8 | 403 | int rc; |
047487c9 | 404 | |
86692475 | 405 | _enter("%zx @%llx/%llx", len, start, i_size); |
047487c9 | 406 | |
86692475 | 407 | if (start >= i_size) { |
047487c9 DH |
408 | ret = NETFS_FILL_WITH_ZEROES; |
409 | why = cachefiles_trace_read_after_eof; | |
410 | goto out_no_object; | |
411 | } | |
412 | ||
413 | if (test_bit(FSCACHE_COOKIE_NO_DATA_TO_READ, &cookie->flags)) { | |
86692475 | 414 | __set_bit(NETFS_SREQ_COPY_TO_CACHE, _flags); |
047487c9 | 415 | why = cachefiles_trace_read_no_data; |
86692475 | 416 | if (!test_bit(NETFS_SREQ_ONDEMAND, _flags)) |
9032b6e8 | 417 | goto out_no_object; |
047487c9 DH |
418 | } |
419 | ||
420 | /* The object and the file may be being created in the background. */ | |
421 | if (!file) { | |
422 | why = cachefiles_trace_read_no_file; | |
423 | if (!fscache_wait_for_operation(cres, FSCACHE_WANT_READ)) | |
424 | goto out_no_object; | |
425 | file = cachefiles_cres_file(cres); | |
426 | if (!file) | |
427 | goto out_no_object; | |
428 | ino = file_inode(file)->i_ino; | |
429 | } | |
430 | ||
431 | object = cachefiles_cres_object(cres); | |
432 | cache = object->volume->cache; | |
433 | cachefiles_begin_secure(cache, &saved_cred); | |
9032b6e8 | 434 | retry: |
047487c9 DH |
435 | off = cachefiles_inject_read_error(); |
436 | if (off == 0) | |
86692475 | 437 | off = vfs_llseek(file, start, SEEK_DATA); |
047487c9 DH |
438 | if (off < 0 && off >= (loff_t)-MAX_ERRNO) { |
439 | if (off == (loff_t)-ENXIO) { | |
440 | why = cachefiles_trace_read_seek_nxio; | |
441 | goto download_and_store; | |
442 | } | |
443 | trace_cachefiles_io_error(object, file_inode(file), off, | |
444 | cachefiles_trace_seek_error); | |
445 | why = cachefiles_trace_read_seek_error; | |
446 | goto out; | |
447 | } | |
448 | ||
86692475 | 449 | if (off >= start + len) { |
047487c9 DH |
450 | why = cachefiles_trace_read_found_hole; |
451 | goto download_and_store; | |
452 | } | |
453 | ||
86692475 | 454 | if (off > start) { |
047487c9 | 455 | off = round_up(off, cache->bsize); |
86692475 JX |
456 | len = off - start; |
457 | *_len = len; | |
047487c9 DH |
458 | why = cachefiles_trace_read_found_part; |
459 | goto download_and_store; | |
460 | } | |
461 | ||
462 | to = cachefiles_inject_read_error(); | |
463 | if (to == 0) | |
86692475 | 464 | to = vfs_llseek(file, start, SEEK_HOLE); |
047487c9 DH |
465 | if (to < 0 && to >= (loff_t)-MAX_ERRNO) { |
466 | trace_cachefiles_io_error(object, file_inode(file), to, | |
467 | cachefiles_trace_seek_error); | |
468 | why = cachefiles_trace_read_seek_error; | |
469 | goto out; | |
470 | } | |
471 | ||
86692475 JX |
472 | if (to < start + len) { |
473 | if (start + len >= i_size) | |
047487c9 DH |
474 | to = round_up(to, cache->bsize); |
475 | else | |
476 | to = round_down(to, cache->bsize); | |
86692475 JX |
477 | len = to - start; |
478 | *_len = len; | |
047487c9 DH |
479 | } |
480 | ||
481 | why = cachefiles_trace_read_have_data; | |
482 | ret = NETFS_READ_FROM_CACHE; | |
483 | goto out; | |
484 | ||
485 | download_and_store: | |
86692475 JX |
486 | __set_bit(NETFS_SREQ_COPY_TO_CACHE, _flags); |
487 | if (test_bit(NETFS_SREQ_ONDEMAND, _flags)) { | |
488 | rc = cachefiles_ondemand_read(object, start, len); | |
9032b6e8 | 489 | if (!rc) { |
86692475 | 490 | __clear_bit(NETFS_SREQ_ONDEMAND, _flags); |
9032b6e8 JX |
491 | goto retry; |
492 | } | |
493 | ret = NETFS_INVALID_READ; | |
494 | } | |
047487c9 DH |
495 | out: |
496 | cachefiles_end_secure(cache, saved_cred); | |
497 | out_no_object: | |
86692475 | 498 | trace_cachefiles_prep_read(object, start, len, *_flags, ret, why, ino, netfs_ino); |
047487c9 DH |
499 | return ret; |
500 | } | |
501 | ||
86692475 JX |
502 | /* |
503 | * Prepare a read operation, shortening it to a cached/uncached | |
504 | * boundary as appropriate. | |
505 | */ | |
506 | static enum netfs_io_source cachefiles_prepare_read(struct netfs_io_subrequest *subreq, | |
507 | loff_t i_size) | |
508 | { | |
509 | return cachefiles_do_prepare_read(&subreq->rreq->cache_resources, | |
510 | subreq->start, &subreq->len, i_size, | |
511 | &subreq->flags, subreq->rreq->inode->i_ino); | |
512 | } | |
513 | ||
514 | /* | |
515 | * Prepare an on-demand read operation, shortening it to a cached/uncached | |
516 | * boundary as appropriate. | |
517 | */ | |
518 | static enum netfs_io_source | |
519 | cachefiles_prepare_ondemand_read(struct netfs_cache_resources *cres, | |
520 | loff_t start, size_t *_len, loff_t i_size, | |
521 | unsigned long *_flags, ino_t ino) | |
522 | { | |
523 | return cachefiles_do_prepare_read(cres, start, _len, i_size, _flags, ino); | |
524 | } | |
525 | ||
047487c9 DH |
526 | /* |
527 | * Prepare for a write to occur. | |
528 | */ | |
a06fac15 JX |
529 | int __cachefiles_prepare_write(struct cachefiles_object *object, |
530 | struct file *file, | |
531 | loff_t *_start, size_t *_len, | |
532 | bool no_space_allocated_yet) | |
047487c9 | 533 | { |
047487c9 | 534 | struct cachefiles_cache *cache = object->volume->cache; |
047487c9 DH |
535 | loff_t start = *_start, pos; |
536 | size_t len = *_len, down; | |
537 | int ret; | |
538 | ||
539 | /* Round to DIO size */ | |
540 | down = start - round_down(start, PAGE_SIZE); | |
541 | *_start = start - down; | |
542 | *_len = round_up(down + 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 | */ | |
3929eca7 DH |
568 | if (cachefiles_has_space(cache, 0, *_len / PAGE_SIZE, |
569 | cachefiles_has_space_check) == 0) | |
047487c9 DH |
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. */ | |
3929eca7 | 584 | fscache_count_no_write_space(); |
047487c9 DH |
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: | |
3929eca7 DH |
600 | return cachefiles_has_space(cache, 0, *_len / PAGE_SIZE, |
601 | cachefiles_has_space_for_write); | |
047487c9 DH |
602 | } |
603 | ||
604 | static int cachefiles_prepare_write(struct netfs_cache_resources *cres, | |
605 | loff_t *_start, size_t *_len, loff_t i_size, | |
606 | 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); | |
a06fac15 JX |
621 | ret = __cachefiles_prepare_write(object, cachefiles_cres_file(cres), |
622 | _start, _len, | |
047487c9 DH |
623 | no_space_allocated_yet); |
624 | cachefiles_end_secure(cache, saved_cred); | |
625 | return ret; | |
626 | } | |
627 | ||
287fd611 DH |
628 | /* |
629 | * Clean up an operation. | |
630 | */ | |
631 | static void cachefiles_end_operation(struct netfs_cache_resources *cres) | |
632 | { | |
633 | struct file *file = cachefiles_cres_file(cres); | |
634 | ||
635 | if (file) | |
636 | fput(file); | |
637 | fscache_end_cookie_access(fscache_cres_cookie(cres), fscache_access_io_end); | |
638 | } | |
639 | ||
640 | static const struct netfs_cache_ops cachefiles_netfs_cache_ops = { | |
641 | .end_operation = cachefiles_end_operation, | |
047487c9 DH |
642 | .read = cachefiles_read, |
643 | .write = cachefiles_write, | |
644 | .prepare_read = cachefiles_prepare_read, | |
645 | .prepare_write = cachefiles_prepare_write, | |
86692475 | 646 | .prepare_ondemand_read = cachefiles_prepare_ondemand_read, |
bee9f655 | 647 | .query_occupancy = cachefiles_query_occupancy, |
287fd611 DH |
648 | }; |
649 | ||
650 | /* | |
651 | * Open the cache file when beginning a cache operation. | |
652 | */ | |
653 | bool cachefiles_begin_operation(struct netfs_cache_resources *cres, | |
654 | enum fscache_want_state want_state) | |
655 | { | |
656 | struct cachefiles_object *object = cachefiles_cres_object(cres); | |
657 | ||
658 | if (!cachefiles_cres_file(cres)) { | |
659 | cres->ops = &cachefiles_netfs_cache_ops; | |
660 | if (object->file) { | |
661 | spin_lock(&object->lock); | |
662 | if (!cres->cache_priv2 && object->file) | |
663 | cres->cache_priv2 = get_file(object->file); | |
664 | spin_unlock(&object->lock); | |
665 | } | |
666 | } | |
667 | ||
668 | if (!cachefiles_cres_file(cres) && want_state != FSCACHE_WANT_PARAMS) { | |
669 | pr_err("failed to get cres->file\n"); | |
670 | return false; | |
671 | } | |
672 | ||
673 | return true; | |
674 | } |