Changeset 1c1c736 in mainline

Timestamp:

2011-11-08T13:05:43Z (13 years ago)

Author:

Frantisek Princ <frantisek.princ@…>

Branches:

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

Children:

0f09d4ea

Parents:

e31e56a1

Message:

not functional block allocation + write operation skeleton

Location:

uspace

Files:

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

uspace/lib/ext4/libext4_bitmap.c

@@ -54 +54 @@
 }
 
+static int ext4_bitmap_find_free_bit_and_set(uint8_t *bitmap, uint32_t *index, uint32_t size)
+{
+        uint8_t *pos = bitmap;
+        int i;
+        uint32_t idx = 0;
+
+        while (pos < bitmap + size) {
+                if ((*pos & 255) != 255) {
+                        // free bit found
+                        break;
+                }
+
+                ++pos;
+                idx += 8;
+        }
+
+        if (pos < bitmap + size) {
+
+                for(i = 0; i < 8; ++i) {
+                        if ((*pos & (1 << i)) == 0) {
+                                // free bit found
+                                *pos |= (1 << i);
+                                *index = idx;
+                                return EOK;
+                        }
+
+                        idx++;
+                }
+        }
+
+        return ENOSPC;
+}
+
 int ext4_bitmap_free_block(ext4_filesystem_t *fs, uint32_t block_index)
 {
@@ -93 +126 @@
         bg_ref->dirty = true;
 
+        // TODO change free blocks count in superblock
+
         rc = ext4_filesystem_put_block_group_ref(bg_ref);
         if (rc != EOK) {
@@ -102 +137 @@
 }
 
+int ext4_bitmap_alloc_block(ext4_filesystem_t *fs, ext4_inode_ref_t *inode_ref, uint32_t *fblock)
+{
+        int rc;
+        uint32_t inodes_per_group, block_group, blocks_per_group;
+        ext4_block_group_ref_t *bg_ref;
+        uint32_t bitmap_block;
+        block_t *block;
+        uint32_t rel_block_idx = 0;
+        uint32_t block_size;
+
+        inodes_per_group = ext4_superblock_get_inodes_per_group(fs->superblock);
+        block_group = inode_ref->index / inodes_per_group;
+
+        block_size = ext4_superblock_get_block_size(fs->superblock);
+
+        rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        bitmap_block = ext4_block_group_get_block_bitmap(bg_ref->block_group);
+
+        rc = block_get(&block, fs->device, bitmap_block, 0);
+        if (rc != EOK) {
+                ext4_filesystem_put_block_group_ref(bg_ref);
+                return rc;
+        }
+
+        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
+
+
+
+
+        // TODO decrement superblock & block group free blocks count
+
+        // return
+        blocks_per_group = ext4_superblock_get_blocks_per_group(fs->superblock);
+        *fblock = blocks_per_group * block_group + rel_block_idx;
+        return EOK;
+
+}
 
 /**

uspace/lib/ext4/libext4_bitmap.h

@@ -38 +38 @@
 
 extern int ext4_bitmap_free_block(ext4_filesystem_t *, uint32_t);
-
+extern int ext4_bitmap_alloc_block(ext4_filesystem_t *,
+                ext4_inode_ref_t *, uint32_t *);
 #endif
 

uspace/srv/fs/ext4fs/ext4fs_ops.c

@@ -926 +926 @@
     size_t *wbytes, aoff64_t *nsize)
 {
-        EXT4FS_DBG("not supported");
-
-        // TODO
-        return ENOTSUP;
+        EXT4FS_DBG("");
+
+        int rc;
+        fs_node_t *fn;
+        ext4fs_node_t *enode;
+        ext4_filesystem_t *fs;
+        ext4_inode_ref_t *inode_ref;
+        ipc_callid_t callid;
+        size_t len, bytes, block_size;
+        block_t *write_block;
+        uint32_t fblock, iblock;
+
+        rc = ext4fs_node_get(&fn, service_id, index);
+        if (rc != EOK) {
+                return rc;
+        }
+
+        if (!async_data_write_receive(&callid, &len)) {
+                rc = EINVAL;
+                ext4fs_node_put(fn);
+                async_answer_0(callid, rc);
+                return rc;
+        }
+
+
+        enode = EXT4FS_NODE(fn);
+        inode_ref = enode->inode_ref;
+        fs = enode->instance->filesystem;
+
+        block_size = ext4_superblock_get_block_size(fs->superblock);
+
+        // Prevent writing to more than one block
+        bytes = min(len, block_size - (pos % block_size));
+
+        EXT4FS_DBG("bytes == \%u", bytes);
+
+        iblock =  pos / block_size;
+
+        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);
+        if (rc != EOK) {
+                ext4fs_node_put(fn);
+                async_answer_0(callid, rc);
+                return rc;
+        }
+
+        /*
+        if (flags == BLOCK_FLAGS_NOREAD)
+                memset(b->data, 0, sbi->block_size);
+        */
+
+        async_data_write_finalize(callid, write_block->data + (pos % block_size), bytes);
+        write_block->dirty = true;
+
+        rc = block_put(write_block);
+        if (rc != EOK) {
+                ext4fs_node_put(fn);
+                return rc;
+        }
+
+        /*
+        if (pos + bytes > ino_i->i_size) {
+                ino_i->i_size = pos + bytes;
+                ino_i->dirty = true;
+        }
+        *nsize = ino_i->i_size;
+        *wbytes = bytes;
+        */
+        return ext4fs_node_put(fn);
 }
 
@@ -957 +1032 @@
         if (! ext4_inode_can_truncate(fs->superblock, inode_ref->inode)) {
                 // Unable to truncate
+                ext4fs_node_put(fn);
                 return EINVAL;
         }
@@ -963 +1039 @@
 
         if (old_size == new_size) {
-                rc = EOK;
+                ext4fs_node_put(fn);
+                return EOK;
         } else {
 
@@ -1005 +1082 @@
 
         ext4fs_node_put(fn);
-        return rc;
+
+        return EOK;
 }