move_extent.c 41 KB

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