ext4_write.c 29 KB

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