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/module.h>
17 #include <linux/mtd/mtd.h>
18 #include <linux/statfs.h>
19 #include <linux/buffer_head.h>
21 static DEFINE_MUTEX(emergency_mutex
);
22 static struct page
*emergency_page
;
24 struct page
*emergency_read_begin(struct address_space
*mapping
, pgoff_t index
)
26 filler_t
*filler
= (filler_t
*)mapping
->a_ops
->readpage
;
30 page
= read_cache_page(mapping
, index
, filler
, NULL
);
34 /* No more pages available, switch to emergency page */
35 printk(KERN_INFO
"Logfs: Using emergency page\n");
36 mutex_lock(&emergency_mutex
);
37 err
= filler(NULL
, emergency_page
);
39 mutex_unlock(&emergency_mutex
);
40 printk(KERN_EMERG
"Logfs: Error reading emergency page\n");
43 return emergency_page
;
46 void emergency_read_end(struct page
*page
)
48 if (page
== emergency_page
)
49 mutex_unlock(&emergency_mutex
);
51 page_cache_release(page
);
54 static void dump_segfile(struct super_block
*sb
)
56 struct logfs_super
*super
= logfs_super(sb
);
57 struct logfs_segment_entry se
;
60 for (segno
= 0; segno
< super
->s_no_segs
; segno
++) {
61 logfs_get_segment_entry(sb
, segno
, &se
);
62 printk("%3x: %6x %8x", segno
, be32_to_cpu(se
.ec_level
),
63 be32_to_cpu(se
.valid
));
64 if (++segno
< super
->s_no_segs
) {
65 logfs_get_segment_entry(sb
, segno
, &se
);
66 printk(" %6x %8x", be32_to_cpu(se
.ec_level
),
67 be32_to_cpu(se
.valid
));
69 if (++segno
< super
->s_no_segs
) {
70 logfs_get_segment_entry(sb
, segno
, &se
);
71 printk(" %6x %8x", be32_to_cpu(se
.ec_level
),
72 be32_to_cpu(se
.valid
));
74 if (++segno
< super
->s_no_segs
) {
75 logfs_get_segment_entry(sb
, segno
, &se
);
76 printk(" %6x %8x", be32_to_cpu(se
.ec_level
),
77 be32_to_cpu(se
.valid
));
84 * logfs_crash_dump - dump debug information to device
86 * The LogFS superblock only occupies part of a segment. This function will
87 * write as much debug information as it can gather into the spare space.
89 void logfs_crash_dump(struct super_block
*sb
)
95 * FIXME: There should be a reserve for root, similar to ext2.
97 int logfs_statfs(struct dentry
*dentry
, struct kstatfs
*stats
)
99 struct super_block
*sb
= dentry
->d_sb
;
100 struct logfs_super
*super
= logfs_super(sb
);
102 stats
->f_type
= LOGFS_MAGIC_U32
;
103 stats
->f_bsize
= sb
->s_blocksize
;
104 stats
->f_blocks
= super
->s_size
>> LOGFS_BLOCK_BITS
>> 3;
105 stats
->f_bfree
= super
->s_free_bytes
>> sb
->s_blocksize_bits
;
106 stats
->f_bavail
= super
->s_free_bytes
>> sb
->s_blocksize_bits
;
109 stats
->f_namelen
= LOGFS_MAX_NAMELEN
;
113 static int logfs_sb_set(struct super_block
*sb
, void *_super
)
115 struct logfs_super
*super
= _super
;
117 sb
->s_fs_info
= super
;
118 sb
->s_mtd
= super
->s_mtd
;
119 sb
->s_bdev
= super
->s_bdev
;
122 sb
->s_bdi
= &bdev_get_queue(sb
->s_bdev
)->backing_dev_info
;
126 sb
->s_bdi
= sb
->s_mtd
->backing_dev_info
;
131 static int logfs_sb_test(struct super_block
*sb
, void *_super
)
133 struct logfs_super
*super
= _super
;
134 struct mtd_info
*mtd
= super
->s_mtd
;
136 if (mtd
&& sb
->s_mtd
== mtd
)
138 if (super
->s_bdev
&& sb
->s_bdev
== super
->s_bdev
)
143 static void set_segment_header(struct logfs_segment_header
*sh
, u8 type
,
144 u8 level
, u32 segno
, u32 ec
)
149 sh
->segno
= cpu_to_be32(segno
);
150 sh
->ec
= cpu_to_be32(ec
);
151 sh
->gec
= cpu_to_be64(segno
);
152 sh
->crc
= logfs_crc32(sh
, LOGFS_SEGMENT_HEADERSIZE
, 4);
155 static void logfs_write_ds(struct super_block
*sb
, struct logfs_disk_super
*ds
,
158 struct logfs_super
*super
= logfs_super(sb
);
159 struct logfs_segment_header
*sh
= &ds
->ds_sh
;
162 memset(ds
, 0, sizeof(*ds
));
163 set_segment_header(sh
, SEG_SUPER
, 0, segno
, ec
);
165 ds
->ds_ifile_levels
= super
->s_ifile_levels
;
166 ds
->ds_iblock_levels
= super
->s_iblock_levels
;
167 ds
->ds_data_levels
= super
->s_data_levels
; /* XXX: Remove */
168 ds
->ds_segment_shift
= super
->s_segshift
;
169 ds
->ds_block_shift
= sb
->s_blocksize_bits
;
170 ds
->ds_write_shift
= super
->s_writeshift
;
171 ds
->ds_filesystem_size
= cpu_to_be64(super
->s_size
);
172 ds
->ds_segment_size
= cpu_to_be32(super
->s_segsize
);
173 ds
->ds_bad_seg_reserve
= cpu_to_be32(super
->s_bad_seg_reserve
);
174 ds
->ds_feature_incompat
= cpu_to_be64(super
->s_feature_incompat
);
175 ds
->ds_feature_ro_compat
= cpu_to_be64(super
->s_feature_ro_compat
);
176 ds
->ds_feature_compat
= cpu_to_be64(super
->s_feature_compat
);
177 ds
->ds_feature_flags
= cpu_to_be64(super
->s_feature_flags
);
178 ds
->ds_root_reserve
= cpu_to_be64(super
->s_root_reserve
);
179 ds
->ds_speed_reserve
= cpu_to_be64(super
->s_speed_reserve
);
181 ds
->ds_journal_seg
[i
] = cpu_to_be32(super
->s_journal_seg
[i
]);
182 ds
->ds_magic
= cpu_to_be64(LOGFS_MAGIC
);
183 ds
->ds_crc
= logfs_crc32(ds
, sizeof(*ds
),
184 LOGFS_SEGMENT_HEADERSIZE
+ 12);
187 static int write_one_sb(struct super_block
*sb
,
188 struct page
*(*find_sb
)(struct super_block
*sb
, u64
*ofs
))
190 struct logfs_super
*super
= logfs_super(sb
);
191 struct logfs_disk_super
*ds
;
192 struct logfs_segment_entry se
;
198 page
= find_sb(sb
, &ofs
);
201 ds
= page_address(page
);
202 segno
= seg_no(sb
, ofs
);
203 logfs_get_segment_entry(sb
, segno
, &se
);
204 ec
= be32_to_cpu(se
.ec_level
) >> 4;
206 logfs_set_segment_erased(sb
, segno
, ec
, 0);
207 logfs_write_ds(sb
, ds
, segno
, ec
);
208 err
= super
->s_devops
->write_sb(sb
, page
);
209 page_cache_release(page
);
213 int logfs_write_sb(struct super_block
*sb
)
215 struct logfs_super
*super
= logfs_super(sb
);
218 /* First superblock */
219 err
= write_one_sb(sb
, super
->s_devops
->find_first_sb
);
223 /* Last superblock */
224 err
= write_one_sb(sb
, super
->s_devops
->find_last_sb
);
230 static int ds_cmp(const void *ds0
, const void *ds1
)
232 size_t len
= sizeof(struct logfs_disk_super
);
234 /* We know the segment headers differ, so ignore them */
235 len
-= LOGFS_SEGMENT_HEADERSIZE
;
236 ds0
+= LOGFS_SEGMENT_HEADERSIZE
;
237 ds1
+= LOGFS_SEGMENT_HEADERSIZE
;
238 return memcmp(ds0
, ds1
, len
);
241 static int logfs_recover_sb(struct super_block
*sb
)
243 struct logfs_super
*super
= logfs_super(sb
);
244 struct logfs_disk_super _ds0
, *ds0
= &_ds0
;
245 struct logfs_disk_super _ds1
, *ds1
= &_ds1
;
246 int err
, valid0
, valid1
;
248 /* read first superblock */
249 err
= wbuf_read(sb
, super
->s_sb_ofs
[0], sizeof(*ds0
), ds0
);
252 /* read last superblock */
253 err
= wbuf_read(sb
, super
->s_sb_ofs
[1], sizeof(*ds1
), ds1
);
256 valid0
= logfs_check_ds(ds0
) == 0;
257 valid1
= logfs_check_ds(ds1
) == 0;
259 if (!valid0
&& valid1
) {
260 printk(KERN_INFO
"First superblock is invalid - fixing.\n");
261 return write_one_sb(sb
, super
->s_devops
->find_first_sb
);
263 if (valid0
&& !valid1
) {
264 printk(KERN_INFO
"Last superblock is invalid - fixing.\n");
265 return write_one_sb(sb
, super
->s_devops
->find_last_sb
);
267 if (valid0
&& valid1
&& ds_cmp(ds0
, ds1
)) {
268 printk(KERN_INFO
"Superblocks don't match - fixing.\n");
269 return logfs_write_sb(sb
);
271 /* If neither is valid now, something's wrong. Didn't we properly
272 * check them before?!? */
273 BUG_ON(!valid0
&& !valid1
);
277 static int logfs_make_writeable(struct super_block
*sb
)
281 err
= logfs_open_segfile(sb
);
285 /* Repair any broken superblock copies */
286 err
= logfs_recover_sb(sb
);
290 /* Check areas for trailing unaccounted data */
291 err
= logfs_check_areas(sb
);
295 /* Do one GC pass before any data gets dirtied */
298 /* after all initializations are done, replay the journal
299 * for rw-mounts, if necessary */
300 err
= logfs_replay_journal(sb
);
307 static int logfs_get_sb_final(struct super_block
*sb
)
309 struct logfs_super
*super
= logfs_super(sb
);
310 struct inode
*rootdir
;
314 rootdir
= logfs_iget(sb
, LOGFS_INO_ROOT
);
318 sb
->s_root
= d_alloc_root(rootdir
);
324 /* at that point we know that ->put_super() will be called */
325 super
->s_erase_page
= alloc_pages(GFP_KERNEL
, 0);
326 if (!super
->s_erase_page
)
328 memset(page_address(super
->s_erase_page
), 0xFF, PAGE_SIZE
);
330 /* FIXME: check for read-only mounts */
331 err
= logfs_make_writeable(sb
);
333 __free_page(super
->s_erase_page
);
337 log_super("LogFS: Finished mounting\n");
341 iput(super
->s_master_inode
);
342 iput(super
->s_segfile_inode
);
343 iput(super
->s_mapping_inode
);
347 int logfs_check_ds(struct logfs_disk_super
*ds
)
349 struct logfs_segment_header
*sh
= &ds
->ds_sh
;
351 if (ds
->ds_magic
!= cpu_to_be64(LOGFS_MAGIC
))
353 if (sh
->crc
!= logfs_crc32(sh
, LOGFS_SEGMENT_HEADERSIZE
, 4))
355 if (ds
->ds_crc
!= logfs_crc32(ds
, sizeof(*ds
),
356 LOGFS_SEGMENT_HEADERSIZE
+ 12))
361 static struct page
*find_super_block(struct super_block
*sb
)
363 struct logfs_super
*super
= logfs_super(sb
);
364 struct page
*first
, *last
;
366 first
= super
->s_devops
->find_first_sb(sb
, &super
->s_sb_ofs
[0]);
367 if (!first
|| IS_ERR(first
))
369 last
= super
->s_devops
->find_last_sb(sb
, &super
->s_sb_ofs
[1]);
370 if (!last
|| IS_ERR(last
)) {
371 page_cache_release(first
);
375 if (!logfs_check_ds(page_address(first
))) {
376 page_cache_release(last
);
380 /* First one didn't work, try the second superblock */
381 if (!logfs_check_ds(page_address(last
))) {
382 page_cache_release(first
);
386 /* Neither worked, sorry folks */
387 page_cache_release(first
);
388 page_cache_release(last
);
392 static int __logfs_read_sb(struct super_block
*sb
)
394 struct logfs_super
*super
= logfs_super(sb
);
396 struct logfs_disk_super
*ds
;
399 page
= find_super_block(sb
);
403 ds
= page_address(page
);
404 super
->s_size
= be64_to_cpu(ds
->ds_filesystem_size
);
405 super
->s_root_reserve
= be64_to_cpu(ds
->ds_root_reserve
);
406 super
->s_speed_reserve
= be64_to_cpu(ds
->ds_speed_reserve
);
407 super
->s_bad_seg_reserve
= be32_to_cpu(ds
->ds_bad_seg_reserve
);
408 super
->s_segsize
= 1 << ds
->ds_segment_shift
;
409 super
->s_segmask
= (1 << ds
->ds_segment_shift
) - 1;
410 super
->s_segshift
= ds
->ds_segment_shift
;
411 sb
->s_blocksize
= 1 << ds
->ds_block_shift
;
412 sb
->s_blocksize_bits
= ds
->ds_block_shift
;
413 super
->s_writesize
= 1 << ds
->ds_write_shift
;
414 super
->s_writeshift
= ds
->ds_write_shift
;
415 super
->s_no_segs
= super
->s_size
>> super
->s_segshift
;
416 super
->s_no_blocks
= super
->s_segsize
>> sb
->s_blocksize_bits
;
417 super
->s_feature_incompat
= be64_to_cpu(ds
->ds_feature_incompat
);
418 super
->s_feature_ro_compat
= be64_to_cpu(ds
->ds_feature_ro_compat
);
419 super
->s_feature_compat
= be64_to_cpu(ds
->ds_feature_compat
);
420 super
->s_feature_flags
= be64_to_cpu(ds
->ds_feature_flags
);
423 super
->s_journal_seg
[i
] = be32_to_cpu(ds
->ds_journal_seg
[i
]);
425 super
->s_ifile_levels
= ds
->ds_ifile_levels
;
426 super
->s_iblock_levels
= ds
->ds_iblock_levels
;
427 super
->s_data_levels
= ds
->ds_data_levels
;
428 super
->s_total_levels
= super
->s_ifile_levels
+ super
->s_iblock_levels
429 + super
->s_data_levels
;
430 page_cache_release(page
);
434 static int logfs_read_sb(struct super_block
*sb
, int read_only
)
436 struct logfs_super
*super
= logfs_super(sb
);
439 super
->s_btree_pool
= mempool_create(32, btree_alloc
, btree_free
, NULL
);
440 if (!super
->s_btree_pool
)
443 btree_init_mempool64(&super
->s_shadow_tree
.new, super
->s_btree_pool
);
444 btree_init_mempool64(&super
->s_shadow_tree
.old
, super
->s_btree_pool
);
445 btree_init_mempool32(&super
->s_shadow_tree
.segment_map
,
446 super
->s_btree_pool
);
448 ret
= logfs_init_mapping(sb
);
452 ret
= __logfs_read_sb(sb
);
456 if (super
->s_feature_incompat
& ~LOGFS_FEATURES_INCOMPAT
)
458 if ((super
->s_feature_ro_compat
& ~LOGFS_FEATURES_RO_COMPAT
) &&
462 ret
= logfs_init_rw(sb
);
466 ret
= logfs_init_areas(sb
);
470 ret
= logfs_init_gc(sb
);
474 ret
= logfs_init_journal(sb
);
481 static void logfs_kill_sb(struct super_block
*sb
)
483 struct logfs_super
*super
= logfs_super(sb
);
485 log_super("LogFS: Start unmounting\n");
486 /* Alias entries slow down mount, so evict as many as possible */
488 logfs_write_anchor(sb
);
491 * From this point on alias entries are simply dropped - and any
492 * writes to the object store are considered bugs.
494 super
->s_flags
|= LOGFS_SB_FLAG_SHUTDOWN
;
495 log_super("LogFS: Now in shutdown\n");
496 generic_shutdown_super(sb
);
498 BUG_ON(super
->s_dirty_used_bytes
|| super
->s_dirty_free_bytes
);
500 logfs_cleanup_gc(sb
);
501 logfs_cleanup_journal(sb
);
502 logfs_cleanup_areas(sb
);
503 logfs_cleanup_rw(sb
);
504 if (super
->s_erase_page
)
505 __free_page(super
->s_erase_page
);
506 super
->s_devops
->put_device(super
);
507 logfs_mempool_destroy(super
->s_btree_pool
);
508 logfs_mempool_destroy(super
->s_alias_pool
);
510 log_super("LogFS: Finished unmounting\n");
513 static struct dentry
*logfs_get_sb_device(struct logfs_super
*super
,
514 struct file_system_type
*type
, int flags
)
516 struct super_block
*sb
;
518 static int mount_count
;
520 log_super("LogFS: Start mount %x\n", mount_count
++);
523 sb
= sget(type
, logfs_sb_test
, logfs_sb_set
, super
);
525 super
->s_devops
->put_device(super
);
531 /* Device is already in use */
532 super
->s_devops
->put_device(super
);
534 return dget(sb
->s_root
);
538 * sb->s_maxbytes is limited to 8TB. On 32bit systems, the page cache
539 * only covers 16TB and the upper 8TB are used for indirect blocks.
540 * On 64bit system we could bump up the limit, but that would make
541 * the filesystem incompatible with 32bit systems.
543 sb
->s_maxbytes
= (1ull << 43) - 1;
544 sb
->s_op
= &logfs_super_operations
;
545 sb
->s_flags
= flags
| MS_NOATIME
;
547 err
= logfs_read_sb(sb
, sb
->s_flags
& MS_RDONLY
);
551 sb
->s_flags
|= MS_ACTIVE
;
552 err
= logfs_get_sb_final(sb
);
554 deactivate_locked_super(sb
);
557 return dget(sb
->s_root
);
560 /* no ->s_root, no ->put_super() */
561 iput(super
->s_master_inode
);
562 iput(super
->s_segfile_inode
);
563 iput(super
->s_mapping_inode
);
564 deactivate_locked_super(sb
);
568 static struct dentry
*logfs_mount(struct file_system_type
*type
, int flags
,
569 const char *devname
, void *data
)
572 struct logfs_super
*super
;
575 super
= kzalloc(sizeof(*super
), GFP_KERNEL
);
577 return ERR_PTR(-ENOMEM
);
579 mutex_init(&super
->s_dirop_mutex
);
580 mutex_init(&super
->s_object_alias_mutex
);
581 INIT_LIST_HEAD(&super
->s_freeing_list
);
584 err
= logfs_get_sb_bdev(super
, type
, devname
);
585 else if (strncmp(devname
, "mtd", 3))
586 err
= logfs_get_sb_bdev(super
, type
, devname
);
589 mtdnr
= simple_strtoul(devname
+3, &garbage
, 0);
593 err
= logfs_get_sb_mtd(super
, mtdnr
);
601 return logfs_get_sb_device(super
, type
, flags
);
604 static struct file_system_type logfs_fs_type
= {
605 .owner
= THIS_MODULE
,
607 .mount
= logfs_mount
,
608 .kill_sb
= logfs_kill_sb
,
609 .fs_flags
= FS_REQUIRES_DEV
,
613 static int __init
logfs_init(void)
617 emergency_page
= alloc_pages(GFP_KERNEL
, 0);
621 ret
= logfs_compr_init();
625 ret
= logfs_init_inode_cache();
629 return register_filesystem(&logfs_fs_type
);
633 __free_pages(emergency_page
, 0);
637 static void __exit
logfs_exit(void)
639 unregister_filesystem(&logfs_fs_type
);
640 logfs_destroy_inode_cache();
642 __free_pages(emergency_page
, 0);
645 module_init(logfs_init
);
646 module_exit(logfs_exit
);
648 MODULE_LICENSE("GPL v2");
649 MODULE_AUTHOR("Joern Engel <joern@logfs.org>");
650 MODULE_DESCRIPTION("scalable flash filesystem");