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