e5b47dda331759c649e8f127bc4911053acb05b7
[releases.git] / orphan.c
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
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  */
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
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  */
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
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
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  */
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
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
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
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 */
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
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
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 }