Changeset 35f48f2 in mainline

Timestamp:

2011-11-09T08:48:06Z (13 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

1e65444

Parents:

0f09d4ea

Message:

succesful writing (only for direct block)

Location:

uspace

Files:

• lib/ext4/libext4_bitmap.c (modified) (1 diff)
• lib/ext4/libext4_filesystem.c (modified) (1 diff)
• lib/ext4/libext4_filesystem.h (modified) (1 diff)
• srv/fs/ext4fs/ext4fs_ops.c (modified) (7 diffs)

uspace/lib/ext4/libext4_bitmap.c

@@ -167 +167 @@
         rc = ext4_bitmap_find_free_bit_and_set(block->data, &rel_block_idx, block_size);
 
-        // if ENOSPC - try next block group - try next block groups
 
+        if (rc != EOK) {
+                EXT4FS_DBG("no block found");
+                // TODO if ENOSPC - try next block group - try next block groups
+        }
 
+        // TODO decrement superblock free blocks count
+        //uint32_t sb_free_blocks = ext4_superblock_get_free_blocks_count(sb);
+        //sb_free_blocks--;
+        //ext4_superblock_set_free_blocks_count(sb, sb_free_blocks);
 
-
-        // TODO decrement superblock & block group free blocks count
+        uint32_t bg_free_blocks = ext4_block_group_get_free_blocks_count(bg_ref->block_group);
+        bg_free_blocks++;
+        ext4_block_group_set_free_blocks_count(bg_ref->block_group, bg_free_blocks);
+        bg_ref->dirty = true;
 
         // return

uspace/lib/ext4/libext4_filesystem.c

@@ -363 +363 @@
 
 
+int ext4_filesystem_set_inode_data_block_index(ext4_filesystem_t *fs,
+                ext4_inode_t *inode, aoff64_t iblock, uint32_t fblock)
+{
+
+//      int rc;
+//      uint32_t offset_in_block;
+//      uint32_t current_block;
+//      aoff64_t block_offset_in_level;
+//      int i;
+//      int level;
+//      block_t *block;
+
+        /* Handle inode using extents */
+        if (ext4_superblock_has_feature_compatible(fs->superblock, EXT4_FEATURE_INCOMPAT_EXTENTS) &&
+                        ext4_inode_has_flag(inode, EXT4_INODE_FLAG_EXTENTS)) {
+                // TODO
+                return ENOTSUP;
+
+        }
+
+        /* Handle simple case when we are dealing with direct reference */
+        if (iblock < EXT4_INODE_DIRECT_BLOCK_COUNT) {
+                ext4_inode_set_direct_block(inode, (uint32_t)iblock, fblock);
+                return EOK;
+        }
+
+//      /* Determine the indirection level needed to get the desired block */
+//      level = -1;
+//      for (i = 1; i < 4; i++) {
+//              if (iblock < fs->inode_block_limits[i]) {
+//                      level = i;
+//                      break;
+//              }
+//      }
+//
+//      if (level == -1) {
+//              return EIO;
+//      }
+//
+//      /* Compute offsets for the topmost level */
+//      block_offset_in_level = iblock - fs->inode_block_limits[level-1];
+//      current_block = ext4_inode_get_indirect_block(inode, level-1);
+//      offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
+//
+//      /* Navigate through other levels, until we find the block number
+//       * or find null reference meaning we are dealing with sparse file
+//       */
+//      while (level > 0) {
+//              rc = block_get(&block, fs->device, current_block, 0);
+//              if (rc != EOK) {
+//                      return rc;
+//              }
+//
+//              current_block = uint32_t_le2host(((uint32_t*)block->data)[offset_in_block]);
+//
+//              rc = block_put(block);
+//              if (rc != EOK) {
+//                      return rc;
+//              }
+//
+//              if (current_block == 0) {
+//                      /* This is a sparse file */
+//                      *fblock = 0;
+//                      return EOK;
+//              }
+//
+//              level -= 1;
+//
+//              /* If we are on the last level, break here as
+//               * there is no next level to visit
+//               */
+//              if (level == 0) {
+//                      break;
+//              }
+//
+//              /* Visit the next level */
+//              block_offset_in_level %= fs->inode_blocks_per_level[level];
+//              offset_in_block = block_offset_in_level / fs->inode_blocks_per_level[level-1];
+//      }
+//
+//      *fblock = current_block;
+//
+//      return EOK;
+//
+//
+
+        return EOK;
+}
+
 int ext4_filesystem_release_inode_block(ext4_filesystem_t *fs,
                 ext4_inode_ref_t *inode_ref, uint32_t iblock)

uspace/lib/ext4/libext4_filesystem.h

@@ -62 +62 @@
 extern int ext4_filesystem_get_inode_data_block_index(ext4_filesystem_t *,
         ext4_inode_t *, aoff64_t iblock, uint32_t *);
+extern int ext4_filesystem_set_inode_data_block_index(ext4_filesystem_t *,
+                ext4_inode_t *, aoff64_t, uint32_t);
 extern int ext4_filesystem_release_inode_block(ext4_filesystem_t *,
                 ext4_inode_ref_t *, uint32_t);

uspace/srv/fs/ext4fs/ext4fs_ops.c

@@ -929 +929 @@
 
         int rc;
+        int flags = BLOCK_FLAGS_NONE;
         fs_node_t *fn;
         ext4fs_node_t *enode;
@@ -937 +938 @@
         block_t *write_block;
         uint32_t fblock, iblock;
+        uint32_t old_inode_size;
 
         rc = ext4fs_node_get(&fn, service_id, index);
@@ -960 +962 @@
         bytes = min(len, block_size - (pos % block_size));
 
+        if (bytes == block_size) {
+                flags = BLOCK_FLAGS_NOREAD;
+        }
+
         EXT4FS_DBG("bytes == \%u", bytes);
 
@@ -966 +972 @@
         rc = ext4_filesystem_get_inode_data_block_index(fs, inode_ref->inode, iblock, &fblock);
 
-
-        // TODO allocation if fblock == 0
         if (fblock == 0) {
                 EXT4FS_DBG("Allocate block !!!");
-
-                return ENOTSUP;
-        }
-
-        // TODO flags
-        rc = block_get(&write_block, service_id, fblock, 0);
+                rc =  ext4_bitmap_alloc_block(fs, inode_ref, &fblock);
+                if (rc != EOK) {
+                        ext4fs_node_put(fn);
+                        async_answer_0(callid, rc);
+                        return rc;
+                }
+
+                ext4_filesystem_set_inode_data_block_index(fs, inode_ref->inode, iblock, fblock);
+                inode_ref->dirty = true;
+
+                flags = BLOCK_FLAGS_NOREAD;
+
+                EXT4FS_DBG("block \%u allocated", fblock);
+        }
+
+        rc = block_get(&write_block, service_id, fblock, flags);
         if (rc != EOK) {
                 ext4fs_node_put(fn);
@@ -982 +996 @@
         }
 
-        /*
-        if (flags == BLOCK_FLAGS_NOREAD)
-                memset(b->data, 0, sbi->block_size);
-        */
-
-        async_data_write_finalize(callid, write_block->data + (pos % block_size), bytes);
+        EXT4FS_DBG("block loaded");
+
+        if (flags == BLOCK_FLAGS_NOREAD) {
+                EXT4FS_DBG("fill block with zeros");
+                memset(write_block->data, 0, block_size);
+        }
+
+        rc = async_data_write_finalize(callid, write_block->data + (pos % block_size), bytes);
+        if (rc != EOK) {
+                EXT4FS_DBG("error in write finalize \%d", rc);
+        }
+
+        char *data = write_block->data + (pos % block_size);
+        for (uint32_t x = 0; x < bytes; ++x) {
+                printf("%c", data[x]);
+        }
+        printf("\n");
+
         write_block->dirty = true;
 
@@ -996 +1022 @@
         }
 
-        /*
-        if (pos + bytes > ino_i->i_size) {
-                ino_i->i_size = pos + bytes;
-                ino_i->dirty = true;
-        }
-        *nsize = ino_i->i_size;
+        EXT4FS_DBG("writing finished");
+
+        old_inode_size = ext4_inode_get_size(fs->superblock, inode_ref->inode);
+        if (pos + bytes > old_inode_size) {
+                ext4_inode_set_size(inode_ref->inode, pos + bytes);
+                inode_ref->dirty = true;
+        }
+
+        *nsize = ext4_inode_get_size(fs->superblock, inode_ref->inode);
         *wbytes = bytes;
-        */
+
         return ext4fs_node_put(fn);
 }
@@ -1105 +1134 @@
 static int ext4fs_sync(service_id_t service_id, fs_index_t index)
 {
-        EXT4FS_DBG("not supported");
-
-        // TODO
-        return ENOTSUP;
+        EXT4FS_DBG("");
+
+        int rc;
+        fs_node_t *fn;
+        ext4fs_node_t *enode;
+
+        rc = ext4fs_node_get(&fn, service_id, index);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        enode = EXT4FS_NODE(fn);
+        enode->inode_ref->dirty = true;
+
+        return ext4fs_node_put(fn);
 }