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/mutex.h>
34 #include <linux/pagemap.h>
35 #include <linux/init.h>
36 #include <linux/module.h>
37 #include <linux/zlib.h>
39 #include "squashfs_fs.h"
40 #include "squashfs_fs_sb.h"
41 #include "squashfs_fs_i.h"
44 static struct file_system_type squashfs_fs_type
;
45 static struct super_operations squashfs_super_ops
;
47 static int supported_squashfs_filesystem(short major
, short minor
, short comp
)
49 if (major
< SQUASHFS_MAJOR
) {
50 ERROR("Major/Minor mismatch, older Squashfs %d.%d "
51 "filesystems are unsupported\n", major
, minor
);
53 } else if (major
> SQUASHFS_MAJOR
|| minor
> SQUASHFS_MINOR
) {
54 ERROR("Major/Minor mismatch, trying to mount newer "
55 "%d.%d filesystem\n", major
, minor
);
56 ERROR("Please update your kernel\n");
60 if (comp
!= ZLIB_COMPRESSION
)
67 static int squashfs_fill_super(struct super_block
*sb
, void *data
, int silent
)
69 struct squashfs_sb_info
*msblk
;
70 struct squashfs_super_block
*sblk
= NULL
;
71 char b
[BDEVNAME_SIZE
];
75 unsigned int fragments
;
76 u64 lookup_table_start
;
79 TRACE("Entered squashfs_fill_superblock\n");
81 sb
->s_fs_info
= kzalloc(sizeof(*msblk
), GFP_KERNEL
);
82 if (sb
->s_fs_info
== NULL
) {
83 ERROR("Failed to allocate squashfs_sb_info\n");
86 msblk
= sb
->s_fs_info
;
88 msblk
->stream
.workspace
= kmalloc(zlib_inflate_workspacesize(),
90 if (msblk
->stream
.workspace
== NULL
) {
91 ERROR("Failed to allocate zlib workspace\n");
95 sblk
= kzalloc(sizeof(*sblk
), GFP_KERNEL
);
97 ERROR("Failed to allocate squashfs_super_block\n");
101 msblk
->devblksize
= sb_min_blocksize(sb
, BLOCK_SIZE
);
102 msblk
->devblksize_log2
= ffz(~msblk
->devblksize
);
104 mutex_init(&msblk
->read_data_mutex
);
105 mutex_init(&msblk
->meta_index_mutex
);
108 * msblk->bytes_used is checked in squashfs_read_table to ensure reads
109 * are not beyond filesystem end. But as we're using
110 * squashfs_read_table here to read the superblock (including the value
111 * of bytes_used) we need to set it to an initial sensible dummy value
113 msblk
->bytes_used
= sizeof(*sblk
);
114 err
= squashfs_read_table(sb
, sblk
, SQUASHFS_START
, sizeof(*sblk
));
117 ERROR("unable to read squashfs_super_block\n");
121 /* Check it is a SQUASHFS superblock */
122 sb
->s_magic
= le32_to_cpu(sblk
->s_magic
);
123 if (sb
->s_magic
!= SQUASHFS_MAGIC
) {
125 ERROR("Can't find a SQUASHFS superblock on %s\n",
126 bdevname(sb
->s_bdev
, b
));
131 /* Check the MAJOR & MINOR versions and compression type */
132 err
= supported_squashfs_filesystem(le16_to_cpu(sblk
->s_major
),
133 le16_to_cpu(sblk
->s_minor
),
134 le16_to_cpu(sblk
->compression
));
141 * Check if there's xattrs in the filesystem. These are not
142 * supported in this version, so warn that they will be ignored.
144 if (le64_to_cpu(sblk
->xattr_table_start
) != SQUASHFS_INVALID_BLK
)
145 ERROR("Xattrs in filesystem, these will be ignored\n");
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
)
159 msblk
->block_log
= le16_to_cpu(sblk
->block_log
);
160 if (msblk
->block_log
> SQUASHFS_FILE_MAX_LOG
)
163 /* Check the root inode for sanity */
164 root_inode
= le64_to_cpu(sblk
->root_inode
);
165 if (SQUASHFS_INODE_OFFSET(root_inode
) > SQUASHFS_METADATA_SIZE
)
168 msblk
->inode_table
= le64_to_cpu(sblk
->inode_table_start
);
169 msblk
->directory_table
= le64_to_cpu(sblk
->directory_table_start
);
170 msblk
->inodes
= le32_to_cpu(sblk
->inodes
);
171 flags
= le16_to_cpu(sblk
->flags
);
173 TRACE("Found valid superblock on %s\n", bdevname(sb
->s_bdev
, b
));
174 TRACE("Inodes are %scompressed\n", SQUASHFS_UNCOMPRESSED_INODES(flags
)
176 TRACE("Data is %scompressed\n", SQUASHFS_UNCOMPRESSED_DATA(flags
)
178 TRACE("Filesystem size %lld bytes\n", msblk
->bytes_used
);
179 TRACE("Block size %d\n", msblk
->block_size
);
180 TRACE("Number of inodes %d\n", msblk
->inodes
);
181 TRACE("Number of fragments %d\n", le32_to_cpu(sblk
->fragments
));
182 TRACE("Number of ids %d\n", le16_to_cpu(sblk
->no_ids
));
183 TRACE("sblk->inode_table_start %llx\n", msblk
->inode_table
);
184 TRACE("sblk->directory_table_start %llx\n", msblk
->directory_table
);
185 TRACE("sblk->fragment_table_start %llx\n",
186 (u64
) le64_to_cpu(sblk
->fragment_table_start
));
187 TRACE("sblk->id_table_start %llx\n",
188 (u64
) le64_to_cpu(sblk
->id_table_start
));
190 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
191 sb
->s_flags
|= MS_RDONLY
;
192 sb
->s_op
= &squashfs_super_ops
;
196 msblk
->block_cache
= squashfs_cache_init("metadata",
197 SQUASHFS_CACHED_BLKS
, SQUASHFS_METADATA_SIZE
);
198 if (msblk
->block_cache
== NULL
)
201 /* Allocate read_page block */
202 msblk
->read_page
= squashfs_cache_init("data", 1, msblk
->block_size
);
203 if (msblk
->read_page
== NULL
) {
204 ERROR("Failed to allocate read_page block\n");
208 /* Allocate and read id index table */
209 msblk
->id_table
= squashfs_read_id_index_table(sb
,
210 le64_to_cpu(sblk
->id_table_start
), le16_to_cpu(sblk
->no_ids
));
211 if (IS_ERR(msblk
->id_table
)) {
212 err
= PTR_ERR(msblk
->id_table
);
213 msblk
->id_table
= NULL
;
217 fragments
= le32_to_cpu(sblk
->fragments
);
219 goto allocate_lookup_table
;
221 msblk
->fragment_cache
= squashfs_cache_init("fragment",
222 SQUASHFS_CACHED_FRAGMENTS
, msblk
->block_size
);
223 if (msblk
->fragment_cache
== NULL
) {
228 /* Allocate and read fragment index table */
229 msblk
->fragment_index
= squashfs_read_fragment_index_table(sb
,
230 le64_to_cpu(sblk
->fragment_table_start
), fragments
);
231 if (IS_ERR(msblk
->fragment_index
)) {
232 err
= PTR_ERR(msblk
->fragment_index
);
233 msblk
->fragment_index
= NULL
;
237 allocate_lookup_table
:
238 lookup_table_start
= le64_to_cpu(sblk
->lookup_table_start
);
239 if (lookup_table_start
== SQUASHFS_INVALID_BLK
)
242 /* Allocate and read inode lookup table */
243 msblk
->inode_lookup_table
= squashfs_read_inode_lookup_table(sb
,
244 lookup_table_start
, msblk
->inodes
);
245 if (IS_ERR(msblk
->inode_lookup_table
)) {
246 err
= PTR_ERR(msblk
->inode_lookup_table
);
247 msblk
->inode_lookup_table
= NULL
;
251 sb
->s_export_op
= &squashfs_export_ops
;
254 root
= new_inode(sb
);
260 err
= squashfs_read_inode(root
, root_inode
);
265 insert_inode_hash(root
);
267 sb
->s_root
= d_alloc_root(root
);
268 if (sb
->s_root
== NULL
) {
269 ERROR("Root inode create failed\n");
275 TRACE("Leaving squashfs_fill_super\n");
280 squashfs_cache_delete(msblk
->block_cache
);
281 squashfs_cache_delete(msblk
->fragment_cache
);
282 squashfs_cache_delete(msblk
->read_page
);
283 kfree(msblk
->inode_lookup_table
);
284 kfree(msblk
->fragment_index
);
285 kfree(msblk
->id_table
);
286 kfree(msblk
->stream
.workspace
);
287 kfree(sb
->s_fs_info
);
288 sb
->s_fs_info
= NULL
;
293 kfree(msblk
->stream
.workspace
);
294 kfree(sb
->s_fs_info
);
295 sb
->s_fs_info
= NULL
;
300 static int squashfs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
302 struct squashfs_sb_info
*msblk
= dentry
->d_sb
->s_fs_info
;
304 TRACE("Entered squashfs_statfs\n");
306 buf
->f_type
= SQUASHFS_MAGIC
;
307 buf
->f_bsize
= msblk
->block_size
;
308 buf
->f_blocks
= ((msblk
->bytes_used
- 1) >> msblk
->block_log
) + 1;
309 buf
->f_bfree
= buf
->f_bavail
= 0;
310 buf
->f_files
= msblk
->inodes
;
312 buf
->f_namelen
= SQUASHFS_NAME_LEN
;
318 static int squashfs_remount(struct super_block
*sb
, int *flags
, char *data
)
325 static void squashfs_put_super(struct super_block
*sb
)
328 struct squashfs_sb_info
*sbi
= sb
->s_fs_info
;
329 squashfs_cache_delete(sbi
->block_cache
);
330 squashfs_cache_delete(sbi
->fragment_cache
);
331 squashfs_cache_delete(sbi
->read_page
);
332 kfree(sbi
->id_table
);
333 kfree(sbi
->fragment_index
);
334 kfree(sbi
->meta_index
);
335 kfree(sbi
->stream
.workspace
);
336 kfree(sb
->s_fs_info
);
337 sb
->s_fs_info
= NULL
;
342 static int squashfs_get_sb(struct file_system_type
*fs_type
, int flags
,
343 const char *dev_name
, void *data
,
344 struct vfsmount
*mnt
)
346 return get_sb_bdev(fs_type
, flags
, dev_name
, data
, squashfs_fill_super
,
351 static struct kmem_cache
*squashfs_inode_cachep
;
354 static void init_once(void *foo
)
356 struct squashfs_inode_info
*ei
= foo
;
358 inode_init_once(&ei
->vfs_inode
);
362 static int __init
init_inodecache(void)
364 squashfs_inode_cachep
= kmem_cache_create("squashfs_inode_cache",
365 sizeof(struct squashfs_inode_info
), 0,
366 SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
, init_once
);
368 return squashfs_inode_cachep
? 0 : -ENOMEM
;
372 static void destroy_inodecache(void)
374 kmem_cache_destroy(squashfs_inode_cachep
);
378 static int __init
init_squashfs_fs(void)
380 int err
= init_inodecache();
385 err
= register_filesystem(&squashfs_fs_type
);
387 destroy_inodecache();
391 printk(KERN_INFO
"squashfs: version 4.0 (2009/01/03) "
392 "Phillip Lougher\n");
398 static void __exit
exit_squashfs_fs(void)
400 unregister_filesystem(&squashfs_fs_type
);
401 destroy_inodecache();
405 static struct inode
*squashfs_alloc_inode(struct super_block
*sb
)
407 struct squashfs_inode_info
*ei
=
408 kmem_cache_alloc(squashfs_inode_cachep
, GFP_KERNEL
);
410 return ei
? &ei
->vfs_inode
: NULL
;
414 static void squashfs_destroy_inode(struct inode
*inode
)
416 kmem_cache_free(squashfs_inode_cachep
, squashfs_i(inode
));
420 static struct file_system_type squashfs_fs_type
= {
421 .owner
= THIS_MODULE
,
423 .get_sb
= squashfs_get_sb
,
424 .kill_sb
= kill_block_super
,
425 .fs_flags
= FS_REQUIRES_DEV
428 static struct super_operations squashfs_super_ops
= {
429 .alloc_inode
= squashfs_alloc_inode
,
430 .destroy_inode
= squashfs_destroy_inode
,
431 .statfs
= squashfs_statfs
,
432 .put_super
= squashfs_put_super
,
433 .remount_fs
= squashfs_remount
436 module_init(init_squashfs_fs
);
437 module_exit(exit_squashfs_fs
);
438 MODULE_DESCRIPTION("squashfs 4.0, a compressed read-only filesystem");
439 MODULE_AUTHOR("Phillip Lougher <phillip@lougher.demon.co.uk>");
440 MODULE_LICENSE("GPL");