4 * As should be obvious for Linux kernel code, license is GPLv2
6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
8 * Generally contains mount/umount code and also serves as a dump area for
9 * any functions that don't fit elsewhere and neither justify a file of their
13 #include <linux/bio.h>
14 #include <linux/slab.h>
15 #include <linux/blkdev.h>
16 #include <linux/mtd/mtd.h>
17 #include <linux/statfs.h>
18 #include <linux/buffer_head.h>
20 static DEFINE_MUTEX(emergency_mutex
);
21 static struct page
*emergency_page
;
23 struct page
*emergency_read_begin(struct address_space
*mapping
, pgoff_t index
)
25 filler_t
*filler
= (filler_t
*)mapping
->a_ops
->readpage
;
29 page
= read_cache_page(mapping
, index
, filler
, NULL
);
33 /* No more pages available, switch to emergency page */
34 printk(KERN_INFO
"Logfs: Using emergency page\n");
35 mutex_lock(&emergency_mutex
);
36 err
= filler(NULL
, emergency_page
);
38 mutex_unlock(&emergency_mutex
);
39 printk(KERN_EMERG
"Logfs: Error reading emergency page\n");
42 return emergency_page
;
45 void emergency_read_end(struct page
*page
)
47 if (page
== emergency_page
)
48 mutex_unlock(&emergency_mutex
);
50 page_cache_release(page
);
53 static void dump_segfile(struct super_block
*sb
)
55 struct logfs_super
*super
= logfs_super(sb
);
56 struct logfs_segment_entry se
;
59 for (segno
= 0; segno
< super
->s_no_segs
; segno
++) {
60 logfs_get_segment_entry(sb
, segno
, &se
);
61 printk("%3x: %6x %8x", segno
, be32_to_cpu(se
.ec_level
),
62 be32_to_cpu(se
.valid
));
63 if (++segno
< super
->s_no_segs
) {
64 logfs_get_segment_entry(sb
, segno
, &se
);
65 printk(" %6x %8x", be32_to_cpu(se
.ec_level
),
66 be32_to_cpu(se
.valid
));
68 if (++segno
< super
->s_no_segs
) {
69 logfs_get_segment_entry(sb
, segno
, &se
);
70 printk(" %6x %8x", be32_to_cpu(se
.ec_level
),
71 be32_to_cpu(se
.valid
));
73 if (++segno
< super
->s_no_segs
) {
74 logfs_get_segment_entry(sb
, segno
, &se
);
75 printk(" %6x %8x", be32_to_cpu(se
.ec_level
),
76 be32_to_cpu(se
.valid
));
83 * logfs_crash_dump - dump debug information to device
85 * The LogFS superblock only occupies part of a segment. This function will
86 * write as much debug information as it can gather into the spare space.
88 void logfs_crash_dump(struct super_block
*sb
)
94 * FIXME: There should be a reserve for root, similar to ext2.
96 int logfs_statfs(struct dentry
*dentry
, struct kstatfs
*stats
)
98 struct super_block
*sb
= dentry
->d_sb
;
99 struct logfs_super
*super
= logfs_super(sb
);
101 stats
->f_type
= LOGFS_MAGIC_U32
;
102 stats
->f_bsize
= sb
->s_blocksize
;
103 stats
->f_blocks
= super
->s_size
>> LOGFS_BLOCK_BITS
>> 3;
104 stats
->f_bfree
= super
->s_free_bytes
>> sb
->s_blocksize_bits
;
105 stats
->f_bavail
= super
->s_free_bytes
>> sb
->s_blocksize_bits
;
108 stats
->f_namelen
= LOGFS_MAX_NAMELEN
;
112 static int logfs_sb_set(struct super_block
*sb
, void *_super
)
114 struct logfs_super
*super
= _super
;
116 sb
->s_fs_info
= super
;
117 sb
->s_mtd
= super
->s_mtd
;
118 sb
->s_bdev
= super
->s_bdev
;
121 sb
->s_bdi
= &bdev_get_queue(sb
->s_bdev
)->backing_dev_info
;
125 sb
->s_bdi
= sb
->s_mtd
->backing_dev_info
;
130 static int logfs_sb_test(struct super_block
*sb
, void *_super
)
132 struct logfs_super
*super
= _super
;
133 struct mtd_info
*mtd
= super
->s_mtd
;
135 if (mtd
&& sb
->s_mtd
== mtd
)
137 if (super
->s_bdev
&& sb
->s_bdev
== super
->s_bdev
)
142 static void set_segment_header(struct logfs_segment_header
*sh
, u8 type
,
143 u8 level
, u32 segno
, u32 ec
)
148 sh
->segno
= cpu_to_be32(segno
);
149 sh
->ec
= cpu_to_be32(ec
);
150 sh
->gec
= cpu_to_be64(segno
);
151 sh
->crc
= logfs_crc32(sh
, LOGFS_SEGMENT_HEADERSIZE
, 4);
154 static void logfs_write_ds(struct super_block
*sb
, struct logfs_disk_super
*ds
,
157 struct logfs_super
*super
= logfs_super(sb
);
158 struct logfs_segment_header
*sh
= &ds
->ds_sh
;
161 memset(ds
, 0, sizeof(*ds
));
162 set_segment_header(sh
, SEG_SUPER
, 0, segno
, ec
);
164 ds
->ds_ifile_levels
= super
->s_ifile_levels
;
165 ds
->ds_iblock_levels
= super
->s_iblock_levels
;
166 ds
->ds_data_levels
= super
->s_data_levels
; /* XXX: Remove */
167 ds
->ds_segment_shift
= super
->s_segshift
;
168 ds
->ds_block_shift
= sb
->s_blocksize_bits
;
169 ds
->ds_write_shift
= super
->s_writeshift
;
170 ds
->ds_filesystem_size
= cpu_to_be64(super
->s_size
);
171 ds
->ds_segment_size
= cpu_to_be32(super
->s_segsize
);
172 ds
->ds_bad_seg_reserve
= cpu_to_be32(super
->s_bad_seg_reserve
);
173 ds
->ds_feature_incompat
= cpu_to_be64(super
->s_feature_incompat
);
174 ds
->ds_feature_ro_compat
= cpu_to_be64(super
->s_feature_ro_compat
);
175 ds
->ds_feature_compat
= cpu_to_be64(super
->s_feature_compat
);
176 ds
->ds_feature_flags
= cpu_to_be64(super
->s_feature_flags
);
177 ds
->ds_root_reserve
= cpu_to_be64(super
->s_root_reserve
);
178 ds
->ds_speed_reserve
= cpu_to_be64(super
->s_speed_reserve
);
180 ds
->ds_journal_seg
[i
] = cpu_to_be32(super
->s_journal_seg
[i
]);
181 ds
->ds_magic
= cpu_to_be64(LOGFS_MAGIC
);
182 ds
->ds_crc
= logfs_crc32(ds
, sizeof(*ds
),
183 LOGFS_SEGMENT_HEADERSIZE
+ 12);
186 static int write_one_sb(struct super_block
*sb
,
187 struct page
*(*find_sb
)(struct super_block
*sb
, u64
*ofs
))
189 struct logfs_super
*super
= logfs_super(sb
);
190 struct logfs_disk_super
*ds
;
191 struct logfs_segment_entry se
;
197 page
= find_sb(sb
, &ofs
);
200 ds
= page_address(page
);
201 segno
= seg_no(sb
, ofs
);
202 logfs_get_segment_entry(sb
, segno
, &se
);
203 ec
= be32_to_cpu(se
.ec_level
) >> 4;
205 logfs_set_segment_erased(sb
, segno
, ec
, 0);
206 logfs_write_ds(sb
, ds
, segno
, ec
);
207 err
= super
->s_devops
->write_sb(sb
, page
);
208 page_cache_release(page
);
212 int logfs_write_sb(struct super_block
*sb
)
214 struct logfs_super
*super
= logfs_super(sb
);
217 /* First superblock */
218 err
= write_one_sb(sb
, super
->s_devops
->find_first_sb
);
222 /* Last superblock */
223 err
= write_one_sb(sb
, super
->s_devops
->find_last_sb
);
229 static int ds_cmp(const void *ds0
, const void *ds1
)
231 size_t len
= sizeof(struct logfs_disk_super
);
233 /* We know the segment headers differ, so ignore them */
234 len
-= LOGFS_SEGMENT_HEADERSIZE
;
235 ds0
+= LOGFS_SEGMENT_HEADERSIZE
;
236 ds1
+= LOGFS_SEGMENT_HEADERSIZE
;
237 return memcmp(ds0
, ds1
, len
);
240 static int logfs_recover_sb(struct super_block
*sb
)
242 struct logfs_super
*super
= logfs_super(sb
);
243 struct logfs_disk_super _ds0
, *ds0
= &_ds0
;
244 struct logfs_disk_super _ds1
, *ds1
= &_ds1
;
245 int err
, valid0
, valid1
;
247 /* read first superblock */
248 err
= wbuf_read(sb
, super
->s_sb_ofs
[0], sizeof(*ds0
), ds0
);
251 /* read last superblock */
252 err
= wbuf_read(sb
, super
->s_sb_ofs
[1], sizeof(*ds1
), ds1
);
255 valid0
= logfs_check_ds(ds0
) == 0;
256 valid1
= logfs_check_ds(ds1
) == 0;
258 if (!valid0
&& valid1
) {
259 printk(KERN_INFO
"First superblock is invalid - fixing.\n");
260 return write_one_sb(sb
, super
->s_devops
->find_first_sb
);
262 if (valid0
&& !valid1
) {
263 printk(KERN_INFO
"Last superblock is invalid - fixing.\n");
264 return write_one_sb(sb
, super
->s_devops
->find_last_sb
);
266 if (valid0
&& valid1
&& ds_cmp(ds0
, ds1
)) {
267 printk(KERN_INFO
"Superblocks don't match - fixing.\n");
268 return logfs_write_sb(sb
);
270 /* If neither is valid now, something's wrong. Didn't we properly
271 * check them before?!? */
272 BUG_ON(!valid0
&& !valid1
);
276 static int logfs_make_writeable(struct super_block
*sb
)
280 err
= logfs_open_segfile(sb
);
284 /* Repair any broken superblock copies */
285 err
= logfs_recover_sb(sb
);
289 /* Check areas for trailing unaccounted data */
290 err
= logfs_check_areas(sb
);
294 /* Do one GC pass before any data gets dirtied */
297 /* after all initializations are done, replay the journal
298 * for rw-mounts, if necessary */
299 err
= logfs_replay_journal(sb
);
306 static int logfs_get_sb_final(struct super_block
*sb
)
308 struct logfs_super
*super
= logfs_super(sb
);
309 struct inode
*rootdir
;
313 rootdir
= logfs_iget(sb
, LOGFS_INO_ROOT
);
317 sb
->s_root
= d_alloc_root(rootdir
);
323 /* at that point we know that ->put_super() will be called */
324 super
->s_erase_page
= alloc_pages(GFP_KERNEL
, 0);
325 if (!super
->s_erase_page
)
327 memset(page_address(super
->s_erase_page
), 0xFF, PAGE_SIZE
);
329 /* FIXME: check for read-only mounts */
330 err
= logfs_make_writeable(sb
);
332 __free_page(super
->s_erase_page
);
336 log_super("LogFS: Finished mounting\n");
340 iput(super
->s_master_inode
);
341 iput(super
->s_segfile_inode
);
342 iput(super
->s_mapping_inode
);
346 int logfs_check_ds(struct logfs_disk_super
*ds
)
348 struct logfs_segment_header
*sh
= &ds
->ds_sh
;
350 if (ds
->ds_magic
!= cpu_to_be64(LOGFS_MAGIC
))
352 if (sh
->crc
!= logfs_crc32(sh
, LOGFS_SEGMENT_HEADERSIZE
, 4))
354 if (ds
->ds_crc
!= logfs_crc32(ds
, sizeof(*ds
),
355 LOGFS_SEGMENT_HEADERSIZE
+ 12))
360 static struct page
*find_super_block(struct super_block
*sb
)
362 struct logfs_super
*super
= logfs_super(sb
);
363 struct page
*first
, *last
;
365 first
= super
->s_devops
->find_first_sb(sb
, &super
->s_sb_ofs
[0]);
366 if (!first
|| IS_ERR(first
))
368 last
= super
->s_devops
->find_last_sb(sb
, &super
->s_sb_ofs
[1]);
369 if (!last
|| IS_ERR(last
)) {
370 page_cache_release(first
);
374 if (!logfs_check_ds(page_address(first
))) {
375 page_cache_release(last
);
379 /* First one didn't work, try the second superblock */
380 if (!logfs_check_ds(page_address(last
))) {
381 page_cache_release(first
);
385 /* Neither worked, sorry folks */
386 page_cache_release(first
);
387 page_cache_release(last
);
391 static int __logfs_read_sb(struct super_block
*sb
)
393 struct logfs_super
*super
= logfs_super(sb
);
395 struct logfs_disk_super
*ds
;
398 page
= find_super_block(sb
);
402 ds
= page_address(page
);
403 super
->s_size
= be64_to_cpu(ds
->ds_filesystem_size
);
404 super
->s_root_reserve
= be64_to_cpu(ds
->ds_root_reserve
);
405 super
->s_speed_reserve
= be64_to_cpu(ds
->ds_speed_reserve
);
406 super
->s_bad_seg_reserve
= be32_to_cpu(ds
->ds_bad_seg_reserve
);
407 super
->s_segsize
= 1 << ds
->ds_segment_shift
;
408 super
->s_segmask
= (1 << ds
->ds_segment_shift
) - 1;
409 super
->s_segshift
= ds
->ds_segment_shift
;
410 sb
->s_blocksize
= 1 << ds
->ds_block_shift
;
411 sb
->s_blocksize_bits
= ds
->ds_block_shift
;
412 super
->s_writesize
= 1 << ds
->ds_write_shift
;
413 super
->s_writeshift
= ds
->ds_write_shift
;
414 super
->s_no_segs
= super
->s_size
>> super
->s_segshift
;
415 super
->s_no_blocks
= super
->s_segsize
>> sb
->s_blocksize_bits
;
416 super
->s_feature_incompat
= be64_to_cpu(ds
->ds_feature_incompat
);
417 super
->s_feature_ro_compat
= be64_to_cpu(ds
->ds_feature_ro_compat
);
418 super
->s_feature_compat
= be64_to_cpu(ds
->ds_feature_compat
);
419 super
->s_feature_flags
= be64_to_cpu(ds
->ds_feature_flags
);
422 super
->s_journal_seg
[i
] = be32_to_cpu(ds
->ds_journal_seg
[i
]);
424 super
->s_ifile_levels
= ds
->ds_ifile_levels
;
425 super
->s_iblock_levels
= ds
->ds_iblock_levels
;
426 super
->s_data_levels
= ds
->ds_data_levels
;
427 super
->s_total_levels
= super
->s_ifile_levels
+ super
->s_iblock_levels
428 + super
->s_data_levels
;
429 page_cache_release(page
);
433 static int logfs_read_sb(struct super_block
*sb
, int read_only
)
435 struct logfs_super
*super
= logfs_super(sb
);
438 super
->s_btree_pool
= mempool_create(32, btree_alloc
, btree_free
, NULL
);
439 if (!super
->s_btree_pool
)
442 btree_init_mempool64(&super
->s_shadow_tree
.new, super
->s_btree_pool
);
443 btree_init_mempool64(&super
->s_shadow_tree
.old
, super
->s_btree_pool
);
444 btree_init_mempool32(&super
->s_shadow_tree
.segment_map
,
445 super
->s_btree_pool
);
447 ret
= logfs_init_mapping(sb
);
451 ret
= __logfs_read_sb(sb
);
455 if (super
->s_feature_incompat
& ~LOGFS_FEATURES_INCOMPAT
)
457 if ((super
->s_feature_ro_compat
& ~LOGFS_FEATURES_RO_COMPAT
) &&
461 ret
= logfs_init_rw(sb
);
465 ret
= logfs_init_areas(sb
);
469 ret
= logfs_init_gc(sb
);
473 ret
= logfs_init_journal(sb
);
480 static void logfs_kill_sb(struct super_block
*sb
)
482 struct logfs_super
*super
= logfs_super(sb
);
484 log_super("LogFS: Start unmounting\n");
485 /* Alias entries slow down mount, so evict as many as possible */
487 logfs_write_anchor(sb
);
490 * From this point on alias entries are simply dropped - and any
491 * writes to the object store are considered bugs.
493 super
->s_flags
|= LOGFS_SB_FLAG_SHUTDOWN
;
494 log_super("LogFS: Now in shutdown\n");
495 generic_shutdown_super(sb
);
497 BUG_ON(super
->s_dirty_used_bytes
|| super
->s_dirty_free_bytes
);
499 logfs_cleanup_gc(sb
);
500 logfs_cleanup_journal(sb
);
501 logfs_cleanup_areas(sb
);
502 logfs_cleanup_rw(sb
);
503 if (super
->s_erase_page
)
504 __free_page(super
->s_erase_page
);
505 super
->s_devops
->put_device(super
);
506 logfs_mempool_destroy(super
->s_btree_pool
);
507 logfs_mempool_destroy(super
->s_alias_pool
);
509 log_super("LogFS: Finished unmounting\n");
512 static struct dentry
*logfs_get_sb_device(struct logfs_super
*super
,
513 struct file_system_type
*type
, int flags
)
515 struct super_block
*sb
;
517 static int mount_count
;
519 log_super("LogFS: Start mount %x\n", mount_count
++);
522 sb
= sget(type
, logfs_sb_test
, logfs_sb_set
, super
);
524 super
->s_devops
->put_device(super
);
530 /* Device is already in use */
531 super
->s_devops
->put_device(super
);
533 return dget(sb
->s_root
);
537 * sb->s_maxbytes is limited to 8TB. On 32bit systems, the page cache
538 * only covers 16TB and the upper 8TB are used for indirect blocks.
539 * On 64bit system we could bump up the limit, but that would make
540 * the filesystem incompatible with 32bit systems.
542 sb
->s_maxbytes
= (1ull << 43) - 1;
543 sb
->s_op
= &logfs_super_operations
;
544 sb
->s_flags
= flags
| MS_NOATIME
;
546 err
= logfs_read_sb(sb
, sb
->s_flags
& MS_RDONLY
);
550 sb
->s_flags
|= MS_ACTIVE
;
551 err
= logfs_get_sb_final(sb
);
553 deactivate_locked_super(sb
);
556 return dget(sb
->s_root
);
559 /* no ->s_root, no ->put_super() */
560 iput(super
->s_master_inode
);
561 iput(super
->s_segfile_inode
);
562 iput(super
->s_mapping_inode
);
563 deactivate_locked_super(sb
);
567 static struct dentry
*logfs_mount(struct file_system_type
*type
, int flags
,
568 const char *devname
, void *data
)
571 struct logfs_super
*super
;
574 super
= kzalloc(sizeof(*super
), GFP_KERNEL
);
576 return ERR_PTR(-ENOMEM
);
578 mutex_init(&super
->s_dirop_mutex
);
579 mutex_init(&super
->s_object_alias_mutex
);
580 INIT_LIST_HEAD(&super
->s_freeing_list
);
583 err
= logfs_get_sb_bdev(super
, type
, devname
);
584 else if (strncmp(devname
, "mtd", 3))
585 err
= logfs_get_sb_bdev(super
, type
, devname
);
588 mtdnr
= simple_strtoul(devname
+3, &garbage
, 0);
592 err
= logfs_get_sb_mtd(super
, mtdnr
);
600 return logfs_get_sb_device(super
, type
, flags
);
603 static struct file_system_type logfs_fs_type
= {
604 .owner
= THIS_MODULE
,
606 .mount
= logfs_mount
,
607 .kill_sb
= logfs_kill_sb
,
608 .fs_flags
= FS_REQUIRES_DEV
,
612 static int __init
logfs_init(void)
616 emergency_page
= alloc_pages(GFP_KERNEL
, 0);
620 ret
= logfs_compr_init();
624 ret
= logfs_init_inode_cache();
628 return register_filesystem(&logfs_fs_type
);
632 __free_pages(emergency_page
, 0);
636 static void __exit
logfs_exit(void)
638 unregister_filesystem(&logfs_fs_type
);
639 logfs_destroy_inode_cache();
641 __free_pages(emergency_page
, 0);
644 module_init(logfs_init
);
645 module_exit(logfs_exit
);
647 MODULE_LICENSE("GPL v2");
648 MODULE_AUTHOR("Joern Engel <joern@logfs.org>");
649 MODULE_DESCRIPTION("scalable flash filesystem");