移去rt

hc

2023-12-08 01573e231f18eb2d99162747186f59511f56b64d

 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);
..
..
@@ -150,40 +152,73 @@
150
152
 				  size_t desc_size, u64 merkle_tree_size)
151
153
 {
152
154
 	struct inode *inode = file_inode(filp);
155
+	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
153
156
 	u64 desc_pos = f2fs_verity_metadata_pos(inode) + merkle_tree_size;
154
157
 	struct fsverity_descriptor_location dloc = {
155
-		.version = cpu_to_le32(1),
158
+		.version = cpu_to_le32(F2FS_VERIFY_VER),
156
159
 		.size = cpu_to_le32(desc_size),
157
160
 		.pos = cpu_to_le64(desc_pos),
158
161
 	};
159
-	int err = 0;
162
+	int err = 0, err2 = 0;
160
163
 
161
-	if (desc != NULL) {
162
-		/* Succeeded; write the verity descriptor. */
163
-		err = pagecache_write(inode, desc, desc_size, desc_pos);
164
+	/*
165
+	 * If an error already occurred (which fs/verity/ signals by passing
166
+	 * desc == NULL), then only clean-up is needed.
167
+	 */
168
+	if (desc == NULL)
169
+		goto cleanup;
164
170
 
165
-		/* Write all pages before clearing FI_VERITY_IN_PROGRESS. */
166
-		if (!err)
167
-			err = filemap_write_and_wait(inode->i_mapping);
168
-	}
171
+	/* Append the verity descriptor. */
172
+	err = pagecache_write(inode, desc, desc_size, desc_pos);
173
+	if (err)
174
+		goto cleanup;
169
175
 
170
-	/* If we failed, truncate anything we wrote past i_size. */
171
-	if (desc == NULL || err)
172
-		f2fs_truncate(inode);
176
+	/*
177
+	 * Write all pages (both data and verity metadata).  Note that this must
178
+	 * happen before clearing FI_VERITY_IN_PROGRESS; otherwise pages beyond
179
+	 * i_size won't be written properly.  For crash consistency, this also
180
+	 * must happen before the verity inode flag gets persisted.
181
+	 */
182
+	err = filemap_write_and_wait(inode->i_mapping);
183
+	if (err)
184
+		goto cleanup;
185
+
186
+	/* Set the verity xattr. */
187
+	err = f2fs_setxattr(inode, F2FS_XATTR_INDEX_VERITY,
188
+			    F2FS_XATTR_NAME_VERITY, &dloc, sizeof(dloc),
189
+			    NULL, XATTR_CREATE);
190
+	if (err)
191
+		goto cleanup;
192
+
193
+	/* Finally, set the verity inode flag. */
194
+	file_set_verity(inode);
195
+	f2fs_set_inode_flags(inode);
196
+	f2fs_mark_inode_dirty_sync(inode, true);
173
197
 
174
198
 	clear_inode_flag(inode, FI_VERITY_IN_PROGRESS);
199
+	return 0;
175
200
 
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
-		}
201
+cleanup:
202
+	/*
203
+	 * Verity failed to be enabled, so clean up by truncating any verity
204
+	 * metadata that was written beyond i_size (both from cache and from
205
+	 * disk) and clearing FI_VERITY_IN_PROGRESS.
206
+	 *
207
+	 * Taking i_gc_rwsem[WRITE] is needed to stop f2fs garbage collection
208
+	 * from re-instantiating cached pages we are truncating (since unlike
209
+	 * normal file accesses, garbage collection isn't limited by i_size).
210
+	 */
211
+	f2fs_down_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
212
+	truncate_inode_pages(inode->i_mapping, inode->i_size);
213
+	err2 = f2fs_truncate(inode);
214
+	if (err2) {
215
+		f2fs_err(sbi, "Truncating verity metadata failed (errno=%d)",
216
+			 err2);
217
+		set_sbi_flag(sbi, SBI_NEED_FSCK);
185
218
 	}
186
-	return err;
219
+	f2fs_up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
220
+	clear_inode_flag(inode, FI_VERITY_IN_PROGRESS);
221
+	return err ?: err2;
187
222
 }
188
223
 
189
224
 static int f2fs_get_verity_descriptor(struct inode *inode, void *buf,
..
..
@@ -199,7 +234,7 @@
199
234
 			    F2FS_XATTR_NAME_VERITY, &dloc, sizeof(dloc), NULL);
200
235
 	if (res < 0 && res != -ERANGE)
201
236
 		return res;
202
-	if (res != sizeof(dloc) || dloc.version != cpu_to_le32(1)) {
237
+	if (res != sizeof(dloc) || dloc.version != cpu_to_le32(F2FS_VERIFY_VER)) {
203
238
 		f2fs_warn(F2FS_I_SB(inode), "unknown verity xattr format");
204
239
 		return -EINVAL;
205
240
 	}
..
..
@@ -222,39 +257,6 @@
222
257
 	return size;
223
258
 }
224
259
 
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
260
 static struct page *f2fs_read_merkle_tree_page(struct inode *inode,
259
261
 					       pgoff_t index,
260
262
 					       unsigned long num_ra_pages)
..
..
@@ -265,11 +267,12 @@
265
267
 
266
268
 	page = find_get_page_flags(inode->i_mapping, index, FGP_ACCESSED);
267
269
 	if (!page || !PageUptodate(page)) {
270
+		DEFINE_READAHEAD(ractl, NULL, inode->i_mapping, index);
271
+
268
272
 		if (page)
269
273
 			put_page(page);
270
274
 		else if (num_ra_pages > 1)
271
-			f2fs_merkle_tree_readahead(inode->i_mapping, index,
272
-						   num_ra_pages);
275
+			page_cache_ra_unbounded(&ractl, num_ra_pages, 0);
273
276
 		page = read_mapping_page(inode->i_mapping, index, NULL);
274
277
 	}
275
278
 	return page;