ext4: do not ask jbd2 to write data for delalloc buffers
[sfrench/cifs-2.6.git] / fs / ext4 / move_extent.c
1 /*
2  * Copyright (c) 2008,2009 NEC Software Tohoku, Ltd.
3  * Written by Takashi Sato <t-sato@yk.jp.nec.com>
4  *            Akira Fujita <a-fujita@rs.jp.nec.com>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of version 2.1 of the GNU Lesser General Public License
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  */
15
16 #include <linux/fs.h>
17 #include <linux/quotaops.h>
18 #include <linux/slab.h>
19 #include "ext4_jbd2.h"
20 #include "ext4.h"
21 #include "ext4_extents.h"
22
23 /**
24  * get_ext_path - Find an extent path for designated logical block number.
25  *
26  * @inode:      an inode which is searched
27  * @lblock:     logical block number to find an extent path
28  * @path:       pointer to an extent path pointer (for output)
29  *
30  * ext4_find_extent wrapper. Return 0 on success, or a negative error value
31  * on failure.
32  */
33 static inline int
34 get_ext_path(struct inode *inode, ext4_lblk_t lblock,
35                 struct ext4_ext_path **ppath)
36 {
37         struct ext4_ext_path *path;
38
39         path = ext4_find_extent(inode, lblock, ppath, EXT4_EX_NOCACHE);
40         if (IS_ERR(path))
41                 return PTR_ERR(path);
42         if (path[ext_depth(inode)].p_ext == NULL) {
43                 ext4_ext_drop_refs(path);
44                 kfree(path);
45                 *ppath = NULL;
46                 return -ENODATA;
47         }
48         *ppath = path;
49         return 0;
50 }
51
52 /**
53  * ext4_double_down_write_data_sem - Acquire two inodes' write lock
54  *                                   of i_data_sem
55  *
56  * Acquire write lock of i_data_sem of the two inodes
57  */
58 void
59 ext4_double_down_write_data_sem(struct inode *first, struct inode *second)
60 {
61         if (first < second) {
62                 down_write(&EXT4_I(first)->i_data_sem);
63                 down_write_nested(&EXT4_I(second)->i_data_sem, I_DATA_SEM_OTHER);
64         } else {
65                 down_write(&EXT4_I(second)->i_data_sem);
66                 down_write_nested(&EXT4_I(first)->i_data_sem, I_DATA_SEM_OTHER);
67
68         }
69 }
70
71 /**
72  * ext4_double_up_write_data_sem - Release two inodes' write lock of i_data_sem
73  *
74  * @orig_inode:         original inode structure to be released its lock first
75  * @donor_inode:        donor inode structure to be released its lock second
76  * Release write lock of i_data_sem of two inodes (orig and donor).
77  */
78 void
79 ext4_double_up_write_data_sem(struct inode *orig_inode,
80                               struct inode *donor_inode)
81 {
82         up_write(&EXT4_I(orig_inode)->i_data_sem);
83         up_write(&EXT4_I(donor_inode)->i_data_sem);
84 }
85
86 /**
87  * mext_check_coverage - Check that all extents in range has the same type
88  *
89  * @inode:              inode in question
90  * @from:               block offset of inode
91  * @count:              block count to be checked
92  * @unwritten:          extents expected to be unwritten
93  * @err:                pointer to save error value
94  *
95  * Return 1 if all extents in range has expected type, and zero otherwise.
96  */
97 static int
98 mext_check_coverage(struct inode *inode, ext4_lblk_t from, ext4_lblk_t count,
99                     int unwritten, int *err)
100 {
101         struct ext4_ext_path *path = NULL;
102         struct ext4_extent *ext;
103         int ret = 0;
104         ext4_lblk_t last = from + count;
105         while (from < last) {
106                 *err = get_ext_path(inode, from, &path);
107                 if (*err)
108                         goto out;
109                 ext = path[ext_depth(inode)].p_ext;
110                 if (unwritten != ext4_ext_is_unwritten(ext))
111                         goto out;
112                 from += ext4_ext_get_actual_len(ext);
113                 ext4_ext_drop_refs(path);
114         }
115         ret = 1;
116 out:
117         ext4_ext_drop_refs(path);
118         kfree(path);
119         return ret;
120 }
121
122 /**
123  * mext_page_double_lock - Grab and lock pages on both @inode1 and @inode2
124  *
125  * @inode1:     the inode structure
126  * @inode2:     the inode structure
127  * @index1:     page index
128  * @index2:     page index
129  * @page:       result page vector
130  *
131  * Grab two locked pages for inode's by inode order
132  */
133 static int
134 mext_page_double_lock(struct inode *inode1, struct inode *inode2,
135                       pgoff_t index1, pgoff_t index2, struct page *page[2])
136 {
137         struct address_space *mapping[2];
138         unsigned fl = AOP_FLAG_NOFS;
139
140         BUG_ON(!inode1 || !inode2);
141         if (inode1 < inode2) {
142                 mapping[0] = inode1->i_mapping;
143                 mapping[1] = inode2->i_mapping;
144         } else {
145                 pgoff_t tmp = index1;
146                 index1 = index2;
147                 index2 = tmp;
148                 mapping[0] = inode2->i_mapping;
149                 mapping[1] = inode1->i_mapping;
150         }
151
152         page[0] = grab_cache_page_write_begin(mapping[0], index1, fl);
153         if (!page[0])
154                 return -ENOMEM;
155
156         page[1] = grab_cache_page_write_begin(mapping[1], index2, fl);
157         if (!page[1]) {
158                 unlock_page(page[0]);
159                 put_page(page[0]);
160                 return -ENOMEM;
161         }
162         /*
163          * grab_cache_page_write_begin() may not wait on page's writeback if
164          * BDI not demand that. But it is reasonable to be very conservative
165          * here and explicitly wait on page's writeback
166          */
167         wait_on_page_writeback(page[0]);
168         wait_on_page_writeback(page[1]);
169         if (inode1 > inode2)
170                 swap(page[0], page[1]);
171
172         return 0;
173 }
174
175 /* Force page buffers uptodate w/o dropping page's lock */
176 static int
177 mext_page_mkuptodate(struct page *page, unsigned from, unsigned to)
178 {
179         struct inode *inode = page->mapping->host;
180         sector_t block;
181         struct buffer_head *bh, *head, *arr[MAX_BUF_PER_PAGE];
182         unsigned int blocksize, block_start, block_end;
183         int i, err,  nr = 0, partial = 0;
184         BUG_ON(!PageLocked(page));
185         BUG_ON(PageWriteback(page));
186
187         if (PageUptodate(page))
188                 return 0;
189
190         blocksize = 1 << inode->i_blkbits;
191         if (!page_has_buffers(page))
192                 create_empty_buffers(page, blocksize, 0);
193
194         head = page_buffers(page);
195         block = (sector_t)page->index << (PAGE_SHIFT - inode->i_blkbits);
196         for (bh = head, block_start = 0; bh != head || !block_start;
197              block++, block_start = block_end, bh = bh->b_this_page) {
198                 block_end = block_start + blocksize;
199                 if (block_end <= from || block_start >= to) {
200                         if (!buffer_uptodate(bh))
201                                 partial = 1;
202                         continue;
203                 }
204                 if (buffer_uptodate(bh))
205                         continue;
206                 if (!buffer_mapped(bh)) {
207                         err = ext4_get_block(inode, block, bh, 0);
208                         if (err) {
209                                 SetPageError(page);
210                                 return err;
211                         }
212                         if (!buffer_mapped(bh)) {
213                                 zero_user(page, block_start, blocksize);
214                                 set_buffer_uptodate(bh);
215                                 continue;
216                         }
217                 }
218                 BUG_ON(nr >= MAX_BUF_PER_PAGE);
219                 arr[nr++] = bh;
220         }
221         /* No io required */
222         if (!nr)
223                 goto out;
224
225         for (i = 0; i < nr; i++) {
226                 bh = arr[i];
227                 if (!bh_uptodate_or_lock(bh)) {
228                         err = bh_submit_read(bh);
229                         if (err)
230                                 return err;
231                 }
232         }
233 out:
234         if (!partial)
235                 SetPageUptodate(page);
236         return 0;
237 }
238
239 /**
240  * move_extent_per_page - Move extent data per page
241  *
242  * @o_filp:                     file structure of original file
243  * @donor_inode:                donor inode
244  * @orig_page_offset:           page index on original file
245  * @donor_page_offset:          page index on donor file
246  * @data_offset_in_page:        block index where data swapping starts
247  * @block_len_in_page:          the number of blocks to be swapped
248  * @unwritten:                  orig extent is unwritten or not
249  * @err:                        pointer to save return value
250  *
251  * Save the data in original inode blocks and replace original inode extents
252  * with donor inode extents by calling ext4_swap_extents().
253  * Finally, write out the saved data in new original inode blocks. Return
254  * replaced block count.
255  */
256 static int
257 move_extent_per_page(struct file *o_filp, struct inode *donor_inode,
258                      pgoff_t orig_page_offset, pgoff_t donor_page_offset,
259                      int data_offset_in_page,
260                      int block_len_in_page, int unwritten, int *err)
261 {
262         struct inode *orig_inode = file_inode(o_filp);
263         struct page *pagep[2] = {NULL, NULL};
264         handle_t *handle;
265         ext4_lblk_t orig_blk_offset, donor_blk_offset;
266         unsigned long blocksize = orig_inode->i_sb->s_blocksize;
267         unsigned int tmp_data_size, data_size, replaced_size;
268         int i, err2, jblocks, retries = 0;
269         int replaced_count = 0;
270         int from = data_offset_in_page << orig_inode->i_blkbits;
271         int blocks_per_page = PAGE_SIZE >> orig_inode->i_blkbits;
272         struct super_block *sb = orig_inode->i_sb;
273         struct buffer_head *bh = NULL;
274
275         /*
276          * It needs twice the amount of ordinary journal buffers because
277          * inode and donor_inode may change each different metadata blocks.
278          */
279 again:
280         *err = 0;
281         jblocks = ext4_writepage_trans_blocks(orig_inode) * 2;
282         handle = ext4_journal_start(orig_inode, EXT4_HT_MOVE_EXTENTS, jblocks);
283         if (IS_ERR(handle)) {
284                 *err = PTR_ERR(handle);
285                 return 0;
286         }
287
288         orig_blk_offset = orig_page_offset * blocks_per_page +
289                 data_offset_in_page;
290
291         donor_blk_offset = donor_page_offset * blocks_per_page +
292                 data_offset_in_page;
293
294         /* Calculate data_size */
295         if ((orig_blk_offset + block_len_in_page - 1) ==
296             ((orig_inode->i_size - 1) >> orig_inode->i_blkbits)) {
297                 /* Replace the last block */
298                 tmp_data_size = orig_inode->i_size & (blocksize - 1);
299                 /*
300                  * If data_size equal zero, it shows data_size is multiples of
301                  * blocksize. So we set appropriate value.
302                  */
303                 if (tmp_data_size == 0)
304                         tmp_data_size = blocksize;
305
306                 data_size = tmp_data_size +
307                         ((block_len_in_page - 1) << orig_inode->i_blkbits);
308         } else
309                 data_size = block_len_in_page << orig_inode->i_blkbits;
310
311         replaced_size = data_size;
312
313         *err = mext_page_double_lock(orig_inode, donor_inode, orig_page_offset,
314                                      donor_page_offset, pagep);
315         if (unlikely(*err < 0))
316                 goto stop_journal;
317         /*
318          * If orig extent was unwritten it can become initialized
319          * at any time after i_data_sem was dropped, in order to
320          * serialize with delalloc we have recheck extent while we
321          * hold page's lock, if it is still the case data copy is not
322          * necessary, just swap data blocks between orig and donor.
323          */
324         if (unwritten) {
325                 ext4_double_down_write_data_sem(orig_inode, donor_inode);
326                 /* If any of extents in range became initialized we have to
327                  * fallback to data copying */
328                 unwritten = mext_check_coverage(orig_inode, orig_blk_offset,
329                                                 block_len_in_page, 1, err);
330                 if (*err)
331                         goto drop_data_sem;
332
333                 unwritten &= mext_check_coverage(donor_inode, donor_blk_offset,
334                                                  block_len_in_page, 1, err);
335                 if (*err)
336                         goto drop_data_sem;
337
338                 if (!unwritten) {
339                         ext4_double_up_write_data_sem(orig_inode, donor_inode);
340                         goto data_copy;
341                 }
342                 if ((page_has_private(pagep[0]) &&
343                      !try_to_release_page(pagep[0], 0)) ||
344                     (page_has_private(pagep[1]) &&
345                      !try_to_release_page(pagep[1], 0))) {
346                         *err = -EBUSY;
347                         goto drop_data_sem;
348                 }
349                 replaced_count = ext4_swap_extents(handle, orig_inode,
350                                                    donor_inode, orig_blk_offset,
351                                                    donor_blk_offset,
352                                                    block_len_in_page, 1, err);
353         drop_data_sem:
354                 ext4_double_up_write_data_sem(orig_inode, donor_inode);
355                 goto unlock_pages;
356         }
357 data_copy:
358         *err = mext_page_mkuptodate(pagep[0], from, from + replaced_size);
359         if (*err)
360                 goto unlock_pages;
361
362         /* At this point all buffers in range are uptodate, old mapping layout
363          * is no longer required, try to drop it now. */
364         if ((page_has_private(pagep[0]) && !try_to_release_page(pagep[0], 0)) ||
365             (page_has_private(pagep[1]) && !try_to_release_page(pagep[1], 0))) {
366                 *err = -EBUSY;
367                 goto unlock_pages;
368         }
369         ext4_double_down_write_data_sem(orig_inode, donor_inode);
370         replaced_count = ext4_swap_extents(handle, orig_inode, donor_inode,
371                                                orig_blk_offset, donor_blk_offset,
372                                            block_len_in_page, 1, err);
373         ext4_double_up_write_data_sem(orig_inode, donor_inode);
374         if (*err) {
375                 if (replaced_count) {
376                         block_len_in_page = replaced_count;
377                         replaced_size =
378                                 block_len_in_page << orig_inode->i_blkbits;
379                 } else
380                         goto unlock_pages;
381         }
382         /* Perform all necessary steps similar write_begin()/write_end()
383          * but keeping in mind that i_size will not change */
384         if (!page_has_buffers(pagep[0]))
385                 create_empty_buffers(pagep[0], 1 << orig_inode->i_blkbits, 0);
386         bh = page_buffers(pagep[0]);
387         for (i = 0; i < data_offset_in_page; i++)
388                 bh = bh->b_this_page;
389         for (i = 0; i < block_len_in_page; i++) {
390                 *err = ext4_get_block(orig_inode, orig_blk_offset + i, bh, 0);
391                 if (*err < 0)
392                         break;
393                 bh = bh->b_this_page;
394         }
395         if (!*err)
396                 *err = block_commit_write(pagep[0], from, from + replaced_size);
397
398         if (unlikely(*err < 0))
399                 goto repair_branches;
400
401         /* Even in case of data=writeback it is reasonable to pin
402          * inode to transaction, to prevent unexpected data loss */
403         *err = ext4_jbd2_inode_add_write(handle, orig_inode);
404
405 unlock_pages:
406         unlock_page(pagep[0]);
407         put_page(pagep[0]);
408         unlock_page(pagep[1]);
409         put_page(pagep[1]);
410 stop_journal:
411         ext4_journal_stop(handle);
412         if (*err == -ENOSPC &&
413             ext4_should_retry_alloc(sb, &retries))
414                 goto again;
415         /* Buffer was busy because probably is pinned to journal transaction,
416          * force transaction commit may help to free it. */
417         if (*err == -EBUSY && retries++ < 4 && EXT4_SB(sb)->s_journal &&
418             jbd2_journal_force_commit_nested(EXT4_SB(sb)->s_journal))
419                 goto again;
420         return replaced_count;
421
422 repair_branches:
423         /*
424          * This should never ever happen!
425          * Extents are swapped already, but we are not able to copy data.
426          * Try to swap extents to it's original places
427          */
428         ext4_double_down_write_data_sem(orig_inode, donor_inode);
429         replaced_count = ext4_swap_extents(handle, donor_inode, orig_inode,
430                                                orig_blk_offset, donor_blk_offset,
431                                            block_len_in_page, 0, &err2);
432         ext4_double_up_write_data_sem(orig_inode, donor_inode);
433         if (replaced_count != block_len_in_page) {
434                 EXT4_ERROR_INODE_BLOCK(orig_inode, (sector_t)(orig_blk_offset),
435                                        "Unable to copy data block,"
436                                        " data will be lost.");
437                 *err = -EIO;
438         }
439         replaced_count = 0;
440         goto unlock_pages;
441 }
442
443 /**
444  * mext_check_arguments - Check whether move extent can be done
445  *
446  * @orig_inode:         original inode
447  * @donor_inode:        donor inode
448  * @orig_start:         logical start offset in block for orig
449  * @donor_start:        logical start offset in block for donor
450  * @len:                the number of blocks to be moved
451  *
452  * Check the arguments of ext4_move_extents() whether the files can be
453  * exchanged with each other.
454  * Return 0 on success, or a negative error value on failure.
455  */
456 static int
457 mext_check_arguments(struct inode *orig_inode,
458                      struct inode *donor_inode, __u64 orig_start,
459                      __u64 donor_start, __u64 *len)
460 {
461         __u64 orig_eof, donor_eof;
462         unsigned int blkbits = orig_inode->i_blkbits;
463         unsigned int blocksize = 1 << blkbits;
464
465         orig_eof = (i_size_read(orig_inode) + blocksize - 1) >> blkbits;
466         donor_eof = (i_size_read(donor_inode) + blocksize - 1) >> blkbits;
467
468
469         if (donor_inode->i_mode & (S_ISUID|S_ISGID)) {
470                 ext4_debug("ext4 move extent: suid or sgid is set"
471                            " to donor file [ino:orig %lu, donor %lu]\n",
472                            orig_inode->i_ino, donor_inode->i_ino);
473                 return -EINVAL;
474         }
475
476         if (IS_IMMUTABLE(donor_inode) || IS_APPEND(donor_inode))
477                 return -EPERM;
478
479         /* Ext4 move extent does not support swapfile */
480         if (IS_SWAPFILE(orig_inode) || IS_SWAPFILE(donor_inode)) {
481                 ext4_debug("ext4 move extent: The argument files should "
482                         "not be swapfile [ino:orig %lu, donor %lu]\n",
483                         orig_inode->i_ino, donor_inode->i_ino);
484                 return -EBUSY;
485         }
486
487         if (IS_NOQUOTA(orig_inode) || IS_NOQUOTA(donor_inode)) {
488                 ext4_debug("ext4 move extent: The argument files should "
489                         "not be quota files [ino:orig %lu, donor %lu]\n",
490                         orig_inode->i_ino, donor_inode->i_ino);
491                 return -EBUSY;
492         }
493
494         /* Ext4 move extent supports only extent based file */
495         if (!(ext4_test_inode_flag(orig_inode, EXT4_INODE_EXTENTS))) {
496                 ext4_debug("ext4 move extent: orig file is not extents "
497                         "based file [ino:orig %lu]\n", orig_inode->i_ino);
498                 return -EOPNOTSUPP;
499         } else if (!(ext4_test_inode_flag(donor_inode, EXT4_INODE_EXTENTS))) {
500                 ext4_debug("ext4 move extent: donor file is not extents "
501                         "based file [ino:donor %lu]\n", donor_inode->i_ino);
502                 return -EOPNOTSUPP;
503         }
504
505         if ((!orig_inode->i_size) || (!donor_inode->i_size)) {
506                 ext4_debug("ext4 move extent: File size is 0 byte\n");
507                 return -EINVAL;
508         }
509
510         /* Start offset should be same */
511         if ((orig_start & ~(PAGE_MASK >> orig_inode->i_blkbits)) !=
512             (donor_start & ~(PAGE_MASK >> orig_inode->i_blkbits))) {
513                 ext4_debug("ext4 move extent: orig and donor's start "
514                         "offset are not alligned [ino:orig %lu, donor %lu]\n",
515                         orig_inode->i_ino, donor_inode->i_ino);
516                 return -EINVAL;
517         }
518
519         if ((orig_start >= EXT_MAX_BLOCKS) ||
520             (donor_start >= EXT_MAX_BLOCKS) ||
521             (*len > EXT_MAX_BLOCKS) ||
522             (donor_start + *len >= EXT_MAX_BLOCKS) ||
523             (orig_start + *len >= EXT_MAX_BLOCKS))  {
524                 ext4_debug("ext4 move extent: Can't handle over [%u] blocks "
525                         "[ino:orig %lu, donor %lu]\n", EXT_MAX_BLOCKS,
526                         orig_inode->i_ino, donor_inode->i_ino);
527                 return -EINVAL;
528         }
529         if (orig_eof < orig_start + *len - 1)
530                 *len = orig_eof - orig_start;
531         if (donor_eof < donor_start + *len - 1)
532                 *len = donor_eof - donor_start;
533         if (!*len) {
534                 ext4_debug("ext4 move extent: len should not be 0 "
535                         "[ino:orig %lu, donor %lu]\n", orig_inode->i_ino,
536                         donor_inode->i_ino);
537                 return -EINVAL;
538         }
539
540         return 0;
541 }
542
543 /**
544  * ext4_move_extents - Exchange the specified range of a file
545  *
546  * @o_filp:             file structure of the original file
547  * @d_filp:             file structure of the donor file
548  * @orig_blk:           start offset in block for orig
549  * @donor_blk:          start offset in block for donor
550  * @len:                the number of blocks to be moved
551  * @moved_len:          moved block length
552  *
553  * This function returns 0 and moved block length is set in moved_len
554  * if succeed, otherwise returns error value.
555  *
556  */
557 int
558 ext4_move_extents(struct file *o_filp, struct file *d_filp, __u64 orig_blk,
559                   __u64 donor_blk, __u64 len, __u64 *moved_len)
560 {
561         struct inode *orig_inode = file_inode(o_filp);
562         struct inode *donor_inode = file_inode(d_filp);
563         struct ext4_ext_path *path = NULL;
564         int blocks_per_page = PAGE_SIZE >> orig_inode->i_blkbits;
565         ext4_lblk_t o_end, o_start = orig_blk;
566         ext4_lblk_t d_start = donor_blk;
567         int ret;
568
569         if (orig_inode->i_sb != donor_inode->i_sb) {
570                 ext4_debug("ext4 move extent: The argument files "
571                         "should be in same FS [ino:orig %lu, donor %lu]\n",
572                         orig_inode->i_ino, donor_inode->i_ino);
573                 return -EINVAL;
574         }
575
576         /* orig and donor should be different inodes */
577         if (orig_inode == donor_inode) {
578                 ext4_debug("ext4 move extent: The argument files should not "
579                         "be same inode [ino:orig %lu, donor %lu]\n",
580                         orig_inode->i_ino, donor_inode->i_ino);
581                 return -EINVAL;
582         }
583
584         /* Regular file check */
585         if (!S_ISREG(orig_inode->i_mode) || !S_ISREG(donor_inode->i_mode)) {
586                 ext4_debug("ext4 move extent: The argument files should be "
587                         "regular file [ino:orig %lu, donor %lu]\n",
588                         orig_inode->i_ino, donor_inode->i_ino);
589                 return -EINVAL;
590         }
591
592         /* TODO: it's not obvious how to swap blocks for inodes with full
593            journaling enabled */
594         if (ext4_should_journal_data(orig_inode) ||
595             ext4_should_journal_data(donor_inode)) {
596                 ext4_msg(orig_inode->i_sb, KERN_ERR,
597                          "Online defrag not supported with data journaling");
598                 return -EOPNOTSUPP;
599         }
600
601         /* Protect orig and donor inodes against a truncate */
602         lock_two_nondirectories(orig_inode, donor_inode);
603
604         /* Wait for all existing dio workers */
605         ext4_inode_block_unlocked_dio(orig_inode);
606         ext4_inode_block_unlocked_dio(donor_inode);
607         inode_dio_wait(orig_inode);
608         inode_dio_wait(donor_inode);
609
610         /* Protect extent tree against block allocations via delalloc */
611         ext4_double_down_write_data_sem(orig_inode, donor_inode);
612         /* Check the filesystem environment whether move_extent can be done */
613         ret = mext_check_arguments(orig_inode, donor_inode, orig_blk,
614                                     donor_blk, &len);
615         if (ret)
616                 goto out;
617         o_end = o_start + len;
618
619         while (o_start < o_end) {
620                 struct ext4_extent *ex;
621                 ext4_lblk_t cur_blk, next_blk;
622                 pgoff_t orig_page_index, donor_page_index;
623                 int offset_in_page;
624                 int unwritten, cur_len;
625
626                 ret = get_ext_path(orig_inode, o_start, &path);
627                 if (ret)
628                         goto out;
629                 ex = path[path->p_depth].p_ext;
630                 next_blk = ext4_ext_next_allocated_block(path);
631                 cur_blk = le32_to_cpu(ex->ee_block);
632                 cur_len = ext4_ext_get_actual_len(ex);
633                 /* Check hole before the start pos */
634                 if (cur_blk + cur_len - 1 < o_start) {
635                         if (next_blk == EXT_MAX_BLOCKS) {
636                                 o_start = o_end;
637                                 ret = -ENODATA;
638                                 goto out;
639                         }
640                         d_start += next_blk - o_start;
641                         o_start = next_blk;
642                         continue;
643                 /* Check hole after the start pos */
644                 } else if (cur_blk > o_start) {
645                         /* Skip hole */
646                         d_start += cur_blk - o_start;
647                         o_start = cur_blk;
648                         /* Extent inside requested range ?*/
649                         if (cur_blk >= o_end)
650                                 goto out;
651                 } else { /* in_range(o_start, o_blk, o_len) */
652                         cur_len += cur_blk - o_start;
653                 }
654                 unwritten = ext4_ext_is_unwritten(ex);
655                 if (o_end - o_start < cur_len)
656                         cur_len = o_end - o_start;
657
658                 orig_page_index = o_start >> (PAGE_SHIFT -
659                                                orig_inode->i_blkbits);
660                 donor_page_index = d_start >> (PAGE_SHIFT -
661                                                donor_inode->i_blkbits);
662                 offset_in_page = o_start % blocks_per_page;
663                 if (cur_len > blocks_per_page- offset_in_page)
664                         cur_len = blocks_per_page - offset_in_page;
665                 /*
666                  * Up semaphore to avoid following problems:
667                  * a. transaction deadlock among ext4_journal_start,
668                  *    ->write_begin via pagefault, and jbd2_journal_commit
669                  * b. racing with ->readpage, ->write_begin, and ext4_get_block
670                  *    in move_extent_per_page
671                  */
672                 ext4_double_up_write_data_sem(orig_inode, donor_inode);
673                 /* Swap original branches with new branches */
674                 move_extent_per_page(o_filp, donor_inode,
675                                      orig_page_index, donor_page_index,
676                                      offset_in_page, cur_len,
677                                      unwritten, &ret);
678                 ext4_double_down_write_data_sem(orig_inode, donor_inode);
679                 if (ret < 0)
680                         break;
681                 o_start += cur_len;
682                 d_start += cur_len;
683         }
684         *moved_len = o_start - orig_blk;
685         if (*moved_len > len)
686                 *moved_len = len;
687
688 out:
689         if (*moved_len) {
690                 ext4_discard_preallocations(orig_inode);
691                 ext4_discard_preallocations(donor_inode);
692         }
693
694         ext4_ext_drop_refs(path);
695         kfree(path);
696         ext4_double_up_write_data_sem(orig_inode, donor_inode);
697         ext4_inode_resume_unlocked_dio(orig_inode);
698         ext4_inode_resume_unlocked_dio(donor_inode);
699         unlock_two_nondirectories(orig_inode, donor_inode);
700
701         return ret;
702 }