fs/ext4/ext4_write.c

   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 <malloc.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         /*
 470          * special case for symlinks whose target are small enough that
 471          *it fits in struct ext2_inode.b.symlink: no block had been allocated
 472          */
 473         if ((le16_to_cpu(inode.mode) & S_IFLNK) &&
 474             le32_to_cpu(inode.size) <= sizeof(inode.b.symlink)) {
 475                 no_blocks = 0;
 476         }
 477
 478         if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FL) {
 479                 /* FIXME delete extent index blocks, i.e. eh_depth >= 1 */
 480                 struct ext4_extent_header *eh =
 481                         (struct ext4_extent_header *)
 482                                 inode.b.blocks.dir_blocks;
 483                 debug("del: dep=%d entries=%d\n", eh->eh_depth, eh->eh_entries);
 484         } else {
 485                 delete_single_indirect_block(&inode);
 486                 delete_double_indirect_block(&inode);
 487                 delete_triple_indirect_block(&inode);
 488         }
 489
 490         /* release data blocks */
 491         for (i = 0; i < no_blocks; i++) {
 492                 blknr = read_allocated_block(&inode, i, NULL);
 493                 if (blknr == 0)
 494                         continue;
 495                 if (blknr < 0)
 496                         goto fail;
 497                 bg_idx = blknr / blk_per_grp;
 498                 if (fs->blksz == 1024) {
 499                         remainder = blknr % blk_per_grp;
 500                         if (!remainder)
 501                                 bg_idx--;
 502                 }
 503                 ext4fs_reset_block_bmap(blknr, fs->blk_bmaps[bg_idx],
 504                                         bg_idx);
 505                 debug("EXT4 Block releasing %ld: %d\n", blknr, bg_idx);
 506
 507                 /* get  block group descriptor table */
 508                 bgd = ext4fs_get_group_descriptor(fs, bg_idx);
 509                 ext4fs_bg_free_blocks_inc(bgd, fs);
 510                 ext4fs_sb_free_blocks_inc(fs->sb);
 511                 /* journal backup */
 512                 if (prev_bg_bmap_idx != bg_idx) {
 513                         uint64_t b_bitmap_blk = ext4fs_bg_get_block_id(bgd, fs);
 514                         status = ext4fs_devread(b_bitmap_blk * fs->sect_perblk,
 515                                                 0, fs->blksz,
 516                                                 journal_buffer);
 517                         if (status == 0)
 518                                 goto fail;
 519                         if (ext4fs_log_journal(journal_buffer, b_bitmap_blk))
 520                                 goto fail;
 521                         prev_bg_bmap_idx = bg_idx;
 522                 }
 523         }
 524
 525         /* release inode */
 526         /* from the inode no to blockno */
 527         inodes_per_block = fs->blksz / fs->inodesz;
 528         ibmap_idx = inodeno / inode_per_grp;
 529
 530         /* get the block no */
 531         inodeno--;
 532         /* get  block group descriptor table */
 533         bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
 534         blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
 535                 (inodeno % inode_per_grp) / inodes_per_block;
 536
 537         /* get the offset of the inode */
 538         blkoff = ((inodeno) % inodes_per_block) * fs->inodesz;
 539
 540         /* read the block no containing the inode */
 541         read_buffer = zalloc(fs->blksz);
 542         if (!read_buffer)
 543                 goto fail;
 544         start_block_address = read_buffer;
 545         status = ext4fs_devread((lbaint_t)blkno * fs->sect_perblk,
 546                                 0, fs->blksz, read_buffer);
 547         if (status == 0)
 548                 goto fail;
 549
 550         if (ext4fs_log_journal(read_buffer, blkno))
 551                 goto fail;
 552
 553         read_buffer = read_buffer + blkoff;
 554         inode_buffer = (struct ext2_inode *)read_buffer;
 555         memset(inode_buffer, '\0', fs->inodesz);
 556
 557         /* write the inode to original position in inode table */
 558         if (ext4fs_put_metadata(start_block_address, blkno))
 559                 goto fail;
 560
 561         /* update the respective inode bitmaps */
 562         inodeno++;
 563         ext4fs_reset_inode_bmap(inodeno, fs->inode_bmaps[ibmap_idx], ibmap_idx);
 564         ext4fs_bg_free_inodes_inc(bgd, fs);
 565         ext4fs_sb_free_inodes_inc(fs->sb);
 566         /* journal backup */
 567         memset(journal_buffer, '\0', fs->blksz);
 568         status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) *
 569                                 fs->sect_perblk, 0, fs->blksz, journal_buffer);
 570         if (status == 0)
 571                 goto fail;
 572         if (ext4fs_log_journal(journal_buffer, ext4fs_bg_get_inode_id(bgd, fs)))
 573                 goto fail;
 574
 575         ext4fs_update();
 576         ext4fs_deinit();
 577         ext4fs_reinit_global();
 578
 579         if (ext4fs_init() != 0) {
 580                 printf("error in File System init\n");
 581                 goto fail;
 582         }
 583
 584         free(start_block_address);
 585         free(journal_buffer);
 586
 587         return 0;
 588 fail:
 589         free(start_block_address);
 590         free(journal_buffer);
 591
 592         return -1;
 593 }
 594
 595 int ext4fs_init(void)
 596 {
 597         short status;
 598         int i;
 599         uint32_t real_free_blocks = 0;
 600         struct ext_filesystem *fs = get_fs();
 601
 602         /* populate fs */
 603         fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root);
 604         fs->sect_perblk = fs->blksz >> fs->dev_desc->log2blksz;
 605
 606         /* get the superblock */
 607         fs->sb = zalloc(SUPERBLOCK_SIZE);
 608         if (!fs->sb)
 609                 return -ENOMEM;
 610         if (!ext4_read_superblock((char *)fs->sb))
 611                 goto fail;
 612
 613         /* init journal */
 614         if (ext4fs_init_journal())
 615                 goto fail;
 616
 617         /* get total no of blockgroups */
 618         fs->no_blkgrp = (uint32_t)ext4fs_div_roundup(
 619                         le32_to_cpu(ext4fs_root->sblock.total_blocks)
 620                         - le32_to_cpu(ext4fs_root->sblock.first_data_block),
 621                         le32_to_cpu(ext4fs_root->sblock.blocks_per_group));
 622
 623         /* get the block group descriptor table */
 624         fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1);
 625         if (ext4fs_get_bgdtable() == -1) {
 626                 printf("Error in getting the block group descriptor table\n");
 627                 goto fail;
 628         }
 629
 630         /* load all the available bitmap block of the partition */
 631         fs->blk_bmaps = zalloc(fs->no_blkgrp * sizeof(char *));
 632         if (!fs->blk_bmaps)
 633                 goto fail;
 634         for (i = 0; i < fs->no_blkgrp; i++) {
 635                 fs->blk_bmaps[i] = zalloc(fs->blksz);
 636                 if (!fs->blk_bmaps[i])
 637                         goto fail;
 638         }
 639
 640         for (i = 0; i < fs->no_blkgrp; i++) {
 641                 struct ext2_block_group *bgd =
 642                         ext4fs_get_group_descriptor(fs, i);
 643                 status = ext4fs_devread(ext4fs_bg_get_block_id(bgd, fs) *
 644                                    fs->sect_perblk, 0,
 645                                    fs->blksz, (char *)fs->blk_bmaps[i]);
 646                 if (status == 0)
 647                         goto fail;
 648         }
 649
 650         /* load all the available inode bitmap of the partition */
 651         fs->inode_bmaps = zalloc(fs->no_blkgrp * sizeof(unsigned char *));
 652         if (!fs->inode_bmaps)
 653                 goto fail;
 654         for (i = 0; i < fs->no_blkgrp; i++) {
 655                 fs->inode_bmaps[i] = zalloc(fs->blksz);
 656                 if (!fs->inode_bmaps[i])
 657                         goto fail;
 658         }
 659
 660         for (i = 0; i < fs->no_blkgrp; i++) {
 661                 struct ext2_block_group *bgd =
 662                         ext4fs_get_group_descriptor(fs, i);
 663                 status = ext4fs_devread(ext4fs_bg_get_inode_id(bgd, fs) *
 664                                         fs->sect_perblk,
 665                                         0, fs->blksz,
 666                                         (char *)fs->inode_bmaps[i]);
 667                 if (status == 0)
 668                         goto fail;
 669         }
 670
 671         /*
 672          * check filesystem consistency with free blocks of file system
 673          * some time we observed that superblock freeblocks does not match
 674          * with the  blockgroups freeblocks when improper
 675          * reboot of a linux kernel
 676          */
 677         for (i = 0; i < fs->no_blkgrp; i++) {
 678                 struct ext2_block_group *bgd =
 679                         ext4fs_get_group_descriptor(fs, i);
 680                 real_free_blocks = real_free_blocks +
 681                         ext4fs_bg_get_free_blocks(bgd, fs);
 682         }
 683         if (real_free_blocks != ext4fs_sb_get_free_blocks(fs->sb))
 684                 ext4fs_sb_set_free_blocks(fs->sb, real_free_blocks);
 685
 686         return 0;
 687 fail:
 688         ext4fs_deinit();
 689
 690         return -1;
 691 }
 692
 693 void ext4fs_deinit(void)
 694 {
 695         int i;
 696         struct ext2_inode inode_journal;
 697         struct journal_superblock_t *jsb;
 698         uint32_t blknr;
 699         struct ext_filesystem *fs = get_fs();
 700         uint32_t new_feature_incompat;
 701
 702         /* free journal */
 703         char *temp_buff = zalloc(fs->blksz);
 704         if (temp_buff) {
 705                 ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO,
 706                                   &inode_journal);
 707                 blknr = read_allocated_block(&inode_journal,
 708                                         EXT2_JOURNAL_SUPERBLOCK, NULL);
 709                 ext4fs_devread((lbaint_t)blknr * fs->sect_perblk, 0, fs->blksz,
 710                                temp_buff);
 711                 jsb = (struct journal_superblock_t *)temp_buff;
 712                 jsb->s_start = 0;
 713                 put_ext4((uint64_t) ((uint64_t)blknr * (uint64_t)fs->blksz),
 714                          (struct journal_superblock_t *)temp_buff, fs->blksz);
 715                 free(temp_buff);
 716         }
 717         ext4fs_free_journal();
 718
 719         /* get the superblock */
 720         ext4_read_superblock((char *)fs->sb);
 721         new_feature_incompat = le32_to_cpu(fs->sb->feature_incompat);
 722         new_feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER;
 723         fs->sb->feature_incompat = cpu_to_le32(new_feature_incompat);
 724         put_ext4((uint64_t)(SUPERBLOCK_SIZE),
 725                  (struct ext2_sblock *)fs->sb, (uint32_t)SUPERBLOCK_SIZE);
 726         free(fs->sb);
 727         fs->sb = NULL;
 728
 729         if (fs->blk_bmaps) {
 730                 for (i = 0; i < fs->no_blkgrp; i++) {
 731                         free(fs->blk_bmaps[i]);
 732                         fs->blk_bmaps[i] = NULL;
 733                 }
 734                 free(fs->blk_bmaps);
 735                 fs->blk_bmaps = NULL;
 736         }
 737
 738         if (fs->inode_bmaps) {
 739                 for (i = 0; i < fs->no_blkgrp; i++) {
 740                         free(fs->inode_bmaps[i]);
 741                         fs->inode_bmaps[i] = NULL;
 742                 }
 743                 free(fs->inode_bmaps);
 744                 fs->inode_bmaps = NULL;
 745         }
 746
 747
 748         free(fs->gdtable);
 749         fs->gdtable = NULL;
 750         /*
 751          * reinitiliazed the global inode and
 752          * block bitmap first execution check variables
 753          */
 754         fs->first_pass_ibmap = 0;
 755         fs->first_pass_bbmap = 0;
 756         fs->curr_inode_no = 0;
 757         fs->curr_blkno = 0;
 758 }
 759
 760 /*
 761  * Write data to filesystem blocks. Uses same optimization for
 762  * contigous sectors as ext4fs_read_file
 763  */
 764 static int ext4fs_write_file(struct ext2_inode *file_inode,
 765                              int pos, unsigned int len, const char *buf)
 766 {
 767         int i;
 768         int blockcnt;
 769         uint32_t filesize = le32_to_cpu(file_inode->size);
 770         struct ext_filesystem *fs = get_fs();
 771         int log2blksz = fs->dev_desc->log2blksz;
 772         int log2_fs_blocksize = LOG2_BLOCK_SIZE(ext4fs_root) - log2blksz;
 773         int previous_block_number = -1;
 774         int delayed_start = 0;
 775         int delayed_extent = 0;
 776         int delayed_next = 0;
 777         const char *delayed_buf = NULL;
 778
 779         /* Adjust len so it we can't read past the end of the file. */
 780         if (len > filesize)
 781                 len = filesize;
 782
 783         blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz;
 784
 785         for (i = pos / fs->blksz; i < blockcnt; i++) {
 786                 long int blknr;
 787                 int blockend = fs->blksz;
 788                 int skipfirst = 0;
 789                 blknr = read_allocated_block(file_inode, i, NULL);
 790                 if (blknr <= 0)
 791                         return -1;
 792
 793                 blknr = blknr << log2_fs_blocksize;
 794
 795                 if (blknr) {
 796                         if (previous_block_number != -1) {
 797                                 if (delayed_next == blknr) {
 798                                         delayed_extent += blockend;
 799                                         delayed_next += blockend >> log2blksz;
 800                                 } else {        /* spill */
 801                                         put_ext4((uint64_t)
 802                                                  ((uint64_t)delayed_start << log2blksz),
 803                                                  delayed_buf,
 804                                                  (uint32_t) delayed_extent);
 805                                         previous_block_number = blknr;
 806                                         delayed_start = blknr;
 807                                         delayed_extent = blockend;
 808                                         delayed_buf = buf;
 809                                         delayed_next = blknr +
 810                                             (blockend >> log2blksz);
 811                                 }
 812                         } else {
 813                                 previous_block_number = blknr;
 814                                 delayed_start = blknr;
 815                                 delayed_extent = blockend;
 816                                 delayed_buf = buf;
 817                                 delayed_next = blknr +
 818                                     (blockend >> log2blksz);
 819                         }
 820                 } else {
 821                         if (previous_block_number != -1) {
 822                                 /* spill */
 823                                 put_ext4((uint64_t) ((uint64_t)delayed_start <<
 824                                                      log2blksz),
 825                                          delayed_buf,
 826                                          (uint32_t) delayed_extent);
 827                                 previous_block_number = -1;
 828                         }
 829                 }
 830                 buf += fs->blksz - skipfirst;
 831         }
 832         if (previous_block_number != -1) {
 833                 /* spill */
 834                 put_ext4((uint64_t) ((uint64_t)delayed_start << log2blksz),
 835                          delayed_buf, (uint32_t) delayed_extent);
 836                 previous_block_number = -1;
 837         }
 838
 839         return len;
 840 }
 841
 842 int ext4fs_write(const char *fname, const char *buffer,
 843                  unsigned long sizebytes, int type)
 844 {
 845         int ret = 0;
 846         struct ext2_inode *file_inode = NULL;
 847         unsigned char *inode_buffer = NULL;
 848         int parent_inodeno;
 849         int inodeno;
 850         time_t timestamp = 0;
 851
 852         uint64_t bytes_reqd_for_file;
 853         unsigned int blks_reqd_for_file;
 854         unsigned int blocks_remaining;
 855         int existing_file_inodeno;
 856         char *temp_ptr = NULL;
 857         long int itable_blkno;
 858         long int parent_itable_blkno;
 859         long int blkoff;
 860         struct ext2_sblock *sblock = &(ext4fs_root->sblock);
 861         unsigned int inodes_per_block;
 862         unsigned int ibmap_idx;
 863         struct ext2_block_group *bgd = NULL;
 864         struct ext_filesystem *fs = get_fs();
 865         ALLOC_CACHE_ALIGN_BUFFER(char, filename, 256);
 866         bool store_link_in_inode = false;
 867         memset(filename, 0x00, 256);
 868
 869         if (type != FILETYPE_REG && type != FILETYPE_SYMLINK)
 870                 return -1;
 871
 872         g_parent_inode = zalloc(fs->inodesz);
 873         if (!g_parent_inode)
 874                 goto fail;
 875
 876         if (ext4fs_init() != 0) {
 877                 printf("error in File System init\n");
 878                 return -1;
 879         }
 880
 881         if (le32_to_cpu(fs->sb->feature_ro_compat) & EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) {
 882                 printf("Unsupported feature metadata_csum found, not writing.\n");
 883                 return -1;
 884         }
 885
 886         inodes_per_block = fs->blksz / fs->inodesz;
 887         parent_inodeno = ext4fs_get_parent_inode_num(fname, filename, F_FILE);
 888         if (parent_inodeno == -1)
 889                 goto fail;
 890         if (ext4fs_iget(parent_inodeno, g_parent_inode))
 891                 goto fail;
 892         /* do not mess up a directory using hash trees */
 893         if (le32_to_cpu(g_parent_inode->flags) & EXT4_INDEX_FL) {
 894                 printf("hash tree directory\n");
 895                 goto fail;
 896         }
 897         /* check if the filename is already present in root */
 898         existing_file_inodeno = ext4fs_filename_unlink(filename);
 899         if (existing_file_inodeno != -1) {
 900                 ret = ext4fs_delete_file(existing_file_inodeno);
 901                 fs->first_pass_bbmap = 0;
 902                 fs->curr_blkno = 0;
 903
 904                 fs->first_pass_ibmap = 0;
 905                 fs->curr_inode_no = 0;
 906                 if (ret)
 907                         goto fail;
 908         }
 909
 910         /* calculate how many blocks required */
 911         if (type == FILETYPE_SYMLINK &&
 912             sizebytes <= sizeof(file_inode->b.symlink)) {
 913                 store_link_in_inode = true;
 914                 bytes_reqd_for_file = 0;
 915         } else {
 916                 bytes_reqd_for_file = sizebytes;
 917         }
 918
 919         blks_reqd_for_file = lldiv(bytes_reqd_for_file, fs->blksz);
 920         if (do_div(bytes_reqd_for_file, fs->blksz) != 0) {
 921                 blks_reqd_for_file++;
 922                 debug("total bytes for a file %u\n", blks_reqd_for_file);
 923         }
 924         blocks_remaining = blks_reqd_for_file;
 925         /* test for available space in partition */
 926         if (le32_to_cpu(fs->sb->free_blocks) < blks_reqd_for_file) {
 927                 printf("Not enough space on partition !!!\n");
 928                 goto fail;
 929         }
 930
 931         inodeno = ext4fs_update_parent_dentry(filename, type);
 932         if (inodeno == -1)
 933                 goto fail;
 934         /* prepare file inode */
 935         inode_buffer = zalloc(fs->inodesz);
 936         if (!inode_buffer)
 937                 goto fail;
 938         file_inode = (struct ext2_inode *)inode_buffer;
 939         file_inode->size = cpu_to_le32(sizebytes);
 940         if (type == FILETYPE_SYMLINK) {
 941                 file_inode->mode = cpu_to_le16(S_IFLNK | S_IRWXU | S_IRWXG |
 942                                                S_IRWXO);
 943                 if (store_link_in_inode) {
 944                         strncpy(file_inode->b.symlink, buffer, sizebytes);
 945                         sizebytes = 0;
 946                 }
 947         } else {
 948                 file_inode->mode = cpu_to_le16(S_IFREG | S_IRWXU | S_IRGRP |
 949                                                S_IROTH | S_IXGRP | S_IXOTH);
 950         }
 951         /* ToDo: Update correct time */
 952         file_inode->mtime = cpu_to_le32(timestamp);
 953         file_inode->atime = cpu_to_le32(timestamp);
 954         file_inode->ctime = cpu_to_le32(timestamp);
 955         file_inode->nlinks = cpu_to_le16(1);
 956
 957         /* Allocate data blocks */
 958         ext4fs_allocate_blocks(file_inode, blocks_remaining,
 959                                &blks_reqd_for_file);
 960         file_inode->blockcnt = cpu_to_le32((blks_reqd_for_file * fs->blksz) >>
 961                                            LOG2_SECTOR_SIZE);
 962
 963         temp_ptr = zalloc(fs->blksz);
 964         if (!temp_ptr)
 965                 goto fail;
 966         ibmap_idx = inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
 967         inodeno--;
 968         bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
 969         itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
 970                         (inodeno % le32_to_cpu(sblock->inodes_per_group)) /
 971                         inodes_per_block;
 972         blkoff = (inodeno % inodes_per_block) * fs->inodesz;
 973         ext4fs_devread((lbaint_t)itable_blkno * fs->sect_perblk, 0, fs->blksz,
 974                        temp_ptr);
 975         if (ext4fs_log_journal(temp_ptr, itable_blkno))
 976                 goto fail;
 977
 978         memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz);
 979         if (ext4fs_put_metadata(temp_ptr, itable_blkno))
 980                 goto fail;
 981         /* copy the file content into data blocks */
 982         if (ext4fs_write_file(file_inode, 0, sizebytes, buffer) == -1) {
 983                 printf("Error in copying content\n");
 984                 /* FIXME: Deallocate data blocks */
 985                 goto fail;
 986         }
 987         ibmap_idx = parent_inodeno / le32_to_cpu(ext4fs_root->sblock.inodes_per_group);
 988         parent_inodeno--;
 989         bgd = ext4fs_get_group_descriptor(fs, ibmap_idx);
 990         parent_itable_blkno = ext4fs_bg_get_inode_table_id(bgd, fs) +
 991             (parent_inodeno %
 992              le32_to_cpu(sblock->inodes_per_group)) / inodes_per_block;
 993         blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz;
 994         if (parent_itable_blkno != itable_blkno) {
 995                 memset(temp_ptr, '\0', fs->blksz);
 996                 ext4fs_devread((lbaint_t)parent_itable_blkno * fs->sect_perblk,
 997                                0, fs->blksz, temp_ptr);
 998                 if (ext4fs_log_journal(temp_ptr, parent_itable_blkno))
 999                         goto fail;
1000
1001                 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
1002                 if (ext4fs_put_metadata(temp_ptr, parent_itable_blkno))
1003                         goto fail;
1004         } else {
1005                 /*
1006                  * If parent and child fall in same inode table block
1007                  * both should be kept in 1 buffer
1008                  */
1009                 memcpy(temp_ptr + blkoff, g_parent_inode, fs->inodesz);
1010                 gd_index--;
1011                 if (ext4fs_put_metadata(temp_ptr, itable_blkno))
1012                         goto fail;
1013         }
1014         ext4fs_update();
1015         ext4fs_deinit();
1016
1017         fs->first_pass_bbmap = 0;
1018         fs->curr_blkno = 0;
1019         fs->first_pass_ibmap = 0;
1020         fs->curr_inode_no = 0;
1021         free(inode_buffer);
1022         free(g_parent_inode);
1023         free(temp_ptr);
1024         g_parent_inode = NULL;
1025
1026         return 0;
1027 fail:
1028         ext4fs_deinit();
1029         free(inode_buffer);
1030         free(g_parent_inode);
1031         free(temp_ptr);
1032         g_parent_inode = NULL;
1033
1034         return -1;
1035 }
1036
1037 int ext4_write_file(const char *filename, void *buf, loff_t offset,
1038                     loff_t len, loff_t *actwrite)
1039 {
1040         int ret;
1041
1042         if (offset != 0) {
1043                 printf("** Cannot support non-zero offset **\n");
1044                 return -1;
1045         }
1046
1047         ret = ext4fs_write(filename, buf, len, FILETYPE_REG);
1048         if (ret) {
1049                 printf("** Error ext4fs_write() **\n");
1050                 goto fail;
1051         }
1052
1053         *actwrite = len;
1054
1055         return 0;
1056
1057 fail:
1058         *actwrite = 0;
1059
1060         return -1;
1061 }
1062
1063 int ext4fs_create_link(const char *target, const char *fname)
1064 {
1065         return ext4fs_write(fname, target, strlen(target), FILETYPE_SYMLINK);
1066 }