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 * TODO: move to lib/string.c
97 * memchr_inv - Find a character in an area of memory.
99 * @c: The byte to search for
100 * @n: The size of the area.
102 * returns the address of the first character other than @c, or %NULL
103 * if the whole buffer contains just @c.
105 void *memchr_inv(const void *s
, int c
, size_t n
)
107 const unsigned char *p
= s
;
109 if ((unsigned char)c
!= *p
++)
110 return (void *)(p
- 1);
115 int logfs_statfs(struct dentry
*dentry
, struct kstatfs
*stats
)
117 struct super_block
*sb
= dentry
->d_sb
;
118 struct logfs_super
*super
= logfs_super(sb
);
120 stats
->f_type
= LOGFS_MAGIC_U32
;
121 stats
->f_bsize
= sb
->s_blocksize
;
122 stats
->f_blocks
= super
->s_size
>> LOGFS_BLOCK_BITS
>> 3;
123 stats
->f_bfree
= super
->s_free_bytes
>> sb
->s_blocksize_bits
;
124 stats
->f_bavail
= super
->s_free_bytes
>> sb
->s_blocksize_bits
;
127 stats
->f_namelen
= LOGFS_MAX_NAMELEN
;
131 static int logfs_sb_set(struct super_block
*sb
, void *_super
)
133 struct logfs_super
*super
= _super
;
135 sb
->s_fs_info
= super
;
136 sb
->s_mtd
= super
->s_mtd
;
137 sb
->s_bdev
= super
->s_bdev
;
140 sb
->s_bdi
= &bdev_get_queue(sb
->s_bdev
)->backing_dev_info
;
144 sb
->s_bdi
= sb
->s_mtd
->backing_dev_info
;
149 static int logfs_sb_test(struct super_block
*sb
, void *_super
)
151 struct logfs_super
*super
= _super
;
152 struct mtd_info
*mtd
= super
->s_mtd
;
154 if (mtd
&& sb
->s_mtd
== mtd
)
156 if (super
->s_bdev
&& sb
->s_bdev
== super
->s_bdev
)
161 static void set_segment_header(struct logfs_segment_header
*sh
, u8 type
,
162 u8 level
, u32 segno
, u32 ec
)
167 sh
->segno
= cpu_to_be32(segno
);
168 sh
->ec
= cpu_to_be32(ec
);
169 sh
->gec
= cpu_to_be64(segno
);
170 sh
->crc
= logfs_crc32(sh
, LOGFS_SEGMENT_HEADERSIZE
, 4);
173 static void logfs_write_ds(struct super_block
*sb
, struct logfs_disk_super
*ds
,
176 struct logfs_super
*super
= logfs_super(sb
);
177 struct logfs_segment_header
*sh
= &ds
->ds_sh
;
180 memset(ds
, 0, sizeof(*ds
));
181 set_segment_header(sh
, SEG_SUPER
, 0, segno
, ec
);
183 ds
->ds_ifile_levels
= super
->s_ifile_levels
;
184 ds
->ds_iblock_levels
= super
->s_iblock_levels
;
185 ds
->ds_data_levels
= super
->s_data_levels
;
186 ds
->ds_segment_shift
= super
->s_segshift
;
187 ds
->ds_block_shift
= sb
->s_blocksize_bits
;
188 ds
->ds_write_shift
= super
->s_writeshift
;
189 ds
->ds_filesystem_size
= cpu_to_be64(super
->s_size
);
190 ds
->ds_segment_size
= cpu_to_be32(super
->s_segsize
);
191 ds
->ds_bad_seg_reserve
= cpu_to_be32(super
->s_bad_seg_reserve
);
192 ds
->ds_feature_incompat
= cpu_to_be64(super
->s_feature_incompat
);
193 ds
->ds_feature_ro_compat
= cpu_to_be64(super
->s_feature_ro_compat
);
194 ds
->ds_feature_compat
= cpu_to_be64(super
->s_feature_compat
);
195 ds
->ds_feature_flags
= cpu_to_be64(super
->s_feature_flags
);
196 ds
->ds_root_reserve
= cpu_to_be64(super
->s_root_reserve
);
197 ds
->ds_speed_reserve
= cpu_to_be64(super
->s_speed_reserve
);
199 ds
->ds_journal_seg
[i
] = cpu_to_be32(super
->s_journal_seg
[i
]);
200 ds
->ds_magic
= cpu_to_be64(LOGFS_MAGIC
);
201 ds
->ds_crc
= logfs_crc32(ds
, sizeof(*ds
),
202 LOGFS_SEGMENT_HEADERSIZE
+ 12);
205 static int write_one_sb(struct super_block
*sb
,
206 struct page
*(*find_sb
)(struct super_block
*sb
, u64
*ofs
))
208 struct logfs_super
*super
= logfs_super(sb
);
209 struct logfs_disk_super
*ds
;
210 struct logfs_segment_entry se
;
216 page
= find_sb(sb
, &ofs
);
219 ds
= page_address(page
);
220 segno
= seg_no(sb
, ofs
);
221 logfs_get_segment_entry(sb
, segno
, &se
);
222 ec
= be32_to_cpu(se
.ec_level
) >> 4;
224 logfs_set_segment_erased(sb
, segno
, ec
, 0);
225 logfs_write_ds(sb
, ds
, segno
, ec
);
226 err
= super
->s_devops
->write_sb(sb
, page
);
227 page_cache_release(page
);
231 int logfs_write_sb(struct super_block
*sb
)
233 struct logfs_super
*super
= logfs_super(sb
);
236 /* First superblock */
237 err
= write_one_sb(sb
, super
->s_devops
->find_first_sb
);
241 /* Last superblock */
242 err
= write_one_sb(sb
, super
->s_devops
->find_last_sb
);
248 static int ds_cmp(const void *ds0
, const void *ds1
)
250 size_t len
= sizeof(struct logfs_disk_super
);
252 /* We know the segment headers differ, so ignore them */
253 len
-= LOGFS_SEGMENT_HEADERSIZE
;
254 ds0
+= LOGFS_SEGMENT_HEADERSIZE
;
255 ds1
+= LOGFS_SEGMENT_HEADERSIZE
;
256 return memcmp(ds0
, ds1
, len
);
259 static int logfs_recover_sb(struct super_block
*sb
)
261 struct logfs_super
*super
= logfs_super(sb
);
262 struct logfs_disk_super _ds0
, *ds0
= &_ds0
;
263 struct logfs_disk_super _ds1
, *ds1
= &_ds1
;
264 int err
, valid0
, valid1
;
266 /* read first superblock */
267 err
= wbuf_read(sb
, super
->s_sb_ofs
[0], sizeof(*ds0
), ds0
);
270 /* read last superblock */
271 err
= wbuf_read(sb
, super
->s_sb_ofs
[1], sizeof(*ds1
), ds1
);
274 valid0
= logfs_check_ds(ds0
) == 0;
275 valid1
= logfs_check_ds(ds1
) == 0;
277 if (!valid0
&& valid1
) {
278 printk(KERN_INFO
"First superblock is invalid - fixing.\n");
279 return write_one_sb(sb
, super
->s_devops
->find_first_sb
);
281 if (valid0
&& !valid1
) {
282 printk(KERN_INFO
"Last superblock is invalid - fixing.\n");
283 return write_one_sb(sb
, super
->s_devops
->find_last_sb
);
285 if (valid0
&& valid1
&& ds_cmp(ds0
, ds1
)) {
286 printk(KERN_INFO
"Superblocks don't match - fixing.\n");
287 return logfs_write_sb(sb
);
289 /* If neither is valid now, something's wrong. Didn't we properly
290 * check them before?!? */
291 BUG_ON(!valid0
&& !valid1
);
295 static int logfs_make_writeable(struct super_block
*sb
)
299 err
= logfs_open_segfile(sb
);
303 /* Repair any broken superblock copies */
304 err
= logfs_recover_sb(sb
);
308 /* Check areas for trailing unaccounted data */
309 err
= logfs_check_areas(sb
);
313 /* Do one GC pass before any data gets dirtied */
316 /* after all initializations are done, replay the journal
317 * for rw-mounts, if necessary */
318 err
= logfs_replay_journal(sb
);
325 static int logfs_get_sb_final(struct super_block
*sb
, struct vfsmount
*mnt
)
327 struct logfs_super
*super
= logfs_super(sb
);
328 struct inode
*rootdir
;
332 rootdir
= logfs_iget(sb
, LOGFS_INO_ROOT
);
336 sb
->s_root
= d_alloc_root(rootdir
);
342 /* at that point we know that ->put_super() will be called */
343 super
->s_erase_page
= alloc_pages(GFP_KERNEL
, 0);
344 if (!super
->s_erase_page
)
346 memset(page_address(super
->s_erase_page
), 0xFF, PAGE_SIZE
);
348 err
= logfs_make_writeable(sb
);
350 __free_page(super
->s_erase_page
);
354 log_super("LogFS: Finished mounting\n");
355 simple_set_mnt(mnt
, sb
);
359 iput(super
->s_master_inode
);
360 iput(super
->s_segfile_inode
);
361 iput(super
->s_mapping_inode
);
365 int logfs_check_ds(struct logfs_disk_super
*ds
)
367 struct logfs_segment_header
*sh
= &ds
->ds_sh
;
369 if (ds
->ds_magic
!= cpu_to_be64(LOGFS_MAGIC
))
371 if (sh
->crc
!= logfs_crc32(sh
, LOGFS_SEGMENT_HEADERSIZE
, 4))
373 if (ds
->ds_crc
!= logfs_crc32(ds
, sizeof(*ds
),
374 LOGFS_SEGMENT_HEADERSIZE
+ 12))
379 static struct page
*find_super_block(struct super_block
*sb
)
381 struct logfs_super
*super
= logfs_super(sb
);
382 struct page
*first
, *last
;
384 first
= super
->s_devops
->find_first_sb(sb
, &super
->s_sb_ofs
[0]);
385 if (!first
|| IS_ERR(first
))
387 last
= super
->s_devops
->find_last_sb(sb
, &super
->s_sb_ofs
[1]);
388 if (!last
|| IS_ERR(last
)) {
389 page_cache_release(first
);
393 if (!logfs_check_ds(page_address(first
))) {
394 page_cache_release(last
);
398 /* First one didn't work, try the second superblock */
399 if (!logfs_check_ds(page_address(last
))) {
400 page_cache_release(first
);
404 /* Neither worked, sorry folks */
405 page_cache_release(first
);
406 page_cache_release(last
);
410 static int __logfs_read_sb(struct super_block
*sb
)
412 struct logfs_super
*super
= logfs_super(sb
);
414 struct logfs_disk_super
*ds
;
417 page
= find_super_block(sb
);
421 ds
= page_address(page
);
422 super
->s_size
= be64_to_cpu(ds
->ds_filesystem_size
);
423 super
->s_root_reserve
= be64_to_cpu(ds
->ds_root_reserve
);
424 super
->s_speed_reserve
= be64_to_cpu(ds
->ds_speed_reserve
);
425 super
->s_bad_seg_reserve
= be32_to_cpu(ds
->ds_bad_seg_reserve
);
426 super
->s_segsize
= 1 << ds
->ds_segment_shift
;
427 super
->s_segmask
= (1 << ds
->ds_segment_shift
) - 1;
428 super
->s_segshift
= ds
->ds_segment_shift
;
429 sb
->s_blocksize
= 1 << ds
->ds_block_shift
;
430 sb
->s_blocksize_bits
= ds
->ds_block_shift
;
431 super
->s_writesize
= 1 << ds
->ds_write_shift
;
432 super
->s_writeshift
= ds
->ds_write_shift
;
433 super
->s_no_segs
= super
->s_size
>> super
->s_segshift
;
434 super
->s_no_blocks
= super
->s_segsize
>> sb
->s_blocksize_bits
;
435 super
->s_feature_incompat
= be64_to_cpu(ds
->ds_feature_incompat
);
436 super
->s_feature_ro_compat
= be64_to_cpu(ds
->ds_feature_ro_compat
);
437 super
->s_feature_compat
= be64_to_cpu(ds
->ds_feature_compat
);
438 super
->s_feature_flags
= be64_to_cpu(ds
->ds_feature_flags
);
441 super
->s_journal_seg
[i
] = be32_to_cpu(ds
->ds_journal_seg
[i
]);
443 super
->s_ifile_levels
= ds
->ds_ifile_levels
;
444 super
->s_iblock_levels
= ds
->ds_iblock_levels
;
445 super
->s_data_levels
= ds
->ds_data_levels
;
446 super
->s_total_levels
= super
->s_ifile_levels
+ super
->s_iblock_levels
447 + super
->s_data_levels
;
448 page_cache_release(page
);
452 static int logfs_read_sb(struct super_block
*sb
, int read_only
)
454 struct logfs_super
*super
= logfs_super(sb
);
457 super
->s_btree_pool
= mempool_create(32, btree_alloc
, btree_free
, NULL
);
458 if (!super
->s_btree_pool
)
461 btree_init_mempool64(&super
->s_shadow_tree
.new, super
->s_btree_pool
);
462 btree_init_mempool64(&super
->s_shadow_tree
.old
, super
->s_btree_pool
);
463 btree_init_mempool32(&super
->s_shadow_tree
.segment_map
,
464 super
->s_btree_pool
);
466 ret
= logfs_init_mapping(sb
);
470 ret
= __logfs_read_sb(sb
);
474 if (super
->s_feature_incompat
& ~LOGFS_FEATURES_INCOMPAT
)
476 if ((super
->s_feature_ro_compat
& ~LOGFS_FEATURES_RO_COMPAT
) &&
480 mutex_init(&super
->s_dirop_mutex
);
481 mutex_init(&super
->s_object_alias_mutex
);
482 INIT_LIST_HEAD(&super
->s_freeing_list
);
484 ret
= logfs_init_rw(sb
);
488 ret
= logfs_init_areas(sb
);
492 ret
= logfs_init_gc(sb
);
496 ret
= logfs_init_journal(sb
);
503 static void logfs_kill_sb(struct super_block
*sb
)
505 struct logfs_super
*super
= logfs_super(sb
);
507 log_super("LogFS: Start unmounting\n");
508 /* Alias entries slow down mount, so evict as many as possible */
510 logfs_write_anchor(sb
);
513 * From this point on alias entries are simply dropped - and any
514 * writes to the object store are considered bugs.
516 super
->s_flags
|= LOGFS_SB_FLAG_SHUTDOWN
;
517 log_super("LogFS: Now in shutdown\n");
518 generic_shutdown_super(sb
);
520 BUG_ON(super
->s_dirty_used_bytes
|| super
->s_dirty_free_bytes
);
522 logfs_cleanup_gc(sb
);
523 logfs_cleanup_journal(sb
);
524 logfs_cleanup_areas(sb
);
525 logfs_cleanup_rw(sb
);
526 if (super
->s_erase_page
)
527 __free_page(super
->s_erase_page
);
528 super
->s_devops
->put_device(sb
);
529 logfs_mempool_destroy(super
->s_btree_pool
);
530 logfs_mempool_destroy(super
->s_alias_pool
);
532 log_super("LogFS: Finished unmounting\n");
535 int logfs_get_sb_device(struct file_system_type
*type
, int flags
,
536 struct mtd_info
*mtd
, struct block_device
*bdev
,
537 const struct logfs_device_ops
*devops
, struct vfsmount
*mnt
)
539 struct logfs_super
*super
;
540 struct super_block
*sb
;
542 static int mount_count
;
544 log_super("LogFS: Start mount %x\n", mount_count
++);
545 super
= kzalloc(sizeof(*super
), GFP_KERNEL
);
550 super
->s_bdev
= bdev
;
552 sb
= sget(type
, logfs_sb_test
, logfs_sb_set
, super
);
557 /* Device is already in use */
559 simple_set_mnt(mnt
, sb
);
563 super
->s_devops
= devops
;
566 * sb->s_maxbytes is limited to 8TB. On 32bit systems, the page cache
567 * only covers 16TB and the upper 8TB are used for indirect blocks.
568 * On 64bit system we could bump up the limit, but that would make
569 * the filesystem incompatible with 32bit systems.
571 sb
->s_maxbytes
= (1ull << 43) - 1;
572 sb
->s_op
= &logfs_super_operations
;
573 sb
->s_flags
= flags
| MS_NOATIME
;
575 err
= logfs_read_sb(sb
, sb
->s_flags
& MS_RDONLY
);
579 sb
->s_flags
|= MS_ACTIVE
;
580 err
= logfs_get_sb_final(sb
, mnt
);
582 deactivate_locked_super(sb
);
586 /* no ->s_root, no ->put_super() */
587 iput(super
->s_master_inode
);
588 iput(super
->s_segfile_inode
);
589 iput(super
->s_mapping_inode
);
590 deactivate_locked_super(sb
);
594 //devops->put_device(sb);
598 static int logfs_get_sb(struct file_system_type
*type
, int flags
,
599 const char *devname
, void *data
, struct vfsmount
*mnt
)
604 return logfs_get_sb_bdev(type
, flags
, devname
, mnt
);
605 if (strncmp(devname
, "mtd", 3))
606 return logfs_get_sb_bdev(type
, flags
, devname
, mnt
);
610 mtdnr
= simple_strtoul(devname
+3, &garbage
, 0);
615 return logfs_get_sb_mtd(type
, flags
, mtdnr
, mnt
);
618 static struct file_system_type logfs_fs_type
= {
619 .owner
= THIS_MODULE
,
621 .get_sb
= logfs_get_sb
,
622 .kill_sb
= logfs_kill_sb
,
623 .fs_flags
= FS_REQUIRES_DEV
,
627 static int __init
logfs_init(void)
631 emergency_page
= alloc_pages(GFP_KERNEL
, 0);
635 ret
= logfs_compr_init();
639 ret
= logfs_init_inode_cache();
643 return register_filesystem(&logfs_fs_type
);
647 __free_pages(emergency_page
, 0);
651 static void __exit
logfs_exit(void)
653 unregister_filesystem(&logfs_fs_type
);
654 logfs_destroy_inode_cache();
656 __free_pages(emergency_page
, 0);
659 module_init(logfs_init
);
660 module_exit(logfs_exit
);
662 MODULE_LICENSE("GPL v2");
663 MODULE_AUTHOR("Joern Engel <joern@logfs.org>");
664 MODULE_DESCRIPTION("scalable flash filesystem");