lael-labs/linux

Documentation/ABI/testing/sysfs-fs-f2fs+7−0

@@ -251,3 +251,10 @@ Description: · 250 unmodified lines
251	If checkpoint=disable, it displays the number of blocks that are unusable.	251	If checkpoint=disable, it displays the number of blocks that are unusable.
252	If checkpoint=enable it displays the enumber of blocks that would be unusable	252	If checkpoint=enable it displays the enumber of blocks that would be unusable
253	if checkpoint=disable were to be set.	253	if checkpoint=disable were to be set.
		254
		255	What: /sys/fs/f2fs/<disk>/encoding
		256	Date July 2019
		257	Contact: "Daniel Rosenberg" <drosen@google.com>
		258	Description:
		259	Displays name and version of the encoding set for the filesystem.
		260	If no encoding is set, displays (none)

Documentation/filesystems/f2fs.txt+8−0

                        enabled by default.
 data_flush             Enable data flushing before checkpoint in order to
                        persist data of regular and symlink.
+reserve_root=%d        Support configuring reserved space which is used for
+                       allocation from a privileged user with specified uid or
+                       gid, unit: 4KB, the default limit is 0.2% of user blocks.
+resuid=%d              The user ID which may use the reserved blocks.
+resgid=%d              The group ID which may use the reserved blocks.
 fault_injection=%d     Enable fault injection in all supported types with
                        specified injection rate.
 fault_type=%d          Support configuring fault injection type, should be
                               that would be unusable if checkpoint=disable were
                               to be set.
+encoding 	              This shows the encoding used for casefolding.
+                              If casefolding is not enabled, returns (none)
 ================================================================================
 USAGE
 ================================================================================

fs/f2fs/Kconfig+4−1

 config F2FS_FS
 	tristate "F2FS filesystem support"
 	depends on BLOCK
+	select NLS
 	select CRYPTO
 	select CRYPTO_CRC32
 	select F2FS_FS_XATTR if FS_ENCRYPTION
 	  Security Models (LSMs) accepted by AppArmor, SELinux, Smack and TOMOYO
 	  Linux. This option enables an extended attribute handler for file
 	  security labels in the f2fs filesystem, so that it requires enabling
-	  the extended attribute support in advance.
+	  the extended attribute support in advance. In particular you need this
+	  option if you use the setcap command to assign initial process capabi-
+	  lities to executables (the security.* extended attributes).
 	  If you are not using a security module, say N.

fs/f2fs/data.c+70−34

 /*
  * Low-level block read/write IO operations.
  */
-static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr,
+static struct bio *__bio_alloc(struct f2fs_io_info *fio, int npages)
-				struct writeback_control *wbc,
-				int npages, bool is_read,
-				enum page_type type, enum temp_type temp)
 {
+	struct f2fs_sb_info *sbi = fio->sbi;
 	struct bio *bio;
 	bio = f2fs_bio_alloc(sbi, npages, true);
-	f2fs_target_device(sbi, blk_addr, bio);
+	f2fs_target_device(sbi, fio->new_blkaddr, bio);
-	if (is_read) {
+	if (is_read_io(fio->op)) {
 		bio->bi_end_io = f2fs_read_end_io;
 		bio->bi_private = NULL;
 	} else {
 		bio->bi_end_io = f2fs_write_end_io;
 		bio->bi_private = sbi;
-		bio->bi_write_hint = f2fs_io_type_to_rw_hint(sbi, type, temp);
+		bio->bi_write_hint = f2fs_io_type_to_rw_hint(sbi,
+						fio->type, fio->temp);
 	}
-	if (wbc)
+	if (fio->io_wbc)
-		wbc_init_bio(wbc, bio);
+		wbc_init_bio(fio->io_wbc, bio);
 	return bio;
 }
 		if (test_opt(sbi, LFS) && current->plug)
 			blk_finish_plug(current->plug);
+		if (F2FS_IO_ALIGNED(sbi))
+			goto submit_io;
 		start = bio->bi_iter.bi_size >> F2FS_BLKSIZE_BITS;
 		start %= F2FS_IO_SIZE(sbi);
 	f2fs_trace_ios(fio, 0);
 	/* Allocate a new bio */
-	bio = __bio_alloc(fio->sbi, fio->new_blkaddr, fio->io_wbc,
+	bio = __bio_alloc(fio, 1);
-				1, is_read_io(fio->op), fio->type, fio->temp);
 	if (bio_add_page(bio, page, PAGE_SIZE, 0) < PAGE_SIZE) {
 		bio_put(bio);
 	return 0;
 }
+static bool page_is_mergeable(struct f2fs_sb_info *sbi, struct bio *bio,
+				block_t last_blkaddr, block_t cur_blkaddr)
+{
+	if (last_blkaddr + 1 != cur_blkaddr)
+		return false;
+	return __same_bdev(sbi, cur_blkaddr, bio);
+}
+static bool io_type_is_mergeable(struct f2fs_bio_info *io,
+						struct f2fs_io_info *fio)
+{
+	if (io->fio.op != fio->op)
+		return false;
+	return io->fio.op_flags == fio->op_flags;
+}
+static bool io_is_mergeable(struct f2fs_sb_info *sbi, struct bio *bio,
+					struct f2fs_bio_info *io,
+					struct f2fs_io_info *fio,
+					block_t last_blkaddr,
+					block_t cur_blkaddr)
+{
+	if (F2FS_IO_ALIGNED(sbi) && (fio->type == DATA || fio->type == NODE)) {
+		unsigned int filled_blocks =
+				F2FS_BYTES_TO_BLK(bio->bi_iter.bi_size);
+		unsigned int io_size = F2FS_IO_SIZE(sbi);
+		unsigned int left_vecs = bio->bi_max_vecs - bio->bi_vcnt;
+		/* IOs in bio is aligned and left space of vectors is not enough */
+		if (!(filled_blocks % io_size) && left_vecs < io_size)
+			return false;
+	}
+	if (!page_is_mergeable(sbi, bio, last_blkaddr, cur_blkaddr))
+		return false;
+	return io_type_is_mergeable(io, fio);
+}
 int f2fs_merge_page_bio(struct f2fs_io_info *fio)
 {
 	struct bio *bio = *fio->bio;
 	trace_f2fs_submit_page_bio(page, fio);
 	f2fs_trace_ios(fio, 0);
-	if (bio && (*fio->last_block + 1 != fio->new_blkaddr ||
+	if (bio && !page_is_mergeable(fio->sbi, bio, *fio->last_block,
-			!__same_bdev(fio->sbi, fio->new_blkaddr, bio))) {
+						fio->new_blkaddr)) {
 		__submit_bio(fio->sbi, bio, fio->type);
 		bio = NULL;
 	}
 alloc_new:
 	if (!bio) {
-		bio = __bio_alloc(fio->sbi, fio->new_blkaddr, fio->io_wbc,
+		bio = __bio_alloc(fio, BIO_MAX_PAGES);
-				BIO_MAX_PAGES, false, fio->type, fio->temp);
 		bio_set_op_attrs(bio, fio->op, fio->op_flags);
 	}
 	inc_page_count(sbi, WB_DATA_TYPE(bio_page));
-	if (io->bio && (io->last_block_in_bio != fio->new_blkaddr - 1 ||
+	if (io->bio && !io_is_mergeable(sbi, io->bio, io, fio,
-	    (io->fio.op != fio->op || io->fio.op_flags != fio->op_flags) ||
+			io->last_block_in_bio, fio->new_blkaddr))
-			!__same_bdev(sbi, fio->new_blkaddr, io->bio)))
 		__submit_merged_bio(io);
 alloc_new:
 	if (io->bio == NULL) {
-		if ((fio->type == DATA || fio->type == NODE) &&
+		if (F2FS_IO_ALIGNED(sbi) &&
+				(fio->type == DATA || fio->type == NODE) &&
 				fio->new_blkaddr & F2FS_IO_SIZE_MASK(sbi)) {
 			dec_page_count(sbi, WB_DATA_TYPE(bio_page));
 			fio->retry = true;
 			goto skip;
 		}
-		io->bio = __bio_alloc(sbi, fio->new_blkaddr, fio->io_wbc,
+		io->bio = __bio_alloc(fio, BIO_MAX_PAGES);
-						BIO_MAX_PAGES, false,
-						fio->type, fio->temp);
 		io->fio = *fio;
 	}
 		goto next;
 out:
 	if (is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN) ||
-				f2fs_is_checkpoint_ready(sbi))
+				!f2fs_is_checkpoint_ready(sbi))
 		__submit_merged_bio(io);
 	up_write(&io->io_rwsem);
 }
 	if (GET_SEGNO(sbi, old_blkaddr) != NULL_SEGNO)
 		invalidate_mapping_pages(META_MAPPING(sbi),
 					old_blkaddr, old_blkaddr);
-	f2fs_set_data_blkaddr(dn);
+	f2fs_update_data_blkaddr(dn, dn->data_blkaddr);
 	/*
 	 * i_size will be updated by direct_IO. Otherwise, we'll get stale
 		if (test_opt(sbi, LFS) && flag == F2FS_GET_BLOCK_DIO &&
 							map->m_may_create) {
 			err = __allocate_data_block(&dn, map->m_seg_type);
-			if (!err) {
+			if (err)
-				blkaddr = dn.data_blkaddr;
+				goto sync_out;
-				set_inode_flag(inode, FI_APPEND_WRITE);
+			blkaddr = dn.data_blkaddr;
-			}
+			set_inode_flag(inode, FI_APPEND_WRITE);
 		}
 	} else {
 		if (create) {
 	return __get_data_block(inode, iblock, bh_result, create,
 				F2FS_GET_BLOCK_DIO, NULL,
 				f2fs_rw_hint_to_seg_type(inode->i_write_hint),
-				true);
+				IS_SWAPFILE(inode) ? false : true);
 }
 static int get_data_block_dio(struct inode *inode, sector_t iblock,
 		goto out;
 	}
-	if (f2fs_has_inline_data(inode)) {
+	if (f2fs_has_inline_data(inode) || f2fs_has_inline_dentry(inode)) {
 		ret = f2fs_inline_data_fiemap(inode, fieinfo, start, len);
 		if (ret != -EAGAIN)
 			goto out;
 	 * This page will go to BIO.  Do we need to send this
 	 * BIO off first?
 	 */
-	if (bio && (*last_block_in_bio != block_nr - 1 ||
+	if (bio && !page_is_mergeable(F2FS_I_SB(inode), bio,
-		!__same_bdev(F2FS_I_SB(inode), block_nr, bio))) {
+				*last_block_in_bio, block_nr)) {
 submit_and_realloc:
 		__submit_bio(F2FS_I_SB(inode), bio, DATA);
 		bio = NULL;
 	trace_f2fs_write_begin(inode, pos, len, flags);
-	err = f2fs_is_checkpoint_ready(sbi);
+	if (!f2fs_is_checkpoint_ready(sbi)) {
-	if (err)
+		err = -ENOSPC;
 		goto fail;
+	}
 	if ((f2fs_is_atomic_file(inode) &&
 			!f2fs_available_free_memory(sbi, INMEM_PAGES)) ||

fs/f2fs/debug.c+2−2

@@ -67,7 +67,7 @@ static void update_general_status(struct f2fs_sb_info *sbi) · 66 unmodified lines
67	si->nr_rd_data = get_pages(sbi, F2FS_RD_DATA);	67	si->nr_rd_data = get_pages(sbi, F2FS_RD_DATA);
68	si->nr_rd_node = get_pages(sbi, F2FS_RD_NODE);	68	si->nr_rd_node = get_pages(sbi, F2FS_RD_NODE);
69	si->nr_rd_meta = get_pages(sbi, F2FS_RD_META);	69	si->nr_rd_meta = get_pages(sbi, F2FS_RD_META);
70	if (SM_I(sbi) && SM_I(sbi)->fcc_info) {	70	if (SM_I(sbi)->fcc_info) {
71	si->nr_flushed =	71	si->nr_flushed =
72	atomic_read(&SM_I(sbi)->fcc_info->issued_flush);	72	atomic_read(&SM_I(sbi)->fcc_info->issued_flush);
73	si->nr_flushing =	73	si->nr_flushing =
@@ -75,7 +75,7 @@ static void update_general_status(struct f2fs_sb_info *sbi) · 1 unmodified line
75	si->flush_list_empty =	75	si->flush_list_empty =
76	llist_empty(&SM_I(sbi)->fcc_info->issue_list);	76	llist_empty(&SM_I(sbi)->fcc_info->issue_list);
77	}	77	}
78	if (SM_I(sbi) && SM_I(sbi)->dcc_info) {	78	if (SM_I(sbi)->dcc_info) {
79	si->nr_discarded =	79	si->nr_discarded =
80	atomic_read(&SM_I(sbi)->dcc_info->issued_discard);	80	atomic_read(&SM_I(sbi)->dcc_info->issued_discard);
81	si->nr_discarding =	81	si->nr_discarding =

fs/f2fs/dir.c+175−9

@@ -8,6 +8,7 @@ · 7 unmodified lines
8	#include <linux/fs.h>	8	#include <linux/fs.h>
9	#include <linux/f2fs_fs.h>	9	#include <linux/f2fs_fs.h>
10	#include <linux/sched/signal.h>	10	#include <linux/sched/signal.h>
		11	#include <linux/unicode.h>
11	#include "f2fs.h"	12	#include "f2fs.h"
12	#include "node.h"	13	#include "node.h"
13	#include "acl.h"	14	#include "acl.h"
@@ -81,7 +82,8 @@ static unsigned long dir_block_index(unsigned int level, · 67 unmodified lines
81	return bidx;	82	return bidx;
82	}	83	}
83		84
84	static struct f2fs_dir_entry find_in_block(struct page dentry_page,	85	static struct f2fs_dir_entry find_in_block(struct inode dir,
		86	struct page *dentry_page,
85	struct fscrypt_name *fname,	87	struct fscrypt_name *fname,
86	f2fs_hash_t namehash,	88	f2fs_hash_t namehash,
87	int *max_slots,	89	int *max_slots,
@@ -93,7 +95,7 @@ static struct f2fs_dir_entry find_in_block(struct page dentry_page, · 5 unmodified lines
93		95
94	dentry_blk = (struct f2fs_dentry_block *)page_address(dentry_page);	96	dentry_blk = (struct f2fs_dentry_block *)page_address(dentry_page);
95		97
96	make_dentry_ptr_block(NULL, &d, dentry_blk);	98	make_dentry_ptr_block(dir, &d, dentry_blk);
97	de = f2fs_find_target_dentry(fname, namehash, max_slots, &d);	99	de = f2fs_find_target_dentry(fname, namehash, max_slots, &d);
98	if (de)	100	if (de)
99	*res_page = dentry_page;	101	*res_page = dentry_page;
@@ -101,14 +103,116 @@ static struct f2fs_dir_entry find_in_block(struct page dentry_page, · 1 unmodified line
101	return de;	103	return de;
102	}	104	}
103		105
		106	#ifdef CONFIG_UNICODE
		107	/*
		108	* Test whether a case-insensitive directory entry matches the filename
		109	* being searched for.
		110	*
		111	* Returns: 0 if the directory entry matches, more than 0 if it
		112	* doesn't match or less than zero on error.
		113	*/
		114	int f2fs_ci_compare(const struct inode parent, const struct qstr name,
		115	const struct qstr *entry, bool quick)
		116	{
		117	const struct f2fs_sb_info *sbi = F2FS_SB(parent->i_sb);
		118	const struct unicode_map *um = sbi->s_encoding;
		119	int ret;
		120
		121	if (quick)
		122	ret = utf8_strncasecmp_folded(um, name, entry);
		123	else
		124	ret = utf8_strncasecmp(um, name, entry);
		125
		126	if (ret < 0) {
		127	/* Handle invalid character sequence as either an error
		128	* or as an opaque byte sequence.
		129	*/
		130	if (f2fs_has_strict_mode(sbi))
		131	return -EINVAL;
		132
		133	if (name->len != entry->len)
		134	return 1;
		135
		136	return !!memcmp(name->name, entry->name, name->len);
		137	}
		138
		139	return ret;
		140	}
		141
		142	static void f2fs_fname_setup_ci_filename(struct inode *dir,
		143	const struct qstr *iname,
		144	struct fscrypt_str *cf_name)
		145	{
		146	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
		147
		148	if (!IS_CASEFOLDED(dir)) {
		149	cf_name->name = NULL;
		150	return;
		151	}
		152
		153	cf_name->name = f2fs_kmalloc(sbi, F2FS_NAME_LEN, GFP_NOFS);
		154	if (!cf_name->name)
		155	return;
		156
		157	cf_name->len = utf8_casefold(sbi->s_encoding,
		158	iname, cf_name->name,
		159	F2FS_NAME_LEN);
		160	if ((int)cf_name->len <= 0) {
		161	kvfree(cf_name->name);
		162	cf_name->name = NULL;
		163	}
		164	}
		165	#endif
		166
		167	static inline bool f2fs_match_name(struct f2fs_dentry_ptr *d,
		168	struct f2fs_dir_entry *de,
		169	struct fscrypt_name *fname,
		170	struct fscrypt_str *cf_str,
		171	unsigned long bit_pos,
		172	f2fs_hash_t namehash)
		173	{
		174	#ifdef CONFIG_UNICODE
		175	struct inode *parent = d->inode;
		176	struct f2fs_sb_info *sbi = F2FS_I_SB(parent);
		177	struct qstr entry;
		178	#endif
		179
		180	if (de->hash_code != namehash)
		181	return false;
		182
		183	#ifdef CONFIG_UNICODE
		184	entry.name = d->filename[bit_pos];
		185	entry.len = de->name_len;
		186
		187	if (sbi->s_encoding && IS_CASEFOLDED(parent)) {
		188	if (cf_str->name) {
		189	struct qstr cf = {.name = cf_str->name,
		190	.len = cf_str->len};
		191	return !f2fs_ci_compare(parent, &cf, &entry, true);
		192	}
		193	return !f2fs_ci_compare(parent, fname->usr_fname, &entry,
		194	false);
		195	}
		196	#endif
		197	if (fscrypt_match_name(fname, d->filename[bit_pos],
		198	le16_to_cpu(de->name_len)))
		199	return true;
		200	return false;
		201	}
		202
104	struct f2fs_dir_entry f2fs_find_target_dentry(struct fscrypt_name fname,	203	struct f2fs_dir_entry f2fs_find_target_dentry(struct fscrypt_name fname,
105	f2fs_hash_t namehash, int *max_slots,	204	f2fs_hash_t namehash, int *max_slots,
106	struct f2fs_dentry_ptr *d)	205	struct f2fs_dentry_ptr *d)
107	{	206	{
108	struct f2fs_dir_entry *de;	207	struct f2fs_dir_entry *de;
		208	struct fscrypt_str cf_str = { .name = NULL, .len = 0 };
109	unsigned long bit_pos = 0;	209	unsigned long bit_pos = 0;
110	int max_len = 0;	210	int max_len = 0;
111		211
		212	#ifdef CONFIG_UNICODE
		213	f2fs_fname_setup_ci_filename(d->inode, fname->usr_fname, &cf_str);
		214	#endif
		215
112	if (max_slots)	216	if (max_slots)
113	*max_slots = 0;	217	*max_slots = 0;
114	while (bit_pos < d->max) {	218	while (bit_pos < d->max) {
@@ -125,9 +229,7 @@ struct f2fs_dir_entry f2fs_find_target_dentry(struct fscrypt_name fname, · 10 unmodified lines
125	continue;	229	continue;
126	}	230	}
127		231
128	if (de->hash_code == namehash &&	232	if (f2fs_match_name(d, de, fname, &cf_str, bit_pos, namehash))
129	fscrypt_match_name(fname, d->filename[bit_pos],
130	le16_to_cpu(de->name_len)))
131	goto found;	233	goto found;
132		234
133	if (max_slots && max_len > *max_slots)	235	if (max_slots && max_len > *max_slots)
@@ -141,6 +243,10 @@ struct f2fs_dir_entry f2fs_find_target_dentry(struct fscrypt_name fname, · 7 unmodified lines
141	found:	243	found:
142	if (max_slots && max_len > *max_slots)	244	if (max_slots && max_len > *max_slots)
143	*max_slots = max_len;	245	*max_slots = max_len;
		246
		247	#ifdef CONFIG_UNICODE
		248	kvfree(cf_str.name);
		249	#endif
144	return de;	250	return de;
145	}	251	}
146		252
@@ -157,7 +263,7 @@ static struct f2fs_dir_entry find_in_level(struct inode dir, · 10 unmodified lines
157	struct f2fs_dir_entry *de = NULL;	263	struct f2fs_dir_entry *de = NULL;
158	bool room = false;	264	bool room = false;
159	int max_slots;	265	int max_slots;
160	f2fs_hash_t namehash = f2fs_dentry_hash(&name, fname);	266	f2fs_hash_t namehash = f2fs_dentry_hash(dir, &name, fname);
161		267
162	nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);	268	nbucket = dir_buckets(level, F2FS_I(dir)->i_dir_level);
163	nblock = bucket_blocks(level);	269	nblock = bucket_blocks(level);
@@ -179,8 +285,8 @@ static struct f2fs_dir_entry find_in_level(struct inode dir, · 15 unmodified lines
179	}	285	}
180	}	286	}
181		287
182	de = find_in_block(dentry_page, fname, namehash, &max_slots,	288	de = find_in_block(dir, dentry_page, fname, namehash,
183	res_page);	289	&max_slots, res_page);
184	if (de)	290	if (de)
185	break;	291	break;
186		292
@@ -250,6 +356,14 @@ struct f2fs_dir_entry f2fs_find_entry(struct inode dir, · 63 unmodified lines
250	struct fscrypt_name fname;	356	struct fscrypt_name fname;
251	int err;	357	int err;
252		358
		359	#ifdef CONFIG_UNICODE
		360	if (f2fs_has_strict_mode(F2FS_I_SB(dir)) && IS_CASEFOLDED(dir) &&
		361	utf8_validate(F2FS_I_SB(dir)->s_encoding, child)) {
		362	*res_page = ERR_PTR(-EINVAL);
		363	return NULL;
		364	}
		365	#endif
		366
253	err = fscrypt_setup_filename(dir, child, 1, &fname);	367	err = fscrypt_setup_filename(dir, child, 1, &fname);
254	if (err) {	368	if (err) {
255	if (err == -ENOENT)	369	if (err == -ENOENT)
@@ -504,7 +618,7 @@ int f2fs_add_regular_entry(struct inode dir, const struct qstr new_name, · 248 unmodified lines
504		618
505	level = 0;	619	level = 0;
506	slots = GET_DENTRY_SLOTS(new_name->len);	620	slots = GET_DENTRY_SLOTS(new_name->len);
507	dentry_hash = f2fs_dentry_hash(new_name, NULL);	621	dentry_hash = f2fs_dentry_hash(dir, new_name, NULL);
508		622
509	current_depth = F2FS_I(dir)->i_current_depth;	623	current_depth = F2FS_I(dir)->i_current_depth;
510	if (F2FS_I(dir)->chash == dentry_hash) {	624	if (F2FS_I(dir)->chash == dentry_hash) {
@@ -568,6 +682,11 @@ add_dentry: · 57 unmodified lines
568		682
569	if (inode) {	683	if (inode) {
570	f2fs_i_pino_write(inode, dir->i_ino);	684	f2fs_i_pino_write(inode, dir->i_ino);
		685
		686	/* synchronize inode page's data from inode cache */
		687	if (is_inode_flag_set(inode, FI_NEW_INODE))
		688	f2fs_update_inode(inode, page);
		689
571	f2fs_put_page(page, 1);	690	f2fs_put_page(page, 1);
572	}	691	}
573		692
@@ -943,3 +1062,50 @@ const struct file_operations f2fs_dir_operations = { · 369 unmodified lines
943	.compat_ioctl = f2fs_compat_ioctl,	1062	.compat_ioctl = f2fs_compat_ioctl,
944	#endif	1063	#endif
945	};	1064	};
		1065
		1066	#ifdef CONFIG_UNICODE
		1067	static int f2fs_d_compare(const struct dentry *dentry, unsigned int len,
		1068	const char str, const struct qstr name)
		1069	{
		1070	struct qstr qstr = {.name = str, .len = len };
		1071
		1072	if (!IS_CASEFOLDED(dentry->d_parent->d_inode)) {
		1073	if (len != name->len)
		1074	return -1;
		1075	return memcmp(str, name, len);
		1076	}
		1077
		1078	return f2fs_ci_compare(dentry->d_parent->d_inode, name, &qstr, false);
		1079	}
		1080
		1081	static int f2fs_d_hash(const struct dentry dentry, struct qstr str)
		1082	{
		1083	struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
		1084	const struct unicode_map *um = sbi->s_encoding;
		1085	unsigned char *norm;
		1086	int len, ret = 0;
		1087
		1088	if (!IS_CASEFOLDED(dentry->d_inode))
		1089	return 0;
		1090
		1091	norm = f2fs_kmalloc(sbi, PATH_MAX, GFP_ATOMIC);
		1092	if (!norm)
		1093	return -ENOMEM;
		1094
		1095	len = utf8_casefold(um, str, norm, PATH_MAX);
		1096	if (len < 0) {
		1097	if (f2fs_has_strict_mode(sbi))
		1098	ret = -EINVAL;
		1099	goto out;
		1100	}
		1101	str->hash = full_name_hash(dentry, norm, len);
		1102	out:
		1103	kvfree(norm);
		1104	return ret;
		1105	}
		1106
		1107	const struct dentry_operations f2fs_dentry_ops = {
		1108	.d_hash = f2fs_d_hash,
		1109	.d_compare = f2fs_d_compare,
		1110	};
		1111	#endif

fs/f2fs/f2fs.h+37−10

 #define F2FS_FEATURE_LOST_FOUND		0x0200
 #define F2FS_FEATURE_VERITY		0x0400
 #define F2FS_FEATURE_SB_CHKSUM		0x0800
+#define F2FS_FEATURE_CASEFOLD		0x1000
 #define __F2FS_HAS_FEATURE(raw_super, mask)				\
 	((raw_super->feature & cpu_to_le32(mask)) != 0)
 #define F2FS_IOC_PRECACHE_EXTENTS	_IO(F2FS_IOCTL_MAGIC, 15)
 #define F2FS_IOC_RESIZE_FS		_IOW(F2FS_IOCTL_MAGIC, 16, __u64)
+#define F2FS_IOC_GET_VOLUME_NAME	FS_IOC_GETFSLABEL
+#define F2FS_IOC_SET_VOLUME_NAME	FS_IOC_SETFSLABEL
 #define F2FS_IOC_SET_ENCRYPTION_POLICY	FS_IOC_SET_ENCRYPTION_POLICY
 #define F2FS_IOC_GET_ENCRYPTION_POLICY	FS_IOC_GET_ENCRYPTION_POLICY
 #define F2FS_IOC_GET_ENCRYPTION_PWSALT	FS_IOC_GET_ENCRYPTION_PWSALT
 	int valid_super_block;			/* valid super block no */
 	unsigned long s_flag;				/* flags for sbi */
 	struct mutex writepages;		/* mutex for writepages() */
+#ifdef CONFIG_UNICODE
+	struct unicode_map *s_encoding;
+	__u16 s_encoding_flags;
+#endif
 #ifdef CONFIG_BLK_DEV_ZONED
 	unsigned int blocks_per_blkz;		/* F2FS blocks per zone */
 static inline void disable_nat_bits(struct f2fs_sb_info *sbi, bool lock)
 {
 	unsigned long flags;
+	unsigned char *nat_bits;
 	/*
 	 * In order to re-enable nat_bits we need to call fsck.f2fs by
 	if (lock)
 		spin_lock_irqsave(&sbi->cp_lock, flags);
 	__clear_ckpt_flags(F2FS_CKPT(sbi), CP_NAT_BITS_FLAG);
-	kvfree(NM_I(sbi)->nat_bits);
+	nat_bits = NM_I(sbi)->nat_bits;
 	NM_I(sbi)->nat_bits = NULL;
 	if (lock)
 		spin_unlock_irqrestore(&sbi->cp_lock, flags);
+	kvfree(nat_bits);
 }
 static inline bool enabled_nat_bits(struct f2fs_sb_info *sbi,
 	if (time_to_inject(sbi, FAULT_BLOCK)) {
 		f2fs_show_injection_info(FAULT_BLOCK);
 		release = *count;
-		goto enospc;
+		goto release_quota;
 	}
 	/*
 enospc:
 	percpu_counter_sub(&sbi->alloc_valid_block_count, release);
+release_quota:
 	dquot_release_reservation_block(inode, release);
 	return -ENOSPC;
 }
 #define F2FS_INDEX_FL			0x00001000 /* hash-indexed directory */
 #define F2FS_DIRSYNC_FL			0x00010000 /* dirsync behaviour (directories only) */
 #define F2FS_PROJINHERIT_FL		0x20000000 /* Create with parents projid */
+#define F2FS_CASEFOLD_FL		0x40000000 /* Casefolded file */
 /* Flags that should be inherited by new inodes from their parent. */
 #define F2FS_FL_INHERITED (F2FS_SYNC_FL | F2FS_NODUMP_FL | F2FS_NOATIME_FL | \
-			   F2FS_DIRSYNC_FL | F2FS_PROJINHERIT_FL)
+			   F2FS_DIRSYNC_FL | F2FS_PROJINHERIT_FL | \
+			   F2FS_CASEFOLD_FL)
 /* Flags that are appropriate for regular files (all but dir-specific ones). */
-#define F2FS_REG_FLMASK		(~(F2FS_DIRSYNC_FL | F2FS_PROJINHERIT_FL))
+#define F2FS_REG_FLMASK		(~(F2FS_DIRSYNC_FL | F2FS_PROJINHERIT_FL | \
+				F2FS_CASEFOLD_FL))
 /* Flags that are appropriate for non-directories/regular files. */
 #define F2FS_OTHER_FLMASK	(F2FS_NODUMP_FL | F2FS_NOATIME_FL)
 							bool hot, bool set);
 struct dentry *f2fs_get_parent(struct dentry *child);
+extern int f2fs_ci_compare(const struct inode *parent,
+			   const struct qstr *name,
+			   const struct qstr *entry,
+			   bool quick);
 /*
  * dir.c
  */
 /*
  * hash.c
  */
-f2fs_hash_t f2fs_dentry_hash(const struct qstr *name_info,
+f2fs_hash_t f2fs_dentry_hash(const struct inode *dir,
-				struct fscrypt_name *fname);
+		const struct qstr *name_info, struct fscrypt_name *fname);
 /*
  * node.c
 #endif
 extern const struct file_operations f2fs_dir_operations;
+#ifdef CONFIG_UNICODE
+extern const struct dentry_operations f2fs_dentry_ops;
+#endif
 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;
 F2FS_FEATURE_FUNCS(lost_found, LOST_FOUND);
 F2FS_FEATURE_FUNCS(verity, VERITY);
 F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);
+F2FS_FEATURE_FUNCS(casefold, CASEFOLD);
 #ifdef CONFIG_BLK_DEV_ZONED
 static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,
 	 */
 	if (f2fs_sb_has_blkzoned(sbi))
 		return true;
-	if (test_opt(sbi, LFS) && (rw == WRITE) &&
+	if (test_opt(sbi, LFS) && (rw == WRITE)) {
-				block_unaligned_IO(inode, iocb, iter))
+		if (block_unaligned_IO(inode, iocb, iter))
-		return true;
+			return true;
+		if (F2FS_IO_ALIGNED(sbi))
+			return true;
+	}
 	if (is_sbi_flag_set(F2FS_I_SB(inode), SBI_CP_DISABLED) &&
-					!(inode->i_flags & S_SWAPFILE))
+					!IS_SWAPFILE(inode))
 		return true;
 	return false;

fs/f2fs/file.c+128−34

@@ -20,6 +20,7 @@ · 19 unmodified lines
20	#include <linux/uio.h>	20	#include <linux/uio.h>
21	#include <linux/uuid.h>	21	#include <linux/uuid.h>
22	#include <linux/file.h>	22	#include <linux/file.h>
		23	#include <linux/nls.h>
23		24
24	#include "f2fs.h"	25	#include "f2fs.h"
25	#include "node.h"	26	#include "node.h"
@@ -57,6 +58,11 @@ static vm_fault_t f2fs_vm_page_mkwrite(struct vm_fault *vmf) · 31 unmodified lines
57	goto err;	58	goto err;
58	}	59	}
59		60
		61	if (!f2fs_is_checkpoint_ready(sbi)) {
		62	err = -ENOSPC;
		63	goto err;
		64	}
		65
60	sb_start_pagefault(inode->i_sb);	66	sb_start_pagefault(inode->i_sb);
61		67
62	f2fs_bug_on(sbi, f2fs_has_inline_data(inode));	68	f2fs_bug_on(sbi, f2fs_has_inline_data(inode));
@@ -819,14 +825,24 @@ int f2fs_setattr(struct dentry dentry, struct iattr attr) · 756 unmodified lines
819	}	825	}
820		826
821	if (attr->ia_valid & ATTR_SIZE) {	827	if (attr->ia_valid & ATTR_SIZE) {
822	bool to_smaller = (attr->ia_size <= i_size_read(inode));	828	loff_t old_size = i_size_read(inode);
		829
		830	if (attr->ia_size > MAX_INLINE_DATA(inode)) {
		831	/*
		832	* should convert inline inode before i_size_write to
		833	* keep smaller than inline_data size with inline flag.
		834	*/
		835	err = f2fs_convert_inline_inode(inode);
		836	if (err)
		837	return err;
		838	}
823		839
824	down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);	840	down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
825	down_write(&F2FS_I(inode)->i_mmap_sem);	841	down_write(&F2FS_I(inode)->i_mmap_sem);
826		842
827	truncate_setsize(inode, attr->ia_size);	843	truncate_setsize(inode, attr->ia_size);
828		844
829	if (to_smaller)	845	if (attr->ia_size <= old_size)
830	err = f2fs_truncate(inode);	846	err = f2fs_truncate(inode);
831	/*	847	/*
832	* do not trim all blocks after i_size if target size is	848	* do not trim all blocks after i_size if target size is
@@ -834,21 +850,11 @@ int f2fs_setattr(struct dentry dentry, struct iattr attr) · 1 unmodified line
834	*/	850	*/
835	up_write(&F2FS_I(inode)->i_mmap_sem);	851	up_write(&F2FS_I(inode)->i_mmap_sem);
836	up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);	852	up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
837
838	if (err)	853	if (err)
839	return err;	854	return err;
840		855
841	if (!to_smaller) {
842	/* should convert inline inode here */
843	if (!f2fs_may_inline_data(inode)) {
844	err = f2fs_convert_inline_inode(inode);
845	if (err)
846	return err;
847	}
848	inode->i_mtime = inode->i_ctime = current_time(inode);
849	}
850
851	down_write(&F2FS_I(inode)->i_sem);	856	down_write(&F2FS_I(inode)->i_sem);
		857	inode->i_mtime = inode->i_ctime = current_time(inode);
852	F2FS_I(inode)->last_disk_size = i_size_read(inode);	858	F2FS_I(inode)->last_disk_size = i_size_read(inode);
853	up_write(&F2FS_I(inode)->i_sem);	859	up_write(&F2FS_I(inode)->i_sem);
854	}	860	}
@@ -1041,7 +1047,7 @@ next_dnode: · 186 unmodified lines
1041		1047
1042	if (test_opt(sbi, LFS)) {	1048	if (test_opt(sbi, LFS)) {
1043	f2fs_put_dnode(&dn);	1049	f2fs_put_dnode(&dn);
1044	return -ENOTSUPP;	1050	return -EOPNOTSUPP;
1045	}	1051	}
1046		1052
1047	/* do not invalidate this block address */	1053	/* do not invalidate this block address */
@@ -1578,6 +1584,8 @@ static long f2fs_fallocate(struct file *file, int mode, · 530 unmodified lines
1578		1584
1579	if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))	1585	if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
1580	return -EIO;	1586	return -EIO;
		1587	if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
		1588	return -ENOSPC;
1581		1589
1582	/* f2fs only support ->fallocate for regular file */	1590	/* f2fs only support ->fallocate for regular file */
1583	if (!S_ISREG(inode->i_mode))	1591	if (!S_ISREG(inode->i_mode))
@@ -1669,6 +1677,13 @@ static int f2fs_setflags_common(struct inode *inode, u32 iflags, u32 mask) · 85 unmodified lines
1669	if (IS_NOQUOTA(inode))	1677	if (IS_NOQUOTA(inode))
1670	return -EPERM;	1678	return -EPERM;
1671		1679
		1680	if ((iflags ^ fi->i_flags) & F2FS_CASEFOLD_FL) {
		1681	if (!f2fs_sb_has_casefold(F2FS_I_SB(inode)))
		1682	return -EOPNOTSUPP;
		1683	if (!f2fs_empty_dir(inode))
		1684	return -ENOTEMPTY;
		1685	}
		1686
1672	fi->i_flags = iflags \| (fi->i_flags & ~mask);	1687	fi->i_flags = iflags \| (fi->i_flags & ~mask);
1673		1688
1674	if (fi->i_flags & F2FS_PROJINHERIT_FL)	1689	if (fi->i_flags & F2FS_PROJINHERIT_FL)
@@ -1703,6 +1718,7 @@ static const struct { · 28 unmodified lines
1703	{ F2FS_INDEX_FL, FS_INDEX_FL },	1718	{ F2FS_INDEX_FL, FS_INDEX_FL },
1704	{ F2FS_DIRSYNC_FL, FS_DIRSYNC_FL },	1719	{ F2FS_DIRSYNC_FL, FS_DIRSYNC_FL },
1705	{ F2FS_PROJINHERIT_FL, FS_PROJINHERIT_FL },	1720	{ F2FS_PROJINHERIT_FL, FS_PROJINHERIT_FL },
		1721	{ F2FS_CASEFOLD_FL, FS_CASEFOLD_FL },
1706	};	1722	};
1707		1723
1708	#define F2FS_GETTABLE_FS_FL ( \	1724	#define F2FS_GETTABLE_FS_FL ( \
@@ -1717,7 +1733,8 @@ static const struct { · 8 unmodified lines
1717	FS_ENCRYPT_FL \| \	1733	FS_ENCRYPT_FL \| \
1718	FS_INLINE_DATA_FL \| \	1734	FS_INLINE_DATA_FL \| \
1719	FS_NOCOW_FL \| \	1735	FS_NOCOW_FL \| \
1720	FS_VERITY_FL)	1736	FS_VERITY_FL \| \
		1737	FS_CASEFOLD_FL)
1721		1738
1722	#define F2FS_SETTABLE_FS_FL ( \	1739	#define F2FS_SETTABLE_FS_FL ( \
1723	FS_SYNC_FL \| \	1740	FS_SYNC_FL \| \
@@ -1726,7 +1743,8 @@ static const struct { · 2 unmodified lines
1726	FS_NODUMP_FL \| \	1743	FS_NODUMP_FL \| \
1727	FS_NOATIME_FL \| \	1744	FS_NOATIME_FL \| \
1728	FS_DIRSYNC_FL \| \	1745	FS_DIRSYNC_FL \| \
1729	FS_PROJINHERIT_FL)	1746	FS_PROJINHERIT_FL \| \
		1747	FS_CASEFOLD_FL)
1730		1748
1731	/* Convert f2fs on-disk i_flags to FS_IOC_{GET,SET}FLAGS flags */	1749	/* Convert f2fs on-disk i_flags to FS_IOC_{GET,SET}FLAGS flags */
1732	static inline u32 f2fs_iflags_to_fsflags(u32 iflags)	1750	static inline u32 f2fs_iflags_to_fsflags(u32 iflags)
@@ -1825,6 +1843,8 @@ static int f2fs_ioc_getversion(struct file *filp, unsigned long arg) · 92 unmodified lines
1825	static int f2fs_ioc_start_atomic_write(struct file *filp)	1843	static int f2fs_ioc_start_atomic_write(struct file *filp)
1826	{	1844	{
1827	struct inode *inode = file_inode(filp);	1845	struct inode *inode = file_inode(filp);
		1846	struct f2fs_inode_info *fi = F2FS_I(inode);
		1847	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
1828	int ret;	1848	int ret;
1829		1849
1830	if (!inode_owner_or_capable(inode))	1850	if (!inode_owner_or_capable(inode))
@@ -1833,6 +1853,9 @@ static int f2fs_ioc_start_atomic_write(struct file *filp) · 2 unmodified lines
1833	if (!S_ISREG(inode->i_mode))	1853	if (!S_ISREG(inode->i_mode))
1834	return -EINVAL;	1854	return -EINVAL;
1835		1855
		1856	if (filp->f_flags & O_DIRECT)
		1857	return -EINVAL;
		1858
1836	ret = mnt_want_write_file(filp);	1859	ret = mnt_want_write_file(filp);
1837	if (ret)	1860	if (ret)
1838	return ret;	1861	return ret;
@@ -1864,6 +1887,12 @@ static int f2fs_ioc_start_atomic_write(struct file *filp) · 25 unmodified lines
1864	goto out;	1887	goto out;
1865	}	1888	}
1866		1889
		1890	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
		1891	if (list_empty(&fi->inmem_ilist))
		1892	list_add_tail(&fi->inmem_ilist, &sbi->inode_list[ATOMIC_FILE]);
		1893	spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
		1894
		1895	/* add inode in inmem_list first and set atomic_file */
1867	set_inode_flag(inode, FI_ATOMIC_FILE);	1896	set_inode_flag(inode, FI_ATOMIC_FILE);
1868	clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);	1897	clear_inode_flag(inode, FI_ATOMIC_REVOKE_REQUEST);
1869	up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);	1898	up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
@@ -1905,11 +1934,8 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp) · 35 unmodified lines
1905	goto err_out;	1934	goto err_out;
1906		1935
1907	ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);	1936	ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
1908	if (!ret) {	1937	if (!ret)
1909	clear_inode_flag(inode, FI_ATOMIC_FILE);	1938	f2fs_drop_inmem_pages(inode);
1910	F2FS_I(inode)->i_gc_failures[GC_FAILURE_ATOMIC] = 0;
1911	stat_dec_atomic_write(inode);
1912	}
1913	} else {	1939	} else {
1914	ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);	1940	ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
1915	}	1941	}
@@ -2295,9 +2321,9 @@ static int f2fs_ioc_gc_range(struct file *filp, unsigned long arg) · 379 unmodified lines
2295	return -EROFS;	2321	return -EROFS;
2296		2322
2297	end = range.start + range.len;	2323	end = range.start + range.len;
2298	if (range.start < MAIN_BLKADDR(sbi) \|\| end >= MAX_BLKADDR(sbi)) {	2324	if (end < range.start \|\| range.start < MAIN_BLKADDR(sbi) \|\|
		2325	end >= MAX_BLKADDR(sbi))
2299	return -EINVAL;	2326	return -EINVAL;
2300	}
2301		2327
2302	ret = mnt_want_write_file(filp);	2328	ret = mnt_want_write_file(filp);
2303	if (ret)	2329	if (ret)
@@ -2421,8 +2447,10 @@ static int f2fs_defragment_range(struct f2fs_sb_info *sbi, · 117 unmodified lines
2421	map.m_lblk += map.m_len;	2447	map.m_lblk += map.m_len;
2422	}	2448	}
2423		2449
2424	if (!fragmented)	2450	if (!fragmented) {
		2451	total = 0;
2425	goto out;	2452	goto out;
		2453	}
2426		2454
2427	sec_num = DIV_ROUND_UP(total, BLKS_PER_SEC(sbi));	2455	sec_num = DIV_ROUND_UP(total, BLKS_PER_SEC(sbi));
2428		2456
@@ -2452,7 +2480,7 @@ do_map: · 23 unmodified lines
2452		2480
2453	if (!(map.m_flags & F2FS_MAP_FLAGS)) {	2481	if (!(map.m_flags & F2FS_MAP_FLAGS)) {
2454	map.m_lblk = next_pgofs;	2482	map.m_lblk = next_pgofs;
2455	continue;	2483	goto check;
2456	}	2484	}
2457		2485
2458	set_inode_flag(inode, FI_DO_DEFRAG);	2486	set_inode_flag(inode, FI_DO_DEFRAG);
@@ -2476,8 +2504,8 @@ do_map: · 17 unmodified lines
2476	}	2504	}
2477		2505
2478	map.m_lblk = idx;	2506	map.m_lblk = idx;
2479		2507	check:
2480	if (idx < pg_end && cnt < blk_per_seg)	2508	if (map.m_lblk < pg_end && cnt < blk_per_seg)
2481	goto do_map;	2509	goto do_map;
2482		2510
2483	clear_inode_flag(inode, FI_DO_DEFRAG);	2511	clear_inode_flag(inode, FI_DO_DEFRAG);
@@ -3141,10 +3169,74 @@ static int f2fs_ioc_measure_verity(struct file *filp, unsigned long arg) · 657 unmodified lines
3141	return fsverity_ioctl_measure(filp, (void __user *)arg);	3169	return fsverity_ioctl_measure(filp, (void __user *)arg);
3142	}	3170	}
3143		3171
		3172	static int f2fs_get_volume_name(struct file *filp, unsigned long arg)
		3173	{
		3174	struct inode *inode = file_inode(filp);
		3175	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
		3176	char *vbuf;
		3177	int count;
		3178	int err = 0;
		3179
		3180	vbuf = f2fs_kzalloc(sbi, MAX_VOLUME_NAME, GFP_KERNEL);
		3181	if (!vbuf)
		3182	return -ENOMEM;
		3183
		3184	down_read(&sbi->sb_lock);
		3185	count = utf16s_to_utf8s(sbi->raw_super->volume_name,
		3186	ARRAY_SIZE(sbi->raw_super->volume_name),
		3187	UTF16_LITTLE_ENDIAN, vbuf, MAX_VOLUME_NAME);
		3188	up_read(&sbi->sb_lock);
		3189
		3190	if (copy_to_user((char __user *)arg, vbuf,
		3191	min(FSLABEL_MAX, count)))
		3192	err = -EFAULT;
		3193
		3194	kvfree(vbuf);
		3195	return err;
		3196	}
		3197
		3198	static int f2fs_set_volume_name(struct file *filp, unsigned long arg)
		3199	{
		3200	struct inode *inode = file_inode(filp);
		3201	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
		3202	char *vbuf;
		3203	int err = 0;
		3204
		3205	if (!capable(CAP_SYS_ADMIN))
		3206	return -EPERM;
		3207
		3208	vbuf = strndup_user((const char __user *)arg, FSLABEL_MAX);
		3209	if (IS_ERR(vbuf))
		3210	return PTR_ERR(vbuf);
		3211
		3212	err = mnt_want_write_file(filp);
		3213	if (err)
		3214	goto out;
		3215
		3216	down_write(&sbi->sb_lock);
		3217
		3218	memset(sbi->raw_super->volume_name, 0,
		3219	sizeof(sbi->raw_super->volume_name));
		3220	utf8s_to_utf16s(vbuf, strlen(vbuf), UTF16_LITTLE_ENDIAN,
		3221	sbi->raw_super->volume_name,
		3222	ARRAY_SIZE(sbi->raw_super->volume_name));
		3223
		3224	err = f2fs_commit_super(sbi, false);
		3225
		3226	up_write(&sbi->sb_lock);
		3227
		3228	mnt_drop_write_file(filp);
		3229	out:
		3230	kfree(vbuf);
		3231	return err;
		3232	}
		3233
3144	long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)	3234	long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
3145	{	3235	{
3146	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))	3236	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
3147	return -EIO;	3237	return -EIO;
		3238	if (!f2fs_is_checkpoint_ready(F2FS_I_SB(file_inode(filp))))
		3239	return -ENOSPC;
3148		3240
3149	switch (cmd) {	3241	switch (cmd) {
3150	case F2FS_IOC_GETFLAGS:	3242	case F2FS_IOC_GETFLAGS:
@@ -3213,6 +3305,10 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) · 62 unmodified lines
3213	return f2fs_ioc_enable_verity(filp, arg);	3305	return f2fs_ioc_enable_verity(filp, arg);
3214	case FS_IOC_MEASURE_VERITY:	3306	case FS_IOC_MEASURE_VERITY:
3215	return f2fs_ioc_measure_verity(filp, arg);	3307	return f2fs_ioc_measure_verity(filp, arg);
		3308	case F2FS_IOC_GET_VOLUME_NAME:
		3309	return f2fs_get_volume_name(filp, arg);
		3310	case F2FS_IOC_SET_VOLUME_NAME:
		3311	return f2fs_set_volume_name(filp, arg);
3216	default:	3312	default:
3217	return -ENOTTY;	3313	return -ENOTTY;
3218	}	3314	}
@@ -3229,16 +3325,12 @@ static ssize_t f2fs_file_write_iter(struct kiocb iocb, struct iov_iter from) · 10 unmodified lines
3229	goto out;	3325	goto out;
3230	}	3326	}
3231		3327
3232	if ((iocb->ki_flags & IOCB_NOWAIT) && !(iocb->ki_flags & IOCB_DIRECT)) {	3328	if (iocb->ki_flags & IOCB_NOWAIT) {
3233	ret = -EINVAL;	3329	if (!inode_trylock(inode)) {
3234	goto out;
3235	}
3236
3237	if (!inode_trylock(inode)) {
3238	if (iocb->ki_flags & IOCB_NOWAIT) {
3239	ret = -EAGAIN;	3330	ret = -EAGAIN;
3240	goto out;	3331	goto out;
3241	}	3332	}
		3333	} else {
3242	inode_lock(inode);	3334	inode_lock(inode);
3243	}	3335	}
3244		3336
@@ -3334,6 +3426,8 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) · 89 unmodified lines
3334	case F2FS_IOC_RESIZE_FS:	3426	case F2FS_IOC_RESIZE_FS:
3335	case FS_IOC_ENABLE_VERITY:	3427	case FS_IOC_ENABLE_VERITY:
3336	case FS_IOC_MEASURE_VERITY:	3428	case FS_IOC_MEASURE_VERITY:
		3429	case F2FS_IOC_GET_VOLUME_NAME:
		3430	case F2FS_IOC_SET_VOLUME_NAME:
3337	break;	3431	break;
3338	default:	3432	default:
3339	return -ENOIOCTLCMD;	3433	return -ENOIOCTLCMD;

fs/f2fs/gc.c+25−2

@@ -382,6 +382,16 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi, · 381 unmodified lines
382	nsearched++;	382	nsearched++;
383	}	383	}
384		384
		385	#ifdef CONFIG_F2FS_CHECK_FS
		386	/*
		387	* skip selecting the invalid segno (that is failed due to block
		388	* validity check failure during GC) to avoid endless GC loop in
		389	* such cases.
		390	*/
		391	if (test_bit(segno, sm->invalid_segmap))
		392	goto next;
		393	#endif
		394
385	secno = GET_SEC_FROM_SEG(sbi, segno);	395	secno = GET_SEC_FROM_SEG(sbi, segno);
386		396
387	if (sec_usage_check(sbi, secno))	397	if (sec_usage_check(sbi, secno))
@@ -627,8 +637,21 @@ static bool is_alive(struct f2fs_sb_info sbi, struct f2fs_summary sum, · 239 unmodified lines
627	source_blkaddr = datablock_addr(NULL, node_page, ofs_in_node);	637	source_blkaddr = datablock_addr(NULL, node_page, ofs_in_node);
628	f2fs_put_page(node_page, 1);	638	f2fs_put_page(node_page, 1);
629		639
630	if (source_blkaddr != blkaddr)	640	if (source_blkaddr != blkaddr) {
		641	#ifdef CONFIG_F2FS_CHECK_FS
		642	unsigned int segno = GET_SEGNO(sbi, blkaddr);
		643	unsigned long offset = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
		644
		645	if (unlikely(check_valid_map(sbi, segno, offset))) {
		646	if (!test_and_set_bit(segno, SIT_I(sbi)->invalid_segmap)) {
		647	f2fs_err(sbi, "mismatched blkaddr %u (source_blkaddr %u) in seg %u\n",
		648	blkaddr, source_blkaddr, segno);
		649	f2fs_bug_on(sbi, 1);
		650	}
		651	}
		652	#endif
631	return false;	653	return false;
		654	}
632	return true;	655	return true;
633	}	656	}
634		657
@@ -1303,7 +1326,7 @@ gc_more: · 668 unmodified lines
1303	round++;	1326	round++;
1304	}	1327	}
1305		1328
1306	if (gc_type == FG_GC)	1329	if (gc_type == FG_GC && seg_freed)
1307	sbi->cur_victim_sec = NULL_SEGNO;	1330	sbi->cur_victim_sec = NULL_SEGNO;
1308		1331
1309	if (sync)	1332	if (sync)

fs/f2fs/hash.c+36−1

@@ -14,6 +14,7 @@ · 13 unmodified lines
14	#include <linux/f2fs_fs.h>	14	#include <linux/f2fs_fs.h>
15	#include <linux/cryptohash.h>	15	#include <linux/cryptohash.h>
16	#include <linux/pagemap.h>	16	#include <linux/pagemap.h>
		17	#include <linux/unicode.h>
17		18
18	#include "f2fs.h"	19	#include "f2fs.h"
19		20
@@ -67,7 +68,7 @@ static void str2hashbuf(const unsigned char *msg, size_t len, · 47 unmodified lines
67	*buf++ = pad;	68	*buf++ = pad;
68	}	69	}
69		70
70	f2fs_hash_t f2fs_dentry_hash(const struct qstr *name_info,	71	static f2fs_hash_t __f2fs_dentry_hash(const struct qstr *name_info,
71	struct fscrypt_name *fname)	72	struct fscrypt_name *fname)
72	{	73	{
73	__u32 hash;	74	__u32 hash;
@@ -103,3 +104,37 @@ f2fs_hash_t f2fs_dentry_hash(const struct qstr *name_info, · 29 unmodified lines
103	f2fs_hash = cpu_to_le32(hash & ~F2FS_HASH_COL_BIT);	104	f2fs_hash = cpu_to_le32(hash & ~F2FS_HASH_COL_BIT);
104	return f2fs_hash;	105	return f2fs_hash;
105	}	106	}
		107
		108	f2fs_hash_t f2fs_dentry_hash(const struct inode *dir,
		109	const struct qstr name_info, struct fscrypt_name fname)
		110	{
		111	#ifdef CONFIG_UNICODE
		112	struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
		113	const struct unicode_map *um = sbi->s_encoding;
		114	int r, dlen;
		115	unsigned char *buff;
		116	struct qstr folded;
		117
		118	if (!name_info->len \|\| !IS_CASEFOLDED(dir))
		119	goto opaque_seq;
		120
		121	buff = f2fs_kzalloc(sbi, sizeof(char) * PATH_MAX, GFP_KERNEL);
		122	if (!buff)
		123	return -ENOMEM;
		124
		125	dlen = utf8_casefold(um, name_info, buff, PATH_MAX);
		126	if (dlen < 0) {
		127	kvfree(buff);
		128	goto opaque_seq;
		129	}
		130	folded.name = buff;
		131	folded.len = dlen;
		132	r = __f2fs_dentry_hash(&folded, fname);
		133
		134	kvfree(buff);
		135	return r;
		136
		137	opaque_seq:
		138	#endif
		139	return __f2fs_dentry_hash(name_info, fname);
		140	}

fs/f2fs/inline.c+15−3

 	err = f2fs_get_node_info(fio.sbi, dn->nid, &ni);
 	if (err) {
+		f2fs_truncate_data_blocks_range(dn, 1);
 		f2fs_put_dnode(dn);
 		return err;
 	}
 		return NULL;
 	}
-	namehash = f2fs_dentry_hash(&name, fname);
+	namehash = f2fs_dentry_hash(dir, &name, fname);
 	inline_dentry = inline_data_addr(dir, ipage);
 	f2fs_wait_on_page_writeback(ipage, NODE, true, true);
-	name_hash = f2fs_dentry_hash(new_name, NULL);
+	name_hash = f2fs_dentry_hash(dir, new_name, NULL);
 	f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos);
 	set_page_dirty(ipage);
 	/* we don't need to mark_inode_dirty now */
 	if (inode) {
 		f2fs_i_pino_write(inode, dir->i_ino);
+		/* synchronize inode page's data from inode cache */
+		if (is_inode_flag_set(inode, FI_NEW_INODE))
+			f2fs_update_inode(inode, page);
 		f2fs_put_page(page, 1);
 	}
 	if (IS_ERR(ipage))
 		return PTR_ERR(ipage);
-	if (!f2fs_has_inline_data(inode)) {
+	if ((S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
+				!f2fs_has_inline_data(inode)) {
+		err = -EAGAIN;
+		goto out;
+	}
+	if (S_ISDIR(inode->i_mode) && !f2fs_has_inline_dentry(inode)) {
 		err = -EAGAIN;
 		goto out;
 	}

fs/f2fs/inode.c+7−4

 		new_fl |= S_ENCRYPTED;
 	if (file_is_verity(inode))
 		new_fl |= S_VERITY;
+	if (flags & F2FS_CASEFOLD_FL)
+		new_fl |= S_CASEFOLD;
 	inode_set_flags(inode, new_fl,
 			S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|
-			S_ENCRYPTED|S_VERITY);
+			S_ENCRYPTED|S_VERITY|S_CASEFOLD);
 }
 static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
 	if (!is_inode_flag_set(inode, FI_DIRTY_INODE))
 		return 0;
-	if (f2fs_is_checkpoint_ready(sbi))
+	if (!f2fs_is_checkpoint_ready(sbi))
 		return -ENOSPC;
 	/*
 	if (err) {
 		f2fs_update_inode_page(inode);
-		set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
+		if (dquot_initialize_needed(inode))
+			set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
 	}
 	sb_end_intwrite(inode->i_sb);
 no_delete:
 	stat_dec_inline_dir(inode);
 	stat_dec_inline_inode(inode);
-	if (likely(!is_set_ckpt_flags(sbi, CP_ERROR_FLAG) &&
+	if (likely(!f2fs_cp_error(sbi) &&
 				!is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
 		f2fs_bug_on(sbi, is_inode_flag_set(inode, FI_DIRTY_INODE));
 	else

fs/f2fs/namei.c+36−18

 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
-	err = f2fs_is_checkpoint_ready(sbi);
+	if (!f2fs_is_checkpoint_ready(sbi))
-	if (err)
+		return -ENOSPC;
-		return err;
 	err = dquot_initialize(dir);
 	if (err)
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
-	err = f2fs_is_checkpoint_ready(sbi);
+	if (!f2fs_is_checkpoint_ready(sbi))
-	if (err)
+		return -ENOSPC;
-		return err;
 	err = fscrypt_prepare_link(old_dentry, dir, dentry);
 	if (err)
 		goto out_iput;
 	}
 out_splice:
+#ifdef CONFIG_UNICODE
+	if (!inode && IS_CASEFOLDED(dir)) {
+		/* Eventually we want to call d_add_ci(dentry, NULL)
+		 * for negative dentries in the encoding case as
+		 * well.  For now, prevent the negative dentry
+		 * from being cached.
+		 */
+		trace_f2fs_lookup_end(dir, dentry, ino, err);
+		return NULL;
+	}
+#endif
 	new = d_splice_alias(inode, dentry);
 	err = PTR_ERR_OR_ZERO(new);
 	trace_f2fs_lookup_end(dir, dentry, ino, err);
 		goto fail;
 	}
 	f2fs_delete_entry(de, page, dir, inode);
+#ifdef CONFIG_UNICODE
+	/* VFS negative dentries are incompatible with Encoding and
+	 * Case-insensitiveness. Eventually we'll want avoid
+	 * invalidating the dentries here, alongside with returning the
+	 * negative dentries at f2fs_lookup(), when it is  better
+	 * supported by the VFS for the CI case.
+	 */
+	if (IS_CASEFOLDED(dir))
+		d_invalidate(dentry);
+#endif
 	f2fs_unlock_op(sbi);
 	if (IS_DIRSYNC(dir))
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
-	err = f2fs_is_checkpoint_ready(sbi);
+	if (!f2fs_is_checkpoint_ready(sbi))
-	if (err)
+		return -ENOSPC;
-		return err;
 	err = fscrypt_prepare_symlink(dir, symname, len, dir->i_sb->s_blocksize,
 				      &disk_link);
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
-	err = f2fs_is_checkpoint_ready(sbi);
+	if (!f2fs_is_checkpoint_ready(sbi))
-	if (err)
+		return -ENOSPC;
-		return err;
 	err = dquot_initialize(dir);
 	if (err)
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
+	if (!f2fs_is_checkpoint_ready(sbi))
+		return -ENOSPC;
 	if (IS_ENCRYPTED(dir) || DUMMY_ENCRYPTION_ENABLED(sbi)) {
 		int err = fscrypt_get_encryption_info(dir);
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
-	err = f2fs_is_checkpoint_ready(sbi);
+	if (!f2fs_is_checkpoint_ready(sbi))
-	if (err)
+		return -ENOSPC;
-		return err;
 	if (is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
 			(!projid_eq(F2FS_I(new_dir)->i_projid,
 	if (unlikely(f2fs_cp_error(sbi)))
 		return -EIO;
-	err = f2fs_is_checkpoint_ready(sbi);
+	if (!f2fs_is_checkpoint_ready(sbi))
-	if (err)
+		return -ENOSPC;
-		return err;
 	if ((is_inode_flag_set(new_dir, FI_PROJ_INHERIT) &&
 			!projid_eq(F2FS_I(new_dir)->i_projid,
 #ifdef CONFIG_F2FS_FS_XATTR
 	.listxattr	= f2fs_listxattr,
 #endif
+	.fiemap		= f2fs_fiemap,
 };
 const struct inode_operations f2fs_symlink_inode_operations = {

fs/f2fs/node.c+54−3

@@ -1524,7 +1524,8 @@ static int __write_node_page(struct page page, bool atomic, bool submitted, · 1523 unmodified lines
1524	if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))	1524	if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
1525	goto redirty_out;	1525	goto redirty_out;
1526		1526
1527	if (wbc->sync_mode == WB_SYNC_NONE &&	1527	if (!is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
		1528	wbc->sync_mode == WB_SYNC_NONE &&
1528	IS_DNODE(page) && is_cold_node(page))	1529	IS_DNODE(page) && is_cold_node(page))
1529	goto redirty_out;	1530	goto redirty_out;
1530		1531
@@ -1762,6 +1763,47 @@ out: · 231 unmodified lines
1762	return ret ? -EIO: 0;	1763	return ret ? -EIO: 0;
1763	}	1764	}
1764		1765
		1766	static int f2fs_match_ino(struct inode inode, unsigned long ino, void data)
		1767	{
		1768	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
		1769	bool clean;
		1770
		1771	if (inode->i_ino != ino)
		1772	return 0;
		1773
		1774	if (!is_inode_flag_set(inode, FI_DIRTY_INODE))
		1775	return 0;
		1776
		1777	spin_lock(&sbi->inode_lock[DIRTY_META]);
		1778	clean = list_empty(&F2FS_I(inode)->gdirty_list);
		1779	spin_unlock(&sbi->inode_lock[DIRTY_META]);
		1780
		1781	if (clean)
		1782	return 0;
		1783
		1784	inode = igrab(inode);
		1785	if (!inode)
		1786	return 0;
		1787	return 1;
		1788	}
		1789
		1790	static bool flush_dirty_inode(struct page *page)
		1791	{
		1792	struct f2fs_sb_info *sbi = F2FS_P_SB(page);
		1793	struct inode *inode;
		1794	nid_t ino = ino_of_node(page);
		1795
		1796	inode = find_inode_nowait(sbi->sb, ino, f2fs_match_ino, NULL);
		1797	if (!inode)
		1798	return false;
		1799
		1800	f2fs_update_inode(inode, page);
		1801	unlock_page(page);
		1802
		1803	iput(inode);
		1804	return true;
		1805	}
		1806
1765	int f2fs_sync_node_pages(struct f2fs_sb_info *sbi,	1807	int f2fs_sync_node_pages(struct f2fs_sb_info *sbi,
1766	struct writeback_control *wbc,	1808	struct writeback_control *wbc,
1767	bool do_balance, enum iostat_type io_type)	1809	bool do_balance, enum iostat_type io_type)
@@ -1785,6 +1827,7 @@ next_step: · 17 unmodified lines
1785	for (i = 0; i < nr_pages; i++) {	1827	for (i = 0; i < nr_pages; i++) {
1786	struct page *page = pvec.pages[i];	1828	struct page *page = pvec.pages[i];
1787	bool submitted = false;	1829	bool submitted = false;
		1830	bool may_dirty = true;
1788		1831
1789	/* give a priority to WB_SYNC threads */	1832	/* give a priority to WB_SYNC threads */
1790	if (atomic_read(&sbi->wb_sync_req[NODE]) &&	1833	if (atomic_read(&sbi->wb_sync_req[NODE]) &&
@@ -1832,6 +1875,13 @@ continue_unlock: · 41 unmodified lines
1832	goto lock_node;	1875	goto lock_node;
1833	}	1876	}
1834		1877
		1878	/* flush dirty inode */
		1879	if (IS_INODE(page) && may_dirty) {
		1880	may_dirty = false;
		1881	if (flush_dirty_inode(page))
		1882	goto lock_node;
		1883	}
		1884
1835	f2fs_wait_on_page_writeback(page, NODE, true, true);	1885	f2fs_wait_on_page_writeback(page, NODE, true, true);
1836		1886
1837	if (!clear_page_dirty_for_io(page))	1887	if (!clear_page_dirty_for_io(page))
@@ -1860,7 +1910,8 @@ continue_unlock: · 22 unmodified lines
1860	}	1910	}
1861		1911
1862	if (step < 2) {	1912	if (step < 2) {
1863	if (wbc->sync_mode == WB_SYNC_NONE && step == 1)	1913	if (!is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
		1914	wbc->sync_mode == WB_SYNC_NONE && step == 1)
1864	goto out;	1915	goto out;
1865	step++;	1916	step++;
1866	goto next_step;	1917	goto next_step;
@@ -2964,7 +3015,7 @@ static int init_node_manager(struct f2fs_sb_info *sbi) · 1097 unmodified lines
2964		3015
2965	/* not used nids: 0, node, meta, (and root counted as valid node) */	3016	/* not used nids: 0, node, meta, (and root counted as valid node) */
2966	nm_i->available_nids = nm_i->max_nid - sbi->total_valid_node_count -	3017	nm_i->available_nids = nm_i->max_nid - sbi->total_valid_node_count -
2967	sbi->nquota_files - F2FS_RESERVED_NODE_NUM;	3018	F2FS_RESERVED_NODE_NUM;
2968	nm_i->nid_cnt[FREE_NID] = 0;	3019	nm_i->nid_cnt[FREE_NID] = 0;
2969	nm_i->nid_cnt[PREALLOC_NID] = 0;	3020	nm_i->nid_cnt[PREALLOC_NID] = 0;
2970	nm_i->nat_cnt = 0;	3021	nm_i->nat_cnt = 0;

fs/f2fs/segment.c+66−69

@@ -185,8 +185,6 @@ bool f2fs_need_SSR(struct f2fs_sb_info *sbi) · 184 unmodified lines
185		185
186	void f2fs_register_inmem_page(struct inode inode, struct page page)	186	void f2fs_register_inmem_page(struct inode inode, struct page page)
187	{	187	{
188	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
189	struct f2fs_inode_info *fi = F2FS_I(inode);
190	struct inmem_pages *new;	188	struct inmem_pages *new;
191		189
192	f2fs_trace_pid(page);	190	f2fs_trace_pid(page);
@@ -200,15 +198,11 @@ void f2fs_register_inmem_page(struct inode inode, struct page page) · 7 unmodified lines
200	INIT_LIST_HEAD(&new->list);	198	INIT_LIST_HEAD(&new->list);
201		199
202	/* increase reference count with clean state */	200	/* increase reference count with clean state */
203	mutex_lock(&fi->inmem_lock);
204	get_page(page);	201	get_page(page);
205	list_add_tail(&new->list, &fi->inmem_pages);	202	mutex_lock(&F2FS_I(inode)->inmem_lock);
206	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);	203	list_add_tail(&new->list, &F2FS_I(inode)->inmem_pages);
207	if (list_empty(&fi->inmem_ilist))
208	list_add_tail(&fi->inmem_ilist, &sbi->inode_list[ATOMIC_FILE]);
209	spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
210	inc_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);	204	inc_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
211	mutex_unlock(&fi->inmem_lock);	205	mutex_unlock(&F2FS_I(inode)->inmem_lock);
212		206
213	trace_f2fs_register_inmem_page(page, INMEM);	207	trace_f2fs_register_inmem_page(page, INMEM);
214	}	208	}
@@ -330,19 +324,17 @@ void f2fs_drop_inmem_pages(struct inode *inode) · 115 unmodified lines
330	mutex_lock(&fi->inmem_lock);	324	mutex_lock(&fi->inmem_lock);
331	__revoke_inmem_pages(inode, &fi->inmem_pages,	325	__revoke_inmem_pages(inode, &fi->inmem_pages,
332	true, false, true);	326	true, false, true);
333
334	if (list_empty(&fi->inmem_pages)) {
335	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
336	if (!list_empty(&fi->inmem_ilist))
337	list_del_init(&fi->inmem_ilist);
338	spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
339	}
340	mutex_unlock(&fi->inmem_lock);	327	mutex_unlock(&fi->inmem_lock);
341	}	328	}
342		329
343	clear_inode_flag(inode, FI_ATOMIC_FILE);	330	clear_inode_flag(inode, FI_ATOMIC_FILE);
344	fi->i_gc_failures[GC_FAILURE_ATOMIC] = 0;	331	fi->i_gc_failures[GC_FAILURE_ATOMIC] = 0;
345	stat_dec_atomic_write(inode);	332	stat_dec_atomic_write(inode);
		333
		334	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
		335	if (!list_empty(&fi->inmem_ilist))
		336	list_del_init(&fi->inmem_ilist);
		337	spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
346	}	338	}
347		339
348	void f2fs_drop_inmem_page(struct inode inode, struct page page)	340	void f2fs_drop_inmem_page(struct inode inode, struct page page)
@@ -471,11 +463,6 @@ int f2fs_commit_inmem_pages(struct inode *inode) · 122 unmodified lines
471		463
472	mutex_lock(&fi->inmem_lock);	464	mutex_lock(&fi->inmem_lock);
473	err = __f2fs_commit_inmem_pages(inode);	465	err = __f2fs_commit_inmem_pages(inode);
474
475	spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
476	if (!list_empty(&fi->inmem_ilist))
477	list_del_init(&fi->inmem_ilist);
478	spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
479	mutex_unlock(&fi->inmem_lock);	466	mutex_unlock(&fi->inmem_lock);
480		467
481	clear_inode_flag(inode, FI_ATOMIC_COMMIT);	468	clear_inode_flag(inode, FI_ATOMIC_COMMIT);
@@ -501,7 +488,7 @@ void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need) · 19 unmodified lines
501	if (need && excess_cached_nats(sbi))	488	if (need && excess_cached_nats(sbi))
502	f2fs_balance_fs_bg(sbi);	489	f2fs_balance_fs_bg(sbi);
503		490
504	if (f2fs_is_checkpoint_ready(sbi))	491	if (!f2fs_is_checkpoint_ready(sbi))
505	return;	492	return;
506		493
507	/*	494	/*
@@ -817,9 +804,13 @@ static void __remove_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno, · 309 unmodified lines
817	if (test_and_clear_bit(segno, dirty_i->dirty_segmap[t]))	804	if (test_and_clear_bit(segno, dirty_i->dirty_segmap[t]))
818	dirty_i->nr_dirty[t]--;	805	dirty_i->nr_dirty[t]--;
819		806
820	if (get_valid_blocks(sbi, segno, true) == 0)	807	if (get_valid_blocks(sbi, segno, true) == 0) {
821	clear_bit(GET_SEC_FROM_SEG(sbi, segno),	808	clear_bit(GET_SEC_FROM_SEG(sbi, segno),
822	dirty_i->victim_secmap);	809	dirty_i->victim_secmap);
		810	#ifdef CONFIG_F2FS_CHECK_FS
		811	clear_bit(segno, SIT_I(sbi)->invalid_segmap);
		812	#endif
		813	}
823	}	814	}
824	}	815	}
825		816
@@ -2084,6 +2075,13 @@ static void destroy_discard_cmd_control(struct f2fs_sb_info *sbi) · 1258 unmodified lines
2084		2075
2085	f2fs_stop_discard_thread(sbi);	2076	f2fs_stop_discard_thread(sbi);
2086		2077
		2078	/*
		2079	* Recovery can cache discard commands, so in error path of
		2080	* fill_super(), it needs to give a chance to handle them.
		2081	*/
		2082	if (unlikely(atomic_read(&dcc->discard_cmd_cnt)))
		2083	f2fs_issue_discard_timeout(sbi);
		2084
2087	kvfree(dcc);	2085	kvfree(dcc);
2088	SM_I(sbi)->dcc_info = NULL;	2086	SM_I(sbi)->dcc_info = NULL;
2089	}	2087	}
@@ -2156,9 +2154,11 @@ static void update_sit_entry(struct f2fs_sb_info *sbi, block_t blkaddr, int del) · 66 unmodified lines
2156	if (!f2fs_test_and_set_bit(offset, se->discard_map))	2154	if (!f2fs_test_and_set_bit(offset, se->discard_map))
2157	sbi->discard_blks--;	2155	sbi->discard_blks--;
2158		2156
2159	/* don't overwrite by SSR to keep node chain */	2157	/*
2160	if (IS_NODESEG(se->type) &&	2158	* SSR should never reuse block which is checkpointed
2161	!is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {	2159	* or newly invalidated.
		2160	*/
		2161	if (!is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {
2162	if (!f2fs_test_and_set_bit(offset, se->ckpt_valid_map))	2162	if (!f2fs_test_and_set_bit(offset, se->ckpt_valid_map))
2163	se->ckpt_valid_blocks++;	2163	se->ckpt_valid_blocks++;
2164	}	2164	}
@@ -3116,12 +3116,14 @@ void f2fs_allocate_data_block(struct f2fs_sb_info sbi, struct page page, · 951 unmodified lines
3116	f2fs_inode_chksum_set(sbi, page);	3116	f2fs_inode_chksum_set(sbi, page);
3117	}	3117	}
3118		3118
		3119	if (F2FS_IO_ALIGNED(sbi))
		3120	fio->retry = false;
		3121
3119	if (add_list) {	3122	if (add_list) {
3120	struct f2fs_bio_info *io;	3123	struct f2fs_bio_info *io;
3121		3124
3122	INIT_LIST_HEAD(&fio->list);	3125	INIT_LIST_HEAD(&fio->list);
3123	fio->in_list = true;	3126	fio->in_list = true;
3124	fio->retry = false;
3125	io = sbi->write_io[fio->type] + fio->temp;	3127	io = sbi->write_io[fio->type] + fio->temp;
3126	spin_lock(&io->io_lock);	3128	spin_lock(&io->io_lock);
3127	list_add_tail(&fio->list, &io->io_list);	3129	list_add_tail(&fio->list, &io->io_list);
@@ -3447,11 +3449,6 @@ static int read_compacted_summaries(struct f2fs_sb_info *sbi) · 319 unmodified lines
3447	seg_i = CURSEG_I(sbi, i);	3449	seg_i = CURSEG_I(sbi, i);
3448	segno = le32_to_cpu(ckpt->cur_data_segno[i]);	3450	segno = le32_to_cpu(ckpt->cur_data_segno[i]);
3449	blk_off = le16_to_cpu(ckpt->cur_data_blkoff[i]);	3451	blk_off = le16_to_cpu(ckpt->cur_data_blkoff[i]);
3450	if (blk_off > ENTRIES_IN_SUM) {
3451	f2fs_bug_on(sbi, 1);
3452	f2fs_put_page(page, 1);
3453	return -EFAULT;
3454	}
3455	seg_i->next_segno = segno;	3452	seg_i->next_segno = segno;
3456	reset_curseg(sbi, i, 0);	3453	reset_curseg(sbi, i, 0);
3457	seg_i->alloc_type = ckpt->alloc_type[i];	3454	seg_i->alloc_type = ckpt->alloc_type[i];
@@ -3941,8 +3938,8 @@ static int build_sit_info(struct f2fs_sb_info *sbi) · 483 unmodified lines
3941	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);	3938	struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
3942	struct sit_info *sit_i;	3939	struct sit_info *sit_i;
3943	unsigned int sit_segs, start;	3940	unsigned int sit_segs, start;
3944	char *src_bitmap;	3941	char src_bitmap, bitmap;
3945	unsigned int bitmap_size;	3942	unsigned int bitmap_size, main_bitmap_size, sit_bitmap_size;
3946		3943
3947	/* allocate memory for SIT information */	3944	/* allocate memory for SIT information */
3948	sit_i = f2fs_kzalloc(sbi, sizeof(struct sit_info), GFP_KERNEL);	3945	sit_i = f2fs_kzalloc(sbi, sizeof(struct sit_info), GFP_KERNEL);
@@ -3958,33 +3955,37 @@ static int build_sit_info(struct f2fs_sb_info *sbi) · 9 unmodified lines
3958	if (!sit_i->sentries)	3955	if (!sit_i->sentries)
3959	return -ENOMEM;	3956	return -ENOMEM;
3960		3957
3961	bitmap_size = f2fs_bitmap_size(MAIN_SEGS(sbi));	3958	main_bitmap_size = f2fs_bitmap_size(MAIN_SEGS(sbi));
3962	sit_i->dirty_sentries_bitmap = f2fs_kvzalloc(sbi, bitmap_size,	3959	sit_i->dirty_sentries_bitmap = f2fs_kvzalloc(sbi, main_bitmap_size,
3963	GFP_KERNEL);	3960	GFP_KERNEL);
3964	if (!sit_i->dirty_sentries_bitmap)	3961	if (!sit_i->dirty_sentries_bitmap)
3965	return -ENOMEM;	3962	return -ENOMEM;
3966		3963
		3964	#ifdef CONFIG_F2FS_CHECK_FS
		3965	bitmap_size = MAIN_SEGS(sbi) * SIT_VBLOCK_MAP_SIZE * 4;
		3966	#else
		3967	bitmap_size = MAIN_SEGS(sbi) * SIT_VBLOCK_MAP_SIZE * 3;
		3968	#endif
		3969	sit_i->bitmap = f2fs_kvzalloc(sbi, bitmap_size, GFP_KERNEL);
		3970	if (!sit_i->bitmap)
		3971	return -ENOMEM;
		3972
		3973	bitmap = sit_i->bitmap;
		3974
3967	for (start = 0; start < MAIN_SEGS(sbi); start++) {	3975	for (start = 0; start < MAIN_SEGS(sbi); start++) {
3968	sit_i->sentries[start].cur_valid_map	3976	sit_i->sentries[start].cur_valid_map = bitmap;
3969	= f2fs_kzalloc(sbi, SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);	3977	bitmap += SIT_VBLOCK_MAP_SIZE;
3970	sit_i->sentries[start].ckpt_valid_map	3978
3971	= f2fs_kzalloc(sbi, SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);	3979	sit_i->sentries[start].ckpt_valid_map = bitmap;
3972	if (!sit_i->sentries[start].cur_valid_map \|\|	3980	bitmap += SIT_VBLOCK_MAP_SIZE;
3973	!sit_i->sentries[start].ckpt_valid_map)
3974	return -ENOMEM;
3975		3981
3976	#ifdef CONFIG_F2FS_CHECK_FS	3982	#ifdef CONFIG_F2FS_CHECK_FS
3977	sit_i->sentries[start].cur_valid_map_mir	3983	sit_i->sentries[start].cur_valid_map_mir = bitmap;
3978	= f2fs_kzalloc(sbi, SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);	3984	bitmap += SIT_VBLOCK_MAP_SIZE;
3979	if (!sit_i->sentries[start].cur_valid_map_mir)
3980	return -ENOMEM;
3981	#endif	3985	#endif
3982		3986
3983	sit_i->sentries[start].discard_map	3987	sit_i->sentries[start].discard_map = bitmap;
3984	= f2fs_kzalloc(sbi, SIT_VBLOCK_MAP_SIZE,	3988	bitmap += SIT_VBLOCK_MAP_SIZE;
3985	GFP_KERNEL);
3986	if (!sit_i->sentries[start].discard_map)
3987	return -ENOMEM;
3988	}	3989	}
3989		3990
3990	sit_i->tmp_map = f2fs_kzalloc(sbi, SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);	3991	sit_i->tmp_map = f2fs_kzalloc(sbi, SIT_VBLOCK_MAP_SIZE, GFP_KERNEL);
@@ -4004,17 +4005,23 @@ static int build_sit_info(struct f2fs_sb_info *sbi) · 13 unmodified lines
4004	sit_segs = le32_to_cpu(raw_super->segment_count_sit) >> 1;	4005	sit_segs = le32_to_cpu(raw_super->segment_count_sit) >> 1;
4005		4006
4006	/* setup SIT bitmap from ckeckpoint pack */	4007	/* setup SIT bitmap from ckeckpoint pack */
4007	bitmap_size = __bitmap_size(sbi, SIT_BITMAP);	4008	sit_bitmap_size = __bitmap_size(sbi, SIT_BITMAP);
4008	src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP);	4009	src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP);
4009		4010
4010	sit_i->sit_bitmap = kmemdup(src_bitmap, bitmap_size, GFP_KERNEL);	4011	sit_i->sit_bitmap = kmemdup(src_bitmap, sit_bitmap_size, GFP_KERNEL);
4011	if (!sit_i->sit_bitmap)	4012	if (!sit_i->sit_bitmap)
4012	return -ENOMEM;	4013	return -ENOMEM;
4013		4014
4014	#ifdef CONFIG_F2FS_CHECK_FS	4015	#ifdef CONFIG_F2FS_CHECK_FS
4015	sit_i->sit_bitmap_mir = kmemdup(src_bitmap, bitmap_size, GFP_KERNEL);	4016	sit_i->sit_bitmap_mir = kmemdup(src_bitmap,
		4017	sit_bitmap_size, GFP_KERNEL);
4016	if (!sit_i->sit_bitmap_mir)	4018	if (!sit_i->sit_bitmap_mir)
4017	return -ENOMEM;	4019	return -ENOMEM;
		4020
		4021	sit_i->invalid_segmap = f2fs_kvzalloc(sbi,
		4022	main_bitmap_size, GFP_KERNEL);
		4023	if (!sit_i->invalid_segmap)
		4024	return -ENOMEM;
4018	#endif	4025	#endif
4019		4026
4020	/* init SIT information */	4027	/* init SIT information */
@@ -4023,7 +4030,7 @@ static int build_sit_info(struct f2fs_sb_info *sbi) · 2 unmodified lines
4023	sit_i->sit_base_addr = le32_to_cpu(raw_super->sit_blkaddr);	4030	sit_i->sit_base_addr = le32_to_cpu(raw_super->sit_blkaddr);
4024	sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg;	4031	sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg;
4025	sit_i->written_valid_blocks = 0;	4032	sit_i->written_valid_blocks = 0;
4026	sit_i->bitmap_size = bitmap_size;	4033	sit_i->bitmap_size = sit_bitmap_size;
4027	sit_i->dirty_sentries = 0;	4034	sit_i->dirty_sentries = 0;
4028	sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK;	4035	sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK;
4029	sit_i->elapsed_time = le64_to_cpu(sbi->ckpt->elapsed_time);	4036	sit_i->elapsed_time = le64_to_cpu(sbi->ckpt->elapsed_time);
@@ -4161,7 +4168,6 @@ static int build_sit_entries(struct f2fs_sb_info *sbi) · 131 unmodified lines
4161	if (start >= MAIN_SEGS(sbi)) {	4168	if (start >= MAIN_SEGS(sbi)) {
4162	f2fs_err(sbi, "Wrong journal entry on segno %u",	4169	f2fs_err(sbi, "Wrong journal entry on segno %u",
4163	start);	4170	start);
4164	set_sbi_flag(sbi, SBI_NEED_FSCK);
4165	err = -EFSCORRUPTED;	4171	err = -EFSCORRUPTED;
4166	break;	4172	break;
4167	}	4173	}
@@ -4201,7 +4207,6 @@ static int build_sit_entries(struct f2fs_sb_info *sbi) · 33 unmodified lines
4201	if (!err && total_node_blocks != valid_node_count(sbi)) {	4207	if (!err && total_node_blocks != valid_node_count(sbi)) {
4202	f2fs_err(sbi, "SIT is corrupted node# %u vs %u",	4208	f2fs_err(sbi, "SIT is corrupted node# %u vs %u",
4203	total_node_blocks, valid_node_count(sbi));	4209	total_node_blocks, valid_node_count(sbi));
4204	set_sbi_flag(sbi, SBI_NEED_FSCK);
4205	err = -EFSCORRUPTED;	4210	err = -EFSCORRUPTED;
4206	}	4211	}
4207		4212
@@ -4492,21 +4497,12 @@ static void destroy_free_segmap(struct f2fs_sb_info *sbi) · 284 unmodified lines
4492	static void destroy_sit_info(struct f2fs_sb_info *sbi)	4497	static void destroy_sit_info(struct f2fs_sb_info *sbi)
4493	{	4498	{
4494	struct sit_info *sit_i = SIT_I(sbi);	4499	struct sit_info *sit_i = SIT_I(sbi);
4495	unsigned int start;
4496		4500
4497	if (!sit_i)	4501	if (!sit_i)
4498	return;	4502	return;
4499		4503
4500	if (sit_i->sentries) {	4504	if (sit_i->sentries)
4501	for (start = 0; start < MAIN_SEGS(sbi); start++) {	4505	kvfree(sit_i->bitmap);
4502	kvfree(sit_i->sentries[start].cur_valid_map);
4503	#ifdef CONFIG_F2FS_CHECK_FS
4504	kvfree(sit_i->sentries[start].cur_valid_map_mir);
4505	#endif
4506	kvfree(sit_i->sentries[start].ckpt_valid_map);
4507	kvfree(sit_i->sentries[start].discard_map);
4508	}
4509	}
4510	kvfree(sit_i->tmp_map);	4506	kvfree(sit_i->tmp_map);
4511		4507
4512	kvfree(sit_i->sentries);	4508	kvfree(sit_i->sentries);
@@ -4517,6 +4513,7 @@ static void destroy_sit_info(struct f2fs_sb_info *sbi) · 4 unmodified lines
4517	kvfree(sit_i->sit_bitmap);	4513	kvfree(sit_i->sit_bitmap);
4518	#ifdef CONFIG_F2FS_CHECK_FS	4514	#ifdef CONFIG_F2FS_CHECK_FS
4519	kvfree(sit_i->sit_bitmap_mir);	4515	kvfree(sit_i->sit_bitmap_mir);
		4516	kvfree(sit_i->invalid_segmap);
4520	#endif	4517	#endif
4521	kvfree(sit_i);	4518	kvfree(sit_i);
4522	}	4519	}

fs/f2fs/segment.h+8−4

 	block_t sit_base_addr;		/* start block address of SIT area */
 	block_t sit_blocks;		/* # of blocks used by SIT area */
 	block_t written_valid_blocks;	/* # of valid blocks in main area */
+	char *bitmap;			/* all bitmaps pointer */
 	char *sit_bitmap;		/* SIT bitmap pointer */
 #ifdef CONFIG_F2FS_CHECK_FS
 	char *sit_bitmap_mir;		/* SIT bitmap mirror */
+	/* bitmap of segments to be ignored by GC in case of errors */
+	unsigned long *invalid_segmap;
 #endif
 	unsigned int bitmap_size;	/* SIT bitmap size */
 		reserved_sections(sbi) + needed);
 }
-static inline int f2fs_is_checkpoint_ready(struct f2fs_sb_info *sbi)
+static inline bool f2fs_is_checkpoint_ready(struct f2fs_sb_info *sbi)
 {
 	if (likely(!is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
-		return 0;
+		return true;
 	if (likely(!has_not_enough_free_secs(sbi, 0, 0)))
-		return 0;
+		return true;
-	return -ENOSPC;
+	return false;
 }
 static inline bool excess_prefree_segs(struct f2fs_sb_info *sbi)

fs/f2fs/super.c+147−9

@@ -23,6 +23,7 @@ · 22 unmodified lines
23	#include <linux/f2fs_fs.h>	23	#include <linux/f2fs_fs.h>
24	#include <linux/sysfs.h>	24	#include <linux/sysfs.h>
25	#include <linux/quota.h>	25	#include <linux/quota.h>
		26	#include <linux/unicode.h>
26		27
27	#include "f2fs.h"	28	#include "f2fs.h"
28	#include "node.h"	29	#include "node.h"
@@ -222,6 +223,36 @@ void f2fs_printk(struct f2fs_sb_info sbi, const char fmt, ...) · 193 unmodified lines
222	va_end(args);	223	va_end(args);
223	}	224	}
224		225
		226	#ifdef CONFIG_UNICODE
		227	static const struct f2fs_sb_encodings {
		228	__u16 magic;
		229	char *name;
		230	char *version;
		231	} f2fs_sb_encoding_map[] = {
		232	{F2FS_ENC_UTF8_12_1, "utf8", "12.1.0"},
		233	};
		234
		235	static int f2fs_sb_read_encoding(const struct f2fs_super_block *sb,
		236	const struct f2fs_sb_encodings **encoding,
		237	__u16 *flags)
		238	{
		239	__u16 magic = le16_to_cpu(sb->s_encoding);
		240	int i;
		241
		242	for (i = 0; i < ARRAY_SIZE(f2fs_sb_encoding_map); i++)
		243	if (magic == f2fs_sb_encoding_map[i].magic)
		244	break;
		245
		246	if (i >= ARRAY_SIZE(f2fs_sb_encoding_map))
		247	return -EINVAL;
		248
		249	*encoding = &f2fs_sb_encoding_map[i];
		250	*flags = le16_to_cpu(sb->s_encoding_flags);
		251
		252	return 0;
		253	}
		254	#endif
		255
225	static inline void limit_reserve_root(struct f2fs_sb_info *sbi)	256	static inline void limit_reserve_root(struct f2fs_sb_info *sbi)
226	{	257	{
227	block_t limit = min((sbi->user_block_count << 1) / 1000,	258	block_t limit = min((sbi->user_block_count << 1) / 1000,
@@ -798,6 +829,13 @@ static int parse_options(struct super_block sb, char options) · 570 unmodified lines
798	return -EINVAL;	829	return -EINVAL;
799	}	830	}
800	#endif	831	#endif
		832	#ifndef CONFIG_UNICODE
		833	if (f2fs_sb_has_casefold(sbi)) {
		834	f2fs_err(sbi,
		835	"Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
		836	return -EINVAL;
		837	}
		838	#endif
801		839
802	if (F2FS_IO_SIZE_BITS(sbi) && !test_opt(sbi, LFS)) {	840	if (F2FS_IO_SIZE_BITS(sbi) && !test_opt(sbi, LFS)) {
803	f2fs_err(sbi, "Should set mode=lfs with %uKB-sized IO",	841	f2fs_err(sbi, "Should set mode=lfs with %uKB-sized IO",
@@ -873,7 +911,21 @@ static struct inode f2fs_alloc_inode(struct super_block sb) · 69 unmodified lines
873		911
874	static int f2fs_drop_inode(struct inode *inode)	912	static int f2fs_drop_inode(struct inode *inode)
875	{	913	{
		914	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
876	int ret;	915	int ret;
		916
		917	/*
		918	* during filesystem shutdown, if checkpoint is disabled,
		919	* drop useless meta/node dirty pages.
		920	*/
		921	if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED))) {
		922	if (inode->i_ino == F2FS_NODE_INO(sbi) \|\|
		923	inode->i_ino == F2FS_META_INO(sbi)) {
		924	trace_f2fs_drop_inode(inode, 1);
		925	return 1;
		926	}
		927	}
		928
877	/*	929	/*
878	* This is to avoid a deadlock condition like below.	930	* This is to avoid a deadlock condition like below.
879	* writeback_single_inode(inode)	931	* writeback_single_inode(inode)
@@ -1091,6 +1143,9 @@ static void f2fs_put_super(struct super_block *sb) · 211 unmodified lines
1091	destroy_percpu_info(sbi);	1143	destroy_percpu_info(sbi);
1092	for (i = 0; i < NR_PAGE_TYPE; i++)	1144	for (i = 0; i < NR_PAGE_TYPE; i++)
1093	kvfree(sbi->write_io[i]);	1145	kvfree(sbi->write_io[i]);
		1146	#ifdef CONFIG_UNICODE
		1147	utf8_unload(sbi->s_encoding);
		1148	#endif
1094	kvfree(sbi);	1149	kvfree(sbi);
1095	}	1150	}
1096		1151
@@ -1216,8 +1271,7 @@ static int f2fs_statfs(struct dentry dentry, struct kstatfs buf) · 119 unmodified lines
1216	else	1271	else
1217	buf->f_bavail = 0;	1272	buf->f_bavail = 0;
1218		1273
1219	avail_node_count = sbi->total_node_count - sbi->nquota_files -	1274	avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
1220	F2FS_RESERVED_NODE_NUM;
1221		1275
1222	if (avail_node_count > user_block_count) {	1276	if (avail_node_count > user_block_count) {
1223	buf->f_files = user_block_count;	1277	buf->f_files = user_block_count;
@@ -1524,6 +1578,7 @@ static int f2fs_remount(struct super_block sb, int flags, char *data) · 300 unmodified lines
1524	bool need_stop_gc = false;	1578	bool need_stop_gc = false;
1525	bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);	1579	bool no_extent_cache = !test_opt(sbi, EXTENT_CACHE);
1526	bool disable_checkpoint = test_opt(sbi, DISABLE_CHECKPOINT);	1580	bool disable_checkpoint = test_opt(sbi, DISABLE_CHECKPOINT);
		1581	bool no_io_align = !F2FS_IO_ALIGNED(sbi);
1527	bool checkpoint_changed;	1582	bool checkpoint_changed;
1528	#ifdef CONFIG_QUOTA	1583	#ifdef CONFIG_QUOTA
1529	int i, j;	1584	int i, j;
@@ -1603,6 +1658,12 @@ static int f2fs_remount(struct super_block sb, int flags, char *data) · 73 unmodified lines
1603	goto restore_opts;	1658	goto restore_opts;
1604	}	1659	}
1605		1660
		1661	if (no_io_align == !!F2FS_IO_ALIGNED(sbi)) {
		1662	err = -EINVAL;
		1663	f2fs_warn(sbi, "switch io_bits option is not allowed");
		1664	goto restore_opts;
		1665	}
		1666
1606	if ((*flags & SB_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {	1667	if ((*flags & SB_RDONLY) && test_opt(sbi, DISABLE_CHECKPOINT)) {
1607	err = -EINVAL;	1668	err = -EINVAL;
1608	f2fs_warn(sbi, "disabling checkpoint not compatible with read-only");	1669	f2fs_warn(sbi, "disabling checkpoint not compatible with read-only");
@@ -1981,6 +2042,12 @@ static int f2fs_quota_on(struct super_block *sb, int type, int format_id, · 372 unmodified lines
1981	struct inode *inode;	2042	struct inode *inode;
1982	int err;	2043	int err;
1983		2044
		2045	/* if quota sysfile exists, deny enabling quota with specific file */
		2046	if (f2fs_sb_has_quota_ino(F2FS_SB(sb))) {
		2047	f2fs_err(F2FS_SB(sb), "quota sysfile already exists");
		2048	return -EBUSY;
		2049	}
		2050
1984	err = f2fs_quota_sync(sb, type);	2051	err = f2fs_quota_sync(sb, type);
1985	if (err)	2052	if (err)
1986	return err;	2053	return err;
@@ -2000,7 +2067,7 @@ static int f2fs_quota_on(struct super_block *sb, int type, int format_id, · 13 unmodified lines
2000	return 0;	2067	return 0;
2001	}	2068	}
2002		2069
2003	static int f2fs_quota_off(struct super_block *sb, int type)	2070	static int __f2fs_quota_off(struct super_block *sb, int type)
2004	{	2071	{
2005	struct inode *inode = sb_dqopt(sb)->files[type];	2072	struct inode *inode = sb_dqopt(sb)->files[type];
2006	int err;	2073	int err;
@@ -2026,13 +2093,30 @@ out_put: · 19 unmodified lines
2026	return err;	2093	return err;
2027	}	2094	}
2028		2095
		2096	static int f2fs_quota_off(struct super_block *sb, int type)
		2097	{
		2098	struct f2fs_sb_info *sbi = F2FS_SB(sb);
		2099	int err;
		2100
		2101	err = __f2fs_quota_off(sb, type);
		2102
		2103	/*
		2104	* quotactl can shutdown journalled quota, result in inconsistence
		2105	* between quota record and fs data by following updates, tag the
		2106	* flag to let fsck be aware of it.
		2107	*/
		2108	if (is_journalled_quota(sbi))
		2109	set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
		2110	return err;
		2111	}
		2112
2029	void f2fs_quota_off_umount(struct super_block *sb)	2113	void f2fs_quota_off_umount(struct super_block *sb)
2030	{	2114	{
2031	int type;	2115	int type;
2032	int err;	2116	int err;
2033		2117
2034	for (type = 0; type < MAXQUOTAS; type++) {	2118	for (type = 0; type < MAXQUOTAS; type++) {
2035	err = f2fs_quota_off(sb, type);	2119	err = __f2fs_quota_off(sb, type);
2036	if (err) {	2120	if (err) {
2037	int ret = dquot_quota_off(sb, type);	2121	int ret = dquot_quota_off(sb, type);
2038		2122
@@ -2617,8 +2701,7 @@ int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi) · 578 unmodified lines
2617	}	2701	}
2618		2702
2619	valid_node_count = le32_to_cpu(ckpt->valid_node_count);	2703	valid_node_count = le32_to_cpu(ckpt->valid_node_count);
2620	avail_node_count = sbi->total_node_count - sbi->nquota_files -	2704	avail_node_count = sbi->total_node_count - F2FS_RESERVED_NODE_NUM;
2621	F2FS_RESERVED_NODE_NUM;
2622	if (valid_node_count > avail_node_count) {	2705	if (valid_node_count > avail_node_count) {
2623	f2fs_err(sbi, "Wrong valid_node_count: %u, avail_node_count: %u",	2706	f2fs_err(sbi, "Wrong valid_node_count: %u, avail_node_count: %u",
2624	valid_node_count, avail_node_count);	2707	valid_node_count, avail_node_count);
@@ -2657,10 +2740,10 @@ int f2fs_sanity_check_ckpt(struct f2fs_sb_info *sbi) · 32 unmodified lines
2657	}	2740	}
2658	}	2741	}
2659	for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {	2742	for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {
2660	for (j = i; j < NR_CURSEG_DATA_TYPE; j++) {	2743	for (j = 0; j < NR_CURSEG_DATA_TYPE; j++) {
2661	if (le32_to_cpu(ckpt->cur_node_segno[i]) ==	2744	if (le32_to_cpu(ckpt->cur_node_segno[i]) ==
2662	le32_to_cpu(ckpt->cur_data_segno[j])) {	2745	le32_to_cpu(ckpt->cur_data_segno[j])) {
2663	f2fs_err(sbi, "Data segment (%u) and Data segment (%u) has the same segno: %u",	2746	f2fs_err(sbi, "Node segment (%u) and Data segment (%u) has the same segno: %u",
2664	i, j,	2747	i, j,
2665	le32_to_cpu(ckpt->cur_node_segno[i]));	2748	le32_to_cpu(ckpt->cur_node_segno[i]));
2666	return 1;	2749	return 1;
@@ -3033,6 +3116,53 @@ static int f2fs_scan_devices(struct f2fs_sb_info *sbi) · 366 unmodified lines
3033	return 0;	3116	return 0;
3034	}	3117	}
3035		3118
		3119	static int f2fs_setup_casefold(struct f2fs_sb_info *sbi)
		3120	{
		3121	#ifdef CONFIG_UNICODE
		3122	if (f2fs_sb_has_casefold(sbi) && !sbi->s_encoding) {
		3123	const struct f2fs_sb_encodings *encoding_info;
		3124	struct unicode_map *encoding;
		3125	__u16 encoding_flags;
		3126
		3127	if (f2fs_sb_has_encrypt(sbi)) {
		3128	f2fs_err(sbi,
		3129	"Can't mount with encoding and encryption");
		3130	return -EINVAL;
		3131	}
		3132
		3133	if (f2fs_sb_read_encoding(sbi->raw_super, &encoding_info,
		3134	&encoding_flags)) {
		3135	f2fs_err(sbi,
		3136	"Encoding requested by superblock is unknown");
		3137	return -EINVAL;
		3138	}
		3139
		3140	encoding = utf8_load(encoding_info->version);
		3141	if (IS_ERR(encoding)) {
		3142	f2fs_err(sbi,
		3143	"can't mount with superblock charset: %s-%s "
		3144	"not supported by the kernel. flags: 0x%x.",
		3145	encoding_info->name, encoding_info->version,
		3146	encoding_flags);
		3147	return PTR_ERR(encoding);
		3148	}
		3149	f2fs_info(sbi, "Using encoding defined by superblock: "
		3150	"%s-%s with flags 0x%hx", encoding_info->name,
		3151	encoding_info->version?:"\b", encoding_flags);
		3152
		3153	sbi->s_encoding = encoding;
		3154	sbi->s_encoding_flags = encoding_flags;
		3155	sbi->sb->s_d_op = &f2fs_dentry_ops;
		3156	}
		3157	#else
		3158	if (f2fs_sb_has_casefold(sbi)) {
		3159	f2fs_err(sbi, "Filesystem with casefold feature cannot be mounted without CONFIG_UNICODE");
		3160	return -EINVAL;
		3161	}
		3162	#endif
		3163	return 0;
		3164	}
		3165
3036	static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)	3166	static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
3037	{	3167	{
3038	struct f2fs_sm_info *sm_i = SM_I(sbi);	3168	struct f2fs_sm_info *sm_i = SM_I(sbi);
@@ -3129,6 +3259,10 @@ try_onemore: · 90 unmodified lines
3129	le32_to_cpu(raw_super->log_blocksize);	3259	le32_to_cpu(raw_super->log_blocksize);
3130	sb->s_max_links = F2FS_LINK_MAX;	3260	sb->s_max_links = F2FS_LINK_MAX;
3131		3261
		3262	err = f2fs_setup_casefold(sbi);
		3263	if (err)
		3264	goto free_options;
		3265
3132	#ifdef CONFIG_QUOTA	3266	#ifdef CONFIG_QUOTA
3133	sb->dq_op = &f2fs_quota_operations;	3267	sb->dq_op = &f2fs_quota_operations;
3134	sb->s_qcop = &f2fs_quotactl_ops;	3268	sb->s_qcop = &f2fs_quotactl_ops;
@@ -3207,7 +3341,7 @@ try_onemore: · 72 unmodified lines
3207	if (err)	3341	if (err)
3208	goto free_bio_info;	3342	goto free_bio_info;
3209		3343
3210	if (F2FS_IO_SIZE(sbi) > 1) {	3344	if (F2FS_IO_ALIGNED(sbi)) {
3211	sbi->write_io_dummy =	3345	sbi->write_io_dummy =
3212	mempool_create_page_pool(2 * (F2FS_IO_SIZE(sbi) - 1), 0);	3346	mempool_create_page_pool(2 * (F2FS_IO_SIZE(sbi) - 1), 0);
3213	if (!sbi->write_io_dummy) {	3347	if (!sbi->write_io_dummy) {
@@ -3482,6 +3616,10 @@ free_percpu: · 268 unmodified lines
3482	free_bio_info:	3616	free_bio_info:
3483	for (i = 0; i < NR_PAGE_TYPE; i++)	3617	for (i = 0; i < NR_PAGE_TYPE; i++)
3484	kvfree(sbi->write_io[i]);	3618	kvfree(sbi->write_io[i]);
		3619
		3620	#ifdef CONFIG_UNICODE
		3621	utf8_unload(sbi->s_encoding);
		3622	#endif
3485	free_options:	3623	free_options:
3486	#ifdef CONFIG_QUOTA	3624	#ifdef CONFIG_QUOTA
3487	for (i = 0; i < MAXQUOTAS; i++)	3625	for (i = 0; i < MAXQUOTAS; i++)

fs/f2fs/sysfs.c+23−0

 #include <linux/proc_fs.h>
 #include <linux/f2fs_fs.h>
 #include <linux/seq_file.h>
+#include <linux/unicode.h>
 #include "f2fs.h"
 #include "segment.h"
 		(unsigned long long)unusable);
 }
+static ssize_t encoding_show(struct f2fs_attr *a,
+		struct f2fs_sb_info *sbi, char *buf)
+{
+#ifdef CONFIG_UNICODE
+	if (f2fs_sb_has_casefold(sbi))
+		return snprintf(buf, PAGE_SIZE, "%s (%d.%d.%d)\n",
+			sbi->s_encoding->charset,
+			(sbi->s_encoding->version >> 16) & 0xff,
+			(sbi->s_encoding->version >> 8) & 0xff,
+			sbi->s_encoding->version & 0xff);
+#endif
+	return snprintf(buf, PAGE_SIZE, "(none)");
+}
 static ssize_t lifetime_write_kbytes_show(struct f2fs_attr *a,
 		struct f2fs_sb_info *sbi, char *buf)
 	if (f2fs_sb_has_sb_chksum(sbi))
 		len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
 				len ? ", " : "", "sb_checksum");
+	if (f2fs_sb_has_casefold(sbi))
+		len += snprintf(buf + len, PAGE_SIZE - len, "%s%s",
+				len ? ", " : "", "casefold");
 	len += snprintf(buf + len, PAGE_SIZE - len, "\n");
 	return len;
 }
 	FEAT_LOST_FOUND,
 	FEAT_VERITY,
 	FEAT_SB_CHECKSUM,
+	FEAT_CASEFOLD,
 };
 static ssize_t f2fs_feature_show(struct f2fs_attr *a,
 	case FEAT_LOST_FOUND:
 	case FEAT_VERITY:
 	case FEAT_SB_CHECKSUM:
+	case FEAT_CASEFOLD:
 		return snprintf(buf, PAGE_SIZE, "supported\n");
 	}
 	return 0;
 F2FS_GENERAL_RO_ATTR(features);
 F2FS_GENERAL_RO_ATTR(current_reserved_blocks);
 F2FS_GENERAL_RO_ATTR(unusable);
+F2FS_GENERAL_RO_ATTR(encoding);
 #ifdef CONFIG_FS_ENCRYPTION
 F2FS_FEATURE_RO_ATTR(encryption, FEAT_CRYPTO);
 F2FS_FEATURE_RO_ATTR(verity, FEAT_VERITY);
 #endif
 F2FS_FEATURE_RO_ATTR(sb_checksum, FEAT_SB_CHECKSUM);
+F2FS_FEATURE_RO_ATTR(casefold, FEAT_CASEFOLD);
 #define ATTR_LIST(name) (&f2fs_attr_##name.attr)
 static struct attribute *f2fs_attrs[] = {
 	ATTR_LIST(features),
 	ATTR_LIST(reserved_blocks),
 	ATTR_LIST(current_reserved_blocks),
+	ATTR_LIST(encoding),
 	NULL,
 };
 ATTRIBUTE_GROUPS(f2fs);
 	ATTR_LIST(verity),
 #endif
 	ATTR_LIST(sb_checksum),
+	ATTR_LIST(casefold),
 	NULL,
 };
 ATTRIBUTE_GROUPS(f2fs_feat);

fs/f2fs/xattr.c+6−0

 #include <linux/posix_acl_xattr.h>
 #include "f2fs.h"
 #include "xattr.h"
+#include "segment.h"
 static int f2fs_xattr_generic_get(const struct xattr_handler *handler,
 		struct dentry *unused, struct inode *inode,
 	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 	int err;
+	if (unlikely(f2fs_cp_error(sbi)))
+		return -EIO;
+	if (!f2fs_is_checkpoint_ready(sbi))
+		return -ENOSPC;
 	err = dquot_initialize(inode);
 	if (err)
 		return err;

include/linux/f2fs_fs.h+9−1

 #define F2FS_MAX_QUOTAS		3
+#define F2FS_ENC_UTF8_12_1	1
+#define F2FS_ENC_STRICT_MODE_FL	(1 << 0)
+#define f2fs_has_strict_mode(sbi) \
+	(sbi->s_encoding_flags & F2FS_ENC_STRICT_MODE_FL)
 #define F2FS_IO_SIZE(sbi)	(1 << F2FS_OPTION(sbi).write_io_size_bits) /* Blocks */
 #define F2FS_IO_SIZE_KB(sbi)	(1 << (F2FS_OPTION(sbi).write_io_size_bits + 2)) /* KB */
 #define F2FS_IO_SIZE_BYTES(sbi)	(1 << (F2FS_OPTION(sbi).write_io_size_bits + 12)) /* B */
 #define F2FS_IO_SIZE_BITS(sbi)	(F2FS_OPTION(sbi).write_io_size_bits) /* power of 2 */
 #define F2FS_IO_SIZE_MASK(sbi)	(F2FS_IO_SIZE(sbi) - 1)
+#define F2FS_IO_ALIGNED(sbi)	(F2FS_IO_SIZE(sbi) > 1)
 /* This flag is used by node and meta inodes, and by recovery */
 #define GFP_F2FS_ZERO		(GFP_NOFS | __GFP_ZERO)
 	struct f2fs_device devs[MAX_DEVICES];	/* device list */
 	__le32 qf_ino[F2FS_MAX_QUOTAS];	/* quota inode numbers */
 	__u8 hot_ext_count;		/* # of hot file extension */
-	__u8 reserved[310];		/* valid reserved region */
+	__le16  s_encoding;		/* Filename charset encoding */
+	__le16  s_encoding_flags;	/* Filename charset encoding flags */
+	__u8 reserved[306];		/* valid reserved region */
 	__le32 crc;			/* checksum of superblock */
 } __packed;

include/uapi/linux/fs.h+1−0

@@ -264,6 +264,7 @@ struct fsxattr { · 263 unmodified lines
264	#define FS_NOCOW_FL 0x00800000 /* Do not cow file */	264	#define FS_NOCOW_FL 0x00800000 /* Do not cow file */
265	#define FS_INLINE_DATA_FL 0x10000000 /* Reserved for ext4 */	265	#define FS_INLINE_DATA_FL 0x10000000 /* Reserved for ext4 */
266	#define FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */	266	#define FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
		267	#define FS_CASEFOLD_FL 0x40000000 /* Folder is case insensitive */
267	#define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */	268	#define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */
268		269
269	#define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */	270	#define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */

tools/include/uapi/linux/fs.h+1−0

@@ -311,6 +311,7 @@ struct fscrypt_key { · 310 unmodified lines
311	#define FS_NOCOW_FL 0x00800000 /* Do not cow file */	311	#define FS_NOCOW_FL 0x00800000 /* Do not cow file */
312	#define FS_INLINE_DATA_FL 0x10000000 /* Reserved for ext4 */	312	#define FS_INLINE_DATA_FL 0x10000000 /* Reserved for ext4 */
313	#define FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */	313	#define FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
		314	#define FS_CASEFOLD_FL 0x40000000 /* Folder is case insensitive */
314	#define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */	315	#define FS_RESERVED_FL 0x80000000 /* reserved for ext2 lib */
315		316
316	#define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */	317	#define FS_FL_USER_VISIBLE 0x0003DFFF /* User visible flags */

Merge tag 'f2fs-for-5.4' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code