Changeset 12b4a7f in mainline

Timestamp:

2011-11-07T16:23:30Z (13 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

43a9968

Parents:

052e82d

Message:

functional truncate operation (only to lower size actually), except extent files

Location:

uspace

Files:

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

uspace/lib/ext4/libext4_bitmap.c

@@ -33 +33 @@
 /**
  * @file        libext4_bitmap.c
- * @brief       TODO
+ * @brief       Ext4 bitmap (block & inode) operations.
  */
 
@@ -91 +91 @@
         free_blocks++;
         ext4_block_group_set_free_blocks_count(bg_ref->block_group, free_blocks);
+        bg_ref->dirty = true;
 
         rc = ext4_filesystem_put_block_group_ref(bg_ref);

uspace/lib/ext4/libext4_block_group.h

@@ -65 +65 @@
         block_t *block; // Reference to a block containing this block group descr
         ext4_block_group_t *block_group;
+        bool dirty;
 } ext4_block_group_ref_t;
 

uspace/lib/ext4/libext4_filesystem.c

@@ -152 +152 @@
         }
 
-        //EXT4FS_DBG("desc size = \%u", (uint32_t)ext4_superblock_get_desc_size(fs->superblock));
-
         descriptors_per_block = ext4_superblock_get_block_size(fs->superblock)
             / ext4_superblock_get_desc_size(fs->superblock);
@@ -171 +169 @@
 
         newref->block_group = newref->block->data + offset;
+        newref->dirty = false;
 
         *ref = newref;
@@ -180 +179 @@
 {
         int rc;
+
+        if (ref->dirty) {
+                ref->block->dirty = true;
+        }
 
         rc = block_put(ref->block);
@@ -375 +378 @@
         /* 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);
+                fblock = ext4_inode_get_direct_block(inode, iblock);
                 // Sparse file
                 if (fblock == 0) {
@@ -386 +389 @@
                 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);
+        }
+
+
+        /* 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];
-
-                /* 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;
-                }
+        }
+
+        fblock = current_block;
+
+        if (fblock == 0) {
+                return EOK;
         }
 

uspace/lib/ext4/libext4_inode.c

@@ -193 +193 @@
 }
 
+bool ext4_inode_can_truncate(ext4_inode_t *inode)
+{
+         if (ext4_inode_has_flag(inode, EXT4_INODE_FLAG_APPEND)
+                         || ext4_inode_has_flag(inode, EXT4_INODE_FLAG_IMMUTABLE)) {
+                 return false;
+         }
+
+
+         if (ext4_inode_get_mode(inode) == EXT4_INODE_MODE_FILE
+                         || ext4_inode_get_mode(inode) == EXT4_INODE_MODE_DIRECTORY) {
+                 return true;
+         }
+
+         return false;
+}
+
 /**
  * @}

uspace/lib/ext4/libext4_inode.h

@@ -187 +187 @@
 extern ext4_extent_header_t * ext4_inode_get_extent_header(ext4_inode_t *);
 extern bool ext4_inode_has_flag(ext4_inode_t *, uint32_t);
+extern bool ext4_inode_can_truncate(ext4_inode_t *);
 
 #endif

uspace/srv/fs/ext4fs/ext4fs_ops.c

@@ -954 +954 @@
         fs = enode->instance->filesystem;
 
+
+        if (! ext4_inode_can_truncate(inode_ref->inode)) {
+                // Unable to truncate
+                return EINVAL;
+        }
+
         old_size = ext4_inode_get_size(fs->superblock, inode_ref->inode);
-
-        printf("old size = \%llu, new size = \%llu\n", old_size, new_size);
 
         if (old_size == new_size) {
@@ -962 +966 @@
         } else {
 
-                //int rc;
                 uint32_t block_size;
                 uint32_t blocks_count, total_blocks;
@@ -970 +973 @@
 
                 if (old_size < new_size) {
-                        // TODO don't return immediately
-                        EXT4FS_DBG("expand the file");
+                        // Currently not supported to expand the file
+                        // TODO
+                        EXT4FS_DBG("trying to expand the file");
                         return EINVAL;
                 }
-
-                EXT4FS_DBG("cut the end of the file !");
 
                 size_diff = old_size - new_size;
@@ -990 +992 @@
                 inode_ref->dirty = true;
 
-                for (i = 0; i< blocks_count; ++i) {
+                // starting from 1 because of logical blocks are numbered from 0
+                for (i = 1; i <= blocks_count; ++i) {
                         // TODO check retval
+                        // TODO decrement inode->blocks_count
+
                         ext4_filesystem_release_inode_block(fs, inode_ref, total_blocks - i);
                 }