2012-11-29 05:28:09 +01:00
|
|
|
/*
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
* fs/f2fs/f2fs.h
|
|
|
|
*
|
|
|
|
* Copyright (c) 2012 Samsung Electronics Co., Ltd.
|
|
|
|
* http://www.samsung.com/
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
#ifndef _LINUX_F2FS_H
|
|
|
|
#define _LINUX_F2FS_H
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/page-flags.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/crc32.h>
|
|
|
|
#include <linux/magic.h>
|
2013-08-08 08:56:49 +02:00
|
|
|
#include <linux/kobject.h>
|
2013-10-22 08:52:26 +02:00
|
|
|
#include <linux/sched.h>
|
2015-09-22 22:50:47 +02:00
|
|
|
#include <linux/vmalloc.h>
|
2015-08-14 20:43:56 +02:00
|
|
|
#include <linux/bio.h>
|
2016-01-09 01:57:48 +01:00
|
|
|
#include <linux/blkdev.h>
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
2013-10-29 07:14:54 +01:00
|
|
|
#ifdef CONFIG_F2FS_CHECK_FS
|
2014-09-03 00:52:58 +02:00
|
|
|
#define f2fs_bug_on(sbi, condition) BUG_ON(condition)
|
2013-11-24 05:50:35 +01:00
|
|
|
#define f2fs_down_write(x, y) down_write_nest_lock(x, y)
|
2013-10-29 07:14:54 +01:00
|
|
|
#else
|
2014-09-03 00:52:58 +02:00
|
|
|
#define f2fs_bug_on(sbi, condition) \
|
|
|
|
do { \
|
|
|
|
if (unlikely(condition)) { \
|
|
|
|
WARN_ON(1); \
|
2015-01-28 10:48:42 +01:00
|
|
|
set_sbi_flag(sbi, SBI_NEED_FSCK); \
|
2014-09-03 00:52:58 +02:00
|
|
|
} \
|
|
|
|
} while (0)
|
2013-11-24 05:50:35 +01:00
|
|
|
#define f2fs_down_write(x, y) down_write(x)
|
2013-10-29 07:14:54 +01:00
|
|
|
#endif
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/*
|
|
|
|
* For mount options
|
|
|
|
*/
|
|
|
|
#define F2FS_MOUNT_BG_GC 0x00000001
|
|
|
|
#define F2FS_MOUNT_DISABLE_ROLL_FORWARD 0x00000002
|
|
|
|
#define F2FS_MOUNT_DISCARD 0x00000004
|
|
|
|
#define F2FS_MOUNT_NOHEAP 0x00000008
|
|
|
|
#define F2FS_MOUNT_XATTR_USER 0x00000010
|
|
|
|
#define F2FS_MOUNT_POSIX_ACL 0x00000020
|
|
|
|
#define F2FS_MOUNT_DISABLE_EXT_IDENTIFY 0x00000040
|
2013-08-08 08:16:22 +02:00
|
|
|
#define F2FS_MOUNT_INLINE_XATTR 0x00000080
|
2013-11-10 16:13:16 +01:00
|
|
|
#define F2FS_MOUNT_INLINE_DATA 0x00000100
|
2014-09-24 12:15:19 +02:00
|
|
|
#define F2FS_MOUNT_INLINE_DENTRY 0x00000200
|
|
|
|
#define F2FS_MOUNT_FLUSH_MERGE 0x00000400
|
|
|
|
#define F2FS_MOUNT_NOBARRIER 0x00000800
|
2014-10-31 06:47:03 +01:00
|
|
|
#define F2FS_MOUNT_FASTBOOT 0x00001000
|
2015-02-05 10:55:51 +01:00
|
|
|
#define F2FS_MOUNT_EXTENT_CACHE 0x00002000
|
2015-10-05 20:02:54 +02:00
|
|
|
#define F2FS_MOUNT_FORCE_FG_GC 0x00004000
|
2015-12-16 06:12:16 +01:00
|
|
|
#define F2FS_MOUNT_DATA_FLUSH 0x00008000
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
#define clear_opt(sbi, option) (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
|
|
|
|
#define set_opt(sbi, option) (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
|
|
|
|
#define test_opt(sbi, option) (sbi->mount_opt.opt & F2FS_MOUNT_##option)
|
|
|
|
|
|
|
|
#define ver_after(a, b) (typecheck(unsigned long long, a) && \
|
|
|
|
typecheck(unsigned long long, b) && \
|
|
|
|
((long long)((a) - (b)) > 0))
|
|
|
|
|
2013-05-24 05:41:04 +02:00
|
|
|
typedef u32 block_t; /*
|
|
|
|
* should not change u32, since it is the on-disk block
|
|
|
|
* address format, __le32.
|
|
|
|
*/
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
typedef u32 nid_t;
|
|
|
|
|
|
|
|
struct f2fs_mount_info {
|
|
|
|
unsigned int opt;
|
|
|
|
};
|
|
|
|
|
2015-04-20 22:57:51 +02:00
|
|
|
#define F2FS_FEATURE_ENCRYPT 0x0001
|
|
|
|
|
2015-04-14 00:10:36 +02:00
|
|
|
#define F2FS_HAS_FEATURE(sb, mask) \
|
|
|
|
((F2FS_SB(sb)->raw_super->feature & cpu_to_le32(mask)) != 0)
|
|
|
|
#define F2FS_SET_FEATURE(sb, mask) \
|
|
|
|
F2FS_SB(sb)->raw_super->feature |= cpu_to_le32(mask)
|
|
|
|
#define F2FS_CLEAR_FEATURE(sb, mask) \
|
|
|
|
F2FS_SB(sb)->raw_super->feature &= ~cpu_to_le32(mask)
|
|
|
|
|
2013-06-19 13:47:19 +02:00
|
|
|
#define CRCPOLY_LE 0xedb88320
|
|
|
|
|
|
|
|
static inline __u32 f2fs_crc32(void *buf, size_t len)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
2013-06-19 13:47:19 +02:00
|
|
|
unsigned char *p = (unsigned char *)buf;
|
|
|
|
__u32 crc = F2FS_SUPER_MAGIC;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
while (len--) {
|
|
|
|
crc ^= *p++;
|
|
|
|
for (i = 0; i < 8; i++)
|
|
|
|
crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
|
|
|
|
}
|
|
|
|
return crc;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
2013-06-19 13:47:19 +02:00
|
|
|
static inline bool f2fs_crc_valid(__u32 blk_crc, void *buf, size_t buf_size)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
2013-06-19 13:47:19 +02:00
|
|
|
return f2fs_crc32(buf, buf_size) == blk_crc;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For checkpoint manager
|
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
NAT_BITMAP,
|
|
|
|
SIT_BITMAP
|
|
|
|
};
|
|
|
|
|
2014-09-21 06:57:51 +02:00
|
|
|
enum {
|
|
|
|
CP_UMOUNT,
|
2015-01-29 20:45:33 +01:00
|
|
|
CP_FASTBOOT,
|
2014-09-21 06:57:51 +02:00
|
|
|
CP_SYNC,
|
2015-04-10 02:03:53 +02:00
|
|
|
CP_RECOVERY,
|
2014-09-21 07:06:39 +02:00
|
|
|
CP_DISCARD,
|
2014-09-21 06:57:51 +02:00
|
|
|
};
|
|
|
|
|
2015-01-27 02:41:23 +01:00
|
|
|
#define DEF_BATCHED_TRIM_SECTIONS 32
|
|
|
|
#define BATCHED_TRIM_SEGMENTS(sbi) \
|
|
|
|
(SM_I(sbi)->trim_sections * (sbi)->segs_per_sec)
|
2015-05-01 07:37:50 +02:00
|
|
|
#define BATCHED_TRIM_BLOCKS(sbi) \
|
|
|
|
(BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg)
|
2015-10-05 23:49:57 +02:00
|
|
|
#define DEF_CP_INTERVAL 60 /* 60 secs */
|
2016-01-09 01:57:48 +01:00
|
|
|
#define DEF_IDLE_INTERVAL 120 /* 2 mins */
|
2015-01-27 02:41:23 +01:00
|
|
|
|
2014-09-21 06:57:51 +02:00
|
|
|
struct cp_control {
|
|
|
|
int reason;
|
2014-09-21 07:06:39 +02:00
|
|
|
__u64 trim_start;
|
|
|
|
__u64 trim_end;
|
|
|
|
__u64 trim_minlen;
|
|
|
|
__u64 trimmed;
|
2014-09-21 06:57:51 +02:00
|
|
|
};
|
|
|
|
|
2014-02-07 09:11:53 +01:00
|
|
|
/*
|
2014-02-27 12:12:24 +01:00
|
|
|
* For CP/NAT/SIT/SSA readahead
|
2014-02-07 09:11:53 +01:00
|
|
|
*/
|
|
|
|
enum {
|
|
|
|
META_CP,
|
|
|
|
META_NAT,
|
2014-02-27 12:12:24 +01:00
|
|
|
META_SIT,
|
2014-09-11 22:49:55 +02:00
|
|
|
META_SSA,
|
|
|
|
META_POR,
|
2014-02-07 09:11:53 +01:00
|
|
|
};
|
|
|
|
|
2014-07-26 00:47:17 +02:00
|
|
|
/* for the list of ino */
|
|
|
|
enum {
|
|
|
|
ORPHAN_INO, /* for orphan ino list */
|
2014-07-25 16:40:59 +02:00
|
|
|
APPEND_INO, /* for append ino list */
|
|
|
|
UPDATE_INO, /* for update ino list */
|
2014-07-26 00:47:17 +02:00
|
|
|
MAX_INO_ENTRY, /* max. list */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ino_entry {
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct list_head list; /* list head */
|
|
|
|
nid_t ino; /* inode number */
|
|
|
|
};
|
|
|
|
|
2015-12-15 06:30:45 +01:00
|
|
|
/* for the list of inodes to be GCed */
|
2014-12-29 08:56:18 +01:00
|
|
|
struct inode_entry {
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct list_head list; /* list head */
|
|
|
|
struct inode *inode; /* vfs inode pointer */
|
|
|
|
};
|
|
|
|
|
2013-11-15 05:55:58 +01:00
|
|
|
/* for the list of blockaddresses to be discarded */
|
|
|
|
struct discard_entry {
|
|
|
|
struct list_head list; /* list head */
|
|
|
|
block_t blkaddr; /* block address to be discarded */
|
|
|
|
int len; /* # of consecutive blocks of the discard */
|
|
|
|
};
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/* for the list of fsync inodes, used only during recovery */
|
|
|
|
struct fsync_inode_entry {
|
|
|
|
struct list_head list; /* list head */
|
|
|
|
struct inode *inode; /* vfs inode pointer */
|
2014-09-11 23:29:06 +02:00
|
|
|
block_t blkaddr; /* block address locating the last fsync */
|
|
|
|
block_t last_dentry; /* block address locating the last dentry */
|
|
|
|
block_t last_inode; /* block address locating the last inode */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#define nats_in_cursum(sum) (le16_to_cpu(sum->n_nats))
|
|
|
|
#define sits_in_cursum(sum) (le16_to_cpu(sum->n_sits))
|
|
|
|
|
|
|
|
#define nat_in_journal(sum, i) (sum->nat_j.entries[i].ne)
|
|
|
|
#define nid_in_journal(sum, i) (sum->nat_j.entries[i].nid)
|
|
|
|
#define sit_in_journal(sum, i) (sum->sit_j.entries[i].se)
|
|
|
|
#define segno_in_journal(sum, i) (sum->sit_j.entries[i].segno)
|
|
|
|
|
2014-09-22 20:40:48 +02:00
|
|
|
#define MAX_NAT_JENTRIES(sum) (NAT_JOURNAL_ENTRIES - nats_in_cursum(sum))
|
|
|
|
#define MAX_SIT_JENTRIES(sum) (SIT_JOURNAL_ENTRIES - sits_in_cursum(sum))
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
static inline int update_nats_in_cursum(struct f2fs_summary_block *rs, int i)
|
|
|
|
{
|
|
|
|
int before = nats_in_cursum(rs);
|
|
|
|
rs->n_nats = cpu_to_le16(before + i);
|
|
|
|
return before;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int update_sits_in_cursum(struct f2fs_summary_block *rs, int i)
|
|
|
|
{
|
|
|
|
int before = sits_in_cursum(rs);
|
|
|
|
rs->n_sits = cpu_to_le16(before + i);
|
|
|
|
return before;
|
|
|
|
}
|
|
|
|
|
f2fs: refactor flush_sit_entries codes for reducing SIT writes
In commit aec71382c681 ("f2fs: refactor flush_nat_entries codes for reducing NAT
writes"), we descripte the issue as below:
"Although building NAT journal in cursum reduce the read/write work for NAT
block, but previous design leave us lower performance when write checkpoint
frequently for these cases:
1. if journal in cursum has already full, it's a bit of waste that we flush all
nat entries to page for persistence, but not to cache any entries.
2. if journal in cursum is not full, we fill nat entries to journal util
journal is full, then flush the left dirty entries to disk without merge
journaled entries, so these journaled entries may be flushed to disk at next
checkpoint but lost chance to flushed last time."
Actually, we have the same problem in using SIT journal area.
In this patch, firstly we will update sit journal with dirty entries as many as
possible. Secondly if there is no space in sit journal, we will remove all
entries in journal and walk through the whole dirty entry bitmap of sit,
accounting dirty sit entries located in same SIT block to sit entry set. All
entry sets are linked to list sit_entry_set in sm_info, sorted ascending order
by count of entries in set. Later we flush entries in set which have fewest
entries into journal as many as we can, and then flush dense set with merged
entries to disk.
In this way we can use sit journal area more effectively, also we will reduce
SIT update, result in gaining in performance and saving lifetime of flash
device.
In my testing environment, it shows this patch can help to reduce SIT block
update obviously.
virtual machine + hard disk:
fsstress -p 20 -n 400 -l 5
sit page num cp count sit pages/cp
based 2006.50 1349.75 1.486
patched 1566.25 1463.25 1.070
Our latency of merging op is small when handling a great number of dirty SIT
entries in flush_sit_entries:
latency(ns) dirty sit count
36038 2151
49168 2123
37174 2232
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2014-09-04 12:13:01 +02:00
|
|
|
static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
if (type == NAT_JOURNAL)
|
2014-09-22 20:40:48 +02:00
|
|
|
return size <= MAX_NAT_JENTRIES(sum);
|
|
|
|
return size <= MAX_SIT_JENTRIES(sum);
|
f2fs: refactor flush_sit_entries codes for reducing SIT writes
In commit aec71382c681 ("f2fs: refactor flush_nat_entries codes for reducing NAT
writes"), we descripte the issue as below:
"Although building NAT journal in cursum reduce the read/write work for NAT
block, but previous design leave us lower performance when write checkpoint
frequently for these cases:
1. if journal in cursum has already full, it's a bit of waste that we flush all
nat entries to page for persistence, but not to cache any entries.
2. if journal in cursum is not full, we fill nat entries to journal util
journal is full, then flush the left dirty entries to disk without merge
journaled entries, so these journaled entries may be flushed to disk at next
checkpoint but lost chance to flushed last time."
Actually, we have the same problem in using SIT journal area.
In this patch, firstly we will update sit journal with dirty entries as many as
possible. Secondly if there is no space in sit journal, we will remove all
entries in journal and walk through the whole dirty entry bitmap of sit,
accounting dirty sit entries located in same SIT block to sit entry set. All
entry sets are linked to list sit_entry_set in sm_info, sorted ascending order
by count of entries in set. Later we flush entries in set which have fewest
entries into journal as many as we can, and then flush dense set with merged
entries to disk.
In this way we can use sit journal area more effectively, also we will reduce
SIT update, result in gaining in performance and saving lifetime of flash
device.
In my testing environment, it shows this patch can help to reduce SIT block
update obviously.
virtual machine + hard disk:
fsstress -p 20 -n 400 -l 5
sit page num cp count sit pages/cp
based 2006.50 1349.75 1.486
patched 1566.25 1463.25 1.070
Our latency of merging op is small when handling a great number of dirty SIT
entries in flush_sit_entries:
latency(ns) dirty sit count
36038 2151
49168 2123
37174 2232
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2014-09-04 12:13:01 +02:00
|
|
|
}
|
|
|
|
|
2013-02-04 15:41:41 +01:00
|
|
|
/*
|
|
|
|
* ioctl commands
|
|
|
|
*/
|
2014-10-07 02:39:50 +02:00
|
|
|
#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS
|
|
|
|
#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS
|
2015-01-23 13:36:04 +01:00
|
|
|
#define F2FS_IOC_GETVERSION FS_IOC_GETVERSION
|
2014-10-07 02:39:50 +02:00
|
|
|
|
|
|
|
#define F2FS_IOCTL_MAGIC 0xf5
|
|
|
|
#define F2FS_IOC_START_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 1)
|
|
|
|
#define F2FS_IOC_COMMIT_ATOMIC_WRITE _IO(F2FS_IOCTL_MAGIC, 2)
|
2014-10-07 01:11:16 +02:00
|
|
|
#define F2FS_IOC_START_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 3)
|
2014-12-09 15:08:59 +01:00
|
|
|
#define F2FS_IOC_RELEASE_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 4)
|
|
|
|
#define F2FS_IOC_ABORT_VOLATILE_WRITE _IO(F2FS_IOCTL_MAGIC, 5)
|
2015-07-10 12:08:10 +02:00
|
|
|
#define F2FS_IOC_GARBAGE_COLLECT _IO(F2FS_IOCTL_MAGIC, 6)
|
2015-10-05 16:24:19 +02:00
|
|
|
#define F2FS_IOC_WRITE_CHECKPOINT _IO(F2FS_IOCTL_MAGIC, 7)
|
2015-10-27 02:53:45 +01:00
|
|
|
#define F2FS_IOC_DEFRAGMENT _IO(F2FS_IOCTL_MAGIC, 8)
|
2013-02-04 15:41:41 +01:00
|
|
|
|
2015-04-21 00:19:06 +02:00
|
|
|
#define F2FS_IOC_SET_ENCRYPTION_POLICY \
|
|
|
|
_IOR('f', 19, struct f2fs_encryption_policy)
|
|
|
|
#define F2FS_IOC_GET_ENCRYPTION_PWSALT \
|
|
|
|
_IOW('f', 20, __u8[16])
|
|
|
|
#define F2FS_IOC_GET_ENCRYPTION_POLICY \
|
|
|
|
_IOW('f', 21, struct f2fs_encryption_policy)
|
|
|
|
|
2015-01-09 04:15:53 +01:00
|
|
|
/*
|
|
|
|
* should be same as XFS_IOC_GOINGDOWN.
|
|
|
|
* Flags for going down operation used by FS_IOC_GOINGDOWN
|
|
|
|
*/
|
|
|
|
#define F2FS_IOC_SHUTDOWN _IOR('X', 125, __u32) /* Shutdown */
|
|
|
|
#define F2FS_GOING_DOWN_FULLSYNC 0x0 /* going down with full sync */
|
|
|
|
#define F2FS_GOING_DOWN_METASYNC 0x1 /* going down with metadata */
|
|
|
|
#define F2FS_GOING_DOWN_NOSYNC 0x2 /* going down */
|
2015-10-07 18:46:37 +02:00
|
|
|
#define F2FS_GOING_DOWN_METAFLUSH 0x3 /* going down with meta flush */
|
2015-01-09 04:15:53 +01:00
|
|
|
|
2013-02-04 15:41:41 +01:00
|
|
|
#if defined(__KERNEL__) && defined(CONFIG_COMPAT)
|
|
|
|
/*
|
|
|
|
* ioctl commands in 32 bit emulation
|
|
|
|
*/
|
2015-11-10 11:44:20 +01:00
|
|
|
#define F2FS_IOC32_GETFLAGS FS_IOC32_GETFLAGS
|
|
|
|
#define F2FS_IOC32_SETFLAGS FS_IOC32_SETFLAGS
|
|
|
|
#define F2FS_IOC32_GETVERSION FS_IOC32_GETVERSION
|
2013-02-04 15:41:41 +01:00
|
|
|
#endif
|
|
|
|
|
2015-10-27 02:53:45 +01:00
|
|
|
struct f2fs_defragment {
|
|
|
|
u64 start;
|
|
|
|
u64 len;
|
|
|
|
};
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/*
|
|
|
|
* For INODE and NODE manager
|
|
|
|
*/
|
2014-10-19 07:52:52 +02:00
|
|
|
/* for directory operations */
|
2015-04-26 09:12:50 +02:00
|
|
|
struct f2fs_str {
|
|
|
|
unsigned char *name;
|
|
|
|
u32 len;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct f2fs_filename {
|
|
|
|
const struct qstr *usr_fname;
|
|
|
|
struct f2fs_str disk_name;
|
|
|
|
f2fs_hash_t hash;
|
|
|
|
#ifdef CONFIG_F2FS_FS_ENCRYPTION
|
|
|
|
struct f2fs_str crypto_buf;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
#define FSTR_INIT(n, l) { .name = n, .len = l }
|
|
|
|
#define FSTR_TO_QSTR(f) QSTR_INIT((f)->name, (f)->len)
|
|
|
|
#define fname_name(p) ((p)->disk_name.name)
|
|
|
|
#define fname_len(p) ((p)->disk_name.len)
|
|
|
|
|
2014-10-19 07:52:52 +02:00
|
|
|
struct f2fs_dentry_ptr {
|
2015-04-28 01:26:24 +02:00
|
|
|
struct inode *inode;
|
2014-10-19 07:52:52 +02:00
|
|
|
const void *bitmap;
|
|
|
|
struct f2fs_dir_entry *dentry;
|
|
|
|
__u8 (*filename)[F2FS_SLOT_LEN];
|
|
|
|
int max;
|
|
|
|
};
|
|
|
|
|
2015-04-28 01:26:24 +02:00
|
|
|
static inline void make_dentry_ptr(struct inode *inode,
|
|
|
|
struct f2fs_dentry_ptr *d, void *src, int type)
|
2014-10-19 07:52:52 +02:00
|
|
|
{
|
2015-04-28 01:26:24 +02:00
|
|
|
d->inode = inode;
|
|
|
|
|
2014-10-19 07:52:52 +02:00
|
|
|
if (type == 1) {
|
|
|
|
struct f2fs_dentry_block *t = (struct f2fs_dentry_block *)src;
|
|
|
|
d->max = NR_DENTRY_IN_BLOCK;
|
|
|
|
d->bitmap = &t->dentry_bitmap;
|
|
|
|
d->dentry = t->dentry;
|
|
|
|
d->filename = t->filename;
|
|
|
|
} else {
|
|
|
|
struct f2fs_inline_dentry *t = (struct f2fs_inline_dentry *)src;
|
|
|
|
d->max = NR_INLINE_DENTRY;
|
|
|
|
d->bitmap = &t->dentry_bitmap;
|
|
|
|
d->dentry = t->dentry;
|
|
|
|
d->filename = t->filename;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-09 01:14:06 +02:00
|
|
|
/*
|
|
|
|
* XATTR_NODE_OFFSET stores xattrs to one node block per file keeping -1
|
|
|
|
* as its node offset to distinguish from index node blocks.
|
|
|
|
* But some bits are used to mark the node block.
|
|
|
|
*/
|
|
|
|
#define XATTR_NODE_OFFSET ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
|
|
|
|
>> OFFSET_BIT_SHIFT)
|
2013-02-26 05:10:46 +01:00
|
|
|
enum {
|
|
|
|
ALLOC_NODE, /* allocate a new node page if needed */
|
|
|
|
LOOKUP_NODE, /* look up a node without readahead */
|
|
|
|
LOOKUP_NODE_RA, /*
|
|
|
|
* look up a node with readahead called
|
2013-12-21 11:02:14 +01:00
|
|
|
* by get_data_block.
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
*/
|
2013-02-26 05:10:46 +01:00
|
|
|
};
|
|
|
|
|
2015-08-11 00:01:12 +02:00
|
|
|
#define F2FS_LINK_MAX 0xffffffff /* maximum link count per file */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
2014-04-28 11:59:43 +02:00
|
|
|
#define MAX_DIR_RA_PAGES 4 /* maximum ra pages of dir */
|
|
|
|
|
2015-02-05 10:52:58 +01:00
|
|
|
/* vector size for gang look-up from extent cache that consists of radix tree */
|
|
|
|
#define EXT_TREE_VEC_SIZE 64
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/* for in-memory extent cache entry */
|
2015-02-05 10:52:58 +01:00
|
|
|
#define F2FS_MIN_EXTENT_LEN 64 /* minimum extent length */
|
|
|
|
|
|
|
|
/* number of extent info in extent cache we try to shrink */
|
|
|
|
#define EXTENT_CACHE_SHRINK_NUMBER 128
|
2013-11-19 02:41:54 +01:00
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct extent_info {
|
2015-02-05 10:52:58 +01:00
|
|
|
unsigned int fofs; /* start offset in a file */
|
|
|
|
u32 blk; /* start block address of the extent */
|
|
|
|
unsigned int len; /* length of the extent */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct extent_node {
|
|
|
|
struct rb_node rb_node; /* rb node located in rb-tree */
|
|
|
|
struct list_head list; /* node in global extent list of sbi */
|
|
|
|
struct extent_info ei; /* extent info */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct extent_tree {
|
|
|
|
nid_t ino; /* inode number */
|
|
|
|
struct rb_root root; /* root of extent info rb-tree */
|
2015-02-05 11:01:39 +01:00
|
|
|
struct extent_node *cached_en; /* recently accessed extent node */
|
2015-06-20 02:53:26 +02:00
|
|
|
struct extent_info largest; /* largested extent info */
|
2016-01-01 00:02:16 +01:00
|
|
|
struct list_head list; /* to be used by sbi->zombie_list */
|
2015-02-05 10:52:58 +01:00
|
|
|
rwlock_t lock; /* protect extent info rb-tree */
|
2016-01-08 13:22:52 +01:00
|
|
|
atomic_t node_cnt; /* # of extent node in rb-tree*/
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
};
|
|
|
|
|
2015-04-07 04:55:34 +02:00
|
|
|
/*
|
|
|
|
* This structure is taken from ext4_map_blocks.
|
|
|
|
*
|
|
|
|
* Note that, however, f2fs uses NEW and MAPPED flags for f2fs_map_blocks().
|
|
|
|
*/
|
|
|
|
#define F2FS_MAP_NEW (1 << BH_New)
|
|
|
|
#define F2FS_MAP_MAPPED (1 << BH_Mapped)
|
2015-05-09 04:30:32 +02:00
|
|
|
#define F2FS_MAP_UNWRITTEN (1 << BH_Unwritten)
|
|
|
|
#define F2FS_MAP_FLAGS (F2FS_MAP_NEW | F2FS_MAP_MAPPED |\
|
|
|
|
F2FS_MAP_UNWRITTEN)
|
2015-04-07 04:55:34 +02:00
|
|
|
|
|
|
|
struct f2fs_map_blocks {
|
|
|
|
block_t m_pblk;
|
|
|
|
block_t m_lblk;
|
|
|
|
unsigned int m_len;
|
|
|
|
unsigned int m_flags;
|
|
|
|
};
|
|
|
|
|
2015-08-19 13:11:19 +02:00
|
|
|
/* for flag in get_data_block */
|
|
|
|
#define F2FS_GET_BLOCK_READ 0
|
|
|
|
#define F2FS_GET_BLOCK_DIO 1
|
|
|
|
#define F2FS_GET_BLOCK_FIEMAP 2
|
|
|
|
#define F2FS_GET_BLOCK_BMAP 3
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/*
|
|
|
|
* i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
|
|
|
|
*/
|
|
|
|
#define FADVISE_COLD_BIT 0x01
|
2013-06-14 01:52:35 +02:00
|
|
|
#define FADVISE_LOST_PINO_BIT 0x02
|
2015-04-20 22:57:51 +02:00
|
|
|
#define FADVISE_ENCRYPT_BIT 0x04
|
2015-04-30 02:02:18 +02:00
|
|
|
#define FADVISE_ENC_NAME_BIT 0x08
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
2015-04-20 22:44:41 +02:00
|
|
|
#define file_is_cold(inode) is_file(inode, FADVISE_COLD_BIT)
|
|
|
|
#define file_wrong_pino(inode) is_file(inode, FADVISE_LOST_PINO_BIT)
|
|
|
|
#define file_set_cold(inode) set_file(inode, FADVISE_COLD_BIT)
|
|
|
|
#define file_lost_pino(inode) set_file(inode, FADVISE_LOST_PINO_BIT)
|
|
|
|
#define file_clear_cold(inode) clear_file(inode, FADVISE_COLD_BIT)
|
|
|
|
#define file_got_pino(inode) clear_file(inode, FADVISE_LOST_PINO_BIT)
|
2015-04-20 22:57:51 +02:00
|
|
|
#define file_is_encrypt(inode) is_file(inode, FADVISE_ENCRYPT_BIT)
|
|
|
|
#define file_set_encrypt(inode) set_file(inode, FADVISE_ENCRYPT_BIT)
|
|
|
|
#define file_clear_encrypt(inode) clear_file(inode, FADVISE_ENCRYPT_BIT)
|
2015-04-30 02:02:18 +02:00
|
|
|
#define file_enc_name(inode) is_file(inode, FADVISE_ENC_NAME_BIT)
|
|
|
|
#define file_set_enc_name(inode) set_file(inode, FADVISE_ENC_NAME_BIT)
|
2015-04-20 22:57:51 +02:00
|
|
|
|
|
|
|
/* Encryption algorithms */
|
|
|
|
#define F2FS_ENCRYPTION_MODE_INVALID 0
|
|
|
|
#define F2FS_ENCRYPTION_MODE_AES_256_XTS 1
|
|
|
|
#define F2FS_ENCRYPTION_MODE_AES_256_GCM 2
|
|
|
|
#define F2FS_ENCRYPTION_MODE_AES_256_CBC 3
|
|
|
|
#define F2FS_ENCRYPTION_MODE_AES_256_CTS 4
|
2015-04-20 22:44:41 +02:00
|
|
|
|
2015-04-21 00:19:06 +02:00
|
|
|
#include "f2fs_crypto.h"
|
|
|
|
|
2014-02-27 12:09:05 +01:00
|
|
|
#define DEF_DIR_LEVEL 0
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct f2fs_inode_info {
|
|
|
|
struct inode vfs_inode; /* serve a vfs inode */
|
|
|
|
unsigned long i_flags; /* keep an inode flags for ioctl */
|
|
|
|
unsigned char i_advise; /* use to give file attribute hints */
|
2014-02-27 10:20:00 +01:00
|
|
|
unsigned char i_dir_level; /* use for dentry level for large dir */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
unsigned int i_current_depth; /* use only in directory structure */
|
f2fs: fix tracking parent inode number
Previously, f2fs didn't track the parent inode number correctly which is stored
in each f2fs_inode. In the case of the following scenario, a bug can be occured.
Let's suppose there are one directory, "/b", and two files, "/a" and "/b/a".
- pino of "/a" is ROOT_INO.
- pino of "/b/a" is DIR_B_INO.
Then,
# sync
: The inode pages of "/a" and "/b/a" contain the parent inode numbers as
ROOT_INO and DIR_B_INO respectively.
# mv /a /b/a
: The parent inode number of "/a" should be changed to DIR_B_INO, but f2fs
didn't do that. Ref. f2fs_set_link().
In order to fix this clearly, I added i_pino in f2fs_inode_info, and whenever
it needs to be changed like in f2fs_add_link() and f2fs_set_link(), it is
updated temporarily in f2fs_inode_info.
And later, f2fs_write_inode() stores the latest information to the inode pages.
For power-off-recovery, f2fs_sync_file() triggers simply f2fs_write_inode().
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-12-10 09:52:48 +01:00
|
|
|
unsigned int i_pino; /* parent inode number */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
umode_t i_acl_mode; /* keep file acl mode temporarily */
|
|
|
|
|
|
|
|
/* Use below internally in f2fs*/
|
|
|
|
unsigned long flags; /* use to pass per-file flags */
|
2014-03-20 11:10:08 +01:00
|
|
|
struct rw_semaphore i_sem; /* protect fi info */
|
2014-09-13 00:53:45 +02:00
|
|
|
atomic_t dirty_pages; /* # of dirty pages */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
f2fs_hash_t chash; /* hash value of given file name */
|
|
|
|
unsigned int clevel; /* maximum level of given file name */
|
|
|
|
nid_t i_xattr_nid; /* node id that contains xattrs */
|
2013-08-09 07:46:15 +02:00
|
|
|
unsigned long long xattr_ver; /* cp version of xattr modification */
|
2014-10-07 02:39:50 +02:00
|
|
|
|
2015-12-15 06:30:45 +01:00
|
|
|
struct list_head dirty_list; /* linked in global dirty list */
|
2014-10-07 02:39:50 +02:00
|
|
|
struct list_head inmem_pages; /* inmemory pages managed by f2fs */
|
|
|
|
struct mutex inmem_lock; /* lock for inmemory pages */
|
2015-04-20 22:57:51 +02:00
|
|
|
|
2015-06-20 02:53:26 +02:00
|
|
|
struct extent_tree *extent_tree; /* cached extent_tree entry */
|
|
|
|
|
2015-04-20 22:57:51 +02:00
|
|
|
#ifdef CONFIG_F2FS_FS_ENCRYPTION
|
|
|
|
/* Encryption params */
|
|
|
|
struct f2fs_crypt_info *i_crypt_info;
|
|
|
|
#endif
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline void get_extent_info(struct extent_info *ext,
|
|
|
|
struct f2fs_extent i_ext)
|
|
|
|
{
|
|
|
|
ext->fofs = le32_to_cpu(i_ext.fofs);
|
2015-02-05 10:47:25 +01:00
|
|
|
ext->blk = le32_to_cpu(i_ext.blk);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
ext->len = le32_to_cpu(i_ext.len);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_raw_extent(struct extent_info *ext,
|
|
|
|
struct f2fs_extent *i_ext)
|
|
|
|
{
|
|
|
|
i_ext->fofs = cpu_to_le32(ext->fofs);
|
2015-02-05 10:47:25 +01:00
|
|
|
i_ext->blk = cpu_to_le32(ext->blk);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
i_ext->len = cpu_to_le32(ext->len);
|
|
|
|
}
|
|
|
|
|
2015-02-05 10:54:31 +01:00
|
|
|
static inline void set_extent_info(struct extent_info *ei, unsigned int fofs,
|
|
|
|
u32 blk, unsigned int len)
|
|
|
|
{
|
|
|
|
ei->fofs = fofs;
|
|
|
|
ei->blk = blk;
|
|
|
|
ei->len = len;
|
|
|
|
}
|
|
|
|
|
2015-03-19 12:27:51 +01:00
|
|
|
static inline bool __is_extent_same(struct extent_info *ei1,
|
|
|
|
struct extent_info *ei2)
|
|
|
|
{
|
|
|
|
return (ei1->fofs == ei2->fofs && ei1->blk == ei2->blk &&
|
|
|
|
ei1->len == ei2->len);
|
|
|
|
}
|
|
|
|
|
2015-02-05 10:54:31 +01:00
|
|
|
static inline bool __is_extent_mergeable(struct extent_info *back,
|
|
|
|
struct extent_info *front)
|
|
|
|
{
|
|
|
|
return (back->fofs + back->len == front->fofs &&
|
|
|
|
back->blk + back->len == front->blk);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool __is_back_mergeable(struct extent_info *cur,
|
|
|
|
struct extent_info *back)
|
|
|
|
{
|
|
|
|
return __is_extent_mergeable(back, cur);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool __is_front_mergeable(struct extent_info *cur,
|
|
|
|
struct extent_info *front)
|
|
|
|
{
|
|
|
|
return __is_extent_mergeable(cur, front);
|
|
|
|
}
|
|
|
|
|
2015-09-22 15:07:47 +02:00
|
|
|
static inline void __try_update_largest_extent(struct extent_tree *et,
|
|
|
|
struct extent_node *en)
|
|
|
|
{
|
|
|
|
if (en->ei.len > et->largest.len)
|
|
|
|
et->largest = en->ei;
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct f2fs_nm_info {
|
|
|
|
block_t nat_blkaddr; /* base disk address of NAT */
|
|
|
|
nid_t max_nid; /* maximum possible node ids */
|
2014-04-18 04:14:37 +02:00
|
|
|
nid_t available_nids; /* maximum available node ids */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
nid_t next_scan_nid; /* the next nid to be scanned */
|
2014-03-19 05:31:37 +01:00
|
|
|
unsigned int ram_thresh; /* control the memory footprint */
|
2015-10-12 11:08:48 +02:00
|
|
|
unsigned int ra_nid_pages; /* # of nid pages to be readaheaded */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/* NAT cache management */
|
|
|
|
struct radix_tree_root nat_root;/* root of the nat entry cache */
|
2014-09-22 20:40:48 +02:00
|
|
|
struct radix_tree_root nat_set_root;/* root of the nat set cache */
|
2014-12-04 06:15:10 +01:00
|
|
|
struct rw_semaphore nat_tree_lock; /* protect nat_tree_lock */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct list_head nat_entries; /* cached nat entry list (clean) */
|
2014-09-22 20:40:48 +02:00
|
|
|
unsigned int nat_cnt; /* the # of cached nat entries */
|
f2fs: refactor flush_nat_entries codes for reducing NAT writes
Although building NAT journal in cursum reduce the read/write work for NAT
block, but previous design leave us lower performance when write checkpoint
frequently for these cases:
1. if journal in cursum has already full, it's a bit of waste that we flush all
nat entries to page for persistence, but not to cache any entries.
2. if journal in cursum is not full, we fill nat entries to journal util
journal is full, then flush the left dirty entries to disk without merge
journaled entries, so these journaled entries may be flushed to disk at next
checkpoint but lost chance to flushed last time.
In this patch we merge dirty entries located in same NAT block to nat entry set,
and linked all set to list, sorted ascending order by entries' count of set.
Later we flush entries in sparse set into journal as many as we can, and then
flush merged entries to disk. In this way we can not only gain in performance,
but also save lifetime of flash device.
In my testing environment, it shows this patch can help to reduce NAT block
writes obviously. In hard disk test case: cost time of fsstress is stablely
reduced by about 5%.
1. virtual machine + hard disk:
fsstress -p 20 -n 200 -l 5
node num cp count nodes/cp
based 4599.6 1803.0 2.551
patched 2714.6 1829.6 1.483
2. virtual machine + 32g micro SD card:
fsstress -p 20 -n 200 -l 1 -w -f chown=0 -f creat=4 -f dwrite=0
-f fdatasync=4 -f fsync=4 -f link=0 -f mkdir=4 -f mknod=4 -f rename=5
-f rmdir=5 -f symlink=0 -f truncate=4 -f unlink=5 -f write=0 -S
node num cp count nodes/cp
based 84.5 43.7 1.933
patched 49.2 40.0 1.23
Our latency of merging op shows not bad when handling extreme case like:
merging a great number of dirty nats:
latency(ns) dirty nat count
3089219 24922
5129423 27422
4000250 24523
change log from v1:
o fix wrong logic in add_nat_entry when grab a new nat entry set.
o swith to create slab cache in create_node_manager_caches.
o use GFP_ATOMIC instead of GFP_NOFS to avoid potential long latency.
change log from v2:
o make comment position more appropriate suggested by Jaegeuk Kim.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2014-06-24 03:18:20 +02:00
|
|
|
unsigned int dirty_nat_cnt; /* total num of nat entries in set */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/* free node ids management */
|
2014-02-21 06:29:35 +01:00
|
|
|
struct radix_tree_root free_nid_root;/* root of the free_nid cache */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct list_head free_nid_list; /* a list for free nids */
|
|
|
|
spinlock_t free_nid_list_lock; /* protect free nid list */
|
|
|
|
unsigned int fcnt; /* the number of free node id */
|
|
|
|
struct mutex build_lock; /* lock for build free nids */
|
|
|
|
|
|
|
|
/* for checkpoint */
|
|
|
|
char *nat_bitmap; /* NAT bitmap pointer */
|
|
|
|
int bitmap_size; /* bitmap size */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* this structure is used as one of function parameters.
|
|
|
|
* all the information are dedicated to a given direct node block determined
|
|
|
|
* by the data offset in a file.
|
|
|
|
*/
|
|
|
|
struct dnode_of_data {
|
|
|
|
struct inode *inode; /* vfs inode pointer */
|
|
|
|
struct page *inode_page; /* its inode page, NULL is possible */
|
|
|
|
struct page *node_page; /* cached direct node page */
|
|
|
|
nid_t nid; /* node id of the direct node block */
|
|
|
|
unsigned int ofs_in_node; /* data offset in the node page */
|
|
|
|
bool inode_page_locked; /* inode page is locked or not */
|
2015-12-22 21:59:54 +01:00
|
|
|
bool node_changed; /* is node block changed */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
block_t data_blkaddr; /* block address of the node block */
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
|
|
|
|
struct page *ipage, struct page *npage, nid_t nid)
|
|
|
|
{
|
2013-01-03 00:57:21 +01:00
|
|
|
memset(dn, 0, sizeof(*dn));
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
dn->inode = inode;
|
|
|
|
dn->inode_page = ipage;
|
|
|
|
dn->node_page = npage;
|
|
|
|
dn->nid = nid;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For SIT manager
|
|
|
|
*
|
|
|
|
* By default, there are 6 active log areas across the whole main area.
|
|
|
|
* When considering hot and cold data separation to reduce cleaning overhead,
|
|
|
|
* we split 3 for data logs and 3 for node logs as hot, warm, and cold types,
|
|
|
|
* respectively.
|
|
|
|
* In the current design, you should not change the numbers intentionally.
|
|
|
|
* Instead, as a mount option such as active_logs=x, you can use 2, 4, and 6
|
|
|
|
* logs individually according to the underlying devices. (default: 6)
|
|
|
|
* Just in case, on-disk layout covers maximum 16 logs that consist of 8 for
|
|
|
|
* data and 8 for node logs.
|
|
|
|
*/
|
|
|
|
#define NR_CURSEG_DATA_TYPE (3)
|
|
|
|
#define NR_CURSEG_NODE_TYPE (3)
|
|
|
|
#define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
|
|
|
|
|
|
|
|
enum {
|
|
|
|
CURSEG_HOT_DATA = 0, /* directory entry blocks */
|
|
|
|
CURSEG_WARM_DATA, /* data blocks */
|
|
|
|
CURSEG_COLD_DATA, /* multimedia or GCed data blocks */
|
|
|
|
CURSEG_HOT_NODE, /* direct node blocks of directory files */
|
|
|
|
CURSEG_WARM_NODE, /* direct node blocks of normal files */
|
|
|
|
CURSEG_COLD_NODE, /* indirect node blocks */
|
2015-01-06 01:02:20 +01:00
|
|
|
NO_CHECK_TYPE,
|
|
|
|
CURSEG_DIRECT_IO, /* to use for the direct IO path */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
};
|
|
|
|
|
2014-04-02 08:34:36 +02:00
|
|
|
struct flush_cmd {
|
|
|
|
struct completion wait;
|
2014-09-05 12:31:00 +02:00
|
|
|
struct llist_node llnode;
|
2014-04-02 08:34:36 +02:00
|
|
|
int ret;
|
|
|
|
};
|
|
|
|
|
2014-04-27 08:21:21 +02:00
|
|
|
struct flush_cmd_control {
|
|
|
|
struct task_struct *f2fs_issue_flush; /* flush thread */
|
|
|
|
wait_queue_head_t flush_wait_queue; /* waiting queue for wake-up */
|
2014-09-05 12:31:00 +02:00
|
|
|
struct llist_head issue_list; /* list for command issue */
|
|
|
|
struct llist_node *dispatch_list; /* list for command dispatch */
|
2014-04-27 08:21:21 +02:00
|
|
|
};
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct f2fs_sm_info {
|
|
|
|
struct sit_info *sit_info; /* whole segment information */
|
|
|
|
struct free_segmap_info *free_info; /* free segment information */
|
|
|
|
struct dirty_seglist_info *dirty_info; /* dirty segment information */
|
|
|
|
struct curseg_info *curseg_array; /* active segment information */
|
|
|
|
|
|
|
|
block_t seg0_blkaddr; /* block address of 0'th segment */
|
|
|
|
block_t main_blkaddr; /* start block address of main area */
|
|
|
|
block_t ssa_blkaddr; /* start block address of SSA area */
|
|
|
|
|
|
|
|
unsigned int segment_count; /* total # of segments */
|
|
|
|
unsigned int main_segments; /* # of segments in main area */
|
|
|
|
unsigned int reserved_segments; /* # of reserved segments */
|
|
|
|
unsigned int ovp_segments; /* # of overprovision segments */
|
2013-10-24 06:31:34 +02:00
|
|
|
|
|
|
|
/* a threshold to reclaim prefree segments */
|
|
|
|
unsigned int rec_prefree_segments;
|
2013-11-15 05:55:58 +01:00
|
|
|
|
|
|
|
/* for small discard management */
|
|
|
|
struct list_head discard_list; /* 4KB discard list */
|
|
|
|
int nr_discards; /* # of discards in the list */
|
|
|
|
int max_discards; /* max. discards to be issued */
|
2013-11-07 05:13:42 +01:00
|
|
|
|
2015-01-27 02:41:23 +01:00
|
|
|
/* for batched trimming */
|
|
|
|
unsigned int trim_sections; /* # of sections to trim */
|
|
|
|
|
f2fs: refactor flush_sit_entries codes for reducing SIT writes
In commit aec71382c681 ("f2fs: refactor flush_nat_entries codes for reducing NAT
writes"), we descripte the issue as below:
"Although building NAT journal in cursum reduce the read/write work for NAT
block, but previous design leave us lower performance when write checkpoint
frequently for these cases:
1. if journal in cursum has already full, it's a bit of waste that we flush all
nat entries to page for persistence, but not to cache any entries.
2. if journal in cursum is not full, we fill nat entries to journal util
journal is full, then flush the left dirty entries to disk without merge
journaled entries, so these journaled entries may be flushed to disk at next
checkpoint but lost chance to flushed last time."
Actually, we have the same problem in using SIT journal area.
In this patch, firstly we will update sit journal with dirty entries as many as
possible. Secondly if there is no space in sit journal, we will remove all
entries in journal and walk through the whole dirty entry bitmap of sit,
accounting dirty sit entries located in same SIT block to sit entry set. All
entry sets are linked to list sit_entry_set in sm_info, sorted ascending order
by count of entries in set. Later we flush entries in set which have fewest
entries into journal as many as we can, and then flush dense set with merged
entries to disk.
In this way we can use sit journal area more effectively, also we will reduce
SIT update, result in gaining in performance and saving lifetime of flash
device.
In my testing environment, it shows this patch can help to reduce SIT block
update obviously.
virtual machine + hard disk:
fsstress -p 20 -n 400 -l 5
sit page num cp count sit pages/cp
based 2006.50 1349.75 1.486
patched 1566.25 1463.25 1.070
Our latency of merging op is small when handling a great number of dirty SIT
entries in flush_sit_entries:
latency(ns) dirty sit count
36038 2151
49168 2123
37174 2232
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2014-09-04 12:13:01 +02:00
|
|
|
struct list_head sit_entry_set; /* sit entry set list */
|
|
|
|
|
2013-11-07 05:13:42 +01:00
|
|
|
unsigned int ipu_policy; /* in-place-update policy */
|
|
|
|
unsigned int min_ipu_util; /* in-place-update threshold */
|
2014-09-11 01:53:02 +02:00
|
|
|
unsigned int min_fsync_blocks; /* threshold for fsync */
|
2014-04-02 08:34:36 +02:00
|
|
|
|
|
|
|
/* for flush command control */
|
2014-04-27 08:21:21 +02:00
|
|
|
struct flush_cmd_control *cmd_control_info;
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For superblock
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* COUNT_TYPE for monitoring
|
|
|
|
*
|
|
|
|
* f2fs monitors the number of several block types such as on-writeback,
|
|
|
|
* dirty dentry blocks, dirty node blocks, and dirty meta blocks.
|
|
|
|
*/
|
|
|
|
enum count_type {
|
|
|
|
F2FS_WRITEBACK,
|
|
|
|
F2FS_DIRTY_DENTS,
|
2015-12-16 06:09:20 +01:00
|
|
|
F2FS_DIRTY_DATA,
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
F2FS_DIRTY_NODES,
|
|
|
|
F2FS_DIRTY_META,
|
2014-12-06 02:18:15 +01:00
|
|
|
F2FS_INMEM_PAGES,
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
NR_COUNT_TYPE,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2014-08-06 16:22:50 +02:00
|
|
|
* The below are the page types of bios used in submit_bio().
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
* The available types are:
|
|
|
|
* DATA User data pages. It operates as async mode.
|
|
|
|
* NODE Node pages. It operates as async mode.
|
|
|
|
* META FS metadata pages such as SIT, NAT, CP.
|
|
|
|
* NR_PAGE_TYPE The number of page types.
|
|
|
|
* META_FLUSH Make sure the previous pages are written
|
|
|
|
* with waiting the bio's completion
|
|
|
|
* ... Only can be used with META.
|
|
|
|
*/
|
2013-11-18 09:13:35 +01:00
|
|
|
#define PAGE_TYPE_OF_BIO(type) ((type) > META ? META : (type))
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
enum page_type {
|
|
|
|
DATA,
|
|
|
|
NODE,
|
|
|
|
META,
|
|
|
|
NR_PAGE_TYPE,
|
|
|
|
META_FLUSH,
|
2015-03-18 01:58:08 +01:00
|
|
|
INMEM, /* the below types are used by tracepoints only. */
|
|
|
|
INMEM_DROP,
|
|
|
|
IPU,
|
|
|
|
OPU,
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
};
|
|
|
|
|
2013-12-11 05:54:01 +01:00
|
|
|
struct f2fs_io_info {
|
2015-04-23 23:38:15 +02:00
|
|
|
struct f2fs_sb_info *sbi; /* f2fs_sb_info pointer */
|
2013-12-20 11:17:49 +01:00
|
|
|
enum page_type type; /* contains DATA/NODE/META/META_FLUSH */
|
|
|
|
int rw; /* contains R/RS/W/WS with REQ_META/REQ_PRIO */
|
2014-12-18 04:33:13 +01:00
|
|
|
block_t blk_addr; /* block address to be written */
|
2015-04-23 23:38:15 +02:00
|
|
|
struct page *page; /* page to be written */
|
2015-04-23 21:04:33 +02:00
|
|
|
struct page *encrypted_page; /* encrypted page */
|
2013-12-11 05:54:01 +01:00
|
|
|
};
|
|
|
|
|
2013-11-30 04:51:14 +01:00
|
|
|
#define is_read_io(rw) (((rw) & 1) == READ)
|
2013-11-19 04:47:22 +01:00
|
|
|
struct f2fs_bio_info {
|
2013-12-11 05:54:01 +01:00
|
|
|
struct f2fs_sb_info *sbi; /* f2fs superblock */
|
2013-11-19 04:47:22 +01:00
|
|
|
struct bio *bio; /* bios to merge */
|
|
|
|
sector_t last_block_in_bio; /* last block number */
|
2013-12-11 05:54:01 +01:00
|
|
|
struct f2fs_io_info fio; /* store buffered io info. */
|
2014-03-22 07:57:23 +01:00
|
|
|
struct rw_semaphore io_rwsem; /* blocking op for bio */
|
2013-11-19 04:47:22 +01:00
|
|
|
};
|
|
|
|
|
2015-12-16 06:09:20 +01:00
|
|
|
enum inode_type {
|
|
|
|
DIR_INODE, /* for dirty dir inode */
|
|
|
|
FILE_INODE, /* for dirty regular/symlink inode */
|
|
|
|
NR_INODE_TYPE,
|
|
|
|
};
|
|
|
|
|
2014-11-18 04:18:36 +01:00
|
|
|
/* for inner inode cache management */
|
|
|
|
struct inode_management {
|
|
|
|
struct radix_tree_root ino_root; /* ino entry array */
|
|
|
|
spinlock_t ino_lock; /* for ino entry lock */
|
|
|
|
struct list_head ino_list; /* inode list head */
|
|
|
|
unsigned long ino_num; /* number of entries */
|
|
|
|
};
|
|
|
|
|
2015-01-28 10:48:42 +01:00
|
|
|
/* For s_flag in struct f2fs_sb_info */
|
|
|
|
enum {
|
|
|
|
SBI_IS_DIRTY, /* dirty flag for checkpoint */
|
|
|
|
SBI_IS_CLOSE, /* specify unmounting */
|
|
|
|
SBI_NEED_FSCK, /* need fsck.f2fs to fix */
|
|
|
|
SBI_POR_DOING, /* recovery is doing or not */
|
|
|
|
};
|
|
|
|
|
2016-01-09 00:51:50 +01:00
|
|
|
enum {
|
|
|
|
CP_TIME,
|
2016-01-09 01:57:48 +01:00
|
|
|
REQ_TIME,
|
2016-01-09 00:51:50 +01:00
|
|
|
MAX_TIME,
|
|
|
|
};
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct f2fs_sb_info {
|
|
|
|
struct super_block *sb; /* pointer to VFS super block */
|
2013-06-28 05:47:01 +02:00
|
|
|
struct proc_dir_entry *s_proc; /* proc entry */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct f2fs_super_block *raw_super; /* raw super block pointer */
|
2015-12-15 10:19:26 +01:00
|
|
|
int valid_super_block; /* valid super block no */
|
2015-01-28 10:48:42 +01:00
|
|
|
int s_flag; /* flags for sbi */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/* for node-related operations */
|
|
|
|
struct f2fs_nm_info *nm_info; /* node manager */
|
|
|
|
struct inode *node_inode; /* cache node blocks */
|
|
|
|
|
|
|
|
/* for segment-related operations */
|
|
|
|
struct f2fs_sm_info *sm_info; /* segment manager */
|
2013-11-19 04:47:22 +01:00
|
|
|
|
|
|
|
/* for bio operations */
|
2013-11-20 07:46:39 +01:00
|
|
|
struct f2fs_bio_info read_io; /* for read bios */
|
2013-11-19 04:47:22 +01:00
|
|
|
struct f2fs_bio_info write_io[NR_PAGE_TYPE]; /* for write bios */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/* for checkpoint */
|
|
|
|
struct f2fs_checkpoint *ckpt; /* raw checkpoint pointer */
|
|
|
|
struct inode *meta_inode; /* cache meta blocks */
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
struct mutex cp_mutex; /* checkpoint procedure lock */
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 12:08:30 +02:00
|
|
|
struct rw_semaphore cp_rwsem; /* blocking FS operations */
|
2014-07-03 12:58:39 +02:00
|
|
|
struct rw_semaphore node_write; /* locking node writes */
|
2015-04-21 19:40:54 +02:00
|
|
|
struct mutex writepages; /* mutex for writepages() */
|
2013-11-07 04:48:25 +01:00
|
|
|
wait_queue_head_t cp_wait;
|
2016-01-09 00:51:50 +01:00
|
|
|
unsigned long last_time[MAX_TIME]; /* to store time in jiffies */
|
|
|
|
long interval_time[MAX_TIME]; /* to store thresholds */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
2014-11-18 04:18:36 +01:00
|
|
|
struct inode_management im[MAX_INO_ENTRY]; /* manage inode cache */
|
2014-07-26 00:47:17 +02:00
|
|
|
|
|
|
|
/* for orphan inode, use 0'th array */
|
2013-12-26 11:24:19 +01:00
|
|
|
unsigned int max_orphans; /* max orphan inodes */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
2015-12-16 06:09:20 +01:00
|
|
|
/* for inode management */
|
|
|
|
struct list_head inode_list[NR_INODE_TYPE]; /* dirty inode list */
|
|
|
|
spinlock_t inode_lock[NR_INODE_TYPE]; /* for dirty inode list lock */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
2015-02-05 10:52:58 +01:00
|
|
|
/* for extent tree cache */
|
|
|
|
struct radix_tree_root extent_tree_root;/* cache extent cache entries */
|
|
|
|
struct rw_semaphore extent_tree_lock; /* locking extent radix tree */
|
|
|
|
struct list_head extent_list; /* lru list for shrinker */
|
|
|
|
spinlock_t extent_lock; /* locking extent lru list */
|
2015-12-22 04:20:15 +01:00
|
|
|
atomic_t total_ext_tree; /* extent tree count */
|
2016-01-01 00:02:16 +01:00
|
|
|
struct list_head zombie_list; /* extent zombie tree list */
|
2015-12-22 04:25:50 +01:00
|
|
|
atomic_t total_zombie_tree; /* extent zombie tree count */
|
2015-02-05 10:52:58 +01:00
|
|
|
atomic_t total_ext_node; /* extent info count */
|
|
|
|
|
2014-08-06 16:22:50 +02:00
|
|
|
/* basic filesystem units */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
unsigned int log_sectors_per_block; /* log2 sectors per block */
|
|
|
|
unsigned int log_blocksize; /* log2 block size */
|
|
|
|
unsigned int blocksize; /* block size */
|
|
|
|
unsigned int root_ino_num; /* root inode number*/
|
|
|
|
unsigned int node_ino_num; /* node inode number*/
|
|
|
|
unsigned int meta_ino_num; /* meta inode number*/
|
|
|
|
unsigned int log_blocks_per_seg; /* log2 blocks per segment */
|
|
|
|
unsigned int blocks_per_seg; /* blocks per segment */
|
|
|
|
unsigned int segs_per_sec; /* segments per section */
|
|
|
|
unsigned int secs_per_zone; /* sections per zone */
|
|
|
|
unsigned int total_sections; /* total section count */
|
|
|
|
unsigned int total_node_count; /* total node block count */
|
|
|
|
unsigned int total_valid_node_count; /* valid node block count */
|
|
|
|
unsigned int total_valid_inode_count; /* valid inode count */
|
2015-12-31 07:35:37 +01:00
|
|
|
loff_t max_file_blocks; /* max block index of file */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int active_logs; /* # of active logs */
|
2014-02-27 12:09:05 +01:00
|
|
|
int dir_level; /* directory level */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
block_t user_block_count; /* # of user blocks */
|
|
|
|
block_t total_valid_block_count; /* # of valid blocks */
|
|
|
|
block_t alloc_valid_block_count; /* # of allocated blocks */
|
2015-05-01 07:37:50 +02:00
|
|
|
block_t discard_blks; /* discard command candidats */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
block_t last_valid_block_count; /* for recovery */
|
|
|
|
u32 s_next_generation; /* for NFS support */
|
|
|
|
atomic_t nr_pages[NR_COUNT_TYPE]; /* # of pages, see count_type */
|
|
|
|
|
|
|
|
struct f2fs_mount_info mount_opt; /* mount options */
|
|
|
|
|
|
|
|
/* for cleaning operations */
|
|
|
|
struct mutex gc_mutex; /* mutex for GC */
|
|
|
|
struct f2fs_gc_kthread *gc_thread; /* GC thread */
|
2013-03-31 06:26:03 +02:00
|
|
|
unsigned int cur_victim_sec; /* current victim section num */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
2014-01-08 05:45:08 +01:00
|
|
|
/* maximum # of trials to find a victim segment for SSR and GC */
|
|
|
|
unsigned int max_victim_search;
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/*
|
|
|
|
* for stat information.
|
|
|
|
* one is for the LFS mode, and the other is for the SSR mode.
|
|
|
|
*/
|
2013-05-23 15:57:53 +02:00
|
|
|
#ifdef CONFIG_F2FS_STAT_FS
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct f2fs_stat_info *stat_info; /* FS status information */
|
|
|
|
unsigned int segment_count[2]; /* # of allocated segments */
|
|
|
|
unsigned int block_count[2]; /* # of allocated blocks */
|
2014-12-23 18:16:54 +01:00
|
|
|
atomic_t inplace_count; /* # of inplace update */
|
2015-09-30 11:38:48 +02:00
|
|
|
atomic64_t total_hit_ext; /* # of lookup extent cache */
|
|
|
|
atomic64_t read_hit_rbtree; /* # of hit rbtree extent node */
|
|
|
|
atomic64_t read_hit_largest; /* # of hit largest extent node */
|
|
|
|
atomic64_t read_hit_cached; /* # of hit cached extent node */
|
2015-07-15 11:28:53 +02:00
|
|
|
atomic_t inline_xattr; /* # of inline_xattr inodes */
|
2014-12-08 12:08:20 +01:00
|
|
|
atomic_t inline_inode; /* # of inline_data inodes */
|
|
|
|
atomic_t inline_dir; /* # of inline_dentry inodes */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int bg_gc; /* background gc calls */
|
2015-12-17 10:14:44 +01:00
|
|
|
unsigned int ndirty_inode[NR_INODE_TYPE]; /* # of dirty inodes */
|
2013-05-23 15:57:53 +02:00
|
|
|
#endif
|
|
|
|
unsigned int last_victim[2]; /* last victim segment # */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
spinlock_t stat_lock; /* lock for stat operations */
|
2013-08-04 16:09:40 +02:00
|
|
|
|
|
|
|
/* For sysfs suppport */
|
|
|
|
struct kobject s_kobj;
|
|
|
|
struct completion s_kobj_unregister;
|
2015-06-19 21:01:21 +02:00
|
|
|
|
|
|
|
/* For shrinker support */
|
|
|
|
struct list_head s_list;
|
|
|
|
struct mutex umount_mutex;
|
|
|
|
unsigned int shrinker_run_no;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
};
|
|
|
|
|
2016-01-09 00:51:50 +01:00
|
|
|
static inline void f2fs_update_time(struct f2fs_sb_info *sbi, int type)
|
|
|
|
{
|
|
|
|
sbi->last_time[type] = jiffies;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool f2fs_time_over(struct f2fs_sb_info *sbi, int type)
|
|
|
|
{
|
|
|
|
struct timespec ts = {sbi->interval_time[type], 0};
|
|
|
|
unsigned long interval = timespec_to_jiffies(&ts);
|
|
|
|
|
|
|
|
return time_after(jiffies, sbi->last_time[type] + interval);
|
|
|
|
}
|
|
|
|
|
2016-01-09 01:57:48 +01:00
|
|
|
static inline bool is_idle(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
struct block_device *bdev = sbi->sb->s_bdev;
|
|
|
|
struct request_queue *q = bdev_get_queue(bdev);
|
|
|
|
struct request_list *rl = &q->root_rl;
|
|
|
|
|
|
|
|
if (rl->count[BLK_RW_SYNC] || rl->count[BLK_RW_ASYNC])
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return f2fs_time_over(sbi, REQ_TIME);
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/*
|
|
|
|
* Inline functions
|
|
|
|
*/
|
|
|
|
static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
|
|
|
|
{
|
|
|
|
return container_of(inode, struct f2fs_inode_info, vfs_inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb)
|
|
|
|
{
|
|
|
|
return sb->s_fs_info;
|
|
|
|
}
|
|
|
|
|
2014-09-03 00:31:18 +02:00
|
|
|
static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode)
|
|
|
|
{
|
|
|
|
return F2FS_SB(inode->i_sb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct f2fs_sb_info *F2FS_M_SB(struct address_space *mapping)
|
|
|
|
{
|
|
|
|
return F2FS_I_SB(mapping->host);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page)
|
|
|
|
{
|
|
|
|
return F2FS_M_SB(page->mapping);
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return (struct f2fs_super_block *)(sbi->raw_super);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return (struct f2fs_checkpoint *)(sbi->ckpt);
|
|
|
|
}
|
|
|
|
|
2013-07-15 11:57:38 +02:00
|
|
|
static inline struct f2fs_node *F2FS_NODE(struct page *page)
|
|
|
|
{
|
|
|
|
return (struct f2fs_node *)page_address(page);
|
|
|
|
}
|
|
|
|
|
2013-12-26 08:30:41 +01:00
|
|
|
static inline struct f2fs_inode *F2FS_INODE(struct page *page)
|
|
|
|
{
|
|
|
|
return &((struct f2fs_node *)page_address(page))->i;
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return (struct f2fs_nm_info *)(sbi->nm_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return (struct f2fs_sm_info *)(sbi->sm_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return (struct sit_info *)(SM_I(sbi)->sit_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return (struct free_segmap_info *)(SM_I(sbi)->free_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);
|
|
|
|
}
|
|
|
|
|
2014-01-20 11:37:04 +01:00
|
|
|
static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return sbi->meta_inode->i_mapping;
|
|
|
|
}
|
|
|
|
|
2014-01-21 10:51:16 +01:00
|
|
|
static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return sbi->node_inode->i_mapping;
|
|
|
|
}
|
|
|
|
|
2015-01-28 10:48:42 +01:00
|
|
|
static inline bool is_sbi_flag_set(struct f2fs_sb_info *sbi, unsigned int type)
|
|
|
|
{
|
|
|
|
return sbi->s_flag & (0x01 << type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
2015-01-28 10:48:42 +01:00
|
|
|
sbi->s_flag |= (0x01 << type);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
2015-01-28 10:48:42 +01:00
|
|
|
static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
2015-01-28 10:48:42 +01:00
|
|
|
sbi->s_flag &= ~(0x01 << type);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
2013-08-09 08:03:21 +02:00
|
|
|
static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
|
|
|
|
{
|
|
|
|
return le64_to_cpu(cp->checkpoint_ver);
|
|
|
|
}
|
|
|
|
|
2012-11-28 08:12:41 +01:00
|
|
|
static inline bool is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
|
|
|
|
{
|
|
|
|
unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
|
|
|
|
return ckpt_flags & f;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
|
|
|
|
{
|
|
|
|
unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
|
|
|
|
ckpt_flags |= f;
|
|
|
|
cp->ckpt_flags = cpu_to_le32(ckpt_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
|
|
|
|
{
|
|
|
|
unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
|
|
|
|
ckpt_flags &= (~f);
|
|
|
|
cp->ckpt_flags = cpu_to_le32(ckpt_flags);
|
|
|
|
}
|
|
|
|
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 12:08:30 +02:00
|
|
|
static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
{
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 12:08:30 +02:00
|
|
|
down_read(&sbi->cp_rwsem);
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
}
|
|
|
|
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 12:08:30 +02:00
|
|
|
static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 12:08:30 +02:00
|
|
|
up_read(&sbi->cp_rwsem);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 12:08:30 +02:00
|
|
|
static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
2013-11-24 05:50:35 +01:00
|
|
|
f2fs_down_write(&sbi->cp_rwsem, &sbi->cp_mutex);
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
}
|
|
|
|
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 12:08:30 +02:00
|
|
|
static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
|
f2fs: introduce a new global lock scheme
In the previous version, f2fs uses global locks according to the usage types,
such as directory operations, block allocation, block write, and so on.
Reference the following lock types in f2fs.h.
enum lock_type {
RENAME, /* for renaming operations */
DENTRY_OPS, /* for directory operations */
DATA_WRITE, /* for data write */
DATA_NEW, /* for data allocation */
DATA_TRUNC, /* for data truncate */
NODE_NEW, /* for node allocation */
NODE_TRUNC, /* for node truncate */
NODE_WRITE, /* for node write */
NR_LOCK_TYPE,
};
In that case, we lose the performance under the multi-threading environment,
since every types of operations must be conducted one at a time.
In order to address the problem, let's share the locks globally with a mutex
array regardless of any types.
So, let users grab a mutex and perform their jobs in parallel as much as
possbile.
For this, I propose a new global lock scheme as follows.
0. Data structure
- f2fs_sb_info -> mutex_lock[NR_GLOBAL_LOCKS]
- f2fs_sb_info -> node_write
1. mutex_lock_op(sbi)
- try to get an avaiable lock from the array.
- returns the index of the gottern lock variable.
2. mutex_unlock_op(sbi, index of the lock)
- unlock the given index of the lock.
3. mutex_lock_all(sbi)
- grab all the locks in the array before the checkpoint.
4. mutex_unlock_all(sbi)
- release all the locks in the array after checkpoint.
5. block_operations()
- call mutex_lock_all()
- sync_dirty_dir_inodes()
- grab node_write
- sync_node_pages()
Note that,
the pairs of mutex_lock_op()/mutex_unlock_op() and
mutex_lock_all()/mutex_unlock_all() should be used together.
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-22 08:21:29 +01:00
|
|
|
{
|
f2fs: use rw_sem instead of fs_lock(locks mutex)
The fs_locks is used to block other ops(ex, recovery) when doing checkpoint.
And each other operate routine(besides checkpoint) needs to acquire a fs_lock,
there is a terrible problem here, if these are too many concurrency threads acquiring
fs_lock, so that they will block each other and may lead to some performance problem,
but this is not the phenomenon we want to see.
Though there are some optimization patches introduced to enhance the usage of fs_lock,
but the thorough solution is using a *rw_sem* to replace the fs_lock.
Checkpoint routine takes write_sem, and other ops take read_sem, so that we can block
other ops(ex, recovery) when doing checkpoint, and other ops will not disturb each other,
this can avoid the problem described above completely.
Because of the weakness of rw_sem, the above change may introduce a potential problem
that the checkpoint thread might get starved if other threads are intensively locking
the read semaphore for I/O.(Pointed out by Xu Jin)
In order to avoid this, a wait_list is introduced, the appending read semaphore ops
will be dropped into the wait_list if checkpoint thread is waiting for write semaphore,
and will be waked up when checkpoint thread gives up write semaphore.
Thanks to Kim's previous review and test, and will be very glad to see other guys'
performance tests about this patch.
V2:
-fix the potential starvation problem.
-use more suitable func name suggested by Xu Jin.
Signed-off-by: Gu Zheng <guz.fnst@cn.fujitsu.com>
[Jaegeuk Kim: adjust minor coding standard]
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2013-09-27 12:08:30 +02:00
|
|
|
up_write(&sbi->cp_rwsem);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
2015-01-29 20:45:33 +01:00
|
|
|
static inline int __get_cp_reason(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
int reason = CP_SYNC;
|
|
|
|
|
|
|
|
if (test_opt(sbi, FASTBOOT))
|
|
|
|
reason = CP_FASTBOOT;
|
|
|
|
if (is_sbi_flag_set(sbi, SBI_IS_CLOSE))
|
|
|
|
reason = CP_UMOUNT;
|
|
|
|
return reason;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool __remain_node_summaries(int reason)
|
|
|
|
{
|
|
|
|
return (reason == CP_UMOUNT || reason == CP_FASTBOOT);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool __exist_node_summaries(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_UMOUNT_FLAG) ||
|
|
|
|
is_set_ckpt_flags(F2FS_CKPT(sbi), CP_FASTBOOT_FLAG));
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/*
|
|
|
|
* Check whether the given nid is within node id range.
|
|
|
|
*/
|
2013-03-17 09:27:20 +01:00
|
|
|
static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
2014-06-12 07:23:41 +02:00
|
|
|
if (unlikely(nid < F2FS_ROOT_INO(sbi)))
|
|
|
|
return -EINVAL;
|
2013-12-05 10:15:22 +01:00
|
|
|
if (unlikely(nid >= NM_I(sbi)->max_nid))
|
2013-03-17 09:27:20 +01:00
|
|
|
return -EINVAL;
|
|
|
|
return 0;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#define F2FS_DEFAULT_ALLOCATED_BLOCKS 1
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check whether the inode has blocks or not
|
|
|
|
*/
|
|
|
|
static inline int F2FS_HAS_BLOCKS(struct inode *inode)
|
|
|
|
{
|
|
|
|
if (F2FS_I(inode)->i_xattr_nid)
|
2014-01-17 21:44:39 +01:00
|
|
|
return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
else
|
2014-01-17 21:44:39 +01:00
|
|
|
return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
2014-03-17 09:35:06 +01:00
|
|
|
static inline bool f2fs_has_xattr_block(unsigned int ofs)
|
|
|
|
{
|
|
|
|
return ofs == XATTR_NODE_OFFSET;
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
|
|
|
|
struct inode *inode, blkcnt_t count)
|
|
|
|
{
|
|
|
|
block_t valid_block_count;
|
|
|
|
|
|
|
|
spin_lock(&sbi->stat_lock);
|
|
|
|
valid_block_count =
|
|
|
|
sbi->total_valid_block_count + (block_t)count;
|
2013-12-05 10:15:22 +01:00
|
|
|
if (unlikely(valid_block_count > sbi->user_block_count)) {
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
spin_unlock(&sbi->stat_lock);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
inode->i_blocks += count;
|
|
|
|
sbi->total_valid_block_count = valid_block_count;
|
|
|
|
sbi->alloc_valid_block_count += (block_t)count;
|
|
|
|
spin_unlock(&sbi->stat_lock);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-11-19 11:03:27 +01:00
|
|
|
static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct inode *inode,
|
|
|
|
blkcnt_t count)
|
|
|
|
{
|
|
|
|
spin_lock(&sbi->stat_lock);
|
2014-09-03 00:52:58 +02:00
|
|
|
f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
|
|
|
|
f2fs_bug_on(sbi, inode->i_blocks < count);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
inode->i_blocks -= count;
|
|
|
|
sbi->total_valid_block_count -= (block_t)count;
|
|
|
|
spin_unlock(&sbi->stat_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
|
|
|
|
{
|
|
|
|
atomic_inc(&sbi->nr_pages[count_type]);
|
2015-01-28 10:48:42 +01:00
|
|
|
set_sbi_flag(sbi, SBI_IS_DIRTY);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
2014-09-13 00:53:45 +02:00
|
|
|
static inline void inode_inc_dirty_pages(struct inode *inode)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
2014-09-13 00:53:45 +02:00
|
|
|
atomic_inc(&F2FS_I(inode)->dirty_pages);
|
2015-12-16 06:09:20 +01:00
|
|
|
inc_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
|
|
|
|
F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
|
|
|
|
{
|
|
|
|
atomic_dec(&sbi->nr_pages[count_type]);
|
|
|
|
}
|
|
|
|
|
2014-09-13 00:53:45 +02:00
|
|
|
static inline void inode_dec_dirty_pages(struct inode *inode)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
2015-06-29 12:14:10 +02:00
|
|
|
if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
|
|
|
|
!S_ISLNK(inode->i_mode))
|
2014-02-07 02:00:06 +01:00
|
|
|
return;
|
|
|
|
|
2014-09-13 00:53:45 +02:00
|
|
|
atomic_dec(&F2FS_I(inode)->dirty_pages);
|
2015-12-16 06:09:20 +01:00
|
|
|
dec_page_count(F2FS_I_SB(inode), S_ISDIR(inode->i_mode) ?
|
|
|
|
F2FS_DIRTY_DENTS : F2FS_DIRTY_DATA);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int get_pages(struct f2fs_sb_info *sbi, int count_type)
|
|
|
|
{
|
|
|
|
return atomic_read(&sbi->nr_pages[count_type]);
|
|
|
|
}
|
|
|
|
|
2014-09-13 00:53:45 +02:00
|
|
|
static inline int get_dirty_pages(struct inode *inode)
|
2014-03-18 04:33:06 +01:00
|
|
|
{
|
2014-09-13 00:53:45 +02:00
|
|
|
return atomic_read(&F2FS_I(inode)->dirty_pages);
|
2014-03-18 04:33:06 +01:00
|
|
|
}
|
|
|
|
|
2013-02-02 15:52:59 +01:00
|
|
|
static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)
|
|
|
|
{
|
2015-12-01 04:56:52 +01:00
|
|
|
unsigned int pages_per_sec = sbi->segs_per_sec * sbi->blocks_per_seg;
|
2013-02-02 15:52:59 +01:00
|
|
|
return ((get_pages(sbi, block_type) + pages_per_sec - 1)
|
|
|
|
>> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
2014-02-24 05:00:13 +01:00
|
|
|
return sbi->total_valid_block_count;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
|
|
|
|
{
|
|
|
|
struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
|
|
|
|
|
|
|
|
/* return NAT or SIT bitmap */
|
|
|
|
if (flag == NAT_BITMAP)
|
|
|
|
return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
|
|
|
|
else if (flag == SIT_BITMAP)
|
|
|
|
return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-02-26 00:57:20 +01:00
|
|
|
static inline block_t __cp_payload(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
|
|
|
|
{
|
|
|
|
struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
|
2014-05-12 05:27:43 +02:00
|
|
|
int offset;
|
|
|
|
|
2015-02-26 00:57:20 +01:00
|
|
|
if (__cp_payload(sbi) > 0) {
|
2014-05-12 05:27:43 +02:00
|
|
|
if (flag == NAT_BITMAP)
|
|
|
|
return &ckpt->sit_nat_version_bitmap;
|
|
|
|
else
|
2014-07-31 02:25:54 +02:00
|
|
|
return (unsigned char *)ckpt + F2FS_BLKSIZE;
|
2014-05-12 05:27:43 +02:00
|
|
|
} else {
|
|
|
|
offset = (flag == NAT_BITMAP) ?
|
2012-11-28 08:12:41 +01:00
|
|
|
le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
|
2014-05-12 05:27:43 +02:00
|
|
|
return &ckpt->sit_nat_version_bitmap + offset;
|
|
|
|
}
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
block_t start_addr;
|
|
|
|
struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
|
2013-08-09 08:03:21 +02:00
|
|
|
unsigned long long ckpt_version = cur_cp_version(ckpt);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
2012-11-28 08:12:41 +01:00
|
|
|
start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* odd numbered checkpoint should at cp segment 0
|
2014-08-06 16:22:50 +02:00
|
|
|
* and even segment must be at cp segment 1
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
*/
|
|
|
|
if (!(ckpt_version & 1))
|
|
|
|
start_addr += sbi->blocks_per_seg;
|
|
|
|
|
|
|
|
return start_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool inc_valid_node_count(struct f2fs_sb_info *sbi,
|
2013-11-19 11:03:38 +01:00
|
|
|
struct inode *inode)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
|
|
|
block_t valid_block_count;
|
|
|
|
unsigned int valid_node_count;
|
|
|
|
|
|
|
|
spin_lock(&sbi->stat_lock);
|
|
|
|
|
2013-11-19 11:03:38 +01:00
|
|
|
valid_block_count = sbi->total_valid_block_count + 1;
|
2013-12-05 10:15:22 +01:00
|
|
|
if (unlikely(valid_block_count > sbi->user_block_count)) {
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
spin_unlock(&sbi->stat_lock);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-11-19 11:03:38 +01:00
|
|
|
valid_node_count = sbi->total_valid_node_count + 1;
|
2013-12-05 10:15:22 +01:00
|
|
|
if (unlikely(valid_node_count > sbi->total_node_count)) {
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
spin_unlock(&sbi->stat_lock);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (inode)
|
2013-11-19 11:03:38 +01:00
|
|
|
inode->i_blocks++;
|
|
|
|
|
|
|
|
sbi->alloc_valid_block_count++;
|
|
|
|
sbi->total_valid_node_count++;
|
|
|
|
sbi->total_valid_block_count++;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
spin_unlock(&sbi->stat_lock);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
|
2013-11-19 11:03:38 +01:00
|
|
|
struct inode *inode)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
|
|
|
spin_lock(&sbi->stat_lock);
|
|
|
|
|
2014-09-03 00:52:58 +02:00
|
|
|
f2fs_bug_on(sbi, !sbi->total_valid_block_count);
|
|
|
|
f2fs_bug_on(sbi, !sbi->total_valid_node_count);
|
|
|
|
f2fs_bug_on(sbi, !inode->i_blocks);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
2013-11-19 11:03:38 +01:00
|
|
|
inode->i_blocks--;
|
|
|
|
sbi->total_valid_node_count--;
|
|
|
|
sbi->total_valid_block_count--;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
spin_unlock(&sbi->stat_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
2014-02-24 05:00:13 +01:00
|
|
|
return sbi->total_valid_node_count;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
spin_lock(&sbi->stat_lock);
|
2014-09-03 00:52:58 +02:00
|
|
|
f2fs_bug_on(sbi, sbi->total_valid_inode_count == sbi->total_node_count);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
sbi->total_valid_inode_count++;
|
|
|
|
spin_unlock(&sbi->stat_lock);
|
|
|
|
}
|
|
|
|
|
2013-11-26 08:36:20 +01:00
|
|
|
static inline void dec_valid_inode_count(struct f2fs_sb_info *sbi)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
|
|
|
spin_lock(&sbi->stat_lock);
|
2014-09-03 00:52:58 +02:00
|
|
|
f2fs_bug_on(sbi, !sbi->total_valid_inode_count);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
sbi->total_valid_inode_count--;
|
|
|
|
spin_unlock(&sbi->stat_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
2014-02-24 05:00:13 +01:00
|
|
|
return sbi->total_valid_inode_count;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
2015-10-10 00:11:38 +02:00
|
|
|
static inline struct page *f2fs_grab_cache_page(struct address_space *mapping,
|
|
|
|
pgoff_t index, bool for_write)
|
|
|
|
{
|
|
|
|
if (!for_write)
|
|
|
|
return grab_cache_page(mapping, index);
|
|
|
|
return grab_cache_page_write_begin(mapping, index, AOP_FLAG_NOFS);
|
|
|
|
}
|
|
|
|
|
2015-10-07 21:28:41 +02:00
|
|
|
static inline void f2fs_copy_page(struct page *src, struct page *dst)
|
|
|
|
{
|
|
|
|
char *src_kaddr = kmap(src);
|
|
|
|
char *dst_kaddr = kmap(dst);
|
|
|
|
|
|
|
|
memcpy(dst_kaddr, src_kaddr, PAGE_SIZE);
|
|
|
|
kunmap(dst);
|
|
|
|
kunmap(src);
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
static inline void f2fs_put_page(struct page *page, int unlock)
|
|
|
|
{
|
2013-11-28 04:55:13 +01:00
|
|
|
if (!page)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (unlock) {
|
2014-09-03 00:52:58 +02:00
|
|
|
f2fs_bug_on(F2FS_P_SB(page), !PageLocked(page));
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
unlock_page(page);
|
|
|
|
}
|
|
|
|
page_cache_release(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void f2fs_put_dnode(struct dnode_of_data *dn)
|
|
|
|
{
|
|
|
|
if (dn->node_page)
|
|
|
|
f2fs_put_page(dn->node_page, 1);
|
|
|
|
if (dn->inode_page && dn->node_page != dn->inode_page)
|
|
|
|
f2fs_put_page(dn->inode_page, 0);
|
|
|
|
dn->node_page = NULL;
|
|
|
|
dn->inode_page = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name,
|
2014-03-07 11:43:28 +01:00
|
|
|
size_t size)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
2014-03-07 11:43:28 +01:00
|
|
|
return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, NULL);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
2013-10-22 08:52:26 +02:00
|
|
|
static inline void *f2fs_kmem_cache_alloc(struct kmem_cache *cachep,
|
|
|
|
gfp_t flags)
|
|
|
|
{
|
|
|
|
void *entry;
|
|
|
|
|
2015-08-20 17:51:56 +02:00
|
|
|
entry = kmem_cache_alloc(cachep, flags);
|
|
|
|
if (!entry)
|
|
|
|
entry = kmem_cache_alloc(cachep, flags | __GFP_NOFAIL);
|
2013-10-22 08:52:26 +02:00
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
2015-08-14 20:43:56 +02:00
|
|
|
static inline struct bio *f2fs_bio_alloc(int npages)
|
|
|
|
{
|
|
|
|
struct bio *bio;
|
|
|
|
|
|
|
|
/* No failure on bio allocation */
|
|
|
|
bio = bio_alloc(GFP_NOIO, npages);
|
2015-08-20 17:51:56 +02:00
|
|
|
if (!bio)
|
|
|
|
bio = bio_alloc(GFP_NOIO | __GFP_NOFAIL, npages);
|
2015-08-14 20:43:56 +02:00
|
|
|
return bio;
|
|
|
|
}
|
|
|
|
|
2014-12-05 19:39:49 +01:00
|
|
|
static inline void f2fs_radix_tree_insert(struct radix_tree_root *root,
|
|
|
|
unsigned long index, void *item)
|
|
|
|
{
|
|
|
|
while (radix_tree_insert(root, index, item))
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
#define RAW_IS_INODE(p) ((p)->footer.nid == (p)->footer.ino)
|
|
|
|
|
|
|
|
static inline bool IS_INODE(struct page *page)
|
|
|
|
{
|
2013-07-15 11:57:38 +02:00
|
|
|
struct f2fs_node *p = F2FS_NODE(page);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
return RAW_IS_INODE(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
|
|
|
|
{
|
|
|
|
return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline block_t datablock_addr(struct page *node_page,
|
|
|
|
unsigned int offset)
|
|
|
|
{
|
|
|
|
struct f2fs_node *raw_node;
|
|
|
|
__le32 *addr_array;
|
2013-07-15 11:57:38 +02:00
|
|
|
raw_node = F2FS_NODE(node_page);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
addr_array = blkaddr_in_node(raw_node);
|
|
|
|
return le32_to_cpu(addr_array[offset]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int f2fs_test_bit(unsigned int nr, char *addr)
|
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
|
|
|
|
addr += (nr >> 3);
|
|
|
|
mask = 1 << (7 - (nr & 0x07));
|
|
|
|
return mask & *addr;
|
|
|
|
}
|
|
|
|
|
2015-05-01 07:37:50 +02:00
|
|
|
static inline void f2fs_set_bit(unsigned int nr, char *addr)
|
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
|
|
|
|
addr += (nr >> 3);
|
|
|
|
mask = 1 << (7 - (nr & 0x07));
|
|
|
|
*addr |= mask;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void f2fs_clear_bit(unsigned int nr, char *addr)
|
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
|
|
|
|
addr += (nr >> 3);
|
|
|
|
mask = 1 << (7 - (nr & 0x07));
|
|
|
|
*addr &= ~mask;
|
|
|
|
}
|
|
|
|
|
2014-10-20 11:45:51 +02:00
|
|
|
static inline int f2fs_test_and_set_bit(unsigned int nr, char *addr)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
addr += (nr >> 3);
|
|
|
|
mask = 1 << (7 - (nr & 0x07));
|
|
|
|
ret = mask & *addr;
|
|
|
|
*addr |= mask;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-20 11:45:51 +02:00
|
|
|
static inline int f2fs_test_and_clear_bit(unsigned int nr, char *addr)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
addr += (nr >> 3);
|
|
|
|
mask = 1 << (7 - (nr & 0x07));
|
|
|
|
ret = mask & *addr;
|
|
|
|
*addr &= ~mask;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-10-20 11:45:50 +02:00
|
|
|
static inline void f2fs_change_bit(unsigned int nr, char *addr)
|
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
|
|
|
|
addr += (nr >> 3);
|
|
|
|
mask = 1 << (7 - (nr & 0x07));
|
|
|
|
*addr ^= mask;
|
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/* used for f2fs_inode_info->flags */
|
|
|
|
enum {
|
|
|
|
FI_NEW_INODE, /* indicate newly allocated inode */
|
2013-06-10 02:17:01 +02:00
|
|
|
FI_DIRTY_INODE, /* indicate inode is dirty or not */
|
2014-04-15 04:19:28 +02:00
|
|
|
FI_DIRTY_DIR, /* indicate directory has dirty pages */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
FI_INC_LINK, /* need to increment i_nlink */
|
|
|
|
FI_ACL_MODE, /* indicate acl mode */
|
|
|
|
FI_NO_ALLOC, /* should not allocate any blocks */
|
2015-06-23 19:36:08 +02:00
|
|
|
FI_FREE_NID, /* free allocated nide */
|
2013-06-07 15:08:23 +02:00
|
|
|
FI_UPDATE_DIR, /* should update inode block for consistency */
|
2013-05-15 09:40:02 +02:00
|
|
|
FI_DELAY_IPUT, /* used for the recovery */
|
2013-11-19 02:41:54 +01:00
|
|
|
FI_NO_EXTENT, /* not to use the extent cache */
|
2013-08-08 08:16:22 +02:00
|
|
|
FI_INLINE_XATTR, /* used for inline xattr */
|
2013-11-10 16:13:16 +01:00
|
|
|
FI_INLINE_DATA, /* used for inline data*/
|
2014-09-24 12:15:19 +02:00
|
|
|
FI_INLINE_DENTRY, /* used for inline dentry */
|
2014-07-25 16:40:59 +02:00
|
|
|
FI_APPEND_WRITE, /* inode has appended data */
|
|
|
|
FI_UPDATE_WRITE, /* inode has in-place-update data */
|
2014-10-07 02:39:50 +02:00
|
|
|
FI_NEED_IPU, /* used for ipu per file */
|
|
|
|
FI_ATOMIC_FILE, /* indicate atomic file */
|
2014-10-07 01:11:16 +02:00
|
|
|
FI_VOLATILE_FILE, /* indicate volatile file */
|
2015-03-18 01:16:35 +01:00
|
|
|
FI_FIRST_BLOCK_WRITTEN, /* indicate #0 data block was written */
|
2014-12-09 15:08:59 +01:00
|
|
|
FI_DROP_CACHE, /* drop dirty page cache */
|
2014-10-24 04:48:09 +02:00
|
|
|
FI_DATA_EXIST, /* indicate data exists */
|
2015-03-31 00:07:16 +02:00
|
|
|
FI_INLINE_DOTS, /* indicate inline dot dentries */
|
2015-10-27 02:53:45 +01:00
|
|
|
FI_DO_DEFRAG, /* indicate defragment is running */
|
2015-12-16 06:09:20 +01:00
|
|
|
FI_DIRTY_FILE, /* indicate regular/symlink has dirty pages */
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
|
|
|
|
{
|
2014-07-26 00:47:23 +02:00
|
|
|
if (!test_bit(flag, &fi->flags))
|
|
|
|
set_bit(flag, &fi->flags);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag)
|
|
|
|
{
|
|
|
|
return test_bit(flag, &fi->flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag)
|
|
|
|
{
|
2014-07-26 00:47:23 +02:00
|
|
|
if (test_bit(flag, &fi->flags))
|
|
|
|
clear_bit(flag, &fi->flags);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode)
|
|
|
|
{
|
|
|
|
fi->i_acl_mode = mode;
|
|
|
|
set_inode_flag(fi, FI_ACL_MODE);
|
|
|
|
}
|
|
|
|
|
2013-08-08 08:16:22 +02:00
|
|
|
static inline void get_inline_info(struct f2fs_inode_info *fi,
|
|
|
|
struct f2fs_inode *ri)
|
|
|
|
{
|
|
|
|
if (ri->i_inline & F2FS_INLINE_XATTR)
|
|
|
|
set_inode_flag(fi, FI_INLINE_XATTR);
|
2013-11-10 16:13:16 +01:00
|
|
|
if (ri->i_inline & F2FS_INLINE_DATA)
|
|
|
|
set_inode_flag(fi, FI_INLINE_DATA);
|
2014-09-24 12:15:19 +02:00
|
|
|
if (ri->i_inline & F2FS_INLINE_DENTRY)
|
|
|
|
set_inode_flag(fi, FI_INLINE_DENTRY);
|
2014-10-24 04:48:09 +02:00
|
|
|
if (ri->i_inline & F2FS_DATA_EXIST)
|
|
|
|
set_inode_flag(fi, FI_DATA_EXIST);
|
2015-03-31 00:07:16 +02:00
|
|
|
if (ri->i_inline & F2FS_INLINE_DOTS)
|
|
|
|
set_inode_flag(fi, FI_INLINE_DOTS);
|
2013-08-08 08:16:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_raw_inline(struct f2fs_inode_info *fi,
|
|
|
|
struct f2fs_inode *ri)
|
|
|
|
{
|
|
|
|
ri->i_inline = 0;
|
|
|
|
|
|
|
|
if (is_inode_flag_set(fi, FI_INLINE_XATTR))
|
|
|
|
ri->i_inline |= F2FS_INLINE_XATTR;
|
2013-11-10 16:13:16 +01:00
|
|
|
if (is_inode_flag_set(fi, FI_INLINE_DATA))
|
|
|
|
ri->i_inline |= F2FS_INLINE_DATA;
|
2014-09-24 12:15:19 +02:00
|
|
|
if (is_inode_flag_set(fi, FI_INLINE_DENTRY))
|
|
|
|
ri->i_inline |= F2FS_INLINE_DENTRY;
|
2014-10-24 04:48:09 +02:00
|
|
|
if (is_inode_flag_set(fi, FI_DATA_EXIST))
|
|
|
|
ri->i_inline |= F2FS_DATA_EXIST;
|
2015-03-31 00:07:16 +02:00
|
|
|
if (is_inode_flag_set(fi, FI_INLINE_DOTS))
|
|
|
|
ri->i_inline |= F2FS_INLINE_DOTS;
|
2013-08-08 08:16:22 +02:00
|
|
|
}
|
|
|
|
|
2014-03-12 08:59:03 +01:00
|
|
|
static inline int f2fs_has_inline_xattr(struct inode *inode)
|
|
|
|
{
|
|
|
|
return is_inode_flag_set(F2FS_I(inode), FI_INLINE_XATTR);
|
|
|
|
}
|
|
|
|
|
2013-08-12 14:08:03 +02:00
|
|
|
static inline unsigned int addrs_per_inode(struct f2fs_inode_info *fi)
|
|
|
|
{
|
2014-03-12 08:59:03 +01:00
|
|
|
if (f2fs_has_inline_xattr(&fi->vfs_inode))
|
2013-08-12 14:08:03 +02:00
|
|
|
return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
|
|
|
|
return DEF_ADDRS_PER_INODE;
|
|
|
|
}
|
|
|
|
|
2013-08-14 14:57:27 +02:00
|
|
|
static inline void *inline_xattr_addr(struct page *page)
|
|
|
|
{
|
2014-02-27 12:52:21 +01:00
|
|
|
struct f2fs_inode *ri = F2FS_INODE(page);
|
2013-08-14 14:57:27 +02:00
|
|
|
return (void *)&(ri->i_addr[DEF_ADDRS_PER_INODE -
|
|
|
|
F2FS_INLINE_XATTR_ADDRS]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int inline_xattr_size(struct inode *inode)
|
|
|
|
{
|
2014-03-12 08:59:03 +01:00
|
|
|
if (f2fs_has_inline_xattr(inode))
|
2013-08-14 14:57:27 +02:00
|
|
|
return F2FS_INLINE_XATTR_ADDRS << 2;
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-26 03:08:57 +01:00
|
|
|
static inline int f2fs_has_inline_data(struct inode *inode)
|
|
|
|
{
|
|
|
|
return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DATA);
|
|
|
|
}
|
|
|
|
|
2014-10-24 04:48:09 +02:00
|
|
|
static inline void f2fs_clear_inline_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
|
|
|
|
clear_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int f2fs_exist_data(struct inode *inode)
|
|
|
|
{
|
|
|
|
return is_inode_flag_set(F2FS_I(inode), FI_DATA_EXIST);
|
|
|
|
}
|
|
|
|
|
2015-03-31 00:07:16 +02:00
|
|
|
static inline int f2fs_has_inline_dots(struct inode *inode)
|
|
|
|
{
|
|
|
|
return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DOTS);
|
|
|
|
}
|
|
|
|
|
2014-10-07 02:39:50 +02:00
|
|
|
static inline bool f2fs_is_atomic_file(struct inode *inode)
|
|
|
|
{
|
|
|
|
return is_inode_flag_set(F2FS_I(inode), FI_ATOMIC_FILE);
|
|
|
|
}
|
|
|
|
|
2014-10-07 01:11:16 +02:00
|
|
|
static inline bool f2fs_is_volatile_file(struct inode *inode)
|
|
|
|
{
|
|
|
|
return is_inode_flag_set(F2FS_I(inode), FI_VOLATILE_FILE);
|
|
|
|
}
|
|
|
|
|
2015-03-18 01:16:35 +01:00
|
|
|
static inline bool f2fs_is_first_block_written(struct inode *inode)
|
|
|
|
{
|
|
|
|
return is_inode_flag_set(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);
|
|
|
|
}
|
|
|
|
|
2014-12-09 15:08:59 +01:00
|
|
|
static inline bool f2fs_is_drop_cache(struct inode *inode)
|
|
|
|
{
|
|
|
|
return is_inode_flag_set(F2FS_I(inode), FI_DROP_CACHE);
|
|
|
|
}
|
|
|
|
|
2013-11-10 16:13:16 +01:00
|
|
|
static inline void *inline_data_addr(struct page *page)
|
|
|
|
{
|
2014-02-27 12:52:21 +01:00
|
|
|
struct f2fs_inode *ri = F2FS_INODE(page);
|
2013-11-10 16:13:16 +01:00
|
|
|
return (void *)&(ri->i_addr[1]);
|
|
|
|
}
|
|
|
|
|
2014-09-24 12:15:19 +02:00
|
|
|
static inline int f2fs_has_inline_dentry(struct inode *inode)
|
|
|
|
{
|
|
|
|
return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DENTRY);
|
|
|
|
}
|
|
|
|
|
2014-11-22 01:36:28 +01:00
|
|
|
static inline void f2fs_dentry_kunmap(struct inode *dir, struct page *page)
|
|
|
|
{
|
|
|
|
if (!f2fs_has_inline_dentry(dir))
|
|
|
|
kunmap(page);
|
|
|
|
}
|
|
|
|
|
2015-04-20 22:44:41 +02:00
|
|
|
static inline int is_file(struct inode *inode, int type)
|
|
|
|
{
|
|
|
|
return F2FS_I(inode)->i_advise & type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void set_file(struct inode *inode, int type)
|
|
|
|
{
|
|
|
|
F2FS_I(inode)->i_advise |= type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void clear_file(struct inode *inode, int type)
|
|
|
|
{
|
|
|
|
F2FS_I(inode)->i_advise &= ~type;
|
|
|
|
}
|
|
|
|
|
2013-05-20 13:28:47 +02:00
|
|
|
static inline int f2fs_readonly(struct super_block *sb)
|
|
|
|
{
|
|
|
|
return sb->s_flags & MS_RDONLY;
|
|
|
|
}
|
|
|
|
|
2014-08-12 01:49:25 +02:00
|
|
|
static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
return is_set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
|
|
|
|
}
|
|
|
|
|
2014-01-24 01:42:16 +01:00
|
|
|
static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
|
|
|
set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
|
|
|
|
sbi->sb->s_flags |= MS_RDONLY;
|
|
|
|
}
|
|
|
|
|
2015-04-26 09:15:29 +02:00
|
|
|
static inline bool is_dot_dotdot(const struct qstr *str)
|
|
|
|
{
|
|
|
|
if (str->len == 1 && str->name[0] == '.')
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (str->len == 2 && str->name[0] == '.' && str->name[1] == '.')
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-06-20 02:53:26 +02:00
|
|
|
static inline bool f2fs_may_extent_tree(struct inode *inode)
|
|
|
|
{
|
|
|
|
if (!test_opt(F2FS_I_SB(inode), EXTENT_CACHE) ||
|
|
|
|
is_inode_flag_set(F2FS_I(inode), FI_NO_EXTENT))
|
|
|
|
return false;
|
|
|
|
|
2015-12-05 09:56:06 +01:00
|
|
|
return S_ISREG(inode->i_mode);
|
2015-06-20 02:53:26 +02:00
|
|
|
}
|
|
|
|
|
2015-09-22 22:50:47 +02:00
|
|
|
static inline void *f2fs_kvmalloc(size_t size, gfp_t flags)
|
|
|
|
{
|
|
|
|
void *ret;
|
|
|
|
|
|
|
|
ret = kmalloc(size, flags | __GFP_NOWARN);
|
|
|
|
if (!ret)
|
|
|
|
ret = __vmalloc(size, flags, PAGE_KERNEL);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *f2fs_kvzalloc(size_t size, gfp_t flags)
|
|
|
|
{
|
|
|
|
void *ret;
|
|
|
|
|
|
|
|
ret = kzalloc(size, flags | __GFP_NOWARN);
|
|
|
|
if (!ret)
|
|
|
|
ret = __vmalloc(size, flags | __GFP_ZERO, PAGE_KERNEL);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-12-20 14:16:45 +01:00
|
|
|
#define get_inode_mode(i) \
|
|
|
|
((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \
|
|
|
|
(F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
|
|
|
|
|
2014-04-23 08:10:24 +02:00
|
|
|
/* get offset of first page in next direct node */
|
|
|
|
#define PGOFS_OF_NEXT_DNODE(pgofs, fi) \
|
|
|
|
((pgofs < ADDRS_PER_INODE(fi)) ? ADDRS_PER_INODE(fi) : \
|
|
|
|
(pgofs - ADDRS_PER_INODE(fi) + ADDRS_PER_BLOCK) / \
|
|
|
|
ADDRS_PER_BLOCK * ADDRS_PER_BLOCK + ADDRS_PER_INODE(fi))
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/*
|
|
|
|
* file.c
|
|
|
|
*/
|
|
|
|
int f2fs_sync_file(struct file *, loff_t, loff_t, int);
|
|
|
|
void truncate_data_blocks(struct dnode_of_data *);
|
2014-08-15 01:32:54 +02:00
|
|
|
int truncate_blocks(struct inode *, u64, bool);
|
2015-08-24 11:39:42 +02:00
|
|
|
int f2fs_truncate(struct inode *, bool);
|
2013-06-07 09:33:07 +02:00
|
|
|
int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int f2fs_setattr(struct dentry *, struct iattr *);
|
|
|
|
int truncate_hole(struct inode *, pgoff_t, pgoff_t);
|
2013-05-22 01:02:02 +02:00
|
|
|
int truncate_data_blocks_range(struct dnode_of_data *, int);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
long f2fs_ioctl(struct file *, unsigned int, unsigned long);
|
2013-02-04 15:41:41 +01:00
|
|
|
long f2fs_compat_ioctl(struct file *, unsigned int, unsigned long);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* inode.c
|
|
|
|
*/
|
|
|
|
void f2fs_set_inode_flags(struct inode *);
|
|
|
|
struct inode *f2fs_iget(struct super_block *, unsigned long);
|
2013-10-24 07:19:18 +02:00
|
|
|
int try_to_free_nats(struct f2fs_sb_info *, int);
|
2016-01-07 22:23:12 +01:00
|
|
|
int update_inode(struct inode *, struct page *);
|
|
|
|
int update_inode_page(struct inode *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int f2fs_write_inode(struct inode *, struct writeback_control *);
|
|
|
|
void f2fs_evict_inode(struct inode *);
|
2014-09-25 20:55:53 +02:00
|
|
|
void handle_failed_inode(struct inode *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* namei.c
|
|
|
|
*/
|
|
|
|
struct dentry *f2fs_get_parent(struct dentry *child);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dir.c
|
|
|
|
*/
|
2014-09-24 12:17:04 +02:00
|
|
|
extern unsigned char f2fs_filetype_table[F2FS_FT_MAX];
|
2015-03-31 00:07:16 +02:00
|
|
|
void set_de_type(struct f2fs_dir_entry *, umode_t);
|
2015-04-28 02:12:39 +02:00
|
|
|
|
|
|
|
struct f2fs_dir_entry *find_target_dentry(struct f2fs_filename *,
|
|
|
|
f2fs_hash_t, int *, struct f2fs_dentry_ptr *);
|
2014-10-19 07:52:52 +02:00
|
|
|
bool f2fs_fill_dentries(struct dir_context *, struct f2fs_dentry_ptr *,
|
2015-04-28 01:26:24 +02:00
|
|
|
unsigned int, struct f2fs_str *);
|
2014-10-19 08:06:41 +02:00
|
|
|
void do_make_empty_dir(struct inode *, struct inode *,
|
|
|
|
struct f2fs_dentry_ptr *);
|
2014-09-24 12:17:04 +02:00
|
|
|
struct page *init_inode_metadata(struct inode *, struct inode *,
|
2014-10-14 04:42:53 +02:00
|
|
|
const struct qstr *, struct page *);
|
2014-09-24 12:17:04 +02:00
|
|
|
void update_parent_metadata(struct inode *, struct inode *, unsigned int);
|
2014-10-14 01:28:13 +02:00
|
|
|
int room_for_filename(const void *, int, int);
|
2014-09-24 12:17:04 +02:00
|
|
|
void f2fs_drop_nlink(struct inode *, struct inode *, struct page *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *,
|
|
|
|
struct page **);
|
|
|
|
struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
|
|
|
|
ino_t f2fs_inode_by_name(struct inode *, struct qstr *);
|
|
|
|
void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
|
|
|
|
struct page *, struct inode *);
|
2015-04-30 02:02:18 +02:00
|
|
|
int update_dent_inode(struct inode *, struct inode *, const struct qstr *);
|
2015-03-31 00:07:16 +02:00
|
|
|
void f2fs_update_dentry(nid_t ino, umode_t mode, struct f2fs_dentry_ptr *,
|
2015-02-16 09:17:20 +01:00
|
|
|
const struct qstr *, f2fs_hash_t , unsigned int);
|
2015-03-31 00:07:16 +02:00
|
|
|
int __f2fs_add_link(struct inode *, const struct qstr *, struct inode *, nid_t,
|
|
|
|
umode_t);
|
2014-09-24 12:17:04 +02:00
|
|
|
void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *,
|
|
|
|
struct inode *);
|
2014-06-21 06:37:02 +02:00
|
|
|
int f2fs_do_tmpfile(struct inode *, struct inode *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
bool f2fs_empty_dir(struct inode *);
|
|
|
|
|
2013-01-25 22:15:43 +01:00
|
|
|
static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
|
|
|
|
{
|
2015-03-17 23:25:59 +01:00
|
|
|
return __f2fs_add_link(d_inode(dentry->d_parent), &dentry->d_name,
|
2015-03-31 00:07:16 +02:00
|
|
|
inode, inode->i_ino, inode->i_mode);
|
2013-01-25 22:15:43 +01:00
|
|
|
}
|
|
|
|
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
/*
|
|
|
|
* super.c
|
|
|
|
*/
|
2015-06-08 07:28:03 +02:00
|
|
|
int f2fs_commit_super(struct f2fs_sb_info *, bool);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int f2fs_sync_fs(struct super_block *, int);
|
2012-12-30 06:52:05 +01:00
|
|
|
extern __printf(3, 4)
|
|
|
|
void f2fs_msg(struct super_block *, const char *, const char *, ...);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* hash.c
|
|
|
|
*/
|
2014-06-24 12:21:23 +02:00
|
|
|
f2fs_hash_t f2fs_dentry_hash(const struct qstr *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* node.c
|
|
|
|
*/
|
|
|
|
struct dnode_of_data;
|
|
|
|
struct node_info;
|
|
|
|
|
2014-04-16 03:47:06 +02:00
|
|
|
bool available_free_memory(struct f2fs_sb_info *, int);
|
2015-04-30 03:31:19 +02:00
|
|
|
int need_dentry_mark(struct f2fs_sb_info *, nid_t);
|
f2fs: fix conditions to remain recovery information in f2fs_sync_file
This patch revisited whole the recovery information during the f2fs_sync_file.
In this patch, there are three information to make a decision.
a) IS_CHECKPOINTED, /* is it checkpointed before? */
b) HAS_FSYNCED_INODE, /* is the inode fsynced before? */
c) HAS_LAST_FSYNC, /* has the latest node fsync mark? */
And, the scenarios for our rule are based on:
[Term] F: fsync_mark, D: dentry_mark
1. inode(x) | CP | inode(x) | dnode(F)
2. inode(x) | CP | inode(F) | dnode(F)
3. inode(x) | CP | dnode(F) | inode(x) | inode(F)
4. inode(x) | CP | dnode(F) | inode(F)
5. CP | inode(x) | dnode(F) | inode(DF)
6. CP | inode(DF) | dnode(F)
7. CP | dnode(F) | inode(DF)
8. CP | dnode(F) | inode(x) | inode(DF)
For example, #3, the three conditions should be changed as follows.
inode(x) | CP | dnode(F) | inode(x) | inode(F)
a) x o o o o
b) x x x x o
c) x o o x o
If f2fs_sync_file stops ------^,
it should write inode(F) --------------^
So, the need_inode_block_update should return true, since
c) get_nat_flag(e, HAS_LAST_FSYNC), is false.
For example, #8,
CP | alloc | dnode(F) | inode(x) | inode(DF)
a) o x x x x
b) x x x o
c) o o x o
If f2fs_sync_file stops -------^,
it should write inode(DF) --------------^
Note that, the roll-forward policy should follow this rule, which means,
if there are any missing blocks, we doesn't need to recover that inode.
Signed-off-by: Huang Ying <ying.huang@intel.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2014-09-15 23:50:48 +02:00
|
|
|
bool is_checkpointed_node(struct f2fs_sb_info *, nid_t);
|
|
|
|
bool need_inode_block_update(struct f2fs_sb_info *, nid_t);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
|
|
|
|
int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int);
|
|
|
|
int truncate_inode_blocks(struct inode *, pgoff_t);
|
2013-08-14 13:40:06 +02:00
|
|
|
int truncate_xattr_node(struct inode *, struct page *);
|
2013-10-31 06:57:01 +01:00
|
|
|
int wait_on_node_pages_writeback(struct f2fs_sb_info *, nid_t);
|
2015-08-24 11:40:45 +02:00
|
|
|
int remove_inode_page(struct inode *);
|
2014-06-21 06:44:02 +02:00
|
|
|
struct page *new_inode_page(struct inode *);
|
2013-06-03 12:46:19 +02:00
|
|
|
struct page *new_node_page(struct dnode_of_data *, unsigned int, struct page *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
void ra_node_page(struct f2fs_sb_info *, nid_t);
|
|
|
|
struct page *get_node_page(struct f2fs_sb_info *, pgoff_t);
|
|
|
|
struct page *get_node_page_ra(struct page *, int);
|
|
|
|
void sync_inode_page(struct dnode_of_data *);
|
|
|
|
int sync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *);
|
|
|
|
bool alloc_nid(struct f2fs_sb_info *, nid_t *);
|
|
|
|
void alloc_nid_done(struct f2fs_sb_info *, nid_t);
|
|
|
|
void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
|
2015-07-28 12:33:46 +02:00
|
|
|
int try_to_free_nids(struct f2fs_sb_info *, int);
|
2014-08-02 09:26:04 +02:00
|
|
|
void recover_inline_xattr(struct inode *, struct page *);
|
2014-08-08 08:49:17 +02:00
|
|
|
void recover_xattr_data(struct inode *, struct page *, block_t);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int recover_inode_page(struct f2fs_sb_info *, struct page *);
|
|
|
|
int restore_node_summary(struct f2fs_sb_info *, unsigned int,
|
|
|
|
struct f2fs_summary_block *);
|
|
|
|
void flush_nat_entries(struct f2fs_sb_info *);
|
|
|
|
int build_node_manager(struct f2fs_sb_info *);
|
|
|
|
void destroy_node_manager(struct f2fs_sb_info *);
|
2013-01-16 16:08:30 +01:00
|
|
|
int __init create_node_manager_caches(void);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
void destroy_node_manager_caches(void);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* segment.c
|
|
|
|
*/
|
2014-10-07 02:39:50 +02:00
|
|
|
void register_inmem_page(struct inode *, struct page *);
|
2015-07-25 09:52:52 +02:00
|
|
|
int commit_inmem_pages(struct inode *, bool);
|
2016-01-07 23:15:04 +01:00
|
|
|
void f2fs_balance_fs(struct f2fs_sb_info *, bool);
|
2013-10-24 07:19:18 +02:00
|
|
|
void f2fs_balance_fs_bg(struct f2fs_sb_info *);
|
2014-04-02 08:34:36 +02:00
|
|
|
int f2fs_issue_flush(struct f2fs_sb_info *);
|
2014-04-27 08:21:33 +02:00
|
|
|
int create_flush_cmd_control(struct f2fs_sb_info *);
|
|
|
|
void destroy_flush_cmd_control(struct f2fs_sb_info *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
void invalidate_blocks(struct f2fs_sb_info *, block_t);
|
2015-10-07 21:28:41 +02:00
|
|
|
bool is_checkpointed_data(struct f2fs_sb_info *, block_t);
|
2014-01-28 04:22:14 +01:00
|
|
|
void refresh_sit_entry(struct f2fs_sb_info *, block_t, block_t);
|
2015-05-01 07:50:06 +02:00
|
|
|
void clear_prefree_segments(struct f2fs_sb_info *, struct cp_control *);
|
2014-09-21 07:06:39 +02:00
|
|
|
void release_discard_addrs(struct f2fs_sb_info *);
|
2015-07-28 12:36:47 +02:00
|
|
|
bool discard_next_dnode(struct f2fs_sb_info *, block_t);
|
2014-12-09 07:21:46 +01:00
|
|
|
int npages_for_summary_flush(struct f2fs_sb_info *, bool);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
void allocate_new_segments(struct f2fs_sb_info *);
|
2014-09-21 07:06:39 +02:00
|
|
|
int f2fs_trim_fs(struct f2fs_sb_info *, struct fstrim_range *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
|
2015-05-19 11:40:04 +02:00
|
|
|
void update_meta_page(struct f2fs_sb_info *, void *, block_t);
|
f2fs: prevent checkpoint once any IO failure is detected
This patch enhances the checkpoint routine to cope with IO errors.
Basically f2fs detects IO errors from end_io_write, and the errors are able to
be occurred during one of data, node, and meta page writes.
In the previous code, when an IO error is occurred during writes, f2fs sets a
flag, CP_ERROR_FLAG, in the raw ckeckpoint buffer which will be written to disk.
Afterwards, write_checkpoint() will check the flag and remount f2fs as a
read-only (ro) mode.
However, even once f2fs is remounted as a ro mode, dirty checkpoint pages are
freely able to be written to disk by flusher or kswapd in background.
In such a case, after cold reboot, f2fs would restore the checkpoint data having
CP_ERROR_FLAG, resulting in disabling write_checkpoint and remounting f2fs as
a ro mode again.
Therefore, let's prevent any checkpoint page (meta) writes once an IO error is
occurred, and remount f2fs as a ro mode right away at that moment.
Reported-by: Oliver Winker <oliver@oli1170.net>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
Reviewed-by: Namjae Jeon <namjae.jeon@samsung.com>
2013-01-24 11:56:11 +01:00
|
|
|
void write_meta_page(struct f2fs_sb_info *, struct page *);
|
2015-04-23 23:38:15 +02:00
|
|
|
void write_node_page(unsigned int, struct f2fs_io_info *);
|
|
|
|
void write_data_page(struct dnode_of_data *, struct f2fs_io_info *);
|
|
|
|
void rewrite_data_page(struct f2fs_io_info *);
|
2015-05-28 13:15:35 +02:00
|
|
|
void f2fs_replace_block(struct f2fs_sb_info *, struct dnode_of_data *,
|
|
|
|
block_t, block_t, unsigned char, bool);
|
2013-12-16 11:04:05 +01:00
|
|
|
void allocate_data_block(struct f2fs_sb_info *, struct page *,
|
|
|
|
block_t, block_t *, struct f2fs_summary *, int);
|
2014-01-10 08:26:14 +01:00
|
|
|
void f2fs_wait_on_page_writeback(struct page *, enum page_type);
|
2015-10-08 07:27:34 +02:00
|
|
|
void f2fs_wait_on_encrypted_page_writeback(struct f2fs_sb_info *, block_t);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
void write_data_summaries(struct f2fs_sb_info *, block_t);
|
|
|
|
void write_node_summaries(struct f2fs_sb_info *, block_t);
|
|
|
|
int lookup_journal_in_cursum(struct f2fs_summary_block *,
|
|
|
|
int, unsigned int, int);
|
2014-09-21 07:06:39 +02:00
|
|
|
void flush_sit_entries(struct f2fs_sb_info *, struct cp_control *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int build_segment_manager(struct f2fs_sb_info *);
|
|
|
|
void destroy_segment_manager(struct f2fs_sb_info *);
|
2013-11-15 05:55:58 +01:00
|
|
|
int __init create_segment_manager_caches(void);
|
|
|
|
void destroy_segment_manager_caches(void);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* checkpoint.c
|
|
|
|
*/
|
|
|
|
struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t);
|
|
|
|
struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
|
2015-10-12 11:04:21 +02:00
|
|
|
struct page *get_tmp_page(struct f2fs_sb_info *, pgoff_t);
|
2015-04-18 12:05:36 +02:00
|
|
|
bool is_valid_blkaddr(struct f2fs_sb_info *, block_t, int);
|
2015-10-12 11:05:59 +02:00
|
|
|
int ra_meta_pages(struct f2fs_sb_info *, block_t, int, int, bool);
|
2014-12-08 08:02:52 +01:00
|
|
|
void ra_meta_pages_cond(struct f2fs_sb_info *, pgoff_t);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
|
2015-12-15 06:29:47 +01:00
|
|
|
void add_ino_entry(struct f2fs_sb_info *, nid_t, int type);
|
|
|
|
void remove_ino_entry(struct f2fs_sb_info *, nid_t, int type);
|
|
|
|
void release_ino_entry(struct f2fs_sb_info *);
|
2014-07-25 16:40:59 +02:00
|
|
|
bool exist_written_data(struct f2fs_sb_info *, nid_t, int);
|
2013-07-30 04:36:53 +02:00
|
|
|
int acquire_orphan_inode(struct f2fs_sb_info *);
|
|
|
|
void release_orphan_inode(struct f2fs_sb_info *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
void add_orphan_inode(struct f2fs_sb_info *, nid_t);
|
|
|
|
void remove_orphan_inode(struct f2fs_sb_info *, nid_t);
|
2015-08-07 11:58:43 +02:00
|
|
|
int recover_orphan_inodes(struct f2fs_sb_info *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int get_valid_checkpoint(struct f2fs_sb_info *);
|
2014-09-13 00:53:45 +02:00
|
|
|
void update_dirty_page(struct inode *, struct page *);
|
2013-06-05 10:42:45 +02:00
|
|
|
void add_dirty_dir_inode(struct inode *);
|
2015-12-16 06:09:20 +01:00
|
|
|
void remove_dirty_inode(struct inode *);
|
2015-12-24 11:04:56 +01:00
|
|
|
int sync_dirty_inodes(struct f2fs_sb_info *, enum inode_type);
|
2015-12-23 10:50:30 +01:00
|
|
|
int write_checkpoint(struct f2fs_sb_info *, struct cp_control *);
|
2014-07-26 00:47:17 +02:00
|
|
|
void init_ino_entry_info(struct f2fs_sb_info *);
|
2013-01-16 16:08:30 +01:00
|
|
|
int __init create_checkpoint_caches(void);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
void destroy_checkpoint_caches(void);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* data.c
|
|
|
|
*/
|
2013-12-11 05:54:01 +01:00
|
|
|
void f2fs_submit_merged_bio(struct f2fs_sb_info *, enum page_type, int);
|
2015-04-23 23:38:15 +02:00
|
|
|
int f2fs_submit_page_bio(struct f2fs_io_info *);
|
|
|
|
void f2fs_submit_page_mbio(struct f2fs_io_info *);
|
2015-03-19 12:23:32 +01:00
|
|
|
void set_data_blkaddr(struct dnode_of_data *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int reserve_new_block(struct dnode_of_data *);
|
2015-08-05 09:52:16 +02:00
|
|
|
int f2fs_get_block(struct dnode_of_data *, pgoff_t);
|
2013-11-10 16:13:18 +01:00
|
|
|
int f2fs_reserve_block(struct dnode_of_data *, pgoff_t);
|
2015-10-10 00:11:38 +02:00
|
|
|
struct page *get_read_data_page(struct inode *, pgoff_t, int, bool);
|
2015-05-01 02:00:33 +02:00
|
|
|
struct page *find_data_page(struct inode *, pgoff_t);
|
2015-10-10 00:11:38 +02:00
|
|
|
struct page *get_lock_data_page(struct inode *, pgoff_t, bool);
|
2013-05-20 02:55:50 +02:00
|
|
|
struct page *get_new_data_page(struct inode *, struct page *, pgoff_t, bool);
|
2015-04-23 23:38:15 +02:00
|
|
|
int do_write_data_page(struct f2fs_io_info *);
|
2015-10-27 02:53:45 +01:00
|
|
|
int f2fs_map_blocks(struct inode *, struct f2fs_map_blocks *, int, int);
|
2014-06-07 21:30:14 +02:00
|
|
|
int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64);
|
2015-02-05 10:44:29 +01:00
|
|
|
void f2fs_invalidate_page(struct page *, unsigned int, unsigned int);
|
|
|
|
int f2fs_release_page(struct page *, gfp_t);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* gc.c
|
|
|
|
*/
|
|
|
|
int start_gc_thread(struct f2fs_sb_info *);
|
|
|
|
void stop_gc_thread(struct f2fs_sb_info *);
|
2013-08-12 14:08:03 +02:00
|
|
|
block_t start_bidx_of_node(unsigned int, struct f2fs_inode_info *);
|
2015-10-05 16:22:44 +02:00
|
|
|
int f2fs_gc(struct f2fs_sb_info *, bool);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
void build_gc_manager(struct f2fs_sb_info *);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* recovery.c
|
|
|
|
*/
|
2013-03-20 11:01:06 +01:00
|
|
|
int recover_fsync_data(struct f2fs_sb_info *);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
bool space_for_roll_forward(struct f2fs_sb_info *);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* debug.c
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_F2FS_STAT_FS
|
|
|
|
struct f2fs_stat_info {
|
|
|
|
struct list_head stat_list;
|
|
|
|
struct f2fs_sb_info *sbi;
|
|
|
|
int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
|
|
|
|
int main_area_segs, main_area_sections, main_area_zones;
|
2015-09-30 11:38:48 +02:00
|
|
|
unsigned long long hit_largest, hit_cached, hit_rbtree;
|
|
|
|
unsigned long long hit_total, total_ext;
|
2016-01-01 00:24:14 +01:00
|
|
|
int ext_tree, zombie_tree, ext_node;
|
2015-12-17 10:14:44 +01:00
|
|
|
int ndirty_node, ndirty_meta;
|
|
|
|
int ndirty_dent, ndirty_dirs, ndirty_data, ndirty_files;
|
2015-01-07 20:09:37 +01:00
|
|
|
int nats, dirty_nats, sits, dirty_sits, fnids;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int total_count, utilization;
|
2015-07-15 11:28:53 +02:00
|
|
|
int bg_gc, inmem_pages, wb_pages;
|
|
|
|
int inline_xattr, inline_inode, inline_dir;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
unsigned int valid_count, valid_node_count, valid_inode_count;
|
|
|
|
unsigned int bimodal, avg_vblocks;
|
|
|
|
int util_free, util_valid, util_invalid;
|
|
|
|
int rsvd_segs, overp_segs;
|
|
|
|
int dirty_count, node_pages, meta_pages;
|
2016-01-09 22:45:17 +01:00
|
|
|
int prefree_count, call_count, cp_count, bg_cp_count;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int tot_segs, node_segs, data_segs, free_segs, free_secs;
|
2014-12-23 00:37:39 +01:00
|
|
|
int bg_node_segs, bg_data_segs;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int tot_blks, data_blks, node_blks;
|
2014-12-23 00:37:39 +01:00
|
|
|
int bg_data_blks, bg_node_blks;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
int curseg[NR_CURSEG_TYPE];
|
|
|
|
int cursec[NR_CURSEG_TYPE];
|
|
|
|
int curzone[NR_CURSEG_TYPE];
|
|
|
|
|
|
|
|
unsigned int segment_count[2];
|
|
|
|
unsigned int block_count[2];
|
2014-12-23 18:16:54 +01:00
|
|
|
unsigned int inplace_count;
|
2015-09-11 08:43:52 +02:00
|
|
|
unsigned long long base_mem, cache_mem, page_mem;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
};
|
|
|
|
|
2013-07-12 08:47:11 +02:00
|
|
|
static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
|
|
|
|
{
|
2014-01-17 21:44:39 +01:00
|
|
|
return (struct f2fs_stat_info *)sbi->stat_info;
|
2013-07-12 08:47:11 +02:00
|
|
|
}
|
|
|
|
|
2014-02-13 07:12:29 +01:00
|
|
|
#define stat_inc_cp_count(si) ((si)->cp_count++)
|
2016-01-09 22:45:17 +01:00
|
|
|
#define stat_inc_bg_cp_count(si) ((si)->bg_cp_count++)
|
2013-10-22 13:56:10 +02:00
|
|
|
#define stat_inc_call_count(si) ((si)->call_count++)
|
|
|
|
#define stat_inc_bggc_count(sbi) ((sbi)->bg_gc++)
|
2015-12-17 10:14:44 +01:00
|
|
|
#define stat_inc_dirty_inode(sbi, type) ((sbi)->ndirty_inode[type]++)
|
|
|
|
#define stat_dec_dirty_inode(sbi, type) ((sbi)->ndirty_inode[type]--)
|
2015-09-30 11:38:48 +02:00
|
|
|
#define stat_inc_total_hit(sbi) (atomic64_inc(&(sbi)->total_hit_ext))
|
|
|
|
#define stat_inc_rbtree_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_rbtree))
|
|
|
|
#define stat_inc_largest_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_largest))
|
|
|
|
#define stat_inc_cached_node_hit(sbi) (atomic64_inc(&(sbi)->read_hit_cached))
|
2015-07-15 11:28:53 +02:00
|
|
|
#define stat_inc_inline_xattr(inode) \
|
|
|
|
do { \
|
|
|
|
if (f2fs_has_inline_xattr(inode)) \
|
|
|
|
(atomic_inc(&F2FS_I_SB(inode)->inline_xattr)); \
|
|
|
|
} while (0)
|
|
|
|
#define stat_dec_inline_xattr(inode) \
|
|
|
|
do { \
|
|
|
|
if (f2fs_has_inline_xattr(inode)) \
|
|
|
|
(atomic_dec(&F2FS_I_SB(inode)->inline_xattr)); \
|
|
|
|
} while (0)
|
2013-11-26 03:08:57 +01:00
|
|
|
#define stat_inc_inline_inode(inode) \
|
|
|
|
do { \
|
|
|
|
if (f2fs_has_inline_data(inode)) \
|
2014-12-08 12:08:20 +01:00
|
|
|
(atomic_inc(&F2FS_I_SB(inode)->inline_inode)); \
|
2013-11-26 03:08:57 +01:00
|
|
|
} while (0)
|
|
|
|
#define stat_dec_inline_inode(inode) \
|
|
|
|
do { \
|
|
|
|
if (f2fs_has_inline_data(inode)) \
|
2014-12-08 12:08:20 +01:00
|
|
|
(atomic_dec(&F2FS_I_SB(inode)->inline_inode)); \
|
2013-11-26 03:08:57 +01:00
|
|
|
} while (0)
|
2014-10-14 05:00:16 +02:00
|
|
|
#define stat_inc_inline_dir(inode) \
|
|
|
|
do { \
|
|
|
|
if (f2fs_has_inline_dentry(inode)) \
|
2014-12-08 12:08:20 +01:00
|
|
|
(atomic_inc(&F2FS_I_SB(inode)->inline_dir)); \
|
2014-10-14 05:00:16 +02:00
|
|
|
} while (0)
|
|
|
|
#define stat_dec_inline_dir(inode) \
|
|
|
|
do { \
|
|
|
|
if (f2fs_has_inline_dentry(inode)) \
|
2014-12-08 12:08:20 +01:00
|
|
|
(atomic_dec(&F2FS_I_SB(inode)->inline_dir)); \
|
2014-10-14 05:00:16 +02:00
|
|
|
} while (0)
|
2013-10-22 13:56:10 +02:00
|
|
|
#define stat_inc_seg_type(sbi, curseg) \
|
|
|
|
((sbi)->segment_count[(curseg)->alloc_type]++)
|
|
|
|
#define stat_inc_block_count(sbi, curseg) \
|
|
|
|
((sbi)->block_count[(curseg)->alloc_type]++)
|
2014-12-23 18:16:54 +01:00
|
|
|
#define stat_inc_inplace_blocks(sbi) \
|
|
|
|
(atomic_inc(&(sbi)->inplace_count))
|
2014-12-23 00:37:39 +01:00
|
|
|
#define stat_inc_seg_count(sbi, type, gc_type) \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
do { \
|
2013-07-12 08:47:11 +02:00
|
|
|
struct f2fs_stat_info *si = F2FS_STAT(sbi); \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
(si)->tot_segs++; \
|
2014-12-23 00:37:39 +01:00
|
|
|
if (type == SUM_TYPE_DATA) { \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
si->data_segs++; \
|
2014-12-23 00:37:39 +01:00
|
|
|
si->bg_data_segs += (gc_type == BG_GC) ? 1 : 0; \
|
|
|
|
} else { \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
si->node_segs++; \
|
2014-12-23 00:37:39 +01:00
|
|
|
si->bg_node_segs += (gc_type == BG_GC) ? 1 : 0; \
|
|
|
|
} \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define stat_inc_tot_blk_count(si, blks) \
|
|
|
|
(si->tot_blks += (blks))
|
|
|
|
|
2014-12-23 00:37:39 +01:00
|
|
|
#define stat_inc_data_blk_count(sbi, blks, gc_type) \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
do { \
|
2013-07-12 08:47:11 +02:00
|
|
|
struct f2fs_stat_info *si = F2FS_STAT(sbi); \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
stat_inc_tot_blk_count(si, blks); \
|
|
|
|
si->data_blks += (blks); \
|
2014-12-23 00:37:39 +01:00
|
|
|
si->bg_data_blks += (gc_type == BG_GC) ? (blks) : 0; \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
} while (0)
|
|
|
|
|
2014-12-23 00:37:39 +01:00
|
|
|
#define stat_inc_node_blk_count(sbi, blks, gc_type) \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
do { \
|
2013-07-12 08:47:11 +02:00
|
|
|
struct f2fs_stat_info *si = F2FS_STAT(sbi); \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
stat_inc_tot_blk_count(si, blks); \
|
|
|
|
si->node_blks += (blks); \
|
2014-12-23 00:37:39 +01:00
|
|
|
si->bg_node_blks += (gc_type == BG_GC) ? (blks) : 0; \
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
int f2fs_build_stats(struct f2fs_sb_info *);
|
|
|
|
void f2fs_destroy_stats(struct f2fs_sb_info *);
|
2015-10-29 02:13:04 +01:00
|
|
|
int __init f2fs_create_root_stats(void);
|
2013-01-15 11:58:47 +01:00
|
|
|
void f2fs_destroy_root_stats(void);
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
#else
|
2014-02-13 07:12:29 +01:00
|
|
|
#define stat_inc_cp_count(si)
|
2016-01-09 22:45:17 +01:00
|
|
|
#define stat_inc_bg_cp_count(si)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
#define stat_inc_call_count(si)
|
2013-10-22 13:56:10 +02:00
|
|
|
#define stat_inc_bggc_count(si)
|
2015-12-17 10:14:44 +01:00
|
|
|
#define stat_inc_dirty_inode(sbi, type)
|
|
|
|
#define stat_dec_dirty_inode(sbi, type)
|
2013-10-22 13:56:10 +02:00
|
|
|
#define stat_inc_total_hit(sb)
|
2015-08-19 13:13:25 +02:00
|
|
|
#define stat_inc_rbtree_node_hit(sb)
|
2015-08-19 13:12:20 +02:00
|
|
|
#define stat_inc_largest_node_hit(sbi)
|
|
|
|
#define stat_inc_cached_node_hit(sbi)
|
2015-07-15 11:28:53 +02:00
|
|
|
#define stat_inc_inline_xattr(inode)
|
|
|
|
#define stat_dec_inline_xattr(inode)
|
2013-11-26 03:08:57 +01:00
|
|
|
#define stat_inc_inline_inode(inode)
|
|
|
|
#define stat_dec_inline_inode(inode)
|
2014-10-14 05:00:16 +02:00
|
|
|
#define stat_inc_inline_dir(inode)
|
|
|
|
#define stat_dec_inline_dir(inode)
|
2013-10-22 13:56:10 +02:00
|
|
|
#define stat_inc_seg_type(sbi, curseg)
|
|
|
|
#define stat_inc_block_count(sbi, curseg)
|
2014-12-23 18:16:54 +01:00
|
|
|
#define stat_inc_inplace_blocks(sbi)
|
2014-12-23 00:37:39 +01:00
|
|
|
#define stat_inc_seg_count(sbi, type, gc_type)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
#define stat_inc_tot_blk_count(si, blks)
|
2014-12-23 00:37:39 +01:00
|
|
|
#define stat_inc_data_blk_count(sbi, blks, gc_type)
|
|
|
|
#define stat_inc_node_blk_count(sbi, blks, gc_type)
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
|
|
|
|
static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
|
|
|
|
static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
|
2015-10-29 02:13:04 +01:00
|
|
|
static inline int __init f2fs_create_root_stats(void) { return 0; }
|
2013-01-15 11:58:47 +01:00
|
|
|
static inline void f2fs_destroy_root_stats(void) { }
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
extern const struct file_operations f2fs_dir_operations;
|
|
|
|
extern const struct file_operations f2fs_file_operations;
|
|
|
|
extern const struct inode_operations f2fs_file_inode_operations;
|
|
|
|
extern const struct address_space_operations f2fs_dblock_aops;
|
|
|
|
extern const struct address_space_operations f2fs_node_aops;
|
|
|
|
extern const struct address_space_operations f2fs_meta_aops;
|
|
|
|
extern const struct inode_operations f2fs_dir_inode_operations;
|
|
|
|
extern const struct inode_operations f2fs_symlink_inode_operations;
|
2015-04-30 00:10:53 +02:00
|
|
|
extern const struct inode_operations f2fs_encrypted_symlink_inode_operations;
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
extern const struct inode_operations f2fs_special_inode_operations;
|
2015-02-11 01:23:12 +01:00
|
|
|
extern struct kmem_cache *inode_entry_slab;
|
2013-11-10 16:13:16 +01:00
|
|
|
|
2013-11-10 16:13:19 +01:00
|
|
|
/*
|
|
|
|
* inline.c
|
|
|
|
*/
|
2015-04-23 19:27:21 +02:00
|
|
|
bool f2fs_may_inline_data(struct inode *);
|
|
|
|
bool f2fs_may_inline_dentry(struct inode *);
|
2014-10-24 04:48:09 +02:00
|
|
|
void read_inline_data(struct page *, struct page *);
|
2015-03-10 06:16:25 +01:00
|
|
|
bool truncate_inline_inode(struct page *, u64);
|
2013-11-10 16:13:19 +01:00
|
|
|
int f2fs_read_inline_data(struct inode *, struct page *);
|
2014-10-24 04:48:09 +02:00
|
|
|
int f2fs_convert_inline_page(struct dnode_of_data *, struct page *);
|
|
|
|
int f2fs_convert_inline_inode(struct inode *);
|
|
|
|
int f2fs_write_inline_data(struct inode *, struct page *);
|
2014-08-08 01:57:17 +02:00
|
|
|
bool recover_inline_data(struct inode *, struct page *);
|
2015-04-28 02:12:39 +02:00
|
|
|
struct f2fs_dir_entry *find_in_inline_dir(struct inode *,
|
|
|
|
struct f2fs_filename *, struct page **);
|
2014-09-24 12:17:53 +02:00
|
|
|
struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *, struct page **);
|
|
|
|
int make_empty_inline_dir(struct inode *inode, struct inode *, struct page *);
|
2015-03-31 00:07:16 +02:00
|
|
|
int f2fs_add_inline_entry(struct inode *, const struct qstr *, struct inode *,
|
|
|
|
nid_t, umode_t);
|
2014-09-24 12:17:53 +02:00
|
|
|
void f2fs_delete_inline_entry(struct f2fs_dir_entry *, struct page *,
|
|
|
|
struct inode *, struct inode *);
|
|
|
|
bool f2fs_empty_inline_dir(struct inode *);
|
2015-04-28 01:26:24 +02:00
|
|
|
int f2fs_read_inline_dir(struct file *, struct dir_context *,
|
|
|
|
struct f2fs_str *);
|
2015-10-15 20:34:49 +02:00
|
|
|
int f2fs_inline_data_fiemap(struct inode *,
|
|
|
|
struct fiemap_extent_info *, __u64, __u64);
|
2015-04-20 22:57:51 +02:00
|
|
|
|
2015-06-19 21:01:21 +02:00
|
|
|
/*
|
|
|
|
* shrinker.c
|
|
|
|
*/
|
|
|
|
unsigned long f2fs_shrink_count(struct shrinker *, struct shrink_control *);
|
|
|
|
unsigned long f2fs_shrink_scan(struct shrinker *, struct shrink_control *);
|
|
|
|
void f2fs_join_shrinker(struct f2fs_sb_info *);
|
|
|
|
void f2fs_leave_shrinker(struct f2fs_sb_info *);
|
|
|
|
|
2015-07-08 11:59:36 +02:00
|
|
|
/*
|
|
|
|
* extent_cache.c
|
|
|
|
*/
|
|
|
|
unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *, int);
|
2015-12-28 20:39:06 +01:00
|
|
|
bool f2fs_init_extent_tree(struct inode *, struct f2fs_extent *);
|
2015-07-08 11:59:36 +02:00
|
|
|
unsigned int f2fs_destroy_extent_node(struct inode *);
|
|
|
|
void f2fs_destroy_extent_tree(struct inode *);
|
|
|
|
bool f2fs_lookup_extent_cache(struct inode *, pgoff_t, struct extent_info *);
|
|
|
|
void f2fs_update_extent_cache(struct dnode_of_data *);
|
f2fs: update extent tree in batches
This patch introduce a new helper f2fs_update_extent_tree_range which can
do extent mapping update at a specified range.
The main idea is:
1) punch all mapping info in extent node(s) which are at a specified range;
2) try to merge new extent mapping with adjacent node, or failing that,
insert the mapping into extent tree as a new node.
In order to see the benefit, I add a function for stating time stamping
count as below:
uint64_t rdtsc(void)
{
uint32_t lo, hi;
__asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
return (uint64_t)hi << 32 | lo;
}
My test environment is: ubuntu, intel i7-3770, 16G memory, 256g micron ssd.
truncation path: update extent cache from truncate_data_blocks_range
non-truncataion path: update extent cache from other paths
total: all update paths
a) Removing 128MB file which has one extent node mapping whole range of
file:
1. dd if=/dev/zero of=/mnt/f2fs/128M bs=1M count=128
2. sync
3. rm /mnt/f2fs/128M
Before:
total count average
truncation: 7651022 32768 233.49
Patched:
total count average
truncation: 3321 33 100.64
b) fsstress:
fsstress -d /mnt/f2fs -l 5 -n 100 -p 20
Test times: 5 times.
Before:
total count average
truncation: 5812480.6 20911.6 277.95
non-truncation: 7783845.6 13440.8 579.12
total: 13596326.2 34352.4 395.79
Patched:
total count average
truncation: 1281283.0 3041.6 421.25
non-truncation: 7355844.4 13662.8 538.38
total: 8637127.4 16704.4 517.06
1) For the updates in truncation path:
- we can see updating in batches leads total tsc and update count reducing
explicitly;
- besides, for a single batched updating, punching multiple extent nodes
in a loop, result in executing more operations, so our average tsc
increase intensively.
2) For the updates in non-truncation path:
- there is a little improvement, that is because for the scenario that we
just need to update in the head or tail of extent node, new interface
optimize to update info in extent node directly, rather than removing
original extent node for updating and then inserting that updated one
into cache as new node.
Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
2015-08-26 14:34:48 +02:00
|
|
|
void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
|
|
|
|
pgoff_t, block_t, unsigned int);
|
2015-07-08 11:59:36 +02:00
|
|
|
void init_extent_cache_info(struct f2fs_sb_info *);
|
|
|
|
int __init create_extent_cache(void);
|
|
|
|
void destroy_extent_cache(void);
|
|
|
|
|
2015-04-20 22:57:51 +02:00
|
|
|
/*
|
|
|
|
* crypto support
|
|
|
|
*/
|
|
|
|
static inline int f2fs_encrypted_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_F2FS_FS_ENCRYPTION
|
|
|
|
return file_is_encrypt(inode);
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void f2fs_set_encrypted_inode(struct inode *inode)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_F2FS_FS_ENCRYPTION
|
|
|
|
file_set_encrypt(inode);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool f2fs_bio_encrypted(struct bio *bio)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_F2FS_FS_ENCRYPTION
|
|
|
|
return unlikely(bio->bi_private != NULL);
|
|
|
|
#else
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int f2fs_sb_has_crypto(struct super_block *sb)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_F2FS_FS_ENCRYPTION
|
|
|
|
return F2FS_HAS_FEATURE(sb, F2FS_FEATURE_ENCRYPT);
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
2015-04-21 00:19:06 +02:00
|
|
|
|
2015-04-22 05:39:58 +02:00
|
|
|
static inline bool f2fs_may_encrypt(struct inode *inode)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_F2FS_FS_ENCRYPTION
|
2015-12-05 09:56:06 +01:00
|
|
|
umode_t mode = inode->i_mode;
|
2015-04-22 05:39:58 +02:00
|
|
|
|
|
|
|
return (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode));
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-04-21 00:19:06 +02:00
|
|
|
/* crypto_policy.c */
|
|
|
|
int f2fs_is_child_context_consistent_with_parent(struct inode *,
|
|
|
|
struct inode *);
|
|
|
|
int f2fs_inherit_context(struct inode *, struct inode *, struct page *);
|
|
|
|
int f2fs_process_policy(const struct f2fs_encryption_policy *, struct inode *);
|
|
|
|
int f2fs_get_policy(struct inode *, struct f2fs_encryption_policy *);
|
2015-04-21 04:52:47 +02:00
|
|
|
|
|
|
|
/* crypt.c */
|
2015-05-12 22:26:54 +02:00
|
|
|
extern struct kmem_cache *f2fs_crypt_info_cachep;
|
2015-04-21 04:52:47 +02:00
|
|
|
bool f2fs_valid_contents_enc_mode(uint32_t);
|
|
|
|
uint32_t f2fs_validate_encryption_key_size(uint32_t, uint32_t);
|
|
|
|
struct f2fs_crypto_ctx *f2fs_get_crypto_ctx(struct inode *);
|
|
|
|
void f2fs_release_crypto_ctx(struct f2fs_crypto_ctx *);
|
|
|
|
struct page *f2fs_encrypt(struct inode *, struct page *);
|
|
|
|
int f2fs_decrypt(struct f2fs_crypto_ctx *, struct page *);
|
|
|
|
int f2fs_decrypt_one(struct inode *, struct page *);
|
|
|
|
void f2fs_end_io_crypto_work(struct f2fs_crypto_ctx *, struct bio *);
|
|
|
|
|
2015-04-22 01:23:47 +02:00
|
|
|
/* crypto_key.c */
|
2015-05-20 07:26:54 +02:00
|
|
|
void f2fs_free_encryption_info(struct inode *, struct f2fs_crypt_info *);
|
2015-04-22 01:23:47 +02:00
|
|
|
int _f2fs_get_encryption_info(struct inode *inode);
|
|
|
|
|
2015-04-26 09:12:50 +02:00
|
|
|
/* crypto_fname.c */
|
|
|
|
bool f2fs_valid_filenames_enc_mode(uint32_t);
|
|
|
|
u32 f2fs_fname_crypto_round_up(u32, u32);
|
|
|
|
int f2fs_fname_crypto_alloc_buffer(struct inode *, u32, struct f2fs_str *);
|
|
|
|
int f2fs_fname_disk_to_usr(struct inode *, f2fs_hash_t *,
|
|
|
|
const struct f2fs_str *, struct f2fs_str *);
|
|
|
|
int f2fs_fname_usr_to_disk(struct inode *, const struct qstr *,
|
|
|
|
struct f2fs_str *);
|
|
|
|
|
2015-04-21 04:52:47 +02:00
|
|
|
#ifdef CONFIG_F2FS_FS_ENCRYPTION
|
|
|
|
void f2fs_restore_and_release_control_page(struct page **);
|
|
|
|
void f2fs_restore_control_page(struct page *);
|
|
|
|
|
2015-05-16 00:37:24 +02:00
|
|
|
int __init f2fs_init_crypto(void);
|
|
|
|
int f2fs_crypto_initialize(void);
|
2015-04-21 04:52:47 +02:00
|
|
|
void f2fs_exit_crypto(void);
|
2015-04-22 01:23:47 +02:00
|
|
|
|
|
|
|
int f2fs_has_encryption_key(struct inode *);
|
|
|
|
|
|
|
|
static inline int f2fs_get_encryption_info(struct inode *inode)
|
|
|
|
{
|
|
|
|
struct f2fs_crypt_info *ci = F2FS_I(inode)->i_crypt_info;
|
|
|
|
|
|
|
|
if (!ci ||
|
|
|
|
(ci->ci_keyring_key &&
|
|
|
|
(ci->ci_keyring_key->flags & ((1 << KEY_FLAG_INVALIDATED) |
|
|
|
|
(1 << KEY_FLAG_REVOKED) |
|
|
|
|
(1 << KEY_FLAG_DEAD)))))
|
|
|
|
return _f2fs_get_encryption_info(inode);
|
|
|
|
return 0;
|
|
|
|
}
|
2015-04-26 09:12:50 +02:00
|
|
|
|
|
|
|
void f2fs_fname_crypto_free_buffer(struct f2fs_str *);
|
|
|
|
int f2fs_fname_setup_filename(struct inode *, const struct qstr *,
|
|
|
|
int lookup, struct f2fs_filename *);
|
|
|
|
void f2fs_fname_free_filename(struct f2fs_filename *);
|
2015-04-21 04:52:47 +02:00
|
|
|
#else
|
|
|
|
static inline void f2fs_restore_and_release_control_page(struct page **p) { }
|
|
|
|
static inline void f2fs_restore_control_page(struct page *p) { }
|
|
|
|
|
2015-05-16 00:37:24 +02:00
|
|
|
static inline int __init f2fs_init_crypto(void) { return 0; }
|
2015-04-21 04:52:47 +02:00
|
|
|
static inline void f2fs_exit_crypto(void) { }
|
2015-04-22 01:23:47 +02:00
|
|
|
|
|
|
|
static inline int f2fs_has_encryption_key(struct inode *i) { return 0; }
|
|
|
|
static inline int f2fs_get_encryption_info(struct inode *i) { return 0; }
|
2015-04-26 09:12:50 +02:00
|
|
|
static inline void f2fs_fname_crypto_free_buffer(struct f2fs_str *p) { }
|
|
|
|
|
|
|
|
static inline int f2fs_fname_setup_filename(struct inode *dir,
|
|
|
|
const struct qstr *iname,
|
|
|
|
int lookup, struct f2fs_filename *fname)
|
|
|
|
{
|
|
|
|
memset(fname, 0, sizeof(struct f2fs_filename));
|
|
|
|
fname->usr_fname = iname;
|
|
|
|
fname->disk_name.name = (unsigned char *)iname->name;
|
|
|
|
fname->disk_name.len = iname->len;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void f2fs_fname_free_filename(struct f2fs_filename *fname) { }
|
2015-04-21 04:52:47 +02:00
|
|
|
#endif
|
f2fs: add superblock and major in-memory structure
This adds the following major in-memory structures in f2fs.
- f2fs_sb_info:
contains f2fs-specific information, two special inode pointers for node and
meta address spaces, and orphan inode management.
- f2fs_inode_info:
contains vfs_inode and other fs-specific information.
- f2fs_nm_info:
contains node manager information such as NAT entry cache, free nid list,
and NAT page management.
- f2fs_node_info:
represents a node as node id, inode number, block address, and its version.
- f2fs_sm_info:
contains segment manager information such as SIT entry cache, free segment
map, current active logs, dirty segment management, and segment utilization.
The specific structures are sit_info, free_segmap_info, dirty_seglist_info,
curseg_info.
In addition, add F2FS_SUPER_MAGIC in magic.h.
Signed-off-by: Chul Lee <chur.lee@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>
2012-11-28 05:37:31 +01:00
|
|
|
#endif
|