ext4_write.c 29 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2011 - 2012 Samsung Electronics
  4. * EXT4 filesystem implementation in Uboot by
  5. * Uma Shankar <uma.shankar@samsung.com>
  6. * Manjunatha C Achar <a.manjunatha@samsung.com>
  7. *
  8. * ext4ls and ext4load : Based on ext2 ls and load support in Uboot.
  9. * Ext4 read optimization taken from Open-Moko
  10. * Qi bootloader
  11. *
  12. * (C) Copyright 2004
  13. * esd gmbh <www.esd-electronics.com>
  14. * Reinhard Arlt <reinhard.arlt@esd-electronics.com>
  15. *
  16. * based on code from grub2 fs/ext2.c and fs/fshelp.c by
  17. * GRUB -- GRand Unified Bootloader
  18. * Copyright (C) 2003, 2004 Free Software Foundation, Inc.
  19. *
  20. * ext4write : Based on generic ext4 protocol.
  21. */
  22. #include <common.h>
  23. #include <malloc.h>
  24. #include <memalign.h>
  25. #include <linux/stat.h>
  26. #include <div64.h>
  27. #include "ext4_common.h"
  28. static inline void ext4fs_sb_free_inodes_inc(struct ext2_sblock *sb)
  29. {
  30. sb->free_inodes = cpu_to_le32(le32_to_cpu(sb->free_inodes) + 1);
  31. }
  32. static inline void ext4fs_sb_free_blocks_inc(struct ext2_sblock *sb)
  33. {
  34. sb->free_blocks = cpu_to_le32(le32_to_cpu(sb->free_blocks) + 1);
  35. }
  36. static inline void ext4fs_bg_free_inodes_inc
  37. (struct ext2_block_group *bg, const struct ext_filesystem *fs)
  38. {
  39. uint32_t free_inodes = le16_to_cpu(bg->free_inodes);
  40. if (fs->gdsize == 64)
  41. free_inodes += le16_to_cpu(bg->free_inodes_high) << 16;
  42. free_inodes++;
  43. bg->free_inodes = cpu_to_le16(free_inodes & 0xffff);
  44. if (fs->gdsize == 64)
  45. bg->free_inodes_high = cpu_to_le16(free_inodes >> 16);
  46. }
  47. static inline void ext4fs_bg_free_blocks_inc
  48. (struct ext2_block_group *bg, const struct ext_filesystem *fs)
  49. {
  50. uint32_t free_blocks = le16_to_cpu(bg->free_blocks);
  51. if (fs->gdsize == 64)
  52. free_blocks += le16_to_cpu(bg->free_blocks_high) << 16;
  53. free_blocks++;
  54. bg->free_blocks = cpu_to_le16(free_blocks & 0xffff);
  55. if (fs->gdsize == 64)
  56. bg->free_blocks_high = cpu_to_le16(free_blocks >> 16);
  57. }
  58. static void ext4fs_update(void)
  59. {
  60. short i;
  61. ext4fs_update_journal();
  62. struct ext_filesystem *fs = get_fs();
  63. struct ext2_block_group *bgd = NULL;
  64. /* update super block */
  65. put_ext4((uint64_t)(SUPERBLOCK_SIZE),
  66. (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
  67. /* update block bitmaps */
  68. for (i = 0; i < fs->no_blkgrp; i++) {
  69. bgd = ext4fs_get_group_descriptor(fs, i);
  70. bgd->bg_checksum = cpu_to_le16(ext4fs_checksum_update(i));
  71. uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
  72. put_ext4(b_bitmap_blk * fs->blksz,
  73. fs->blk_bmaps[i], fs->blksz);
  74. }
  75. /* update inode bitmaps */
  76. for (i = 0; i < fs->no_blkgrp; i++) {
  77. bgd = ext4fs_get_group_descriptor(fs, i);
  78. uint64_t i_bitmap_blk = ext4fs_bg_get_inode_id(bgd, fs);
  79. put_ext4(i_bitmap_blk * fs->blksz,
  80. fs->inode_bmaps[i], fs->blksz);
  81. }
  82. /* update the block group descriptor table */
  83. put_ext4((uint64_t)((uint64_t)fs->gdtable_blkno * (uint64_t)fs->blksz),
  84. (struct ext2_block_group *)fs->gdtable,
  85. (fs->blksz * fs->no_blk_pergdt));
  86. ext4fs_dump_metadata();
  87. gindex = 0;
  88. gd_index = 0;
  89. }
  90. int ext4fs_get_bgdtable(void)
  91. {
  92. int status;
  93. struct ext_filesystem *fs = get_fs();
  94. int gdsize_total = ROUND(fs->no_blkgrp * fs->gdsize, fs->blksz);
  95. fs->no_blk_pergdt = gdsize_total / fs->blksz;
  96. /* allocate memory for gdtable */
  97. fs->gdtable = zalloc(gdsize_total);
  98. if (!fs->gdtable)
  99. return -ENOMEM;
  100. /* read the group descriptor table */
  101. status = ext4fs_devread((lbaint_t)fs->gdtable_blkno * fs->sect_perblk,
  102. 0, fs->blksz * fs->no_blk_pergdt, fs->gdtable);
  103. if (status == 0)
  104. goto fail;
  105. if (ext4fs_log_gdt(fs->gdtable)) {
  106. printf("Error in ext4fs_log_gdt\n");
  107. return -1;
  108. }
  109. return 0;
  110. fail:
  111. free(fs->gdtable);
  112. fs->gdtable = NULL;
  113. return -1;
  114. }
  115. static void delete_single_indirect_block(struct ext2_inode *inode)
  116. {
  117. struct ext2_block_group *bgd = NULL;
  118. static int prev_bg_bmap_idx = -1;
  119. uint32_t blknr;
  120. int remainder;
  121. int bg_idx;
  122. int status;
  123. uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
  124. struct ext_filesystem *fs = get_fs();
  125. char *journal_buffer = zalloc(fs->blksz);
  126. if (!journal_buffer) {
  127. printf("No memory\n");
  128. return;
  129. }
  130. /* deleting the single indirect block associated with inode */
  131. if (inode->b.blocks.indir_block != 0) {
  132. blknr = le32_to_cpu(inode->b.blocks.indir_block);
  133. debug("SIPB releasing %u\n", blknr);
  134. bg_idx = blknr / blk_per_grp;
  135. if (fs->blksz == 1024) {
  136. remainder = blknr % blk_per_grp;
  137. if (!remainder)
  138. bg_idx--;
  139. }
  140. ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
  141. /* get block group descriptor table */
  142. bgd = ext4fs_get_group_descriptor(fs, bg_idx);
  143. ext4fs_bg_free_blocks_inc(bgd, fs);
  144. ext4fs_sb_free_blocks_inc(fs->sb);
  145. /* journal backup */
  146. if (prev_bg_bmap_idx != bg_idx) {
  147. uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
  148. status = ext4fs_devread(
  149. b_bitmap_blk * fs->sect_perblk,
  150. 0, fs->blksz, journal_buffer);
  151. if (status == 0)
  152. goto fail;
  153. if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
  154. goto fail;
  155. prev_bg_bmap_idx = bg_idx;
  156. }
  157. }
  158. fail:
  159. free(journal_buffer);
  160. }
  161. static void delete_double_indirect_block(struct ext2_inode *inode)
  162. {
  163. int i;
  164. short status;
  165. static int prev_bg_bmap_idx = -1;
  166. uint32_t blknr;
  167. int remainder;
  168. int bg_idx;
  169. uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
  170. __le32 *di_buffer = NULL;
  171. void *dib_start_addr = NULL;
  172. struct ext2_block_group *bgd = NULL;
  173. struct ext_filesystem *fs = get_fs();
  174. char *journal_buffer = zalloc(fs->blksz);
  175. if (!journal_buffer) {
  176. printf("No memory\n");
  177. return;
  178. }
  179. if (inode->b.blocks.double_indir_block != 0) {
  180. di_buffer = zalloc(fs->blksz);
  181. if (!di_buffer) {
  182. printf("No memory\n");
  183. return;
  184. }
  185. dib_start_addr = di_buffer;
  186. blknr = le32_to_cpu(inode->b.blocks.double_indir_block);
  187. status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
  188. fs->blksz, (char *)di_buffer);
  189. for (i = 0; i < fs->blksz / sizeof(int); i++) {
  190. if (*di_buffer == 0)
  191. break;
  192. debug("DICB releasing %u\n", *di_buffer);
  193. bg_idx = le32_to_cpu(*di_buffer) / blk_per_grp;
  194. if (fs->blksz == 1024) {
  195. remainder = le32_to_cpu(*di_buffer) % blk_per_grp;
  196. if (!remainder)
  197. bg_idx--;
  198. }
  199. /* get block group descriptor table */
  200. bgd = ext4fs_get_group_descriptor(fs, bg_idx);
  201. ext4fs_reset_block_bmap(le32_to_cpu(*di_buffer),
  202. fs->blk_bmaps[bg_idx], bg_idx);
  203. di_buffer++;
  204. ext4fs_bg_free_blocks_inc(bgd, fs);
  205. ext4fs_sb_free_blocks_inc(fs->sb);
  206. /* journal backup */
  207. if (prev_bg_bmap_idx != bg_idx) {
  208. uint64_t b_bitmap_blk =
  209. ext4fs_bg_get_block_id(bgd, fs);
  210. status = ext4fs_devread(b_bitmap_blk
  211. * fs->sect_perblk, 0,
  212. fs->blksz,
  213. journal_buffer);
  214. if (status == 0)
  215. goto fail;
  216. if (ext4fs_log_journal(journal_buffer,
  217. b_bitmap_blk))
  218. goto fail;
  219. prev_bg_bmap_idx = bg_idx;
  220. }
  221. }
  222. /* removing the parent double indirect block */
  223. blknr = le32_to_cpu(inode->b.blocks.double_indir_block);
  224. bg_idx = blknr / blk_per_grp;
  225. if (fs->blksz == 1024) {
  226. remainder = blknr % blk_per_grp;
  227. if (!remainder)
  228. bg_idx--;
  229. }
  230. /* get block group descriptor table */
  231. bgd = ext4fs_get_group_descriptor(fs, bg_idx);
  232. ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
  233. ext4fs_bg_free_blocks_inc(bgd, fs);
  234. ext4fs_sb_free_blocks_inc(fs->sb);
  235. /* journal backup */
  236. if (prev_bg_bmap_idx != bg_idx) {
  237. uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
  238. status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
  239. 0, fs->blksz, journal_buffer);
  240. if (status == 0)
  241. goto fail;
  242. if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
  243. goto fail;
  244. prev_bg_bmap_idx = bg_idx;
  245. }
  246. debug("DIPB releasing %d\n", blknr);
  247. }
  248. fail:
  249. free(dib_start_addr);
  250. free(journal_buffer);
  251. }
  252. static void delete_triple_indirect_block(struct ext2_inode *inode)
  253. {
  254. int i, j;
  255. short status;
  256. static int prev_bg_bmap_idx = -1;
  257. uint32_t blknr;
  258. int remainder;
  259. int bg_idx;
  260. uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
  261. __le32 *tigp_buffer = NULL;
  262. void *tib_start_addr = NULL;
  263. __le32 *tip_buffer = NULL;
  264. void *tipb_start_addr = NULL;
  265. struct ext2_block_group *bgd = NULL;
  266. struct ext_filesystem *fs = get_fs();
  267. char *journal_buffer = zalloc(fs->blksz);
  268. if (!journal_buffer) {
  269. printf("No memory\n");
  270. return;
  271. }
  272. if (inode->b.blocks.triple_indir_block != 0) {
  273. tigp_buffer = zalloc(fs->blksz);
  274. if (!tigp_buffer) {
  275. printf("No memory\n");
  276. return;
  277. }
  278. tib_start_addr = tigp_buffer;
  279. blknr = le32_to_cpu(inode->b.blocks.triple_indir_block);
  280. status = ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0,
  281. fs->blksz, (char *)tigp_buffer);
  282. for (i = 0; i < fs->blksz / sizeof(int); i++) {
  283. if (*tigp_buffer == 0)
  284. break;
  285. debug("tigp buffer releasing %u\n", *tigp_buffer);
  286. tip_buffer = zalloc(fs->blksz);
  287. if (!tip_buffer)
  288. goto fail;
  289. tipb_start_addr = tip_buffer;
  290. status = ext4fs_devread((lbaint_t)le32_to_cpu(*tigp_buffer) *
  291. fs->sect_perblk, 0, fs->blksz,
  292. (char *)tip_buffer);
  293. for (j = 0; j < fs->blksz / sizeof(int); j++) {
  294. if (le32_to_cpu(*tip_buffer) == 0)
  295. break;
  296. bg_idx = le32_to_cpu(*tip_buffer) / blk_per_grp;
  297. if (fs->blksz == 1024) {
  298. remainder = le32_to_cpu(*tip_buffer) % blk_per_grp;
  299. if (!remainder)
  300. bg_idx--;
  301. }
  302. ext4fs_reset_block_bmap(le32_to_cpu(*tip_buffer),
  303. fs->blk_bmaps[bg_idx],
  304. bg_idx);
  305. tip_buffer++;
  306. /* get block group descriptor table */
  307. bgd = ext4fs_get_group_descriptor(fs, bg_idx);
  308. ext4fs_bg_free_blocks_inc(bgd, fs);
  309. ext4fs_sb_free_blocks_inc(fs->sb);
  310. /* journal backup */
  311. if (prev_bg_bmap_idx != bg_idx) {
  312. uint64_t b_bitmap_blk =
  313. ext4fs_bg_get_block_id(bgd, fs);
  314. status =
  315. ext4fs_devread(
  316. b_bitmap_blk *
  317. fs->sect_perblk, 0,
  318. fs->blksz,
  319. journal_buffer);
  320. if (status == 0)
  321. goto fail;
  322. if (ext4fs_log_journal(journal_buffer,
  323. b_bitmap_blk))
  324. goto fail;
  325. prev_bg_bmap_idx = bg_idx;
  326. }
  327. }
  328. free(tipb_start_addr);
  329. tipb_start_addr = NULL;
  330. /*
  331. * removing the grand parent blocks
  332. * which is connected to inode
  333. */
  334. bg_idx = le32_to_cpu(*tigp_buffer) / blk_per_grp;
  335. if (fs->blksz == 1024) {
  336. remainder = le32_to_cpu(*tigp_buffer) % blk_per_grp;
  337. if (!remainder)
  338. bg_idx--;
  339. }
  340. ext4fs_reset_block_bmap(le32_to_cpu(*tigp_buffer),
  341. fs->blk_bmaps[bg_idx], bg_idx);
  342. tigp_buffer++;
  343. /* get block group descriptor table */
  344. bgd = ext4fs_get_group_descriptor(fs, bg_idx);
  345. ext4fs_bg_free_blocks_inc(bgd, fs);
  346. ext4fs_sb_free_blocks_inc(fs->sb);
  347. /* journal backup */
  348. if (prev_bg_bmap_idx != bg_idx) {
  349. uint64_t b_bitmap_blk =
  350. ext4fs_bg_get_block_id(bgd, fs);
  351. memset(journal_buffer, '\0', fs->blksz);
  352. status = ext4fs_devread(b_bitmap_blk *
  353. fs->sect_perblk, 0,
  354. fs->blksz,
  355. journal_buffer);
  356. if (status == 0)
  357. goto fail;
  358. if (ext4fs_log_journal(journal_buffer,
  359. b_bitmap_blk))
  360. goto fail;
  361. prev_bg_bmap_idx = bg_idx;
  362. }
  363. }
  364. /* removing the grand parent triple indirect block */
  365. blknr = le32_to_cpu(inode->b.blocks.triple_indir_block);
  366. bg_idx = blknr / blk_per_grp;
  367. if (fs->blksz == 1024) {
  368. remainder = blknr % blk_per_grp;
  369. if (!remainder)
  370. bg_idx--;
  371. }
  372. ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx);
  373. /* get block group descriptor table */
  374. bgd = ext4fs_get_group_descriptor(fs, bg_idx);
  375. ext4fs_bg_free_blocks_inc(bgd, fs);
  376. ext4fs_sb_free_blocks_inc(fs->sb);
  377. /* journal backup */
  378. if (prev_bg_bmap_idx != bg_idx) {
  379. uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
  380. status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
  381. 0, fs->blksz, journal_buffer);
  382. if (status == 0)
  383. goto fail;
  384. if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
  385. goto fail;
  386. prev_bg_bmap_idx = bg_idx;
  387. }
  388. debug("tigp buffer itself releasing %d\n", blknr);
  389. }
  390. fail:
  391. free(tib_start_addr);
  392. free(tipb_start_addr);
  393. free(journal_buffer);
  394. }
  395. static int ext4fs_delete_file(int inodeno)
  396. {
  397. struct ext2_inode inode;
  398. short status;
  399. int i;
  400. int remainder;
  401. long int blknr;
  402. int bg_idx;
  403. int ibmap_idx;
  404. char *read_buffer = NULL;
  405. char *start_block_address = NULL;
  406. uint32_t no_blocks;
  407. static int prev_bg_bmap_idx = -1;
  408. unsigned int inodes_per_block;
  409. uint32_t blkno;
  410. unsigned int blkoff;
  411. uint32_t blk_per_grp = le32_to_cpu(ext4fs_root->sblock.blocks_per_group);
  412. uint32_t inode_per_grp = le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
  413. struct ext2_inode *inode_buffer = NULL;
  414. struct ext2_block_group *bgd = NULL;
  415. struct ext_filesystem *fs = get_fs();
  416. char *journal_buffer = zalloc(fs->blksz);
  417. if (!journal_buffer)
  418. return -ENOMEM;
  419. status = ext4fs_read_inode(ext4fs_root, inodeno, &inode);
  420. if (status == 0)
  421. goto fail;
  422. /* read the block no allocated to a file */
  423. no_blocks = le32_to_cpu(inode.size) / fs->blksz;
  424. if (le32_to_cpu(inode.size) % fs->blksz)
  425. no_blocks++;
  426. /*
  427. * special case for symlinks whose target are small enough that
  428. *it fits in struct ext2_inode.b.symlink: no block had been allocated
  429. */
  430. if ((le16_to_cpu(inode.mode) & S_IFLNK) &&
  431. le32_to_cpu(inode.size) <= sizeof(inode.b.symlink)) {
  432. no_blocks = 0;
  433. }
  434. if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FL) {
  435. /* FIXME delete extent index blocks, i.e. eh_depth >= 1 */
  436. struct ext4_extent_header *eh =
  437. (struct ext4_extent_header *)
  438. inode.b.blocks.dir_blocks;
  439. debug("del: dep=%d entries=%d\n", eh->eh_depth, eh->eh_entries);
  440. } else {
  441. delete_single_indirect_block(&inode);
  442. delete_double_indirect_block(&inode);
  443. delete_triple_indirect_block(&inode);
  444. }
  445. /* release data blocks */
  446. for (i = 0; i < no_blocks; i++) {
  447. blknr = read_allocated_block(&inode, i, NULL);
  448. if (blknr == 0)
  449. continue;
  450. if (blknr < 0)
  451. goto fail;
  452. bg_idx = blknr / blk_per_grp;
  453. if (fs->blksz == 1024) {
  454. remainder = blknr % blk_per_grp;
  455. if (!remainder)
  456. bg_idx--;
  457. }
  458. ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx],
  459. bg_idx);
  460. debug("EXT4 Block releasing %ld: %d\n", blknr, bg_idx);
  461. /* get block group descriptor table */
  462. bgd = ext4fs_get_group_descriptor(fs, bg_idx);
  463. ext4fs_bg_free_blocks_inc(bgd, fs);
  464. ext4fs_sb_free_blocks_inc(fs->sb);
  465. /* journal backup */
  466. if (prev_bg_bmap_idx != bg_idx) {
  467. uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
  468. status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
  469. 0, fs->blksz,
  470. journal_buffer);
  471. if (status == 0)
  472. goto fail;
  473. if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
  474. goto fail;
  475. prev_bg_bmap_idx = bg_idx;
  476. }
  477. }
  478. /* release inode */
  479. /* from the inode no to blockno */
  480. inodes_per_block = fs->blksz / fs->inodesz;
  481. ibmap_idx = inodeno / inode_per_grp;
  482. /* get the block no */
  483. inodeno--;
  484. /* get block group descriptor table */
  485. bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
  486. blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
  487. (inodeno % inode_per_grp) / inodes_per_block;
  488. /* get the offset of the inode */
  489. blkoff = ((inodeno) % inodes_per_block) * fs->inodesz;
  490. /* read the block no containing the inode */
  491. read_buffer = zalloc(fs->blksz);
  492. if (!read_buffer)
  493. goto fail;
  494. start_block_address = read_buffer;
  495. status = ext4fs_devread((lbaint_t)blkno * fs->sect_perblk,
  496. 0, fs->blksz, read_buffer);
  497. if (status == 0)
  498. goto fail;
  499. if (ext4fs_log_journal(read_buffer, blkno))
  500. goto fail;
  501. read_buffer = read_buffer + blkoff;
  502. inode_buffer = (struct ext2_inode *)read_buffer;
  503. memset(inode_buffer, '\0', fs->inodesz);
  504. /* write the inode to original position in inode table */
  505. if (ext4fs_put_metadata(start_block_address, blkno))
  506. goto fail;
  507. /* update the respective inode bitmaps */
  508. inodeno++;
  509. ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx);
  510. ext4fs_bg_free_inodes_inc(bgd, fs);
  511. ext4fs_sb_free_inodes_inc(fs->sb);
  512. /* journal backup */
  513. memset(journal_buffer, '\0', fs->blksz);
  514. status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) *
  515. fs->sect_perblk, 0, fs->blksz, journal_buffer);
  516. if (status == 0)
  517. goto fail;
  518. if (ext4fs_log_journal(journal_buffer, ext4fs_bg_get_inode_id(bgd, fs)))
  519. goto fail;
  520. ext4fs_update();
  521. ext4fs_deinit();
  522. ext4fs_reinit_global();
  523. if (ext4fs_init() != 0) {
  524. printf("error in File System init\n");
  525. goto fail;
  526. }
  527. free(start_block_address);
  528. free(journal_buffer);
  529. return 0;
  530. fail:
  531. free(start_block_address);
  532. free(journal_buffer);
  533. return -1;
  534. }
  535. int ext4fs_init(void)
  536. {
  537. short status;
  538. int i;
  539. uint32_t real_free_blocks = 0;
  540. struct ext_filesystem *fs = get_fs();
  541. /* populate fs */
  542. fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root);
  543. fs->sect_perblk = fs->blksz >> fs->dev_desc->log2blksz;
  544. /* get the superblock */
  545. fs->sb = zalloc(SUPERBLOCK_SIZE);
  546. if (!fs->sb)
  547. return -ENOMEM;
  548. if (!ext4_read_superblock((char *)fs->sb))
  549. goto fail;
  550. /* init journal */
  551. if (ext4fs_init_journal())
  552. goto fail;
  553. /* get total no of blockgroups */
  554. fs->no_blkgrp = (uint32_t)ext4fs_div_roundup(
  555. le32_to_cpu(ext4fs_root->sblock.total_blocks)
  556. - le32_to_cpu(ext4fs_root->sblock.first_data_block),
  557. le32_to_cpu(ext4fs_root->sblock.blocks_per_group));
  558. /* get the block group descriptor table */
  559. fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1);
  560. if (ext4fs_get_bgdtable() == -1) {
  561. printf("Error in getting the block group descriptor table\n");
  562. goto fail;
  563. }
  564. /* load all the available bitmap block of the partition */
  565. fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *));
  566. if (!fs->blk_bmaps)
  567. goto fail;
  568. for (i = 0; i < fs->no_blkgrp; i++) {
  569. fs->blk_bmaps[i] = zalloc(fs->blksz);
  570. if (!fs->blk_bmaps[i])
  571. goto fail;
  572. }
  573. for (i = 0; i < fs->no_blkgrp; i++) {
  574. struct ext2_block_group *bgd =
  575. ext4fs_get_group_descriptor(fs, i);
  576. status = ext4fs_devread(ext4fs_bg_get_block_id(bgd, fs) *
  577. fs->sect_perblk, 0,
  578. fs->blksz, (char *)fs->blk_bmaps[i]);
  579. if (status == 0)
  580. goto fail;
  581. }
  582. /* load all the available inode bitmap of the partition */
  583. fs->inode_bmaps = zalloc(fs->no_blkgrp * sizeof(unsigned char *));
  584. if (!fs->inode_bmaps)
  585. goto fail;
  586. for (i = 0; i < fs->no_blkgrp; i++) {
  587. fs->inode_bmaps[i] = zalloc(fs->blksz);
  588. if (!fs->inode_bmaps[i])
  589. goto fail;
  590. }
  591. for (i = 0; i < fs->no_blkgrp; i++) {
  592. struct ext2_block_group *bgd =
  593. ext4fs_get_group_descriptor(fs, i);
  594. status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) *
  595. fs->sect_perblk,
  596. 0, fs->blksz,
  597. (char *)fs->inode_bmaps[i]);
  598. if (status == 0)
  599. goto fail;
  600. }
  601. /*
  602. * check filesystem consistency with free blocks of file system
  603. * some time we observed that superblock freeblocks does not match
  604. * with the blockgroups freeblocks when improper
  605. * reboot of a linux kernel
  606. */
  607. for (i = 0; i < fs->no_blkgrp; i++) {
  608. struct ext2_block_group *bgd =
  609. ext4fs_get_group_descriptor(fs, i);
  610. real_free_blocks = real_free_blocks +
  611. ext4fs_bg_get_free_blocks(bgd, fs);
  612. }
  613. if (real_free_blocks != ext4fs_sb_get_free_blocks(fs->sb))
  614. ext4fs_sb_set_free_blocks(fs->sb, real_free_blocks);
  615. return 0;
  616. fail:
  617. ext4fs_deinit();
  618. return -1;
  619. }
  620. void ext4fs_deinit(void)
  621. {
  622. int i;
  623. struct ext2_inode inode_journal;
  624. struct journal_superblock_t *jsb;
  625. uint32_t blknr;
  626. struct ext_filesystem *fs = get_fs();
  627. uint32_t new_feature_incompat;
  628. /* free journal */
  629. char *temp_buff = zalloc(fs->blksz);
  630. if (temp_buff) {
  631. ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
  632. &inode_journal);
  633. blknr = read_allocated_block(&inode_journal,
  634. EXT2_JOURNAL_SUPERBLOCK, NULL);
  635. ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz,
  636. temp_buff);
  637. jsb = (struct journal_superblock_t *)temp_buff;
  638. jsb->s_start = 0;
  639. put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz),
  640. (struct journal_superblock_t *)temp_buff, fs->blksz);
  641. free(temp_buff);
  642. }
  643. ext4fs_free_journal();
  644. /* get the superblock */
  645. ext4_read_superblock((char *)fs->sb);
  646. new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat);
  647. new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
  648. fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat);
  649. put_ext4((uint64_t)(SUPERBLOCK_SIZE),
  650. (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
  651. free(fs->sb);
  652. fs->sb = NULL;
  653. if (fs->blk_bmaps) {
  654. for (i = 0; i < fs->no_blkgrp; i++) {
  655. free(fs->blk_bmaps[i]);
  656. fs->blk_bmaps[i] = NULL;
  657. }
  658. free(fs->blk_bmaps);
  659. fs->blk_bmaps = NULL;
  660. }
  661. if (fs->inode_bmaps) {
  662. for (i = 0; i < fs->no_blkgrp; i++) {
  663. free(fs->inode_bmaps[i]);
  664. fs->inode_bmaps[i] = NULL;
  665. }
  666. free(fs->inode_bmaps);
  667. fs->inode_bmaps = NULL;
  668. }
  669. free(fs->gdtable);
  670. fs->gdtable = NULL;
  671. /*
  672. * reinitiliazed the global inode and
  673. * block bitmap first execution check variables
  674. */
  675. fs->first_pass_ibmap = 0;
  676. fs->first_pass_bbmap = 0;
  677. fs->curr_inode_no = 0;
  678. fs->curr_blkno = 0;
  679. }
  680. /*
  681. * Write data to filesystem blocks. Uses same optimization for
  682. * contigous sectors as ext4fs_read_file
  683. */
  684. static int ext4fs_write_file(struct ext2_inode *file_inode,
  685. int pos, unsigned int len, const char *buf)
  686. {
  687. int i;
  688. int blockcnt;
  689. uint32_t filesize = le32_to_cpu(file_inode->size);
  690. struct ext_filesystem *fs = get_fs();
  691. int log2blksz = fs->dev_desc->log2blksz;
  692. int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz;
  693. int previous_block_number = -1;
  694. int delayed_start = 0;
  695. int delayed_extent = 0;
  696. int delayed_next = 0;
  697. const char *delayed_buf = NULL;
  698. /* Adjust len so it we can't read past the end of the file. */
  699. if (len > filesize)
  700. len = filesize;
  701. blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz;
  702. for (i = pos / fs->blksz; i < blockcnt; i++) {
  703. long int blknr;
  704. int blockend = fs->blksz;
  705. int skipfirst = 0;
  706. blknr = read_allocated_block(file_inode, i, NULL);
  707. if (blknr <= 0)
  708. return -1;
  709. blknr = blknr << log2_fs_blocksize;
  710. if (blknr) {
  711. if (previous_block_number != -1) {
  712. if (delayed_next == blknr) {
  713. delayed_extent += blockend;
  714. delayed_next += blockend >> log2blksz;
  715. } else { /* spill */
  716. put_ext4((uint64_t)
  717. ((uint64_t)delayed_start << log2blksz),
  718. delayed_buf,
  719. (uint32_t) delayed_extent);
  720. previous_block_number = blknr;
  721. delayed_start = blknr;
  722. delayed_extent = blockend;
  723. delayed_buf = buf;
  724. delayed_next = blknr +
  725. (blockend >> log2blksz);
  726. }
  727. } else {
  728. previous_block_number = blknr;
  729. delayed_start = blknr;
  730. delayed_extent = blockend;
  731. delayed_buf = buf;
  732. delayed_next = blknr +
  733. (blockend >> log2blksz);
  734. }
  735. } else {
  736. if (previous_block_number != -1) {
  737. /* spill */
  738. put_ext4((uint64_t) ((uint64_t)delayed_start <<
  739. log2blksz),
  740. delayed_buf,
  741. (uint32_t) delayed_extent);
  742. previous_block_number = -1;
  743. }
  744. }
  745. buf += fs->blksz - skipfirst;
  746. }
  747. if (previous_block_number != -1) {
  748. /* spill */
  749. put_ext4((uint64_t) ((uint64_t)delayed_start << log2blksz),
  750. delayed_buf, (uint32_t) delayed_extent);
  751. previous_block_number = -1;
  752. }
  753. return len;
  754. }
  755. int ext4fs_write(const char *fname, const char *buffer,
  756. unsigned long sizebytes, int type)
  757. {
  758. int ret = 0;
  759. struct ext2_inode *file_inode = NULL;
  760. unsigned char *inode_buffer = NULL;
  761. int parent_inodeno;
  762. int inodeno;
  763. time_t timestamp = 0;
  764. uint64_t bytes_reqd_for_file;
  765. unsigned int blks_reqd_for_file;
  766. unsigned int blocks_remaining;
  767. int existing_file_inodeno;
  768. char *temp_ptr = NULL;
  769. long int itable_blkno;
  770. long int parent_itable_blkno;
  771. long int blkoff;
  772. struct ext2_sblock *sblock = &(ext4fs_root->sblock);
  773. unsigned int inodes_per_block;
  774. unsigned int ibmap_idx;
  775. struct ext2_block_group *bgd = NULL;
  776. struct ext_filesystem *fs = get_fs();
  777. ALLOC_CACHE_ALIGN_BUFFER(char, filename, 256);
  778. bool store_link_in_inode = false;
  779. memset(filename, 0x00, 256);
  780. if (type != FILETYPE_REG && type != FILETYPE_SYMLINK)
  781. return -1;
  782. g_parent_inode = zalloc(fs->inodesz);
  783. if (!g_parent_inode)
  784. goto fail;
  785. if (ext4fs_init() != 0) {
  786. printf("error in File System init\n");
  787. return -1;
  788. }
  789. if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) {
  790. printf("Unsupported feature metadata_csum found, not writing.\n");
  791. return -1;
  792. }
  793. inodes_per_block = fs->blksz / fs->inodesz;
  794. parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE);
  795. if (parent_inodeno == -1)
  796. goto fail;
  797. if (ext4fs_iget(parent_inodeno, g_parent_inode))
  798. goto fail;
  799. /* do not mess up a directory using hash trees */
  800. if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) {
  801. printf("hash tree directory\n");
  802. goto fail;
  803. }
  804. /* check if the filename is already present in root */
  805. existing_file_inodeno = ext4fs_filename_unlink(filename);
  806. if (existing_file_inodeno != -1) {
  807. ret = ext4fs_delete_file(existing_file_inodeno);
  808. fs->first_pass_bbmap = 0;
  809. fs->curr_blkno = 0;
  810. fs->first_pass_ibmap = 0;
  811. fs->curr_inode_no = 0;
  812. if (ret)
  813. goto fail;
  814. }
  815. /* calculate how many blocks required */
  816. if (type == FILETYPE_SYMLINK &&
  817. sizebytes <= sizeof(file_inode->b.symlink)) {
  818. store_link_in_inode = true;
  819. bytes_reqd_for_file = 0;
  820. } else {
  821. bytes_reqd_for_file = sizebytes;
  822. }
  823. blks_reqd_for_file = lldiv(bytes_reqd_for_file, fs->blksz);
  824. if (do_div(bytes_reqd_for_file, fs->blksz) != 0) {
  825. blks_reqd_for_file++;
  826. debug("total bytes for a file %u\n", blks_reqd_for_file);
  827. }
  828. blocks_remaining = blks_reqd_for_file;
  829. /* test for available space in partition */
  830. if (le32_to_cpu(fs->sb->free_blocks) < blks_reqd_for_file) {
  831. printf("Not enough space on partition !!!\n");
  832. goto fail;
  833. }
  834. inodeno = ext4fs_update_parent_dentry(filename, type);
  835. if (inodeno == -1)
  836. goto fail;
  837. /* prepare file inode */
  838. inode_buffer = zalloc(fs->inodesz);
  839. if (!inode_buffer)
  840. goto fail;
  841. file_inode = (struct ext2_inode *)inode_buffer;
  842. file_inode->size = cpu_to_le32(sizebytes);
  843. if (type == FILETYPE_SYMLINK) {
  844. file_inode->mode = cpu_to_le16(S_IFLNK | S_IRWXU | S_IRWXG |
  845. S_IRWXO);
  846. if (store_link_in_inode) {
  847. strncpy(file_inode->b.symlink, buffer, sizebytes);
  848. sizebytes = 0;
  849. }
  850. } else {
  851. file_inode->mode = cpu_to_le16(S_IFREG | S_IRWXU | S_IRGRP |
  852. S_IROTH | S_IXGRP | S_IXOTH);
  853. }
  854. /* ToDo: Update correct time */
  855. file_inode->mtime = cpu_to_le32(timestamp);
  856. file_inode->atime = cpu_to_le32(timestamp);
  857. file_inode->ctime = cpu_to_le32(timestamp);
  858. file_inode->nlinks = cpu_to_le16(1);
  859. /* Allocate data blocks */
  860. ext4fs_allocate_blocks(file_inode, blocks_remaining,
  861. &blks_reqd_for_file);
  862. file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >>
  863. LOG2_SECTOR_SIZE);
  864. temp_ptr = zalloc(fs->blksz);
  865. if (!temp_ptr)
  866. goto fail;
  867. ibmap_idx = inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
  868. inodeno--;
  869. bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
  870. itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
  871. (inodeno % le32_to_cpu(sblock->inodes_per_group)) /
  872. inodes_per_block;
  873. blkoff = (inodeno % inodes_per_block) * fs->inodesz;
  874. ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz,
  875. temp_ptr);
  876. if (ext4fs_log_journal(temp_ptr, itable_blkno))
  877. goto fail;
  878. memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz);
  879. if (ext4fs_put_metadata(temp_ptr, itable_blkno))
  880. goto fail;
  881. /* copy the file content into data blocks */
  882. if (ext4fs_write_file(file_inode, 0, sizebytes, buffer) == -1) {
  883. printf("Error in copying content\n");
  884. /* FIXME: Deallocate data blocks */
  885. goto fail;
  886. }
  887. ibmap_idx = parent_inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
  888. parent_inodeno--;
  889. bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
  890. parent_itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
  891. (parent_inodeno %
  892. le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
  893. blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz;
  894. if (parent_itable_blkno != itable_blkno) {
  895. memset(temp_ptr, '\0', fs->blksz);
  896. ext4fs_devread((lbaint_t)parent_itable_blkno * fs->sect_perblk,
  897. 0, fs->blksz, temp_ptr);
  898. if (ext4fs_log_journal(temp_ptr, parent_itable_blkno))
  899. goto fail;
  900. memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
  901. if (ext4fs_put_metadata(temp_ptr, parent_itable_blkno))
  902. goto fail;
  903. } else {
  904. /*
  905. * If parent and child fall in same inode table block
  906. * both should be kept in 1 buffer
  907. */
  908. memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
  909. gd_index--;
  910. if (ext4fs_put_metadata(temp_ptr, itable_blkno))
  911. goto fail;
  912. }
  913. ext4fs_update();
  914. ext4fs_deinit();
  915. fs->first_pass_bbmap = 0;
  916. fs->curr_blkno = 0;
  917. fs->first_pass_ibmap = 0;
  918. fs->curr_inode_no = 0;
  919. free(inode_buffer);
  920. free(g_parent_inode);
  921. free(temp_ptr);
  922. g_parent_inode = NULL;
  923. return 0;
  924. fail:
  925. ext4fs_deinit();
  926. free(inode_buffer);
  927. free(g_parent_inode);
  928. free(temp_ptr);
  929. g_parent_inode = NULL;
  930. return -1;
  931. }
  932. int ext4_write_file(const char *filename, void *buf, loff_t offset,
  933. loff_t len, loff_t *actwrite)
  934. {
  935. int ret;
  936. if (offset != 0) {
  937. printf("** Cannot support non-zero offset **\n");
  938. return -1;
  939. }
  940. ret = ext4fs_write(filename, buf, len, FILETYPE_REG);
  941. if (ret) {
  942. printf("** Error ext4fs_write() **\n");
  943. goto fail;
  944. }
  945. *actwrite = len;
  946. return 0;
  947. fail:
  948. *actwrite = 0;
  949. return -1;
  950. }
  951. int ext4fs_create_link(const char *target, const char *fname)
  952. {
  953. return ext4fs_write(fname, target, strlen(target), FILETYPE_SYMLINK);
  954. }