?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 6.13-rc7
[linux.git] / fs / bcachefs / fs-io-pagecache.c
blob1d4910ea0f1d63f14c556cec39560897388b86a1
1 // SPDX-License-Identifier: GPL-2.0
2 #ifndef NO_BCACHEFS_FS
3
4 #include "bcachefs.h"
5 #include "btree_iter.h"
6 #include "extents.h"
7 #include "fs-io.h"
8 #include "fs-io-pagecache.h"
9 #include "subvolume.h"
10
11 #include <linux/pagevec.h>
12 #include <linux/writeback.h>
13
14 int bch2_filemap_get_contig_folios_d(struct address_space *mapping,
15 loff_t start, u64 end,
16 fgf_t fgp_flags, gfp_t gfp,
17 folios *fs)
18 {
19 struct folio *f;
20 u64 pos = start;
21 int ret = 0;
22
23 while (pos < end) {
24 if ((u64) pos >= (u64) start + (1ULL << 20))
25 fgp_flags &= ~FGP_CREAT;
26
27 ret = darray_make_room_gfp(fs, 1, gfp & GFP_KERNEL);
28 if (ret)
29 break;
30
31 f = __filemap_get_folio(mapping, pos >> PAGE_SHIFT, fgp_flags, gfp);
32 if (IS_ERR_OR_NULL(f))
33 break;
34
35 BUG_ON(fs->nr && folio_pos(f) != pos);
36
37 pos = folio_end_pos(f);
38 darray_push(fs, f);
39 }
40
41 if (!fs->nr && !ret && (fgp_flags & FGP_CREAT))
42 ret = -ENOMEM;
43
44 return fs->nr ? 0 : ret;
45 }
46
47 /* pagecache_block must be held */
48 int bch2_write_invalidate_inode_pages_range(struct address_space *mapping,
49 loff_t start, loff_t end)
50 {
51 int ret;
52
53 /*
54 * XXX: the way this is currently implemented, we can spin if a process
55 * is continually redirtying a specific page
56 */
57 do {
58 if (!mapping->nrpages)
59 return 0;
60
61 ret = filemap_write_and_wait_range(mapping, start, end);
62 if (ret)
63 break;
64
65 if (!mapping->nrpages)
66 return 0;
67
68 ret = invalidate_inode_pages2_range(mapping,
69 start >> PAGE_SHIFT,
70 end >> PAGE_SHIFT);
71 } while (ret == -EBUSY);
72
73 return ret;
74 }
75
76 #if 0
77 /* Useful for debug tracing: */
78 static const char * const bch2_folio_sector_states[] = {
79 #define x(n) #n,
80 BCH_FOLIO_SECTOR_STATE()
81 #undef x
82 NULL
83 };
84 #endif
85
86 static inline enum bch_folio_sector_state
87 folio_sector_dirty(enum bch_folio_sector_state state)
88 {
89 switch (state) {
90 case SECTOR_unallocated:
91 return SECTOR_dirty;
92 case SECTOR_reserved:
93 return SECTOR_dirty_reserved;
94 default:
95 return state;
96 }
97 }
98
99 static inline enum bch_folio_sector_state
100 folio_sector_undirty(enum bch_folio_sector_state state)
101 {
102 switch (state) {
103 case SECTOR_dirty:
104 return SECTOR_unallocated;
105 case SECTOR_dirty_reserved:
106 return SECTOR_reserved;
107 default:
108 return state;
109 }
110 }
111
112 static inline enum bch_folio_sector_state
113 folio_sector_reserve(enum bch_folio_sector_state state)
114 {
115 switch (state) {
116 case SECTOR_unallocated:
117 return SECTOR_reserved;
118 case SECTOR_dirty:
119 return SECTOR_dirty_reserved;
120 default:
121 return state;
122 }
123 }
124
125 /* for newly allocated folios: */
126 struct bch_folio *__bch2_folio_create(struct folio *folio, gfp_t gfp)
127 {
128 struct bch_folio *s;
129
130 s = kzalloc(sizeof(*s) +
131 sizeof(struct bch_folio_sector) *
132 folio_sectors(folio), gfp);
133 if (!s)
134 return NULL;
135
136 spin_lock_init(&s->lock);
137 folio_attach_private(folio, s);
138 return s;
139 }
140
141 struct bch_folio *bch2_folio_create(struct folio *folio, gfp_t gfp)
142 {
143 return bch2_folio(folio) ?: __bch2_folio_create(folio, gfp);
144 }
145
146 static unsigned bkey_to_sector_state(struct bkey_s_c k)
147 {
148 if (bkey_extent_is_reservation(k))
149 return SECTOR_reserved;
150 if (bkey_extent_is_allocation(k.k))
151 return SECTOR_allocated;
152 return SECTOR_unallocated;
153 }
154
155 static void __bch2_folio_set(struct folio *folio,
156 unsigned pg_offset, unsigned pg_len,
157 unsigned nr_ptrs, unsigned state)
158 {
159 struct bch_folio *s = bch2_folio(folio);
160 unsigned i, sectors = folio_sectors(folio);
161
162 BUG_ON(pg_offset >= sectors);
163 BUG_ON(pg_offset + pg_len > sectors);
164
165 spin_lock(&s->lock);
166
167 for (i = pg_offset; i < pg_offset + pg_len; i++) {
168 s->s[i].nr_replicas = nr_ptrs;
169 bch2_folio_sector_set(folio, s, i, state);
170 }
171
172 if (i == sectors)
173 s->uptodate = true;
174
175 spin_unlock(&s->lock);
176 }
177
178 /*
179 * Initialize bch_folio state (allocated/unallocated, nr_replicas) from the
180 * extents btree:
181 */
182 int bch2_folio_set(struct bch_fs *c, subvol_inum inum,
183 struct folio **fs, unsigned nr_folios)
184 {
185 u64 offset = folio_sector(fs[0]);
186 bool need_set = false;
187
188 for (unsigned folio_idx = 0; folio_idx < nr_folios; folio_idx++) {
189 struct bch_folio *s = bch2_folio_create(fs[folio_idx], GFP_KERNEL);
190 if (!s)
191 return -ENOMEM;
192
193 need_set |= !s->uptodate;
194 }
195
196 if (!need_set)
197 return 0;
198
199 unsigned folio_idx = 0;
200
201 return bch2_trans_run(c,
202 for_each_btree_key_in_subvolume_upto(trans, iter, BTREE_ID_extents,
203 POS(inum.inum, offset),
204 POS(inum.inum, U64_MAX),
205 inum.subvol, BTREE_ITER_slots, k, ({
206 unsigned nr_ptrs = bch2_bkey_nr_ptrs_fully_allocated(k);
207 unsigned state = bkey_to_sector_state(k);
208
209 while (folio_idx < nr_folios) {
210 struct folio *folio = fs[folio_idx];
211 u64 folio_start = folio_sector(folio);
212 u64 folio_end = folio_end_sector(folio);
213 unsigned folio_offset = max(bkey_start_offset(k.k), folio_start) -
214 folio_start;
215 unsigned folio_len = min(k.k->p.offset, folio_end) -
216 folio_offset - folio_start;
217
218 BUG_ON(k.k->p.offset < folio_start);
219 BUG_ON(bkey_start_offset(k.k) > folio_end);
220
221 if (!bch2_folio(folio)->uptodate)
222 __bch2_folio_set(folio, folio_offset, folio_len, nr_ptrs, state);
223
224 if (k.k->p.offset < folio_end)
225 break;
226 folio_idx++;
227 }
228
229 if (folio_idx == nr_folios)
230 break;
231 0;
232 })));
233 }
234
235 void bch2_bio_page_state_set(struct bio *bio, struct bkey_s_c k)
236 {
237 struct bvec_iter iter;
238 struct folio_vec fv;
239 unsigned nr_ptrs = k.k->type == KEY_TYPE_reflink_v
240 ? 0 : bch2_bkey_nr_ptrs_fully_allocated(k);
241 unsigned state = bkey_to_sector_state(k);
242
243 bio_for_each_folio(fv, bio, iter)
244 __bch2_folio_set(fv.fv_folio,
245 fv.fv_offset >> 9,
246 fv.fv_len >> 9,
247 nr_ptrs, state);
248 }
249
250 void bch2_mark_pagecache_unallocated(struct bch_inode_info *inode,
251 u64 start, u64 end)
252 {
253 pgoff_t index = start >> PAGE_SECTORS_SHIFT;
254 pgoff_t end_index = (end - 1) >> PAGE_SECTORS_SHIFT;
255 struct folio_batch fbatch;
256 unsigned i, j;
257
258 if (end <= start)
259 return;
260
261 folio_batch_init(&fbatch);
262
263 while (filemap_get_folios(inode->v.i_mapping,
264 &index, end_index, &fbatch)) {
265 for (i = 0; i < folio_batch_count(&fbatch); i++) {
266 struct folio *folio = fbatch.folios[i];
267 u64 folio_start = folio_sector(folio);
268 u64 folio_end = folio_end_sector(folio);
269 unsigned folio_offset = max(start, folio_start) - folio_start;
270 unsigned folio_len = min(end, folio_end) - folio_offset - folio_start;
271 struct bch_folio *s;
272
273 BUG_ON(end <= folio_start);
274
275 folio_lock(folio);
276 s = bch2_folio(folio);
277
278 if (s) {
279 spin_lock(&s->lock);
280 for (j = folio_offset; j < folio_offset + folio_len; j++)
281 s->s[j].nr_replicas = 0;
282 spin_unlock(&s->lock);
283 }
284
285 folio_unlock(folio);
286 }
287 folio_batch_release(&fbatch);
288 cond_resched();
289 }
290 }
291
292 int bch2_mark_pagecache_reserved(struct bch_inode_info *inode,
293 u64 *start, u64 end,
294 bool nonblocking)
295 {
296 struct bch_fs *c = inode->v.i_sb->s_fs_info;
297 pgoff_t index = *start >> PAGE_SECTORS_SHIFT;
298 pgoff_t end_index = (end - 1) >> PAGE_SECTORS_SHIFT;
299 struct folio_batch fbatch;
300 s64 i_sectors_delta = 0;
301 int ret = 0;
302
303 if (end <= *start)
304 return 0;
305
306 folio_batch_init(&fbatch);
307
308 while (filemap_get_folios(inode->v.i_mapping,
309 &index, end_index, &fbatch)) {
310 for (unsigned i = 0; i < folio_batch_count(&fbatch); i++) {
311 struct folio *folio = fbatch.folios[i];
312
313 if (!nonblocking)
314 folio_lock(folio);
315 else if (!folio_trylock(folio)) {
316 folio_batch_release(&fbatch);
317 ret = -EAGAIN;
318 break;
319 }
320
321 u64 folio_start = folio_sector(folio);
322 u64 folio_end = folio_end_sector(folio);
323
324 BUG_ON(end <= folio_start);
325
326 *start = min(end, folio_end);
327
328 struct bch_folio *s = bch2_folio(folio);
329 if (s) {
330 unsigned folio_offset = max(*start, folio_start) - folio_start;
331 unsigned folio_len = min(end, folio_end) - folio_offset - folio_start;
332
333 spin_lock(&s->lock);
334 for (unsigned j = folio_offset; j < folio_offset + folio_len; j++) {
335 i_sectors_delta -= s->s[j].state == SECTOR_dirty;
336 bch2_folio_sector_set(folio, s, j,
337 folio_sector_reserve(s->s[j].state));
338 }
339 spin_unlock(&s->lock);
340 }
341
342 folio_unlock(folio);
343 }
344 folio_batch_release(&fbatch);
345 cond_resched();
346 }
347
348 bch2_i_sectors_acct(c, inode, NULL, i_sectors_delta);
349 return ret;
350 }
351
352 static inline unsigned sectors_to_reserve(struct bch_folio_sector *s,
353 unsigned nr_replicas)
354 {
355 return max(0, (int) nr_replicas -
356 s->nr_replicas -
357 s->replicas_reserved);
358 }
359
360 int bch2_get_folio_disk_reservation(struct bch_fs *c,
361 struct bch_inode_info *inode,
362 struct folio *folio, bool check_enospc)
363 {
364 struct bch_folio *s = bch2_folio_create(folio, 0);
365 unsigned nr_replicas = inode_nr_replicas(c, inode);
366 struct disk_reservation disk_res = { 0 };
367 unsigned i, sectors = folio_sectors(folio), disk_res_sectors = 0;
368 int ret;
369
370 if (!s)
371 return -ENOMEM;
372
373 for (i = 0; i < sectors; i++)
374 disk_res_sectors += sectors_to_reserve(&s->s[i], nr_replicas);
375
376 if (!disk_res_sectors)
377 return 0;
378
379 ret = bch2_disk_reservation_get(c, &disk_res,
380 disk_res_sectors, 1,
381 !check_enospc
382 ? BCH_DISK_RESERVATION_NOFAIL
383 : 0);
384 if (unlikely(ret))
385 return ret;
386
387 for (i = 0; i < sectors; i++)
388 s->s[i].replicas_reserved +=
389 sectors_to_reserve(&s->s[i], nr_replicas);
390
391 return 0;
392 }
393
394 void bch2_folio_reservation_put(struct bch_fs *c,
395 struct bch_inode_info *inode,
396 struct bch2_folio_reservation *res)
397 {
398 bch2_disk_reservation_put(c, &res->disk);
399 bch2_quota_reservation_put(c, inode, &res->quota);
400 }
401
402 static int __bch2_folio_reservation_get(struct bch_fs *c,
403 struct bch_inode_info *inode,
404 struct folio *folio,
405 struct bch2_folio_reservation *res,
406 size_t offset, size_t len,
407 bool partial)
408 {
409 struct bch_folio *s = bch2_folio_create(folio, 0);
410 unsigned i, disk_sectors = 0, quota_sectors = 0;
411 struct disk_reservation disk_res = {};
412 size_t reserved = len;
413 int ret;
414
415 if (!s)
416 return -ENOMEM;
417
418 BUG_ON(!s->uptodate);
419
420 for (i = round_down(offset, block_bytes(c)) >> 9;
421 i < round_up(offset + len, block_bytes(c)) >> 9;
422 i++) {
423 disk_sectors += sectors_to_reserve(&s->s[i], res->disk.nr_replicas);
424 quota_sectors += s->s[i].state == SECTOR_unallocated;
425 }
426
427 if (disk_sectors) {
428 ret = bch2_disk_reservation_add(c, &disk_res, disk_sectors,
429 partial ? BCH_DISK_RESERVATION_PARTIAL : 0);
430 if (unlikely(ret))
431 return ret;
432
433 if (unlikely(disk_res.sectors != disk_sectors)) {
434 disk_sectors = quota_sectors = 0;
435
436 for (i = round_down(offset, block_bytes(c)) >> 9;
437 i < round_up(offset + len, block_bytes(c)) >> 9;
438 i++) {
439 disk_sectors += sectors_to_reserve(&s->s[i], res->disk.nr_replicas);
440 if (disk_sectors > disk_res.sectors) {
441 /*
442 * Make sure to get a reservation that's
443 * aligned to the filesystem blocksize:
444 */
445 unsigned reserved_offset = round_down(i << 9, block_bytes(c));
446 reserved = clamp(reserved_offset, offset, offset + len) - offset;
447
448 if (!reserved) {
449 bch2_disk_reservation_put(c, &disk_res);
450 return -BCH_ERR_ENOSPC_disk_reservation;
451 }
452 break;
453 }
454 quota_sectors += s->s[i].state == SECTOR_unallocated;
455 }
456 }
457 }
458
459 if (quota_sectors) {
460 ret = bch2_quota_reservation_add(c, inode, &res->quota, quota_sectors, true);
461 if (unlikely(ret)) {
462 bch2_disk_reservation_put(c, &disk_res);
463 return ret;
464 }
465 }
466
467 res->disk.sectors += disk_res.sectors;
468 return partial ? reserved : 0;
469 }
470
471 int bch2_folio_reservation_get(struct bch_fs *c,
472 struct bch_inode_info *inode,
473 struct folio *folio,
474 struct bch2_folio_reservation *res,
475 size_t offset, size_t len)
476 {
477 return __bch2_folio_reservation_get(c, inode, folio, res, offset, len, false);
478 }
479
480 ssize_t bch2_folio_reservation_get_partial(struct bch_fs *c,
481 struct bch_inode_info *inode,
482 struct folio *folio,
483 struct bch2_folio_reservation *res,
484 size_t offset, size_t len)
485 {
486 return __bch2_folio_reservation_get(c, inode, folio, res, offset, len, true);
487 }
488
489 static void bch2_clear_folio_bits(struct folio *folio)
490 {
491 struct bch_inode_info *inode = to_bch_ei(folio->mapping->host);
492 struct bch_fs *c = inode->v.i_sb->s_fs_info;
493 struct bch_folio *s = bch2_folio(folio);
494 struct disk_reservation disk_res = { 0 };
495 int i, sectors = folio_sectors(folio), dirty_sectors = 0;
496
497 if (!s)
498 return;
499
500 EBUG_ON(!folio_test_locked(folio));
501 EBUG_ON(folio_test_writeback(folio));
502
503 for (i = 0; i < sectors; i++) {
504 disk_res.sectors += s->s[i].replicas_reserved;
505 s->s[i].replicas_reserved = 0;
506
507 dirty_sectors -= s->s[i].state == SECTOR_dirty;
508 bch2_folio_sector_set(folio, s, i, folio_sector_undirty(s->s[i].state));
509 }
510
511 bch2_disk_reservation_put(c, &disk_res);
512
513 bch2_i_sectors_acct(c, inode, NULL, dirty_sectors);
514
515 bch2_folio_release(folio);
516 }
517
518 void bch2_set_folio_dirty(struct bch_fs *c,
519 struct bch_inode_info *inode,
520 struct folio *folio,
521 struct bch2_folio_reservation *res,
522 unsigned offset, unsigned len)
523 {
524 struct bch_folio *s = bch2_folio(folio);
525 unsigned i, dirty_sectors = 0;
526
527 WARN_ON((u64) folio_pos(folio) + offset + len >
528 round_up((u64) i_size_read(&inode->v), block_bytes(c)));
529
530 BUG_ON(!s->uptodate);
531
532 spin_lock(&s->lock);
533
534 for (i = round_down(offset, block_bytes(c)) >> 9;
535 i < round_up(offset + len, block_bytes(c)) >> 9;
536 i++) {
537 unsigned sectors = sectors_to_reserve(&s->s[i],
538 res->disk.nr_replicas);
539
540 /*
541 * This can happen if we race with the error path in
542 * bch2_writepage_io_done():
543 */
544 sectors = min_t(unsigned, sectors, res->disk.sectors);
545
546 s->s[i].replicas_reserved += sectors;
547 res->disk.sectors -= sectors;
548
549 dirty_sectors += s->s[i].state == SECTOR_unallocated;
550
551 bch2_folio_sector_set(folio, s, i, folio_sector_dirty(s->s[i].state));
552 }
553
554 spin_unlock(&s->lock);
555
556 bch2_i_sectors_acct(c, inode, &res->quota, dirty_sectors);
557
558 if (!folio_test_dirty(folio))
559 filemap_dirty_folio(inode->v.i_mapping, folio);
560 }
561
562 vm_fault_t bch2_page_fault(struct vm_fault *vmf)
563 {
564 struct file *file = vmf->vma->vm_file;
565 struct address_space *mapping = file->f_mapping;
566 struct address_space *fdm = faults_disabled_mapping();
567 struct bch_inode_info *inode = file_bch_inode(file);
568 vm_fault_t ret;
569
570 if (fdm == mapping)
571 return VM_FAULT_SIGBUS;
572
573 /* Lock ordering: */
574 if (fdm > mapping) {
575 struct bch_inode_info *fdm_host = to_bch_ei(fdm->host);
576
577 if (bch2_pagecache_add_tryget(inode))
578 goto got_lock;
579
580 bch2_pagecache_block_put(fdm_host);
581
582 bch2_pagecache_add_get(inode);
583 bch2_pagecache_add_put(inode);
584
585 bch2_pagecache_block_get(fdm_host);
586
587 /* Signal that lock has been dropped: */
588 set_fdm_dropped_locks();
589 return VM_FAULT_SIGBUS;
590 }
591
592 bch2_pagecache_add_get(inode);
593 got_lock:
594 ret = filemap_fault(vmf);
595 bch2_pagecache_add_put(inode);
596
597 return ret;
598 }
599
600 vm_fault_t bch2_page_mkwrite(struct vm_fault *vmf)
601 {
602 struct folio *folio = page_folio(vmf->page);
603 struct file *file = vmf->vma->vm_file;
604 struct bch_inode_info *inode = file_bch_inode(file);
605 struct address_space *mapping = file->f_mapping;
606 struct bch_fs *c = inode->v.i_sb->s_fs_info;
607 struct bch2_folio_reservation res;
608 unsigned len;
609 loff_t isize;
610 vm_fault_t ret;
611
612 bch2_folio_reservation_init(c, inode, &res);
613
614 sb_start_pagefault(inode->v.i_sb);
615 file_update_time(file);
616
617 /*
618 * Not strictly necessary, but helps avoid dio writes livelocking in
619 * bch2_write_invalidate_inode_pages_range() - can drop this if/when we get
620 * a bch2_write_invalidate_inode_pages_range() that works without dropping
621 * page lock before invalidating page
622 */
623 bch2_pagecache_add_get(inode);
624
625 folio_lock(folio);
626 isize = i_size_read(&inode->v);
627
628 if (folio->mapping != mapping || folio_pos(folio) >= isize) {
629 folio_unlock(folio);
630 ret = VM_FAULT_NOPAGE;
631 goto out;
632 }
633
634 len = min_t(loff_t, folio_size(folio), isize - folio_pos(folio));
635
636 if (bch2_folio_set(c, inode_inum(inode), &folio, 1) ?:
637 bch2_folio_reservation_get(c, inode, folio, &res, 0, len)) {
638 folio_unlock(folio);
639 ret = VM_FAULT_SIGBUS;
640 goto out;
641 }
642
643 bch2_set_folio_dirty(c, inode, folio, &res, 0, len);
644 bch2_folio_reservation_put(c, inode, &res);
645
646 folio_wait_stable(folio);
647 ret = VM_FAULT_LOCKED;
648 out:
649 bch2_pagecache_add_put(inode);
650 sb_end_pagefault(inode->v.i_sb);
651
652 return ret;
653 }
654
655 void bch2_invalidate_folio(struct folio *folio, size_t offset, size_t length)
656 {
657 if (offset || length < folio_size(folio))
658 return;
659
660 bch2_clear_folio_bits(folio);
661 }
662
663 bool bch2_release_folio(struct folio *folio, gfp_t gfp_mask)
664 {
665 if (folio_test_dirty(folio) || folio_test_writeback(folio))
666 return false;
667
668 bch2_clear_folio_bits(folio);
669 return true;
670 }
671
672 /* fseek: */
673
674 static int folio_data_offset(struct folio *folio, loff_t pos,
675 unsigned min_replicas)
676 {
677 struct bch_folio *s = bch2_folio(folio);
678 unsigned i, sectors = folio_sectors(folio);
679
680 if (s)
681 for (i = folio_pos_to_s(folio, pos); i < sectors; i++)
682 if (s->s[i].state >= SECTOR_dirty &&
683 s->s[i].nr_replicas + s->s[i].replicas_reserved >= min_replicas)
684 return i << SECTOR_SHIFT;
685
686 return -1;
687 }
688
689 loff_t bch2_seek_pagecache_data(struct inode *vinode,
690 loff_t start_offset,
691 loff_t end_offset,
692 unsigned min_replicas,
693 bool nonblock)
694 {
695 struct folio_batch fbatch;
696 pgoff_t start_index = start_offset >> PAGE_SHIFT;
697 pgoff_t end_index = end_offset >> PAGE_SHIFT;
698 pgoff_t index = start_index;
699 unsigned i;
700 loff_t ret;
701 int offset;
702
703 folio_batch_init(&fbatch);
704
705 while (filemap_get_folios(vinode->i_mapping,
706 &index, end_index, &fbatch)) {
707 for (i = 0; i < folio_batch_count(&fbatch); i++) {
708 struct folio *folio = fbatch.folios[i];
709
710 if (!nonblock) {
711 folio_lock(folio);
712 } else if (!folio_trylock(folio)) {
713 folio_batch_release(&fbatch);
714 return -EAGAIN;
715 }
716
717 offset = folio_data_offset(folio,
718 max(folio_pos(folio), start_offset),
719 min_replicas);
720 if (offset >= 0) {
721 ret = clamp(folio_pos(folio) + offset,
722 start_offset, end_offset);
723 folio_unlock(folio);
724 folio_batch_release(&fbatch);
725 return ret;
726 }
727 folio_unlock(folio);
728 }
729 folio_batch_release(&fbatch);
730 cond_resched();
731 }
732
733 return end_offset;
734 }
735
736 /*
737 * Search for a hole in a folio.
738 *
739 * The filemap layer returns -ENOENT if no folio exists, so reuse the same error
740 * code to indicate a pagecache hole exists at the returned offset. Otherwise
741 * return 0 if the folio is filled with data, or an error code. This function
742 * can return -EAGAIN if nonblock is specified.
743 */
744 static int folio_hole_offset(struct address_space *mapping, loff_t *offset,
745 unsigned min_replicas, bool nonblock)
746 {
747 struct folio *folio;
748 struct bch_folio *s;
749 unsigned i, sectors;
750 int ret = -ENOENT;
751
752 folio = __filemap_get_folio(mapping, *offset >> PAGE_SHIFT,
753 FGP_LOCK|(nonblock ? FGP_NOWAIT : 0), 0);
754 if (IS_ERR(folio))
755 return PTR_ERR(folio);
756
757 s = bch2_folio(folio);
758 if (!s)
759 goto unlock;
760
761 sectors = folio_sectors(folio);
762 for (i = folio_pos_to_s(folio, *offset); i < sectors; i++)
763 if (s->s[i].state < SECTOR_dirty ||
764 s->s[i].nr_replicas + s->s[i].replicas_reserved < min_replicas) {
765 *offset = max(*offset,
766 folio_pos(folio) + (i << SECTOR_SHIFT));
767 goto unlock;
768 }
769
770 *offset = folio_end_pos(folio);
771 ret = 0;
772 unlock:
773 folio_unlock(folio);
774 folio_put(folio);
775 return ret;
776 }
777
778 loff_t bch2_seek_pagecache_hole(struct inode *vinode,
779 loff_t start_offset,
780 loff_t end_offset,
781 unsigned min_replicas,
782 bool nonblock)
783 {
784 struct address_space *mapping = vinode->i_mapping;
785 loff_t offset = start_offset;
786 loff_t ret = 0;
787
788 while (!ret && offset < end_offset)
789 ret = folio_hole_offset(mapping, &offset, min_replicas, nonblock);
790
791 if (ret && ret != -ENOENT)
792 return ret;
793 return min(offset, end_offset);
794 }
795
796 int bch2_clamp_data_hole(struct inode *inode,
797 u64 *hole_start,
798 u64 *hole_end,
799 unsigned min_replicas,
800 bool nonblock)
801 {
802 loff_t ret;
803
804 ret = bch2_seek_pagecache_hole(inode,
805 *hole_start << 9, *hole_end << 9, min_replicas, nonblock) >> 9;
806 if (ret < 0)
807 return ret;
808
809 *hole_start = ret;
810
811 if (*hole_start == *hole_end)
812 return 0;
813
814 ret = bch2_seek_pagecache_data(inode,
815 *hole_start << 9, *hole_end << 9, min_replicas, nonblock) >> 9;
816 if (ret < 0)
817 return ret;
818
819 *hole_end = ret;
820 return 0;
821 }
822
823 #endif /* NO_BCACHEFS_FS */
Linux Kernel