Commit | Line | Data |
---|---|---|
25c6d98f JK |
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 | ||
02f310fc JK |
11 | static int ext4_orphan_file_add(handle_t *handle, struct inode *inode) |
12 | { | |
4a79a98c | 13 | int i, j, start; |
02f310fc JK |
14 | struct ext4_orphan_info *oi = &EXT4_SB(inode->i_sb)->s_orphan_info; |
15 | int ret = 0; | |
4a79a98c | 16 | bool found = false; |
02f310fc JK |
17 | __le32 *bdata; |
18 | int inodes_per_ob = ext4_inodes_per_orphan_block(inode->i_sb); | |
4a79a98c JK |
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); | |
02f310fc | 36 | |
4a79a98c | 37 | if (!found) { |
02f310fc JK |
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 | } | |
02f310fc | 46 | |
02f310fc JK |
47 | ret = ext4_journal_get_write_access(handle, inode->i_sb, |
48 | oi->of_binfo[i].ob_bh, EXT4_JTR_ORPHAN_FILE); | |
4a79a98c JK |
49 | if (ret) { |
50 | atomic_inc(&oi->of_binfo[i].ob_free_entries); | |
02f310fc | 51 | return ret; |
4a79a98c | 52 | } |
02f310fc JK |
53 | |
54 | bdata = (__le32 *)(oi->of_binfo[i].ob_bh->b_data); | |
02f310fc | 55 | /* Find empty slot in a block */ |
4a79a98c JK |
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 | ||
02f310fc JK |
81 | EXT4_I(inode)->i_orphan_idx = i * inodes_per_ob + j; |
82 | ext4_set_inode_state(inode, EXT4_STATE_ORPHAN_FILE); | |
02f310fc JK |
83 | |
84 | return ext4_handle_dirty_metadata(handle, NULL, oi->of_binfo[i].ob_bh); | |
85 | } | |
86 | ||
25c6d98f JK |
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 | * | |
f340b3d9 | 96 | * Orphan list manipulation functions must be called under i_rwsem unless |
25c6d98f JK |
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 | /* | |
02f310fc | 113 | * Inode orphaned in orphan file or in orphan list? |
25c6d98f | 114 | */ |
02f310fc JK |
115 | if (ext4_test_inode_state(inode, EXT4_STATE_ORPHAN_FILE) || |
116 | !list_empty(&EXT4_I(inode)->i_orphan)) | |
25c6d98f JK |
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 | |
f340b3d9 | 122 | * hold i_rwsem, or the inode can not be referenced from outside, |
25c6d98f JK |
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 | ||
02f310fc JK |
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 | ||
25c6d98f JK |
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 | ||
4978c659 JK |
184 | ext4_debug("superblock will point to %lu\n", inode->i_ino); |
185 | ext4_debug("orphan inode %lu will point to %d\n", | |
25c6d98f JK |
186 | inode->i_ino, NEXT_ORPHAN(inode)); |
187 | out: | |
188 | ext4_std_error(sb, err); | |
189 | return err; | |
190 | } | |
191 | ||
02f310fc JK |
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); | |
02f310fc | 213 | bdata[off] = 0; |
4a79a98c | 214 | atomic_inc(&oi->of_binfo[blk].ob_free_entries); |
02f310fc JK |
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 | ||
25c6d98f JK |
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)); | |
02f310fc JK |
241 | if (ext4_test_inode_state(inode, EXT4_STATE_ORPHAN_FILE)) |
242 | return ext4_orphan_file_del(handle, inode); | |
243 | ||
25c6d98f JK |
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); | |
4978c659 | 254 | ext4_debug("remove inode %lu from orphan list\n", inode->i_ino); |
25c6d98f JK |
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) { | |
4978c659 | 270 | ext4_debug("superblock will point to %u\n", ino_next); |
25c6d98f JK |
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 | ||
4978c659 | 289 | ext4_debug("orphan inode %lu will point to %u\n", |
25c6d98f JK |
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 | ||
02f310fc JK |
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); | |
4978c659 JK |
335 | ext4_debug("truncating inode %lu to %lld bytes\n", |
336 | inode->i_ino, inode->i_size); | |
02f310fc JK |
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); | |
4978c659 JK |
356 | ext4_debug("deleting unreferenced inode %lu\n", |
357 | inode->i_ino); | |
02f310fc JK |
358 | (*nr_orphans)++; |
359 | } | |
360 | iput(inode); /* The delete magic happens here! */ | |
361 | } | |
362 | ||
25c6d98f JK |
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; | |
02f310fc JK |
383 | int nr_orphans = 0, nr_truncates = 0; |
384 | struct inode *inode; | |
385 | int i, j; | |
25c6d98f JK |
386 | #ifdef CONFIG_QUOTA |
387 | int quota_update = 0; | |
25c6d98f | 388 | #endif |
02f310fc JK |
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) { | |
4978c659 | 394 | ext4_debug("no orphan inodes to clean up\n"); |
25c6d98f JK |
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, " | |
78742d4d | 415 | "clearing orphan list."); |
25c6d98f JK |
416 | es->s_last_orphan = 0; |
417 | } | |
4978c659 | 418 | ext4_debug("Skipping orphan recovery on fs with errors.\n"); |
25c6d98f JK |
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) { | |
25c6d98f JK |
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) { | |
4978c659 | 462 | ext4_debug("Skipping orphan recovery on fs with errors.\n"); |
25c6d98f JK |
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); | |
02f310fc JK |
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); | |
25c6d98f | 488 | } |
25c6d98f JK |
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 | } | |
02f310fc JK |
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 | ||
02f310fc JK |
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++; | |
4a79a98c | 626 | atomic_set(&oi->of_binfo[i].ob_free_entries, free); |
02f310fc JK |
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++) | |
4a79a98c JK |
648 | if (atomic_read(&oi->of_binfo[i].ob_free_entries) != |
649 | inodes_per_ob) | |
02f310fc JK |
650 | return 0; |
651 | return 1; | |
652 | } |