Changeset 304faab in mainline

Timestamp:

2012-01-24T09:24:14Z (13 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

786bd56

Parents:

08cc26b

Message:

Very simple allocation algorithm

Location:

uspace

Files:

• lib/ext4/libext4_filesystem.c (modified) (3 diffs)
• lib/ext4/libext4_filesystem.h (modified) (1 diff)
• lib/ext4/libext4_ialloc.c (modified) (2 diffs)
• lib/ext4/libext4_ialloc.h (modified) (1 diff)
• srv/fs/ext4fs/ext4fs_ops.c (modified) (1 diff)

uspace/lib/ext4/libext4_filesystem.c

@@ -266 +266 @@
 }
 
-int ext4_filesystem_alloc_inode(ext4_filesystem_t *fs, ext4_inode_ref_t **inode_ref)
-{
-        // TODO
-        return EOK;
-}
-
-int ext4_filesystem_init_inode(ext4_filesystem_t *fs, ext4_inode_ref_t *inode_ref, int flags)
-{
-        ext4_inode_t *inode = inode_ref->inode;
-
+int ext4_filesystem_alloc_inode(ext4_filesystem_t *fs,
+                ext4_inode_ref_t **inode_ref, int flags)
+{
+        int rc;
+
+        bool is_dir = false;
         if (flags & L_DIRECTORY) {
+                is_dir = true;
+        }
+
+        // allocate inode
+        uint32_t index;
+        rc = ext4_ialloc_alloc_inode(fs, &index, is_dir);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        // TODO extents, dir_index etc...
+        rc = ext4_filesystem_get_inode_ref(fs, index, inode_ref);
+        if (rc != EOK) {
+                ext4_ialloc_free_inode(fs, index, is_dir);
+                return rc;
+        }
+
+        // init inode
+        ext4_inode_t *inode = (*inode_ref)->inode;
+
+        if (is_dir) {
                 ext4_inode_set_mode(fs->superblock, inode, EXT4_INODE_MODE_DIRECTORY);
                 ext4_inode_set_links_count(inode, 1); // '.' entry
@@ -299 +316 @@
         }
 
+        (*inode_ref)->dirty = true;
+
         return EOK;
 }
@@ -408 +427 @@
 
         // Free inode
-        rc = ext4_ialloc_free_inode(fs, inode_ref);
+        if (ext4_inode_is_type(fs->superblock, inode_ref->inode,
+                        EXT4_INODE_MODE_DIRECTORY)) {
+                rc = ext4_ialloc_free_inode(fs, inode_ref->index, true);
+        } else {
+                rc = ext4_ialloc_free_inode(fs, inode_ref->index, false);
+        }
         if (rc != EOK) {
                 return rc;

uspace/lib/ext4/libext4_filesystem.h

@@ -61 +61 @@
                 ext4_inode_ref_t **);
 extern int ext4_filesystem_put_inode_ref(ext4_inode_ref_t *);
-extern int ext4_filesystem_alloc_inode(ext4_filesystem_t *, ext4_inode_ref_t **);
-extern int ext4_filesystem_init_inode(ext4_filesystem_t *, ext4_inode_ref_t *, int);
+extern int ext4_filesystem_alloc_inode(ext4_filesystem_t *,
+                ext4_inode_ref_t **, int);
 extern int ext4_filesystem_free_inode(ext4_filesystem_t *, ext4_inode_ref_t *);
 extern int ext4_filesystem_truncate_inode(ext4_filesystem_t *,

uspace/lib/ext4/libext4_ialloc.c

@@ -56 +56 @@
 
 
-int ext4_ialloc_free_inode(ext4_filesystem_t *fs, ext4_inode_ref_t *inode_ref)
+int ext4_ialloc_free_inode(ext4_filesystem_t *fs, uint32_t index, bool is_dir)
 {
         int rc;
 
-        uint32_t block_group = ext4_ialloc_get_bgid_of_inode(
-                        fs->superblock, inode_ref->index);
+        ext4_superblock_t *sb = fs->superblock;
+
+        uint32_t block_group = ext4_ialloc_get_bgid_of_inode(sb, index);
 
         ext4_block_group_ref_t *bg_ref;
         rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
         if (rc != EOK) {
-                EXT4FS_DBG("error in loading bg_ref \%d", rc);
                 return rc;
         }
 
         uint32_t bitmap_block_addr = ext4_block_group_get_inode_bitmap(
-                        bg_ref->block_group, fs->superblock);
+                        bg_ref->block_group, sb);
         block_t *bitmap_block;
-        rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0);
-        if (rc != EOK) {
-                EXT4FS_DBG("error in loading bitmap \%d", rc);
-                return rc;
-        }
-
-        uint32_t index_in_group = ext4_ialloc_inode2index_in_group(
-                                fs->superblock, inode_ref->index);
+        rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, BLOCK_FLAGS_NONE);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        uint32_t index_in_group = ext4_ialloc_inode2index_in_group(sb, index);
         ext4_bitmap_free_bit(bitmap_block->data, index_in_group);
         bitmap_block->dirty = true;
@@ -88 +86 @@
                 // Error in saving bitmap
                 ext4_filesystem_put_block_group_ref(bg_ref);
-                EXT4FS_DBG("error in saving bitmap \%d", rc);
-                return rc;
-        }
-
-        // if inode is directory, decrement directories count
-        if (ext4_inode_is_type(fs->superblock, inode_ref->inode, EXT4_INODE_MODE_DIRECTORY)) {
+                return rc;
+        }
+
+        // if inode is directory, decrement used directories count
+        if (is_dir) {
                 uint32_t bg_used_dirs = ext4_block_group_get_used_dirs_count(
-                        bg_ref->block_group, fs->superblock);
+                        bg_ref->block_group, sb);
                 bg_used_dirs--;
                 ext4_block_group_set_used_dirs_count(
-                                bg_ref->block_group, fs->superblock, bg_used_dirs);
-        }
-
-        // Update superblock free inodes count
-        uint32_t sb_free_inodes = ext4_superblock_get_free_inodes_count(fs->superblock);
-        sb_free_inodes++;
-        ext4_superblock_set_free_inodes_count(fs->superblock, sb_free_inodes);
+                                bg_ref->block_group, sb, bg_used_dirs);
+        }
 
         // Update block group free inodes count
         uint32_t free_inodes = ext4_block_group_get_free_inodes_count(
-                        bg_ref->block_group, fs->superblock);
+                        bg_ref->block_group, sb);
         free_inodes++;
         ext4_block_group_set_free_inodes_count(bg_ref->block_group,
-                        fs->superblock, free_inodes);
+                        sb, free_inodes);
         bg_ref->dirty = true;
 
         rc = ext4_filesystem_put_block_group_ref(bg_ref);
         if (rc != EOK) {
-                EXT4FS_DBG("error in saving bg_ref \%d", rc);
-                // TODO error
-                return rc;
-        }
+                return rc;
+        }
+
+        // Update superblock free inodes count
+        uint32_t sb_free_inodes = ext4_superblock_get_free_inodes_count(sb);
+        sb_free_inodes++;
+        ext4_superblock_set_free_inodes_count(sb, sb_free_inodes);
 
         return EOK;
 }
 
+int ext4_ialloc_alloc_inode(ext4_filesystem_t *fs, uint32_t *index, bool is_dir)
+{
+        int rc;
+
+        ext4_superblock_t *sb = fs->superblock;
+
+        uint32_t bgid = 0;
+        uint32_t bg_count = ext4_superblock_get_block_group_count(sb);
+
+        while (bgid < bg_count) {
+
+                ext4_block_group_ref_t *bg_ref;
+                rc = ext4_filesystem_get_block_group_ref(fs, bgid, &bg_ref);
+                if (rc != EOK) {
+                        return rc;
+                }
+                ext4_block_group_t *bg = bg_ref->block_group;
+
+                uint32_t free_blocks = ext4_block_group_get_free_blocks_count(bg, sb);
+                uint32_t free_inodes = ext4_block_group_get_free_inodes_count(bg, sb);
+                uint32_t used_dirs = ext4_block_group_get_used_dirs_count(bg, sb);
+
+                if ((free_inodes > 0) && (free_blocks > 0)) {
+
+                        uint32_t bitmap_block_addr =  ext4_block_group_get_block_bitmap(
+                                        bg_ref->block_group, sb);
+
+                        block_t *bitmap_block;
+                        rc = block_get(&bitmap_block, fs->device,
+                                        bitmap_block_addr, BLOCK_FLAGS_NONE);
+                        if (rc != EOK) {
+                                return rc;
+                        }
+
+                        // Alloc bit
+                        uint32_t inodes_in_group = ext4_superblock_get_inodes_in_group(sb, bgid);
+                        rc = ext4_bitmap_find_free_bit_and_set(bitmap_block->data, 0, index, inodes_in_group);
+                        if (rc == ENOSPC) {
+                                block_put(bitmap_block);
+                                ext4_filesystem_put_block_group_ref(bg_ref);
+                                continue;
+                        }
+
+                        bitmap_block->dirty = true;
+
+                        rc = block_put(bitmap_block);
+                        if (rc != EOK) {
+                                return rc;
+                        }
+
+                        // Modify filesystem counters
+                        free_inodes--;
+                        ext4_block_group_set_free_inodes_count(bg, sb, free_inodes);
+
+                        if (is_dir) {
+                                used_dirs--;
+                                ext4_block_group_set_used_dirs_count(bg, sb, used_dirs);
+                        }
+
+                        bg_ref->dirty = true;
+
+                        rc = ext4_filesystem_put_block_group_ref(bg_ref);
+                        if (rc != EOK) {
+                                // TODO
+                        }
+
+                        uint32_t sb_free_inodes = ext4_superblock_get_free_inodes_count(sb);
+                        sb_free_inodes--;
+                        ext4_superblock_set_free_inodes_count(sb, sb_free_inodes);
+
+                        return EOK;
+
+                } else {
+                        // Not modified
+                        ext4_filesystem_put_block_group_ref(bg_ref);
+                }
+
+        }
+
+        return ENOSPC;
+}
 
 /**

uspace/lib/ext4/libext4_ialloc.h

@@ -37 +37 @@
 #include "libext4_inode.h"
 
-extern int ext4_ialloc_free_inode(ext4_filesystem_t *, ext4_inode_ref_t *);
-
+extern int ext4_ialloc_free_inode(ext4_filesystem_t *, uint32_t, bool);
+extern int ext4_ialloc_alloc_inode(ext4_filesystem_t *, uint32_t *, bool);
 #endif
 

uspace/srv/fs/ext4fs/ext4fs_ops.c

@@ -394 +394 @@
 
         ext4_inode_ref_t *inode_ref;
-        rc = ext4_filesystem_alloc_inode(inst->filesystem, &inode_ref);
+        rc = ext4_filesystem_alloc_inode(inst->filesystem, &inode_ref, flags);
         if (rc != EOK) {
                 free(enode);
                 free(fs_node);
-                return rc;
-        }
-
-        EXT4FS_DBG("inode allocated");
-        // TODO
-        return ENOTSUP;
-
-        rc = ext4_filesystem_init_inode(inst->filesystem, inode_ref, flags);
-        if (rc != EOK) {
-                free(enode);
-                free(fs_node);
-                ext4_filesystem_free_inode(inst->filesystem, inode_ref);
                 return rc;
         }