blob: 0adc624c956f7b5994a2ad2a9add6dbd97fc4f76 [file] [log] [blame]
Phillip Lougher0aa66612009-01-05 08:46:25 +00001/*
2 * Squashfs - a compressed read only filesystem for Linux
3 *
4 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008
5 * Phillip Lougher <phillip@lougher.demon.co.uk>
6 *
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.
11 *
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.
16 *
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.
20 *
21 * super.c
22 */
23
24/*
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
27 * the filesystem.
28 */
29
30#include <linux/fs.h>
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>
Qinghuang Feng1bcbf312009-01-15 13:51:03 -080038#include <linux/magic.h>
Phillip Lougher0aa66612009-01-05 08:46:25 +000039
40#include "squashfs_fs.h"
41#include "squashfs_fs_sb.h"
42#include "squashfs_fs_i.h"
43#include "squashfs.h"
44
45static struct file_system_type squashfs_fs_type;
46static struct super_operations squashfs_super_ops;
47
48static int supported_squashfs_filesystem(short major, short minor, short comp)
49{
50 if (major < SQUASHFS_MAJOR) {
51 ERROR("Major/Minor mismatch, older Squashfs %d.%d "
52 "filesystems are unsupported\n", major, minor);
53 return -EINVAL;
54 } else if (major > SQUASHFS_MAJOR || minor > SQUASHFS_MINOR) {
55 ERROR("Major/Minor mismatch, trying to mount newer "
56 "%d.%d filesystem\n", major, minor);
57 ERROR("Please update your kernel\n");
58 return -EINVAL;
59 }
60
61 if (comp != ZLIB_COMPRESSION)
62 return -EINVAL;
63
64 return 0;
65}
66
67
68static int squashfs_fill_super(struct super_block *sb, void *data, int silent)
69{
70 struct squashfs_sb_info *msblk;
71 struct squashfs_super_block *sblk = NULL;
72 char b[BDEVNAME_SIZE];
73 struct inode *root;
74 long long root_inode;
75 unsigned short flags;
76 unsigned int fragments;
77 u64 lookup_table_start;
78 int err;
79
80 TRACE("Entered squashfs_fill_superblock\n");
81
82 sb->s_fs_info = kzalloc(sizeof(*msblk), GFP_KERNEL);
83 if (sb->s_fs_info == NULL) {
84 ERROR("Failed to allocate squashfs_sb_info\n");
85 return -ENOMEM;
86 }
87 msblk = sb->s_fs_info;
88
89 msblk->stream.workspace = kmalloc(zlib_inflate_workspacesize(),
90 GFP_KERNEL);
91 if (msblk->stream.workspace == NULL) {
92 ERROR("Failed to allocate zlib workspace\n");
93 goto failure;
94 }
95
96 sblk = kzalloc(sizeof(*sblk), GFP_KERNEL);
97 if (sblk == NULL) {
98 ERROR("Failed to allocate squashfs_super_block\n");
99 goto failure;
100 }
101
102 msblk->devblksize = sb_min_blocksize(sb, BLOCK_SIZE);
103 msblk->devblksize_log2 = ffz(~msblk->devblksize);
104
105 mutex_init(&msblk->read_data_mutex);
106 mutex_init(&msblk->meta_index_mutex);
107
108 /*
109 * msblk->bytes_used is checked in squashfs_read_table to ensure reads
110 * are not beyond filesystem end. But as we're using
111 * squashfs_read_table here to read the superblock (including the value
112 * of bytes_used) we need to set it to an initial sensible dummy value
113 */
114 msblk->bytes_used = sizeof(*sblk);
115 err = squashfs_read_table(sb, sblk, SQUASHFS_START, sizeof(*sblk));
116
117 if (err < 0) {
118 ERROR("unable to read squashfs_super_block\n");
119 goto failed_mount;
120 }
121
122 /* Check it is a SQUASHFS superblock */
123 sb->s_magic = le32_to_cpu(sblk->s_magic);
124 if (sb->s_magic != SQUASHFS_MAGIC) {
125 if (!silent)
126 ERROR("Can't find a SQUASHFS superblock on %s\n",
127 bdevname(sb->s_bdev, b));
128 err = -EINVAL;
129 goto failed_mount;
130 }
131
132 /* Check the MAJOR & MINOR versions and compression type */
133 err = supported_squashfs_filesystem(le16_to_cpu(sblk->s_major),
134 le16_to_cpu(sblk->s_minor),
135 le16_to_cpu(sblk->compression));
136 if (err < 0)
137 goto failed_mount;
138
139 err = -EINVAL;
140
141 /*
142 * Check if there's xattrs in the filesystem. These are not
143 * supported in this version, so warn that they will be ignored.
144 */
145 if (le64_to_cpu(sblk->xattr_table_start) != SQUASHFS_INVALID_BLK)
146 ERROR("Xattrs in filesystem, these will be ignored\n");
147
148 /* Check the filesystem does not extend beyond the end of the
149 block device */
150 msblk->bytes_used = le64_to_cpu(sblk->bytes_used);
151 if (msblk->bytes_used < 0 || msblk->bytes_used >
152 i_size_read(sb->s_bdev->bd_inode))
153 goto failed_mount;
154
155 /* Check block size for sanity */
156 msblk->block_size = le32_to_cpu(sblk->block_size);
157 if (msblk->block_size > SQUASHFS_FILE_MAX_SIZE)
158 goto failed_mount;
159
Phillip Lougherfffb47b2009-05-13 02:59:26 +0100160 /*
161 * Check the system page size is not larger than the filesystem
162 * block size (by default 128K). This is currently not supported.
163 */
164 if (PAGE_CACHE_SIZE > msblk->block_size) {
165 ERROR("Page size > filesystem block size (%d). This is "
166 "currently not supported!\n", msblk->block_size);
167 goto failed_mount;
168 }
169
Phillip Lougher0aa66612009-01-05 08:46:25 +0000170 msblk->block_log = le16_to_cpu(sblk->block_log);
171 if (msblk->block_log > SQUASHFS_FILE_MAX_LOG)
172 goto failed_mount;
173
174 /* Check the root inode for sanity */
175 root_inode = le64_to_cpu(sblk->root_inode);
176 if (SQUASHFS_INODE_OFFSET(root_inode) > SQUASHFS_METADATA_SIZE)
177 goto failed_mount;
178
179 msblk->inode_table = le64_to_cpu(sblk->inode_table_start);
180 msblk->directory_table = le64_to_cpu(sblk->directory_table_start);
181 msblk->inodes = le32_to_cpu(sblk->inodes);
182 flags = le16_to_cpu(sblk->flags);
183
184 TRACE("Found valid superblock on %s\n", bdevname(sb->s_bdev, b));
185 TRACE("Inodes are %scompressed\n", SQUASHFS_UNCOMPRESSED_INODES(flags)
186 ? "un" : "");
187 TRACE("Data is %scompressed\n", SQUASHFS_UNCOMPRESSED_DATA(flags)
188 ? "un" : "");
189 TRACE("Filesystem size %lld bytes\n", msblk->bytes_used);
190 TRACE("Block size %d\n", msblk->block_size);
191 TRACE("Number of inodes %d\n", msblk->inodes);
192 TRACE("Number of fragments %d\n", le32_to_cpu(sblk->fragments));
193 TRACE("Number of ids %d\n", le16_to_cpu(sblk->no_ids));
194 TRACE("sblk->inode_table_start %llx\n", msblk->inode_table);
195 TRACE("sblk->directory_table_start %llx\n", msblk->directory_table);
196 TRACE("sblk->fragment_table_start %llx\n",
197 (u64) le64_to_cpu(sblk->fragment_table_start));
198 TRACE("sblk->id_table_start %llx\n",
199 (u64) le64_to_cpu(sblk->id_table_start));
200
201 sb->s_maxbytes = MAX_LFS_FILESIZE;
202 sb->s_flags |= MS_RDONLY;
203 sb->s_op = &squashfs_super_ops;
204
205 err = -ENOMEM;
206
207 msblk->block_cache = squashfs_cache_init("metadata",
208 SQUASHFS_CACHED_BLKS, SQUASHFS_METADATA_SIZE);
209 if (msblk->block_cache == NULL)
210 goto failed_mount;
211
212 /* Allocate read_page block */
213 msblk->read_page = squashfs_cache_init("data", 1, msblk->block_size);
214 if (msblk->read_page == NULL) {
215 ERROR("Failed to allocate read_page block\n");
216 goto failed_mount;
217 }
218
219 /* Allocate and read id index table */
220 msblk->id_table = squashfs_read_id_index_table(sb,
221 le64_to_cpu(sblk->id_table_start), le16_to_cpu(sblk->no_ids));
222 if (IS_ERR(msblk->id_table)) {
223 err = PTR_ERR(msblk->id_table);
224 msblk->id_table = NULL;
225 goto failed_mount;
226 }
227
228 fragments = le32_to_cpu(sblk->fragments);
229 if (fragments == 0)
230 goto allocate_lookup_table;
231
232 msblk->fragment_cache = squashfs_cache_init("fragment",
233 SQUASHFS_CACHED_FRAGMENTS, msblk->block_size);
234 if (msblk->fragment_cache == NULL) {
235 err = -ENOMEM;
236 goto failed_mount;
237 }
238
239 /* Allocate and read fragment index table */
240 msblk->fragment_index = squashfs_read_fragment_index_table(sb,
241 le64_to_cpu(sblk->fragment_table_start), fragments);
242 if (IS_ERR(msblk->fragment_index)) {
243 err = PTR_ERR(msblk->fragment_index);
244 msblk->fragment_index = NULL;
245 goto failed_mount;
246 }
247
248allocate_lookup_table:
249 lookup_table_start = le64_to_cpu(sblk->lookup_table_start);
250 if (lookup_table_start == SQUASHFS_INVALID_BLK)
251 goto allocate_root;
252
253 /* Allocate and read inode lookup table */
254 msblk->inode_lookup_table = squashfs_read_inode_lookup_table(sb,
255 lookup_table_start, msblk->inodes);
256 if (IS_ERR(msblk->inode_lookup_table)) {
257 err = PTR_ERR(msblk->inode_lookup_table);
258 msblk->inode_lookup_table = NULL;
259 goto failed_mount;
260 }
261
262 sb->s_export_op = &squashfs_export_ops;
263
264allocate_root:
265 root = new_inode(sb);
266 if (!root) {
267 err = -ENOMEM;
268 goto failed_mount;
269 }
270
271 err = squashfs_read_inode(root, root_inode);
272 if (err) {
273 iget_failed(root);
274 goto failed_mount;
275 }
276 insert_inode_hash(root);
277
278 sb->s_root = d_alloc_root(root);
279 if (sb->s_root == NULL) {
280 ERROR("Root inode create failed\n");
281 err = -ENOMEM;
282 iput(root);
283 goto failed_mount;
284 }
285
286 TRACE("Leaving squashfs_fill_super\n");
287 kfree(sblk);
288 return 0;
289
290failed_mount:
291 squashfs_cache_delete(msblk->block_cache);
292 squashfs_cache_delete(msblk->fragment_cache);
293 squashfs_cache_delete(msblk->read_page);
294 kfree(msblk->inode_lookup_table);
295 kfree(msblk->fragment_index);
296 kfree(msblk->id_table);
297 kfree(msblk->stream.workspace);
298 kfree(sb->s_fs_info);
299 sb->s_fs_info = NULL;
300 kfree(sblk);
301 return err;
302
303failure:
304 kfree(msblk->stream.workspace);
305 kfree(sb->s_fs_info);
306 sb->s_fs_info = NULL;
307 return -ENOMEM;
308}
309
310
311static int squashfs_statfs(struct dentry *dentry, struct kstatfs *buf)
312{
313 struct squashfs_sb_info *msblk = dentry->d_sb->s_fs_info;
Coly Li2fc7f562009-04-02 16:59:42 -0700314 u64 id = huge_encode_dev(dentry->d_sb->s_bdev->bd_dev);
Phillip Lougher0aa66612009-01-05 08:46:25 +0000315
316 TRACE("Entered squashfs_statfs\n");
317
318 buf->f_type = SQUASHFS_MAGIC;
319 buf->f_bsize = msblk->block_size;
320 buf->f_blocks = ((msblk->bytes_used - 1) >> msblk->block_log) + 1;
321 buf->f_bfree = buf->f_bavail = 0;
322 buf->f_files = msblk->inodes;
323 buf->f_ffree = 0;
324 buf->f_namelen = SQUASHFS_NAME_LEN;
Coly Li2fc7f562009-04-02 16:59:42 -0700325 buf->f_fsid.val[0] = (u32)id;
326 buf->f_fsid.val[1] = (u32)(id >> 32);
Phillip Lougher0aa66612009-01-05 08:46:25 +0000327
328 return 0;
329}
330
331
332static int squashfs_remount(struct super_block *sb, int *flags, char *data)
333{
334 *flags |= MS_RDONLY;
335 return 0;
336}
337
338
339static void squashfs_put_super(struct super_block *sb)
340{
341 if (sb->s_fs_info) {
342 struct squashfs_sb_info *sbi = sb->s_fs_info;
343 squashfs_cache_delete(sbi->block_cache);
344 squashfs_cache_delete(sbi->fragment_cache);
345 squashfs_cache_delete(sbi->read_page);
346 kfree(sbi->id_table);
347 kfree(sbi->fragment_index);
348 kfree(sbi->meta_index);
349 kfree(sbi->stream.workspace);
350 kfree(sb->s_fs_info);
351 sb->s_fs_info = NULL;
352 }
353}
354
355
356static int squashfs_get_sb(struct file_system_type *fs_type, int flags,
357 const char *dev_name, void *data,
358 struct vfsmount *mnt)
359{
360 return get_sb_bdev(fs_type, flags, dev_name, data, squashfs_fill_super,
361 mnt);
362}
363
364
365static struct kmem_cache *squashfs_inode_cachep;
366
367
368static void init_once(void *foo)
369{
370 struct squashfs_inode_info *ei = foo;
371
372 inode_init_once(&ei->vfs_inode);
373}
374
375
376static int __init init_inodecache(void)
377{
378 squashfs_inode_cachep = kmem_cache_create("squashfs_inode_cache",
379 sizeof(struct squashfs_inode_info), 0,
380 SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT, init_once);
381
382 return squashfs_inode_cachep ? 0 : -ENOMEM;
383}
384
385
386static void destroy_inodecache(void)
387{
388 kmem_cache_destroy(squashfs_inode_cachep);
389}
390
391
392static int __init init_squashfs_fs(void)
393{
394 int err = init_inodecache();
395
396 if (err)
397 return err;
398
399 err = register_filesystem(&squashfs_fs_type);
400 if (err) {
401 destroy_inodecache();
402 return err;
403 }
404
Phillip Lougher118e1ef2009-03-05 00:31:12 +0000405 printk(KERN_INFO "squashfs: version 4.0 (2009/01/31) "
Phillip Lougher0aa66612009-01-05 08:46:25 +0000406 "Phillip Lougher\n");
407
408 return 0;
409}
410
411
412static void __exit exit_squashfs_fs(void)
413{
414 unregister_filesystem(&squashfs_fs_type);
415 destroy_inodecache();
416}
417
418
419static struct inode *squashfs_alloc_inode(struct super_block *sb)
420{
421 struct squashfs_inode_info *ei =
422 kmem_cache_alloc(squashfs_inode_cachep, GFP_KERNEL);
423
424 return ei ? &ei->vfs_inode : NULL;
425}
426
427
428static void squashfs_destroy_inode(struct inode *inode)
429{
430 kmem_cache_free(squashfs_inode_cachep, squashfs_i(inode));
431}
432
433
434static struct file_system_type squashfs_fs_type = {
435 .owner = THIS_MODULE,
436 .name = "squashfs",
437 .get_sb = squashfs_get_sb,
438 .kill_sb = kill_block_super,
439 .fs_flags = FS_REQUIRES_DEV
440};
441
442static struct super_operations squashfs_super_ops = {
443 .alloc_inode = squashfs_alloc_inode,
444 .destroy_inode = squashfs_destroy_inode,
445 .statfs = squashfs_statfs,
446 .put_super = squashfs_put_super,
447 .remount_fs = squashfs_remount
448};
449
450module_init(init_squashfs_fs);
451module_exit(exit_squashfs_fs);
452MODULE_DESCRIPTION("squashfs 4.0, a compressed read-only filesystem");
453MODULE_AUTHOR("Phillip Lougher <phillip@lougher.demon.co.uk>");
454MODULE_LICENSE("GPL");