export RK_PA3

hc

2024-02-19 151fecfb72a0d602dfe79790602ef64b4e241574

 kernel/fs/f2fs/verity.c
..
..
@@ -29,6 +29,8 @@
29
29
 #include "f2fs.h"
30
30
 #include "xattr.h"
31
31
 
32
+#define F2FS_VERIFY_VER	(1)
33
+
32
34
 static inline loff_t f2fs_verity_metadata_pos(const struct inode *inode)
33
35
 {
34
36
 	return round_up(inode->i_size, 65536);
..
..
@@ -45,16 +47,13 @@
45
47
 		size_t n = min_t(size_t, count,
46
48
 				 PAGE_SIZE - offset_in_page(pos));
47
49
 		struct page *page;
48
-		void *addr;
49
50
 
50
51
 		page = read_mapping_page(inode->i_mapping, pos >> PAGE_SHIFT,
51
52
 					 NULL);
52
53
 		if (IS_ERR(page))
53
54
 			return PTR_ERR(page);
54
55
 
55
-		addr = kmap_atomic(page);
56
-		memcpy(buf, addr + offset_in_page(pos), n);
57
-		kunmap_atomic(addr);
56
+		memcpy_from_page(buf, page, offset_in_page(pos), n);
58
57
 
59
58
 		put_page(page);
60
59
 
..
..
@@ -79,8 +78,7 @@
79
78
 		size_t n = min_t(size_t, count,
80
79
 				 PAGE_SIZE - offset_in_page(pos));
81
80
 		struct page *page;
82
-		void *fsdata;
83
-		void *addr;
81
+		void *fsdata = NULL;
84
82
 		int res;
85
83
 
86
84
 		res = pagecache_write_begin(NULL, inode->i_mapping, pos, n, 0,
..
..
@@ -88,9 +86,7 @@
88
86
 		if (res)
89
87
 			return res;
90
88
 
91
-		addr = kmap_atomic(page);
92
-		memcpy(addr + offset_in_page(pos), buf, n);
93
-		kunmap_atomic(addr);
89
+		memcpy_to_page(page, offset_in_page(pos), buf, n);
94
90
 
95
91
 		res = pagecache_write_end(NULL, inode->i_mapping, pos, n, n,
96
92
 					  page, fsdata);
..
..
@@ -150,40 +146,73 @@
150
146
 				  size_t desc_size, u64 merkle_tree_size)
151
147
 {
152
148
 	struct inode *inode = file_inode(filp);
149
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
153
150
 	u64 desc_pos = f2fs_verity_metadata_pos(inode) + merkle_tree_size;
154
151
 	struct fsverity_descriptor_location dloc = {
155
-		.version = cpu_to_le32(1),
152
+		.version = cpu_to_le32(F2FS_VERIFY_VER),
156
153
 		.size = cpu_to_le32(desc_size),
157
154
 		.pos = cpu_to_le64(desc_pos),
158
155
 	};
159
-	int err = 0;
156
+	int err = 0, err2 = 0;
160
157
 
161
-	if (desc != NULL) {
162
-		/* Succeeded; write the verity descriptor. */
163
-		err = pagecache_write(inode, desc, desc_size, desc_pos);
158
+	/*
159
+	 * If an error already occurred (which fs/verity/ signals by passing
160
+	 * desc == NULL), then only clean-up is needed.
161
+	 */
162
+	if (desc == NULL)
163
+		goto cleanup;
164
164
 
165
-		/* Write all pages before clearing FI_VERITY_IN_PROGRESS. */
166
-		if (!err)
167
-			err = filemap_write_and_wait(inode->i_mapping);
168
-	}
165
+	/* Append the verity descriptor. */
166
+	err = pagecache_write(inode, desc, desc_size, desc_pos);
167
+	if (err)
168
+		goto cleanup;
169
169
 
170
-	/* If we failed, truncate anything we wrote past i_size. */
171
-	if (desc == NULL || err)
172
-		f2fs_truncate(inode);
170
+	/*
171
+	 * Write all pages (both data and verity metadata).  Note that this must
172
+	 * happen before clearing FI_VERITY_IN_PROGRESS; otherwise pages beyond
173
+	 * i_size won't be written properly.  For crash consistency, this also
174
+	 * must happen before the verity inode flag gets persisted.
175
+	 */
176
+	err = filemap_write_and_wait(inode->i_mapping);
177
+	if (err)
178
+		goto cleanup;
179
+
180
+	/* Set the verity xattr. */
181
+	err = f2fs_setxattr(inode, F2FS_XATTR_INDEX_VERITY,
182
+			    F2FS_XATTR_NAME_VERITY, &dloc, sizeof(dloc),
183
+			    NULL, XATTR_CREATE);
184
+	if (err)
185
+		goto cleanup;
186
+
187
+	/* Finally, set the verity inode flag. */
188
+	file_set_verity(inode);
189
+	f2fs_set_inode_flags(inode);
190
+	f2fs_mark_inode_dirty_sync(inode, true);
173
191
 
174
192
 	clear_inode_flag(inode, FI_VERITY_IN_PROGRESS);
193
+	return 0;
175
194
 
176
-	if (desc != NULL && !err) {
177
-		err = f2fs_setxattr(inode, F2FS_XATTR_INDEX_VERITY,
178
-				    F2FS_XATTR_NAME_VERITY, &dloc, sizeof(dloc),
179
-				    NULL, XATTR_CREATE);
180
-		if (!err) {
181
-			file_set_verity(inode);
182
-			f2fs_set_inode_flags(inode);
183
-			f2fs_mark_inode_dirty_sync(inode, true);
184
-		}
195
+cleanup:
196
+	/*
197
+	 * Verity failed to be enabled, so clean up by truncating any verity
198
+	 * metadata that was written beyond i_size (both from cache and from
199
+	 * disk) and clearing FI_VERITY_IN_PROGRESS.
200
+	 *
201
+	 * Taking i_gc_rwsem[WRITE] is needed to stop f2fs garbage collection
202
+	 * from re-instantiating cached pages we are truncating (since unlike
203
+	 * normal file accesses, garbage collection isn't limited by i_size).
204
+	 */
205
+	f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
206
+	truncate_inode_pages(inode->i_mapping, inode->i_size);
207
+	err2 = f2fs_truncate(inode);
208
+	if (err2) {
209
+		f2fs_err(sbi, "Truncating verity metadata failed (errno=%d)",
210
+			 err2);
211
+		set_sbi_flag(sbi, SBI_NEED_FSCK);
185
212
 	}
186
-	return err;
213
+	f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
214
+	clear_inode_flag(inode, FI_VERITY_IN_PROGRESS);
215
+	return err ?: err2;
187
216
 }
188
217
 
189
218
 static int f2fs_get_verity_descriptor(struct inode *inode, void *buf,
..
..
@@ -199,7 +228,7 @@
199
228
 			    F2FS_XATTR_NAME_VERITY, &dloc, sizeof(dloc), NULL);
200
229
 	if (res < 0 && res != -ERANGE)
201
230
 		return res;
202
-	if (res != sizeof(dloc) || dloc.version != cpu_to_le32(1)) {
231
+	if (res != sizeof(dloc) || dloc.version != cpu_to_le32(F2FS_VERIFY_VER)) {
203
232
 		f2fs_warn(F2FS_I_SB(inode), "unknown verity xattr format");
204
233
 		return -EINVAL;
205
234
 	}
..
..
@@ -222,39 +251,6 @@
222
251
 	return size;
223
252
 }
224
253
 
225
-/*
226
- * Prefetch some pages from the file's Merkle tree.
227
- *
228
- * This is basically a stripped-down version of __do_page_cache_readahead()
229
- * which works on pages past i_size.
230
- */
231
-static void f2fs_merkle_tree_readahead(struct address_space *mapping,
232
-				       pgoff_t start_index, unsigned long count)
233
-{
234
-	LIST_HEAD(pages);
235
-	unsigned int nr_pages = 0;
236
-	struct page *page;
237
-	pgoff_t index;
238
-	struct blk_plug plug;
239
-
240
-	for (index = start_index; index < start_index + count; index++) {
241
-		rcu_read_lock();
242
-		page = radix_tree_lookup(&mapping->i_pages, index);
243
-		rcu_read_unlock();
244
-		if (!page || radix_tree_exceptional_entry(page)) {
245
-			page = __page_cache_alloc(readahead_gfp_mask(mapping));
246
-			if (!page)
247
-				break;
248
-			page->index = index;
249
-			list_add(&page->lru, &pages);
250
-			nr_pages++;
251
-		}
252
-	}
253
-	blk_start_plug(&plug);
254
-	f2fs_mpage_readpages(mapping, &pages, NULL, nr_pages, true);
255
-	blk_finish_plug(&plug);
256
-}
257
-
258
254
 static struct page *f2fs_read_merkle_tree_page(struct inode *inode,
259
255
 					       pgoff_t index,
260
256
 					       unsigned long num_ra_pages)
..
..
@@ -265,11 +261,12 @@
265
261
 
266
262
 	page = find_get_page_flags(inode->i_mapping, index, FGP_ACCESSED);
267
263
 	if (!page || !PageUptodate(page)) {
264
+		DEFINE_READAHEAD(ractl, NULL, inode->i_mapping, index);
265
+
268
266
 		if (page)
269
267
 			put_page(page);
270
268
 		else if (num_ra_pages > 1)
271
-			f2fs_merkle_tree_readahead(inode->i_mapping, index,
272
-						   num_ra_pages);
269
+			page_cache_ra_unbounded(&ractl, num_ra_pages, 0);
273
270
 		page = read_mapping_page(inode->i_mapping, index, NULL);
274
271
 	}
275
272
 	return page;