Changeset 052e82d in mainline

Timestamp:

2011-11-07T11:50:31Z (13 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

12b4a7f

Parents:

5664cf64

Message:

partially functional truncate operation

Location:

uspace

Files:

• lib/ext4/Makefile (modified) (1 diff)
• lib/ext4/libext4.h (modified) (1 diff)
• lib/ext4/libext4_bitmap.c (added)
• lib/ext4/libext4_bitmap.h (added)
• lib/ext4/libext4_block_group.c (modified) (1 diff)
• lib/ext4/libext4_block_group.h (modified) (1 diff)
• lib/ext4/libext4_filesystem.c (modified) (3 diffs)
• lib/ext4/libext4_filesystem.h (modified) (1 diff)
• lib/ext4/libext4_inode.c (modified) (1 diff)
• lib/ext4/libext4_inode.h (modified) (2 diffs)
• srv/fs/ext4fs/ext4fs_ops.c (modified) (4 diffs)

uspace/lib/ext4/Makefile

@@ -33 +33 @@
 
 SOURCES = \
+        libext4_bitmap.c \
         libext4_block_group.c \
         libext4_directory.c \

uspace/lib/ext4/libext4.h

@@ -34 +34 @@
 #define LIBEXT4_LIBEXT4_H_
 
+#include "libext4_bitmap.h"
 #include "libext4_block_group.h"
 #include "libext4_directory.h"

uspace/lib/ext4/libext4_block_group.c

@@ -63 +63 @@
 }
 
+void ext4_block_group_set_free_blocks_count(ext4_block_group_t *bg, uint32_t value) {
+        bg->free_blocks_count_lo = host2uint16_t_le((value << 16) >> 16);
+        bg->free_blocks_count_hi = host2uint16_t_le(value >> 16);
+}
+
 uint32_t ext4_block_group_get_free_inodes_count(ext4_block_group_t *bg)
 {

uspace/lib/ext4/libext4_block_group.h

@@ -73 +73 @@
 extern uint64_t ext4_block_group_get_inode_table_first_block(ext4_block_group_t *);
 extern uint32_t ext4_block_group_get_free_blocks_count(ext4_block_group_t *);
+extern void ext4_block_group_set_free_blocks_count(ext4_block_group_t *, uint32_t);
 extern uint32_t ext4_block_group_get_free_inodes_count(ext4_block_group_t *);
 extern uint32_t ext4_block_group_get_used_dirs_count(ext4_block_group_t *);

uspace/lib/ext4/libext4_filesystem.c

@@ -251 +251 @@
          */
         newref->index = index+1;
+        newref->dirty = false;
 
         *ref = newref;
@@ -261 +262 @@
 {
         int rc;
+
+        if (ref->dirty) {
+                ref->block->dirty = true;
+        }
 
         rc = block_put(ref->block);
@@ -355 +360 @@
 
 
-int ext4_filesystem_release_inode_block(ext4_filesystem_t *fs, ext4_inode_t *inode, uint32_t iblock)
+int ext4_filesystem_release_inode_block(ext4_filesystem_t *fs,
+                ext4_inode_ref_t *inode_ref, uint32_t iblock)
 {
         int rc;
         uint32_t fblock;
-
-        // TODO handle with extents
-
-        rc = ext4_filesystem_get_inode_data_block_index(fs, inode, iblock, &fblock);
-        if (rc != EOK) {
-                // TODO error
-                return rc;
-        }
-
-        // Sparse file
-        if (fblock == 0) {
-
-                //
-                return EOK;
-        }
-
-
-        // TODO vyhledat policko s ukazatelem a nastavit nulu
-
-
-        // TODO uvolnit blok v bitmape
-
-        // TODO return
-
-
-        return EOK;
+        int i;
+        int level;
+        aoff64_t block_offset_in_level;
+        uint32_t current_block;
+        uint32_t offset_in_block;
+        block_t *block;
+        ext4_inode_t *inode = inode_ref->inode;
+
+        /* TODO handle extents */
+
+        /* Handle simple case when we are dealing with direct reference */
+        if (iblock < EXT4_INODE_DIRECT_BLOCK_COUNT) {
+                EXT4FS_DBG("direct block");
+                fblock = ext4_inode_get_direct_block(inode, (uint32_t)iblock);
+                // Sparse file
+                if (fblock == 0) {
+                        return EOK;
+                }
+
+                ext4_inode_set_direct_block(inode, iblock, 0);
+                return ext4_bitmap_free_block(fs, fblock);
+        } else {
+
+                /* 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]);
+
+                        // Set zero
+                        if (level == 1) {
+                                ((uint32_t*)block->data)[offset_in_block] = host2uint32_t_le(0);
+                                block->dirty = true;
+                        }
+
+                        rc = block_put(block);
+                        if (rc != EOK) {
+                                return rc;
+                        }
+
+                        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;
+
+                if (fblock == 0) {
+                        return EOK;
+                }
+        }
+
+        return ext4_bitmap_free_block(fs, fblock);
+
 }
 

uspace/lib/ext4/libext4_filesystem.h

@@ -63 +63 @@
         ext4_inode_t *, aoff64_t iblock, uint32_t *);
 extern int ext4_filesystem_release_inode_block(ext4_filesystem_t *,
-                ext4_inode_t *, uint32_t);
+                ext4_inode_ref_t *, uint32_t);
 #endif
 

uspace/lib/ext4/libext4_inode.c

@@ -67 +67 @@
                 return ((uint64_t)uint32_t_le2host(inode->size_hi)) << 32 |
                             ((uint64_t)uint32_t_le2host(inode->size_lo));
-                }
+        }
         return uint32_t_le2host(inode->size_lo);
+}
+
+void ext4_inode_set_size(ext4_inode_t *inode, uint64_t value) {
+        inode->size_lo = host2uint32_t_le((value << 32) >> 32);
+        inode->size_hi = host2uint32_t_le(value >> 32);
 }
 

uspace/lib/ext4/libext4_inode.h

@@ -144 +144 @@
         ext4_inode_t *inode;
         uint32_t index; // Index number of this inode
+        bool dirty;
 } ext4_inode_ref_t;
 
@@ -153 +154 @@
 */
 extern uint64_t ext4_inode_get_size(ext4_superblock_t *, ext4_inode_t *);
+extern void ext4_inode_set_size(ext4_inode_t *, uint64_t);
 /*
 extern uint32_t ext4_inode_get_access_time(ext4_inode_t *);

uspace/srv/fs/ext4fs/ext4fs_ops.c

@@ -939 +939 @@
         fs_node_t *fn;
         ext4fs_node_t *enode;
-        ext4_inode_t *inode;
+        ext4_inode_ref_t *inode_ref;
         ext4_filesystem_t* fs;
         aoff64_t old_size;
@@ -951 +951 @@
 
         enode = EXT4FS_NODE(fn);
-        inode = enode->inode_ref->inode;
+        inode_ref = enode->inode_ref;
         fs = enode->instance->filesystem;
 
-        old_size = ext4_inode_get_size(fs->superblock, inode);
+        old_size = ext4_inode_get_size(fs->superblock, inode_ref->inode);
 
         printf("old size = \%llu, new size = \%llu\n", old_size, new_size);
@@ -961 +961 @@
                 rc = EOK;
         } else {
-                /** AAAAAAAAAAAAAAAAAAAA */
 
                 //int rc;
@@ -989 +988 @@
                 }
 
-                // TODO dirty add to inode_ref_t
-                //ino_i->dirty = true;
+                inode_ref->dirty = true;
 
                 for (i = 0; i< blocks_count; ++i) {
                         // TODO check retval
-                        ext4_filesystem_release_inode_block(fs, inode, total_blocks - i);
-                        // TODO subtract inode->size
-                }
-
-                /** BBBBBBBBBBBBBBBBBBBB */
+                        ext4_filesystem_release_inode_block(fs, inode_ref, total_blocks - i);
+                }
+
+                ext4_inode_set_size(inode_ref->inode, new_size);
 
         }