1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Squashfs - a compressed read only filesystem for Linux
5 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
6 * Phillip Lougher <phillip@squashfs.org.uk>
12 * This file implements code to read the superblock, read and initialise
13 * in-memory structures at mount time, and all the VFS glue code to register
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <linux/fs_context.h>
21 #include <linux/fs_parser.h>
22 #include <linux/vfs.h>
23 #include <linux/slab.h>
24 #include <linux/mutex.h>
25 #include <linux/seq_file.h>
26 #include <linux/pagemap.h>
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <linux/magic.h>
30 #include <linux/xattr.h>
32 #include "squashfs_fs.h"
33 #include "squashfs_fs_sb.h"
34 #include "squashfs_fs_i.h"
36 #include "decompressor.h"
39 static struct file_system_type squashfs_fs_type
;
40 static const struct super_operations squashfs_super_ops
;
51 struct squashfs_mount_opts
{
52 enum Opt_errors errors
;
55 static const struct constant_table squashfs_param_errors
[] = {
56 {"continue", Opt_errors_continue
},
57 {"panic", Opt_errors_panic
},
61 static const struct fs_parameter_spec squashfs_fs_parameters
[] = {
62 fsparam_enum("errors", Opt_errors
, squashfs_param_errors
),
66 static int squashfs_parse_param(struct fs_context
*fc
, struct fs_parameter
*param
)
68 struct squashfs_mount_opts
*opts
= fc
->fs_private
;
69 struct fs_parse_result result
;
72 opt
= fs_parse(fc
, squashfs_fs_parameters
, param
, &result
);
78 opts
->errors
= result
.uint_32
;
87 static const struct squashfs_decompressor
*supported_squashfs_filesystem(
88 struct fs_context
*fc
,
89 short major
, short minor
, short id
)
91 const struct squashfs_decompressor
*decompressor
;
93 if (major
< SQUASHFS_MAJOR
) {
94 errorf(fc
, "Major/Minor mismatch, older Squashfs %d.%d "
95 "filesystems are unsupported", major
, minor
);
97 } else if (major
> SQUASHFS_MAJOR
|| minor
> SQUASHFS_MINOR
) {
98 errorf(fc
, "Major/Minor mismatch, trying to mount newer "
99 "%d.%d filesystem", major
, minor
);
100 errorf(fc
, "Please update your kernel");
104 decompressor
= squashfs_lookup_decompressor(id
);
105 if (!decompressor
->supported
) {
106 errorf(fc
, "Filesystem uses \"%s\" compression. This is not supported",
115 static int squashfs_fill_super(struct super_block
*sb
, struct fs_context
*fc
)
117 struct squashfs_mount_opts
*opts
= fc
->fs_private
;
118 struct squashfs_sb_info
*msblk
;
119 struct squashfs_super_block
*sblk
= NULL
;
121 long long root_inode
;
122 unsigned short flags
;
123 unsigned int fragments
;
124 u64 lookup_table_start
, xattr_id_table_start
, next_table
;
127 TRACE("Entered squashfs_fill_superblock\n");
129 sb
->s_fs_info
= kzalloc(sizeof(*msblk
), GFP_KERNEL
);
130 if (sb
->s_fs_info
== NULL
) {
131 ERROR("Failed to allocate squashfs_sb_info\n");
134 msblk
= sb
->s_fs_info
;
136 msblk
->panic_on_errors
= (opts
->errors
== Opt_errors_panic
);
138 msblk
->devblksize
= sb_min_blocksize(sb
, SQUASHFS_DEVBLK_SIZE
);
139 msblk
->devblksize_log2
= ffz(~msblk
->devblksize
);
141 mutex_init(&msblk
->meta_index_mutex
);
144 * msblk->bytes_used is checked in squashfs_read_table to ensure reads
145 * are not beyond filesystem end. But as we're using
146 * squashfs_read_table here to read the superblock (including the value
147 * of bytes_used) we need to set it to an initial sensible dummy value
149 msblk
->bytes_used
= sizeof(*sblk
);
150 sblk
= squashfs_read_table(sb
, SQUASHFS_START
, sizeof(*sblk
));
153 errorf(fc
, "unable to read squashfs_super_block");
161 /* Check it is a SQUASHFS superblock */
162 sb
->s_magic
= le32_to_cpu(sblk
->s_magic
);
163 if (sb
->s_magic
!= SQUASHFS_MAGIC
) {
164 if (!(fc
->sb_flags
& SB_SILENT
))
165 errorf(fc
, "Can't find a SQUASHFS superblock on %pg",
170 /* Check the MAJOR & MINOR versions and lookup compression type */
171 msblk
->decompressor
= supported_squashfs_filesystem(
173 le16_to_cpu(sblk
->s_major
),
174 le16_to_cpu(sblk
->s_minor
),
175 le16_to_cpu(sblk
->compression
));
176 if (msblk
->decompressor
== NULL
)
179 /* Check the filesystem does not extend beyond the end of the
181 msblk
->bytes_used
= le64_to_cpu(sblk
->bytes_used
);
182 if (msblk
->bytes_used
< 0 || msblk
->bytes_used
>
183 i_size_read(sb
->s_bdev
->bd_inode
))
186 /* Check block size for sanity */
187 msblk
->block_size
= le32_to_cpu(sblk
->block_size
);
188 if (msblk
->block_size
> SQUASHFS_FILE_MAX_SIZE
)
192 * Check the system page size is not larger than the filesystem
193 * block size (by default 128K). This is currently not supported.
195 if (PAGE_SIZE
> msblk
->block_size
) {
196 errorf(fc
, "Page size > filesystem block size (%d). This is "
197 "currently not supported!", msblk
->block_size
);
201 /* Check block log for sanity */
202 msblk
->block_log
= le16_to_cpu(sblk
->block_log
);
203 if (msblk
->block_log
> SQUASHFS_FILE_MAX_LOG
)
206 /* Check that block_size and block_log match */
207 if (msblk
->block_size
!= (1 << msblk
->block_log
))
210 /* Check the root inode for sanity */
211 root_inode
= le64_to_cpu(sblk
->root_inode
);
212 if (SQUASHFS_INODE_OFFSET(root_inode
) > SQUASHFS_METADATA_SIZE
)
215 msblk
->inode_table
= le64_to_cpu(sblk
->inode_table_start
);
216 msblk
->directory_table
= le64_to_cpu(sblk
->directory_table_start
);
217 msblk
->inodes
= le32_to_cpu(sblk
->inodes
);
218 msblk
->fragments
= le32_to_cpu(sblk
->fragments
);
219 msblk
->ids
= le16_to_cpu(sblk
->no_ids
);
220 flags
= le16_to_cpu(sblk
->flags
);
222 TRACE("Found valid superblock on %pg\n", sb
->s_bdev
);
223 TRACE("Inodes are %scompressed\n", SQUASHFS_UNCOMPRESSED_INODES(flags
)
225 TRACE("Data is %scompressed\n", SQUASHFS_UNCOMPRESSED_DATA(flags
)
227 TRACE("Filesystem size %lld bytes\n", msblk
->bytes_used
);
228 TRACE("Block size %d\n", msblk
->block_size
);
229 TRACE("Number of inodes %d\n", msblk
->inodes
);
230 TRACE("Number of fragments %d\n", msblk
->fragments
);
231 TRACE("Number of ids %d\n", msblk
->ids
);
232 TRACE("sblk->inode_table_start %llx\n", msblk
->inode_table
);
233 TRACE("sblk->directory_table_start %llx\n", msblk
->directory_table
);
234 TRACE("sblk->fragment_table_start %llx\n",
235 (u64
) le64_to_cpu(sblk
->fragment_table_start
));
236 TRACE("sblk->id_table_start %llx\n",
237 (u64
) le64_to_cpu(sblk
->id_table_start
));
239 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
241 sb
->s_time_max
= U32_MAX
;
242 sb
->s_flags
|= SB_RDONLY
;
243 sb
->s_op
= &squashfs_super_ops
;
247 msblk
->block_cache
= squashfs_cache_init("metadata",
248 SQUASHFS_CACHED_BLKS
, SQUASHFS_METADATA_SIZE
);
249 if (msblk
->block_cache
== NULL
)
252 /* Allocate read_page block */
253 msblk
->read_page
= squashfs_cache_init("data",
254 squashfs_max_decompressors(), msblk
->block_size
);
255 if (msblk
->read_page
== NULL
) {
256 errorf(fc
, "Failed to allocate read_page block");
260 msblk
->stream
= squashfs_decompressor_setup(sb
, flags
);
261 if (IS_ERR(msblk
->stream
)) {
262 err
= PTR_ERR(msblk
->stream
);
263 msblk
->stream
= NULL
;
268 sb
->s_xattr
= squashfs_xattr_handlers
;
269 xattr_id_table_start
= le64_to_cpu(sblk
->xattr_id_table_start
);
270 if (xattr_id_table_start
== SQUASHFS_INVALID_BLK
) {
271 next_table
= msblk
->bytes_used
;
272 goto allocate_id_index_table
;
275 /* Allocate and read xattr id lookup table */
276 msblk
->xattr_id_table
= squashfs_read_xattr_id_table(sb
,
277 xattr_id_table_start
, &msblk
->xattr_table
, &msblk
->xattr_ids
);
278 if (IS_ERR(msblk
->xattr_id_table
)) {
279 errorf(fc
, "unable to read xattr id index table");
280 err
= PTR_ERR(msblk
->xattr_id_table
);
281 msblk
->xattr_id_table
= NULL
;
282 if (err
!= -ENOTSUPP
)
285 next_table
= msblk
->xattr_table
;
287 allocate_id_index_table
:
288 /* Allocate and read id index table */
289 msblk
->id_table
= squashfs_read_id_index_table(sb
,
290 le64_to_cpu(sblk
->id_table_start
), next_table
, msblk
->ids
);
291 if (IS_ERR(msblk
->id_table
)) {
292 errorf(fc
, "unable to read id index table");
293 err
= PTR_ERR(msblk
->id_table
);
294 msblk
->id_table
= NULL
;
297 next_table
= le64_to_cpu(msblk
->id_table
[0]);
299 /* Handle inode lookup table */
300 lookup_table_start
= le64_to_cpu(sblk
->lookup_table_start
);
301 if (lookup_table_start
== SQUASHFS_INVALID_BLK
)
302 goto handle_fragments
;
304 /* Allocate and read inode lookup table */
305 msblk
->inode_lookup_table
= squashfs_read_inode_lookup_table(sb
,
306 lookup_table_start
, next_table
, msblk
->inodes
);
307 if (IS_ERR(msblk
->inode_lookup_table
)) {
308 errorf(fc
, "unable to read inode lookup table");
309 err
= PTR_ERR(msblk
->inode_lookup_table
);
310 msblk
->inode_lookup_table
= NULL
;
313 next_table
= le64_to_cpu(msblk
->inode_lookup_table
[0]);
315 sb
->s_export_op
= &squashfs_export_ops
;
318 fragments
= msblk
->fragments
;
320 goto check_directory_table
;
322 msblk
->fragment_cache
= squashfs_cache_init("fragment",
323 SQUASHFS_CACHED_FRAGMENTS
, msblk
->block_size
);
324 if (msblk
->fragment_cache
== NULL
) {
329 /* Allocate and read fragment index table */
330 msblk
->fragment_index
= squashfs_read_fragment_index_table(sb
,
331 le64_to_cpu(sblk
->fragment_table_start
), next_table
, fragments
);
332 if (IS_ERR(msblk
->fragment_index
)) {
333 errorf(fc
, "unable to read fragment index table");
334 err
= PTR_ERR(msblk
->fragment_index
);
335 msblk
->fragment_index
= NULL
;
338 next_table
= le64_to_cpu(msblk
->fragment_index
[0]);
340 check_directory_table
:
341 /* Sanity check directory_table */
342 if (msblk
->directory_table
> next_table
) {
347 /* Sanity check inode_table */
348 if (msblk
->inode_table
>= msblk
->directory_table
) {
354 root
= new_inode(sb
);
360 err
= squashfs_read_inode(root
, root_inode
);
362 make_bad_inode(root
);
366 insert_inode_hash(root
);
368 sb
->s_root
= d_make_root(root
);
369 if (sb
->s_root
== NULL
) {
370 ERROR("Root inode create failed\n");
375 TRACE("Leaving squashfs_fill_super\n");
380 errorf(fc
, "squashfs image failed sanity check");
382 squashfs_cache_delete(msblk
->block_cache
);
383 squashfs_cache_delete(msblk
->fragment_cache
);
384 squashfs_cache_delete(msblk
->read_page
);
385 squashfs_decompressor_destroy(msblk
);
386 kfree(msblk
->inode_lookup_table
);
387 kfree(msblk
->fragment_index
);
388 kfree(msblk
->id_table
);
389 kfree(msblk
->xattr_id_table
);
390 kfree(sb
->s_fs_info
);
391 sb
->s_fs_info
= NULL
;
396 static int squashfs_get_tree(struct fs_context
*fc
)
398 return get_tree_bdev(fc
, squashfs_fill_super
);
401 static int squashfs_reconfigure(struct fs_context
*fc
)
403 struct super_block
*sb
= fc
->root
->d_sb
;
404 struct squashfs_sb_info
*msblk
= sb
->s_fs_info
;
405 struct squashfs_mount_opts
*opts
= fc
->fs_private
;
407 sync_filesystem(fc
->root
->d_sb
);
408 fc
->sb_flags
|= SB_RDONLY
;
410 msblk
->panic_on_errors
= (opts
->errors
== Opt_errors_panic
);
415 static void squashfs_free_fs_context(struct fs_context
*fc
)
417 kfree(fc
->fs_private
);
420 static const struct fs_context_operations squashfs_context_ops
= {
421 .get_tree
= squashfs_get_tree
,
422 .free
= squashfs_free_fs_context
,
423 .parse_param
= squashfs_parse_param
,
424 .reconfigure
= squashfs_reconfigure
,
427 static int squashfs_show_options(struct seq_file
*s
, struct dentry
*root
)
429 struct super_block
*sb
= root
->d_sb
;
430 struct squashfs_sb_info
*msblk
= sb
->s_fs_info
;
432 if (msblk
->panic_on_errors
)
433 seq_puts(s
, ",errors=panic");
435 seq_puts(s
, ",errors=continue");
440 static int squashfs_init_fs_context(struct fs_context
*fc
)
442 struct squashfs_mount_opts
*opts
;
444 opts
= kzalloc(sizeof(*opts
), GFP_KERNEL
);
448 fc
->fs_private
= opts
;
449 fc
->ops
= &squashfs_context_ops
;
453 static int squashfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
455 struct squashfs_sb_info
*msblk
= dentry
->d_sb
->s_fs_info
;
456 u64 id
= huge_encode_dev(dentry
->d_sb
->s_bdev
->bd_dev
);
458 TRACE("Entered squashfs_statfs\n");
460 buf
->f_type
= SQUASHFS_MAGIC
;
461 buf
->f_bsize
= msblk
->block_size
;
462 buf
->f_blocks
= ((msblk
->bytes_used
- 1) >> msblk
->block_log
) + 1;
463 buf
->f_bfree
= buf
->f_bavail
= 0;
464 buf
->f_files
= msblk
->inodes
;
466 buf
->f_namelen
= SQUASHFS_NAME_LEN
;
467 buf
->f_fsid
= u64_to_fsid(id
);
473 static void squashfs_put_super(struct super_block
*sb
)
476 struct squashfs_sb_info
*sbi
= sb
->s_fs_info
;
477 squashfs_cache_delete(sbi
->block_cache
);
478 squashfs_cache_delete(sbi
->fragment_cache
);
479 squashfs_cache_delete(sbi
->read_page
);
480 squashfs_decompressor_destroy(sbi
);
481 kfree(sbi
->id_table
);
482 kfree(sbi
->fragment_index
);
483 kfree(sbi
->meta_index
);
484 kfree(sbi
->inode_lookup_table
);
485 kfree(sbi
->xattr_id_table
);
486 kfree(sb
->s_fs_info
);
487 sb
->s_fs_info
= NULL
;
491 static struct kmem_cache
*squashfs_inode_cachep
;
494 static void init_once(void *foo
)
496 struct squashfs_inode_info
*ei
= foo
;
498 inode_init_once(&ei
->vfs_inode
);
502 static int __init
init_inodecache(void)
504 squashfs_inode_cachep
= kmem_cache_create("squashfs_inode_cache",
505 sizeof(struct squashfs_inode_info
), 0,
506 SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|SLAB_ACCOUNT
,
509 return squashfs_inode_cachep
? 0 : -ENOMEM
;
513 static void destroy_inodecache(void)
516 * Make sure all delayed rcu free inodes are flushed before we
520 kmem_cache_destroy(squashfs_inode_cachep
);
524 static int __init
init_squashfs_fs(void)
526 int err
= init_inodecache();
531 err
= register_filesystem(&squashfs_fs_type
);
533 destroy_inodecache();
537 pr_info("version 4.0 (2009/01/31) Phillip Lougher\n");
543 static void __exit
exit_squashfs_fs(void)
545 unregister_filesystem(&squashfs_fs_type
);
546 destroy_inodecache();
550 static struct inode
*squashfs_alloc_inode(struct super_block
*sb
)
552 struct squashfs_inode_info
*ei
=
553 kmem_cache_alloc(squashfs_inode_cachep
, GFP_KERNEL
);
555 return ei
? &ei
->vfs_inode
: NULL
;
559 static void squashfs_free_inode(struct inode
*inode
)
561 kmem_cache_free(squashfs_inode_cachep
, squashfs_i(inode
));
564 static struct file_system_type squashfs_fs_type
= {
565 .owner
= THIS_MODULE
,
567 .init_fs_context
= squashfs_init_fs_context
,
568 .parameters
= squashfs_fs_parameters
,
569 .kill_sb
= kill_block_super
,
570 .fs_flags
= FS_REQUIRES_DEV
572 MODULE_ALIAS_FS("squashfs");
574 static const struct super_operations squashfs_super_ops
= {
575 .alloc_inode
= squashfs_alloc_inode
,
576 .free_inode
= squashfs_free_inode
,
577 .statfs
= squashfs_statfs
,
578 .put_super
= squashfs_put_super
,
579 .show_options
= squashfs_show_options
,
582 module_init(init_squashfs_fs
);
583 module_exit(exit_squashfs_fs
);
584 MODULE_DESCRIPTION("squashfs 4.0, a compressed read-only filesystem");
585 MODULE_AUTHOR("Phillip Lougher <phillip@squashfs.org.uk>");
586 MODULE_LICENSE("GPL");