Branch data Line data Source code
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_ext_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 **orig_path)
36 : : {
37 : : int ret = 0;
38 : : struct ext4_ext_path *path;
39 : :
40 : 0 : path = ext4_ext_find_extent(inode, lblock, *orig_path, EXT4_EX_NOCACHE);
41 [ # # # # : 0 : if (IS_ERR(path))
# # # # #
# # # # #
# # # # #
# # # ]
42 : : ret = PTR_ERR(path);
43 [ # # ][ # # ]: 0 : else if (path[ext_depth(inode)].p_ext == NULL)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
44 : : ret = -ENODATA;
45 : : else
46 : : *orig_path = path;
47 : :
48 : : return ret;
49 : : }
50 : :
51 : : /**
52 : : * copy_extent_status - Copy the extent's initialization status
53 : : *
54 : : * @src: an extent for getting initialize status
55 : : * @dest: an extent to be set the status
56 : : */
57 : : static void
58 : 0 : copy_extent_status(struct ext4_extent *src, struct ext4_extent *dest)
59 : : {
60 [ # # ]: 0 : if (ext4_ext_is_uninitialized(src))
61 : : ext4_ext_mark_uninitialized(dest);
62 : : else
63 : 0 : dest->ee_len = cpu_to_le16(ext4_ext_get_actual_len(dest));
64 : 0 : }
65 : :
66 : : /**
67 : : * mext_next_extent - Search for the next extent and set it to "extent"
68 : : *
69 : : * @inode: inode which is searched
70 : : * @path: this will obtain data for the next extent
71 : : * @extent: pointer to the next extent we have just gotten
72 : : *
73 : : * Search the next extent in the array of ext4_ext_path structure (@path)
74 : : * and set it to ext4_extent structure (@extent). In addition, the member of
75 : : * @path (->p_ext) also points the next extent. Return 0 on success, 1 if
76 : : * ext4_ext_path structure refers to the last extent, or a negative error
77 : : * value on failure.
78 : : */
79 : : static int
80 : 0 : mext_next_extent(struct inode *inode, struct ext4_ext_path *path,
81 : : struct ext4_extent **extent)
82 : : {
83 : : struct ext4_extent_header *eh;
84 : 0 : int ppos, leaf_ppos = path->p_depth;
85 : :
86 : : ppos = leaf_ppos;
87 [ # # ]: 0 : if (EXT_LAST_EXTENT(path[ppos].p_hdr) > path[ppos].p_ext) {
88 : : /* leaf block */
89 : 0 : *extent = ++path[ppos].p_ext;
90 : 0 : path[ppos].p_block = ext4_ext_pblock(path[ppos].p_ext);
91 : : return 0;
92 : : }
93 : :
94 [ # # ]: 0 : while (--ppos >= 0) {
95 [ # # ]: 0 : if (EXT_LAST_INDEX(path[ppos].p_hdr) >
96 : 0 : path[ppos].p_idx) {
97 : : int cur_ppos = ppos;
98 : :
99 : : /* index block */
100 : 0 : path[ppos].p_idx++;
101 : 0 : path[ppos].p_block = ext4_idx_pblock(path[ppos].p_idx);
102 [ # # ]: 0 : if (path[ppos+1].p_bh)
103 : : brelse(path[ppos+1].p_bh);
104 : 0 : path[ppos+1].p_bh =
105 : 0 : sb_bread(inode->i_sb, path[ppos].p_block);
106 [ # # ]: 0 : if (!path[ppos+1].p_bh)
107 : : return -EIO;
108 : 0 : path[ppos+1].p_hdr =
109 : : ext_block_hdr(path[ppos+1].p_bh);
110 : :
111 : : /* Halfway index block */
112 [ # # ]: 0 : while (++cur_ppos < leaf_ppos) {
113 : 0 : path[cur_ppos].p_idx =
114 : 0 : EXT_FIRST_INDEX(path[cur_ppos].p_hdr);
115 : 0 : path[cur_ppos].p_block =
116 : 0 : ext4_idx_pblock(path[cur_ppos].p_idx);
117 [ # # ]: 0 : if (path[cur_ppos+1].p_bh)
118 : : brelse(path[cur_ppos+1].p_bh);
119 : 0 : path[cur_ppos+1].p_bh = sb_bread(inode->i_sb,
120 : : path[cur_ppos].p_block);
121 [ # # ]: 0 : if (!path[cur_ppos+1].p_bh)
122 : : return -EIO;
123 : 0 : path[cur_ppos+1].p_hdr =
124 : : ext_block_hdr(path[cur_ppos+1].p_bh);
125 : : }
126 : :
127 : 0 : path[leaf_ppos].p_ext = *extent = NULL;
128 : :
129 : 0 : eh = path[leaf_ppos].p_hdr;
130 [ # # ]: 0 : if (le16_to_cpu(eh->eh_entries) == 0)
131 : : /* empty leaf is found */
132 : : return -ENODATA;
133 : :
134 : : /* leaf block */
135 : 0 : path[leaf_ppos].p_ext = *extent =
136 : 0 : EXT_FIRST_EXTENT(path[leaf_ppos].p_hdr);
137 : 0 : path[leaf_ppos].p_block =
138 : 0 : ext4_ext_pblock(path[leaf_ppos].p_ext);
139 : : return 0;
140 : : }
141 : : }
142 : : /* We found the last extent */
143 : : return 1;
144 : : }
145 : :
146 : : /**
147 : : * ext4_double_down_write_data_sem - Acquire two inodes' write lock
148 : : * of i_data_sem
149 : : *
150 : : * Acquire write lock of i_data_sem of the two inodes
151 : : */
152 : : void
153 : 0 : ext4_double_down_write_data_sem(struct inode *first, struct inode *second)
154 : : {
155 [ # # ]: 0 : if (first < second) {
156 : 0 : down_write(&EXT4_I(first)->i_data_sem);
157 : 0 : down_write_nested(&EXT4_I(second)->i_data_sem, SINGLE_DEPTH_NESTING);
158 : : } else {
159 : 0 : down_write(&EXT4_I(second)->i_data_sem);
160 : 0 : down_write_nested(&EXT4_I(first)->i_data_sem, SINGLE_DEPTH_NESTING);
161 : :
162 : : }
163 : 0 : }
164 : :
165 : : /**
166 : : * ext4_double_up_write_data_sem - Release two inodes' write lock of i_data_sem
167 : : *
168 : : * @orig_inode: original inode structure to be released its lock first
169 : : * @donor_inode: donor inode structure to be released its lock second
170 : : * Release write lock of i_data_sem of two inodes (orig and donor).
171 : : */
172 : : void
173 : 0 : ext4_double_up_write_data_sem(struct inode *orig_inode,
174 : : struct inode *donor_inode)
175 : : {
176 : 0 : up_write(&EXT4_I(orig_inode)->i_data_sem);
177 : 0 : up_write(&EXT4_I(donor_inode)->i_data_sem);
178 : 0 : }
179 : :
180 : : /**
181 : : * mext_insert_across_blocks - Insert extents across leaf block
182 : : *
183 : : * @handle: journal handle
184 : : * @orig_inode: original inode
185 : : * @o_start: first original extent to be changed
186 : : * @o_end: last original extent to be changed
187 : : * @start_ext: first new extent to be inserted
188 : : * @new_ext: middle of new extent to be inserted
189 : : * @end_ext: last new extent to be inserted
190 : : *
191 : : * Allocate a new leaf block and insert extents into it. Return 0 on success,
192 : : * or a negative error value on failure.
193 : : */
194 : : static int
195 : 0 : mext_insert_across_blocks(handle_t *handle, struct inode *orig_inode,
196 : : struct ext4_extent *o_start, struct ext4_extent *o_end,
197 : : struct ext4_extent *start_ext, struct ext4_extent *new_ext,
198 : 0 : struct ext4_extent *end_ext)
199 : : {
200 : : struct ext4_ext_path *orig_path = NULL;
201 : : ext4_lblk_t eblock = 0;
202 : : int new_flag = 0;
203 : : int end_flag = 0;
204 : : int err = 0;
205 : :
206 [ # # ][ # # ]: 0 : if (start_ext->ee_len && new_ext->ee_len && end_ext->ee_len) {
[ # # ]
207 [ # # ]: 0 : if (o_start == o_end) {
208 : :
209 : : /* start_ext new_ext end_ext
210 : : * donor |---------|-----------|--------|
211 : : * orig |------------------------------|
212 : : */
213 : : end_flag = 1;
214 : : } else {
215 : :
216 : : /* start_ext new_ext end_ext
217 : : * donor |---------|----------|---------|
218 : : * orig |---------------|--------------|
219 : : */
220 : 0 : o_end->ee_block = end_ext->ee_block;
221 : 0 : o_end->ee_len = end_ext->ee_len;
222 : : ext4_ext_store_pblock(o_end, ext4_ext_pblock(end_ext));
223 : : }
224 : :
225 : 0 : o_start->ee_len = start_ext->ee_len;
226 : 0 : eblock = le32_to_cpu(start_ext->ee_block);
227 : : new_flag = 1;
228 : :
229 [ # # ][ # # ]: 0 : } else if (start_ext->ee_len && new_ext->ee_len &&
[ # # ]
230 [ # # ]: 0 : !end_ext->ee_len && o_start == o_end) {
231 : :
232 : : /* start_ext new_ext
233 : : * donor |--------------|---------------|
234 : : * orig |------------------------------|
235 : : */
236 : 0 : o_start->ee_len = start_ext->ee_len;
237 : 0 : eblock = le32_to_cpu(start_ext->ee_block);
238 : : new_flag = 1;
239 : :
240 [ # # ][ # # ]: 0 : } else if (!start_ext->ee_len && new_ext->ee_len &&
[ # # ]
241 [ # # ]: 0 : end_ext->ee_len && o_start == o_end) {
242 : :
243 : : /* new_ext end_ext
244 : : * donor |--------------|---------------|
245 : : * orig |------------------------------|
246 : : */
247 : 0 : o_end->ee_block = end_ext->ee_block;
248 : 0 : o_end->ee_len = end_ext->ee_len;
249 : : ext4_ext_store_pblock(o_end, ext4_ext_pblock(end_ext));
250 : :
251 : : /*
252 : : * Set 0 to the extent block if new_ext was
253 : : * the first block.
254 : : */
255 [ # # ]: 0 : if (new_ext->ee_block)
256 : : eblock = le32_to_cpu(new_ext->ee_block);
257 : :
258 : : new_flag = 1;
259 : : } else {
260 : : ext4_debug("ext4 move extent: Unexpected insert case\n");
261 : : return -EIO;
262 : : }
263 : :
264 : : if (new_flag) {
265 : : err = get_ext_path(orig_inode, eblock, &orig_path);
266 [ # # ]: 0 : if (err)
267 : : goto out;
268 : :
269 [ # # ]: 0 : if (ext4_ext_insert_extent(handle, orig_inode,
270 : : orig_path, new_ext, 0))
271 : : goto out;
272 : : }
273 : :
274 [ # # ]: 0 : if (end_flag) {
275 : 0 : err = get_ext_path(orig_inode,
276 : 0 : le32_to_cpu(end_ext->ee_block) - 1, &orig_path);
277 [ # # ]: 0 : if (err)
278 : : goto out;
279 : :
280 : 0 : if (ext4_ext_insert_extent(handle, orig_inode,
281 : : orig_path, end_ext, 0))
282 : : goto out;
283 : : }
284 : : out:
285 [ # # ]: 0 : if (orig_path) {
286 : 0 : ext4_ext_drop_refs(orig_path);
287 : 0 : kfree(orig_path);
288 : : }
289 : :
290 : : return err;
291 : :
292 : : }
293 : :
294 : : /**
295 : : * mext_insert_inside_block - Insert new extent to the extent block
296 : : *
297 : : * @o_start: first original extent to be moved
298 : : * @o_end: last original extent to be moved
299 : : * @start_ext: first new extent to be inserted
300 : : * @new_ext: middle of new extent to be inserted
301 : : * @end_ext: last new extent to be inserted
302 : : * @eh: extent header of target leaf block
303 : : * @range_to_move: used to decide how to insert extent
304 : : *
305 : : * Insert extents into the leaf block. The extent (@o_start) is overwritten
306 : : * by inserted extents.
307 : : */
308 : : static void
309 : 0 : mext_insert_inside_block(struct ext4_extent *o_start,
310 : : struct ext4_extent *o_end,
311 : : struct ext4_extent *start_ext,
312 : 0 : struct ext4_extent *new_ext,
313 : : struct ext4_extent *end_ext,
314 : : struct ext4_extent_header *eh,
315 : : int range_to_move)
316 : : {
317 : : int i = 0;
318 : : unsigned long len;
319 : :
320 : : /* Move the existing extents */
321 [ # # ][ # # ]: 0 : if (range_to_move && o_end < EXT_LAST_EXTENT(eh)) {
322 : 0 : len = (unsigned long)(EXT_LAST_EXTENT(eh) + 1) -
323 : : (unsigned long)(o_end + 1);
324 : 0 : memmove(o_end + 1 + range_to_move, o_end + 1, len);
325 : : }
326 : :
327 : : /* Insert start entry */
328 [ # # ]: 0 : if (start_ext->ee_len)
329 : 0 : o_start[i++].ee_len = start_ext->ee_len;
330 : :
331 : : /* Insert new entry */
332 [ # # ]: 0 : if (new_ext->ee_len) {
333 : 0 : o_start[i] = *new_ext;
334 : 0 : ext4_ext_store_pblock(&o_start[i++], ext4_ext_pblock(new_ext));
335 : : }
336 : :
337 : : /* Insert end entry */
338 [ # # ]: 0 : if (end_ext->ee_len)
339 : 0 : o_start[i] = *end_ext;
340 : :
341 : : /* Increment the total entries counter on the extent block */
342 : 0 : le16_add_cpu(&eh->eh_entries, range_to_move);
343 : 0 : }
344 : :
345 : : /**
346 : : * mext_insert_extents - Insert new extent
347 : : *
348 : : * @handle: journal handle
349 : : * @orig_inode: original inode
350 : : * @orig_path: path indicates first extent to be changed
351 : : * @o_start: first original extent to be changed
352 : : * @o_end: last original extent to be changed
353 : : * @start_ext: first new extent to be inserted
354 : : * @new_ext: middle of new extent to be inserted
355 : : * @end_ext: last new extent to be inserted
356 : : *
357 : : * Call the function to insert extents. If we cannot add more extents into
358 : : * the leaf block, we call mext_insert_across_blocks() to create a
359 : : * new leaf block. Otherwise call mext_insert_inside_block(). Return 0
360 : : * on success, or a negative error value on failure.
361 : : */
362 : : static int
363 : 0 : mext_insert_extents(handle_t *handle, struct inode *orig_inode,
364 : : struct ext4_ext_path *orig_path,
365 : : struct ext4_extent *o_start,
366 : : struct ext4_extent *o_end,
367 : : struct ext4_extent *start_ext,
368 : : struct ext4_extent *new_ext,
369 : : struct ext4_extent *end_ext)
370 : : {
371 : : struct ext4_extent_header *eh;
372 : : unsigned long need_slots, slots_range;
373 : : int range_to_move, depth, ret;
374 : :
375 : : /*
376 : : * The extents need to be inserted
377 : : * start_extent + new_extent + end_extent.
378 : : */
379 : 0 : need_slots = (start_ext->ee_len ? 1 : 0) + (end_ext->ee_len ? 1 : 0) +
380 : 0 : (new_ext->ee_len ? 1 : 0);
381 : :
382 : : /* The number of slots between start and end */
383 : 0 : slots_range = ((unsigned long)(o_end + 1) - (unsigned long)o_start + 1)
384 : : / sizeof(struct ext4_extent);
385 : :
386 : : /* Range to move the end of extent */
387 : 0 : range_to_move = need_slots - slots_range;
388 : 0 : depth = orig_path->p_depth;
389 : 0 : orig_path += depth;
390 : 0 : eh = orig_path->p_hdr;
391 : :
392 [ # # ]: 0 : if (depth) {
393 : : /* Register to journal */
394 : 0 : ret = ext4_journal_get_write_access(handle, orig_path->p_bh);
395 [ # # ]: 0 : if (ret)
396 : : return ret;
397 : : }
398 : :
399 : : /* Expansion */
400 [ # # ][ # # ]: 0 : if (range_to_move > 0 &&
401 : 0 : (range_to_move > le16_to_cpu(eh->eh_max)
402 : 0 : - le16_to_cpu(eh->eh_entries))) {
403 : :
404 : 0 : ret = mext_insert_across_blocks(handle, orig_inode, o_start,
405 : : o_end, start_ext, new_ext, end_ext);
406 [ # # ]: 0 : if (ret < 0)
407 : : return ret;
408 : : } else
409 : 0 : mext_insert_inside_block(o_start, o_end, start_ext, new_ext,
410 : : end_ext, eh, range_to_move);
411 : :
412 : 0 : return ext4_ext_dirty(handle, orig_inode, orig_path);
413 : : }
414 : :
415 : : /**
416 : : * mext_leaf_block - Move one leaf extent block into the inode.
417 : : *
418 : : * @handle: journal handle
419 : : * @orig_inode: original inode
420 : : * @orig_path: path indicates first extent to be changed
421 : : * @dext: donor extent
422 : : * @from: start offset on the target file
423 : : *
424 : : * In order to insert extents into the leaf block, we must divide the extent
425 : : * in the leaf block into three extents. The one is located to be inserted
426 : : * extents, and the others are located around it.
427 : : *
428 : : * Therefore, this function creates structures to save extents of the leaf
429 : : * block, and inserts extents by calling mext_insert_extents() with
430 : : * created extents. Return 0 on success, or a negative error value on failure.
431 : : */
432 : : static int
433 : 0 : mext_leaf_block(handle_t *handle, struct inode *orig_inode,
434 : 0 : struct ext4_ext_path *orig_path, struct ext4_extent *dext,
435 : : ext4_lblk_t *from)
436 : : {
437 : 0 : struct ext4_extent *oext, *o_start, *o_end, *prev_ext;
438 : : struct ext4_extent new_ext, start_ext, end_ext;
439 : : ext4_lblk_t new_ext_end;
440 : : int oext_alen, new_ext_alen, end_ext_alen;
441 : : int depth = ext_depth(orig_inode);
442 : : int ret;
443 : :
444 : 0 : start_ext.ee_block = end_ext.ee_block = 0;
445 : 0 : o_start = o_end = oext = orig_path[depth].p_ext;
446 : : oext_alen = ext4_ext_get_actual_len(oext);
447 : 0 : start_ext.ee_len = end_ext.ee_len = 0;
448 : :
449 : 0 : new_ext.ee_block = cpu_to_le32(*from);
450 : : ext4_ext_store_pblock(&new_ext, ext4_ext_pblock(dext));
451 : 0 : new_ext.ee_len = dext->ee_len;
452 : : new_ext_alen = ext4_ext_get_actual_len(&new_ext);
453 : 0 : new_ext_end = le32_to_cpu(new_ext.ee_block) + new_ext_alen - 1;
454 : :
455 : : /*
456 : : * Case: original extent is first
457 : : * oext |--------|
458 : : * new_ext |--|
459 : : * start_ext |--|
460 : : */
461 [ # # ][ # # ]: 0 : if (le32_to_cpu(oext->ee_block) < le32_to_cpu(new_ext.ee_block) &&
462 : : le32_to_cpu(new_ext.ee_block) <
463 : 0 : le32_to_cpu(oext->ee_block) + oext_alen) {
464 : 0 : start_ext.ee_len = cpu_to_le16(le32_to_cpu(new_ext.ee_block) -
465 : : le32_to_cpu(oext->ee_block));
466 : 0 : start_ext.ee_block = oext->ee_block;
467 : 0 : copy_extent_status(oext, &start_ext);
468 [ # # ]: 0 : } else if (oext > EXT_FIRST_EXTENT(orig_path[depth].p_hdr)) {
469 : 0 : prev_ext = oext - 1;
470 : : /*
471 : : * We can merge new_ext into previous extent,
472 : : * if these are contiguous and same extent type.
473 : : */
474 [ # # ]: 0 : if (ext4_can_extents_be_merged(orig_inode, prev_ext,
475 : : &new_ext)) {
476 : : o_start = prev_ext;
477 : 0 : start_ext.ee_len = cpu_to_le16(
478 : : ext4_ext_get_actual_len(prev_ext) +
479 : : new_ext_alen);
480 : 0 : start_ext.ee_block = oext->ee_block;
481 : 0 : copy_extent_status(prev_ext, &start_ext);
482 : 0 : new_ext.ee_len = 0;
483 : : }
484 : : }
485 : :
486 : : /*
487 : : * Case: new_ext_end must be less than oext
488 : : * oext |-----------|
489 : : * new_ext |-------|
490 : : */
491 [ # # ]: 0 : if (le32_to_cpu(oext->ee_block) + oext_alen - 1 < new_ext_end) {
492 : 0 : EXT4_ERROR_INODE(orig_inode,
493 : : "new_ext_end(%u) should be less than or equal to "
494 : : "oext->ee_block(%u) + oext_alen(%d) - 1",
495 : : new_ext_end, le32_to_cpu(oext->ee_block),
496 : : oext_alen);
497 : : ret = -EIO;
498 : : goto out;
499 : : }
500 : :
501 : : /*
502 : : * Case: new_ext is smaller than original extent
503 : : * oext |---------------|
504 : : * new_ext |-----------|
505 : : * end_ext |---|
506 : : */
507 [ # # ][ # # ]: 0 : if (le32_to_cpu(oext->ee_block) <= new_ext_end &&
508 : : new_ext_end < le32_to_cpu(oext->ee_block) + oext_alen - 1) {
509 : 0 : end_ext.ee_len =
510 : 0 : cpu_to_le16(le32_to_cpu(oext->ee_block) +
511 : : oext_alen - 1 - new_ext_end);
512 : 0 : copy_extent_status(oext, &end_ext);
513 : 0 : end_ext_alen = ext4_ext_get_actual_len(&end_ext);
514 : 0 : ext4_ext_store_pblock(&end_ext,
515 : 0 : (ext4_ext_pblock(o_end) + oext_alen - end_ext_alen));
516 : 0 : end_ext.ee_block =
517 : 0 : cpu_to_le32(le32_to_cpu(o_end->ee_block) +
518 : : oext_alen - end_ext_alen);
519 : : }
520 : :
521 : 0 : ret = mext_insert_extents(handle, orig_inode, orig_path, o_start,
522 : : o_end, &start_ext, &new_ext, &end_ext);
523 : : out:
524 : 0 : return ret;
525 : : }
526 : :
527 : : /**
528 : : * mext_calc_swap_extents - Calculate extents for extent swapping.
529 : : *
530 : : * @tmp_dext: the extent that will belong to the original inode
531 : : * @tmp_oext: the extent that will belong to the donor inode
532 : : * @orig_off: block offset of original inode
533 : : * @donor_off: block offset of donor inode
534 : : * @max_count: the maximum length of extents
535 : : *
536 : : * Return 0 on success, or a negative error value on failure.
537 : : */
538 : : static int
539 : 0 : mext_calc_swap_extents(struct ext4_extent *tmp_dext,
540 : 0 : struct ext4_extent *tmp_oext,
541 : : ext4_lblk_t orig_off, ext4_lblk_t donor_off,
542 : : ext4_lblk_t max_count)
543 : : {
544 : : ext4_lblk_t diff, orig_diff;
545 : : struct ext4_extent dext_old, oext_old;
546 : :
547 [ # # ]: 0 : BUG_ON(orig_off != donor_off);
548 : :
549 : : /* original and donor extents have to cover the same block offset */
550 [ # # ][ # # ]: 0 : if (orig_off < le32_to_cpu(tmp_oext->ee_block) ||
551 : 0 : le32_to_cpu(tmp_oext->ee_block) +
552 : 0 : ext4_ext_get_actual_len(tmp_oext) - 1 < orig_off)
553 : : return -ENODATA;
554 : :
555 [ # # ][ # # ]: 0 : if (orig_off < le32_to_cpu(tmp_dext->ee_block) ||
556 : 0 : le32_to_cpu(tmp_dext->ee_block) +
557 : 0 : ext4_ext_get_actual_len(tmp_dext) - 1 < orig_off)
558 : : return -ENODATA;
559 : :
560 : 0 : dext_old = *tmp_dext;
561 : 0 : oext_old = *tmp_oext;
562 : :
563 : : /* When tmp_dext is too large, pick up the target range. */
564 : 0 : diff = donor_off - le32_to_cpu(tmp_dext->ee_block);
565 : :
566 : 0 : ext4_ext_store_pblock(tmp_dext, ext4_ext_pblock(tmp_dext) + diff);
567 : : le32_add_cpu(&tmp_dext->ee_block, diff);
568 : 0 : le16_add_cpu(&tmp_dext->ee_len, -diff);
569 : :
570 [ # # ]: 0 : if (max_count < ext4_ext_get_actual_len(tmp_dext))
571 : 0 : tmp_dext->ee_len = cpu_to_le16(max_count);
572 : :
573 : 0 : orig_diff = orig_off - le32_to_cpu(tmp_oext->ee_block);
574 : 0 : ext4_ext_store_pblock(tmp_oext, ext4_ext_pblock(tmp_oext) + orig_diff);
575 : :
576 : : /* Adjust extent length if donor extent is larger than orig */
577 [ # # ]: 0 : if (ext4_ext_get_actual_len(tmp_dext) >
578 : 0 : ext4_ext_get_actual_len(tmp_oext) - orig_diff)
579 : 0 : tmp_dext->ee_len = cpu_to_le16(le16_to_cpu(tmp_oext->ee_len) -
580 : : orig_diff);
581 : :
582 : 0 : tmp_oext->ee_len = cpu_to_le16(ext4_ext_get_actual_len(tmp_dext));
583 : :
584 : 0 : copy_extent_status(&oext_old, tmp_dext);
585 : 0 : copy_extent_status(&dext_old, tmp_oext);
586 : :
587 : 0 : return 0;
588 : : }
589 : :
590 : : /**
591 : : * mext_check_coverage - Check that all extents in range has the same type
592 : : *
593 : : * @inode: inode in question
594 : : * @from: block offset of inode
595 : : * @count: block count to be checked
596 : : * @uninit: extents expected to be uninitialized
597 : : * @err: pointer to save error value
598 : : *
599 : : * Return 1 if all extents in range has expected type, and zero otherwise.
600 : : */
601 : : static int
602 : 0 : mext_check_coverage(struct inode *inode, ext4_lblk_t from, ext4_lblk_t count,
603 : : int uninit, int *err)
604 : : {
605 : : struct ext4_ext_path *path = NULL;
606 : 0 : struct ext4_extent *ext;
607 : : int ret = 0;
608 : 0 : ext4_lblk_t last = from + count;
609 [ # # ]: 0 : while (from < last) {
610 : 0 : *err = get_ext_path(inode, from, &path);
611 [ # # ]: 0 : if (*err)
612 : : goto out;
613 : 0 : ext = path[ext_depth(inode)].p_ext;
614 [ # # ]: 0 : if (uninit != ext4_ext_is_uninitialized(ext))
615 : : goto out;
616 : 0 : from += ext4_ext_get_actual_len(ext);
617 : 0 : ext4_ext_drop_refs(path);
618 : : }
619 : : ret = 1;
620 : : out:
621 [ # # ]: 0 : if (path) {
622 : 0 : ext4_ext_drop_refs(path);
623 : 0 : kfree(path);
624 : : }
625 : 0 : return ret;
626 : : }
627 : :
628 : : /**
629 : : * mext_replace_branches - Replace original extents with new extents
630 : : *
631 : : * @handle: journal handle
632 : : * @orig_inode: original inode
633 : : * @donor_inode: donor inode
634 : : * @from: block offset of orig_inode
635 : : * @count: block count to be replaced
636 : : * @err: pointer to save return value
637 : : *
638 : : * Replace original inode extents and donor inode extents page by page.
639 : : * We implement this replacement in the following three steps:
640 : : * 1. Save the block information of original and donor inodes into
641 : : * dummy extents.
642 : : * 2. Change the block information of original inode to point at the
643 : : * donor inode blocks.
644 : : * 3. Change the block information of donor inode to point at the saved
645 : : * original inode blocks in the dummy extents.
646 : : *
647 : : * Return replaced block count.
648 : : */
649 : : static int
650 : 0 : mext_replace_branches(handle_t *handle, struct inode *orig_inode,
651 : : struct inode *donor_inode, ext4_lblk_t from,
652 : : ext4_lblk_t count, int *err)
653 : : {
654 : : struct ext4_ext_path *orig_path = NULL;
655 : : struct ext4_ext_path *donor_path = NULL;
656 : : struct ext4_extent *oext, *dext;
657 : : struct ext4_extent tmp_dext, tmp_oext;
658 : : ext4_lblk_t orig_off = from, donor_off = from;
659 : : int depth;
660 : : int replaced_count = 0;
661 : : int dext_alen;
662 : :
663 : 0 : *err = ext4_es_remove_extent(orig_inode, from, count);
664 [ # # ]: 0 : if (*err)
665 : : goto out;
666 : :
667 : 0 : *err = ext4_es_remove_extent(donor_inode, from, count);
668 [ # # ]: 0 : if (*err)
669 : : goto out;
670 : :
671 : : /* Get the original extent for the block "orig_off" */
672 : 0 : *err = get_ext_path(orig_inode, orig_off, &orig_path);
673 [ # # ]: 0 : if (*err)
674 : : goto out;
675 : :
676 : : /* Get the donor extent for the head */
677 : 0 : *err = get_ext_path(donor_inode, donor_off, &donor_path);
678 [ # # ]: 0 : if (*err)
679 : : goto out;
680 : : depth = ext_depth(orig_inode);
681 : 0 : oext = orig_path[depth].p_ext;
682 : 0 : tmp_oext = *oext;
683 : :
684 : : depth = ext_depth(donor_inode);
685 : 0 : dext = donor_path[depth].p_ext;
686 [ # # ]: 0 : if (unlikely(!dext))
687 : : goto missing_donor_extent;
688 : 0 : tmp_dext = *dext;
689 : :
690 : 0 : *err = mext_calc_swap_extents(&tmp_dext, &tmp_oext, orig_off,
691 : : donor_off, count);
692 [ # # ]: 0 : if (*err)
693 : : goto out;
694 : :
695 : : /* Loop for the donor extents */
696 : : while (1) {
697 : : /* The extent for donor must be found. */
698 [ # # ]: 0 : if (unlikely(!dext)) {
699 : : missing_donor_extent:
700 : 0 : EXT4_ERROR_INODE(donor_inode,
701 : : "The extent for donor must be found");
702 : 0 : *err = -EIO;
703 : 0 : goto out;
704 [ # # ]: 0 : } else if (donor_off != le32_to_cpu(tmp_dext.ee_block)) {
705 : 0 : EXT4_ERROR_INODE(donor_inode,
706 : : "Donor offset(%u) and the first block of donor "
707 : : "extent(%u) should be equal",
708 : : donor_off,
709 : : le32_to_cpu(tmp_dext.ee_block));
710 : 0 : *err = -EIO;
711 : 0 : goto out;
712 : : }
713 : :
714 : : /* Set donor extent to orig extent */
715 : 0 : *err = mext_leaf_block(handle, orig_inode,
716 : : orig_path, &tmp_dext, &orig_off);
717 [ # # ]: 0 : if (*err)
718 : : goto out;
719 : :
720 : : /* Set orig extent to donor extent */
721 : 0 : *err = mext_leaf_block(handle, donor_inode,
722 : : donor_path, &tmp_oext, &donor_off);
723 [ # # ]: 0 : if (*err)
724 : : goto out;
725 : :
726 : 0 : dext_alen = ext4_ext_get_actual_len(&tmp_dext);
727 : 0 : replaced_count += dext_alen;
728 : 0 : donor_off += dext_alen;
729 : : orig_off += dext_alen;
730 : :
731 [ # # ]: 0 : BUG_ON(replaced_count > count);
732 : : /* Already moved the expected blocks */
733 [ # # ]: 0 : if (replaced_count >= count)
734 : : break;
735 : :
736 [ # # ]: 0 : if (orig_path)
737 : 0 : ext4_ext_drop_refs(orig_path);
738 : 0 : *err = get_ext_path(orig_inode, orig_off, &orig_path);
739 [ # # ]: 0 : if (*err)
740 : : goto out;
741 : : depth = ext_depth(orig_inode);
742 : 0 : oext = orig_path[depth].p_ext;
743 : 0 : tmp_oext = *oext;
744 : :
745 [ # # ]: 0 : if (donor_path)
746 : 0 : ext4_ext_drop_refs(donor_path);
747 : 0 : *err = get_ext_path(donor_inode, donor_off, &donor_path);
748 [ # # ]: 0 : if (*err)
749 : : goto out;
750 : : depth = ext_depth(donor_inode);
751 : 0 : dext = donor_path[depth].p_ext;
752 : 0 : tmp_dext = *dext;
753 : :
754 : 0 : *err = mext_calc_swap_extents(&tmp_dext, &tmp_oext, orig_off,
755 : : donor_off, count - replaced_count);
756 [ # # ]: 0 : if (*err)
757 : : goto out;
758 : : }
759 : :
760 : : out:
761 [ # # ]: 0 : if (orig_path) {
762 : 0 : ext4_ext_drop_refs(orig_path);
763 : 0 : kfree(orig_path);
764 : : }
765 [ # # ]: 0 : if (donor_path) {
766 : 0 : ext4_ext_drop_refs(donor_path);
767 : 0 : kfree(donor_path);
768 : : }
769 : :
770 : 0 : return replaced_count;
771 : : }
772 : :
773 : : /**
774 : : * mext_page_double_lock - Grab and lock pages on both @inode1 and @inode2
775 : : *
776 : : * @inode1: the inode structure
777 : : * @inode2: the inode structure
778 : : * @index: page index
779 : : * @page: result page vector
780 : : *
781 : : * Grab two locked pages for inode's by inode order
782 : : */
783 : : static int
784 : 0 : mext_page_double_lock(struct inode *inode1, struct inode *inode2,
785 : : pgoff_t index, struct page *page[2])
786 : : {
787 : : struct address_space *mapping[2];
788 : : unsigned fl = AOP_FLAG_NOFS;
789 : :
790 [ # # ]: 0 : BUG_ON(!inode1 || !inode2);
791 [ # # ]: 0 : if (inode1 < inode2) {
792 : 0 : mapping[0] = inode1->i_mapping;
793 : 0 : mapping[1] = inode2->i_mapping;
794 : : } else {
795 : 0 : mapping[0] = inode2->i_mapping;
796 : 0 : mapping[1] = inode1->i_mapping;
797 : : }
798 : :
799 : 0 : page[0] = grab_cache_page_write_begin(mapping[0], index, fl);
800 [ # # ]: 0 : if (!page[0])
801 : : return -ENOMEM;
802 : :
803 : 0 : page[1] = grab_cache_page_write_begin(mapping[1], index, fl);
804 [ # # ]: 0 : if (!page[1]) {
805 : 0 : unlock_page(page[0]);
806 : 0 : page_cache_release(page[0]);
807 : 0 : return -ENOMEM;
808 : : }
809 : : /*
810 : : * grab_cache_page_write_begin() may not wait on page's writeback if
811 : : * BDI not demand that. But it is reasonable to be very conservative
812 : : * here and explicitly wait on page's writeback
813 : : */
814 : 0 : wait_on_page_writeback(page[0]);
815 : 0 : wait_on_page_writeback(page[1]);
816 [ # # ]: 0 : if (inode1 > inode2) {
817 : : struct page *tmp;
818 : 0 : tmp = page[0];
819 : 0 : page[0] = page[1];
820 : 0 : page[1] = tmp;
821 : : }
822 : : return 0;
823 : : }
824 : :
825 : : /* Force page buffers uptodate w/o dropping page's lock */
826 : : static int
827 : 0 : mext_page_mkuptodate(struct page *page, unsigned from, unsigned to)
828 : : {
829 : 0 : struct inode *inode = page->mapping->host;
830 : : sector_t block;
831 : : struct buffer_head *bh, *head, *arr[MAX_BUF_PER_PAGE];
832 : : unsigned int blocksize, block_start, block_end;
833 : : int i, err, nr = 0, partial = 0;
834 [ # # ]: 0 : BUG_ON(!PageLocked(page));
835 [ # # ]: 0 : BUG_ON(PageWriteback(page));
836 : :
837 [ # # ]: 0 : if (PageUptodate(page))
838 : : return 0;
839 : :
840 : 0 : blocksize = 1 << inode->i_blkbits;
841 [ # # ]: 0 : if (!page_has_buffers(page))
842 : 0 : create_empty_buffers(page, blocksize, 0);
843 : :
844 [ # # ]: 0 : head = page_buffers(page);
845 : 0 : block = (sector_t)page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
846 [ # # ]: 0 : for (bh = head, block_start = 0; bh != head || !block_start;
847 : 0 : block++, block_start = block_end, bh = bh->b_this_page) {
848 : 0 : block_end = block_start + blocksize;
849 [ # # ]: 0 : if (block_end <= from || block_start >= to) {
850 [ # # ]: 0 : if (!buffer_uptodate(bh))
851 : : partial = 1;
852 : 0 : continue;
853 : : }
854 [ # # ]: 0 : if (buffer_uptodate(bh))
855 : 0 : continue;
856 [ # # ]: 0 : if (!buffer_mapped(bh)) {
857 : 0 : err = ext4_get_block(inode, block, bh, 0);
858 [ # # ]: 0 : if (err) {
859 : : SetPageError(page);
860 : 0 : return err;
861 : : }
862 [ # # ]: 0 : if (!buffer_mapped(bh)) {
863 : : zero_user(page, block_start, blocksize);
864 [ # # ]: 0 : if (!err)
865 : : set_buffer_uptodate(bh);
866 : 0 : continue;
867 : : }
868 : : }
869 [ # # ]: 0 : BUG_ON(nr >= MAX_BUF_PER_PAGE);
870 : 0 : arr[nr++] = bh;
871 : : }
872 : : /* No io required */
873 [ # # ]: 0 : if (!nr)
874 : : goto out;
875 : :
876 [ # # ]: 0 : for (i = 0; i < nr; i++) {
877 : 0 : bh = arr[i];
878 [ # # ]: 0 : if (!bh_uptodate_or_lock(bh)) {
879 : 0 : err = bh_submit_read(bh);
880 [ # # ]: 0 : if (err)
881 : : return err;
882 : : }
883 : : }
884 : : out:
885 [ # # ]: 0 : if (!partial)
886 : : SetPageUptodate(page);
887 : : return 0;
888 : : }
889 : :
890 : : /**
891 : : * move_extent_per_page - Move extent data per page
892 : : *
893 : : * @o_filp: file structure of original file
894 : : * @donor_inode: donor inode
895 : : * @orig_page_offset: page index on original file
896 : : * @data_offset_in_page: block index where data swapping starts
897 : : * @block_len_in_page: the number of blocks to be swapped
898 : : * @uninit: orig extent is uninitialized or not
899 : : * @err: pointer to save return value
900 : : *
901 : : * Save the data in original inode blocks and replace original inode extents
902 : : * with donor inode extents by calling mext_replace_branches().
903 : : * Finally, write out the saved data in new original inode blocks. Return
904 : : * replaced block count.
905 : : */
906 : : static int
907 : 0 : move_extent_per_page(struct file *o_filp, struct inode *donor_inode,
908 : : pgoff_t orig_page_offset, int data_offset_in_page,
909 : : int block_len_in_page, int uninit, int *err)
910 : : {
911 : 0 : struct inode *orig_inode = file_inode(o_filp);
912 : 0 : struct page *pagep[2] = {NULL, NULL};
913 : : handle_t *handle;
914 : : ext4_lblk_t orig_blk_offset;
915 : 0 : unsigned long blocksize = orig_inode->i_sb->s_blocksize;
916 : : unsigned int w_flags = 0;
917 : : unsigned int tmp_data_size, data_size, replaced_size;
918 : 0 : int err2, jblocks, retries = 0;
919 : : int replaced_count = 0;
920 : 0 : int from = data_offset_in_page << orig_inode->i_blkbits;
921 : 0 : int blocks_per_page = PAGE_CACHE_SIZE >> orig_inode->i_blkbits;
922 : :
923 : : /*
924 : : * It needs twice the amount of ordinary journal buffers because
925 : : * inode and donor_inode may change each different metadata blocks.
926 : : */
927 : : again:
928 : 0 : *err = 0;
929 : 0 : jblocks = ext4_writepage_trans_blocks(orig_inode) * 2;
930 : : handle = ext4_journal_start(orig_inode, EXT4_HT_MOVE_EXTENTS, jblocks);
931 [ # # ]: 0 : if (IS_ERR(handle)) {
932 : 0 : *err = PTR_ERR(handle);
933 : 0 : return 0;
934 : : }
935 : :
936 : : if (segment_eq(get_fs(), KERNEL_DS))
937 : : w_flags |= AOP_FLAG_UNINTERRUPTIBLE;
938 : :
939 : 0 : orig_blk_offset = orig_page_offset * blocks_per_page +
940 : : data_offset_in_page;
941 : :
942 : : /* Calculate data_size */
943 [ # # ]: 0 : if ((orig_blk_offset + block_len_in_page - 1) ==
944 : 0 : ((orig_inode->i_size - 1) >> orig_inode->i_blkbits)) {
945 : : /* Replace the last block */
946 : 0 : tmp_data_size = orig_inode->i_size & (blocksize - 1);
947 : : /*
948 : : * If data_size equal zero, it shows data_size is multiples of
949 : : * blocksize. So we set appropriate value.
950 : : */
951 [ # # ]: 0 : if (tmp_data_size == 0)
952 : : tmp_data_size = blocksize;
953 : :
954 : 0 : data_size = tmp_data_size +
955 : 0 : ((block_len_in_page - 1) << orig_inode->i_blkbits);
956 : : } else
957 : 0 : data_size = block_len_in_page << orig_inode->i_blkbits;
958 : :
959 : : replaced_size = data_size;
960 : :
961 : 0 : *err = mext_page_double_lock(orig_inode, donor_inode, orig_page_offset,
962 : : pagep);
963 [ # # ]: 0 : if (unlikely(*err < 0))
964 : : goto stop_journal;
965 : : /*
966 : : * If orig extent was uninitialized it can become initialized
967 : : * at any time after i_data_sem was dropped, in order to
968 : : * serialize with delalloc we have recheck extent while we
969 : : * hold page's lock, if it is still the case data copy is not
970 : : * necessary, just swap data blocks between orig and donor.
971 : : */
972 [ # # ]: 0 : if (uninit) {
973 : 0 : ext4_double_down_write_data_sem(orig_inode, donor_inode);
974 : : /* If any of extents in range became initialized we have to
975 : : * fallback to data copying */
976 : 0 : uninit = mext_check_coverage(orig_inode, orig_blk_offset,
977 : : block_len_in_page, 1, err);
978 [ # # ]: 0 : if (*err)
979 : : goto drop_data_sem;
980 : :
981 : 0 : uninit &= mext_check_coverage(donor_inode, orig_blk_offset,
982 : : block_len_in_page, 1, err);
983 [ # # ]: 0 : if (*err)
984 : : goto drop_data_sem;
985 : :
986 [ # # ]: 0 : if (!uninit) {
987 : : ext4_double_up_write_data_sem(orig_inode, donor_inode);
988 : : goto data_copy;
989 : : }
990 [ # # # # ]: 0 : if ((page_has_private(pagep[0]) &&
991 [ # # ]: 0 : !try_to_release_page(pagep[0], 0)) ||
992 [ # # ]: 0 : (page_has_private(pagep[1]) &&
993 : 0 : !try_to_release_page(pagep[1], 0))) {
994 : 0 : *err = -EBUSY;
995 : 0 : goto drop_data_sem;
996 : : }
997 : 0 : replaced_count = mext_replace_branches(handle, orig_inode,
998 : : donor_inode, orig_blk_offset,
999 : : block_len_in_page, err);
1000 : : drop_data_sem:
1001 : : ext4_double_up_write_data_sem(orig_inode, donor_inode);
1002 : : goto unlock_pages;
1003 : : }
1004 : : data_copy:
1005 : 0 : *err = mext_page_mkuptodate(pagep[0], from, from + replaced_size);
1006 [ # # ]: 0 : if (*err)
1007 : : goto unlock_pages;
1008 : :
1009 : : /* At this point all buffers in range are uptodate, old mapping layout
1010 : : * is no longer required, try to drop it now. */
1011 [ # # ][ # # ]: 0 : if ((page_has_private(pagep[0]) && !try_to_release_page(pagep[0], 0)) ||
[ # # ]
1012 [ # # ]: 0 : (page_has_private(pagep[1]) && !try_to_release_page(pagep[1], 0))) {
1013 : 0 : *err = -EBUSY;
1014 : 0 : goto unlock_pages;
1015 : : }
1016 : :
1017 : 0 : replaced_count = mext_replace_branches(handle, orig_inode, donor_inode,
1018 : : orig_blk_offset,
1019 : : block_len_in_page, err);
1020 [ # # ]: 0 : if (*err) {
1021 [ # # ]: 0 : if (replaced_count) {
1022 : : block_len_in_page = replaced_count;
1023 : 0 : replaced_size =
1024 : 0 : block_len_in_page << orig_inode->i_blkbits;
1025 : : } else
1026 : : goto unlock_pages;
1027 : : }
1028 : : /* Perform all necessary steps similar write_begin()/write_end()
1029 : : * but keeping in mind that i_size will not change */
1030 : 0 : *err = __block_write_begin(pagep[0], from, replaced_size,
1031 : : ext4_get_block);
1032 [ # # ]: 0 : if (!*err)
1033 : 0 : *err = block_commit_write(pagep[0], from, from + replaced_size);
1034 : :
1035 [ # # ]: 0 : if (unlikely(*err < 0))
1036 : : goto repair_branches;
1037 : :
1038 : : /* Even in case of data=writeback it is reasonable to pin
1039 : : * inode to transaction, to prevent unexpected data loss */
1040 : 0 : *err = ext4_jbd2_file_inode(handle, orig_inode);
1041 : :
1042 : : unlock_pages:
1043 : 0 : unlock_page(pagep[0]);
1044 : 0 : page_cache_release(pagep[0]);
1045 : 0 : unlock_page(pagep[1]);
1046 : 0 : page_cache_release(pagep[1]);
1047 : : stop_journal:
1048 : 0 : ext4_journal_stop(handle);
1049 : : /* Buffer was busy because probably is pinned to journal transaction,
1050 : : * force transaction commit may help to free it. */
1051 [ # # ][ # # ]: 0 : if (*err == -EBUSY && ext4_should_retry_alloc(orig_inode->i_sb,
1052 : : &retries))
1053 : : goto again;
1054 : 0 : return replaced_count;
1055 : :
1056 : : repair_branches:
1057 : : /*
1058 : : * This should never ever happen!
1059 : : * Extents are swapped already, but we are not able to copy data.
1060 : : * Try to swap extents to it's original places
1061 : : */
1062 : 0 : ext4_double_down_write_data_sem(orig_inode, donor_inode);
1063 : 0 : replaced_count = mext_replace_branches(handle, donor_inode, orig_inode,
1064 : : orig_blk_offset,
1065 : : block_len_in_page, &err2);
1066 : : ext4_double_up_write_data_sem(orig_inode, donor_inode);
1067 [ # # ]: 0 : if (replaced_count != block_len_in_page) {
1068 : 0 : EXT4_ERROR_INODE_BLOCK(orig_inode, (sector_t)(orig_blk_offset),
1069 : : "Unable to copy data block,"
1070 : : " data will be lost.");
1071 : 0 : *err = -EIO;
1072 : : }
1073 : : replaced_count = 0;
1074 : : goto unlock_pages;
1075 : : }
1076 : :
1077 : : /**
1078 : : * mext_check_arguments - Check whether move extent can be done
1079 : : *
1080 : : * @orig_inode: original inode
1081 : : * @donor_inode: donor inode
1082 : : * @orig_start: logical start offset in block for orig
1083 : : * @donor_start: logical start offset in block for donor
1084 : : * @len: the number of blocks to be moved
1085 : : *
1086 : : * Check the arguments of ext4_move_extents() whether the files can be
1087 : : * exchanged with each other.
1088 : : * Return 0 on success, or a negative error value on failure.
1089 : : */
1090 : : static int
1091 : 0 : mext_check_arguments(struct inode *orig_inode,
1092 : : struct inode *donor_inode, __u64 orig_start,
1093 : : __u64 donor_start, __u64 *len)
1094 : : {
1095 : : ext4_lblk_t orig_blocks, donor_blocks;
1096 : 0 : unsigned int blkbits = orig_inode->i_blkbits;
1097 : 0 : unsigned int blocksize = 1 << blkbits;
1098 : :
1099 [ # # ]: 0 : if (donor_inode->i_mode & (S_ISUID|S_ISGID)) {
1100 : : ext4_debug("ext4 move extent: suid or sgid is set"
1101 : : " to donor file [ino:orig %lu, donor %lu]\n",
1102 : : orig_inode->i_ino, donor_inode->i_ino);
1103 : : return -EINVAL;
1104 : : }
1105 : :
1106 [ # # ]: 0 : if (IS_IMMUTABLE(donor_inode) || IS_APPEND(donor_inode))
1107 : : return -EPERM;
1108 : :
1109 : : /* Ext4 move extent does not support swapfile */
1110 [ # # ][ # # ]: 0 : if (IS_SWAPFILE(orig_inode) || IS_SWAPFILE(donor_inode)) {
1111 : : ext4_debug("ext4 move extent: The argument files should "
1112 : : "not be swapfile [ino:orig %lu, donor %lu]\n",
1113 : : orig_inode->i_ino, donor_inode->i_ino);
1114 : : return -EINVAL;
1115 : : }
1116 : :
1117 : : /* Ext4 move extent supports only extent based file */
1118 [ # # ]: 0 : if (!(ext4_test_inode_flag(orig_inode, EXT4_INODE_EXTENTS))) {
1119 : : ext4_debug("ext4 move extent: orig file is not extents "
1120 : : "based file [ino:orig %lu]\n", orig_inode->i_ino);
1121 : : return -EOPNOTSUPP;
1122 [ # # ]: 0 : } else if (!(ext4_test_inode_flag(donor_inode, EXT4_INODE_EXTENTS))) {
1123 : : ext4_debug("ext4 move extent: donor file is not extents "
1124 : : "based file [ino:donor %lu]\n", donor_inode->i_ino);
1125 : : return -EOPNOTSUPP;
1126 : : }
1127 : :
1128 [ # # ][ # # ]: 0 : if ((!orig_inode->i_size) || (!donor_inode->i_size)) {
1129 : : ext4_debug("ext4 move extent: File size is 0 byte\n");
1130 : : return -EINVAL;
1131 : : }
1132 : :
1133 : : /* Start offset should be same */
1134 [ # # ]: 0 : if (orig_start != donor_start) {
1135 : : ext4_debug("ext4 move extent: orig and donor's start "
1136 : : "offset are not same [ino:orig %lu, donor %lu]\n",
1137 : : orig_inode->i_ino, donor_inode->i_ino);
1138 : : return -EINVAL;
1139 : : }
1140 : :
1141 [ # # ][ # # ]: 0 : if ((orig_start >= EXT_MAX_BLOCKS) ||
1142 [ # # ]: 0 : (*len > EXT_MAX_BLOCKS) ||
1143 : 0 : (orig_start + *len >= EXT_MAX_BLOCKS)) {
1144 : : ext4_debug("ext4 move extent: Can't handle over [%u] blocks "
1145 : : "[ino:orig %lu, donor %lu]\n", EXT_MAX_BLOCKS,
1146 : : orig_inode->i_ino, donor_inode->i_ino);
1147 : : return -EINVAL;
1148 : : }
1149 : :
1150 [ # # ]: 0 : if (orig_inode->i_size > donor_inode->i_size) {
1151 : 0 : donor_blocks = (donor_inode->i_size + blocksize - 1) >> blkbits;
1152 : : /* TODO: eliminate this artificial restriction */
1153 [ # # ]: 0 : if (orig_start >= donor_blocks) {
1154 : : ext4_debug("ext4 move extent: orig start offset "
1155 : : "[%llu] should be less than donor file blocks "
1156 : : "[%u] [ino:orig %lu, donor %lu]\n",
1157 : : orig_start, donor_blocks,
1158 : : orig_inode->i_ino, donor_inode->i_ino);
1159 : : return -EINVAL;
1160 : : }
1161 : :
1162 : : /* TODO: eliminate this artificial restriction */
1163 [ # # ]: 0 : if (orig_start + *len > donor_blocks) {
1164 : : ext4_debug("ext4 move extent: End offset [%llu] should "
1165 : : "be less than donor file blocks [%u]."
1166 : : "So adjust length from %llu to %llu "
1167 : : "[ino:orig %lu, donor %lu]\n",
1168 : : orig_start + *len, donor_blocks,
1169 : : *len, donor_blocks - orig_start,
1170 : : orig_inode->i_ino, donor_inode->i_ino);
1171 : 0 : *len = donor_blocks - orig_start;
1172 : : }
1173 : : } else {
1174 : 0 : orig_blocks = (orig_inode->i_size + blocksize - 1) >> blkbits;
1175 [ # # ]: 0 : if (orig_start >= orig_blocks) {
1176 : : ext4_debug("ext4 move extent: start offset [%llu] "
1177 : : "should be less than original file blocks "
1178 : : "[%u] [ino:orig %lu, donor %lu]\n",
1179 : : orig_start, orig_blocks,
1180 : : orig_inode->i_ino, donor_inode->i_ino);
1181 : : return -EINVAL;
1182 : : }
1183 : :
1184 [ # # ]: 0 : if (orig_start + *len > orig_blocks) {
1185 : : ext4_debug("ext4 move extent: Adjust length "
1186 : : "from %llu to %llu. Because it should be "
1187 : : "less than original file blocks "
1188 : : "[ino:orig %lu, donor %lu]\n",
1189 : : *len, orig_blocks - orig_start,
1190 : : orig_inode->i_ino, donor_inode->i_ino);
1191 : 0 : *len = orig_blocks - orig_start;
1192 : : }
1193 : : }
1194 : :
1195 [ # # ]: 0 : if (!*len) {
1196 : : ext4_debug("ext4 move extent: len should not be 0 "
1197 : : "[ino:orig %lu, donor %lu]\n", orig_inode->i_ino,
1198 : : donor_inode->i_ino);
1199 : : return -EINVAL;
1200 : : }
1201 : :
1202 : 0 : return 0;
1203 : : }
1204 : :
1205 : : /**
1206 : : * ext4_move_extents - Exchange the specified range of a file
1207 : : *
1208 : : * @o_filp: file structure of the original file
1209 : : * @d_filp: file structure of the donor file
1210 : : * @orig_start: start offset in block for orig
1211 : : * @donor_start: start offset in block for donor
1212 : : * @len: the number of blocks to be moved
1213 : : * @moved_len: moved block length
1214 : : *
1215 : : * This function returns 0 and moved block length is set in moved_len
1216 : : * if succeed, otherwise returns error value.
1217 : : *
1218 : : * Note: ext4_move_extents() proceeds the following order.
1219 : : * 1:ext4_move_extents() calculates the last block number of moving extent
1220 : : * function by the start block number (orig_start) and the number of blocks
1221 : : * to be moved (len) specified as arguments.
1222 : : * If the {orig, donor}_start points a hole, the extent's start offset
1223 : : * pointed by ext_cur (current extent), holecheck_path, orig_path are set
1224 : : * after hole behind.
1225 : : * 2:Continue step 3 to step 5, until the holecheck_path points to last_extent
1226 : : * or the ext_cur exceeds the block_end which is last logical block number.
1227 : : * 3:To get the length of continues area, call mext_next_extent()
1228 : : * specified with the ext_cur (initial value is holecheck_path) re-cursive,
1229 : : * until find un-continuous extent, the start logical block number exceeds
1230 : : * the block_end or the extent points to the last extent.
1231 : : * 4:Exchange the original inode data with donor inode data
1232 : : * from orig_page_offset to seq_end_page.
1233 : : * The start indexes of data are specified as arguments.
1234 : : * That of the original inode is orig_page_offset,
1235 : : * and the donor inode is also orig_page_offset
1236 : : * (To easily handle blocksize != pagesize case, the offset for the
1237 : : * donor inode is block unit).
1238 : : * 5:Update holecheck_path and orig_path to points a next proceeding extent,
1239 : : * then returns to step 2.
1240 : : * 6:Release holecheck_path, orig_path and set the len to moved_len
1241 : : * which shows the number of moved blocks.
1242 : : * The moved_len is useful for the command to calculate the file offset
1243 : : * for starting next move extent ioctl.
1244 : : * 7:Return 0 on success, or a negative error value on failure.
1245 : : */
1246 : : int
1247 : 0 : ext4_move_extents(struct file *o_filp, struct file *d_filp,
1248 : : __u64 orig_start, __u64 donor_start, __u64 len,
1249 : : __u64 *moved_len)
1250 : : {
1251 : : struct inode *orig_inode = file_inode(o_filp);
1252 : : struct inode *donor_inode = file_inode(d_filp);
1253 : : struct ext4_ext_path *orig_path = NULL, *holecheck_path = NULL;
1254 : 0 : struct ext4_extent *ext_prev, *ext_cur, *ext_dummy;
1255 : 0 : ext4_lblk_t block_start = orig_start;
1256 : : ext4_lblk_t block_end, seq_start, add_blocks, file_end, seq_blocks = 0;
1257 : : ext4_lblk_t rest_blocks;
1258 : : pgoff_t orig_page_offset = 0, seq_end_page;
1259 : : int ret, depth, last_extent = 0;
1260 : 0 : int blocks_per_page = PAGE_CACHE_SIZE >> orig_inode->i_blkbits;
1261 : : int data_offset_in_page;
1262 : : int block_len_in_page;
1263 : : int uninit;
1264 : :
1265 [ # # ]: 0 : if (orig_inode->i_sb != donor_inode->i_sb) {
1266 : : ext4_debug("ext4 move extent: The argument files "
1267 : : "should be in same FS [ino:orig %lu, donor %lu]\n",
1268 : : orig_inode->i_ino, donor_inode->i_ino);
1269 : : return -EINVAL;
1270 : : }
1271 : :
1272 : : /* orig and donor should be different inodes */
1273 [ # # ]: 0 : if (orig_inode == donor_inode) {
1274 : : ext4_debug("ext4 move extent: The argument files should not "
1275 : : "be same inode [ino:orig %lu, donor %lu]\n",
1276 : : orig_inode->i_ino, donor_inode->i_ino);
1277 : : return -EINVAL;
1278 : : }
1279 : :
1280 : : /* Regular file check */
1281 [ # # ][ # # ]: 0 : if (!S_ISREG(orig_inode->i_mode) || !S_ISREG(donor_inode->i_mode)) {
1282 : : ext4_debug("ext4 move extent: The argument files should be "
1283 : : "regular file [ino:orig %lu, donor %lu]\n",
1284 : : orig_inode->i_ino, donor_inode->i_ino);
1285 : : return -EINVAL;
1286 : : }
1287 : : /* TODO: This is non obvious task to swap blocks for inodes with full
1288 : : jornaling enabled */
1289 [ # # ][ # # ]: 0 : if (ext4_should_journal_data(orig_inode) ||
1290 : : ext4_should_journal_data(donor_inode)) {
1291 : : return -EINVAL;
1292 : : }
1293 : : /* Protect orig and donor inodes against a truncate */
1294 : 0 : lock_two_nondirectories(orig_inode, donor_inode);
1295 : :
1296 : : /* Wait for all existing dio workers */
1297 : : ext4_inode_block_unlocked_dio(orig_inode);
1298 : : ext4_inode_block_unlocked_dio(donor_inode);
1299 : 0 : inode_dio_wait(orig_inode);
1300 : 0 : inode_dio_wait(donor_inode);
1301 : :
1302 : : /* Protect extent tree against block allocations via delalloc */
1303 : 0 : ext4_double_down_write_data_sem(orig_inode, donor_inode);
1304 : : /* Check the filesystem environment whether move_extent can be done */
1305 : 0 : ret = mext_check_arguments(orig_inode, donor_inode, orig_start,
1306 : : donor_start, &len);
1307 [ # # ]: 0 : if (ret)
1308 : : goto out;
1309 : :
1310 : 0 : file_end = (i_size_read(orig_inode) - 1) >> orig_inode->i_blkbits;
1311 : 0 : block_end = block_start + len - 1;
1312 [ # # ]: 0 : if (file_end < block_end)
1313 : 0 : len -= block_end - file_end;
1314 : :
1315 : 0 : ret = get_ext_path(orig_inode, block_start, &orig_path);
1316 [ # # ]: 0 : if (ret)
1317 : : goto out;
1318 : :
1319 : : /* Get path structure to check the hole */
1320 : 0 : ret = get_ext_path(orig_inode, block_start, &holecheck_path);
1321 [ # # ]: 0 : if (ret)
1322 : : goto out;
1323 : :
1324 : : depth = ext_depth(orig_inode);
1325 : 0 : ext_cur = holecheck_path[depth].p_ext;
1326 : :
1327 : : /*
1328 : : * Get proper starting location of block replacement if block_start was
1329 : : * within the hole.
1330 : : */
1331 [ # # ]: 0 : if (le32_to_cpu(ext_cur->ee_block) +
1332 : 0 : ext4_ext_get_actual_len(ext_cur) - 1 < block_start) {
1333 : : /*
1334 : : * The hole exists between extents or the tail of
1335 : : * original file.
1336 : : */
1337 : 0 : last_extent = mext_next_extent(orig_inode,
1338 : : holecheck_path, &ext_cur);
1339 [ # # ]: 0 : if (last_extent < 0) {
1340 : 0 : ret = last_extent;
1341 : 0 : goto out;
1342 : : }
1343 : 0 : last_extent = mext_next_extent(orig_inode, orig_path,
1344 : : &ext_dummy);
1345 [ # # ]: 0 : if (last_extent < 0) {
1346 : 0 : ret = last_extent;
1347 : 0 : goto out;
1348 : : }
1349 : 0 : seq_start = le32_to_cpu(ext_cur->ee_block);
1350 [ # # ]: 0 : } else if (le32_to_cpu(ext_cur->ee_block) > block_start)
1351 : : /* The hole exists at the beginning of original file. */
1352 : : seq_start = le32_to_cpu(ext_cur->ee_block);
1353 : : else
1354 : : seq_start = block_start;
1355 : :
1356 : : /* No blocks within the specified range. */
1357 [ # # ]: 0 : if (le32_to_cpu(ext_cur->ee_block) > block_end) {
1358 : : ext4_debug("ext4 move extent: The specified range of file "
1359 : : "may be the hole\n");
1360 : 0 : ret = -EINVAL;
1361 : 0 : goto out;
1362 : : }
1363 : :
1364 : : /* Adjust start blocks */
1365 : 0 : add_blocks = min(le32_to_cpu(ext_cur->ee_block) +
1366 : : ext4_ext_get_actual_len(ext_cur), block_end + 1) -
1367 : 0 : max(le32_to_cpu(ext_cur->ee_block), block_start);
1368 : :
1369 [ # # ][ # # ]: 0 : while (!last_extent && le32_to_cpu(ext_cur->ee_block) <= block_end) {
1370 : 0 : seq_blocks += add_blocks;
1371 : :
1372 : : /* Adjust tail blocks */
1373 [ # # ]: 0 : if (seq_start + seq_blocks - 1 > block_end)
1374 : 0 : seq_blocks = block_end - seq_start + 1;
1375 : :
1376 : : ext_prev = ext_cur;
1377 : 0 : last_extent = mext_next_extent(orig_inode, holecheck_path,
1378 : : &ext_cur);
1379 [ # # ]: 0 : if (last_extent < 0) {
1380 : 0 : ret = last_extent;
1381 : 0 : break;
1382 : : }
1383 : 0 : add_blocks = ext4_ext_get_actual_len(ext_cur);
1384 : :
1385 : : /*
1386 : : * Extend the length of contiguous block (seq_blocks)
1387 : : * if extents are contiguous.
1388 : : */
1389 [ # # ]: 0 : if (ext4_can_extents_be_merged(orig_inode,
1390 [ # # ]: 0 : ext_prev, ext_cur) &&
1391 [ # # ]: 0 : block_end >= le32_to_cpu(ext_cur->ee_block) &&
1392 : : !last_extent)
1393 : 0 : continue;
1394 : :
1395 : : /* Is original extent is uninitialized */
1396 : : uninit = ext4_ext_is_uninitialized(ext_prev);
1397 : :
1398 : 0 : data_offset_in_page = seq_start % blocks_per_page;
1399 : :
1400 : : /*
1401 : : * Calculate data blocks count that should be swapped
1402 : : * at the first page.
1403 : : */
1404 [ # # ]: 0 : if (data_offset_in_page + seq_blocks > blocks_per_page) {
1405 : : /* Swapped blocks are across pages */
1406 : 0 : block_len_in_page =
1407 : : blocks_per_page - data_offset_in_page;
1408 : : } else {
1409 : : /* Swapped blocks are in a page */
1410 : 0 : block_len_in_page = seq_blocks;
1411 : : }
1412 : :
1413 : 0 : orig_page_offset = seq_start >>
1414 : 0 : (PAGE_CACHE_SHIFT - orig_inode->i_blkbits);
1415 : 0 : seq_end_page = (seq_start + seq_blocks - 1) >>
1416 : : (PAGE_CACHE_SHIFT - orig_inode->i_blkbits);
1417 : 0 : seq_start = le32_to_cpu(ext_cur->ee_block);
1418 : : rest_blocks = seq_blocks;
1419 : :
1420 : : /*
1421 : : * Up semaphore to avoid following problems:
1422 : : * a. transaction deadlock among ext4_journal_start,
1423 : : * ->write_begin via pagefault, and jbd2_journal_commit
1424 : : * b. racing with ->readpage, ->write_begin, and ext4_get_block
1425 : : * in move_extent_per_page
1426 : : */
1427 : : ext4_double_up_write_data_sem(orig_inode, donor_inode);
1428 : :
1429 [ # # ]: 0 : while (orig_page_offset <= seq_end_page) {
1430 : :
1431 : : /* Swap original branches with new branches */
1432 : 0 : block_len_in_page = move_extent_per_page(
1433 : : o_filp, donor_inode,
1434 : : orig_page_offset,
1435 : : data_offset_in_page,
1436 : : block_len_in_page, uninit,
1437 : : &ret);
1438 : :
1439 : : /* Count how many blocks we have exchanged */
1440 : 0 : *moved_len += block_len_in_page;
1441 [ # # ]: 0 : if (ret < 0)
1442 : : break;
1443 [ # # ]: 0 : if (*moved_len > len) {
1444 : 0 : EXT4_ERROR_INODE(orig_inode,
1445 : : "We replaced blocks too much! "
1446 : : "sum of replaced: %llu requested: %llu",
1447 : : *moved_len, len);
1448 : 0 : ret = -EIO;
1449 : 0 : break;
1450 : : }
1451 : :
1452 : 0 : orig_page_offset++;
1453 : : data_offset_in_page = 0;
1454 : 0 : rest_blocks -= block_len_in_page;
1455 [ # # ]: 0 : if (rest_blocks > blocks_per_page)
1456 : : block_len_in_page = blocks_per_page;
1457 : : else
1458 : 0 : block_len_in_page = rest_blocks;
1459 : : }
1460 : :
1461 : 0 : ext4_double_down_write_data_sem(orig_inode, donor_inode);
1462 [ # # ]: 0 : if (ret < 0)
1463 : : break;
1464 : :
1465 : : /* Decrease buffer counter */
1466 [ # # ]: 0 : if (holecheck_path)
1467 : 0 : ext4_ext_drop_refs(holecheck_path);
1468 : 0 : ret = get_ext_path(orig_inode, seq_start, &holecheck_path);
1469 [ # # ]: 0 : if (ret)
1470 : : break;
1471 : 0 : depth = holecheck_path->p_depth;
1472 : :
1473 : : /* Decrease buffer counter */
1474 [ # # ]: 0 : if (orig_path)
1475 : 0 : ext4_ext_drop_refs(orig_path);
1476 : 0 : ret = get_ext_path(orig_inode, seq_start, &orig_path);
1477 [ # # ]: 0 : if (ret)
1478 : : break;
1479 : :
1480 : 0 : ext_cur = holecheck_path[depth].p_ext;
1481 : 0 : add_blocks = ext4_ext_get_actual_len(ext_cur);
1482 : : seq_blocks = 0;
1483 : :
1484 : : }
1485 : : out:
1486 [ # # ]: 0 : if (*moved_len) {
1487 : 0 : ext4_discard_preallocations(orig_inode);
1488 : 0 : ext4_discard_preallocations(donor_inode);
1489 : : }
1490 : :
1491 [ # # ]: 0 : if (orig_path) {
1492 : 0 : ext4_ext_drop_refs(orig_path);
1493 : 0 : kfree(orig_path);
1494 : : }
1495 [ # # ]: 0 : if (holecheck_path) {
1496 : 0 : ext4_ext_drop_refs(holecheck_path);
1497 : 0 : kfree(holecheck_path);
1498 : : }
1499 : : ext4_double_up_write_data_sem(orig_inode, donor_inode);
1500 : : ext4_inode_resume_unlocked_dio(orig_inode);
1501 : : ext4_inode_resume_unlocked_dio(donor_inode);
1502 : 0 : unlock_two_nondirectories(orig_inode, donor_inode);
1503 : :
1504 : 0 : return ret;
1505 : : }
|
