cregit-Linux how code gets into the kernel

Release 4.7 fs/logfs/logfs.h

Directory: fs/logfs
/*
 * fs/logfs/logfs.h
 *
 * As should be obvious for Linux kernel code, license is GPLv2
 *
 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
 *
 * Private header for logfs.
 */
#ifndef FS_LOGFS_LOGFS_H

#define FS_LOGFS_LOGFS_H


#undef __CHECK_ENDIAN__

#define __CHECK_ENDIAN__

#include <linux/btree.h>
#include <linux/crc32.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/mempool.h>
#include <linux/pagemap.h>
#include <linux/mtd/mtd.h>
#include "logfs_abi.h"


#define LOGFS_DEBUG_SUPER	(0x0001)

#define LOGFS_DEBUG_SEGMENT	(0x0002)

#define LOGFS_DEBUG_JOURNAL	(0x0004)

#define LOGFS_DEBUG_DIR		(0x0008)

#define LOGFS_DEBUG_FILE	(0x0010)

#define LOGFS_DEBUG_INODE	(0x0020)

#define LOGFS_DEBUG_READWRITE	(0x0040)

#define LOGFS_DEBUG_GC		(0x0080)

#define LOGFS_DEBUG_GC_NOISY	(0x0100)

#define LOGFS_DEBUG_ALIASES	(0x0200)

#define LOGFS_DEBUG_BLOCKMOVE	(0x0400)

#define LOGFS_DEBUG_ALL		(0xffffffff)


#define LOGFS_DEBUG		(0x01)
/*
 * To enable specific log messages, simply define LOGFS_DEBUG to match any
 * or all of the above.
 */
#ifndef LOGFS_DEBUG

#define LOGFS_DEBUG		(0)
#endif


#define log_cond(cond, fmt, arg...) do {    \
        if (cond)                               \
                printk(KERN_DEBUG fmt, ##arg);  \
} while (0)


#define log_super(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_SUPER, fmt, ##arg)

#define log_segment(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_SEGMENT, fmt, ##arg)

#define log_journal(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_JOURNAL, fmt, ##arg)

#define log_dir(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_DIR, fmt, ##arg)

#define log_file(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_FILE, fmt, ##arg)

#define log_inode(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_INODE, fmt, ##arg)

#define log_readwrite(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_READWRITE, fmt, ##arg)

#define log_gc(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_GC, fmt, ##arg)

#define log_gc_noisy(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_GC_NOISY, fmt, ##arg)

#define log_aliases(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_ALIASES, fmt, ##arg)

#define log_blockmove(fmt, arg...) \
	log_cond(LOGFS_DEBUG & LOGFS_DEBUG_BLOCKMOVE, fmt, ##arg)


#define PG_pre_locked		PG_owner_priv_1

#define PagePreLocked(page)	test_bit(PG_pre_locked, &(page)->flags)

#define SetPagePreLocked(page)	set_bit(PG_pre_locked, &(page)->flags)

#define ClearPagePreLocked(page) clear_bit(PG_pre_locked, &(page)->flags)

/* FIXME: This should really be somewhere in the 64bit area. */

#define LOGFS_LINK_MAX		(1<<30)

/* Read-only filesystem */

#define LOGFS_SB_FLAG_RO	0x0001

#define LOGFS_SB_FLAG_DIRTY	0x0002

#define LOGFS_SB_FLAG_OBJ_ALIAS	0x0004

#define LOGFS_SB_FLAG_SHUTDOWN	0x0008

/* Write Control Flags */

#define WF_LOCK			0x01 
/* take write lock */

#define WF_WRITE		0x02 
/* write block */

#define WF_DELETE		0x04 
/* delete old block */


typedef u8 __bitwise level_t;

typedef u8 __bitwise gc_level_t;


#define LEVEL(level) ((__force level_t)(level))

#define GC_LEVEL(gc_level) ((__force gc_level_t)(gc_level))


#define SUBLEVEL(level) ( (void)((level) == LEVEL(1)),  \
                (__force level_t)((__force u8)(level) - 1) )

/**
 * struct logfs_area - area management information
 *
 * @a_sb:                       the superblock this area belongs to
 * @a_is_open:                  1 if the area is currently open, else 0
 * @a_segno:                    segment number of area
 * @a_written_bytes:            number of bytes already written back
 * @a_used_bytes:               number of used bytes
 * @a_ops:                      area operations (either journal or ostore)
 * @a_erase_count:              erase count
 * @a_level:                    GC level
 */

struct logfs_area { /* a segment open for writing */
	
struct super_block *a_sb;
	
int	a_is_open;
	
u32	a_segno;
	
u32	a_written_bytes;
	
u32	a_used_bytes;
	
const struct logfs_area_ops *a_ops;
	
u32	a_erase_count;
	
gc_level_t a_level;
};

/**
 * struct logfs_area_ops - area operations
 *
 * @get_free_segment:           fill area->ofs with the offset of a free segment
 * @get_erase_count:            fill area->erase_count (needs area->ofs)
 * @erase_segment:              erase and setup segment
 */

struct logfs_area_ops {
	
void	(*get_free_segment)(struct logfs_area *area);
	
void	(*get_erase_count)(struct logfs_area *area);
	
int	(*erase_segment)(struct logfs_area *area);
};

struct logfs_super;	/* forward */
/**
 * struct logfs_device_ops - device access operations
 *
 * @readpage:                   read one page (mm page)
 * @writeseg:                   write one segment.  may be a partial segment
 * @erase:                      erase one segment
 * @read:                       read from the device
 * @erase:                      erase part of the device
 * @can_write_buf:              decide whether wbuf can be written to ofs
 */

struct logfs_device_ops {
	
struct page *(*find_first_sb)(struct super_block *sb, u64 *ofs);
	
struct page *(*find_last_sb)(struct super_block *sb, u64 *ofs);
	
int (*write_sb)(struct super_block *sb, struct page *page);
	
int (*readpage)(void *_sb, struct page *page);
	
void (*writeseg)(struct super_block *sb, u64 ofs, size_t len);
	
int (*erase)(struct super_block *sb, loff_t ofs, size_t len,
			int ensure_write);
	
int (*can_write_buf)(struct super_block *sb, u64 ofs);
	
void (*sync)(struct super_block *sb);
	
void (*put_device)(struct logfs_super *s);
};

/**
 * struct candidate_list - list of similar candidates
 */

struct candidate_list {
	
struct rb_root rb_tree;
	
int count;
	
int maxcount;
	
int sort_by_ec;
};

/**
 * struct gc_candidate - "candidate" segment to be garbage collected next
 *
 * @list:                       list (either free of low)
 * @segno:                      segment number
 * @valid:                      number of valid bytes
 * @erase_count:                erase count of segment
 * @dist:                       distance from tree root
 *
 * Candidates can be on two lists.  The free list contains electees rather
 * than candidates - segments that no longer contain any valid data.  The
 * low list contains candidates to be picked for GC.  It should be kept
 * short.  It is not required to always pick a perfect candidate.  In the
 * worst case GC will have to move more data than absolutely necessary.
 */

struct gc_candidate {
	
struct rb_node rb_node;
	
struct candidate_list *list;
	
u32	segno;
	
u32	valid;
	
u32	erase_count;
	
u8	dist;
};

/**
 * struct logfs_journal_entry - temporary structure used during journal scan
 *
 * @used:
 * @version:                    normalized version
 * @len:                        length
 * @offset:                     offset
 */

struct logfs_journal_entry {
	
int used;
	
s16 version;
	
u16 len;
	
u16 datalen;
	
u64 offset;
};


enum transaction_state {
	
CREATE_1 = 1,
	
CREATE_2,
	
UNLINK_1,
	
UNLINK_2,
	
CROSS_RENAME_1,
	
CROSS_RENAME_2,
	
TARGET_RENAME_1,
	
TARGET_RENAME_2,
	
TARGET_RENAME_3
};

/**
 * struct logfs_transaction - essential fields to support atomic dirops
 *
 * @ino:                        target inode
 * @dir:                        inode of directory containing dentry
 * @pos:                        pos of dentry in directory
 */

struct logfs_transaction {
	
enum transaction_state state;
	
u64	 ino;
	
u64	 dir;
	
u64	 pos;
};

/**
 * struct logfs_shadow - old block in the shadow of a not-yet-committed new one
 * @old_ofs:                    offset of old block on medium
 * @new_ofs:                    offset of new block on medium
 * @ino:                        inode number
 * @bix:                        block index
 * @old_len:                    size of old block, including header
 * @new_len:                    size of new block, including header
 * @level:                      block level
 */

struct logfs_shadow {
	
u64 old_ofs;
	
u64 new_ofs;
	
u64 ino;
	
u64 bix;
	
int old_len;
	
int new_len;
	
gc_level_t gc_level;
};

/**
 * struct shadow_tree
 * @new:                        shadows where old_ofs==0, indexed by new_ofs
 * @old:                        shadows where old_ofs!=0, indexed by old_ofs
 * @segment_map:                bitfield of segments containing shadows
 * @no_shadowed_segment:        number of segments containing shadows
 */

struct shadow_tree {
	
struct btree_head64 new;
	
struct btree_head64 old;
	
struct btree_head32 segment_map;
	
int no_shadowed_segments;
};


struct object_alias_item {
	
struct list_head list;
	
__be64 val;
	
int child_no;
};

/**
 * struct logfs_block - contains any block state
 * @type:                       indirect block or inode
 * @full:                       number of fully populated children
 * @partial:                    number of partially populated children
 *
 * Most blocks are directly represented by page cache pages.  But when a block
 * becomes dirty, is part of a transaction, contains aliases or is otherwise
 * special, a struct logfs_block is allocated to track the additional state.
 * Inodes are very similar to indirect blocks, so they can also get one of
 * these structures added when appropriate.
 */

#define BLOCK_INDIRECT	1	
/* Indirect block */

#define BLOCK_INODE	2	
/* Inode */
struct logfs_block_ops;

struct logfs_block {
	
struct list_head alias_list;
	
struct list_head item_list;
	
struct super_block *sb;
	
u64 ino;
	
u64 bix;
	
level_t level;
	
struct page *page;
	
struct inode *inode;
	
struct logfs_transaction *ta;
	
unsigned long alias_map[LOGFS_BLOCK_FACTOR / BITS_PER_LONG];
	
const struct logfs_block_ops *ops;
	
int full;
	
int partial;
	
int reserved_bytes;
};


typedef int write_alias_t(struct super_block *sb, u64 ino, u64 bix,
		level_t level, int child_no, __be64 val);

struct logfs_block_ops {
	
void	(*write_block)(struct logfs_block *block);
	
void	(*free_block)(struct super_block *sb, struct logfs_block*block);
	
int	(*write_alias)(struct super_block *sb,
			struct logfs_block *block,
			write_alias_t *write_one_alias);
};


#define MAX_JOURNAL_ENTRIES 256


struct logfs_super {
	
struct mtd_info *s_mtd;			/* underlying device */
	
struct block_device *s_bdev;		/* underlying device */
	
const struct logfs_device_ops *s_devops;/* device access */
	
struct inode	*s_master_inode;	/* inode file */
	
struct inode	*s_segfile_inode;	/* segment file */
	
struct inode *s_mapping_inode;		/* device mapping */
	
atomic_t s_pending_writes;		/* outstanting bios */
	
long	 s_flags;
	
mempool_t *s_btree_pool;		/* for btree nodes */
	
mempool_t *s_alias_pool;		/* aliases in segment.c */
	
u64	 s_feature_incompat;
	
u64	 s_feature_ro_compat;
	
u64	 s_feature_compat;
	
u64	 s_feature_flags;
	
u64	 s_sb_ofs[2];
	
struct page *s_erase_page;		/* for dev_bdev.c */
	/* alias.c fields */
	
struct btree_head32 s_segment_alias;	/* remapped segments */
	
int	 s_no_object_aliases;
	
struct list_head s_object_alias;	/* remapped objects */
	
struct btree_head128 s_object_alias_tree; /* remapped objects */
	
struct mutex s_object_alias_mutex;
	/* dir.c fields */
	
struct mutex s_dirop_mutex;		/* for creat/unlink/rename */
	
u64	 s_victim_ino;			/* used for atomic dir-ops */
	
u64	 s_rename_dir;			/* source directory ino */
	
u64	 s_rename_pos;			/* position of source dd */
	/* gc.c fields */
	
long	 s_segsize;			/* size of a segment */
	
int	 s_segshift;			/* log2 of segment size */
	
long	 s_segmask;			/* 1 << s_segshift - 1 */
	
long	 s_no_segs;			/* segments on device */
	
long	 s_no_journal_segs;		/* segments used for journal */
	
long	 s_no_blocks;			/* blocks per segment */
	
long	 s_writesize;			/* minimum write size */
	
int	 s_writeshift;			/* log2 of write size */
	
u64	 s_size;			/* filesystem size */
	
struct logfs_area *s_area[LOGFS_NO_AREAS];	/* open segment array */
	
u64	 s_gec;				/* global erase count */
	
u64	 s_wl_gec_ostore;		/* time of last wl event */
	
u64	 s_wl_gec_journal;		/* time of last wl event */
	
u64	 s_sweeper;			/* current sweeper pos */
	
u8	 s_ifile_levels;		/* max level of ifile */
	
u8	 s_iblock_levels;		/* max level of regular files */
	
u8	 s_data_levels;			/* # of segments to leaf block*/
	
u8	 s_total_levels;		/* sum of above three */
	
struct btree_head32 s_cand_tree;	/* all candidates */
	
struct candidate_list s_free_list;	/* 100% free segments */
	
struct candidate_list s_reserve_list;	/* Bad segment reserve */
	
struct candidate_list s_low_list[LOGFS_NO_AREAS];/* good candidates */
	
struct candidate_list s_ec_list;	/* wear level candidates */
	
struct btree_head32 s_reserved_segments;/* sb, journal, bad, etc. */
	/* inode.c fields */
	
u64	 s_last_ino;			/* highest ino used */
	
long	 s_inos_till_wrap;
	
u32	 s_generation;			/* i_generation for new files */
	
struct list_head s_freeing_list;	/* inodes being freed */
	/* journal.c fields */
	
struct mutex s_journal_mutex;
	
void	*s_je;				/* journal entry to compress */
	
void	*s_compressed_je;		/* block to write to journal */
	
u32	 s_journal_seg[LOGFS_JOURNAL_SEGS]; /* journal segments */
	
u32	 s_journal_ec[LOGFS_JOURNAL_SEGS]; /* journal erasecounts */
	
u64	 s_last_version;
	
struct logfs_area *s_journal_area;	/* open journal segment */
	
__be64	s_je_array[MAX_JOURNAL_ENTRIES];
	
int	s_no_je;

	
int	 s_sum_index;			/* for the 12 summaries */
	
struct shadow_tree s_shadow_tree;
	
int	 s_je_fill;			/* index of current je */
	/* readwrite.c fields */
	
struct mutex s_write_mutex;
	
int	 s_lock_count;
	
mempool_t *s_block_pool;		/* struct logfs_block pool */
	
mempool_t *s_shadow_pool;		/* struct logfs_shadow pool */
	
struct list_head s_writeback_list;	/* writeback pages */
	/*
         * Space accounting:
         * - s_used_bytes specifies space used to store valid data objects.
         * - s_dirty_used_bytes is space used to store non-committed data
         *   objects.  Those objects have already been written themselves,
         *   but they don't become valid until all indirect blocks up to the
         *   journal have been written as well.
         * - s_dirty_free_bytes is space used to store the old copy of a
         *   replaced object, as long as the replacement is non-committed.
         *   In other words, it is the amount of space freed when all dirty
         *   blocks are written back.
         * - s_free_bytes is the amount of free space available for any
         *   purpose.
         * - s_root_reserve is the amount of free space available only to
         *   the root user.  Non-privileged users can no longer write once
         *   this watermark has been reached.
         * - s_speed_reserve is space which remains unused to speed up
         *   garbage collection performance.
         * - s_dirty_pages is the space reserved for currently dirty pages.
         *   It is a pessimistic estimate, so some/most will get freed on
         *   page writeback.
         *
         * s_used_bytes + s_free_bytes + s_speed_reserve = total usable size
         */
	
u64	 s_free_bytes;
	
u64	 s_used_bytes;
	
u64	 s_dirty_free_bytes;
	
u64	 s_dirty_used_bytes;
	
u64	 s_root_reserve;
	
u64	 s_speed_reserve;
	
u64	 s_dirty_pages;
	/* Bad block handling:
         * - s_bad_seg_reserve is a number of segments usually kept
         *   free.  When encountering bad blocks, the affected segment's data
         *   is _temporarily_ moved to a reserved segment.
         * - s_bad_segments is the number of known bad segments.
         */
	
u32	 s_bad_seg_reserve;
	
u32	 s_bad_segments;
};

/**
 * struct logfs_inode - in-memory inode
 *
 * @vfs_inode:                  struct inode
 * @li_data:                    data pointers
 * @li_used_bytes:              number of used bytes
 * @li_freeing_list:            used to track inodes currently being freed
 * @li_flags:                   inode flags
 * @li_refcount:                number of internal (GC-induced) references
 */

struct logfs_inode {
	
struct inode vfs_inode;
	
u64	li_data[LOGFS_EMBEDDED_FIELDS];
	
u64	li_used_bytes;
	
struct list_head li_freeing_list;
	
struct logfs_block *li_block;
	
u32	li_flags;
	
u8	li_height;
	
int	li_refcount;
};


#define journal_for_each(__i) for (__i = 0; __i < LOGFS_JOURNAL_SEGS; __i++)

#define for_each_area(__i) for (__i = 0; __i < LOGFS_NO_AREAS; __i++)

#define for_each_area_down(__i) for (__i = LOGFS_NO_AREAS - 1; __i >= 0; __i--)

/* compr.c */
int logfs_compress(void *in, void *out, size_t inlen, size_t outlen);
int logfs_uncompress(void *in, void *out, size_t inlen, size_t outlen);
int __init logfs_compr_init(void);
void logfs_compr_exit(void);

/* dev_bdev.c */
#ifdef CONFIG_BLOCK
int logfs_get_sb_bdev(struct logfs_super *s,
		struct file_system_type *type,
		const char *devname);
#else

static inline int logfs_get_sb_bdev(struct logfs_super *s, struct file_system_type *type, const char *devname) { return -ENODEV; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel2180.77%150.00%
al viroal viro519.23%150.00%
Total26100.00%2100.00%

#endif /* dev_mtd.c */ #if IS_ENABLED(CONFIG_MTD) int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr); #else
static inline int logfs_get_sb_mtd(struct logfs_super *s, int mtdnr) { return -ENODEV; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel1052.63%133.33%
paul mundtpaul mundt631.58%133.33%
al viroal viro315.79%133.33%
Total19100.00%3100.00%

#endif /* dir.c */ extern const struct inode_operations logfs_dir_iops; extern const struct file_operations logfs_dir_fops; int logfs_replay_journal(struct super_block *sb); /* file.c */ extern const struct inode_operations logfs_reg_iops; extern const struct file_operations logfs_reg_fops; extern const struct address_space_operations logfs_reg_aops; int logfs_readpage(struct file *file, struct page *page); long logfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg); int logfs_fsync(struct file *file, loff_t start, loff_t end, int datasync); /* gc.c */ u32 get_best_cand(struct super_block *sb, struct candidate_list *list, u32 *ec); void logfs_gc_pass(struct super_block *sb); int logfs_check_areas(struct super_block *sb); int logfs_init_gc(struct super_block *sb); void logfs_cleanup_gc(struct super_block *sb); /* inode.c */ extern const struct super_operations logfs_super_operations; struct inode *logfs_iget(struct super_block *sb, ino_t ino); struct inode *logfs_safe_iget(struct super_block *sb, ino_t ino, int *cookie); void logfs_safe_iput(struct inode *inode, int cookie); struct inode *logfs_new_inode(struct inode *dir, umode_t mode); struct inode *logfs_new_meta_inode(struct super_block *sb, u64 ino); struct inode *logfs_read_meta_inode(struct super_block *sb, u64 ino); int logfs_init_inode_cache(void); void logfs_destroy_inode_cache(void); void logfs_set_blocks(struct inode *inode, u64 no); /* these logically belong into inode.c but actually reside in readwrite.c */ int logfs_read_inode(struct inode *inode); int __logfs_write_inode(struct inode *inode, struct page *, long flags); void logfs_evict_inode(struct inode *inode); /* journal.c */ void logfs_write_anchor(struct super_block *sb); int logfs_init_journal(struct super_block *sb); void logfs_cleanup_journal(struct super_block *sb); int write_alias_journal(struct super_block *sb, u64 ino, u64 bix, level_t level, int child_no, __be64 val); void do_logfs_journal_wl_pass(struct super_block *sb); /* readwrite.c */ pgoff_t logfs_pack_index(u64 bix, level_t level); void logfs_unpack_index(pgoff_t index, u64 *bix, level_t *level); int logfs_inode_write(struct inode *inode, const void *buf, size_t count, loff_t bix, long flags, struct shadow_tree *shadow_tree); int logfs_readpage_nolock(struct page *page); int logfs_write_buf(struct inode *inode, struct page *page, long flags); int logfs_delete(struct inode *inode, pgoff_t index, struct shadow_tree *shadow_tree); int logfs_rewrite_block(struct inode *inode, u64 bix, u64 ofs, gc_level_t gc_level, long flags); int logfs_is_valid_block(struct super_block *sb, u64 ofs, u64 ino, u64 bix, gc_level_t gc_level); int logfs_truncate(struct inode *inode, u64 size); u64 logfs_seek_hole(struct inode *inode, u64 bix); u64 logfs_seek_data(struct inode *inode, u64 bix); int logfs_open_segfile(struct super_block *sb); int logfs_init_rw(struct super_block *sb); void logfs_cleanup_rw(struct super_block *sb); void logfs_add_transaction(struct inode *inode, struct logfs_transaction *ta); void logfs_del_transaction(struct inode *inode, struct logfs_transaction *ta); void logfs_write_block(struct logfs_block *block, long flags); int logfs_write_obj_aliases_pagecache(struct super_block *sb); void logfs_get_segment_entry(struct super_block *sb, u32 segno, struct logfs_segment_entry *se); void logfs_set_segment_used(struct super_block *sb, u64 ofs, int increment); void logfs_set_segment_erased(struct super_block *sb, u32 segno, u32 ec, gc_level_t gc_level); void logfs_set_segment_reserved(struct super_block *sb, u32 segno); void logfs_set_segment_unreserved(struct super_block *sb, u32 segno, u32 ec); struct logfs_block *__alloc_block(struct super_block *sb, u64 ino, u64 bix, level_t level); void __free_block(struct super_block *sb, struct logfs_block *block); void btree_write_block(struct logfs_block *block); void initialize_block_counters(struct page *page, struct logfs_block *block, __be64 *array, int page_is_empty); int logfs_exist_block(struct inode *inode, u64 bix); int get_page_reserve(struct inode *inode, struct page *page); void logfs_get_wblocks(struct super_block *sb, struct page *page, int lock); void logfs_put_wblocks(struct super_block *sb, struct page *page, int lock); extern const struct logfs_block_ops indirect_block_ops; /* segment.c */ int logfs_erase_segment(struct super_block *sb, u32 ofs, int ensure_erase); int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf); int logfs_segment_read(struct inode *inode, struct page *page, u64 ofs, u64 bix, level_t level); int logfs_segment_write(struct inode *inode, struct page *page, struct logfs_shadow *shadow); int logfs_segment_delete(struct inode *inode, struct logfs_shadow *shadow); int logfs_load_object_aliases(struct super_block *sb, struct logfs_obj_alias *oa, int count); void move_page_to_btree(struct page *page); int logfs_init_mapping(struct super_block *sb); void logfs_sync_area(struct logfs_area *area); void logfs_sync_segments(struct super_block *sb); void freeseg(struct super_block *sb, u32 segno); void free_areas(struct super_block *sb); /* area handling */ int logfs_init_areas(struct super_block *sb); void logfs_cleanup_areas(struct super_block *sb); int logfs_open_area(struct logfs_area *area, size_t bytes); int __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len, int use_filler);
static inline int logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len) { return __logfs_buf_write(area, ofs, buf, len, 0); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel36100.00%2100.00%
Total36100.00%2100.00%


static inline int logfs_buf_recover(struct logfs_area *area, u64 ofs, void *buf, size_t len) { return __logfs_buf_write(area, ofs, buf, len, 1); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel36100.00%2100.00%
Total36100.00%2100.00%

/* super.c */ struct page *emergency_read_begin(struct address_space *mapping, pgoff_t index); void emergency_read_end(struct page *page); void logfs_crash_dump(struct super_block *sb); int logfs_statfs(struct dentry *dentry, struct kstatfs *stats); int logfs_check_ds(struct logfs_disk_super *ds); int logfs_write_sb(struct super_block *sb);
static inline struct logfs_super *logfs_super(struct super_block *sb) { return sb->s_fs_info; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel19100.00%1100.00%
Total19100.00%1100.00%


static inline struct logfs_inode *logfs_inode(struct inode *inode) { return container_of(inode, struct logfs_inode, vfs_inode); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel25100.00%1100.00%
Total25100.00%1100.00%


static inline void logfs_set_ro(struct super_block *sb) { logfs_super(sb)->s_flags |= LOGFS_SB_FLAG_RO; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel21100.00%1100.00%
Total21100.00%1100.00%

#define LOGFS_BUG(sb) do { \ struct super_block *__sb = sb; \ logfs_crash_dump(__sb); \ logfs_super(__sb)->s_flags |= LOGFS_SB_FLAG_RO; \ BUG(); \ } while (0) #define LOGFS_BUG_ON(condition, sb) \ do { if (unlikely(condition)) LOGFS_BUG((sb)); } while (0)
static inline __be32 logfs_crc32(void *data, size_t len, size_t skip) { return cpu_to_be32(crc32(~0, data+skip, len-skip)); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel35100.00%1100.00%
Total35100.00%1100.00%


static inline u8 logfs_type(struct inode *inode) { return (inode->i_mode >> 12) & 15; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel23100.00%1100.00%
Total23100.00%1100.00%


static inline pgoff_t logfs_index(struct super_block *sb, u64 pos) { return pos >> sb->s_blocksize_bits; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel22100.00%1100.00%
Total22100.00%1100.00%


static inline u64 dev_ofs(struct super_block *sb, u32 segno, u32 ofs) { return ((u64)segno << logfs_super(sb)->s_segshift) + ofs; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel35100.00%1100.00%
Total35100.00%1100.00%


static inline u32 seg_no(struct super_block *sb, u64 ofs) { return ofs >> logfs_super(sb)->s_segshift; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel25100.00%1100.00%
Total25100.00%1100.00%


static inline u32 seg_ofs(struct super_block *sb, u64 ofs) { return ofs & logfs_super(sb)->s_segmask; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel25100.00%1100.00%
Total25100.00%1100.00%


static inline u64 seg_align(struct super_block *sb, u64 ofs) { return ofs & ~logfs_super(sb)->s_segmask; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel26100.00%1100.00%
Total26100.00%1100.00%


static inline struct logfs_block *logfs_block(struct page *page) { return (void *)page->private; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel23100.00%1100.00%
Total23100.00%1100.00%


static inline level_t shrink_level(gc_level_t __level) { u8 level = (__force u8)__level; if (level >= LOGFS_MAX_LEVELS) level -= LOGFS_MAX_LEVELS; return (__force level_t)level; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel36100.00%1100.00%
Total36100.00%1100.00%


static inline gc_level_t expand_level(u64 ino, level_t __level) { u8 level = (__force u8)__level; if (ino == LOGFS_INO_MASTER) { /* ifile has separate areas */ level += LOGFS_MAX_LEVELS; } return (__force gc_level_t)level; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel4197.62%150.00%
anand gadiyaranand gadiyar12.38%150.00%
Total42100.00%2100.00%


static inline int logfs_block_shift(struct super_block *sb, level_t level) { level = shrink_level((__force gc_level_t)level); return (__force int)level * (sb->s_blocksize_bits - 3); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel41100.00%1100.00%
Total41100.00%1100.00%


static inline u64 logfs_block_mask(struct super_block *sb, level_t level) { return ~0ull << logfs_block_shift(sb, level); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel26100.00%1100.00%
Total26100.00%1100.00%


static inline struct logfs_area *get_area(struct super_block *sb, gc_level_t gc_level) { return logfs_super(sb)->s_area[(__force u8)gc_level]; }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel32100.00%1100.00%
Total32100.00%1100.00%


static inline void logfs_mempool_destroy(mempool_t *pool) { if (pool) mempool_destroy(pool); }

Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel20100.00%1100.00%
Total20100.00%1100.00%

#endif

Overall Contributors

PersonTokensPropCommitsCommitProp
joern engeljoern engel304297.19%1045.45%
prasad joshiprasad joshi381.21%29.09%
al viroal viro230.73%418.18%
paul mundtpaul mundt120.38%14.55%
josef bacikjosef bacik60.19%14.55%
michal marekmichal marek50.16%14.55%
julia lawalljulia lawall20.06%14.55%
arnd bergmannarnd bergmann10.03%14.55%
anand gadiyaranand gadiyar10.03%14.55%
Total3130100.00%22100.00%
Directory: fs/logfs
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
{% endraw %}