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