PageRenderTime 69ms CodeModel.GetById 42ms app.highlight 22ms RepoModel.GetById 0ms app.codeStats 0ms

/fs/logfs/logfs.h

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C Header | 734 lines | 500 code | 67 blank | 167 comment | 13 complexity | c7e7087d4ace1d324609114c816fccc5 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
  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_DIRTY	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
 94typedef u8 __bitwise level_t;
 95typedef 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 */
115struct 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 */
133struct 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
139struct logfs_super;	/* forward */
140/**
141 * struct logfs_device_ops - device access operations
142 *
143 * @readpage:			read one page (mm page)
144 * @writeseg:			write one segment.  may be a partial segment
145 * @erase:			erase one segment
146 * @read:			read from the device
147 * @erase:			erase part of the device
148 * @can_write_buf:		decide whether wbuf can be written to ofs
149 */
150struct logfs_device_ops {
151	struct page *(*find_first_sb)(struct super_block *sb, u64 *ofs);
152	struct page *(*find_last_sb)(struct super_block *sb, u64 *ofs);
153	int (*write_sb)(struct super_block *sb, struct page *page);
154	int (*readpage)(void *_sb, struct page *page);
155	void (*writeseg)(struct super_block *sb, u64 ofs, size_t len);
156	int (*erase)(struct super_block *sb, loff_t ofs, size_t len,
157			int ensure_write);
158	int (*can_write_buf)(struct super_block *sb, u64 ofs);
159	void (*sync)(struct super_block *sb);
160	void (*put_device)(struct logfs_super *s);
161};
162
163/**
164 * struct candidate_list - list of similar candidates
165 */
166struct candidate_list {
167	struct rb_root rb_tree;
168	int count;
169	int maxcount;
170	int sort_by_ec;
171};
172
173/**
174 * struct gc_candidate - "candidate" segment to be garbage collected next
175 *
176 * @list:			list (either free of low)
177 * @segno:			segment number
178 * @valid:			number of valid bytes
179 * @erase_count:		erase count of segment
180 * @dist:			distance from tree root
181 *
182 * Candidates can be on two lists.  The free list contains electees rather
183 * than candidates - segments that no longer contain any valid data.  The
184 * low list contains candidates to be picked for GC.  It should be kept
185 * short.  It is not required to always pick a perfect candidate.  In the
186 * worst case GC will have to move more data than absolutely necessary.
187 */
188struct gc_candidate {
189	struct rb_node rb_node;
190	struct candidate_list *list;
191	u32	segno;
192	u32	valid;
193	u32	erase_count;
194	u8	dist;
195};
196
197/**
198 * struct logfs_journal_entry - temporary structure used during journal scan
199 *
200 * @used:
201 * @version:			normalized version
202 * @len:			length
203 * @offset:			offset
204 */
205struct logfs_journal_entry {
206	int used;
207	s16 version;
208	u16 len;
209	u16 datalen;
210	u64 offset;
211};
212
213enum transaction_state {
214	CREATE_1 = 1,
215	CREATE_2,
216	UNLINK_1,
217	UNLINK_2,
218	CROSS_RENAME_1,
219	CROSS_RENAME_2,
220	TARGET_RENAME_1,
221	TARGET_RENAME_2,
222	TARGET_RENAME_3
223};
224
225/**
226 * struct logfs_transaction - essential fields to support atomic dirops
227 *
228 * @ino:			target inode
229 * @dir:			inode of directory containing dentry
230 * @pos:			pos of dentry in directory
231 */
232struct logfs_transaction {
233	enum transaction_state state;
234	u64	 ino;
235	u64	 dir;
236	u64	 pos;
237};
238
239/**
240 * struct logfs_shadow - old block in the shadow of a not-yet-committed new one
241 * @old_ofs:			offset of old block on medium
242 * @new_ofs:			offset of new block on medium
243 * @ino:			inode number
244 * @bix:			block index
245 * @old_len:			size of old block, including header
246 * @new_len:			size of new block, including header
247 * @level:			block level
248 */
249struct logfs_shadow {
250	u64 old_ofs;
251	u64 new_ofs;
252	u64 ino;
253	u64 bix;
254	int old_len;
255	int new_len;
256	gc_level_t gc_level;
257};
258
259/**
260 * struct shadow_tree
261 * @new:			shadows where old_ofs==0, indexed by new_ofs
262 * @old:			shadows where old_ofs!=0, indexed by old_ofs
263 * @segment_map:		bitfield of segments containing shadows
264 * @no_shadowed_segment:	number of segments containing shadows
265 */
266struct shadow_tree {
267	struct btree_head64 new;
268	struct btree_head64 old;
269	struct btree_head32 segment_map;
270	int no_shadowed_segments;
271};
272
273struct object_alias_item {
274	struct list_head list;
275	__be64 val;
276	int child_no;
277};
278
279/**
280 * struct logfs_block - contains any block state
281 * @type:			indirect block or inode
282 * @full:			number of fully populated children
283 * @partial:			number of partially populated children
284 *
285 * Most blocks are directly represented by page cache pages.  But when a block
286 * becomes dirty, is part of a transaction, contains aliases or is otherwise
287 * special, a struct logfs_block is allocated to track the additional state.
288 * Inodes are very similar to indirect blocks, so they can also get one of
289 * these structures added when appropriate.
290 */
291#define BLOCK_INDIRECT	1	/* Indirect block */
292#define BLOCK_INODE	2	/* Inode */
293struct logfs_block_ops;
294struct logfs_block {
295	struct list_head alias_list;
296	struct list_head item_list;
297	struct super_block *sb;
298	u64 ino;
299	u64 bix;
300	level_t level;
301	struct page *page;
302	struct inode *inode;
303	struct logfs_transaction *ta;
304	unsigned long alias_map[LOGFS_BLOCK_FACTOR / BITS_PER_LONG];
305	struct logfs_block_ops *ops;
306	int full;
307	int partial;
308	int reserved_bytes;
309};
310
311typedef int write_alias_t(struct super_block *sb, u64 ino, u64 bix,
312		level_t level, int child_no, __be64 val);
313struct logfs_block_ops {
314	void	(*write_block)(struct logfs_block *block);
315	void	(*free_block)(struct super_block *sb, struct logfs_block*block);
316	int	(*write_alias)(struct super_block *sb,
317			struct logfs_block *block,
318			write_alias_t *write_one_alias);
319};
320
321#define MAX_JOURNAL_ENTRIES 256
322
323struct logfs_super {
324	struct mtd_info *s_mtd;			/* underlying device */
325	struct block_device *s_bdev;		/* underlying device */
326	const struct logfs_device_ops *s_devops;/* device access */
327	struct inode	*s_master_inode;	/* inode file */
328	struct inode	*s_segfile_inode;	/* segment file */
329	struct inode *s_mapping_inode;		/* device mapping */
330	atomic_t s_pending_writes;		/* outstanting bios */
331	long	 s_flags;
332	mempool_t *s_btree_pool;		/* for btree nodes */
333	mempool_t *s_alias_pool;		/* aliases in segment.c */
334	u64	 s_feature_incompat;
335	u64	 s_feature_ro_compat;
336	u64	 s_feature_compat;
337	u64	 s_feature_flags;
338	u64	 s_sb_ofs[2];
339	struct page *s_erase_page;		/* for dev_bdev.c */
340	/* alias.c fields */
341	struct btree_head32 s_segment_alias;	/* remapped segments */
342	int	 s_no_object_aliases;
343	struct list_head s_object_alias;	/* remapped objects */
344	struct btree_head128 s_object_alias_tree; /* remapped objects */
345	struct mutex s_object_alias_mutex;
346	/* dir.c fields */
347	struct mutex s_dirop_mutex;		/* for creat/unlink/rename */
348	u64	 s_victim_ino;			/* used for atomic dir-ops */
349	u64	 s_rename_dir;			/* source directory ino */
350	u64	 s_rename_pos;			/* position of source dd */
351	/* gc.c fields */
352	long	 s_segsize;			/* size of a segment */
353	int	 s_segshift;			/* log2 of segment size */
354	long	 s_segmask;			/* 1 << s_segshift - 1 */
355	long	 s_no_segs;			/* segments on device */
356	long	 s_no_journal_segs;		/* segments used for journal */
357	long	 s_no_blocks;			/* blocks per segment */
358	long	 s_writesize;			/* minimum write size */
359	int	 s_writeshift;			/* log2 of write size */
360	u64	 s_size;			/* filesystem size */
361	struct logfs_area *s_area[LOGFS_NO_AREAS];	/* open segment array */
362	u64	 s_gec;				/* global erase count */
363	u64	 s_wl_gec_ostore;		/* time of last wl event */
364	u64	 s_wl_gec_journal;		/* time of last wl event */
365	u64	 s_sweeper;			/* current sweeper pos */
366	u8	 s_ifile_levels;		/* max level of ifile */
367	u8	 s_iblock_levels;		/* max level of regular files */
368	u8	 s_data_levels;			/* # of segments to leaf block*/
369	u8	 s_total_levels;		/* sum of above three */
370	struct btree_head32 s_cand_tree;	/* all candidates */
371	struct candidate_list s_free_list;	/* 100% free segments */
372	struct candidate_list s_reserve_list;	/* Bad segment reserve */
373	struct candidate_list s_low_list[LOGFS_NO_AREAS];/* good candidates */
374	struct candidate_list s_ec_list;	/* wear level candidates */
375	struct btree_head32 s_reserved_segments;/* sb, journal, bad, etc. */
376	/* inode.c fields */
377	u64	 s_last_ino;			/* highest ino used */
378	long	 s_inos_till_wrap;
379	u32	 s_generation;			/* i_generation for new files */
380	struct list_head s_freeing_list;	/* inodes being freed */
381	/* journal.c fields */
382	struct mutex s_journal_mutex;
383	void	*s_je;				/* journal entry to compress */
384	void	*s_compressed_je;		/* block to write to journal */
385	u32	 s_journal_seg[LOGFS_JOURNAL_SEGS]; /* journal segments */
386	u32	 s_journal_ec[LOGFS_JOURNAL_SEGS]; /* journal erasecounts */
387	u64	 s_last_version;
388	struct logfs_area *s_journal_area;	/* open journal segment */
389	__be64	s_je_array[MAX_JOURNAL_ENTRIES];
390	int	s_no_je;
391
392	int	 s_sum_index;			/* for the 12 summaries */
393	struct shadow_tree s_shadow_tree;
394	int	 s_je_fill;			/* index of current je */
395	/* readwrite.c fields */
396	struct mutex s_write_mutex;
397	int	 s_lock_count;
398	mempool_t *s_block_pool;		/* struct logfs_block pool */
399	mempool_t *s_shadow_pool;		/* struct logfs_shadow pool */
400	struct list_head s_writeback_list;	/* writeback pages */
401	/*
402	 * Space accounting:
403	 * - s_used_bytes specifies space used to store valid data objects.
404	 * - s_dirty_used_bytes is space used to store non-committed data
405	 *   objects.  Those objects have already been written themselves,
406	 *   but they don't become valid until all indirect blocks up to the
407	 *   journal have been written as well.
408	 * - s_dirty_free_bytes is space used to store the old copy of a
409	 *   replaced object, as long as the replacement is non-committed.
410	 *   In other words, it is the amount of space freed when all dirty
411	 *   blocks are written back.
412	 * - s_free_bytes is the amount of free space available for any
413	 *   purpose.
414	 * - s_root_reserve is the amount of free space available only to
415	 *   the root user.  Non-privileged users can no longer write once
416	 *   this watermark has been reached.
417	 * - s_speed_reserve is space which remains unused to speed up
418	 *   garbage collection performance.
419	 * - s_dirty_pages is the space reserved for currently dirty pages.
420	 *   It is a pessimistic estimate, so some/most will get freed on
421	 *   page writeback.
422	 *
423	 * s_used_bytes + s_free_bytes + s_speed_reserve = total usable size
424	 */
425	u64	 s_free_bytes;
426	u64	 s_used_bytes;
427	u64	 s_dirty_free_bytes;
428	u64	 s_dirty_used_bytes;
429	u64	 s_root_reserve;
430	u64	 s_speed_reserve;
431	u64	 s_dirty_pages;
432	/* Bad block handling:
433	 * - s_bad_seg_reserve is a number of segments usually kept
434	 *   free.  When encountering bad blocks, the affected segment's data
435	 *   is _temporarily_ moved to a reserved segment.
436	 * - s_bad_segments is the number of known bad segments.
437	 */
438	u32	 s_bad_seg_reserve;
439	u32	 s_bad_segments;
440};
441
442/**
443 * struct logfs_inode - in-memory inode
444 *
445 * @vfs_inode:			struct inode
446 * @li_data:			data pointers
447 * @li_used_bytes:		number of used bytes
448 * @li_freeing_list:		used to track inodes currently being freed
449 * @li_flags:			inode flags
450 * @li_refcount:		number of internal (GC-induced) references
451 */
452struct logfs_inode {
453	struct inode vfs_inode;
454	u64	li_data[LOGFS_EMBEDDED_FIELDS];
455	u64	li_used_bytes;
456	struct list_head li_freeing_list;
457	struct logfs_block *li_block;
458	u32	li_flags;
459	u8	li_height;
460	int	li_refcount;
461};
462
463#define journal_for_each(__i) for (__i = 0; __i < LOGFS_JOURNAL_SEGS; __i++)
464#define for_each_area(__i) for (__i = 0; __i < LOGFS_NO_AREAS; __i++)
465#define for_each_area_down(__i) for (__i = LOGFS_NO_AREAS - 1; __i >= 0; __i--)
466
467/* compr.c */
468int logfs_compress(void *in, void *out, size_t inlen, size_t outlen);
469int logfs_uncompress(void *in, void *out, size_t inlen, size_t outlen);
470int __init logfs_compr_init(void);
471void logfs_compr_exit(void);
472
473/* dev_bdev.c */
474#ifdef CONFIG_BLOCK
475int logfs_get_sb_bdev(struct logfs_super *s,
476		struct file_system_type *type,
477		const char *devname);
478#else
479static inline int logfs_get_sb_bdev(struct logfs_super *s,
480		struct file_system_type *type,
481		const char *devname)
482{
483	return -ENODEV;
484}
485#endif
486
487/* dev_mtd.c */
488#ifdef CONFIG_MTD
489int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr);
490#else
491static inline int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr)
492{
493	return -ENODEV;
494}
495#endif
496
497/* dir.c */
498extern const struct inode_operations logfs_symlink_iops;
499extern const struct inode_operations logfs_dir_iops;
500extern const struct file_operations logfs_dir_fops;
501int logfs_replay_journal(struct super_block *sb);
502
503/* file.c */
504extern const struct inode_operations logfs_reg_iops;
505extern const struct file_operations logfs_reg_fops;
506extern const struct address_space_operations logfs_reg_aops;
507int logfs_readpage(struct file *file, struct page *page);
508long logfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
509int logfs_fsync(struct file *file, loff_t start, loff_t end, int datasync);
510
511/* gc.c */
512u32 get_best_cand(struct super_block *sb, struct candidate_list *list, u32 *ec);
513void logfs_gc_pass(struct super_block *sb);
514int logfs_check_areas(struct super_block *sb);
515int logfs_init_gc(struct super_block *sb);
516void logfs_cleanup_gc(struct super_block *sb);
517
518/* inode.c */
519extern const struct super_operations logfs_super_operations;
520struct inode *logfs_iget(struct super_block *sb, ino_t ino);
521struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *cookie);
522void logfs_safe_iput(struct inode *inode, int cookie);
523struct inode *logfs_new_inode(struct inode *dir, int mode);
524struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino);
525struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino);
526int logfs_init_inode_cache(void);
527void logfs_destroy_inode_cache(void);
528void logfs_set_blocks(struct inode *inode, u64 no);
529/* these logically belong into inode.c but actually reside in readwrite.c */
530int logfs_read_inode(struct inode *inode);
531int __logfs_write_inode(struct inode *inode, long flags);
532void logfs_evict_inode(struct inode *inode);
533
534/* journal.c */
535void logfs_write_anchor(struct super_block *sb);
536int logfs_init_journal(struct super_block *sb);
537void logfs_cleanup_journal(struct super_block *sb);
538int write_alias_journal(struct super_block *sb, u64 ino, u64 bix,
539		level_t level, int child_no, __be64 val);
540void do_logfs_journal_wl_pass(struct super_block *sb);
541
542/* readwrite.c */
543pgoff_t logfs_pack_index(u64 bix, level_t level);
544void logfs_unpack_index(pgoff_t index, u64 *bix, level_t *level);
545int logfs_inode_write(struct inode *inode, const void *buf, size_t count,
546		loff_t bix, long flags, struct shadow_tree *shadow_tree);
547int logfs_readpage_nolock(struct page *page);
548int logfs_write_buf(struct inode *inode, struct page *page, long flags);
549int logfs_delete(struct inode *inode, pgoff_t index,
550		struct shadow_tree *shadow_tree);
551int logfs_rewrite_block(struct inode *inode, u64 bix, u64 ofs,
552		gc_level_t gc_level, long flags);
553int logfs_is_valid_block(struct super_block *sb, u64 ofs, u64 ino, u64 bix,
554		gc_level_t gc_level);
555int logfs_truncate(struct inode *inode, u64 size);
556u64 logfs_seek_hole(struct inode *inode, u64 bix);
557u64 logfs_seek_data(struct inode *inode, u64 bix);
558int logfs_open_segfile(struct super_block *sb);
559int logfs_init_rw(struct super_block *sb);
560void logfs_cleanup_rw(struct super_block *sb);
561void logfs_add_transaction(struct inode *inode, struct logfs_transaction *ta);
562void logfs_del_transaction(struct inode *inode, struct logfs_transaction *ta);
563void logfs_write_block(struct logfs_block *block, long flags);
564int logfs_write_obj_aliases_pagecache(struct super_block *sb);
565void logfs_get_segment_entry(struct super_block *sb, u32 segno,
566		struct logfs_segment_entry *se);
567void logfs_set_segment_used(struct super_block *sb, u64 ofs, int increment);
568void logfs_set_segment_erased(struct super_block *sb, u32 segno, u32 ec,
569		gc_level_t gc_level);
570void logfs_set_segment_reserved(struct super_block *sb, u32 segno);
571void logfs_set_segment_unreserved(struct super_block *sb, u32 segno, u32 ec);
572struct logfs_block *__alloc_block(struct super_block *sb,
573		u64 ino, u64 bix, level_t level);
574void __free_block(struct super_block *sb, struct logfs_block *block);
575void btree_write_block(struct logfs_block *block);
576void initialize_block_counters(struct page *page, struct logfs_block *block,
577		__be64 *array, int page_is_empty);
578int logfs_exist_block(struct inode *inode, u64 bix);
579int get_page_reserve(struct inode *inode, struct page *page);
580extern struct logfs_block_ops indirect_block_ops;
581
582/* segment.c */
583int logfs_erase_segment(struct super_block *sb, u32 ofs, int ensure_erase);
584int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf);
585int logfs_segment_read(struct inode *inode, struct page *page, u64 ofs, u64 bix,
586		level_t level);
587int logfs_segment_write(struct inode *inode, struct page *page,
588		struct logfs_shadow *shadow);
589int logfs_segment_delete(struct inode *inode, struct logfs_shadow *shadow);
590int logfs_load_object_aliases(struct super_block *sb,
591		struct logfs_obj_alias *oa, int count);
592void move_page_to_btree(struct page *page);
593int logfs_init_mapping(struct super_block *sb);
594void logfs_sync_area(struct logfs_area *area);
595void logfs_sync_segments(struct super_block *sb);
596void freeseg(struct super_block *sb, u32 segno);
597
598/* area handling */
599int logfs_init_areas(struct super_block *sb);
600void logfs_cleanup_areas(struct super_block *sb);
601int logfs_open_area(struct logfs_area *area, size_t bytes);
602int __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len,
603		int use_filler);
604
605static inline int logfs_buf_write(struct logfs_area *area, u64 ofs,
606		void *buf, size_t len)
607{
608	return __logfs_buf_write(area, ofs, buf, len, 0);
609}
610
611static inline int logfs_buf_recover(struct logfs_area *area, u64 ofs,
612		void *buf, size_t len)
613{
614	return __logfs_buf_write(area, ofs, buf, len, 1);
615}
616
617/* super.c */
618struct page *emergency_read_begin(struct address_space *mapping, pgoff_t index);
619void emergency_read_end(struct page *page);
620void logfs_crash_dump(struct super_block *sb);
621void *memchr_inv(const void *s, int c, size_t n);
622int logfs_statfs(struct dentry *dentry, struct kstatfs *stats);
623int logfs_check_ds(struct logfs_disk_super *ds);
624int logfs_write_sb(struct super_block *sb);
625
626static inline struct logfs_super *logfs_super(struct super_block *sb)
627{
628	return sb->s_fs_info;
629}
630
631static inline struct logfs_inode *logfs_inode(struct inode *inode)
632{
633	return container_of(inode, struct logfs_inode, vfs_inode);
634}
635
636static inline void logfs_set_ro(struct super_block *sb)
637{
638	logfs_super(sb)->s_flags |= LOGFS_SB_FLAG_RO;
639}
640
641#define LOGFS_BUG(sb) do {					\
642	struct super_block *__sb = sb;				\
643	logfs_crash_dump(__sb);					\
644	logfs_super(__sb)->s_flags |= LOGFS_SB_FLAG_RO;		\
645	BUG();							\
646} while (0)
647
648#define LOGFS_BUG_ON(condition, sb) \
649	do { if (unlikely(condition)) LOGFS_BUG((sb)); } while (0)
650
651static inline __be32 logfs_crc32(void *data, size_t len, size_t skip)
652{
653	return cpu_to_be32(crc32(~0, data+skip, len-skip));
654}
655
656static inline u8 logfs_type(struct inode *inode)
657{
658	return (inode->i_mode >> 12) & 15;
659}
660
661static inline pgoff_t logfs_index(struct super_block *sb, u64 pos)
662{
663	return pos >> sb->s_blocksize_bits;
664}
665
666static inline u64 dev_ofs(struct super_block *sb, u32 segno, u32 ofs)
667{
668	return ((u64)segno << logfs_super(sb)->s_segshift) + ofs;
669}
670
671static inline u32 seg_no(struct super_block *sb, u64 ofs)
672{
673	return ofs >> logfs_super(sb)->s_segshift;
674}
675
676static inline u32 seg_ofs(struct super_block *sb, u64 ofs)
677{
678	return ofs & logfs_super(sb)->s_segmask;
679}
680
681static inline u64 seg_align(struct super_block *sb, u64 ofs)
682{
683	return ofs & ~logfs_super(sb)->s_segmask;
684}
685
686static inline struct logfs_block *logfs_block(struct page *page)
687{
688	return (void *)page->private;
689}
690
691static inline level_t shrink_level(gc_level_t __level)
692{
693	u8 level = (__force u8)__level;
694
695	if (level >= LOGFS_MAX_LEVELS)
696		level -= LOGFS_MAX_LEVELS;
697	return (__force level_t)level;
698}
699
700static inline gc_level_t expand_level(u64 ino, level_t __level)
701{
702	u8 level = (__force u8)__level;
703
704	if (ino == LOGFS_INO_MASTER) {
705		/* ifile has separate areas */
706		level += LOGFS_MAX_LEVELS;
707	}
708	return (__force gc_level_t)level;
709}
710
711static inline int logfs_block_shift(struct super_block *sb, level_t level)
712{
713	level = shrink_level((__force gc_level_t)level);
714	return (__force int)level * (sb->s_blocksize_bits - 3);
715}
716
717static inline u64 logfs_block_mask(struct super_block *sb, level_t level)
718{
719	return ~0ull << logfs_block_shift(sb, level);
720}
721
722static inline struct logfs_area *get_area(struct super_block *sb,
723		gc_level_t gc_level)
724{
725	return logfs_super(sb)->s_area[(__force u8)gc_level];
726}
727
728static inline void logfs_mempool_destroy(mempool_t *pool)
729{
730	if (pool)
731		mempool_destroy(pool);
732}
733
734#endif