f2fs.h 63 KB
Newer Older
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 * 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>
20
#include <linux/kobject.h>
21
#include <linux/sched.h>
22

23
#ifdef CONFIG_F2FS_CHECK_FS
24
#define f2fs_bug_on(sbi, condition)	BUG_ON(condition)
25
#define f2fs_down_write(x, y)	down_write_nest_lock(x, y)
26
#else
27 28 29 30
#define f2fs_bug_on(sbi, condition)					\
	do {								\
		if (unlikely(condition)) {				\
			WARN_ON(1);					\
31
			set_sbi_flag(sbi, SBI_NEED_FSCK);		\
32 33
		}							\
	} while (0)
34
#define f2fs_down_write(x, y)	down_write(x)
35 36
#endif

37 38 39 40 41 42 43 44 45 46
/*
 * 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
47
#define F2FS_MOUNT_INLINE_XATTR		0x00000080
48
#define F2FS_MOUNT_INLINE_DATA		0x00000100
49 50 51
#define F2FS_MOUNT_INLINE_DENTRY	0x00000200
#define F2FS_MOUNT_FLUSH_MERGE		0x00000400
#define F2FS_MOUNT_NOBARRIER		0x00000800
52
#define F2FS_MOUNT_FASTBOOT		0x00001000
53
#define F2FS_MOUNT_EXTENT_CACHE		0x00002000
54 55 56 57 58 59 60 61 62

#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))

63 64 65 66
typedef u32 block_t;	/*
			 * should not change u32, since it is the on-disk block
			 * address format, __le32.
			 */
67 68 69 70 71 72
typedef u32 nid_t;

struct f2fs_mount_info {
	unsigned int	opt;
};

73 74
#define F2FS_FEATURE_ENCRYPT	0x0001

75 76 77 78 79 80 81
#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)

Jaegeuk Kim's avatar
Jaegeuk Kim committed
82 83 84
#define CRCPOLY_LE 0xedb88320

static inline __u32 f2fs_crc32(void *buf, size_t len)
85
{
Jaegeuk Kim's avatar
Jaegeuk Kim committed
86 87 88 89 90 91 92 93 94 95
	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;
96 97
}

Jaegeuk Kim's avatar
Jaegeuk Kim committed
98
static inline bool f2fs_crc_valid(__u32 blk_crc, void *buf, size_t buf_size)
99
{
Jaegeuk Kim's avatar
Jaegeuk Kim committed
100
	return f2fs_crc32(buf, buf_size) == blk_crc;
101 102 103 104 105 106 107 108 109 110
}

/*
 * For checkpoint manager
 */
enum {
	NAT_BITMAP,
	SIT_BITMAP
};

111 112
enum {
	CP_UMOUNT,
113
	CP_FASTBOOT,
114
	CP_SYNC,
115
	CP_RECOVERY,
116
	CP_DISCARD,
117 118
};

Jaegeuk Kim's avatar
Jaegeuk Kim committed
119 120 121
#define DEF_BATCHED_TRIM_SECTIONS	32
#define BATCHED_TRIM_SEGMENTS(sbi)	\
		(SM_I(sbi)->trim_sections * (sbi)->segs_per_sec)
122 123
#define BATCHED_TRIM_BLOCKS(sbi)	\
		(BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
124

125 126
struct cp_control {
	int reason;
127 128 129 130
	__u64 trim_start;
	__u64 trim_end;
	__u64 trim_minlen;
	__u64 trimmed;
131 132
};

133
/*
134
 * For CP/NAT/SIT/SSA readahead
135 136 137 138
 */
enum {
	META_CP,
	META_NAT,
139
	META_SIT,
140 141
	META_SSA,
	META_POR,
142 143
};

144 145 146
/* for the list of ino */
enum {
	ORPHAN_INO,		/* for orphan ino list */
147 148
	APPEND_INO,		/* for append ino list */
	UPDATE_INO,		/* for update ino list */
149 150 151 152
	MAX_INO_ENTRY,		/* max. list */
};

struct ino_entry {
153 154 155 156
	struct list_head list;	/* list head */
	nid_t ino;		/* inode number */
};

157 158 159 160 161 162 163 164
/*
 * for the list of directory inodes or gc inodes.
 * NOTE: there are two slab users for this structure, if we add/modify/delete
 * fields in structure for one of slab users, it may affect fields or size of
 * other one, in this condition, it's better to split both of slab and related
 * data structure.
 */
struct inode_entry {
165 166 167 168
	struct list_head list;	/* list head */
	struct inode *inode;	/* vfs inode pointer */
};

169 170 171 172 173 174 175
/* 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 */
};

176 177 178 179
/* 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 */
180 181 182
	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 */
183 184 185 186 187 188 189 190 191 192
};

#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)

193 194 195
#define MAX_NAT_JENTRIES(sum)	(NAT_JOURNAL_ENTRIES - nats_in_cursum(sum))
#define MAX_SIT_JENTRIES(sum)	(SIT_JOURNAL_ENTRIES - sits_in_cursum(sum))

196 197 198 199 200 201 202 203 204 205 206 207 208 209
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;
}

210 211 212 213
static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,
								int type)
{
	if (type == NAT_JOURNAL)
214 215
		return size <= MAX_NAT_JENTRIES(sum);
	return size <= MAX_SIT_JENTRIES(sum);
216 217
}

218 219 220
/*
 * ioctl commands
 */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
221 222
#define F2FS_IOC_GETFLAGS		FS_IOC_GETFLAGS
#define F2FS_IOC_SETFLAGS		FS_IOC_SETFLAGS
223
#define F2FS_IOC_GETVERSION		FS_IOC_GETVERSION
Jaegeuk Kim's avatar
Jaegeuk Kim committed
224 225 226 227

#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)
228
#define F2FS_IOC_START_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 3)
229 230
#define F2FS_IOC_RELEASE_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 4)
#define F2FS_IOC_ABORT_VOLATILE_WRITE	_IO(F2FS_IOCTL_MAGIC, 5)
231

232 233 234 235 236 237 238
#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)

Jaegeuk Kim's avatar
Jaegeuk Kim committed
239 240 241 242 243 244 245 246 247
/*
 * 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 */

248 249 250 251 252 253 254 255
#if defined(__KERNEL__) && defined(CONFIG_COMPAT)
/*
 * ioctl commands in 32 bit emulation
 */
#define F2FS_IOC32_GETFLAGS             FS_IOC32_GETFLAGS
#define F2FS_IOC32_SETFLAGS             FS_IOC32_SETFLAGS
#endif

256 257 258
/*
 * For INODE and NODE manager
 */
259
/* for directory operations */
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
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)

279
struct f2fs_dentry_ptr {
280
	struct inode *inode;
281 282 283 284 285 286
	const void *bitmap;
	struct f2fs_dir_entry *dentry;
	__u8 (*filename)[F2FS_SLOT_LEN];
	int max;
};

287 288
static inline void make_dentry_ptr(struct inode *inode,
		struct f2fs_dentry_ptr *d, void *src, int type)
289
{
290 291
	d->inode = inode;

292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
	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;
	}
}

307 308 309 310 311 312 313
/*
 * 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)
314 315 316 317 318
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
Chao Yu's avatar
Chao Yu committed
319
					 * by get_data_block.
320
					 */
321 322
};

323 324
#define F2FS_LINK_MAX		32000	/* maximum link count per file */

325 326
#define MAX_DIR_RA_PAGES	4	/* maximum ra pages of dir */

327 328 329
/* vector size for gang look-up from extent cache that consists of radix tree */
#define EXT_TREE_VEC_SIZE	64

330
/* for in-memory extent cache entry */
331 332 333 334
#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
335

336
struct extent_info {
337 338 339 340 341 342 343 344 345 346 347 348 349 350
	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 */
351
	struct extent_node *cached_en;	/* recently accessed extent node */
352 353 354
	rwlock_t lock;			/* protect extent info rb-tree */
	atomic_t refcount;		/* reference count of rb-tree */
	unsigned int count;		/* # of extent node in rb-tree*/
355 356
};

Jaegeuk Kim's avatar
Jaegeuk Kim committed
357 358 359 360 361 362 363
/*
 * 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)
364 365 366
#define F2FS_MAP_UNWRITTEN	(1 << BH_Unwritten)
#define F2FS_MAP_FLAGS		(F2FS_MAP_NEW | F2FS_MAP_MAPPED |\
				F2FS_MAP_UNWRITTEN)
Jaegeuk Kim's avatar
Jaegeuk Kim committed
367 368 369 370 371 372 373 374

struct f2fs_map_blocks {
	block_t m_pblk;
	block_t m_lblk;
	unsigned int m_len;
	unsigned int m_flags;
};

375 376 377 378
/*
 * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
 */
#define FADVISE_COLD_BIT	0x01
379
#define FADVISE_LOST_PINO_BIT	0x02
380
#define FADVISE_ENCRYPT_BIT	0x04
381
#define FADVISE_ENC_NAME_BIT	0x08
382

383 384 385 386 387 388
#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)
389 390 391
#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)
392 393
#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)
394 395 396 397 398 399 400

/* 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
401

402 403
#include "f2fs_crypto.h"

404 405
#define DEF_DIR_LEVEL		0

406 407 408 409
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 */
410
	unsigned char i_dir_level;	/* use for dentry level for large dir */
411
	unsigned int i_current_depth;	/* use only in directory structure */
412
	unsigned int i_pino;		/* parent inode number */
413 414 415 416
	umode_t i_acl_mode;		/* keep file acl mode temporarily */

	/* Use below internally in f2fs*/
	unsigned long flags;		/* use to pass per-file flags */
417
	struct rw_semaphore i_sem;	/* protect fi info */
418
	atomic_t dirty_pages;		/* # of dirty pages */
419 420 421
	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 */
422
	unsigned long long xattr_ver;	/* cp version of xattr modification */
423
	struct extent_info ext;		/* in-memory extent cache entry */
424
	rwlock_t ext_lock;		/* rwlock for single extent cache */
425
	struct inode_entry *dirty_dir;	/* the pointer of dirty dir */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
426

427
	struct radix_tree_root inmem_root;	/* radix tree for inmem pages */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
428 429
	struct list_head inmem_pages;	/* inmemory pages managed by f2fs */
	struct mutex inmem_lock;	/* lock for inmemory pages */
430 431 432 433 434

#ifdef CONFIG_F2FS_FS_ENCRYPTION
	/* Encryption params */
	struct f2fs_crypt_info *i_crypt_info;
#endif
435 436 437 438 439 440
};

static inline void get_extent_info(struct extent_info *ext,
					struct f2fs_extent i_ext)
{
	ext->fofs = le32_to_cpu(i_ext.fofs);
441
	ext->blk = le32_to_cpu(i_ext.blk);
442 443 444 445 446 447 448
	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);
449
	i_ext->blk = cpu_to_le32(ext->blk);
450 451 452
	i_ext->len = cpu_to_le32(ext->len);
}

453 454 455 456 457 458 459 460
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;
}

461 462 463 464 465 466 467
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);
}

468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
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);
}

487 488 489
struct f2fs_nm_info {
	block_t nat_blkaddr;		/* base disk address of NAT */
	nid_t max_nid;			/* maximum possible node ids */
490
	nid_t available_nids;		/* maximum available node ids */
491
	nid_t next_scan_nid;		/* the next nid to be scanned */
492
	unsigned int ram_thresh;	/* control the memory footprint */
493 494 495

	/* NAT cache management */
	struct radix_tree_root nat_root;/* root of the nat entry cache */
496
	struct radix_tree_root nat_set_root;/* root of the nat set cache */
497
	struct rw_semaphore nat_tree_lock;	/* protect nat_tree_lock */
498
	struct list_head nat_entries;	/* cached nat entry list (clean) */
499
	unsigned int nat_cnt;		/* the # of cached nat entries */
500
	unsigned int dirty_nat_cnt;	/* total num of nat entries in set */
501 502

	/* free node ids management */
503
	struct radix_tree_root free_nid_root;/* root of the free_nid cache */
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
	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 */
	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)
{
532
	memset(dn, 0, sizeof(*dn));
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
	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 */
563 564
	NO_CHECK_TYPE,
	CURSEG_DIRECT_IO,	/* to use for the direct IO path */
565 566
};

567 568
struct flush_cmd {
	struct completion wait;
569
	struct llist_node llnode;
570 571 572
	int ret;
};

573 574 575
struct flush_cmd_control {
	struct task_struct *f2fs_issue_flush;	/* flush thread */
	wait_queue_head_t flush_wait_queue;	/* waiting queue for wake-up */
576 577
	struct llist_head issue_list;		/* list for command issue */
	struct llist_node *dispatch_list;	/* list for command dispatch */
578 579
};

580 581 582 583 584 585 586 587 588 589 590 591 592 593
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 */
594 595 596

	/* a threshold to reclaim prefree segments */
	unsigned int rec_prefree_segments;
597 598 599 600 601

	/* 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 */
602

Jaegeuk Kim's avatar
Jaegeuk Kim committed
603 604 605
	/* for batched trimming */
	unsigned int trim_sections;		/* # of sections to trim */

606 607
	struct list_head sit_entry_set;	/* sit entry set list */

608 609
	unsigned int ipu_policy;	/* in-place-update policy */
	unsigned int min_ipu_util;	/* in-place-update threshold */
610
	unsigned int min_fsync_blocks;	/* threshold for fsync */
611 612

	/* for flush command control */
613 614
	struct flush_cmd_control *cmd_control_info;

615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
};

/*
 * 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,
	F2FS_DIRTY_NODES,
	F2FS_DIRTY_META,
631
	F2FS_INMEM_PAGES,
632 633 634 635
	NR_COUNT_TYPE,
};

/*
arter97's avatar
arter97 committed
636
 * The below are the page types of bios used in submit_bio().
637 638 639 640 641 642 643 644 645
 * 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.
 */
646
#define PAGE_TYPE_OF_BIO(type)	((type) > META ? META : (type))
647 648 649 650 651 652
enum page_type {
	DATA,
	NODE,
	META,
	NR_PAGE_TYPE,
	META_FLUSH,
653 654 655 656
	INMEM,		/* the below types are used by tracepoints only. */
	INMEM_DROP,
	IPU,
	OPU,
657 658
};

Jaegeuk Kim's avatar
Jaegeuk Kim committed
659
struct f2fs_io_info {
660
	struct f2fs_sb_info *sbi;	/* f2fs_sb_info pointer */
661 662
	enum page_type type;	/* contains DATA/NODE/META/META_FLUSH */
	int rw;			/* contains R/RS/W/WS with REQ_META/REQ_PRIO */
663
	block_t blk_addr;	/* block address to be written */
664
	struct page *page;	/* page to be written */
665
	struct page *encrypted_page;	/* encrypted page */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
666 667
};

668
#define is_read_io(rw)	(((rw) & 1) == READ)
669
struct f2fs_bio_info {
Jaegeuk Kim's avatar
Jaegeuk Kim committed
670
	struct f2fs_sb_info *sbi;	/* f2fs superblock */
671 672
	struct bio *bio;		/* bios to merge */
	sector_t last_block_in_bio;	/* last block number */
Jaegeuk Kim's avatar
Jaegeuk Kim committed
673
	struct f2fs_io_info fio;	/* store buffered io info. */
674
	struct rw_semaphore io_rwsem;	/* blocking op for bio */
675 676
};

677 678 679 680 681 682 683 684
/* 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 */
};

685 686 687 688 689 690 691 692
/* 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 */
};

693 694
struct f2fs_sb_info {
	struct super_block *sb;			/* pointer to VFS super block */
695
	struct proc_dir_entry *s_proc;		/* proc entry */
696 697
	struct buffer_head *raw_super_buf;	/* buffer head of raw sb */
	struct f2fs_super_block *raw_super;	/* raw super block pointer */
698
	int s_flag;				/* flags for sbi */
699 700 701 702 703 704 705

	/* 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 */
706 707

	/* for bio operations */
708
	struct f2fs_bio_info read_io;			/* for read bios */
709
	struct f2fs_bio_info write_io[NR_PAGE_TYPE];	/* for write bios */
710 711 712 713

	/* for checkpoint */
	struct f2fs_checkpoint *ckpt;		/* raw checkpoint pointer */
	struct inode *meta_inode;		/* cache meta blocks */
714
	struct mutex cp_mutex;			/* checkpoint procedure lock */
715
	struct rw_semaphore cp_rwsem;		/* blocking FS operations */
716
	struct rw_semaphore node_write;		/* locking node writes */
717
	struct mutex writepages;		/* mutex for writepages() */
718
	wait_queue_head_t cp_wait;
719

720
	struct inode_management im[MAX_INO_ENTRY];      /* manage inode cache */
721 722

	/* for orphan inode, use 0'th array */
723
	unsigned int max_orphans;		/* max orphan inodes */
724 725 726 727 728

	/* for directory inode management */
	struct list_head dir_inode_list;	/* dir inode list */
	spinlock_t dir_inode_lock;		/* for dir inode list lock */

729 730 731 732 733 734 735 736
	/* 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 */
	int total_ext_tree;			/* extent tree count */
	atomic_t total_ext_node;		/* extent info count */

arter97's avatar
arter97 committed
737
	/* basic filesystem units */
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752
	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 */
	int active_logs;			/* # of active logs */
753
	int dir_level;				/* directory level */
754 755 756 757

	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 */
758
	block_t discard_blks;			/* discard command candidats */
759 760 761 762 763 764 765 766 767
	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 */
768
	unsigned int cur_victim_sec;		/* current victim section num */
769

770 771 772
	/* maximum # of trials to find a victim segment for SSR and GC */
	unsigned int max_victim_search;

773 774 775 776
	/*
	 * for stat information.
	 * one is for the LFS mode, and the other is for the SSR mode.
	 */
777
#ifdef CONFIG_F2FS_STAT_FS
778 779 780
	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 */
781
	atomic_t inplace_count;		/* # of inplace update */
782
	int total_hit_ext, read_hit_ext;	/* extent cache hit ratio */
783 784
	atomic_t inline_inode;			/* # of inline_data inodes */
	atomic_t inline_dir;			/* # of inline_dentry inodes */
785
	int bg_gc;				/* background gc calls */
786 787 788
	unsigned int n_dirty_dirs;		/* # of dir inodes */
#endif
	unsigned int last_victim[2];		/* last victim segment # */
789
	spinlock_t stat_lock;			/* lock for stat operations */
790 791 792 793

	/* For sysfs suppport */
	struct kobject s_kobj;
	struct completion s_kobj_unregister;
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
};

/*
 * 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;
}

809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
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);
}

824 825 826 827 828 829 830 831 832 833
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);
}

834 835 836 837 838
static inline struct f2fs_node *F2FS_NODE(struct page *page)
{
	return (struct f2fs_node *)page_address(page);
}

839 840 841 842 843
static inline struct f2fs_inode *F2FS_INODE(struct page *page)
{
	return &((struct f2fs_node *)page_address(page))->i;
}

844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868
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);
}

869 870 871 872 873
static inline struct address_space *META_MAPPING(struct f2fs_sb_info *sbi)
{
	return sbi->meta_inode->i_mapping;
}

874 875 876 877 878
static inline struct address_space *NODE_MAPPING(struct f2fs_sb_info *sbi)
{
	return sbi->node_inode->i_mapping;
}

879 880 881 882 883 884
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)
885
{
886
	sbi->s_flag |= (0x01 << type);
887 888
}

889
static inline void clear_sbi_flag(struct f2fs_sb_info *sbi, unsigned int type)
890
{
891
	sbi->s_flag &= ~(0x01 << type);
892 893
}

894 895 896 897 898
static inline unsigned long long cur_cp_version(struct f2fs_checkpoint *cp)
{
	return le64_to_cpu(cp->checkpoint_ver);
}

899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918
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);
}

919
static inline void f2fs_lock_op(struct f2fs_sb_info *sbi)
920
{
921
	down_read(&sbi->cp_rwsem);
922 923
}

924
static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)
925
{
926
	up_read(&sbi->cp_rwsem);
927 928
}

929
static inline void f2fs_lock_all(struct f2fs_sb_info *sbi)
930
{
931
	f2fs_down_write(&sbi->cp_rwsem, &sbi->cp_mutex);
932 933
}

934
static inline void f2fs_unlock_all(struct f2fs_sb_info *sbi)
935
{
936
	up_write(&sbi->cp_rwsem);
937 938
}

939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
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));
}

961 962 963
/*
 * Check whether the given nid is within node id range.
 */
964
static inline int check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
965
{
966 967
	if (unlikely(nid < F2FS_ROOT_INO(sbi)))
		return -EINVAL;
968
	if (unlikely(nid >= NM_I(sbi)->max_nid))
969 970
		return -EINVAL;
	return 0;
971 972 973 974 975 976 977 978 979 980
}

#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)
Chris Fries's avatar
Chris Fries committed
981
		return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1;
982
	else
Chris Fries's avatar
Chris Fries committed
983
		return inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS;
984 985
}

986 987 988 989 990
static inline bool f2fs_has_xattr_block(unsigned int ofs)
{
	return ofs == XATTR_NODE_OFFSET;
}

991 992 993 994 995 996 997 998
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;
999
	if (unlikely(valid_block_count > sbi->user_block_count)) {
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
		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;
}

1010
static inline void dec_valid_block_count(struct f2fs_sb_info *sbi,
1011 1012 1013 1014
						struct inode *inode,
						blkcnt_t count)
{
	spin_lock(&sbi->stat_lock);
1015 1016
	f2fs_bug_on(sbi, sbi->total_valid_block_count < (block_t) count);
	f2fs_bug_on(sbi, inode->i_blocks < count);
1017 1018 1019 1020 1021 1022 1023 1024
	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]);
1025
	set_sbi_flag(sbi, SBI_IS_DIRTY);
1026 1027
}

1028
static inline void inode_inc_dirty_pages(struct inode *inode)
1029
{
1030 1031 1032
	atomic_inc(&F2FS_I(inode)->dirty_pages);
	if (S_ISDIR(inode->i_mode))
		inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
1033 1034 1035 1036 1037 1038 1039
}

static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
{
	atomic_dec(&sbi->nr_pages[count_type]);
}

1040
static inline void inode_dec_dirty_pages(struct inode *inode)
1041
{
1042
	if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode))
1043 1044
		return;

1045 1046 1047 1048
	atomic_dec(&F2FS_I(inode)->dirty_pages);

	if (S_ISDIR(inode->i_mode))
		dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);
1049 1050 1051 1052 1053 1054 1055
}

static inline int get_pages(struct f2fs_sb_info *sbi, int count_type)
{
	return atomic_read(&sbi->nr_pages[count_type]);
}

1056
static inline int get_dirty_pages(struct inode *inode)
1057
{
1058
	return atomic_read(&F2FS_I(inode)->dirty_pages);
1059 1060
}

1061 1062 1063 1064 1065 1066 1067 1068
static inline int get_blocktype_secs(struct f2fs_sb_info *sbi, int block_type)
{
	unsigned int pages_per_sec = sbi->segs_per_sec *
					(1 << sbi->log_blocks_per_seg);
	return ((get_pages(sbi, block_type) + pages_per_sec - 1)
			>> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
}

1069 1070
static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
{
1071
	return sbi->total_valid_block_count;
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
}

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;
}

1087 1088 1089 1090 1091
static inline block_t __cp_payload(struct f2fs_sb_info *sbi)
{
	return le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
}

1092 1093 1094
static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
{
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
Changman Lee's avatar
Changman Lee committed
1095 1096
	int offset;

1097
	if (__cp_payload(sbi) > 0) {
Changman Lee's avatar
Changman Lee committed
1098 1099 1100
		if (flag == NAT_BITMAP)
			return &ckpt->sit_nat_version_bitmap;
		else
Jaegeuk Kim's avatar
Jaegeuk Kim committed
1101
			return (unsigned char *)ckpt + F2FS_BLKSIZE;
Changman Lee's avatar
Changman Lee committed
1102 1103
	} else {
		offset = (flag == NAT_BITMAP) ?
1104
			le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
Changman Lee's avatar
Changman Lee committed
1105 1106
		return &ckpt->sit_nat_version_bitmap + offset;
	}
1107 1108 1109 1110 1111 1112
}

static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
{
	block_t start_addr;
	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
1113
	unsigned long long ckpt_version = cur_cp_version(ckpt);
1114

1115
	start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
1116 1117 1118

	/*
	 * odd numbered checkpoint should at cp segment 0
arter97's avatar
arter97 committed
1119
	 * and even segment must be at cp segment 1