xref: /linux/fs/ext4/orphan.c (revision 7ae9fb1b7ecbb5d85d07857943f677fd1a559b18)
1 /*
2  * Ext4 orphan inode handling
3  */
4 #include <linux/fs.h>
5 #include <linux/quotaops.h>
6 #include <linux/buffer_head.h>
7 
8 #include "ext4.h"
9 #include "ext4_jbd2.h"
10 
ext4_orphan_file_add(handle_t * handle,struct inode * inode)11 static int ext4_orphan_file_add(handle_t *handle, struct inode *inode)
12 {
13 	int i, j, start;
14 	struct ext4_orphan_info *oi = &EXT4_SB(inode->i_sb)->s_orphan_info;
15 	int ret = 0;
16 	bool found = false;
17 	__le32 *bdata;
18 	int inodes_per_ob = ext4_inodes_per_orphan_block(inode->i_sb);
19 	int looped = 0;
20 
21 	/*
22 	 * Find block with free orphan entry. Use CPU number for a naive hash
23 	 * for a search start in the orphan file
24 	 */
25 	start = raw_smp_processor_id()*13 % oi->of_blocks;
26 	i = start;
27 	do {
28 		if (atomic_dec_if_positive(&oi->of_binfo[i].ob_free_entries)
29 		    >= 0) {
30 			found = true;
31 			break;
32 		}
33 		if (++i >= oi->of_blocks)
34 			i = 0;
35 	} while (i != start);
36 
37 	if (!found) {
38 		/*
39 		 * For now we don't grow or shrink orphan file. We just use
40 		 * whatever was allocated at mke2fs time. The additional
41 		 * credits we would have to reserve for each orphan inode
42 		 * operation just don't seem worth it.
43 		 */
44 		return -ENOSPC;
45 	}
46 
47 	ret = ext4_journal_get_write_access(handle, inode->i_sb,
48 				oi->of_binfo[i].ob_bh, EXT4_JTR_ORPHAN_FILE);
49 	if (ret) {
50 		atomic_inc(&oi->of_binfo[i].ob_free_entries);
51 		return ret;
52 	}
53 
54 	bdata = (__le32 *)(oi->of_binfo[i].ob_bh->b_data);
55 	/* Find empty slot in a block */
56 	j = 0;
57 	do {
58 		if (looped) {
59 			/*
60 			 * Did we walk through the block several times without
61 			 * finding free entry? It is theoretically possible
62 			 * if entries get constantly allocated and freed or
63 			 * if the block is corrupted. Avoid indefinite looping
64 			 * and bail. We'll use orphan list instead.
65 			 */
66 			if (looped > 3) {
67 				atomic_inc(&oi->of_binfo[i].ob_free_entries);
68 				return -ENOSPC;
69 			}
70 			cond_resched();
71 		}
72 		while (bdata[j]) {
73 			if (++j >= inodes_per_ob) {
74 				j = 0;
75 				looped++;
76 			}
77 		}
78 	} while (cmpxchg(&bdata[j], (__le32)0, cpu_to_le32(inode->i_ino)) !=
79 		 (__le32)0);
80 
81 	EXT4_I(inode)->i_orphan_idx = i * inodes_per_ob + j;
82 	ext4_set_inode_state(inode, EXT4_STATE_ORPHAN_FILE);
83 
84 	return ext4_handle_dirty_metadata(handle, NULL, oi->of_binfo[i].ob_bh);
85 }
86 
87 /*
88  * ext4_orphan_add() links an unlinked or truncated inode into a list of
89  * such inodes, starting at the superblock, in case we crash before the
90  * file is closed/deleted, or in case the inode truncate spans multiple
91  * transactions and the last transaction is not recovered after a crash.
92  *
93  * At filesystem recovery time, we walk this list deleting unlinked
94  * inodes and truncating linked inodes in ext4_orphan_cleanup().
95  *
96  * Orphan list manipulation functions must be called under i_rwsem unless
97  * we are just creating the inode or deleting it.
98  */
ext4_orphan_add(handle_t * handle,struct inode * inode)99 int ext4_orphan_add(handle_t *handle, struct inode *inode)
100 {
101 	struct super_block *sb = inode->i_sb;
102 	struct ext4_sb_info *sbi = EXT4_SB(sb);
103 	struct ext4_iloc iloc;
104 	int err = 0, rc;
105 	bool dirty = false;
106 
107 	if (!sbi->s_journal || is_bad_inode(inode))
108 		return 0;
109 
110 	WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
111 		     !inode_is_locked(inode));
112 	/*
113 	 * Inode orphaned in orphan file or in orphan list?
114 	 */
115 	if (ext4_test_inode_state(inode, EXT4_STATE_ORPHAN_FILE) ||
116 	    !list_empty(&EXT4_I(inode)->i_orphan))
117 		return 0;
118 
119 	/*
120 	 * Orphan handling is only valid for files with data blocks
121 	 * being truncated, or files being unlinked. Note that we either
122 	 * hold i_rwsem, or the inode can not be referenced from outside,
123 	 * so i_nlink should not be bumped due to race
124 	 */
125 	ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
126 		  S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
127 
128 	if (sbi->s_orphan_info.of_blocks) {
129 		err = ext4_orphan_file_add(handle, inode);
130 		/*
131 		 * Fallback to normal orphan list of orphan file is
132 		 * out of space
133 		 */
134 		if (err != -ENOSPC)
135 			return err;
136 	}
137 
138 	BUFFER_TRACE(sbi->s_sbh, "get_write_access");
139 	err = ext4_journal_get_write_access(handle, sb, sbi->s_sbh,
140 					    EXT4_JTR_NONE);
141 	if (err)
142 		goto out;
143 
144 	err = ext4_reserve_inode_write(handle, inode, &iloc);
145 	if (err)
146 		goto out;
147 
148 	mutex_lock(&sbi->s_orphan_lock);
149 	/*
150 	 * Due to previous errors inode may be already a part of on-disk
151 	 * orphan list. If so skip on-disk list modification.
152 	 */
153 	if (!NEXT_ORPHAN(inode) || NEXT_ORPHAN(inode) >
154 	    (le32_to_cpu(sbi->s_es->s_inodes_count))) {
155 		/* Insert this inode at the head of the on-disk orphan list */
156 		NEXT_ORPHAN(inode) = le32_to_cpu(sbi->s_es->s_last_orphan);
157 		lock_buffer(sbi->s_sbh);
158 		sbi->s_es->s_last_orphan = cpu_to_le32(inode->i_ino);
159 		ext4_superblock_csum_set(sb);
160 		unlock_buffer(sbi->s_sbh);
161 		dirty = true;
162 	}
163 	list_add(&EXT4_I(inode)->i_orphan, &sbi->s_orphan);
164 	mutex_unlock(&sbi->s_orphan_lock);
165 
166 	if (dirty) {
167 		err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh);
168 		rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
169 		if (!err)
170 			err = rc;
171 		if (err) {
172 			/*
173 			 * We have to remove inode from in-memory list if
174 			 * addition to on disk orphan list failed. Stray orphan
175 			 * list entries can cause panics at unmount time.
176 			 */
177 			mutex_lock(&sbi->s_orphan_lock);
178 			list_del_init(&EXT4_I(inode)->i_orphan);
179 			mutex_unlock(&sbi->s_orphan_lock);
180 		}
181 	} else
182 		brelse(iloc.bh);
183 
184 	ext4_debug("superblock will point to %lu\n", inode->i_ino);
185 	ext4_debug("orphan inode %lu will point to %d\n",
186 			inode->i_ino, NEXT_ORPHAN(inode));
187 out:
188 	ext4_std_error(sb, err);
189 	return err;
190 }
191 
ext4_orphan_file_del(handle_t * handle,struct inode * inode)192 static int ext4_orphan_file_del(handle_t *handle, struct inode *inode)
193 {
194 	struct ext4_orphan_info *oi = &EXT4_SB(inode->i_sb)->s_orphan_info;
195 	__le32 *bdata;
196 	int blk, off;
197 	int inodes_per_ob = ext4_inodes_per_orphan_block(inode->i_sb);
198 	int ret = 0;
199 
200 	if (!handle)
201 		goto out;
202 	blk = EXT4_I(inode)->i_orphan_idx / inodes_per_ob;
203 	off = EXT4_I(inode)->i_orphan_idx % inodes_per_ob;
204 	if (WARN_ON_ONCE(blk >= oi->of_blocks))
205 		goto out;
206 
207 	ret = ext4_journal_get_write_access(handle, inode->i_sb,
208 				oi->of_binfo[blk].ob_bh, EXT4_JTR_ORPHAN_FILE);
209 	if (ret)
210 		goto out;
211 
212 	bdata = (__le32 *)(oi->of_binfo[blk].ob_bh->b_data);
213 	bdata[off] = 0;
214 	atomic_inc(&oi->of_binfo[blk].ob_free_entries);
215 	ret = ext4_handle_dirty_metadata(handle, NULL, oi->of_binfo[blk].ob_bh);
216 out:
217 	ext4_clear_inode_state(inode, EXT4_STATE_ORPHAN_FILE);
218 	INIT_LIST_HEAD(&EXT4_I(inode)->i_orphan);
219 
220 	return ret;
221 }
222 
223 /*
224  * ext4_orphan_del() removes an unlinked or truncated inode from the list
225  * of such inodes stored on disk, because it is finally being cleaned up.
226  */
ext4_orphan_del(handle_t * handle,struct inode * inode)227 int ext4_orphan_del(handle_t *handle, struct inode *inode)
228 {
229 	struct list_head *prev;
230 	struct ext4_inode_info *ei = EXT4_I(inode);
231 	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
232 	__u32 ino_next;
233 	struct ext4_iloc iloc;
234 	int err = 0;
235 
236 	if (!sbi->s_journal && !(sbi->s_mount_state & EXT4_ORPHAN_FS))
237 		return 0;
238 
239 	WARN_ON_ONCE(!(inode->i_state & (I_NEW | I_FREEING)) &&
240 		     !inode_is_locked(inode));
241 	if (ext4_test_inode_state(inode, EXT4_STATE_ORPHAN_FILE))
242 		return ext4_orphan_file_del(handle, inode);
243 
244 	/* Do this quick check before taking global s_orphan_lock. */
245 	if (list_empty(&ei->i_orphan))
246 		return 0;
247 
248 	if (handle) {
249 		/* Grab inode buffer early before taking global s_orphan_lock */
250 		err = ext4_reserve_inode_write(handle, inode, &iloc);
251 	}
252 
253 	mutex_lock(&sbi->s_orphan_lock);
254 	ext4_debug("remove inode %lu from orphan list\n", inode->i_ino);
255 
256 	prev = ei->i_orphan.prev;
257 	list_del_init(&ei->i_orphan);
258 
259 	/* If we're on an error path, we may not have a valid
260 	 * transaction handle with which to update the orphan list on
261 	 * disk, but we still need to remove the inode from the linked
262 	 * list in memory. */
263 	if (!handle || err) {
264 		mutex_unlock(&sbi->s_orphan_lock);
265 		goto out_err;
266 	}
267 
268 	ino_next = NEXT_ORPHAN(inode);
269 	if (prev == &sbi->s_orphan) {
270 		ext4_debug("superblock will point to %u\n", ino_next);
271 		BUFFER_TRACE(sbi->s_sbh, "get_write_access");
272 		err = ext4_journal_get_write_access(handle, inode->i_sb,
273 						    sbi->s_sbh, EXT4_JTR_NONE);
274 		if (err) {
275 			mutex_unlock(&sbi->s_orphan_lock);
276 			goto out_brelse;
277 		}
278 		lock_buffer(sbi->s_sbh);
279 		sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
280 		ext4_superblock_csum_set(inode->i_sb);
281 		unlock_buffer(sbi->s_sbh);
282 		mutex_unlock(&sbi->s_orphan_lock);
283 		err = ext4_handle_dirty_metadata(handle, NULL, sbi->s_sbh);
284 	} else {
285 		struct ext4_iloc iloc2;
286 		struct inode *i_prev =
287 			&list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
288 
289 		ext4_debug("orphan inode %lu will point to %u\n",
290 			  i_prev->i_ino, ino_next);
291 		err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
292 		if (err) {
293 			mutex_unlock(&sbi->s_orphan_lock);
294 			goto out_brelse;
295 		}
296 		NEXT_ORPHAN(i_prev) = ino_next;
297 		err = ext4_mark_iloc_dirty(handle, i_prev, &iloc2);
298 		mutex_unlock(&sbi->s_orphan_lock);
299 	}
300 	if (err)
301 		goto out_brelse;
302 	NEXT_ORPHAN(inode) = 0;
303 	err = ext4_mark_iloc_dirty(handle, inode, &iloc);
304 out_err:
305 	ext4_std_error(inode->i_sb, err);
306 	return err;
307 
308 out_brelse:
309 	brelse(iloc.bh);
310 	goto out_err;
311 }
312 
313 #ifdef CONFIG_QUOTA
ext4_quota_on_mount(struct super_block * sb,int type)314 static int ext4_quota_on_mount(struct super_block *sb, int type)
315 {
316 	return dquot_quota_on_mount(sb,
317 		rcu_dereference_protected(EXT4_SB(sb)->s_qf_names[type],
318 					  lockdep_is_held(&sb->s_umount)),
319 		EXT4_SB(sb)->s_jquota_fmt, type);
320 }
321 #endif
322 
ext4_process_orphan(struct inode * inode,int * nr_truncates,int * nr_orphans)323 static void ext4_process_orphan(struct inode *inode,
324 				int *nr_truncates, int *nr_orphans)
325 {
326 	struct super_block *sb = inode->i_sb;
327 	int ret;
328 
329 	dquot_initialize(inode);
330 	if (inode->i_nlink) {
331 		if (test_opt(sb, DEBUG))
332 			ext4_msg(sb, KERN_DEBUG,
333 				"%s: truncating inode %lu to %lld bytes",
334 				__func__, inode->i_ino, inode->i_size);
335 		ext4_debug("truncating inode %lu to %lld bytes\n",
336 			   inode->i_ino, inode->i_size);
337 		inode_lock(inode);
338 		truncate_inode_pages(inode->i_mapping, inode->i_size);
339 		ret = ext4_truncate(inode);
340 		if (ret) {
341 			/*
342 			 * We need to clean up the in-core orphan list
343 			 * manually if ext4_truncate() failed to get a
344 			 * transaction handle.
345 			 */
346 			ext4_orphan_del(NULL, inode);
347 			ext4_std_error(inode->i_sb, ret);
348 		}
349 		inode_unlock(inode);
350 		(*nr_truncates)++;
351 	} else {
352 		if (test_opt(sb, DEBUG))
353 			ext4_msg(sb, KERN_DEBUG,
354 				"%s: deleting unreferenced inode %lu",
355 				__func__, inode->i_ino);
356 		ext4_debug("deleting unreferenced inode %lu\n",
357 			   inode->i_ino);
358 		(*nr_orphans)++;
359 	}
360 	iput(inode);  /* The delete magic happens here! */
361 }
362 
363 /* ext4_orphan_cleanup() walks a singly-linked list of inodes (starting at
364  * the superblock) which were deleted from all directories, but held open by
365  * a process at the time of a crash.  We walk the list and try to delete these
366  * inodes at recovery time (only with a read-write filesystem).
367  *
368  * In order to keep the orphan inode chain consistent during traversal (in
369  * case of crash during recovery), we link each inode into the superblock
370  * orphan list_head and handle it the same way as an inode deletion during
371  * normal operation (which journals the operations for us).
372  *
373  * We only do an iget() and an iput() on each inode, which is very safe if we
374  * accidentally point at an in-use or already deleted inode.  The worst that
375  * can happen in this case is that we get a "bit already cleared" message from
376  * ext4_free_inode().  The only reason we would point at a wrong inode is if
377  * e2fsck was run on this filesystem, and it must have already done the orphan
378  * inode cleanup for us, so we can safely abort without any further action.
379  */
ext4_orphan_cleanup(struct super_block * sb,struct ext4_super_block * es)380 void ext4_orphan_cleanup(struct super_block *sb, struct ext4_super_block *es)
381 {
382 	unsigned int s_flags = sb->s_flags;
383 	int nr_orphans = 0, nr_truncates = 0;
384 	struct inode *inode;
385 	int i, j;
386 #ifdef CONFIG_QUOTA
387 	int quota_update = 0;
388 #endif
389 	__le32 *bdata;
390 	struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info;
391 	int inodes_per_ob = ext4_inodes_per_orphan_block(sb);
392 
393 	if (!es->s_last_orphan && !oi->of_blocks) {
394 		ext4_debug("no orphan inodes to clean up\n");
395 		return;
396 	}
397 
398 	if (bdev_read_only(sb->s_bdev)) {
399 		ext4_msg(sb, KERN_ERR, "write access "
400 			"unavailable, skipping orphan cleanup");
401 		return;
402 	}
403 
404 	/* Check if feature set would not allow a r/w mount */
405 	if (!ext4_feature_set_ok(sb, 0)) {
406 		ext4_msg(sb, KERN_INFO, "Skipping orphan cleanup due to "
407 			 "unknown ROCOMPAT features");
408 		return;
409 	}
410 
411 	if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
412 		/* don't clear list on RO mount w/ errors */
413 		if (es->s_last_orphan && !(s_flags & SB_RDONLY)) {
414 			ext4_msg(sb, KERN_INFO, "Errors on filesystem, "
415 				  "clearing orphan list.");
416 			es->s_last_orphan = 0;
417 		}
418 		ext4_debug("Skipping orphan recovery on fs with errors.\n");
419 		return;
420 	}
421 
422 	if (s_flags & SB_RDONLY) {
423 		ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
424 		sb->s_flags &= ~SB_RDONLY;
425 	}
426 #ifdef CONFIG_QUOTA
427 	/*
428 	 * Turn on quotas which were not enabled for read-only mounts if
429 	 * filesystem has quota feature, so that they are updated correctly.
430 	 */
431 	if (ext4_has_feature_quota(sb) && (s_flags & SB_RDONLY)) {
432 		int ret = ext4_enable_quotas(sb);
433 
434 		if (!ret)
435 			quota_update = 1;
436 		else
437 			ext4_msg(sb, KERN_ERR,
438 				"Cannot turn on quotas: error %d", ret);
439 	}
440 
441 	/* Turn on journaled quotas used for old sytle */
442 	for (i = 0; i < EXT4_MAXQUOTAS; i++) {
443 		if (EXT4_SB(sb)->s_qf_names[i]) {
444 			int ret = ext4_quota_on_mount(sb, i);
445 
446 			if (!ret)
447 				quota_update = 1;
448 			else
449 				ext4_msg(sb, KERN_ERR,
450 					"Cannot turn on journaled "
451 					"quota: type %d: error %d", i, ret);
452 		}
453 	}
454 #endif
455 
456 	while (es->s_last_orphan) {
457 		/*
458 		 * We may have encountered an error during cleanup; if
459 		 * so, skip the rest.
460 		 */
461 		if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
462 			ext4_debug("Skipping orphan recovery on fs with errors.\n");
463 			es->s_last_orphan = 0;
464 			break;
465 		}
466 
467 		inode = ext4_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
468 		if (IS_ERR(inode)) {
469 			es->s_last_orphan = 0;
470 			break;
471 		}
472 
473 		list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
474 		ext4_process_orphan(inode, &nr_truncates, &nr_orphans);
475 	}
476 
477 	for (i = 0; i < oi->of_blocks; i++) {
478 		bdata = (__le32 *)(oi->of_binfo[i].ob_bh->b_data);
479 		for (j = 0; j < inodes_per_ob; j++) {
480 			if (!bdata[j])
481 				continue;
482 			inode = ext4_orphan_get(sb, le32_to_cpu(bdata[j]));
483 			if (IS_ERR(inode))
484 				continue;
485 			ext4_set_inode_state(inode, EXT4_STATE_ORPHAN_FILE);
486 			EXT4_I(inode)->i_orphan_idx = i * inodes_per_ob + j;
487 			ext4_process_orphan(inode, &nr_truncates, &nr_orphans);
488 		}
489 	}
490 
491 #define PLURAL(x) (x), ((x) == 1) ? "" : "s"
492 
493 	if (nr_orphans)
494 		ext4_msg(sb, KERN_INFO, "%d orphan inode%s deleted",
495 		       PLURAL(nr_orphans));
496 	if (nr_truncates)
497 		ext4_msg(sb, KERN_INFO, "%d truncate%s cleaned up",
498 		       PLURAL(nr_truncates));
499 #ifdef CONFIG_QUOTA
500 	/* Turn off quotas if they were enabled for orphan cleanup */
501 	if (quota_update) {
502 		for (i = 0; i < EXT4_MAXQUOTAS; i++) {
503 			if (sb_dqopt(sb)->files[i])
504 				dquot_quota_off(sb, i);
505 		}
506 	}
507 #endif
508 	sb->s_flags = s_flags; /* Restore SB_RDONLY status */
509 }
510 
ext4_release_orphan_info(struct super_block * sb)511 void ext4_release_orphan_info(struct super_block *sb)
512 {
513 	int i;
514 	struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info;
515 
516 	if (!oi->of_blocks)
517 		return;
518 	for (i = 0; i < oi->of_blocks; i++)
519 		brelse(oi->of_binfo[i].ob_bh);
520 	kfree(oi->of_binfo);
521 }
522 
ext4_orphan_block_tail(struct super_block * sb,struct buffer_head * bh)523 static struct ext4_orphan_block_tail *ext4_orphan_block_tail(
524 						struct super_block *sb,
525 						struct buffer_head *bh)
526 {
527 	return (struct ext4_orphan_block_tail *)(bh->b_data + sb->s_blocksize -
528 				sizeof(struct ext4_orphan_block_tail));
529 }
530 
ext4_orphan_file_block_csum_verify(struct super_block * sb,struct buffer_head * bh)531 static int ext4_orphan_file_block_csum_verify(struct super_block *sb,
532 					      struct buffer_head *bh)
533 {
534 	__u32 calculated;
535 	int inodes_per_ob = ext4_inodes_per_orphan_block(sb);
536 	struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info;
537 	struct ext4_orphan_block_tail *ot;
538 	__le64 dsk_block_nr = cpu_to_le64(bh->b_blocknr);
539 
540 	if (!ext4_has_metadata_csum(sb))
541 		return 1;
542 
543 	ot = ext4_orphan_block_tail(sb, bh);
544 	calculated = ext4_chksum(EXT4_SB(sb), oi->of_csum_seed,
545 				 (__u8 *)&dsk_block_nr, sizeof(dsk_block_nr));
546 	calculated = ext4_chksum(EXT4_SB(sb), calculated, (__u8 *)bh->b_data,
547 				 inodes_per_ob * sizeof(__u32));
548 	return le32_to_cpu(ot->ob_checksum) == calculated;
549 }
550 
551 /* This gets called only when checksumming is enabled */
ext4_orphan_file_block_trigger(struct jbd2_buffer_trigger_type * triggers,struct buffer_head * bh,void * data,size_t size)552 void ext4_orphan_file_block_trigger(struct jbd2_buffer_trigger_type *triggers,
553 				    struct buffer_head *bh,
554 				    void *data, size_t size)
555 {
556 	struct super_block *sb = EXT4_TRIGGER(triggers)->sb;
557 	__u32 csum;
558 	int inodes_per_ob = ext4_inodes_per_orphan_block(sb);
559 	struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info;
560 	struct ext4_orphan_block_tail *ot;
561 	__le64 dsk_block_nr = cpu_to_le64(bh->b_blocknr);
562 
563 	csum = ext4_chksum(EXT4_SB(sb), oi->of_csum_seed,
564 			   (__u8 *)&dsk_block_nr, sizeof(dsk_block_nr));
565 	csum = ext4_chksum(EXT4_SB(sb), csum, (__u8 *)data,
566 			   inodes_per_ob * sizeof(__u32));
567 	ot = ext4_orphan_block_tail(sb, bh);
568 	ot->ob_checksum = cpu_to_le32(csum);
569 }
570 
ext4_init_orphan_info(struct super_block * sb)571 int ext4_init_orphan_info(struct super_block *sb)
572 {
573 	struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info;
574 	struct inode *inode;
575 	int i, j;
576 	int ret;
577 	int free;
578 	__le32 *bdata;
579 	int inodes_per_ob = ext4_inodes_per_orphan_block(sb);
580 	struct ext4_orphan_block_tail *ot;
581 	ino_t orphan_ino = le32_to_cpu(EXT4_SB(sb)->s_es->s_orphan_file_inum);
582 
583 	if (!ext4_has_feature_orphan_file(sb))
584 		return 0;
585 
586 	inode = ext4_iget(sb, orphan_ino, EXT4_IGET_SPECIAL);
587 	if (IS_ERR(inode)) {
588 		ext4_msg(sb, KERN_ERR, "get orphan inode failed");
589 		return PTR_ERR(inode);
590 	}
591 	oi->of_blocks = inode->i_size >> sb->s_blocksize_bits;
592 	oi->of_csum_seed = EXT4_I(inode)->i_csum_seed;
593 	oi->of_binfo = kmalloc(oi->of_blocks*sizeof(struct ext4_orphan_block),
594 			       GFP_KERNEL);
595 	if (!oi->of_binfo) {
596 		ret = -ENOMEM;
597 		goto out_put;
598 	}
599 	for (i = 0; i < oi->of_blocks; i++) {
600 		oi->of_binfo[i].ob_bh = ext4_bread(NULL, inode, i, 0);
601 		if (IS_ERR(oi->of_binfo[i].ob_bh)) {
602 			ret = PTR_ERR(oi->of_binfo[i].ob_bh);
603 			goto out_free;
604 		}
605 		if (!oi->of_binfo[i].ob_bh) {
606 			ret = -EIO;
607 			goto out_free;
608 		}
609 		ot = ext4_orphan_block_tail(sb, oi->of_binfo[i].ob_bh);
610 		if (le32_to_cpu(ot->ob_magic) != EXT4_ORPHAN_BLOCK_MAGIC) {
611 			ext4_error(sb, "orphan file block %d: bad magic", i);
612 			ret = -EIO;
613 			goto out_free;
614 		}
615 		if (!ext4_orphan_file_block_csum_verify(sb,
616 						oi->of_binfo[i].ob_bh)) {
617 			ext4_error(sb, "orphan file block %d: bad checksum", i);
618 			ret = -EIO;
619 			goto out_free;
620 		}
621 		bdata = (__le32 *)(oi->of_binfo[i].ob_bh->b_data);
622 		free = 0;
623 		for (j = 0; j < inodes_per_ob; j++)
624 			if (bdata[j] == 0)
625 				free++;
626 		atomic_set(&oi->of_binfo[i].ob_free_entries, free);
627 	}
628 	iput(inode);
629 	return 0;
630 out_free:
631 	for (i--; i >= 0; i--)
632 		brelse(oi->of_binfo[i].ob_bh);
633 	kfree(oi->of_binfo);
634 out_put:
635 	iput(inode);
636 	return ret;
637 }
638 
ext4_orphan_file_empty(struct super_block * sb)639 int ext4_orphan_file_empty(struct super_block *sb)
640 {
641 	struct ext4_orphan_info *oi = &EXT4_SB(sb)->s_orphan_info;
642 	int i;
643 	int inodes_per_ob = ext4_inodes_per_orphan_block(sb);
644 
645 	if (!ext4_has_feature_orphan_file(sb))
646 		return 1;
647 	for (i = 0; i < oi->of_blocks; i++)
648 		if (atomic_read(&oi->of_binfo[i].ob_free_entries) !=
649 		    inodes_per_ob)
650 			return 0;
651 	return 1;
652 }
653