Root/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 "ext4_jbd2.h"
19#include "ext4_extents.h"
20#include "ext4.h"
21
22#define get_ext_path(path, inode, block, ret) \
23    do { \
24        path = ext4_ext_find_extent(inode, block, path); \
25        if (IS_ERR(path)) { \
26            ret = PTR_ERR(path); \
27            path = NULL; \
28        } \
29    } while (0)
30
31/**
32 * copy_extent_status - Copy the extent's initialization status
33 *
34 * @src: an extent for getting initialize status
35 * @dest: an extent to be set the status
36 */
37static void
38copy_extent_status(struct ext4_extent *src, struct ext4_extent *dest)
39{
40    if (ext4_ext_is_uninitialized(src))
41        ext4_ext_mark_uninitialized(dest);
42    else
43        dest->ee_len = cpu_to_le16(ext4_ext_get_actual_len(dest));
44}
45
46/**
47 * mext_next_extent - Search for the next extent and set it to "extent"
48 *
49 * @inode: inode which is searched
50 * @path: this will obtain data for the next extent
51 * @extent: pointer to the next extent we have just gotten
52 *
53 * Search the next extent in the array of ext4_ext_path structure (@path)
54 * and set it to ext4_extent structure (@extent). In addition, the member of
55 * @path (->p_ext) also points the next extent. Return 0 on success, 1 if
56 * ext4_ext_path structure refers to the last extent, or a negative error
57 * value on failure.
58 */
59static int
60mext_next_extent(struct inode *inode, struct ext4_ext_path *path,
61              struct ext4_extent **extent)
62{
63    int ppos, leaf_ppos = path->p_depth;
64
65    ppos = leaf_ppos;
66    if (EXT_LAST_EXTENT(path[ppos].p_hdr) > path[ppos].p_ext) {
67        /* leaf block */
68        *extent = ++path[ppos].p_ext;
69        return 0;
70    }
71
72    while (--ppos >= 0) {
73        if (EXT_LAST_INDEX(path[ppos].p_hdr) >
74            path[ppos].p_idx) {
75            int cur_ppos = ppos;
76
77            /* index block */
78            path[ppos].p_idx++;
79            path[ppos].p_block = idx_pblock(path[ppos].p_idx);
80            if (path[ppos+1].p_bh)
81                brelse(path[ppos+1].p_bh);
82            path[ppos+1].p_bh =
83                sb_bread(inode->i_sb, path[ppos].p_block);
84            if (!path[ppos+1].p_bh)
85                return -EIO;
86            path[ppos+1].p_hdr =
87                ext_block_hdr(path[ppos+1].p_bh);
88
89            /* Halfway index block */
90            while (++cur_ppos < leaf_ppos) {
91                path[cur_ppos].p_idx =
92                    EXT_FIRST_INDEX(path[cur_ppos].p_hdr);
93                path[cur_ppos].p_block =
94                    idx_pblock(path[cur_ppos].p_idx);
95                if (path[cur_ppos+1].p_bh)
96                    brelse(path[cur_ppos+1].p_bh);
97                path[cur_ppos+1].p_bh = sb_bread(inode->i_sb,
98                    path[cur_ppos].p_block);
99                if (!path[cur_ppos+1].p_bh)
100                    return -EIO;
101                path[cur_ppos+1].p_hdr =
102                    ext_block_hdr(path[cur_ppos+1].p_bh);
103            }
104
105            /* leaf block */
106            path[leaf_ppos].p_ext = *extent =
107                EXT_FIRST_EXTENT(path[leaf_ppos].p_hdr);
108            return 0;
109        }
110    }
111    /* We found the last extent */
112    return 1;
113}
114
115/**
116 * mext_double_down_read - Acquire two inodes' read semaphore
117 *
118 * @orig_inode: original inode structure
119 * @donor_inode: donor inode structure
120 * Acquire read semaphore of the two inodes (orig and donor) by i_ino order.
121 */
122static void
123mext_double_down_read(struct inode *orig_inode, struct inode *donor_inode)
124{
125    struct inode *first = orig_inode, *second = donor_inode;
126
127    BUG_ON(orig_inode == NULL || donor_inode == NULL);
128
129    /*
130     * Use the inode number to provide the stable locking order instead
131     * of its address, because the C language doesn't guarantee you can
132     * compare pointers that don't come from the same array.
133     */
134    if (donor_inode->i_ino < orig_inode->i_ino) {
135        first = donor_inode;
136        second = orig_inode;
137    }
138
139    down_read(&EXT4_I(first)->i_data_sem);
140    down_read(&EXT4_I(second)->i_data_sem);
141}
142
143/**
144 * mext_double_down_write - Acquire two inodes' write semaphore
145 *
146 * @orig_inode: original inode structure
147 * @donor_inode: donor inode structure
148 * Acquire write semaphore of the two inodes (orig and donor) by i_ino order.
149 */
150static void
151mext_double_down_write(struct inode *orig_inode, struct inode *donor_inode)
152{
153    struct inode *first = orig_inode, *second = donor_inode;
154
155    BUG_ON(orig_inode == NULL || donor_inode == NULL);
156
157    /*
158     * Use the inode number to provide the stable locking order instead
159     * of its address, because the C language doesn't guarantee you can
160     * compare pointers that don't come from the same array.
161     */
162    if (donor_inode->i_ino < orig_inode->i_ino) {
163        first = donor_inode;
164        second = orig_inode;
165    }
166
167    down_write(&EXT4_I(first)->i_data_sem);
168    down_write(&EXT4_I(second)->i_data_sem);
169}
170
171/**
172 * mext_double_up_read - Release two inodes' read semaphore
173 *
174 * @orig_inode: original inode structure to be released its lock first
175 * @donor_inode: donor inode structure to be released its lock second
176 * Release read semaphore of two inodes (orig and donor).
177 */
178static void
179mext_double_up_read(struct inode *orig_inode, struct inode *donor_inode)
180{
181    BUG_ON(orig_inode == NULL || donor_inode == NULL);
182
183    up_read(&EXT4_I(orig_inode)->i_data_sem);
184    up_read(&EXT4_I(donor_inode)->i_data_sem);
185}
186
187/**
188 * mext_double_up_write - Release two inodes' write semaphore
189 *
190 * @orig_inode: original inode structure to be released its lock first
191 * @donor_inode: donor inode structure to be released its lock second
192 * Release write semaphore of two inodes (orig and donor).
193 */
194static void
195mext_double_up_write(struct inode *orig_inode, struct inode *donor_inode)
196{
197    BUG_ON(orig_inode == NULL || donor_inode == NULL);
198
199    up_write(&EXT4_I(orig_inode)->i_data_sem);
200    up_write(&EXT4_I(donor_inode)->i_data_sem);
201}
202
203/**
204 * mext_insert_across_blocks - Insert extents across leaf block
205 *
206 * @handle: journal handle
207 * @orig_inode: original inode
208 * @o_start: first original extent to be changed
209 * @o_end: last original extent to be changed
210 * @start_ext: first new extent to be inserted
211 * @new_ext: middle of new extent to be inserted
212 * @end_ext: last new extent to be inserted
213 *
214 * Allocate a new leaf block and insert extents into it. Return 0 on success,
215 * or a negative error value on failure.
216 */
217static int
218mext_insert_across_blocks(handle_t *handle, struct inode *orig_inode,
219        struct ext4_extent *o_start, struct ext4_extent *o_end,
220        struct ext4_extent *start_ext, struct ext4_extent *new_ext,
221        struct ext4_extent *end_ext)
222{
223    struct ext4_ext_path *orig_path = NULL;
224    ext4_lblk_t eblock = 0;
225    int new_flag = 0;
226    int end_flag = 0;
227    int err = 0;
228
229    if (start_ext->ee_len && new_ext->ee_len && end_ext->ee_len) {
230        if (o_start == o_end) {
231
232            /* start_ext new_ext end_ext
233             * donor |---------|-----------|--------|
234             * orig |------------------------------|
235             */
236            end_flag = 1;
237        } else {
238
239            /* start_ext new_ext end_ext
240             * donor |---------|----------|---------|
241             * orig |---------------|--------------|
242             */
243            o_end->ee_block = end_ext->ee_block;
244            o_end->ee_len = end_ext->ee_len;
245            ext4_ext_store_pblock(o_end, ext_pblock(end_ext));
246        }
247
248        o_start->ee_len = start_ext->ee_len;
249        new_flag = 1;
250
251    } else if (start_ext->ee_len && new_ext->ee_len &&
252           !end_ext->ee_len && o_start == o_end) {
253
254        /* start_ext new_ext
255         * donor |--------------|---------------|
256         * orig |------------------------------|
257         */
258        o_start->ee_len = start_ext->ee_len;
259        new_flag = 1;
260
261    } else if (!start_ext->ee_len && new_ext->ee_len &&
262           end_ext->ee_len && o_start == o_end) {
263
264        /* new_ext end_ext
265         * donor |--------------|---------------|
266         * orig |------------------------------|
267         */
268        o_end->ee_block = end_ext->ee_block;
269        o_end->ee_len = end_ext->ee_len;
270        ext4_ext_store_pblock(o_end, ext_pblock(end_ext));
271
272        /*
273         * Set 0 to the extent block if new_ext was
274         * the first block.
275         */
276        if (new_ext->ee_block)
277            eblock = le32_to_cpu(new_ext->ee_block);
278
279        new_flag = 1;
280    } else {
281        ext4_debug("ext4 move extent: Unexpected insert case\n");
282        return -EIO;
283    }
284
285    if (new_flag) {
286        get_ext_path(orig_path, orig_inode, eblock, err);
287        if (orig_path == NULL)
288            goto out;
289
290        if (ext4_ext_insert_extent(handle, orig_inode,
291                    orig_path, new_ext))
292            goto out;
293    }
294
295    if (end_flag) {
296        get_ext_path(orig_path, orig_inode,
297                      le32_to_cpu(end_ext->ee_block) - 1, err);
298        if (orig_path == NULL)
299            goto out;
300
301        if (ext4_ext_insert_extent(handle, orig_inode,
302                       orig_path, end_ext))
303            goto out;
304    }
305out:
306    if (orig_path) {
307        ext4_ext_drop_refs(orig_path);
308        kfree(orig_path);
309    }
310
311    return err;
312
313}
314
315/**
316 * mext_insert_inside_block - Insert new extent to the extent block
317 *
318 * @o_start: first original extent to be moved
319 * @o_end: last original extent to be moved
320 * @start_ext: first new extent to be inserted
321 * @new_ext: middle of new extent to be inserted
322 * @end_ext: last new extent to be inserted
323 * @eh: extent header of target leaf block
324 * @range_to_move: used to decide how to insert extent
325 *
326 * Insert extents into the leaf block. The extent (@o_start) is overwritten
327 * by inserted extents.
328 */
329static void
330mext_insert_inside_block(struct ext4_extent *o_start,
331                  struct ext4_extent *o_end,
332                  struct ext4_extent *start_ext,
333                  struct ext4_extent *new_ext,
334                  struct ext4_extent *end_ext,
335                  struct ext4_extent_header *eh,
336                  int range_to_move)
337{
338    int i = 0;
339    unsigned long len;
340
341    /* Move the existing extents */
342    if (range_to_move && o_end < EXT_LAST_EXTENT(eh)) {
343        len = (unsigned long)(EXT_LAST_EXTENT(eh) + 1) -
344            (unsigned long)(o_end + 1);
345        memmove(o_end + 1 + range_to_move, o_end + 1, len);
346    }
347
348    /* Insert start entry */
349    if (start_ext->ee_len)
350        o_start[i++].ee_len = start_ext->ee_len;
351
352    /* Insert new entry */
353    if (new_ext->ee_len) {
354        o_start[i] = *new_ext;
355        ext4_ext_store_pblock(&o_start[i++], ext_pblock(new_ext));
356    }
357
358    /* Insert end entry */
359    if (end_ext->ee_len)
360        o_start[i] = *end_ext;
361
362    /* Increment the total entries counter on the extent block */
363    le16_add_cpu(&eh->eh_entries, range_to_move);
364}
365
366/**
367 * mext_insert_extents - Insert new extent
368 *
369 * @handle: journal handle
370 * @orig_inode: original inode
371 * @orig_path: path indicates first extent to be changed
372 * @o_start: first original extent to be changed
373 * @o_end: last original extent to be changed
374 * @start_ext: first new extent to be inserted
375 * @new_ext: middle of new extent to be inserted
376 * @end_ext: last new extent to be inserted
377 *
378 * Call the function to insert extents. If we cannot add more extents into
379 * the leaf block, we call mext_insert_across_blocks() to create a
380 * new leaf block. Otherwise call mext_insert_inside_block(). Return 0
381 * on success, or a negative error value on failure.
382 */
383static int
384mext_insert_extents(handle_t *handle, struct inode *orig_inode,
385             struct ext4_ext_path *orig_path,
386             struct ext4_extent *o_start,
387             struct ext4_extent *o_end,
388             struct ext4_extent *start_ext,
389             struct ext4_extent *new_ext,
390             struct ext4_extent *end_ext)
391{
392    struct ext4_extent_header *eh;
393    unsigned long need_slots, slots_range;
394    int range_to_move, depth, ret;
395
396    /*
397     * The extents need to be inserted
398     * start_extent + new_extent + end_extent.
399     */
400    need_slots = (start_ext->ee_len ? 1 : 0) + (end_ext->ee_len ? 1 : 0) +
401        (new_ext->ee_len ? 1 : 0);
402
403    /* The number of slots between start and end */
404    slots_range = ((unsigned long)(o_end + 1) - (unsigned long)o_start + 1)
405        / sizeof(struct ext4_extent);
406
407    /* Range to move the end of extent */
408    range_to_move = need_slots - slots_range;
409    depth = orig_path->p_depth;
410    orig_path += depth;
411    eh = orig_path->p_hdr;
412
413    if (depth) {
414        /* Register to journal */
415        ret = ext4_journal_get_write_access(handle, orig_path->p_bh);
416        if (ret)
417            return ret;
418    }
419
420    /* Expansion */
421    if (range_to_move > 0 &&
422        (range_to_move > le16_to_cpu(eh->eh_max)
423            - le16_to_cpu(eh->eh_entries))) {
424
425        ret = mext_insert_across_blocks(handle, orig_inode, o_start,
426                    o_end, start_ext, new_ext, end_ext);
427        if (ret < 0)
428            return ret;
429    } else
430        mext_insert_inside_block(o_start, o_end, start_ext, new_ext,
431                        end_ext, eh, range_to_move);
432
433    if (depth) {
434        ret = ext4_handle_dirty_metadata(handle, orig_inode,
435                         orig_path->p_bh);
436        if (ret)
437            return ret;
438    } else {
439        ret = ext4_mark_inode_dirty(handle, orig_inode);
440        if (ret < 0)
441            return ret;
442    }
443
444    return 0;
445}
446
447/**
448 * mext_leaf_block - Move one leaf extent block into the inode.
449 *
450 * @handle: journal handle
451 * @orig_inode: original inode
452 * @orig_path: path indicates first extent to be changed
453 * @dext: donor extent
454 * @from: start offset on the target file
455 *
456 * In order to insert extents into the leaf block, we must divide the extent
457 * in the leaf block into three extents. The one is located to be inserted
458 * extents, and the others are located around it.
459 *
460 * Therefore, this function creates structures to save extents of the leaf
461 * block, and inserts extents by calling mext_insert_extents() with
462 * created extents. Return 0 on success, or a negative error value on failure.
463 */
464static int
465mext_leaf_block(handle_t *handle, struct inode *orig_inode,
466             struct ext4_ext_path *orig_path, struct ext4_extent *dext,
467             ext4_lblk_t *from)
468{
469    struct ext4_extent *oext, *o_start, *o_end, *prev_ext;
470    struct ext4_extent new_ext, start_ext, end_ext;
471    ext4_lblk_t new_ext_end;
472    ext4_fsblk_t new_phys_end;
473    int oext_alen, new_ext_alen, end_ext_alen;
474    int depth = ext_depth(orig_inode);
475    int ret;
476
477    o_start = o_end = oext = orig_path[depth].p_ext;
478    oext_alen = ext4_ext_get_actual_len(oext);
479    start_ext.ee_len = end_ext.ee_len = 0;
480
481    new_ext.ee_block = cpu_to_le32(*from);
482    ext4_ext_store_pblock(&new_ext, ext_pblock(dext));
483    new_ext.ee_len = dext->ee_len;
484    new_ext_alen = ext4_ext_get_actual_len(&new_ext);
485    new_ext_end = le32_to_cpu(new_ext.ee_block) + new_ext_alen - 1;
486    new_phys_end = ext_pblock(&new_ext) + new_ext_alen - 1;
487
488    /*
489     * Case: original extent is first
490     * oext |--------|
491     * new_ext |--|
492     * start_ext |--|
493     */
494    if (le32_to_cpu(oext->ee_block) < le32_to_cpu(new_ext.ee_block) &&
495        le32_to_cpu(new_ext.ee_block) <
496        le32_to_cpu(oext->ee_block) + oext_alen) {
497        start_ext.ee_len = cpu_to_le16(le32_to_cpu(new_ext.ee_block) -
498                           le32_to_cpu(oext->ee_block));
499        copy_extent_status(oext, &start_ext);
500    } else if (oext > EXT_FIRST_EXTENT(orig_path[depth].p_hdr)) {
501        prev_ext = oext - 1;
502        /*
503         * We can merge new_ext into previous extent,
504         * if these are contiguous and same extent type.
505         */
506        if (ext4_can_extents_be_merged(orig_inode, prev_ext,
507                           &new_ext)) {
508            o_start = prev_ext;
509            start_ext.ee_len = cpu_to_le16(
510                ext4_ext_get_actual_len(prev_ext) +
511                new_ext_alen);
512            copy_extent_status(prev_ext, &start_ext);
513            new_ext.ee_len = 0;
514        }
515    }
516
517    /*
518     * Case: new_ext_end must be less than oext
519     * oext |-----------|
520     * new_ext |-------|
521     */
522    BUG_ON(le32_to_cpu(oext->ee_block) + oext_alen - 1 < new_ext_end);
523
524    /*
525     * Case: new_ext is smaller than original extent
526     * oext |---------------|
527     * new_ext |-----------|
528     * end_ext |---|
529     */
530    if (le32_to_cpu(oext->ee_block) <= new_ext_end &&
531        new_ext_end < le32_to_cpu(oext->ee_block) + oext_alen - 1) {
532        end_ext.ee_len =
533            cpu_to_le16(le32_to_cpu(oext->ee_block) +
534            oext_alen - 1 - new_ext_end);
535        copy_extent_status(oext, &end_ext);
536        end_ext_alen = ext4_ext_get_actual_len(&end_ext);
537        ext4_ext_store_pblock(&end_ext,
538            (ext_pblock(o_end) + oext_alen - end_ext_alen));
539        end_ext.ee_block =
540            cpu_to_le32(le32_to_cpu(o_end->ee_block) +
541            oext_alen - end_ext_alen);
542    }
543
544    ret = mext_insert_extents(handle, orig_inode, orig_path, o_start,
545                o_end, &start_ext, &new_ext, &end_ext);
546    return ret;
547}
548
549/**
550 * mext_calc_swap_extents - Calculate extents for extent swapping.
551 *
552 * @tmp_dext: the extent that will belong to the original inode
553 * @tmp_oext: the extent that will belong to the donor inode
554 * @orig_off: block offset of original inode
555 * @donor_off: block offset of donor inode
556 * @max_count: the maximun length of extents
557 */
558static void
559mext_calc_swap_extents(struct ext4_extent *tmp_dext,
560                  struct ext4_extent *tmp_oext,
561                  ext4_lblk_t orig_off, ext4_lblk_t donor_off,
562                  ext4_lblk_t max_count)
563{
564    ext4_lblk_t diff, orig_diff;
565    struct ext4_extent dext_old, oext_old;
566
567    dext_old = *tmp_dext;
568    oext_old = *tmp_oext;
569
570    /* When tmp_dext is too large, pick up the target range. */
571    diff = donor_off - le32_to_cpu(tmp_dext->ee_block);
572
573    ext4_ext_store_pblock(tmp_dext, ext_pblock(tmp_dext) + diff);
574    tmp_dext->ee_block =
575            cpu_to_le32(le32_to_cpu(tmp_dext->ee_block) + diff);
576    tmp_dext->ee_len = cpu_to_le16(le16_to_cpu(tmp_dext->ee_len) - diff);
577
578    if (max_count < ext4_ext_get_actual_len(tmp_dext))
579        tmp_dext->ee_len = cpu_to_le16(max_count);
580
581    orig_diff = orig_off - le32_to_cpu(tmp_oext->ee_block);
582    ext4_ext_store_pblock(tmp_oext, ext_pblock(tmp_oext) + orig_diff);
583
584    /* Adjust extent length if donor extent is larger than orig */
585    if (ext4_ext_get_actual_len(tmp_dext) >
586        ext4_ext_get_actual_len(tmp_oext) - orig_diff)
587        tmp_dext->ee_len = cpu_to_le16(le16_to_cpu(tmp_oext->ee_len) -
588                        orig_diff);
589
590    tmp_oext->ee_len = cpu_to_le16(ext4_ext_get_actual_len(tmp_dext));
591
592    copy_extent_status(&oext_old, tmp_dext);
593    copy_extent_status(&dext_old, tmp_oext);
594}
595
596/**
597 * mext_replace_branches - Replace original extents with new extents
598 *
599 * @handle: journal handle
600 * @orig_inode: original inode
601 * @donor_inode: donor inode
602 * @from: block offset of orig_inode
603 * @count: block count to be replaced
604 *
605 * Replace original inode extents and donor inode extents page by page.
606 * We implement this replacement in the following three steps:
607 * 1. Save the block information of original and donor inodes into
608 * dummy extents.
609 * 2. Change the block information of original inode to point at the
610 * donor inode blocks.
611 * 3. Change the block information of donor inode to point at the saved
612 * original inode blocks in the dummy extents.
613 *
614 * Return 0 on success, or a negative error value on failure.
615 */
616static int
617mext_replace_branches(handle_t *handle, struct inode *orig_inode,
618               struct inode *donor_inode, ext4_lblk_t from,
619               ext4_lblk_t count)
620{
621    struct ext4_ext_path *orig_path = NULL;
622    struct ext4_ext_path *donor_path = NULL;
623    struct ext4_extent *oext, *dext;
624    struct ext4_extent tmp_dext, tmp_oext;
625    ext4_lblk_t orig_off = from, donor_off = from;
626    int err = 0;
627    int depth;
628    int replaced_count = 0;
629    int dext_alen;
630
631    mext_double_down_write(orig_inode, donor_inode);
632
633    /* Get the original extent for the block "orig_off" */
634    get_ext_path(orig_path, orig_inode, orig_off, err);
635    if (orig_path == NULL)
636        goto out;
637
638    /* Get the donor extent for the head */
639    get_ext_path(donor_path, donor_inode, donor_off, err);
640    if (donor_path == NULL)
641        goto out;
642    depth = ext_depth(orig_inode);
643    oext = orig_path[depth].p_ext;
644    tmp_oext = *oext;
645
646    depth = ext_depth(donor_inode);
647    dext = donor_path[depth].p_ext;
648    tmp_dext = *dext;
649
650    mext_calc_swap_extents(&tmp_dext, &tmp_oext, orig_off,
651                      donor_off, count);
652
653    /* Loop for the donor extents */
654    while (1) {
655        /* The extent for donor must be found. */
656        BUG_ON(!dext || donor_off != le32_to_cpu(tmp_dext.ee_block));
657
658        /* Set donor extent to orig extent */
659        err = mext_leaf_block(handle, orig_inode,
660                       orig_path, &tmp_dext, &orig_off);
661        if (err < 0)
662            goto out;
663
664        /* Set orig extent to donor extent */
665        err = mext_leaf_block(handle, donor_inode,
666                       donor_path, &tmp_oext, &donor_off);
667        if (err < 0)
668            goto out;
669
670        dext_alen = ext4_ext_get_actual_len(&tmp_dext);
671        replaced_count += dext_alen;
672        donor_off += dext_alen;
673        orig_off += dext_alen;
674
675        /* Already moved the expected blocks */
676        if (replaced_count >= count)
677            break;
678
679        if (orig_path)
680            ext4_ext_drop_refs(orig_path);
681        get_ext_path(orig_path, orig_inode, orig_off, err);
682        if (orig_path == NULL)
683            goto out;
684        depth = ext_depth(orig_inode);
685        oext = orig_path[depth].p_ext;
686        if (le32_to_cpu(oext->ee_block) +
687                ext4_ext_get_actual_len(oext) <= orig_off) {
688            err = 0;
689            goto out;
690        }
691        tmp_oext = *oext;
692
693        if (donor_path)
694            ext4_ext_drop_refs(donor_path);
695        get_ext_path(donor_path, donor_inode,
696                      donor_off, err);
697        if (donor_path == NULL)
698            goto out;
699        depth = ext_depth(donor_inode);
700        dext = donor_path[depth].p_ext;
701        if (le32_to_cpu(dext->ee_block) +
702                ext4_ext_get_actual_len(dext) <= donor_off) {
703            err = 0;
704            goto out;
705        }
706        tmp_dext = *dext;
707
708        mext_calc_swap_extents(&tmp_dext, &tmp_oext, orig_off,
709                          donor_off,
710                          count - replaced_count);
711    }
712
713out:
714    if (orig_path) {
715        ext4_ext_drop_refs(orig_path);
716        kfree(orig_path);
717    }
718    if (donor_path) {
719        ext4_ext_drop_refs(donor_path);
720        kfree(donor_path);
721    }
722
723    mext_double_up_write(orig_inode, donor_inode);
724    return err;
725}
726
727/**
728 * move_extent_per_page - Move extent data per page
729 *
730 * @o_filp: file structure of original file
731 * @donor_inode: donor inode
732 * @orig_page_offset: page index on original file
733 * @data_offset_in_page: block index where data swapping starts
734 * @block_len_in_page: the number of blocks to be swapped
735 * @uninit: orig extent is uninitialized or not
736 *
737 * Save the data in original inode blocks and replace original inode extents
738 * with donor inode extents by calling mext_replace_branches().
739 * Finally, write out the saved data in new original inode blocks. Return 0
740 * on success, or a negative error value on failure.
741 */
742static int
743move_extent_par_page(struct file *o_filp, struct inode *donor_inode,
744          pgoff_t orig_page_offset, int data_offset_in_page,
745          int block_len_in_page, int uninit)
746{
747    struct inode *orig_inode = o_filp->f_dentry->d_inode;
748    struct address_space *mapping = orig_inode->i_mapping;
749    struct buffer_head *bh;
750    struct page *page = NULL;
751    const struct address_space_operations *a_ops = mapping->a_ops;
752    handle_t *handle;
753    ext4_lblk_t orig_blk_offset;
754    long long offs = orig_page_offset << PAGE_CACHE_SHIFT;
755    unsigned long blocksize = orig_inode->i_sb->s_blocksize;
756    unsigned int w_flags = 0;
757    unsigned int tmp_data_len, data_len;
758    void *fsdata;
759    int ret, i, jblocks;
760    int blocks_per_page = PAGE_CACHE_SIZE >> orig_inode->i_blkbits;
761
762    /*
763     * It needs twice the amount of ordinary journal buffers because
764     * inode and donor_inode may change each different metadata blocks.
765     */
766    jblocks = ext4_writepage_trans_blocks(orig_inode) * 2;
767    handle = ext4_journal_start(orig_inode, jblocks);
768    if (IS_ERR(handle)) {
769        ret = PTR_ERR(handle);
770        return ret;
771    }
772
773    if (segment_eq(get_fs(), KERNEL_DS))
774        w_flags |= AOP_FLAG_UNINTERRUPTIBLE;
775
776    orig_blk_offset = orig_page_offset * blocks_per_page +
777        data_offset_in_page;
778
779    /*
780     * If orig extent is uninitialized one,
781     * it's not necessary force the page into memory
782     * and then force it to be written out again.
783     * Just swap data blocks between orig and donor.
784     */
785    if (uninit) {
786        ret = mext_replace_branches(handle, orig_inode,
787                         donor_inode, orig_blk_offset,
788                         block_len_in_page);
789
790        /* Clear the inode cache not to refer to the old data */
791        ext4_ext_invalidate_cache(orig_inode);
792        ext4_ext_invalidate_cache(donor_inode);
793        goto out2;
794    }
795
796    offs = (long long)orig_blk_offset << orig_inode->i_blkbits;
797
798    /* Calculate data_len */
799    if ((orig_blk_offset + block_len_in_page - 1) ==
800        ((orig_inode->i_size - 1) >> orig_inode->i_blkbits)) {
801        /* Replace the last block */
802        tmp_data_len = orig_inode->i_size & (blocksize - 1);
803        /*
804         * If data_len equal zero, it shows data_len is multiples of
805         * blocksize. So we set appropriate value.
806         */
807        if (tmp_data_len == 0)
808            tmp_data_len = blocksize;
809
810        data_len = tmp_data_len +
811            ((block_len_in_page - 1) << orig_inode->i_blkbits);
812    } else {
813        data_len = block_len_in_page << orig_inode->i_blkbits;
814    }
815
816    ret = a_ops->write_begin(o_filp, mapping, offs, data_len, w_flags,
817                 &page, &fsdata);
818    if (unlikely(ret < 0))
819        goto out;
820
821    if (!PageUptodate(page)) {
822        mapping->a_ops->readpage(o_filp, page);
823        lock_page(page);
824    }
825
826    /*
827     * try_to_release_page() doesn't call releasepage in writeback mode.
828     * We should care about the order of writing to the same file
829     * by multiple move extent processes.
830     * It needs to call wait_on_page_writeback() to wait for the
831     * writeback of the page.
832     */
833    if (PageWriteback(page))
834        wait_on_page_writeback(page);
835
836    /* Release old bh and drop refs */
837    try_to_release_page(page, 0);
838
839    ret = mext_replace_branches(handle, orig_inode, donor_inode,
840                     orig_blk_offset, block_len_in_page);
841    if (ret < 0)
842        goto out;
843
844    /* Clear the inode cache not to refer to the old data */
845    ext4_ext_invalidate_cache(orig_inode);
846    ext4_ext_invalidate_cache(donor_inode);
847
848    if (!page_has_buffers(page))
849        create_empty_buffers(page, 1 << orig_inode->i_blkbits, 0);
850
851    bh = page_buffers(page);
852    for (i = 0; i < data_offset_in_page; i++)
853        bh = bh->b_this_page;
854
855    for (i = 0; i < block_len_in_page; i++) {
856        ret = ext4_get_block(orig_inode,
857                (sector_t)(orig_blk_offset + i), bh, 0);
858        if (ret < 0)
859            goto out;
860
861        if (bh->b_this_page != NULL)
862            bh = bh->b_this_page;
863    }
864
865    ret = a_ops->write_end(o_filp, mapping, offs, data_len, data_len,
866                   page, fsdata);
867    page = NULL;
868
869out:
870    if (unlikely(page)) {
871        if (PageLocked(page))
872            unlock_page(page);
873        page_cache_release(page);
874    }
875out2:
876    ext4_journal_stop(handle);
877
878    return ret < 0 ? ret : 0;
879}
880
881/**
882 * mext_check_argumants - Check whether move extent can be done
883 *
884 * @orig_inode: original inode
885 * @donor_inode: donor inode
886 * @orig_start: logical start offset in block for orig
887 * @donor_start: logical start offset in block for donor
888 * @len: the number of blocks to be moved
889 * @moved_len: moved block length
890 *
891 * Check the arguments of ext4_move_extents() whether the files can be
892 * exchanged with each other.
893 * Return 0 on success, or a negative error value on failure.
894 */
895static int
896mext_check_arguments(struct inode *orig_inode,
897              struct inode *donor_inode, __u64 orig_start,
898              __u64 donor_start, __u64 *len, __u64 moved_len)
899{
900    /* Regular file check */
901    if (!S_ISREG(orig_inode->i_mode) || !S_ISREG(donor_inode->i_mode)) {
902        ext4_debug("ext4 move extent: The argument files should be "
903            "regular file [ino:orig %lu, donor %lu]\n",
904            orig_inode->i_ino, donor_inode->i_ino);
905        return -EINVAL;
906    }
907
908    /* Ext4 move extent does not support swapfile */
909    if (IS_SWAPFILE(orig_inode) || IS_SWAPFILE(donor_inode)) {
910        ext4_debug("ext4 move extent: The argument files should "
911            "not be swapfile [ino:orig %lu, donor %lu]\n",
912            orig_inode->i_ino, donor_inode->i_ino);
913        return -EINVAL;
914    }
915
916    /* Files should be in the same ext4 FS */
917    if (orig_inode->i_sb != donor_inode->i_sb) {
918        ext4_debug("ext4 move extent: The argument files "
919            "should be in same FS [ino:orig %lu, donor %lu]\n",
920            orig_inode->i_ino, donor_inode->i_ino);
921        return -EINVAL;
922    }
923
924    /* orig and donor should be different file */
925    if (orig_inode->i_ino == donor_inode->i_ino) {
926        ext4_debug("ext4 move extent: The argument files should not "
927            "be same file [ino:orig %lu, donor %lu]\n",
928            orig_inode->i_ino, donor_inode->i_ino);
929        return -EINVAL;
930    }
931
932    /* Ext4 move extent supports only extent based file */
933    if (!(EXT4_I(orig_inode)->i_flags & EXT4_EXTENTS_FL)) {
934        ext4_debug("ext4 move extent: orig file is not extents "
935            "based file [ino:orig %lu]\n", orig_inode->i_ino);
936        return -EOPNOTSUPP;
937    } else if (!(EXT4_I(donor_inode)->i_flags & EXT4_EXTENTS_FL)) {
938        ext4_debug("ext4 move extent: donor file is not extents "
939            "based file [ino:donor %lu]\n", donor_inode->i_ino);
940        return -EOPNOTSUPP;
941    }
942
943    if ((!orig_inode->i_size) || (!donor_inode->i_size)) {
944        ext4_debug("ext4 move extent: File size is 0 byte\n");
945        return -EINVAL;
946    }
947
948    /* Start offset should be same */
949    if (orig_start != donor_start) {
950        ext4_debug("ext4 move extent: orig and donor's start "
951            "offset are not same [ino:orig %lu, donor %lu]\n",
952            orig_inode->i_ino, donor_inode->i_ino);
953        return -EINVAL;
954    }
955
956    if (moved_len) {
957        ext4_debug("ext4 move extent: moved_len should be 0 "
958            "[ino:orig %lu, donor %lu]\n", orig_inode->i_ino,
959            donor_inode->i_ino);
960        return -EINVAL;
961    }
962
963    if ((orig_start > MAX_DEFRAG_SIZE) ||
964        (donor_start > MAX_DEFRAG_SIZE) ||
965        (*len > MAX_DEFRAG_SIZE) ||
966        (orig_start + *len > MAX_DEFRAG_SIZE)) {
967        ext4_debug("ext4 move extent: Can't handle over [%lu] blocks "
968            "[ino:orig %lu, donor %lu]\n", MAX_DEFRAG_SIZE,
969            orig_inode->i_ino, donor_inode->i_ino);
970        return -EINVAL;
971    }
972
973    if (orig_inode->i_size > donor_inode->i_size) {
974        if (orig_start >= donor_inode->i_size) {
975            ext4_debug("ext4 move extent: orig start offset "
976            "[%llu] should be less than donor file size "
977            "[%lld] [ino:orig %lu, donor_inode %lu]\n",
978            orig_start, donor_inode->i_size,
979            orig_inode->i_ino, donor_inode->i_ino);
980            return -EINVAL;
981        }
982
983        if (orig_start + *len > donor_inode->i_size) {
984            ext4_debug("ext4 move extent: End offset [%llu] should "
985                "be less than donor file size [%lld]."
986                "So adjust length from %llu to %lld "
987                "[ino:orig %lu, donor %lu]\n",
988                orig_start + *len, donor_inode->i_size,
989                *len, donor_inode->i_size - orig_start,
990                orig_inode->i_ino, donor_inode->i_ino);
991            *len = donor_inode->i_size - orig_start;
992        }
993    } else {
994        if (orig_start >= orig_inode->i_size) {
995            ext4_debug("ext4 move extent: start offset [%llu] "
996                "should be less than original file size "
997                "[%lld] [inode:orig %lu, donor %lu]\n",
998                 orig_start, orig_inode->i_size,
999                orig_inode->i_ino, donor_inode->i_ino);
1000            return -EINVAL;
1001        }
1002
1003        if (orig_start + *len > orig_inode->i_size) {
1004            ext4_debug("ext4 move extent: Adjust length "
1005                "from %llu to %lld. Because it should be "
1006                "less than original file size "
1007                "[ino:orig %lu, donor %lu]\n",
1008                *len, orig_inode->i_size - orig_start,
1009                orig_inode->i_ino, donor_inode->i_ino);
1010            *len = orig_inode->i_size - orig_start;
1011        }
1012    }
1013
1014    if (!*len) {
1015        ext4_debug("ext4 move extent: len shoudld not be 0 "
1016            "[ino:orig %lu, donor %lu]\n", orig_inode->i_ino,
1017            donor_inode->i_ino);
1018        return -EINVAL;
1019    }
1020
1021    return 0;
1022}
1023
1024/**
1025 * mext_inode_double_lock - Lock i_mutex on both @inode1 and @inode2
1026 *
1027 * @inode1: the inode structure
1028 * @inode2: the inode structure
1029 *
1030 * Lock two inodes' i_mutex by i_ino order. This function is moved from
1031 * fs/inode.c.
1032 */
1033static void
1034mext_inode_double_lock(struct inode *inode1, struct inode *inode2)
1035{
1036    if (inode1 == NULL || inode2 == NULL || inode1 == inode2) {
1037        if (inode1)
1038            mutex_lock(&inode1->i_mutex);
1039        else if (inode2)
1040            mutex_lock(&inode2->i_mutex);
1041        return;
1042    }
1043
1044    if (inode1->i_ino < inode2->i_ino) {
1045        mutex_lock_nested(&inode1->i_mutex, I_MUTEX_PARENT);
1046        mutex_lock_nested(&inode2->i_mutex, I_MUTEX_CHILD);
1047    } else {
1048        mutex_lock_nested(&inode2->i_mutex, I_MUTEX_PARENT);
1049        mutex_lock_nested(&inode1->i_mutex, I_MUTEX_CHILD);
1050    }
1051}
1052
1053/**
1054 * mext_inode_double_unlock - Release i_mutex on both @inode1 and @inode2
1055 *
1056 * @inode1: the inode that is released first
1057 * @inode2: the inode that is released second
1058 *
1059 * This function is moved from fs/inode.c.
1060 */
1061
1062static void
1063mext_inode_double_unlock(struct inode *inode1, struct inode *inode2)
1064{
1065    if (inode1)
1066        mutex_unlock(&inode1->i_mutex);
1067
1068    if (inode2 && inode2 != inode1)
1069        mutex_unlock(&inode2->i_mutex);
1070}
1071
1072/**
1073 * ext4_move_extents - Exchange the specified range of a file
1074 *
1075 * @o_filp: file structure of the original file
1076 * @d_filp: file structure of the donor file
1077 * @orig_start: start offset in block for orig
1078 * @donor_start: start offset in block for donor
1079 * @len: the number of blocks to be moved
1080 * @moved_len: moved block length
1081 *
1082 * This function returns 0 and moved block length is set in moved_len
1083 * if succeed, otherwise returns error value.
1084 *
1085 * Note: ext4_move_extents() proceeds the following order.
1086 * 1:ext4_move_extents() calculates the last block number of moving extent
1087 * function by the start block number (orig_start) and the number of blocks
1088 * to be moved (len) specified as arguments.
1089 * If the {orig, donor}_start points a hole, the extent's start offset
1090 * pointed by ext_cur (current extent), holecheck_path, orig_path are set
1091 * after hole behind.
1092 * 2:Continue step 3 to step 5, until the holecheck_path points to last_extent
1093 * or the ext_cur exceeds the block_end which is last logical block number.
1094 * 3:To get the length of continues area, call mext_next_extent()
1095 * specified with the ext_cur (initial value is holecheck_path) re-cursive,
1096 * until find un-continuous extent, the start logical block number exceeds
1097 * the block_end or the extent points to the last extent.
1098 * 4:Exchange the original inode data with donor inode data
1099 * from orig_page_offset to seq_end_page.
1100 * The start indexes of data are specified as arguments.
1101 * That of the original inode is orig_page_offset,
1102 * and the donor inode is also orig_page_offset
1103 * (To easily handle blocksize != pagesize case, the offset for the
1104 * donor inode is block unit).
1105 * 5:Update holecheck_path and orig_path to points a next proceeding extent,
1106 * then returns to step 2.
1107 * 6:Release holecheck_path, orig_path and set the len to moved_len
1108 * which shows the number of moved blocks.
1109 * The moved_len is useful for the command to calculate the file offset
1110 * for starting next move extent ioctl.
1111 * 7:Return 0 on success, or a negative error value on failure.
1112 */
1113int
1114ext4_move_extents(struct file *o_filp, struct file *d_filp,
1115         __u64 orig_start, __u64 donor_start, __u64 len,
1116         __u64 *moved_len)
1117{
1118    struct inode *orig_inode = o_filp->f_dentry->d_inode;
1119    struct inode *donor_inode = d_filp->f_dentry->d_inode;
1120    struct ext4_ext_path *orig_path = NULL, *holecheck_path = NULL;
1121    struct ext4_extent *ext_prev, *ext_cur, *ext_dummy;
1122    ext4_lblk_t block_start = orig_start;
1123    ext4_lblk_t block_end, seq_start, add_blocks, file_end, seq_blocks = 0;
1124    ext4_lblk_t rest_blocks;
1125    pgoff_t orig_page_offset = 0, seq_end_page;
1126    int ret, depth, last_extent = 0;
1127    int blocks_per_page = PAGE_CACHE_SIZE >> orig_inode->i_blkbits;
1128    int data_offset_in_page;
1129    int block_len_in_page;
1130    int uninit;
1131
1132    /* protect orig and donor against a truncate */
1133    mext_inode_double_lock(orig_inode, donor_inode);
1134
1135    mext_double_down_read(orig_inode, donor_inode);
1136    /* Check the filesystem environment whether move_extent can be done */
1137    ret = mext_check_arguments(orig_inode, donor_inode, orig_start,
1138                    donor_start, &len, *moved_len);
1139    mext_double_up_read(orig_inode, donor_inode);
1140    if (ret)
1141        goto out2;
1142
1143    file_end = (i_size_read(orig_inode) - 1) >> orig_inode->i_blkbits;
1144    block_end = block_start + len - 1;
1145    if (file_end < block_end)
1146        len -= block_end - file_end;
1147
1148    get_ext_path(orig_path, orig_inode, block_start, ret);
1149    if (orig_path == NULL)
1150        goto out2;
1151
1152    /* Get path structure to check the hole */
1153    get_ext_path(holecheck_path, orig_inode, block_start, ret);
1154    if (holecheck_path == NULL)
1155        goto out;
1156
1157    depth = ext_depth(orig_inode);
1158    ext_cur = holecheck_path[depth].p_ext;
1159    if (ext_cur == NULL) {
1160        ret = -EINVAL;
1161        goto out;
1162    }
1163
1164    /*
1165     * Get proper extent whose ee_block is beyond block_start
1166     * if block_start was within the hole.
1167     */
1168    if (le32_to_cpu(ext_cur->ee_block) +
1169        ext4_ext_get_actual_len(ext_cur) - 1 < block_start) {
1170        last_extent = mext_next_extent(orig_inode,
1171                    holecheck_path, &ext_cur);
1172        if (last_extent < 0) {
1173            ret = last_extent;
1174            goto out;
1175        }
1176        last_extent = mext_next_extent(orig_inode, orig_path,
1177                            &ext_dummy);
1178        if (last_extent < 0) {
1179            ret = last_extent;
1180            goto out;
1181        }
1182    }
1183    seq_start = block_start;
1184
1185    /* No blocks within the specified range. */
1186    if (le32_to_cpu(ext_cur->ee_block) > block_end) {
1187        ext4_debug("ext4 move extent: The specified range of file "
1188                            "may be the hole\n");
1189        ret = -EINVAL;
1190        goto out;
1191    }
1192
1193    /* Adjust start blocks */
1194    add_blocks = min(le32_to_cpu(ext_cur->ee_block) +
1195             ext4_ext_get_actual_len(ext_cur), block_end + 1) -
1196             max(le32_to_cpu(ext_cur->ee_block), block_start);
1197
1198    while (!last_extent && le32_to_cpu(ext_cur->ee_block) <= block_end) {
1199        seq_blocks += add_blocks;
1200
1201        /* Adjust tail blocks */
1202        if (seq_start + seq_blocks - 1 > block_end)
1203            seq_blocks = block_end - seq_start + 1;
1204
1205        ext_prev = ext_cur;
1206        last_extent = mext_next_extent(orig_inode, holecheck_path,
1207                        &ext_cur);
1208        if (last_extent < 0) {
1209            ret = last_extent;
1210            break;
1211        }
1212        add_blocks = ext4_ext_get_actual_len(ext_cur);
1213
1214        /*
1215         * Extend the length of contiguous block (seq_blocks)
1216         * if extents are contiguous.
1217         */
1218        if (ext4_can_extents_be_merged(orig_inode,
1219                           ext_prev, ext_cur) &&
1220            block_end >= le32_to_cpu(ext_cur->ee_block) &&
1221            !last_extent)
1222            continue;
1223
1224        /* Is original extent is uninitialized */
1225        uninit = ext4_ext_is_uninitialized(ext_prev);
1226
1227        data_offset_in_page = seq_start % blocks_per_page;
1228
1229        /*
1230         * Calculate data blocks count that should be swapped
1231         * at the first page.
1232         */
1233        if (data_offset_in_page + seq_blocks > blocks_per_page) {
1234            /* Swapped blocks are across pages */
1235            block_len_in_page =
1236                    blocks_per_page - data_offset_in_page;
1237        } else {
1238            /* Swapped blocks are in a page */
1239            block_len_in_page = seq_blocks;
1240        }
1241
1242        orig_page_offset = seq_start >>
1243                (PAGE_CACHE_SHIFT - orig_inode->i_blkbits);
1244        seq_end_page = (seq_start + seq_blocks - 1) >>
1245                (PAGE_CACHE_SHIFT - orig_inode->i_blkbits);
1246        seq_start = le32_to_cpu(ext_cur->ee_block);
1247        rest_blocks = seq_blocks;
1248
1249        /* Discard preallocations of two inodes */
1250        down_write(&EXT4_I(orig_inode)->i_data_sem);
1251        ext4_discard_preallocations(orig_inode);
1252        up_write(&EXT4_I(orig_inode)->i_data_sem);
1253
1254        down_write(&EXT4_I(donor_inode)->i_data_sem);
1255        ext4_discard_preallocations(donor_inode);
1256        up_write(&EXT4_I(donor_inode)->i_data_sem);
1257
1258        while (orig_page_offset <= seq_end_page) {
1259
1260            /* Swap original branches with new branches */
1261            ret = move_extent_par_page(o_filp, donor_inode,
1262                        orig_page_offset,
1263                        data_offset_in_page,
1264                        block_len_in_page, uninit);
1265            if (ret < 0)
1266                goto out;
1267            orig_page_offset++;
1268            /* Count how many blocks we have exchanged */
1269            *moved_len += block_len_in_page;
1270            BUG_ON(*moved_len > len);
1271
1272            data_offset_in_page = 0;
1273            rest_blocks -= block_len_in_page;
1274            if (rest_blocks > blocks_per_page)
1275                block_len_in_page = blocks_per_page;
1276            else
1277                block_len_in_page = rest_blocks;
1278        }
1279
1280        /* Decrease buffer counter */
1281        if (holecheck_path)
1282            ext4_ext_drop_refs(holecheck_path);
1283        get_ext_path(holecheck_path, orig_inode,
1284                      seq_start, ret);
1285        if (holecheck_path == NULL)
1286            break;
1287        depth = holecheck_path->p_depth;
1288
1289        /* Decrease buffer counter */
1290        if (orig_path)
1291            ext4_ext_drop_refs(orig_path);
1292        get_ext_path(orig_path, orig_inode, seq_start, ret);
1293        if (orig_path == NULL)
1294            break;
1295
1296        ext_cur = holecheck_path[depth].p_ext;
1297        add_blocks = ext4_ext_get_actual_len(ext_cur);
1298        seq_blocks = 0;
1299
1300    }
1301out:
1302    if (orig_path) {
1303        ext4_ext_drop_refs(orig_path);
1304        kfree(orig_path);
1305    }
1306    if (holecheck_path) {
1307        ext4_ext_drop_refs(holecheck_path);
1308        kfree(holecheck_path);
1309    }
1310out2:
1311    mext_inode_double_unlock(orig_inode, donor_inode);
1312
1313    if (ret)
1314        return ret;
1315
1316    /* All of the specified blocks must be exchanged in succeed */
1317    BUG_ON(*moved_len != len);
1318
1319    return 0;
1320}
1321

Archive Download this file



interactive