]>
Commit | Line | Data |
---|---|---|
5db53f3e JE |
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 | |
c6d38301 | 85 | #define LOGFS_SB_FLAG_DIRTY 0x0002 |
5db53f3e JE |
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 | ||
e5a0726a | 139 | struct logfs_super; /* forward */ |
5db53f3e JE |
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 | |
6f485b41 | 148 | * @can_write_buf: decide whether wbuf can be written to ofs |
5db53f3e JE |
149 | */ |
150 | struct 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); | |
9421502b JE |
156 | int (*erase)(struct super_block *sb, loff_t ofs, size_t len, |
157 | int ensure_write); | |
6f485b41 | 158 | int (*can_write_buf)(struct super_block *sb, u64 ofs); |
5db53f3e | 159 | void (*sync)(struct super_block *sb); |
e5a0726a | 160 | void (*put_device)(struct logfs_super *s); |
5db53f3e JE |
161 | }; |
162 | ||
163 | /** | |
164 | * struct candidate_list - list of similar candidates | |
165 | */ | |
166 | struct 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 | */ | |
188 | struct 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 | */ | |
205 | struct logfs_journal_entry { | |
206 | int used; | |
207 | s16 version; | |
208 | u16 len; | |
209 | u16 datalen; | |
210 | u64 offset; | |
211 | }; | |
212 | ||
213 | enum 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 | */ | |
232 | struct 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 | */ | |
249 | struct 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 | |
032d8f72 JE |
263 | * @segment_map: bitfield of segments containing shadows |
264 | * @no_shadowed_segment: number of segments containing shadows | |
5db53f3e JE |
265 | */ |
266 | struct shadow_tree { | |
267 | struct btree_head64 new; | |
268 | struct btree_head64 old; | |
032d8f72 JE |
269 | struct btree_head32 segment_map; |
270 | int no_shadowed_segments; | |
5db53f3e JE |
271 | }; |
272 | ||
273 | struct 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 */ | |
293 | struct logfs_block_ops; | |
294 | struct 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 | ||
311 | typedef int write_alias_t(struct super_block *sb, u64 ino, u64 bix, | |
312 | level_t level, int child_no, __be64 val); | |
313 | struct logfs_block_ops { | |
314 | void (*write_block)(struct logfs_block *block); | |
5db53f3e JE |
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 | ||
032d8f72 JE |
321 | #define MAX_JOURNAL_ENTRIES 256 |
322 | ||
5db53f3e JE |
323 | struct 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]; | |
9421502b | 339 | struct page *s_erase_page; /* for dev_bdev.c */ |
5db53f3e JE |
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 */ | |
032d8f72 | 389 | __be64 s_je_array[MAX_JOURNAL_ENTRIES]; |
5db53f3e JE |
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 */ | |
05ebad85 | 400 | struct list_head s_writeback_list; /* writeback pages */ |
5db53f3e JE |
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 | */ | |
452 | struct 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 */ | |
468 | int logfs_compress(void *in, void *out, size_t inlen, size_t outlen); | |
469 | int logfs_uncompress(void *in, void *out, size_t inlen, size_t outlen); | |
470 | int __init logfs_compr_init(void); | |
471 | void logfs_compr_exit(void); | |
472 | ||
473 | /* dev_bdev.c */ | |
474 | #ifdef CONFIG_BLOCK | |
71a1c012 | 475 | int logfs_get_sb_bdev(struct logfs_super *s, |
7d945a3a AV |
476 | struct file_system_type *type, |
477 | const char *devname); | |
5db53f3e | 478 | #else |
71a1c012 | 479 | static inline int logfs_get_sb_bdev(struct logfs_super *s, |
7d945a3a AV |
480 | struct file_system_type *type, |
481 | const char *devname) | |
5db53f3e JE |
482 | { |
483 | return -ENODEV; | |
484 | } | |
485 | #endif | |
486 | ||
487 | /* dev_mtd.c */ | |
488 | #ifdef CONFIG_MTD | |
e99d11d1 | 489 | int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr); |
5db53f3e | 490 | #else |
7d945a3a | 491 | static inline int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr) |
5db53f3e JE |
492 | { |
493 | return -ENODEV; | |
494 | } | |
495 | #endif | |
496 | ||
497 | /* dir.c */ | |
498 | extern const struct inode_operations logfs_symlink_iops; | |
499 | extern const struct inode_operations logfs_dir_iops; | |
500 | extern const struct file_operations logfs_dir_fops; | |
501 | int logfs_replay_journal(struct super_block *sb); | |
502 | ||
503 | /* file.c */ | |
504 | extern const struct inode_operations logfs_reg_iops; | |
505 | extern const struct file_operations logfs_reg_fops; | |
506 | extern const struct address_space_operations logfs_reg_aops; | |
507 | int logfs_readpage(struct file *file, struct page *page); | |
02d6d685 | 508 | long logfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); |
02c24a82 | 509 | int logfs_fsync(struct file *file, loff_t start, loff_t end, int datasync); |
5db53f3e JE |
510 | |
511 | /* gc.c */ | |
512 | u32 get_best_cand(struct super_block *sb, struct candidate_list *list, u32 *ec); | |
513 | void logfs_gc_pass(struct super_block *sb); | |
514 | int logfs_check_areas(struct super_block *sb); | |
515 | int logfs_init_gc(struct super_block *sb); | |
516 | void logfs_cleanup_gc(struct super_block *sb); | |
517 | ||
518 | /* inode.c */ | |
519 | extern const struct super_operations logfs_super_operations; | |
520 | struct inode *logfs_iget(struct super_block *sb, ino_t ino); | |
521 | struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *cookie); | |
522 | void logfs_safe_iput(struct inode *inode, int cookie); | |
523 | struct inode *logfs_new_inode(struct inode *dir, int mode); | |
524 | struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino); | |
525 | struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino); | |
526 | int logfs_init_inode_cache(void); | |
527 | void logfs_destroy_inode_cache(void); | |
5db53f3e JE |
528 | void logfs_set_blocks(struct inode *inode, u64 no); |
529 | /* these logically belong into inode.c but actually reside in readwrite.c */ | |
530 | int logfs_read_inode(struct inode *inode); | |
0bd90387 | 531 | int __logfs_write_inode(struct inode *inode, struct page *, long flags); |
7da08fd1 | 532 | void logfs_evict_inode(struct inode *inode); |
5db53f3e JE |
533 | |
534 | /* journal.c */ | |
c6d38301 | 535 | void logfs_write_anchor(struct super_block *sb); |
5db53f3e JE |
536 | int logfs_init_journal(struct super_block *sb); |
537 | void logfs_cleanup_journal(struct super_block *sb); | |
538 | int write_alias_journal(struct super_block *sb, u64 ino, u64 bix, | |
539 | level_t level, int child_no, __be64 val); | |
540 | void do_logfs_journal_wl_pass(struct super_block *sb); | |
541 | ||
542 | /* readwrite.c */ | |
543 | pgoff_t logfs_pack_index(u64 bix, level_t level); | |
544 | void logfs_unpack_index(pgoff_t index, u64 *bix, level_t *level); | |
545 | int logfs_inode_write(struct inode *inode, const void *buf, size_t count, | |
546 | loff_t bix, long flags, struct shadow_tree *shadow_tree); | |
547 | int logfs_readpage_nolock(struct page *page); | |
548 | int logfs_write_buf(struct inode *inode, struct page *page, long flags); | |
549 | int logfs_delete(struct inode *inode, pgoff_t index, | |
550 | struct shadow_tree *shadow_tree); | |
551 | int logfs_rewrite_block(struct inode *inode, u64 bix, u64 ofs, | |
552 | gc_level_t gc_level, long flags); | |
553 | int logfs_is_valid_block(struct super_block *sb, u64 ofs, u64 ino, u64 bix, | |
554 | gc_level_t gc_level); | |
555 | int logfs_truncate(struct inode *inode, u64 size); | |
556 | u64 logfs_seek_hole(struct inode *inode, u64 bix); | |
557 | u64 logfs_seek_data(struct inode *inode, u64 bix); | |
558 | int logfs_open_segfile(struct super_block *sb); | |
559 | int logfs_init_rw(struct super_block *sb); | |
560 | void logfs_cleanup_rw(struct super_block *sb); | |
561 | void logfs_add_transaction(struct inode *inode, struct logfs_transaction *ta); | |
562 | void logfs_del_transaction(struct inode *inode, struct logfs_transaction *ta); | |
563 | void logfs_write_block(struct logfs_block *block, long flags); | |
564 | int logfs_write_obj_aliases_pagecache(struct super_block *sb); | |
565 | void logfs_get_segment_entry(struct super_block *sb, u32 segno, | |
566 | struct logfs_segment_entry *se); | |
567 | void logfs_set_segment_used(struct super_block *sb, u64 ofs, int increment); | |
568 | void logfs_set_segment_erased(struct super_block *sb, u32 segno, u32 ec, | |
569 | gc_level_t gc_level); | |
570 | void logfs_set_segment_reserved(struct super_block *sb, u32 segno); | |
571 | void logfs_set_segment_unreserved(struct super_block *sb, u32 segno, u32 ec); | |
572 | struct logfs_block *__alloc_block(struct super_block *sb, | |
573 | u64 ino, u64 bix, level_t level); | |
574 | void __free_block(struct super_block *sb, struct logfs_block *block); | |
575 | void btree_write_block(struct logfs_block *block); | |
576 | void initialize_block_counters(struct page *page, struct logfs_block *block, | |
577 | __be64 *array, int page_is_empty); | |
578 | int logfs_exist_block(struct inode *inode, u64 bix); | |
579 | int get_page_reserve(struct inode *inode, struct page *page); | |
13ced29c PJ |
580 | void logfs_get_wblocks(struct super_block *sb, struct page *page, int lock); |
581 | void logfs_put_wblocks(struct super_block *sb, struct page *page, int lock); | |
5db53f3e JE |
582 | extern struct logfs_block_ops indirect_block_ops; |
583 | ||
584 | /* segment.c */ | |
9421502b | 585 | int logfs_erase_segment(struct super_block *sb, u32 ofs, int ensure_erase); |
5db53f3e JE |
586 | int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf); |
587 | int logfs_segment_read(struct inode *inode, struct page *page, u64 ofs, u64 bix, | |
588 | level_t level); | |
589 | int logfs_segment_write(struct inode *inode, struct page *page, | |
590 | struct logfs_shadow *shadow); | |
591 | int logfs_segment_delete(struct inode *inode, struct logfs_shadow *shadow); | |
592 | int logfs_load_object_aliases(struct super_block *sb, | |
593 | struct logfs_obj_alias *oa, int count); | |
594 | void move_page_to_btree(struct page *page); | |
595 | int logfs_init_mapping(struct super_block *sb); | |
596 | void logfs_sync_area(struct logfs_area *area); | |
597 | void logfs_sync_segments(struct super_block *sb); | |
723b2ff4 | 598 | void freeseg(struct super_block *sb, u32 segno); |
5db53f3e JE |
599 | |
600 | /* area handling */ | |
601 | int logfs_init_areas(struct super_block *sb); | |
602 | void logfs_cleanup_areas(struct super_block *sb); | |
603 | int logfs_open_area(struct logfs_area *area, size_t bytes); | |
20503664 | 604 | int __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len, |
5db53f3e JE |
605 | int use_filler); |
606 | ||
20503664 | 607 | static inline int logfs_buf_write(struct logfs_area *area, u64 ofs, |
5db53f3e JE |
608 | void *buf, size_t len) |
609 | { | |
20503664 | 610 | return __logfs_buf_write(area, ofs, buf, len, 0); |
5db53f3e JE |
611 | } |
612 | ||
20503664 | 613 | static inline int logfs_buf_recover(struct logfs_area *area, u64 ofs, |
5db53f3e JE |
614 | void *buf, size_t len) |
615 | { | |
20503664 | 616 | return __logfs_buf_write(area, ofs, buf, len, 1); |
5db53f3e JE |
617 | } |
618 | ||
619 | /* super.c */ | |
620 | struct page *emergency_read_begin(struct address_space *mapping, pgoff_t index); | |
621 | void emergency_read_end(struct page *page); | |
622 | void logfs_crash_dump(struct super_block *sb); | |
5db53f3e | 623 | int logfs_statfs(struct dentry *dentry, struct kstatfs *stats); |
5db53f3e JE |
624 | int logfs_check_ds(struct logfs_disk_super *ds); |
625 | int logfs_write_sb(struct super_block *sb); | |
626 | ||
627 | static inline struct logfs_super *logfs_super(struct super_block *sb) | |
628 | { | |
629 | return sb->s_fs_info; | |
630 | } | |
631 | ||
632 | static inline struct logfs_inode *logfs_inode(struct inode *inode) | |
633 | { | |
634 | return container_of(inode, struct logfs_inode, vfs_inode); | |
635 | } | |
636 | ||
637 | static inline void logfs_set_ro(struct super_block *sb) | |
638 | { | |
639 | logfs_super(sb)->s_flags |= LOGFS_SB_FLAG_RO; | |
640 | } | |
641 | ||
642 | #define LOGFS_BUG(sb) do { \ | |
643 | struct super_block *__sb = sb; \ | |
644 | logfs_crash_dump(__sb); \ | |
645 | logfs_super(__sb)->s_flags |= LOGFS_SB_FLAG_RO; \ | |
646 | BUG(); \ | |
647 | } while (0) | |
648 | ||
649 | #define LOGFS_BUG_ON(condition, sb) \ | |
650 | do { if (unlikely(condition)) LOGFS_BUG((sb)); } while (0) | |
651 | ||
652 | static inline __be32 logfs_crc32(void *data, size_t len, size_t skip) | |
653 | { | |
654 | return cpu_to_be32(crc32(~0, data+skip, len-skip)); | |
655 | } | |
656 | ||
657 | static inline u8 logfs_type(struct inode *inode) | |
658 | { | |
659 | return (inode->i_mode >> 12) & 15; | |
660 | } | |
661 | ||
662 | static inline pgoff_t logfs_index(struct super_block *sb, u64 pos) | |
663 | { | |
664 | return pos >> sb->s_blocksize_bits; | |
665 | } | |
666 | ||
667 | static inline u64 dev_ofs(struct super_block *sb, u32 segno, u32 ofs) | |
668 | { | |
669 | return ((u64)segno << logfs_super(sb)->s_segshift) + ofs; | |
670 | } | |
671 | ||
672 | static inline u32 seg_no(struct super_block *sb, u64 ofs) | |
673 | { | |
674 | return ofs >> logfs_super(sb)->s_segshift; | |
675 | } | |
676 | ||
677 | static inline u32 seg_ofs(struct super_block *sb, u64 ofs) | |
678 | { | |
679 | return ofs & logfs_super(sb)->s_segmask; | |
680 | } | |
681 | ||
682 | static inline u64 seg_align(struct super_block *sb, u64 ofs) | |
683 | { | |
684 | return ofs & ~logfs_super(sb)->s_segmask; | |
685 | } | |
686 | ||
687 | static inline struct logfs_block *logfs_block(struct page *page) | |
688 | { | |
689 | return (void *)page->private; | |
690 | } | |
691 | ||
692 | static inline level_t shrink_level(gc_level_t __level) | |
693 | { | |
694 | u8 level = (__force u8)__level; | |
695 | ||
696 | if (level >= LOGFS_MAX_LEVELS) | |
697 | level -= LOGFS_MAX_LEVELS; | |
698 | return (__force level_t)level; | |
699 | } | |
700 | ||
701 | static inline gc_level_t expand_level(u64 ino, level_t __level) | |
702 | { | |
703 | u8 level = (__force u8)__level; | |
704 | ||
705 | if (ino == LOGFS_INO_MASTER) { | |
a8cd4561 | 706 | /* ifile has separate areas */ |
5db53f3e JE |
707 | level += LOGFS_MAX_LEVELS; |
708 | } | |
709 | return (__force gc_level_t)level; | |
710 | } | |
711 | ||
712 | static inline int logfs_block_shift(struct super_block *sb, level_t level) | |
713 | { | |
714 | level = shrink_level((__force gc_level_t)level); | |
715 | return (__force int)level * (sb->s_blocksize_bits - 3); | |
716 | } | |
717 | ||
718 | static inline u64 logfs_block_mask(struct super_block *sb, level_t level) | |
719 | { | |
720 | return ~0ull << logfs_block_shift(sb, level); | |
721 | } | |
722 | ||
723 | static inline struct logfs_area *get_area(struct super_block *sb, | |
724 | gc_level_t gc_level) | |
725 | { | |
726 | return logfs_super(sb)->s_area[(__force u8)gc_level]; | |
727 | } | |
728 | ||
1f1b0008 JE |
729 | static inline void logfs_mempool_destroy(mempool_t *pool) |
730 | { | |
731 | if (pool) | |
732 | mempool_destroy(pool); | |
733 | } | |
734 | ||
5db53f3e | 735 | #endif |