2 * Squashfs - a compressed read only filesystem for Linux
4 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 * Phillip Lougher <phillip@lougher.demon.co.uk>
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2,
10 * or (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
25 * This file implements code to read the superblock, read and initialise
26 * in-memory structures at mount time, and all the VFS glue code to register
31 #include <linux/vfs.h>
32 #include <linux/slab.h>
33 #include <linux/smp_lock.h>
34 #include <linux/mutex.h>
35 #include <linux/pagemap.h>
36 #include <linux/init.h>
37 #include <linux/module.h>
38 #include <linux/magic.h>
39 #include <linux/xattr.h>
41 #include "squashfs_fs.h"
42 #include "squashfs_fs_sb.h"
43 #include "squashfs_fs_i.h"
45 #include "decompressor.h"
48 static struct file_system_type squashfs_fs_type
;
49 static const struct super_operations squashfs_super_ops
;
51 static const struct squashfs_decompressor
*supported_squashfs_filesystem(short
52 major
, short minor
, short id
)
54 const struct squashfs_decompressor
*decompressor
;
56 if (major
< SQUASHFS_MAJOR
) {
57 ERROR("Major/Minor mismatch, older Squashfs %d.%d "
58 "filesystems are unsupported\n", major
, minor
);
60 } else if (major
> SQUASHFS_MAJOR
|| minor
> SQUASHFS_MINOR
) {
61 ERROR("Major/Minor mismatch, trying to mount newer "
62 "%d.%d filesystem\n", major
, minor
);
63 ERROR("Please update your kernel\n");
67 decompressor
= squashfs_lookup_decompressor(id
);
68 if (!decompressor
->supported
) {
69 ERROR("Filesystem uses \"%s\" compression. This is not "
70 "supported\n", decompressor
->name
);
78 static int squashfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
80 struct squashfs_sb_info
*msblk
;
81 struct squashfs_super_block
*sblk
= NULL
;
82 char b
[BDEVNAME_SIZE
];
86 unsigned int fragments
;
87 u64 lookup_table_start
, xattr_id_table_start
;
92 TRACE("Entered squashfs_fill_superblock\n");
94 sb
->s_fs_info
= kzalloc(sizeof(*msblk
), GFP_KERNEL
);
95 if (sb
->s_fs_info
== NULL
) {
96 ERROR("Failed to allocate squashfs_sb_info\n");
100 msblk
= sb
->s_fs_info
;
102 sblk
= kzalloc(sizeof(*sblk
), GFP_KERNEL
);
104 ERROR("Failed to allocate squashfs_super_block\n");
108 msblk
->devblksize
= sb_min_blocksize(sb
, BLOCK_SIZE
);
109 msblk
->devblksize_log2
= ffz(~msblk
->devblksize
);
111 mutex_init(&msblk
->read_data_mutex
);
112 mutex_init(&msblk
->meta_index_mutex
);
115 * msblk->bytes_used is checked in squashfs_read_table to ensure reads
116 * are not beyond filesystem end. But as we're using
117 * squashfs_read_table here to read the superblock (including the value
118 * of bytes_used) we need to set it to an initial sensible dummy value
120 msblk
->bytes_used
= sizeof(*sblk
);
121 err
= squashfs_read_table(sb
, sblk
, SQUASHFS_START
, sizeof(*sblk
));
124 ERROR("unable to read squashfs_super_block\n");
130 /* Check it is a SQUASHFS superblock */
131 sb
->s_magic
= le32_to_cpu(sblk
->s_magic
);
132 if (sb
->s_magic
!= SQUASHFS_MAGIC
) {
134 ERROR("Can't find a SQUASHFS superblock on %s\n",
135 bdevname(sb
->s_bdev
, b
));
139 /* Check the MAJOR & MINOR versions and lookup compression type */
140 msblk
->decompressor
= supported_squashfs_filesystem(
141 le16_to_cpu(sblk
->s_major
),
142 le16_to_cpu(sblk
->s_minor
),
143 le16_to_cpu(sblk
->compression
));
144 if (msblk
->decompressor
== NULL
)
147 /* Check the filesystem does not extend beyond the end of the
149 msblk
->bytes_used
= le64_to_cpu(sblk
->bytes_used
);
150 if (msblk
->bytes_used
< 0 || msblk
->bytes_used
>
151 i_size_read(sb
->s_bdev
->bd_inode
))
154 /* Check block size for sanity */
155 msblk
->block_size
= le32_to_cpu(sblk
->block_size
);
156 if (msblk
->block_size
> SQUASHFS_FILE_MAX_SIZE
)
160 * Check the system page size is not larger than the filesystem
161 * block size (by default 128K). This is currently not supported.
163 if (PAGE_CACHE_SIZE
> msblk
->block_size
) {
164 ERROR("Page size > filesystem block size (%d). This is "
165 "currently not supported!\n", msblk
->block_size
);
169 msblk
->block_log
= le16_to_cpu(sblk
->block_log
);
170 if (msblk
->block_log
> SQUASHFS_FILE_MAX_LOG
)
173 /* Check the root inode for sanity */
174 root_inode
= le64_to_cpu(sblk
->root_inode
);
175 if (SQUASHFS_INODE_OFFSET(root_inode
) > SQUASHFS_METADATA_SIZE
)
178 msblk
->inode_table
= le64_to_cpu(sblk
->inode_table_start
);
179 msblk
->directory_table
= le64_to_cpu(sblk
->directory_table_start
);
180 msblk
->inodes
= le32_to_cpu(sblk
->inodes
);
181 flags
= le16_to_cpu(sblk
->flags
);
183 TRACE("Found valid superblock on %s\n", bdevname(sb
->s_bdev
, b
));
184 TRACE("Inodes are %scompressed\n", SQUASHFS_UNCOMPRESSED_INODES(flags
)
186 TRACE("Data is %scompressed\n", SQUASHFS_UNCOMPRESSED_DATA(flags
)
188 TRACE("Filesystem size %lld bytes\n", msblk
->bytes_used
);
189 TRACE("Block size %d\n", msblk
->block_size
);
190 TRACE("Number of inodes %d\n", msblk
->inodes
);
191 TRACE("Number of fragments %d\n", le32_to_cpu(sblk
->fragments
));
192 TRACE("Number of ids %d\n", le16_to_cpu(sblk
->no_ids
));
193 TRACE("sblk->inode_table_start %llx\n", msblk
->inode_table
);
194 TRACE("sblk->directory_table_start %llx\n", msblk
->directory_table
);
195 TRACE("sblk->fragment_table_start %llx\n",
196 (u64
) le64_to_cpu(sblk
->fragment_table_start
));
197 TRACE("sblk->id_table_start %llx\n",
198 (u64
) le64_to_cpu(sblk
->id_table_start
));
200 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
201 sb
->s_flags
|= MS_RDONLY
;
202 sb
->s_op
= &squashfs_super_ops
;
206 msblk
->stream
= squashfs_decompressor_init(msblk
);
207 if (msblk
->stream
== NULL
)
210 msblk
->block_cache
= squashfs_cache_init("metadata",
211 SQUASHFS_CACHED_BLKS
, SQUASHFS_METADATA_SIZE
);
212 if (msblk
->block_cache
== NULL
)
215 /* Allocate read_page block */
216 msblk
->read_page
= squashfs_cache_init("data", 1, msblk
->block_size
);
217 if (msblk
->read_page
== NULL
) {
218 ERROR("Failed to allocate read_page block\n");
222 /* Allocate and read id index table */
223 msblk
->id_table
= squashfs_read_id_index_table(sb
,
224 le64_to_cpu(sblk
->id_table_start
), le16_to_cpu(sblk
->no_ids
));
225 if (IS_ERR(msblk
->id_table
)) {
226 err
= PTR_ERR(msblk
->id_table
);
227 msblk
->id_table
= NULL
;
231 fragments
= le32_to_cpu(sblk
->fragments
);
233 goto allocate_lookup_table
;
235 msblk
->fragment_cache
= squashfs_cache_init("fragment",
236 SQUASHFS_CACHED_FRAGMENTS
, msblk
->block_size
);
237 if (msblk
->fragment_cache
== NULL
) {
242 /* Allocate and read fragment index table */
243 msblk
->fragment_index
= squashfs_read_fragment_index_table(sb
,
244 le64_to_cpu(sblk
->fragment_table_start
), fragments
);
245 if (IS_ERR(msblk
->fragment_index
)) {
246 err
= PTR_ERR(msblk
->fragment_index
);
247 msblk
->fragment_index
= NULL
;
251 allocate_lookup_table
:
252 lookup_table_start
= le64_to_cpu(sblk
->lookup_table_start
);
253 if (lookup_table_start
== SQUASHFS_INVALID_BLK
)
254 goto allocate_xattr_table
;
256 /* Allocate and read inode lookup table */
257 msblk
->inode_lookup_table
= squashfs_read_inode_lookup_table(sb
,
258 lookup_table_start
, msblk
->inodes
);
259 if (IS_ERR(msblk
->inode_lookup_table
)) {
260 err
= PTR_ERR(msblk
->inode_lookup_table
);
261 msblk
->inode_lookup_table
= NULL
;
265 sb
->s_export_op
= &squashfs_export_ops
;
267 allocate_xattr_table
:
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
)
273 /* Allocate and read xattr id lookup table */
274 msblk
->xattr_id_table
= squashfs_read_xattr_id_table(sb
,
275 xattr_id_table_start
, &msblk
->xattr_table
, &msblk
->xattr_ids
);
276 if (IS_ERR(msblk
->xattr_id_table
)) {
277 err
= PTR_ERR(msblk
->xattr_id_table
);
278 msblk
->xattr_id_table
= NULL
;
279 if (err
!= -ENOTSUPP
)
283 root
= new_inode(sb
);
289 err
= squashfs_read_inode(root
, root_inode
);
291 make_bad_inode(root
);
295 insert_inode_hash(root
);
297 sb
->s_root
= d_alloc_root(root
);
298 if (sb
->s_root
== NULL
) {
299 ERROR("Root inode create failed\n");
305 TRACE("Leaving squashfs_fill_super\n");
311 squashfs_cache_delete(msblk
->block_cache
);
312 squashfs_cache_delete(msblk
->fragment_cache
);
313 squashfs_cache_delete(msblk
->read_page
);
314 squashfs_decompressor_free(msblk
, msblk
->stream
);
315 kfree(msblk
->inode_lookup_table
);
316 kfree(msblk
->fragment_index
);
317 kfree(msblk
->id_table
);
318 kfree(msblk
->xattr_id_table
);
319 kfree(sb
->s_fs_info
);
320 sb
->s_fs_info
= NULL
;
326 kfree(sb
->s_fs_info
);
327 sb
->s_fs_info
= NULL
;
333 static int squashfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
335 struct squashfs_sb_info
*msblk
= dentry
->d_sb
->s_fs_info
;
336 u64 id
= huge_encode_dev(dentry
->d_sb
->s_bdev
->bd_dev
);
338 TRACE("Entered squashfs_statfs\n");
340 buf
->f_type
= SQUASHFS_MAGIC
;
341 buf
->f_bsize
= msblk
->block_size
;
342 buf
->f_blocks
= ((msblk
->bytes_used
- 1) >> msblk
->block_log
) + 1;
343 buf
->f_bfree
= buf
->f_bavail
= 0;
344 buf
->f_files
= msblk
->inodes
;
346 buf
->f_namelen
= SQUASHFS_NAME_LEN
;
347 buf
->f_fsid
.val
[0] = (u32
)id
;
348 buf
->f_fsid
.val
[1] = (u32
)(id
>> 32);
354 static int squashfs_remount(struct super_block
*sb
, int *flags
, char *data
)
361 static void squashfs_put_super(struct super_block
*sb
)
366 struct squashfs_sb_info
*sbi
= sb
->s_fs_info
;
367 squashfs_cache_delete(sbi
->block_cache
);
368 squashfs_cache_delete(sbi
->fragment_cache
);
369 squashfs_cache_delete(sbi
->read_page
);
370 squashfs_decompressor_free(sbi
, sbi
->stream
);
371 kfree(sbi
->id_table
);
372 kfree(sbi
->fragment_index
);
373 kfree(sbi
->meta_index
);
374 kfree(sbi
->inode_lookup_table
);
375 kfree(sbi
->xattr_id_table
);
376 kfree(sb
->s_fs_info
);
377 sb
->s_fs_info
= NULL
;
384 static int squashfs_get_sb(struct file_system_type
*fs_type
, int flags
,
385 const char *dev_name
, void *data
,
386 struct vfsmount
*mnt
)
388 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, squashfs_fill_super
,
393 static struct kmem_cache
*squashfs_inode_cachep
;
396 static void init_once(void *foo
)
398 struct squashfs_inode_info
*ei
= foo
;
400 inode_init_once(&ei
->vfs_inode
);
404 static int __init
init_inodecache(void)
406 squashfs_inode_cachep
= kmem_cache_create("squashfs_inode_cache",
407 sizeof(struct squashfs_inode_info
), 0,
408 SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
, init_once
);
410 return squashfs_inode_cachep
? 0 : -ENOMEM
;
414 static void destroy_inodecache(void)
416 kmem_cache_destroy(squashfs_inode_cachep
);
420 static int __init
init_squashfs_fs(void)
422 int err
= init_inodecache();
427 err
= register_filesystem(&squashfs_fs_type
);
429 destroy_inodecache();
433 printk(KERN_INFO
"squashfs: version 4.0 (2009/01/31) "
434 "Phillip Lougher\n");
440 static void __exit
exit_squashfs_fs(void)
442 unregister_filesystem(&squashfs_fs_type
);
443 destroy_inodecache();
447 static struct inode
*squashfs_alloc_inode(struct super_block
*sb
)
449 struct squashfs_inode_info
*ei
=
450 kmem_cache_alloc(squashfs_inode_cachep
, GFP_KERNEL
);
452 return ei
? &ei
->vfs_inode
: NULL
;
456 static void squashfs_destroy_inode(struct inode
*inode
)
458 kmem_cache_free(squashfs_inode_cachep
, squashfs_i(inode
));
462 static struct file_system_type squashfs_fs_type
= {
463 .owner
= THIS_MODULE
,
465 .get_sb
= squashfs_get_sb
,
466 .kill_sb
= kill_block_super
,
467 .fs_flags
= FS_REQUIRES_DEV
470 static const struct super_operations squashfs_super_ops
= {
471 .alloc_inode
= squashfs_alloc_inode
,
472 .destroy_inode
= squashfs_destroy_inode
,
473 .statfs
= squashfs_statfs
,
474 .put_super
= squashfs_put_super
,
475 .remount_fs
= squashfs_remount
478 module_init(init_squashfs_fs
);
479 module_exit(exit_squashfs_fs
);
480 MODULE_DESCRIPTION("squashfs 4.0, a compressed read-only filesystem");
481 MODULE_AUTHOR("Phillip Lougher <phillip@lougher.demon.co.uk>");
482 MODULE_LICENSE("GPL");