Merge branch 'etnaviv/fixes' of https://git.pengutronix.de/git/lst/linux into drm...
[linux-2.6-microblaze.git] / fs / squashfs / file.c
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
43 /*
44  * Locate cache slot in range [offset, index] for specified inode.  If
45  * there's more than one return the slot closest to index.
46  */
47 static struct meta_index *locate_meta_index(struct inode *inode, int offset,
48                                 int index)
49 {
50         struct meta_index *meta = NULL;
51         struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
52         int i;
53
54         mutex_lock(&msblk->meta_index_mutex);
55
56         TRACE("locate_meta_index: index %d, offset %d\n", index, offset);
57
58         if (msblk->meta_index == NULL)
59                 goto not_allocated;
60
61         for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
62                 if (msblk->meta_index[i].inode_number == inode->i_ino &&
63                                 msblk->meta_index[i].offset >= offset &&
64                                 msblk->meta_index[i].offset <= index &&
65                                 msblk->meta_index[i].locked == 0) {
66                         TRACE("locate_meta_index: entry %d, offset %d\n", i,
67                                         msblk->meta_index[i].offset);
68                         meta = &msblk->meta_index[i];
69                         offset = meta->offset;
70                 }
71         }
72
73         if (meta)
74                 meta->locked = 1;
75
76 not_allocated:
77         mutex_unlock(&msblk->meta_index_mutex);
78
79         return meta;
80 }
81
82
83 /*
84  * Find and initialise an empty cache slot for index offset.
85  */
86 static struct meta_index *empty_meta_index(struct inode *inode, int offset,
87                                 int skip)
88 {
89         struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
90         struct meta_index *meta = NULL;
91         int i;
92
93         mutex_lock(&msblk->meta_index_mutex);
94
95         TRACE("empty_meta_index: offset %d, skip %d\n", offset, skip);
96
97         if (msblk->meta_index == NULL) {
98                 /*
99                  * First time cache index has been used, allocate and
100                  * initialise.  The cache index could be allocated at
101                  * mount time but doing it here means it is allocated only
102                  * if a 'large' file is read.
103                  */
104                 msblk->meta_index = kcalloc(SQUASHFS_META_SLOTS,
105                         sizeof(*(msblk->meta_index)), GFP_KERNEL);
106                 if (msblk->meta_index == NULL) {
107                         ERROR("Failed to allocate meta_index\n");
108                         goto failed;
109                 }
110                 for (i = 0; i < SQUASHFS_META_SLOTS; i++) {
111                         msblk->meta_index[i].inode_number = 0;
112                         msblk->meta_index[i].locked = 0;
113                 }
114                 msblk->next_meta_index = 0;
115         }
116
117         for (i = SQUASHFS_META_SLOTS; i &&
118                         msblk->meta_index[msblk->next_meta_index].locked; i--)
119                 msblk->next_meta_index = (msblk->next_meta_index + 1) %
120                         SQUASHFS_META_SLOTS;
121
122         if (i == 0) {
123                 TRACE("empty_meta_index: failed!\n");
124                 goto failed;
125         }
126
127         TRACE("empty_meta_index: returned meta entry %d, %p\n",
128                         msblk->next_meta_index,
129                         &msblk->meta_index[msblk->next_meta_index]);
130
131         meta = &msblk->meta_index[msblk->next_meta_index];
132         msblk->next_meta_index = (msblk->next_meta_index + 1) %
133                         SQUASHFS_META_SLOTS;
134
135         meta->inode_number = inode->i_ino;
136         meta->offset = offset;
137         meta->skip = skip;
138         meta->entries = 0;
139         meta->locked = 1;
140
141 failed:
142         mutex_unlock(&msblk->meta_index_mutex);
143         return meta;
144 }
145
146
147 static void release_meta_index(struct inode *inode, struct meta_index *meta)
148 {
149         struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
150         mutex_lock(&msblk->meta_index_mutex);
151         meta->locked = 0;
152         mutex_unlock(&msblk->meta_index_mutex);
153 }
154
155
156 /*
157  * Read the next n blocks from the block list, starting from
158  * metadata block <start_block, offset>.
159  */
160 static long long read_indexes(struct super_block *sb, int n,
161                                 u64 *start_block, int *offset)
162 {
163         int err, i;
164         long long block = 0;
165         __le32 *blist = kmalloc(PAGE_SIZE, GFP_KERNEL);
166
167         if (blist == NULL) {
168                 ERROR("read_indexes: Failed to allocate block_list\n");
169                 return -ENOMEM;
170         }
171
172         while (n) {
173                 int blocks = min_t(int, n, PAGE_SIZE >> 2);
174
175                 err = squashfs_read_metadata(sb, blist, start_block,
176                                 offset, blocks << 2);
177                 if (err < 0) {
178                         ERROR("read_indexes: reading block [%llx:%x]\n",
179                                 *start_block, *offset);
180                         goto failure;
181                 }
182
183                 for (i = 0; i < blocks; i++) {
184                         int size = squashfs_block_size(blist[i]);
185                         if (size < 0) {
186                                 err = size;
187                                 goto failure;
188                         }
189                         block += SQUASHFS_COMPRESSED_SIZE_BLOCK(size);
190                 }
191                 n -= blocks;
192         }
193
194         kfree(blist);
195         return block;
196
197 failure:
198         kfree(blist);
199         return err;
200 }
201
202
203 /*
204  * Each cache index slot has SQUASHFS_META_ENTRIES, each of which
205  * can cache one index -> datablock/blocklist-block mapping.  We wish
206  * to distribute these over the length of the file, entry[0] maps index x,
207  * entry[1] maps index x + skip, entry[2] maps index x + 2 * skip, and so on.
208  * The larger the file, the greater the skip factor.  The skip factor is
209  * limited to the size of the metadata cache (SQUASHFS_CACHED_BLKS) to ensure
210  * the number of metadata blocks that need to be read fits into the cache.
211  * If the skip factor is limited in this way then the file will use multiple
212  * slots.
213  */
214 static inline int calculate_skip(int blocks)
215 {
216         int skip = blocks / ((SQUASHFS_META_ENTRIES + 1)
217                  * SQUASHFS_META_INDEXES);
218         return min(SQUASHFS_CACHED_BLKS - 1, skip + 1);
219 }
220
221
222 /*
223  * Search and grow the index cache for the specified inode, returning the
224  * on-disk locations of the datablock and block list metadata block
225  * <index_block, index_offset> for index (scaled to nearest cache index).
226  */
227 static int fill_meta_index(struct inode *inode, int index,
228                 u64 *index_block, int *index_offset, u64 *data_block)
229 {
230         struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
231         int skip = calculate_skip(i_size_read(inode) >> msblk->block_log);
232         int offset = 0;
233         struct meta_index *meta;
234         struct meta_entry *meta_entry;
235         u64 cur_index_block = squashfs_i(inode)->block_list_start;
236         int cur_offset = squashfs_i(inode)->offset;
237         u64 cur_data_block = squashfs_i(inode)->start;
238         int err, i;
239
240         /*
241          * Scale index to cache index (cache slot entry)
242          */
243         index /= SQUASHFS_META_INDEXES * skip;
244
245         while (offset < index) {
246                 meta = locate_meta_index(inode, offset + 1, index);
247
248                 if (meta == NULL) {
249                         meta = empty_meta_index(inode, offset + 1, skip);
250                         if (meta == NULL)
251                                 goto all_done;
252                 } else {
253                         offset = index < meta->offset + meta->entries ? index :
254                                 meta->offset + meta->entries - 1;
255                         meta_entry = &meta->meta_entry[offset - meta->offset];
256                         cur_index_block = meta_entry->index_block +
257                                 msblk->inode_table;
258                         cur_offset = meta_entry->offset;
259                         cur_data_block = meta_entry->data_block;
260                         TRACE("get_meta_index: offset %d, meta->offset %d, "
261                                 "meta->entries %d\n", offset, meta->offset,
262                                 meta->entries);
263                         TRACE("get_meta_index: index_block 0x%llx, offset 0x%x"
264                                 " data_block 0x%llx\n", cur_index_block,
265                                 cur_offset, cur_data_block);
266                 }
267
268                 /*
269                  * If necessary grow cache slot by reading block list.  Cache
270                  * slot is extended up to index or to the end of the slot, in
271                  * which case further slots will be used.
272                  */
273                 for (i = meta->offset + meta->entries; i <= index &&
274                                 i < meta->offset + SQUASHFS_META_ENTRIES; i++) {
275                         int blocks = skip * SQUASHFS_META_INDEXES;
276                         long long res = read_indexes(inode->i_sb, blocks,
277                                         &cur_index_block, &cur_offset);
278
279                         if (res < 0) {
280                                 if (meta->entries == 0)
281                                         /*
282                                          * Don't leave an empty slot on read
283                                          * error allocated to this inode...
284                                          */
285                                         meta->inode_number = 0;
286                                 err = res;
287                                 goto failed;
288                         }
289
290                         cur_data_block += res;
291                         meta_entry = &meta->meta_entry[i - meta->offset];
292                         meta_entry->index_block = cur_index_block -
293                                 msblk->inode_table;
294                         meta_entry->offset = cur_offset;
295                         meta_entry->data_block = cur_data_block;
296                         meta->entries++;
297                         offset++;
298                 }
299
300                 TRACE("get_meta_index: meta->offset %d, meta->entries %d\n",
301                                 meta->offset, meta->entries);
302
303                 release_meta_index(inode, meta);
304         }
305
306 all_done:
307         *index_block = cur_index_block;
308         *index_offset = cur_offset;
309         *data_block = cur_data_block;
310
311         /*
312          * Scale cache index (cache slot entry) to index
313          */
314         return offset * SQUASHFS_META_INDEXES * skip;
315
316 failed:
317         release_meta_index(inode, meta);
318         return err;
319 }
320
321
322 /*
323  * Get the on-disk location and compressed size of the datablock
324  * specified by index.  Fill_meta_index() does most of the work.
325  */
326 static int read_blocklist(struct inode *inode, int index, u64 *block)
327 {
328         u64 start;
329         long long blks;
330         int offset;
331         __le32 size;
332         int res = fill_meta_index(inode, index, &start, &offset, block);
333
334         TRACE("read_blocklist: res %d, index %d, start 0x%llx, offset"
335                        " 0x%x, block 0x%llx\n", res, index, start, offset,
336                         *block);
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                 *block += blks;
352         }
353
354         /*
355          * Read length of block specified by index.
356          */
357         res = squashfs_read_metadata(inode->i_sb, &size, &start, &offset,
358                         sizeof(size));
359         if (res < 0)
360                 return res;
361         return squashfs_block_size(size);
362 }
363
364 void squashfs_fill_page(struct page *page, struct squashfs_cache_entry *buffer, int offset, int avail)
365 {
366         int copied;
367         void *pageaddr;
368
369         pageaddr = kmap_atomic(page);
370         copied = squashfs_copy_data(pageaddr, buffer, offset, avail);
371         memset(pageaddr + copied, 0, PAGE_SIZE - copied);
372         kunmap_atomic(pageaddr);
373
374         flush_dcache_page(page);
375         if (copied == avail)
376                 SetPageUptodate(page);
377         else
378                 SetPageError(page);
379 }
380
381 /* Copy data into page cache  */
382 void squashfs_copy_cache(struct page *page, struct squashfs_cache_entry *buffer,
383         int bytes, int offset)
384 {
385         struct inode *inode = page->mapping->host;
386         struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
387         int i, mask = (1 << (msblk->block_log - PAGE_SHIFT)) - 1;
388         int start_index = page->index & ~mask, end_index = start_index | mask;
389
390         /*
391          * Loop copying datablock into pages.  As the datablock likely covers
392          * many PAGE_SIZE pages (default block size is 128 KiB) explicitly
393          * grab the pages from the page cache, except for the page that we've
394          * been called to fill.
395          */
396         for (i = start_index; i <= end_index && bytes > 0; i++,
397                         bytes -= PAGE_SIZE, offset += PAGE_SIZE) {
398                 struct page *push_page;
399                 int avail = buffer ? min_t(int, bytes, PAGE_SIZE) : 0;
400
401                 TRACE("bytes %d, i %d, available_bytes %d\n", bytes, i, avail);
402
403                 push_page = (i == page->index) ? page :
404                         grab_cache_page_nowait(page->mapping, i);
405
406                 if (!push_page)
407                         continue;
408
409                 if (PageUptodate(push_page))
410                         goto skip_page;
411
412                 squashfs_fill_page(push_page, buffer, offset, avail);
413 skip_page:
414                 unlock_page(push_page);
415                 if (i != page->index)
416                         put_page(push_page);
417         }
418 }
419
420 /* Read datablock stored packed inside a fragment (tail-end packed block) */
421 static int squashfs_readpage_fragment(struct page *page, int expected)
422 {
423         struct inode *inode = page->mapping->host;
424         struct squashfs_cache_entry *buffer = squashfs_get_fragment(inode->i_sb,
425                 squashfs_i(inode)->fragment_block,
426                 squashfs_i(inode)->fragment_size);
427         int res = buffer->error;
428
429         if (res)
430                 ERROR("Unable to read page, block %llx, size %x\n",
431                         squashfs_i(inode)->fragment_block,
432                         squashfs_i(inode)->fragment_size);
433         else
434                 squashfs_copy_cache(page, buffer, expected,
435                         squashfs_i(inode)->fragment_offset);
436
437         squashfs_cache_put(buffer);
438         return res;
439 }
440
441 static int squashfs_readpage_sparse(struct page *page, int expected)
442 {
443         squashfs_copy_cache(page, NULL, expected, 0);
444         return 0;
445 }
446
447 static int squashfs_readpage(struct file *file, struct page *page)
448 {
449         struct inode *inode = page->mapping->host;
450         struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info;
451         int index = page->index >> (msblk->block_log - PAGE_SHIFT);
452         int file_end = i_size_read(inode) >> msblk->block_log;
453         int expected = index == file_end ?
454                         (i_size_read(inode) & (msblk->block_size - 1)) :
455                          msblk->block_size;
456         int res;
457         void *pageaddr;
458
459         TRACE("Entered squashfs_readpage, page index %lx, start block %llx\n",
460                                 page->index, squashfs_i(inode)->start);
461
462         if (page->index >= ((i_size_read(inode) + PAGE_SIZE - 1) >>
463                                         PAGE_SHIFT))
464                 goto out;
465
466         if (index < file_end || squashfs_i(inode)->fragment_block ==
467                                         SQUASHFS_INVALID_BLK) {
468                 u64 block = 0;
469                 int bsize = read_blocklist(inode, index, &block);
470                 if (bsize < 0)
471                         goto error_out;
472
473                 if (bsize == 0)
474                         res = squashfs_readpage_sparse(page, expected);
475                 else
476                         res = squashfs_readpage_block(page, block, bsize, expected);
477         } else
478                 res = squashfs_readpage_fragment(page, expected);
479
480         if (!res)
481                 return 0;
482
483 error_out:
484         SetPageError(page);
485 out:
486         pageaddr = kmap_atomic(page);
487         memset(pageaddr, 0, PAGE_SIZE);
488         kunmap_atomic(pageaddr);
489         flush_dcache_page(page);
490         if (!PageError(page))
491                 SetPageUptodate(page);
492         unlock_page(page);
493
494         return 0;
495 }
496
497
498 const struct address_space_operations squashfs_aops = {
499         .readpage = squashfs_readpage
500 };