1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/slab.h>
16#include "ext4_jbd2.h"
17#include "ext4_extents.h"
18
19
20
21
22
23struct migrate_struct {
24 ext4_lblk_t first_block, last_block, curr_block;
25 ext4_fsblk_t first_pblock, last_pblock;
26};
27
28static int finish_range(handle_t *handle, struct inode *inode,
29 struct migrate_struct *lb)
30
31{
32 int retval = 0, needed;
33 struct ext4_extent newext;
34 struct ext4_ext_path *path;
35 if (lb->first_pblock == 0)
36 return 0;
37
38
39 newext.ee_block = cpu_to_le32(lb->first_block);
40 newext.ee_len = cpu_to_le16(lb->last_block - lb->first_block + 1);
41 ext4_ext_store_pblock(&newext, lb->first_pblock);
42 path = ext4_ext_find_extent(inode, lb->first_block, NULL);
43
44 if (IS_ERR(path)) {
45 retval = PTR_ERR(path);
46 path = NULL;
47 goto err_out;
48 }
49
50
51
52
53
54
55
56 needed = ext4_ext_calc_credits_for_single_extent(inode,
57 lb->last_block - lb->first_block + 1, path);
58
59
60
61
62 if (needed && ext4_handle_has_enough_credits(handle,
63 EXT4_RESERVE_TRANS_BLOCKS)) {
64 retval = ext4_journal_restart(handle, needed);
65 if (retval)
66 goto err_out;
67 } else if (needed) {
68 retval = ext4_journal_extend(handle, needed);
69 if (retval) {
70
71
72
73 retval = ext4_journal_restart(handle, needed);
74 if (retval)
75 goto err_out;
76 }
77 }
78 retval = ext4_ext_insert_extent(handle, inode, path, &newext, 0);
79err_out:
80 if (path) {
81 ext4_ext_drop_refs(path);
82 kfree(path);
83 }
84 lb->first_pblock = 0;
85 return retval;
86}
87
88static int update_extent_range(handle_t *handle, struct inode *inode,
89 ext4_fsblk_t pblock, struct migrate_struct *lb)
90{
91 int retval;
92
93
94
95 if (lb->first_pblock &&
96 (lb->last_pblock+1 == pblock) &&
97 (lb->last_block+1 == lb->curr_block)) {
98 lb->last_pblock = pblock;
99 lb->last_block = lb->curr_block;
100 lb->curr_block++;
101 return 0;
102 }
103
104
105
106 retval = finish_range(handle, inode, lb);
107 lb->first_pblock = lb->last_pblock = pblock;
108 lb->first_block = lb->last_block = lb->curr_block;
109 lb->curr_block++;
110 return retval;
111}
112
113static int update_ind_extent_range(handle_t *handle, struct inode *inode,
114 ext4_fsblk_t pblock,
115 struct migrate_struct *lb)
116{
117 struct buffer_head *bh;
118 __le32 *i_data;
119 int i, retval = 0;
120 unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
121
122 bh = sb_bread(inode->i_sb, pblock);
123 if (!bh)
124 return -EIO;
125
126 i_data = (__le32 *)bh->b_data;
127 for (i = 0; i < max_entries; i++) {
128 if (i_data[i]) {
129 retval = update_extent_range(handle, inode,
130 le32_to_cpu(i_data[i]), lb);
131 if (retval)
132 break;
133 } else {
134 lb->curr_block++;
135 }
136 }
137 put_bh(bh);
138 return retval;
139
140}
141
142static int update_dind_extent_range(handle_t *handle, struct inode *inode,
143 ext4_fsblk_t pblock,
144 struct migrate_struct *lb)
145{
146 struct buffer_head *bh;
147 __le32 *i_data;
148 int i, retval = 0;
149 unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
150
151 bh = sb_bread(inode->i_sb, pblock);
152 if (!bh)
153 return -EIO;
154
155 i_data = (__le32 *)bh->b_data;
156 for (i = 0; i < max_entries; i++) {
157 if (i_data[i]) {
158 retval = update_ind_extent_range(handle, inode,
159 le32_to_cpu(i_data[i]), lb);
160 if (retval)
161 break;
162 } else {
163
164 lb->curr_block += max_entries;
165 }
166 }
167 put_bh(bh);
168 return retval;
169
170}
171
172static int update_tind_extent_range(handle_t *handle, struct inode *inode,
173 ext4_fsblk_t pblock,
174 struct migrate_struct *lb)
175{
176 struct buffer_head *bh;
177 __le32 *i_data;
178 int i, retval = 0;
179 unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
180
181 bh = sb_bread(inode->i_sb, pblock);
182 if (!bh)
183 return -EIO;
184
185 i_data = (__le32 *)bh->b_data;
186 for (i = 0; i < max_entries; i++) {
187 if (i_data[i]) {
188 retval = update_dind_extent_range(handle, inode,
189 le32_to_cpu(i_data[i]), lb);
190 if (retval)
191 break;
192 } else {
193
194 lb->curr_block += max_entries * max_entries;
195 }
196 }
197 put_bh(bh);
198 return retval;
199
200}
201
202static int extend_credit_for_blkdel(handle_t *handle, struct inode *inode)
203{
204 int retval = 0, needed;
205
206 if (ext4_handle_has_enough_credits(handle, EXT4_RESERVE_TRANS_BLOCKS+1))
207 return 0;
208
209
210
211
212
213
214 needed = 3 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb);
215
216 if (ext4_journal_extend(handle, needed) != 0)
217 retval = ext4_journal_restart(handle, needed);
218
219 return retval;
220}
221
222static int free_dind_blocks(handle_t *handle,
223 struct inode *inode, __le32 i_data)
224{
225 int i;
226 __le32 *tmp_idata;
227 struct buffer_head *bh;
228 unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
229
230 bh = sb_bread(inode->i_sb, le32_to_cpu(i_data));
231 if (!bh)
232 return -EIO;
233
234 tmp_idata = (__le32 *)bh->b_data;
235 for (i = 0; i < max_entries; i++) {
236 if (tmp_idata[i]) {
237 extend_credit_for_blkdel(handle, inode);
238 ext4_free_blocks(handle, inode, NULL,
239 le32_to_cpu(tmp_idata[i]), 1,
240 EXT4_FREE_BLOCKS_METADATA |
241 EXT4_FREE_BLOCKS_FORGET);
242 }
243 }
244 put_bh(bh);
245 extend_credit_for_blkdel(handle, inode);
246 ext4_free_blocks(handle, inode, NULL, le32_to_cpu(i_data), 1,
247 EXT4_FREE_BLOCKS_METADATA |
248 EXT4_FREE_BLOCKS_FORGET);
249 return 0;
250}
251
252static int free_tind_blocks(handle_t *handle,
253 struct inode *inode, __le32 i_data)
254{
255 int i, retval = 0;
256 __le32 *tmp_idata;
257 struct buffer_head *bh;
258 unsigned long max_entries = inode->i_sb->s_blocksize >> 2;
259
260 bh = sb_bread(inode->i_sb, le32_to_cpu(i_data));
261 if (!bh)
262 return -EIO;
263
264 tmp_idata = (__le32 *)bh->b_data;
265 for (i = 0; i < max_entries; i++) {
266 if (tmp_idata[i]) {
267 retval = free_dind_blocks(handle,
268 inode, tmp_idata[i]);
269 if (retval) {
270 put_bh(bh);
271 return retval;
272 }
273 }
274 }
275 put_bh(bh);
276 extend_credit_for_blkdel(handle, inode);
277 ext4_free_blocks(handle, inode, NULL, le32_to_cpu(i_data), 1,
278 EXT4_FREE_BLOCKS_METADATA |
279 EXT4_FREE_BLOCKS_FORGET);
280 return 0;
281}
282
283static int free_ind_block(handle_t *handle, struct inode *inode, __le32 *i_data)
284{
285 int retval;
286
287
288 if (i_data[0]) {
289 extend_credit_for_blkdel(handle, inode);
290 ext4_free_blocks(handle, inode, NULL,
291 le32_to_cpu(i_data[0]), 1,
292 EXT4_FREE_BLOCKS_METADATA |
293 EXT4_FREE_BLOCKS_FORGET);
294 }
295
296
297 if (i_data[1]) {
298 retval = free_dind_blocks(handle, inode, i_data[1]);
299 if (retval)
300 return retval;
301 }
302
303
304 if (i_data[2]) {
305 retval = free_tind_blocks(handle, inode, i_data[2]);
306 if (retval)
307 return retval;
308 }
309 return 0;
310}
311
312static int ext4_ext_swap_inode_data(handle_t *handle, struct inode *inode,
313 struct inode *tmp_inode)
314{
315 int retval;
316 __le32 i_data[3];
317 struct ext4_inode_info *ei = EXT4_I(inode);
318 struct ext4_inode_info *tmp_ei = EXT4_I(tmp_inode);
319
320
321
322
323
324 retval = ext4_journal_extend(handle, 1);
325 if (retval) {
326 retval = ext4_journal_restart(handle, 1);
327 if (retval)
328 goto err_out;
329 }
330
331 i_data[0] = ei->i_data[EXT4_IND_BLOCK];
332 i_data[1] = ei->i_data[EXT4_DIND_BLOCK];
333 i_data[2] = ei->i_data[EXT4_TIND_BLOCK];
334
335 down_write(&EXT4_I(inode)->i_data_sem);
336
337
338
339
340
341 if (!ext4_test_inode_state(inode, EXT4_STATE_EXT_MIGRATE)) {
342 retval = -EAGAIN;
343 up_write(&EXT4_I(inode)->i_data_sem);
344 goto err_out;
345 } else
346 ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
347
348
349
350
351 ext4_set_inode_flag(inode, EXT4_INODE_EXTENTS);
352 memcpy(ei->i_data, tmp_ei->i_data, sizeof(ei->i_data));
353
354
355
356
357
358
359
360
361
362
363 spin_lock(&inode->i_lock);
364 inode->i_blocks += tmp_inode->i_blocks;
365 spin_unlock(&inode->i_lock);
366 up_write(&EXT4_I(inode)->i_data_sem);
367
368
369
370
371
372 retval = free_ind_block(handle, inode, i_data);
373 ext4_mark_inode_dirty(handle, inode);
374
375err_out:
376 return retval;
377}
378
379static int free_ext_idx(handle_t *handle, struct inode *inode,
380 struct ext4_extent_idx *ix)
381{
382 int i, retval = 0;
383 ext4_fsblk_t block;
384 struct buffer_head *bh;
385 struct ext4_extent_header *eh;
386
387 block = ext4_idx_pblock(ix);
388 bh = sb_bread(inode->i_sb, block);
389 if (!bh)
390 return -EIO;
391
392 eh = (struct ext4_extent_header *)bh->b_data;
393 if (eh->eh_depth != 0) {
394 ix = EXT_FIRST_INDEX(eh);
395 for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ix++) {
396 retval = free_ext_idx(handle, inode, ix);
397 if (retval)
398 break;
399 }
400 }
401 put_bh(bh);
402 extend_credit_for_blkdel(handle, inode);
403 ext4_free_blocks(handle, inode, NULL, block, 1,
404 EXT4_FREE_BLOCKS_METADATA | EXT4_FREE_BLOCKS_FORGET);
405 return retval;
406}
407
408
409
410
411static int free_ext_block(handle_t *handle, struct inode *inode)
412{
413 int i, retval = 0;
414 struct ext4_inode_info *ei = EXT4_I(inode);
415 struct ext4_extent_header *eh = (struct ext4_extent_header *)ei->i_data;
416 struct ext4_extent_idx *ix;
417 if (eh->eh_depth == 0)
418
419
420
421 return 0;
422 ix = EXT_FIRST_INDEX(eh);
423 for (i = 0; i < le16_to_cpu(eh->eh_entries); i++, ix++) {
424 retval = free_ext_idx(handle, inode, ix);
425 if (retval)
426 return retval;
427 }
428 return retval;
429
430}
431
432int ext4_ext_migrate(struct inode *inode)
433{
434 handle_t *handle;
435 int retval = 0, i;
436 __le32 *i_data;
437 struct ext4_inode_info *ei;
438 struct inode *tmp_inode = NULL;
439 struct migrate_struct lb;
440 unsigned long max_entries;
441 __u32 goal;
442 uid_t owner[2];
443
444
445
446
447
448 if (!EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb,
449 EXT4_FEATURE_INCOMPAT_EXTENTS) ||
450 (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
451 return -EINVAL;
452
453 if (S_ISLNK(inode->i_mode) && inode->i_blocks == 0)
454
455
456
457 return retval;
458
459
460
461
462
463
464 handle = ext4_journal_start(inode, EXT4_HT_MIGRATE,
465 4 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb));
466
467 if (IS_ERR(handle)) {
468 retval = PTR_ERR(handle);
469 return retval;
470 }
471 goal = (((inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode->i_sb)) *
472 EXT4_INODES_PER_GROUP(inode->i_sb)) + 1;
473 owner[0] = i_uid_read(inode);
474 owner[1] = i_gid_read(inode);
475 tmp_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode,
476 S_IFREG, NULL, goal, owner);
477 if (IS_ERR(tmp_inode)) {
478 retval = PTR_ERR(tmp_inode);
479 ext4_journal_stop(handle);
480 return retval;
481 }
482 i_size_write(tmp_inode, i_size_read(inode));
483
484
485
486
487 clear_nlink(tmp_inode);
488
489 ext4_ext_tree_init(handle, tmp_inode);
490 ext4_orphan_add(handle, tmp_inode);
491 ext4_journal_stop(handle);
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509 down_read((&EXT4_I(inode)->i_data_sem));
510 ext4_set_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
511 up_read((&EXT4_I(inode)->i_data_sem));
512
513 handle = ext4_journal_start(inode, EXT4_HT_MIGRATE, 1);
514 if (IS_ERR(handle)) {
515
516
517
518
519
520 ext4_orphan_del(NULL, tmp_inode);
521 retval = PTR_ERR(handle);
522 goto out;
523 }
524
525 ei = EXT4_I(inode);
526 i_data = ei->i_data;
527 memset(&lb, 0, sizeof(lb));
528
529
530 max_entries = inode->i_sb->s_blocksize >> 2;
531 for (i = 0; i < EXT4_NDIR_BLOCKS; i++) {
532 if (i_data[i]) {
533 retval = update_extent_range(handle, tmp_inode,
534 le32_to_cpu(i_data[i]), &lb);
535 if (retval)
536 goto err_out;
537 } else
538 lb.curr_block++;
539 }
540 if (i_data[EXT4_IND_BLOCK]) {
541 retval = update_ind_extent_range(handle, tmp_inode,
542 le32_to_cpu(i_data[EXT4_IND_BLOCK]), &lb);
543 if (retval)
544 goto err_out;
545 } else
546 lb.curr_block += max_entries;
547 if (i_data[EXT4_DIND_BLOCK]) {
548 retval = update_dind_extent_range(handle, tmp_inode,
549 le32_to_cpu(i_data[EXT4_DIND_BLOCK]), &lb);
550 if (retval)
551 goto err_out;
552 } else
553 lb.curr_block += max_entries * max_entries;
554 if (i_data[EXT4_TIND_BLOCK]) {
555 retval = update_tind_extent_range(handle, tmp_inode,
556 le32_to_cpu(i_data[EXT4_TIND_BLOCK]), &lb);
557 if (retval)
558 goto err_out;
559 }
560
561
562
563 retval = finish_range(handle, tmp_inode, &lb);
564err_out:
565 if (retval)
566
567
568
569
570 free_ext_block(handle, tmp_inode);
571 else {
572 retval = ext4_ext_swap_inode_data(handle, inode, tmp_inode);
573 if (retval)
574
575
576
577
578 free_ext_block(handle, tmp_inode);
579 }
580
581
582 if (ext4_journal_extend(handle, 1) != 0)
583 ext4_journal_restart(handle, 1);
584
585
586
587
588 i_size_write(tmp_inode, 0);
589
590
591
592
593
594
595
596
597
598 tmp_inode->i_blocks = 0;
599
600
601 ext4_ext_tree_init(handle, tmp_inode);
602 ext4_journal_stop(handle);
603out:
604 unlock_new_inode(tmp_inode);
605 iput(tmp_inode);
606
607 return retval;
608}
609