1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Squashfs - a compressed read only filesystem for Linux
4 *
5 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
6 * Phillip Lougher <phillip@squashfs.org.uk>
7 *
8 * file.c
9 */
10
11 /*
12 * This file contains code for handling regular files. A regular file
13 * consists of a sequence of contiguous compressed blocks, and/or a
14 * compressed fragment block (tail-end packed block). The compressed size
15 * of each datablock is stored in a block list contained within the
16 * file inode (itself stored in one or more compressed metadata blocks).
17 *
18 * To speed up access to datablocks when reading 'large' files (256 Mbytes or
19 * larger), the code implements an index cache that caches the mapping from
20 * block index to datablock location on disk.
21 *
22 * The index cache allows Squashfs to handle large files (up to 1.75 TiB) while
23 * retaining a simple and space-efficient block list on disk. The cache
24 * is split into slots, caching up to eight 224 GiB files (128 KiB blocks).
25 * Larger files use multiple slots, with 1.75 TiB files using all 8 slots.
26 * The index cache is designed to be memory efficient, and by default uses
27 * 16 KiB.
28 */
29
30 #include <linux/fs.h>
31 #include <linux/vfs.h>
32 #include <linux/kernel.h>
33 #include <linux/slab.h>
34 #include <linux/string.h>
35 #include <linux/pagemap.h>
36 #include <linux/mutex.h>
37
38 #include "squashfs_fs.h"
39 #include "squashfs_fs_sb.h"
40 #include "squashfs_fs_i.h"
41 #include "squashfs.h"
42 #include "page_actor.h"
43
44 /*
45 * Locate cache slot in range [offset, index] for specified inode. If
46 * there's more than one return the slot closest to index.
47 */
locate_meta_index(struct inode * inode,int offset,int index)48 static struct meta_index *locate_meta_index(struct inode *inode, int offset,
49 int index)
50 {
51 struct meta_index *meta = NULL;
52 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
53 int i;
54
55 mutex_lock(&msblk->meta_index_mutex);
56
57 TRACE("locate_meta_index: index %d, offset %d\n", index, offset);
58
59 if (msblk->meta_index == NULL)
60 goto not_allocated;
61
62 for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
63 if (msblk->meta_index[i].inode_number == inode->i_ino &&
64 msblk->meta_index[i].offset >= offset &&
65 msblk->meta_index[i].offset <= index &&
66 msblk->meta_index[i].locked == 0) {
67 TRACE("locate_meta_index: entry %d, offset %d\n", i,
68 msblk->meta_index[i].offset);
69 meta = &msblk->meta_index[i];
70 offset = meta->offset;
71 }
72 }
73
74 if (meta)
75 meta->locked = 1;
76
77 not_allocated:
78 mutex_unlock(&msblk->meta_index_mutex);
79
80 return meta;
81 }
82
83
84 /*
85 * Find and initialise an empty cache slot for index offset.
86 */
empty_meta_index(struct inode * inode,int offset,int skip)87 static struct meta_index *empty_meta_index(struct inode *inode, int offset,
88 int skip)
89 {
90 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
91 struct meta_index *meta = NULL;
92 int i;
93
94 mutex_lock(&msblk->meta_index_mutex);
95
96 TRACE("empty_meta_index: offset %d, skip %d\n", offset, skip);
97
98 if (msblk->meta_index == NULL) {
99 /*
100 * First time cache index has been used, allocate and
101 * initialise. The cache index could be allocated at
102 * mount time but doing it here means it is allocated only
103 * if a 'large' file is read.
104 */
105 msblk->meta_index = kcalloc(SQUASHFS_META_SLOTS,
106 sizeof(*(msblk->meta_index)), GFP_KERNEL);
107 if (msblk->meta_index == NULL) {
108 ERROR("Failed to allocate meta_index\n");
109 goto failed;
110 }
111 for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
112 msblk->meta_index[i].inode_number = 0;
113 msblk->meta_index[i].locked = 0;
114 }
115 msblk->next_meta_index = 0;
116 }
117
118 for (i = SQUASHFS_META_SLOTS; i &&
119 msblk->meta_index[msblk->next_meta_index].locked; i--)
120 msblk->next_meta_index = (msblk->next_meta_index + 1) %
121 SQUASHFS_META_SLOTS;
122
123 if (i == 0) {
124 TRACE("empty_meta_index: failed!\n");
125 goto failed;
126 }
127
128 TRACE("empty_meta_index: returned meta entry %d, %p\n",
129 msblk->next_meta_index,
130 &msblk->meta_index[msblk->next_meta_index]);
131
132 meta = &msblk->meta_index[msblk->next_meta_index];
133 msblk->next_meta_index = (msblk->next_meta_index + 1) %
134 SQUASHFS_META_SLOTS;
135
136 meta->inode_number = inode->i_ino;
137 meta->offset = offset;
138 meta->skip = skip;
139 meta->entries = 0;
140 meta->locked = 1;
141
142 failed:
143 mutex_unlock(&msblk->meta_index_mutex);
144 return meta;
145 }
146
147
release_meta_index(struct inode * inode,struct meta_index * meta)148 static void release_meta_index(struct inode *inode, struct meta_index *meta)
149 {
150 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
151 mutex_lock(&msblk->meta_index_mutex);
152 meta->locked = 0;
153 mutex_unlock(&msblk->meta_index_mutex);
154 }
155
156
157 /*
158 * Read the next n blocks from the block list, starting from
159 * metadata block <start_block, offset>.
160 */
read_indexes(struct super_block * sb,int n,u64 * start_block,int * offset)161 static long long read_indexes(struct super_block *sb, int n,
162 u64 *start_block, int *offset)
163 {
164 int err, i;
165 long long block = 0;
166 __le32 *blist = kmalloc(PAGE_SIZE, GFP_KERNEL);
167
168 if (blist == NULL) {
169 ERROR("read_indexes: Failed to allocate block_list\n");
170 return -ENOMEM;
171 }
172
173 while (n) {
174 int blocks = min_t(int, n, PAGE_SIZE >> 2);
175
176 err = squashfs_read_metadata(sb, blist, start_block,
177 offset, blocks << 2);
178 if (err < 0) {
179 ERROR("read_indexes: reading block [%llx:%x]\n",
180 *start_block, *offset);
181 goto failure;
182 }
183
184 for (i = 0; i < blocks; i++) {
185 int size = squashfs_block_size(blist[i]);
186 if (size < 0) {
187 err = size;
188 goto failure;
189 }
190 block += SQUASHFS_COMPRESSED_SIZE_BLOCK(size);
191 }
192 n -= blocks;
193 }
194
195 kfree(blist);
196 return block;
197
198 failure:
199 kfree(blist);
200 return err;
201 }
202
203
204 /*
205 * Each cache index slot has SQUASHFS_META_ENTRIES, each of which
206 * can cache one index -> datablock/blocklist-block mapping. We wish
207 * to distribute these over the length of the file, entry[0] maps index x,
208 * entry[1] maps index x + skip, entry[2] maps index x + 2 * skip, and so on.
209 * The larger the file, the greater the skip factor. The skip factor is
210 * limited to the size of the metadata cache (SQUASHFS_CACHED_BLKS) to ensure
211 * the number of metadata blocks that need to be read fits into the cache.
212 * If the skip factor is limited in this way then the file will use multiple
213 * slots.
214 */
calculate_skip(u64 blocks)215 static inline int calculate_skip(u64 blocks)
216 {
217 u64 skip = blocks / ((SQUASHFS_META_ENTRIES + 1)
218 * SQUASHFS_META_INDEXES);
219 return min((u64) SQUASHFS_CACHED_BLKS - 1, skip + 1);
220 }
221
222
223 /*
224 * Search and grow the index cache for the specified inode, returning the
225 * on-disk locations of the datablock and block list metadata block
226 * <index_block, index_offset> for index (scaled to nearest cache index).
227 */
fill_meta_index(struct inode * inode,int index,u64 * index_block,int * index_offset,u64 * data_block)228 static int fill_meta_index(struct inode *inode, int index,
229 u64 *index_block, int *index_offset, u64 *data_block)
230 {
231 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
232 int skip = calculate_skip(i_size_read(inode) >> msblk->block_log);
233 int offset = 0;
234 struct meta_index *meta;
235 struct meta_entry *meta_entry;
236 u64 cur_index_block = squashfs_i(inode)->block_list_start;
237 int cur_offset = squashfs_i(inode)->offset;
238 u64 cur_data_block = squashfs_i(inode)->start;
239 int err, i;
240
241 /*
242 * Scale index to cache index (cache slot entry)
243 */
244 index /= SQUASHFS_META_INDEXES * skip;
245
246 while (offset < index) {
247 meta = locate_meta_index(inode, offset + 1, index);
248
249 if (meta == NULL) {
250 meta = empty_meta_index(inode, offset + 1, skip);
251 if (meta == NULL)
252 goto all_done;
253 } else {
254 offset = index < meta->offset + meta->entries ? index :
255 meta->offset + meta->entries - 1;
256 meta_entry = &meta->meta_entry[offset - meta->offset];
257 cur_index_block = meta_entry->index_block +
258 msblk->inode_table;
259 cur_offset = meta_entry->offset;
260 cur_data_block = meta_entry->data_block;
261 TRACE("get_meta_index: offset %d, meta->offset %d, "
262 "meta->entries %d\n", offset, meta->offset,
263 meta->entries);
264 TRACE("get_meta_index: index_block 0x%llx, offset 0x%x"
265 " data_block 0x%llx\n", cur_index_block,
266 cur_offset, cur_data_block);
267 }
268
269 /*
270 * If necessary grow cache slot by reading block list. Cache
271 * slot is extended up to index or to the end of the slot, in
272 * which case further slots will be used.
273 */
274 for (i = meta->offset + meta->entries; i <= index &&
275 i < meta->offset + SQUASHFS_META_ENTRIES; i++) {
276 int blocks = skip * SQUASHFS_META_INDEXES;
277 long long res = read_indexes(inode->i_sb, blocks,
278 &cur_index_block, &cur_offset);
279
280 if (res < 0) {
281 if (meta->entries == 0)
282 /*
283 * Don't leave an empty slot on read
284 * error allocated to this inode...
285 */
286 meta->inode_number = 0;
287 err = res;
288 goto failed;
289 }
290
291 cur_data_block += res;
292 meta_entry = &meta->meta_entry[i - meta->offset];
293 meta_entry->index_block = cur_index_block -
294 msblk->inode_table;
295 meta_entry->offset = cur_offset;
296 meta_entry->data_block = cur_data_block;
297 meta->entries++;
298 offset++;
299 }
300
301 TRACE("get_meta_index: meta->offset %d, meta->entries %d\n",
302 meta->offset, meta->entries);
303
304 release_meta_index(inode, meta);
305 }
306
307 all_done:
308 *index_block = cur_index_block;
309 *index_offset = cur_offset;
310 if (data_block)
311 *data_block = cur_data_block;
312
313 /*
314 * Scale cache index (cache slot entry) to index
315 */
316 return offset * SQUASHFS_META_INDEXES * skip;
317
318 failed:
319 release_meta_index(inode, meta);
320 return err;
321 }
322
323
324 /*
325 * Get the on-disk location and compressed size of the datablock
326 * specified by index. Fill_meta_index() does most of the work.
327 */
read_blocklist_ptrs(struct inode * inode,int index,u64 * start,int * offset,u64 * block)328 static int read_blocklist_ptrs(struct inode *inode, int index, u64 *start,
329 int *offset, u64 *block)
330 {
331 long long blks;
332 __le32 size;
333 int res = fill_meta_index(inode, index, start, offset, block);
334
335 TRACE("read_blocklist: res %d, index %d, start 0x%llx, offset 0x%x, block 0x%llx\n",
336 res, index, *start, *offset, block ? *block : 0);
337
338 if (res < 0)
339 return res;
340
341 /*
342 * res contains the index of the mapping returned by fill_meta_index(),
343 * this will likely be less than the desired index (because the
344 * meta_index cache works at a higher granularity). Read any
345 * extra block indexes needed.
346 */
347 if (res < index) {
348 blks = read_indexes(inode->i_sb, index - res, start, offset);
349 if (blks < 0)
350 return (int) blks;
351 if (block)
352 *block += blks;
353 }
354
355 /*
356 * Read length of block specified by index.
357 */
358 res = squashfs_read_metadata(inode->i_sb, &size, start, offset,
359 sizeof(size));
360 if (res < 0)
361 return res;
362 return squashfs_block_size(size);
363 }
364
read_blocklist(struct inode * inode,int index,u64 * block)365 static inline int read_blocklist(struct inode *inode, int index, u64 *block)
366 {
367 u64 start;
368 int offset;
369
370 return read_blocklist_ptrs(inode, index, &start, &offset, block);
371 }
372
squashfs_fill_page(struct folio * folio,struct squashfs_cache_entry * buffer,size_t offset,size_t avail)373 static bool squashfs_fill_page(struct folio *folio,
374 struct squashfs_cache_entry *buffer, size_t offset,
375 size_t avail)
376 {
377 size_t copied;
378 void *pageaddr;
379
380 pageaddr = kmap_local_folio(folio, 0);
381 copied = squashfs_copy_data(pageaddr, buffer, offset, avail);
382 memset(pageaddr + copied, 0, PAGE_SIZE - copied);
383 kunmap_local(pageaddr);
384
385 flush_dcache_folio(folio);
386
387 return copied == avail;
388 }
389
390 /* Copy data into page cache */
squashfs_copy_cache(struct folio * folio,struct squashfs_cache_entry * buffer,size_t bytes,size_t offset)391 void squashfs_copy_cache(struct folio *folio,
392 struct squashfs_cache_entry *buffer, size_t bytes,
393 size_t offset)
394 {
395 struct address_space *mapping = folio->mapping;
396 struct inode *inode = mapping->host;
397 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
398 int i, mask = (1 << (msblk->block_log - PAGE_SHIFT)) - 1;
399 int start_index = folio->index & ~mask, end_index = start_index | mask;
400
401 /*
402 * Loop copying datablock into pages. As the datablock likely covers
403 * many PAGE_SIZE pages (default block size is 128 KiB) explicitly
404 * grab the pages from the page cache, except for the page that we've
405 * been called to fill.
406 */
407 for (i = start_index; i <= end_index && bytes > 0; i++,
408 bytes -= PAGE_SIZE, offset += PAGE_SIZE) {
409 struct folio *push_folio;
410 size_t avail = buffer ? min(bytes, PAGE_SIZE) : 0;
411 bool updated = false;
412
413 TRACE("bytes %zu, i %d, available_bytes %zu\n", bytes, i, avail);
414
415 push_folio = (i == folio->index) ? folio :
416 __filemap_get_folio(mapping, i,
417 FGP_LOCK|FGP_CREAT|FGP_NOFS|FGP_NOWAIT,
418 mapping_gfp_mask(mapping));
419
420 if (IS_ERR(push_folio))
421 continue;
422
423 if (folio_test_uptodate(push_folio))
424 goto skip_folio;
425
426 updated = squashfs_fill_page(push_folio, buffer, offset, avail);
427 skip_folio:
428 folio_end_read(push_folio, updated);
429 if (i != folio->index)
430 folio_put(push_folio);
431 }
432 }
433
434 /* Read datablock stored packed inside a fragment (tail-end packed block) */
squashfs_readpage_fragment(struct folio * folio,int expected)435 static int squashfs_readpage_fragment(struct folio *folio, int expected)
436 {
437 struct inode *inode = folio->mapping->host;
438 struct squashfs_cache_entry *buffer = squashfs_get_fragment(inode->i_sb,
439 squashfs_i(inode)->fragment_block,
440 squashfs_i(inode)->fragment_size);
441 int res = buffer->error;
442
443 if (res)
444 ERROR("Unable to read page, block %llx, size %x\n",
445 squashfs_i(inode)->fragment_block,
446 squashfs_i(inode)->fragment_size);
447 else
448 squashfs_copy_cache(folio, buffer, expected,
449 squashfs_i(inode)->fragment_offset);
450
451 squashfs_cache_put(buffer);
452 return res;
453 }
454
squashfs_readpage_sparse(struct folio * folio,int expected)455 static int squashfs_readpage_sparse(struct folio *folio, int expected)
456 {
457 squashfs_copy_cache(folio, NULL, expected, 0);
458 return 0;
459 }
460
squashfs_read_folio(struct file * file,struct folio * folio)461 static int squashfs_read_folio(struct file *file, struct folio *folio)
462 {
463 struct inode *inode = folio->mapping->host;
464 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
465 int index = folio->index >> (msblk->block_log - PAGE_SHIFT);
466 int file_end = i_size_read(inode) >> msblk->block_log;
467 int expected = index == file_end ?
468 (i_size_read(inode) & (msblk->block_size - 1)) :
469 msblk->block_size;
470 int res = 0;
471
472 TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n",
473 folio->index, squashfs_i(inode)->start);
474
475 if (folio->index >= ((i_size_read(inode) + PAGE_SIZE - 1) >>
476 PAGE_SHIFT))
477 goto out;
478
479 if (index < file_end || squashfs_i(inode)->fragment_block ==
480 SQUASHFS_INVALID_BLK) {
481 u64 block = 0;
482
483 res = read_blocklist(inode, index, &block);
484 if (res < 0)
485 goto out;
486
487 if (res == 0)
488 res = squashfs_readpage_sparse(folio, expected);
489 else
490 res = squashfs_readpage_block(folio, block, res, expected);
491 } else
492 res = squashfs_readpage_fragment(folio, expected);
493
494 if (!res)
495 return 0;
496
497 out:
498 folio_zero_segment(folio, 0, folio_size(folio));
499 folio_end_read(folio, res == 0);
500
501 return res;
502 }
503
squashfs_readahead_fragment(struct inode * inode,struct page ** page,unsigned int pages,unsigned int expected,loff_t start)504 static int squashfs_readahead_fragment(struct inode *inode, struct page **page,
505 unsigned int pages, unsigned int expected, loff_t start)
506 {
507 struct squashfs_cache_entry *buffer = squashfs_get_fragment(inode->i_sb,
508 squashfs_i(inode)->fragment_block,
509 squashfs_i(inode)->fragment_size);
510 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
511 int i, bytes, copied;
512 struct squashfs_page_actor *actor;
513 unsigned int offset;
514 void *addr;
515 struct page *last_page;
516
517 if (buffer->error)
518 goto out;
519
520 actor = squashfs_page_actor_init_special(msblk, page, pages,
521 expected, start);
522 if (!actor)
523 goto out;
524
525 squashfs_actor_nobuff(actor);
526 addr = squashfs_first_page(actor);
527
528 for (copied = offset = 0; offset < expected; offset += PAGE_SIZE) {
529 int avail = min_t(int, expected - offset, PAGE_SIZE);
530
531 if (!IS_ERR(addr)) {
532 bytes = squashfs_copy_data(addr, buffer, offset +
533 squashfs_i(inode)->fragment_offset, avail);
534
535 if (bytes != avail)
536 goto failed;
537 }
538
539 copied += avail;
540 addr = squashfs_next_page(actor);
541 }
542
543 last_page = squashfs_page_actor_free(actor);
544
545 if (copied == expected && !IS_ERR(last_page)) {
546 /* Last page (if present) may have trailing bytes not filled */
547 bytes = copied % PAGE_SIZE;
548 if (bytes && last_page)
549 memzero_page(last_page, bytes, PAGE_SIZE - bytes);
550
551 for (i = 0; i < pages; i++) {
552 flush_dcache_page(page[i]);
553 SetPageUptodate(page[i]);
554 }
555 }
556
557 for (i = 0; i < pages; i++) {
558 unlock_page(page[i]);
559 put_page(page[i]);
560 }
561
562 squashfs_cache_put(buffer);
563 return 0;
564
565 failed:
566 squashfs_page_actor_free(actor);
567
568 out:
569 squashfs_cache_put(buffer);
570 return 1;
571 }
572
squashfs_readahead(struct readahead_control * ractl)573 static void squashfs_readahead(struct readahead_control *ractl)
574 {
575 struct inode *inode = ractl->mapping->host;
576 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
577 size_t mask = (1UL << msblk->block_log) - 1;
578 unsigned short shift = msblk->block_log - PAGE_SHIFT;
579 loff_t start = readahead_pos(ractl) & ~mask;
580 size_t len = readahead_length(ractl) + readahead_pos(ractl) - start;
581 struct squashfs_page_actor *actor;
582 unsigned int nr_pages = 0;
583 struct page **pages;
584 int i;
585 loff_t file_end = i_size_read(inode) >> msblk->block_log;
586 unsigned int max_pages = 1UL << shift;
587
588 readahead_expand(ractl, start, (len | mask) + 1);
589
590 pages = kmalloc_array(max_pages, sizeof(void *), GFP_KERNEL);
591 if (!pages)
592 return;
593
594 for (;;) {
595 int res, bsize;
596 u64 block = 0;
597 unsigned int expected;
598 struct page *last_page;
599
600 expected = start >> msblk->block_log == file_end ?
601 (i_size_read(inode) & (msblk->block_size - 1)) :
602 msblk->block_size;
603
604 max_pages = (expected + PAGE_SIZE - 1) >> PAGE_SHIFT;
605
606 nr_pages = __readahead_batch(ractl, pages, max_pages);
607 if (!nr_pages)
608 break;
609
610 if (readahead_pos(ractl) >= i_size_read(inode))
611 goto skip_pages;
612
613 if (start >> msblk->block_log == file_end &&
614 squashfs_i(inode)->fragment_block != SQUASHFS_INVALID_BLK) {
615 res = squashfs_readahead_fragment(inode, pages,
616 nr_pages, expected, start);
617 if (res)
618 goto skip_pages;
619 continue;
620 }
621
622 bsize = read_blocklist(inode, start >> msblk->block_log, &block);
623 if (bsize == 0)
624 goto skip_pages;
625
626 actor = squashfs_page_actor_init_special(msblk, pages, nr_pages,
627 expected, start);
628 if (!actor)
629 goto skip_pages;
630
631 res = squashfs_read_data(inode->i_sb, block, bsize, NULL, actor);
632
633 last_page = squashfs_page_actor_free(actor);
634
635 if (res == expected && !IS_ERR(last_page)) {
636 int bytes;
637
638 /* Last page (if present) may have trailing bytes not filled */
639 bytes = res % PAGE_SIZE;
640 if (start >> msblk->block_log == file_end && bytes && last_page)
641 memzero_page(last_page, bytes,
642 PAGE_SIZE - bytes);
643
644 for (i = 0; i < nr_pages; i++) {
645 flush_dcache_page(pages[i]);
646 SetPageUptodate(pages[i]);
647 }
648 }
649
650 for (i = 0; i < nr_pages; i++) {
651 unlock_page(pages[i]);
652 put_page(pages[i]);
653 }
654
655 start += readahead_batch_length(ractl);
656 }
657
658 kfree(pages);
659 return;
660
661 skip_pages:
662 for (i = 0; i < nr_pages; i++) {
663 unlock_page(pages[i]);
664 put_page(pages[i]);
665 }
666 kfree(pages);
667 }
668
seek_hole_data(struct file * file,loff_t offset,int whence)669 static loff_t seek_hole_data(struct file *file, loff_t offset, int whence)
670 {
671 struct inode *inode = file->f_mapping->host;
672 struct super_block *sb = inode->i_sb;
673 struct squashfs_sb_info *msblk = sb->s_fs_info;
674 u64 start, index = offset >> msblk->block_log;
675 u64 file_end = (i_size_read(inode) + msblk->block_size - 1) >> msblk->block_log;
676 int s_offset, length;
677 __le32 *blist = NULL;
678
679 /* reject offset if negative or beyond file end */
680 if ((unsigned long long)offset >= i_size_read(inode))
681 return -ENXIO;
682
683 /* is offset within tailend and is tailend packed into a fragment? */
684 if (index + 1 == file_end &&
685 squashfs_i(inode)->fragment_block != SQUASHFS_INVALID_BLK) {
686 if (whence == SEEK_DATA)
687 return offset;
688
689 /* there is an implicit hole at the end of any file */
690 return i_size_read(inode);
691 }
692
693 length = read_blocklist_ptrs(inode, index, &start, &s_offset, NULL);
694 if (length < 0)
695 return length;
696
697 /* nothing more to do if offset matches desired whence value */
698 if ((length == 0 && whence == SEEK_HOLE) ||
699 (length && whence == SEEK_DATA))
700 return offset;
701
702 /* skip scanning forwards if we're at file end */
703 if (++ index == file_end)
704 goto not_found;
705
706 blist = kmalloc(SQUASHFS_SCAN_INDEXES << 2, GFP_KERNEL);
707 if (blist == NULL) {
708 ERROR("%s: Failed to allocate block_list\n", __func__);
709 return -ENOMEM;
710 }
711
712 while (index < file_end) {
713 int i, indexes = min(file_end - index, SQUASHFS_SCAN_INDEXES);
714
715 offset = squashfs_read_metadata(sb, blist, &start, &s_offset, indexes << 2);
716 if (offset < 0)
717 goto finished;
718
719 for (i = 0; i < indexes; i++) {
720 length = squashfs_block_size(blist[i]);
721 if (length < 0) {
722 offset = length;
723 goto finished;
724 }
725
726 /* does this block match desired whence value? */
727 if ((length == 0 && whence == SEEK_HOLE) ||
728 (length && whence == SEEK_DATA)) {
729 offset = (index + i) << msblk->block_log;
730 goto finished;
731 }
732 }
733
734 index += indexes;
735 }
736
737 not_found:
738 /* whence value determines what happens */
739 if (whence == SEEK_DATA)
740 offset = -ENXIO;
741 else
742 /* there is an implicit hole at the end of any file */
743 offset = i_size_read(inode);
744
745 finished:
746 kfree(blist);
747 return offset;
748 }
749
squashfs_llseek(struct file * file,loff_t offset,int whence)750 static loff_t squashfs_llseek(struct file *file, loff_t offset, int whence)
751 {
752 struct inode *inode = file->f_mapping->host;
753
754 switch (whence) {
755 default:
756 return generic_file_llseek(file, offset, whence);
757 case SEEK_DATA:
758 case SEEK_HOLE:
759 offset = seek_hole_data(file, offset, whence);
760 break;
761 }
762
763 if (offset < 0)
764 return offset;
765
766 return vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
767 }
768
769 const struct address_space_operations squashfs_aops = {
770 .read_folio = squashfs_read_folio,
771 .readahead = squashfs_readahead
772 };
773
774 const struct file_operations squashfs_file_operations = {
775 .llseek = squashfs_llseek,
776 .read_iter = generic_file_read_iter,
777 .mmap_prepare = generic_file_readonly_mmap_prepare,
778 .splice_read = filemap_splice_read
779 };
780