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 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 struct 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 */ 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)(struct file *_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 */ 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 263 * @segment_map: bitfield of segments containing shadows 264 * @no_shadowed_segment: number of segments containing shadows 265 */ 266 struct 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 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 const 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); 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 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]; 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 */ 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 475 int logfs_get_sb_bdev(struct logfs_super *s, 476 struct file_system_type *type, 477 const char *devname); 478 #else logfs_get_sb_bdev(struct logfs_super * s,struct file_system_type * type,const char * devname)479 static 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 #if IS_ENABLED(CONFIG_MTD) 489 int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr); 490 #else logfs_get_sb_mtd(struct logfs_super * s,int mtdnr)491 static inline int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr) 492 { 493 return -ENODEV; 494 } 495 #endif 496 497 /* dir.c */ 498 extern const struct inode_operations logfs_dir_iops; 499 extern const struct file_operations logfs_dir_fops; 500 int logfs_replay_journal(struct super_block *sb); 501 502 /* file.c */ 503 extern const struct inode_operations logfs_reg_iops; 504 extern const struct file_operations logfs_reg_fops; 505 extern const struct address_space_operations logfs_reg_aops; 506 int logfs_readpage(struct file *file, struct page *page); 507 long logfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 508 int logfs_fsync(struct file *file, loff_t start, loff_t end, int datasync); 509 510 /* gc.c */ 511 u32 get_best_cand(struct super_block *sb, struct candidate_list *list, u32 *ec); 512 void logfs_gc_pass(struct super_block *sb); 513 int logfs_check_areas(struct super_block *sb); 514 int logfs_init_gc(struct super_block *sb); 515 void logfs_cleanup_gc(struct super_block *sb); 516 517 /* inode.c */ 518 extern const struct super_operations logfs_super_operations; 519 struct inode *logfs_iget(struct super_block *sb, ino_t ino); 520 struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *cookie); 521 void logfs_safe_iput(struct inode *inode, int cookie); 522 struct inode *logfs_new_inode(struct inode *dir, umode_t mode); 523 struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino); 524 struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino); 525 int logfs_init_inode_cache(void); 526 void logfs_destroy_inode_cache(void); 527 void logfs_set_blocks(struct inode *inode, u64 no); 528 /* these logically belong into inode.c but actually reside in readwrite.c */ 529 int logfs_read_inode(struct inode *inode); 530 int __logfs_write_inode(struct inode *inode, struct page *, long flags); 531 void logfs_evict_inode(struct inode *inode); 532 533 /* journal.c */ 534 void logfs_write_anchor(struct super_block *sb); 535 int logfs_init_journal(struct super_block *sb); 536 void logfs_cleanup_journal(struct super_block *sb); 537 int write_alias_journal(struct super_block *sb, u64 ino, u64 bix, 538 level_t level, int child_no, __be64 val); 539 void do_logfs_journal_wl_pass(struct super_block *sb); 540 541 /* readwrite.c */ 542 pgoff_t logfs_pack_index(u64 bix, level_t level); 543 void logfs_unpack_index(pgoff_t index, u64 *bix, level_t *level); 544 int logfs_inode_write(struct inode *inode, const void *buf, size_t count, 545 loff_t bix, long flags, struct shadow_tree *shadow_tree); 546 int logfs_readpage_nolock(struct page *page); 547 int logfs_write_buf(struct inode *inode, struct page *page, long flags); 548 int logfs_delete(struct inode *inode, pgoff_t index, 549 struct shadow_tree *shadow_tree); 550 int logfs_rewrite_block(struct inode *inode, u64 bix, u64 ofs, 551 gc_level_t gc_level, long flags); 552 int logfs_is_valid_block(struct super_block *sb, u64 ofs, u64 ino, u64 bix, 553 gc_level_t gc_level); 554 int logfs_truncate(struct inode *inode, u64 size); 555 u64 logfs_seek_hole(struct inode *inode, u64 bix); 556 u64 logfs_seek_data(struct inode *inode, u64 bix); 557 int logfs_open_segfile(struct super_block *sb); 558 int logfs_init_rw(struct super_block *sb); 559 void logfs_cleanup_rw(struct super_block *sb); 560 void logfs_add_transaction(struct inode *inode, struct logfs_transaction *ta); 561 void logfs_del_transaction(struct inode *inode, struct logfs_transaction *ta); 562 void logfs_write_block(struct logfs_block *block, long flags); 563 int logfs_write_obj_aliases_pagecache(struct super_block *sb); 564 void logfs_get_segment_entry(struct super_block *sb, u32 segno, 565 struct logfs_segment_entry *se); 566 void logfs_set_segment_used(struct super_block *sb, u64 ofs, int increment); 567 void logfs_set_segment_erased(struct super_block *sb, u32 segno, u32 ec, 568 gc_level_t gc_level); 569 void logfs_set_segment_reserved(struct super_block *sb, u32 segno); 570 void logfs_set_segment_unreserved(struct super_block *sb, u32 segno, u32 ec); 571 struct logfs_block *__alloc_block(struct super_block *sb, 572 u64 ino, u64 bix, level_t level); 573 void __free_block(struct super_block *sb, struct logfs_block *block); 574 void btree_write_block(struct logfs_block *block); 575 void initialize_block_counters(struct page *page, struct logfs_block *block, 576 __be64 *array, int page_is_empty); 577 int logfs_exist_block(struct inode *inode, u64 bix); 578 int get_page_reserve(struct inode *inode, struct page *page); 579 void logfs_get_wblocks(struct super_block *sb, struct page *page, int lock); 580 void logfs_put_wblocks(struct super_block *sb, struct page *page, int lock); 581 extern const struct logfs_block_ops indirect_block_ops; 582 583 /* segment.c */ 584 int logfs_erase_segment(struct super_block *sb, u32 ofs, int ensure_erase); 585 int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf); 586 int logfs_segment_read(struct inode *inode, struct page *page, u64 ofs, u64 bix, 587 level_t level); 588 int logfs_segment_write(struct inode *inode, struct page *page, 589 struct logfs_shadow *shadow); 590 int logfs_segment_delete(struct inode *inode, struct logfs_shadow *shadow); 591 int logfs_load_object_aliases(struct super_block *sb, 592 struct logfs_obj_alias *oa, int count); 593 void move_page_to_btree(struct page *page); 594 int logfs_init_mapping(struct super_block *sb); 595 void logfs_sync_area(struct logfs_area *area); 596 void logfs_sync_segments(struct super_block *sb); 597 void freeseg(struct super_block *sb, u32 segno); 598 void free_areas(struct super_block *sb); 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); 604 int __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len, 605 int use_filler); 606 logfs_buf_write(struct logfs_area * area,u64 ofs,void * buf,size_t len)607 static inline int logfs_buf_write(struct logfs_area *area, u64 ofs, 608 void *buf, size_t len) 609 { 610 return __logfs_buf_write(area, ofs, buf, len, 0); 611 } 612 logfs_buf_recover(struct logfs_area * area,u64 ofs,void * buf,size_t len)613 static inline int logfs_buf_recover(struct logfs_area *area, u64 ofs, 614 void *buf, size_t len) 615 { 616 return __logfs_buf_write(area, ofs, buf, len, 1); 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); 623 int logfs_statfs(struct dentry *dentry, struct kstatfs *stats); 624 int logfs_check_ds(struct logfs_disk_super *ds); 625 int logfs_write_sb(struct super_block *sb); 626 logfs_super(struct super_block * sb)627 static inline struct logfs_super *logfs_super(struct super_block *sb) 628 { 629 return sb->s_fs_info; 630 } 631 logfs_inode(struct inode * inode)632 static inline struct logfs_inode *logfs_inode(struct inode *inode) 633 { 634 return container_of(inode, struct logfs_inode, vfs_inode); 635 } 636 logfs_set_ro(struct super_block * sb)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 logfs_crc32(void * data,size_t len,size_t skip)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 logfs_type(struct inode * inode)657 static inline u8 logfs_type(struct inode *inode) 658 { 659 return (inode->i_mode >> 12) & 15; 660 } 661 logfs_index(struct super_block * sb,u64 pos)662 static inline pgoff_t logfs_index(struct super_block *sb, u64 pos) 663 { 664 return pos >> sb->s_blocksize_bits; 665 } 666 dev_ofs(struct super_block * sb,u32 segno,u32 ofs)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 seg_no(struct super_block * sb,u64 ofs)672 static inline u32 seg_no(struct super_block *sb, u64 ofs) 673 { 674 return ofs >> logfs_super(sb)->s_segshift; 675 } 676 seg_ofs(struct super_block * sb,u64 ofs)677 static inline u32 seg_ofs(struct super_block *sb, u64 ofs) 678 { 679 return ofs & logfs_super(sb)->s_segmask; 680 } 681 seg_align(struct super_block * sb,u64 ofs)682 static inline u64 seg_align(struct super_block *sb, u64 ofs) 683 { 684 return ofs & ~logfs_super(sb)->s_segmask; 685 } 686 logfs_block(struct page * page)687 static inline struct logfs_block *logfs_block(struct page *page) 688 { 689 return (void *)page->private; 690 } 691 shrink_level(gc_level_t __level)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 expand_level(u64 ino,level_t __level)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) { 706 /* ifile has separate areas */ 707 level += LOGFS_MAX_LEVELS; 708 } 709 return (__force gc_level_t)level; 710 } 711 logfs_block_shift(struct super_block * sb,level_t level)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 logfs_block_mask(struct super_block * sb,level_t level)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 get_area(struct super_block * sb,gc_level_t gc_level)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 logfs_mempool_destroy(mempool_t * pool)729 static inline void logfs_mempool_destroy(mempool_t *pool) 730 { 731 if (pool) 732 mempool_destroy(pool); 733 } 734 735 #endif 736