[LogFS] add new flash file system
[linux-2.6.git] / fs / logfs / logfs.h
1 /*
2  * fs/logfs/logfs.h
3  *
4  * As should be obvious for Linux kernel code, license is GPLv2
5  *
6  * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
7  *
8  * Private header for logfs.
9  */
10 #ifndef FS_LOGFS_LOGFS_H
11 #define FS_LOGFS_LOGFS_H
12
13 #undef __CHECK_ENDIAN__
14 #define __CHECK_ENDIAN__
15
16 #include <linux/btree.h>
17 #include <linux/crc32.h>
18 #include <linux/fs.h>
19 #include <linux/kernel.h>
20 #include <linux/mempool.h>
21 #include <linux/pagemap.h>
22 #include <linux/mtd/mtd.h>
23 #include "logfs_abi.h"
24
25 #define LOGFS_DEBUG_SUPER       (0x0001)
26 #define LOGFS_DEBUG_SEGMENT     (0x0002)
27 #define LOGFS_DEBUG_JOURNAL     (0x0004)
28 #define LOGFS_DEBUG_DIR         (0x0008)
29 #define LOGFS_DEBUG_FILE        (0x0010)
30 #define LOGFS_DEBUG_INODE       (0x0020)
31 #define LOGFS_DEBUG_READWRITE   (0x0040)
32 #define LOGFS_DEBUG_GC          (0x0080)
33 #define LOGFS_DEBUG_GC_NOISY    (0x0100)
34 #define LOGFS_DEBUG_ALIASES     (0x0200)
35 #define LOGFS_DEBUG_BLOCKMOVE   (0x0400)
36 #define LOGFS_DEBUG_ALL         (0xffffffff)
37
38 #define LOGFS_DEBUG             (0x01)
39 /*
40  * To enable specific log messages, simply define LOGFS_DEBUG to match any
41  * or all of the above.
42  */
43 #ifndef LOGFS_DEBUG
44 #define LOGFS_DEBUG             (0)
45 #endif
46
47 #define log_cond(cond, fmt, arg...) do {        \
48         if (cond)                               \
49                 printk(KERN_DEBUG fmt, ##arg);  \
50 } while (0)
51
52 #define log_super(fmt, arg...) \
53         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_SUPER, fmt, ##arg)
54 #define log_segment(fmt, arg...) \
55         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_SEGMENT, fmt, ##arg)
56 #define log_journal(fmt, arg...) \
57         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_JOURNAL, fmt, ##arg)
58 #define log_dir(fmt, arg...) \
59         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_DIR, fmt, ##arg)
60 #define log_file(fmt, arg...) \
61         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_FILE, fmt, ##arg)
62 #define log_inode(fmt, arg...) \
63         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_INODE, fmt, ##arg)
64 #define log_readwrite(fmt, arg...) \
65         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_READWRITE, fmt, ##arg)
66 #define log_gc(fmt, arg...) \
67         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_GC, fmt, ##arg)
68 #define log_gc_noisy(fmt, arg...) \
69         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_GC_NOISY, fmt, ##arg)
70 #define log_aliases(fmt, arg...) \
71         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_ALIASES, fmt, ##arg)
72 #define log_blockmove(fmt, arg...) \
73         log_cond(LOGFS_DEBUG & LOGFS_DEBUG_BLOCKMOVE, fmt, ##arg)
74
75 #define PG_pre_locked           PG_owner_priv_1
76 #define PagePreLocked(page)     test_bit(PG_pre_locked, &(page)->flags)
77 #define SetPagePreLocked(page)  set_bit(PG_pre_locked, &(page)->flags)
78 #define ClearPagePreLocked(page) clear_bit(PG_pre_locked, &(page)->flags)
79
80 /* FIXME: This should really be somewhere in the 64bit area. */
81 #define LOGFS_LINK_MAX          (1<<30)
82
83 /* Read-only filesystem */
84 #define LOGFS_SB_FLAG_RO        0x0001
85 #define LOGFS_SB_FLAG_SEG_ALIAS 0x0002
86 #define LOGFS_SB_FLAG_OBJ_ALIAS 0x0004
87 #define LOGFS_SB_FLAG_SHUTDOWN  0x0008
88
89 /* Write Control Flags */
90 #define WF_LOCK                 0x01 /* take write lock */
91 #define WF_WRITE                0x02 /* write block */
92 #define WF_DELETE               0x04 /* delete old block */
93
94 typedef u8 __bitwise level_t;
95 typedef u8 __bitwise gc_level_t;
96
97 #define LEVEL(level) ((__force level_t)(level))
98 #define GC_LEVEL(gc_level) ((__force gc_level_t)(gc_level))
99
100 #define SUBLEVEL(level) ( (void)((level) == LEVEL(1)),  \
101                 (__force level_t)((__force u8)(level) - 1) )
102
103 /**
104  * struct logfs_area - area management information
105  *
106  * @a_sb:                       the superblock this area belongs to
107  * @a_is_open:                  1 if the area is currently open, else 0
108  * @a_segno:                    segment number of area
109  * @a_written_bytes:            number of bytes already written back
110  * @a_used_bytes:               number of used bytes
111  * @a_ops:                      area operations (either journal or ostore)
112  * @a_erase_count:              erase count
113  * @a_level:                    GC level
114  */
115 struct logfs_area { /* a segment open for writing */
116         struct super_block *a_sb;
117         int     a_is_open;
118         u32     a_segno;
119         u32     a_written_bytes;
120         u32     a_used_bytes;
121         const struct logfs_area_ops *a_ops;
122         u32     a_erase_count;
123         gc_level_t a_level;
124 };
125
126 /**
127  * struct logfs_area_ops - area operations
128  *
129  * @get_free_segment:           fill area->ofs with the offset of a free segment
130  * @get_erase_count:            fill area->erase_count (needs area->ofs)
131  * @erase_segment:              erase and setup segment
132  */
133 struct logfs_area_ops {
134         void    (*get_free_segment)(struct logfs_area *area);
135         void    (*get_erase_count)(struct logfs_area *area);
136         int     (*erase_segment)(struct logfs_area *area);
137 };
138
139 /**
140  * struct logfs_device_ops - device access operations
141  *
142  * @readpage:                   read one page (mm page)
143  * @writeseg:                   write one segment.  may be a partial segment
144  * @erase:                      erase one segment
145  * @read:                       read from the device
146  * @erase:                      erase part of the device
147  */
148 struct logfs_device_ops {
149         struct page *(*find_first_sb)(struct super_block *sb, u64 *ofs);
150         struct page *(*find_last_sb)(struct super_block *sb, u64 *ofs);
151         int (*write_sb)(struct super_block *sb, struct page *page);
152         int (*readpage)(void *_sb, struct page *page);
153         void (*writeseg)(struct super_block *sb, u64 ofs, size_t len);
154         int (*erase)(struct super_block *sb, loff_t ofs, size_t len);
155         void (*sync)(struct super_block *sb);
156         void (*put_device)(struct super_block *sb);
157 };
158
159 /**
160  * struct candidate_list - list of similar candidates
161  */
162 struct candidate_list {
163         struct rb_root rb_tree;
164         int count;
165         int maxcount;
166         int sort_by_ec;
167 };
168
169 /**
170  * struct gc_candidate - "candidate" segment to be garbage collected next
171  *
172  * @list:                       list (either free of low)
173  * @segno:                      segment number
174  * @valid:                      number of valid bytes
175  * @erase_count:                erase count of segment
176  * @dist:                       distance from tree root
177  *
178  * Candidates can be on two lists.  The free list contains electees rather
179  * than candidates - segments that no longer contain any valid data.  The
180  * low list contains candidates to be picked for GC.  It should be kept
181  * short.  It is not required to always pick a perfect candidate.  In the
182  * worst case GC will have to move more data than absolutely necessary.
183  */
184 struct gc_candidate {
185         struct rb_node rb_node;
186         struct candidate_list *list;
187         u32     segno;
188         u32     valid;
189         u32     erase_count;
190         u8      dist;
191 };
192
193 /**
194  * struct logfs_journal_entry - temporary structure used during journal scan
195  *
196  * @used:
197  * @version:                    normalized version
198  * @len:                        length
199  * @offset:                     offset
200  */
201 struct logfs_journal_entry {
202         int used;
203         s16 version;
204         u16 len;
205         u16 datalen;
206         u64 offset;
207 };
208
209 enum transaction_state {
210         CREATE_1 = 1,
211         CREATE_2,
212         UNLINK_1,
213         UNLINK_2,
214         CROSS_RENAME_1,
215         CROSS_RENAME_2,
216         TARGET_RENAME_1,
217         TARGET_RENAME_2,
218         TARGET_RENAME_3
219 };
220
221 /**
222  * struct logfs_transaction - essential fields to support atomic dirops
223  *
224  * @ino:                        target inode
225  * @dir:                        inode of directory containing dentry
226  * @pos:                        pos of dentry in directory
227  */
228 struct logfs_transaction {
229         enum transaction_state state;
230         u64      ino;
231         u64      dir;
232         u64      pos;
233 };
234
235 /**
236  * struct logfs_shadow - old block in the shadow of a not-yet-committed new one
237  * @old_ofs:                    offset of old block on medium
238  * @new_ofs:                    offset of new block on medium
239  * @ino:                        inode number
240  * @bix:                        block index
241  * @old_len:                    size of old block, including header
242  * @new_len:                    size of new block, including header
243  * @level:                      block level
244  */
245 struct logfs_shadow {
246         u64 old_ofs;
247         u64 new_ofs;
248         u64 ino;
249         u64 bix;
250         int old_len;
251         int new_len;
252         gc_level_t gc_level;
253 };
254
255 /**
256  * struct shadow_tree
257  * @new:                        shadows where old_ofs==0, indexed by new_ofs
258  * @old:                        shadows where old_ofs!=0, indexed by old_ofs
259  */
260 struct shadow_tree {
261         struct btree_head64 new;
262         struct btree_head64 old;
263 };
264
265 struct object_alias_item {
266         struct list_head list;
267         __be64 val;
268         int child_no;
269 };
270
271 /**
272  * struct logfs_block - contains any block state
273  * @type:                       indirect block or inode
274  * @full:                       number of fully populated children
275  * @partial:                    number of partially populated children
276  *
277  * Most blocks are directly represented by page cache pages.  But when a block
278  * becomes dirty, is part of a transaction, contains aliases or is otherwise
279  * special, a struct logfs_block is allocated to track the additional state.
280  * Inodes are very similar to indirect blocks, so they can also get one of
281  * these structures added when appropriate.
282  */
283 #define BLOCK_INDIRECT  1       /* Indirect block */
284 #define BLOCK_INODE     2       /* Inode */
285 struct logfs_block_ops;
286 struct logfs_block {
287         struct list_head alias_list;
288         struct list_head item_list;
289         struct super_block *sb;
290         u64 ino;
291         u64 bix;
292         level_t level;
293         struct page *page;
294         struct inode *inode;
295         struct logfs_transaction *ta;
296         unsigned long alias_map[LOGFS_BLOCK_FACTOR / BITS_PER_LONG];
297         struct logfs_block_ops *ops;
298         int full;
299         int partial;
300         int reserved_bytes;
301 };
302
303 typedef int write_alias_t(struct super_block *sb, u64 ino, u64 bix,
304                 level_t level, int child_no, __be64 val);
305 struct logfs_block_ops {
306         void    (*write_block)(struct logfs_block *block);
307         gc_level_t      (*block_level)(struct logfs_block *block);
308         void    (*free_block)(struct super_block *sb, struct logfs_block*block);
309         int     (*write_alias)(struct super_block *sb,
310                         struct logfs_block *block,
311                         write_alias_t *write_one_alias);
312 };
313
314 struct logfs_super {
315         struct mtd_info *s_mtd;                 /* underlying device */
316         struct block_device *s_bdev;            /* underlying device */
317         const struct logfs_device_ops *s_devops;/* device access */
318         struct inode    *s_master_inode;        /* inode file */
319         struct inode    *s_segfile_inode;       /* segment file */
320         struct inode *s_mapping_inode;          /* device mapping */
321         atomic_t s_pending_writes;              /* outstanting bios */
322         long     s_flags;
323         mempool_t *s_btree_pool;                /* for btree nodes */
324         mempool_t *s_alias_pool;                /* aliases in segment.c */
325         u64      s_feature_incompat;
326         u64      s_feature_ro_compat;
327         u64      s_feature_compat;
328         u64      s_feature_flags;
329         u64      s_sb_ofs[2];
330         /* alias.c fields */
331         struct btree_head32 s_segment_alias;    /* remapped segments */
332         int      s_no_object_aliases;
333         struct list_head s_object_alias;        /* remapped objects */
334         struct btree_head128 s_object_alias_tree; /* remapped objects */
335         struct mutex s_object_alias_mutex;
336         /* dir.c fields */
337         struct mutex s_dirop_mutex;             /* for creat/unlink/rename */
338         u64      s_victim_ino;                  /* used for atomic dir-ops */
339         u64      s_rename_dir;                  /* source directory ino */
340         u64      s_rename_pos;                  /* position of source dd */
341         /* gc.c fields */
342         long     s_segsize;                     /* size of a segment */
343         int      s_segshift;                    /* log2 of segment size */
344         long     s_segmask;                     /* 1 << s_segshift - 1 */
345         long     s_no_segs;                     /* segments on device */
346         long     s_no_journal_segs;             /* segments used for journal */
347         long     s_no_blocks;                   /* blocks per segment */
348         long     s_writesize;                   /* minimum write size */
349         int      s_writeshift;                  /* log2 of write size */
350         u64      s_size;                        /* filesystem size */
351         struct logfs_area *s_area[LOGFS_NO_AREAS];      /* open segment array */
352         u64      s_gec;                         /* global erase count */
353         u64      s_wl_gec_ostore;               /* time of last wl event */
354         u64      s_wl_gec_journal;              /* time of last wl event */
355         u64      s_sweeper;                     /* current sweeper pos */
356         u8       s_ifile_levels;                /* max level of ifile */
357         u8       s_iblock_levels;               /* max level of regular files */
358         u8       s_data_levels;                 /* # of segments to leaf block*/
359         u8       s_total_levels;                /* sum of above three */
360         struct btree_head32 s_cand_tree;        /* all candidates */
361         struct candidate_list s_free_list;      /* 100% free segments */
362         struct candidate_list s_reserve_list;   /* Bad segment reserve */
363         struct candidate_list s_low_list[LOGFS_NO_AREAS];/* good candidates */
364         struct candidate_list s_ec_list;        /* wear level candidates */
365         struct btree_head32 s_reserved_segments;/* sb, journal, bad, etc. */
366         /* inode.c fields */
367         u64      s_last_ino;                    /* highest ino used */
368         long     s_inos_till_wrap;
369         u32      s_generation;                  /* i_generation for new files */
370         struct list_head s_freeing_list;        /* inodes being freed */
371         /* journal.c fields */
372         struct mutex s_journal_mutex;
373         void    *s_je;                          /* journal entry to compress */
374         void    *s_compressed_je;               /* block to write to journal */
375         u32      s_journal_seg[LOGFS_JOURNAL_SEGS]; /* journal segments */
376         u32      s_journal_ec[LOGFS_JOURNAL_SEGS]; /* journal erasecounts */
377         u64      s_last_version;
378         struct logfs_area *s_journal_area;      /* open journal segment */
379         __be64  s_je_array[64];
380         int     s_no_je;
381
382         int      s_sum_index;                   /* for the 12 summaries */
383         struct shadow_tree s_shadow_tree;
384         int      s_je_fill;                     /* index of current je */
385         /* readwrite.c fields */
386         struct mutex s_write_mutex;
387         int      s_lock_count;
388         mempool_t *s_block_pool;                /* struct logfs_block pool */
389         mempool_t *s_shadow_pool;               /* struct logfs_shadow pool */
390         /*
391          * Space accounting:
392          * - s_used_bytes specifies space used to store valid data objects.
393          * - s_dirty_used_bytes is space used to store non-committed data
394          *   objects.  Those objects have already been written themselves,
395          *   but they don't become valid until all indirect blocks up to the
396          *   journal have been written as well.
397          * - s_dirty_free_bytes is space used to store the old copy of a
398          *   replaced object, as long as the replacement is non-committed.
399          *   In other words, it is the amount of space freed when all dirty
400          *   blocks are written back.
401          * - s_free_bytes is the amount of free space available for any
402          *   purpose.
403          * - s_root_reserve is the amount of free space available only to
404          *   the root user.  Non-privileged users can no longer write once
405          *   this watermark has been reached.
406          * - s_speed_reserve is space which remains unused to speed up
407          *   garbage collection performance.
408          * - s_dirty_pages is the space reserved for currently dirty pages.
409          *   It is a pessimistic estimate, so some/most will get freed on
410          *   page writeback.
411          *
412          * s_used_bytes + s_free_bytes + s_speed_reserve = total usable size
413          */
414         u64      s_free_bytes;
415         u64      s_used_bytes;
416         u64      s_dirty_free_bytes;
417         u64      s_dirty_used_bytes;
418         u64      s_root_reserve;
419         u64      s_speed_reserve;
420         u64      s_dirty_pages;
421         /* Bad block handling:
422          * - s_bad_seg_reserve is a number of segments usually kept
423          *   free.  When encountering bad blocks, the affected segment's data
424          *   is _temporarily_ moved to a reserved segment.
425          * - s_bad_segments is the number of known bad segments.
426          */
427         u32      s_bad_seg_reserve;
428         u32      s_bad_segments;
429 };
430
431 /**
432  * struct logfs_inode - in-memory inode
433  *
434  * @vfs_inode:                  struct inode
435  * @li_data:                    data pointers
436  * @li_used_bytes:              number of used bytes
437  * @li_freeing_list:            used to track inodes currently being freed
438  * @li_flags:                   inode flags
439  * @li_refcount:                number of internal (GC-induced) references
440  */
441 struct logfs_inode {
442         struct inode vfs_inode;
443         u64     li_data[LOGFS_EMBEDDED_FIELDS];
444         u64     li_used_bytes;
445         struct list_head li_freeing_list;
446         struct logfs_block *li_block;
447         u32     li_flags;
448         u8      li_height;
449         int     li_refcount;
450 };
451
452 #define journal_for_each(__i) for (__i = 0; __i < LOGFS_JOURNAL_SEGS; __i++)
453 #define for_each_area(__i) for (__i = 0; __i < LOGFS_NO_AREAS; __i++)
454 #define for_each_area_down(__i) for (__i = LOGFS_NO_AREAS - 1; __i >= 0; __i--)
455
456 /* compr.c */
457 int logfs_compress(void *in, void *out, size_t inlen, size_t outlen);
458 int logfs_uncompress(void *in, void *out, size_t inlen, size_t outlen);
459 int __init logfs_compr_init(void);
460 void logfs_compr_exit(void);
461
462 /* dev_bdev.c */
463 #ifdef CONFIG_BLOCK
464 int logfs_get_sb_bdev(struct file_system_type *type, int flags,
465                 const char *devname, struct vfsmount *mnt);
466 #else
467 static inline int logfs_get_sb_bdev(struct file_system_type *type, int flags,
468                 const char *devname, struct vfsmount *mnt)
469 {
470         return -ENODEV;
471 }
472 #endif
473
474 /* dev_mtd.c */
475 #ifdef CONFIG_MTD
476 int logfs_get_sb_mtd(struct file_system_type *type, int flags,
477                 int mtdnr, struct vfsmount *mnt);
478 #else
479 static inline int logfs_get_sb_mtd(struct file_system_type *type, int flags,
480                 int mtdnr, struct vfsmount *mnt)
481 {
482         return -ENODEV;
483 }
484 #endif
485
486 /* dir.c */
487 extern const struct inode_operations logfs_symlink_iops;
488 extern const struct inode_operations logfs_dir_iops;
489 extern const struct file_operations logfs_dir_fops;
490 int logfs_replay_journal(struct super_block *sb);
491
492 /* file.c */
493 extern const struct inode_operations logfs_reg_iops;
494 extern const struct file_operations logfs_reg_fops;
495 extern const struct address_space_operations logfs_reg_aops;
496 int logfs_readpage(struct file *file, struct page *page);
497 int logfs_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
498                 unsigned long arg);
499 int logfs_fsync(struct file *file, struct dentry *dentry, int datasync);
500
501 /* gc.c */
502 u32 get_best_cand(struct super_block *sb, struct candidate_list *list, u32 *ec);
503 void logfs_gc_pass(struct super_block *sb);
504 int logfs_check_areas(struct super_block *sb);
505 int logfs_init_gc(struct super_block *sb);
506 void logfs_cleanup_gc(struct super_block *sb);
507
508 /* inode.c */
509 extern const struct super_operations logfs_super_operations;
510 struct inode *logfs_iget(struct super_block *sb, ino_t ino);
511 struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *cookie);
512 void logfs_safe_iput(struct inode *inode, int cookie);
513 struct inode *logfs_new_inode(struct inode *dir, int mode);
514 struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino);
515 struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino);
516 int logfs_init_inode_cache(void);
517 void logfs_destroy_inode_cache(void);
518 void destroy_meta_inode(struct inode *inode);
519 void logfs_set_blocks(struct inode *inode, u64 no);
520 /* these logically belong into inode.c but actually reside in readwrite.c */
521 int logfs_read_inode(struct inode *inode);
522 int __logfs_write_inode(struct inode *inode, long flags);
523 void logfs_delete_inode(struct inode *inode);
524 void logfs_clear_inode(struct inode *inode);
525
526 /* journal.c */
527 void logfs_write_anchor(struct inode *inode);
528 int logfs_init_journal(struct super_block *sb);
529 void logfs_cleanup_journal(struct super_block *sb);
530 int write_alias_journal(struct super_block *sb, u64 ino, u64 bix,
531                 level_t level, int child_no, __be64 val);
532 void do_logfs_journal_wl_pass(struct super_block *sb);
533
534 /* readwrite.c */
535 pgoff_t logfs_pack_index(u64 bix, level_t level);
536 void logfs_unpack_index(pgoff_t index, u64 *bix, level_t *level);
537 int logfs_inode_write(struct inode *inode, const void *buf, size_t count,
538                 loff_t bix, long flags, struct shadow_tree *shadow_tree);
539 int logfs_readpage_nolock(struct page *page);
540 int logfs_write_buf(struct inode *inode, struct page *page, long flags);
541 int logfs_delete(struct inode *inode, pgoff_t index,
542                 struct shadow_tree *shadow_tree);
543 int logfs_rewrite_block(struct inode *inode, u64 bix, u64 ofs,
544                 gc_level_t gc_level, long flags);
545 int logfs_is_valid_block(struct super_block *sb, u64 ofs, u64 ino, u64 bix,
546                 gc_level_t gc_level);
547 int logfs_truncate(struct inode *inode, u64 size);
548 u64 logfs_seek_hole(struct inode *inode, u64 bix);
549 u64 logfs_seek_data(struct inode *inode, u64 bix);
550 int logfs_open_segfile(struct super_block *sb);
551 int logfs_init_rw(struct super_block *sb);
552 void logfs_cleanup_rw(struct super_block *sb);
553 void logfs_add_transaction(struct inode *inode, struct logfs_transaction *ta);
554 void logfs_del_transaction(struct inode *inode, struct logfs_transaction *ta);
555 void logfs_write_block(struct logfs_block *block, long flags);
556 int logfs_write_obj_aliases_pagecache(struct super_block *sb);
557 void logfs_get_segment_entry(struct super_block *sb, u32 segno,
558                 struct logfs_segment_entry *se);
559 void logfs_set_segment_used(struct super_block *sb, u64 ofs, int increment);
560 void logfs_set_segment_erased(struct super_block *sb, u32 segno, u32 ec,
561                 gc_level_t gc_level);
562 void logfs_set_segment_reserved(struct super_block *sb, u32 segno);
563 void logfs_set_segment_unreserved(struct super_block *sb, u32 segno, u32 ec);
564 struct logfs_block *__alloc_block(struct super_block *sb,
565                 u64 ino, u64 bix, level_t level);
566 void __free_block(struct super_block *sb, struct logfs_block *block);
567 void btree_write_block(struct logfs_block *block);
568 void initialize_block_counters(struct page *page, struct logfs_block *block,
569                 __be64 *array, int page_is_empty);
570 int logfs_exist_block(struct inode *inode, u64 bix);
571 int get_page_reserve(struct inode *inode, struct page *page);
572 extern struct logfs_block_ops indirect_block_ops;
573
574 /* segment.c */
575 int logfs_erase_segment(struct super_block *sb, u32 ofs);
576 int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf);
577 int logfs_segment_read(struct inode *inode, struct page *page, u64 ofs, u64 bix,
578                 level_t level);
579 int logfs_segment_write(struct inode *inode, struct page *page,
580                 struct logfs_shadow *shadow);
581 int logfs_segment_delete(struct inode *inode, struct logfs_shadow *shadow);
582 int logfs_load_object_aliases(struct super_block *sb,
583                 struct logfs_obj_alias *oa, int count);
584 void move_page_to_btree(struct page *page);
585 int logfs_init_mapping(struct super_block *sb);
586 void logfs_sync_area(struct logfs_area *area);
587 void logfs_sync_segments(struct super_block *sb);
588
589 /* area handling */
590 int logfs_init_areas(struct super_block *sb);
591 void logfs_cleanup_areas(struct super_block *sb);
592 int logfs_open_area(struct logfs_area *area, size_t bytes);
593 void __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len,
594                 int use_filler);
595
596 static inline void logfs_buf_write(struct logfs_area *area, u64 ofs,
597                 void *buf, size_t len)
598 {
599         __logfs_buf_write(area, ofs, buf, len, 0);
600 }
601
602 static inline void logfs_buf_recover(struct logfs_area *area, u64 ofs,
603                 void *buf, size_t len)
604 {
605         __logfs_buf_write(area, ofs, buf, len, 1);
606 }
607
608 /* super.c */
609 struct page *emergency_read_begin(struct address_space *mapping, pgoff_t index);
610 void emergency_read_end(struct page *page);
611 void logfs_crash_dump(struct super_block *sb);
612 void *memchr_inv(const void *s, int c, size_t n);
613 int logfs_statfs(struct dentry *dentry, struct kstatfs *stats);
614 int logfs_get_sb_device(struct file_system_type *type, int flags,
615                 struct mtd_info *mtd, struct block_device *bdev,
616                 const struct logfs_device_ops *devops, struct vfsmount *mnt);
617 int logfs_check_ds(struct logfs_disk_super *ds);
618 int logfs_write_sb(struct super_block *sb);
619
620 static inline struct logfs_super *logfs_super(struct super_block *sb)
621 {
622         return sb->s_fs_info;
623 }
624
625 static inline struct logfs_inode *logfs_inode(struct inode *inode)
626 {
627         return container_of(inode, struct logfs_inode, vfs_inode);
628 }
629
630 static inline void logfs_set_ro(struct super_block *sb)
631 {
632         logfs_super(sb)->s_flags |= LOGFS_SB_FLAG_RO;
633 }
634
635 #define LOGFS_BUG(sb) do {                                      \
636         struct super_block *__sb = sb;                          \
637         logfs_crash_dump(__sb);                                 \
638         logfs_super(__sb)->s_flags |= LOGFS_SB_FLAG_RO;         \
639         BUG();                                                  \
640 } while (0)
641
642 #define LOGFS_BUG_ON(condition, sb) \
643         do { if (unlikely(condition)) LOGFS_BUG((sb)); } while (0)
644
645 static inline __be32 logfs_crc32(void *data, size_t len, size_t skip)
646 {
647         return cpu_to_be32(crc32(~0, data+skip, len-skip));
648 }
649
650 static inline u8 logfs_type(struct inode *inode)
651 {
652         return (inode->i_mode >> 12) & 15;
653 }
654
655 static inline pgoff_t logfs_index(struct super_block *sb, u64 pos)
656 {
657         return pos >> sb->s_blocksize_bits;
658 }
659
660 static inline u64 dev_ofs(struct super_block *sb, u32 segno, u32 ofs)
661 {
662         return ((u64)segno << logfs_super(sb)->s_segshift) + ofs;
663 }
664
665 static inline u32 seg_no(struct super_block *sb, u64 ofs)
666 {
667         return ofs >> logfs_super(sb)->s_segshift;
668 }
669
670 static inline u32 seg_ofs(struct super_block *sb, u64 ofs)
671 {
672         return ofs & logfs_super(sb)->s_segmask;
673 }
674
675 static inline u64 seg_align(struct super_block *sb, u64 ofs)
676 {
677         return ofs & ~logfs_super(sb)->s_segmask;
678 }
679
680 static inline struct logfs_block *logfs_block(struct page *page)
681 {
682         return (void *)page->private;
683 }
684
685 static inline level_t shrink_level(gc_level_t __level)
686 {
687         u8 level = (__force u8)__level;
688
689         if (level >= LOGFS_MAX_LEVELS)
690                 level -= LOGFS_MAX_LEVELS;
691         return (__force level_t)level;
692 }
693
694 static inline gc_level_t expand_level(u64 ino, level_t __level)
695 {
696         u8 level = (__force u8)__level;
697
698         if (ino == LOGFS_INO_MASTER) {
699                 /* ifile has seperate areas */
700                 level += LOGFS_MAX_LEVELS;
701         }
702         return (__force gc_level_t)level;
703 }
704
705 static inline int logfs_block_shift(struct super_block *sb, level_t level)
706 {
707         level = shrink_level((__force gc_level_t)level);
708         return (__force int)level * (sb->s_blocksize_bits - 3);
709 }
710
711 static inline u64 logfs_block_mask(struct super_block *sb, level_t level)
712 {
713         return ~0ull << logfs_block_shift(sb, level);
714 }
715
716 static inline struct logfs_area *get_area(struct super_block *sb,
717                 gc_level_t gc_level)
718 {
719         return logfs_super(sb)->s_area[(__force u8)gc_level];
720 }
721
722 #endif