Changes in uspace/lib/ext4/src/filesystem.c [b7fd2a0:395df52] in mainline

File:

• uspace/lib/ext4/src/filesystem.c (modified) (41 diffs)

uspace/lib/ext4/src/filesystem.c

@@ -54 +54 @@
 #include "ext4/superblock.h"
 
-static errno_t ext4_filesystem_check_features(ext4_filesystem_t *, bool *);
+static int ext4_filesystem_check_features(ext4_filesystem_t *, bool *);
 
 /** Initialize filesystem for opening.
@@ -67 +67 @@
  *
  */
-static errno_t ext4_filesystem_init(ext4_filesystem_t *fs, service_id_t service_id,
+static int ext4_filesystem_init(ext4_filesystem_t *fs, service_id_t service_id,
     enum cache_mode cmode)
 {
-        errno_t rc;
+        int rc;
         ext4_superblock_t *temp_superblock = NULL;
 
@@ -161 +161 @@
  * @param service_id Block device to probe
  *
- * @return EOK or an error code.
- *
- */
-errno_t ext4_filesystem_probe(service_id_t service_id)
+ * @return EOK or negative error code.
+ *
+ */
+int ext4_filesystem_probe(service_id_t service_id)
 {
         ext4_filesystem_t *fs = NULL;
-        errno_t rc;
+        int rc;
 
         fs = calloc(1, sizeof(ext4_filesystem_t));
@@ -195 +195 @@
  *
  */
-errno_t ext4_filesystem_open(ext4_instance_t *inst, service_id_t service_id,
+int ext4_filesystem_open(ext4_instance_t *inst, service_id_t service_id,
     enum cache_mode cmode, aoff64_t *size, ext4_filesystem_t **rfs)
 {
         ext4_filesystem_t *fs = NULL;
         fs_node_t *root_node = NULL;
-        errno_t rc;
+        int rc;
 
         fs = calloc(1, sizeof(ext4_filesystem_t));
@@ -252 +252 @@
  * @param fs Filesystem to be destroyed
  *
- * @return EOK or an error code. On error the state of the file
+ * @return EOK or negative error code. On error the state of the file
  *         system is unchanged.
  *
  */
-errno_t ext4_filesystem_close(ext4_filesystem_t *fs)
+int ext4_filesystem_close(ext4_filesystem_t *fs)
 {
         /* Write the superblock to the device */
         ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_VALID_FS);
-        errno_t rc = ext4_superblock_write_direct(fs->device, fs->superblock);
+        int rc = ext4_superblock_write_direct(fs->device, fs->superblock);
         if (rc != EOK)
                 return rc;
@@ -281 +281 @@
  *
  */
-static errno_t ext4_filesystem_check_features(ext4_filesystem_t *fs,
+static int ext4_filesystem_check_features(ext4_filesystem_t *fs,
     bool *read_only)
 {
@@ -380 +380 @@
  *
  */
-static errno_t ext4_filesystem_init_block_bitmap(ext4_block_group_ref_t *bg_ref)
+static int ext4_filesystem_init_block_bitmap(ext4_block_group_ref_t *bg_ref)
 {
         uint64_t itb;
@@ -394 +394 @@
         
         block_t *bitmap_block;
-        errno_t rc = block_get(&bitmap_block, bg_ref->fs->device,
+        int rc = block_get(&bitmap_block, bg_ref->fs->device,
             bitmap_block_addr, BLOCK_FLAGS_NOREAD);
         if (rc != EOK)
@@ -451 +451 @@
  *
  */
-static errno_t ext4_filesystem_init_inode_bitmap(ext4_block_group_ref_t *bg_ref)
+static int ext4_filesystem_init_inode_bitmap(ext4_block_group_ref_t *bg_ref)
 {
         /* Load bitmap */
@@ -458 +458 @@
         block_t *bitmap_block;
         
-        errno_t rc = block_get(&bitmap_block, bg_ref->fs->device,
+        int rc = block_get(&bitmap_block, bg_ref->fs->device,
             bitmap_block_addr, BLOCK_FLAGS_NOREAD);
         if (rc != EOK)
@@ -494 +494 @@
  *
  */
-static errno_t ext4_filesystem_init_inode_table(ext4_block_group_ref_t *bg_ref)
+static int ext4_filesystem_init_inode_table(ext4_block_group_ref_t *bg_ref)
 {
         ext4_superblock_t *sb = bg_ref->fs->superblock;
@@ -519 +519 @@
         for (uint32_t fblock = first_block; fblock <= last_block; ++fblock) {
                 block_t *block;
-                errno_t rc = block_get(&block, bg_ref->fs->device, fblock,
+                int rc = block_get(&block, bg_ref->fs->device, fblock,
                     BLOCK_FLAGS_NOREAD);
                 if (rc != EOK)
@@ -544 +544 @@
  *
  */
-errno_t ext4_filesystem_get_block_group_ref(ext4_filesystem_t *fs, uint32_t bgid,
+int ext4_filesystem_get_block_group_ref(ext4_filesystem_t *fs, uint32_t bgid,
     ext4_block_group_ref_t **ref)
 {
@@ -568 +568 @@
         
         /* Load block with descriptors */
-        errno_t rc = block_get(&newref->block, fs->device, block_id, 0);
+        int rc = block_get(&newref->block, fs->device, block_id, 0);
         if (rc != EOK) {
                 free(newref);
@@ -804 +804 @@
  *
  */
-errno_t ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *ref)
+int ext4_filesystem_put_block_group_ref(ext4_block_group_ref_t *ref)
 {
         /* Check if reference modified */
@@ -819 +819 @@
         
         /* Put back block, that contains block group descriptor */
-        errno_t rc = block_put(ref->block);
+        int rc = block_put(ref->block);
         free(ref);
         
@@ -834 +834 @@
  *
  */
-errno_t ext4_filesystem_get_inode_ref(ext4_filesystem_t *fs, uint32_t index,
+int ext4_filesystem_get_inode_ref(ext4_filesystem_t *fs, uint32_t index,
     ext4_inode_ref_t **ref)
 {
@@ -857 +857 @@
         /* Load block group, where i-node is located */
         ext4_block_group_ref_t *bg_ref;
-        errno_t rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
+        int rc = ext4_filesystem_get_block_group_ref(fs, block_group, &bg_ref);
         if (rc != EOK) {
                 free(newref);
@@ -909 +909 @@
  *
  */
-errno_t ext4_filesystem_put_inode_ref(ext4_inode_ref_t *ref)
+int ext4_filesystem_put_inode_ref(ext4_inode_ref_t *ref)
 {
         /* Check if reference modified */
@@ -918 +918 @@
         
         /* Put back block, that contains i-node */
-        errno_t rc = block_put(ref->block);
+        int rc = block_put(ref->block);
         free(ref);
         
@@ -933 +933 @@
  *
  */
-errno_t ext4_filesystem_alloc_inode(ext4_filesystem_t *fs,
+int ext4_filesystem_alloc_inode(ext4_filesystem_t *fs,
     ext4_inode_ref_t **inode_ref, int flags)
 {
@@ -943 +943 @@
         /* Allocate inode by allocation algorithm */
         uint32_t index;
-        errno_t rc = ext4_ialloc_alloc_inode(fs, &index, is_dir);
+        int rc = ext4_ialloc_alloc_inode(fs, &index, is_dir);
         if (rc != EOK)
                 return rc;
@@ -1025 +1025 @@
  *
  */
-errno_t ext4_filesystem_free_inode(ext4_inode_ref_t *inode_ref)
+int ext4_filesystem_free_inode(ext4_inode_ref_t *inode_ref)
 {
         ext4_filesystem_t *fs = inode_ref->fs;
@@ -1042 +1042 @@
         uint32_t fblock = ext4_inode_get_indirect_block(inode_ref->inode, 0);
         if (fblock != 0) {
-                errno_t rc = ext4_balloc_free_block(inode_ref, fblock);
+                int rc = ext4_balloc_free_block(inode_ref, fblock);
                 if (rc != EOK)
                         return rc;
@@ -1056 +1056 @@
         fblock = ext4_inode_get_indirect_block(inode_ref->inode, 1);
         if (fblock != 0) {
-                errno_t rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
+                int rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
                 if (rc != EOK)
                         return rc;
@@ -1088 +1088 @@
         fblock = ext4_inode_get_indirect_block(inode_ref->inode, 2);
         if (fblock != 0) {
-                errno_t rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
+                int rc = block_get(&block, fs->device, fblock, BLOCK_FLAGS_NONE);
                 if (rc != EOK)
                         return rc;
@@ -1153 +1153 @@
             inode_ref->inode, fs->superblock);
         if (xattr_block) {
-                errno_t rc = ext4_balloc_free_block(inode_ref, xattr_block);
+                int rc = ext4_balloc_free_block(inode_ref, xattr_block);
                 if (rc != EOK)
                         return rc;
@@ -1161 +1161 @@
         
         /* Free inode by allocator */
-        errno_t rc;
+        int rc;
         if (ext4_inode_is_type(fs->superblock, inode_ref->inode,
             EXT4_INODE_MODE_DIRECTORY))
@@ -1179 +1179 @@
  *
  */
-errno_t ext4_filesystem_truncate_inode(ext4_inode_ref_t *inode_ref,
+int ext4_filesystem_truncate_inode(ext4_inode_ref_t *inode_ref,
     aoff64_t new_size)
 {
@@ -1212 +1212 @@
             (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) {
                 /* Extents require special operation */
-                errno_t rc = ext4_extent_release_blocks_from(inode_ref,
+                int rc = ext4_extent_release_blocks_from(inode_ref,
                     old_blocks_count - diff_blocks_count);
                 if (rc != EOK)
@@ -1221 +1221 @@
                 /* Starting from 1 because of logical blocks are numbered from 0 */
                 for (uint32_t i = 1; i <= diff_blocks_count; ++i) {
-                        errno_t rc = ext4_filesystem_release_inode_block(inode_ref,
+                        int rc = ext4_filesystem_release_inode_block(inode_ref,
                             old_blocks_count - i);
                         if (rc != EOK)
@@ -1244 +1244 @@
  *
  */
-errno_t ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *inode_ref,
+int ext4_filesystem_get_inode_data_block_index(ext4_inode_ref_t *inode_ref,
     aoff64_t iblock, uint32_t *fblock)
 {
@@ -1261 +1261 @@
             EXT4_FEATURE_INCOMPAT_EXTENTS)) &&
             (ext4_inode_has_flag(inode_ref->inode, EXT4_INODE_FLAG_EXTENTS))) {
-                errno_t rc = ext4_extent_find_block(inode_ref, iblock, &current_block);
+                int rc = ext4_extent_find_block(inode_ref, iblock, &current_block);
                 if (rc != EOK)
                         return rc;
@@ -1311 +1311 @@
         while (level > 0) {
                 /* Load indirect block */
-                errno_t rc = block_get(&block, fs->device, current_block, 0);
+                int rc = block_get(&block, fs->device, current_block, 0);
                 if (rc != EOK)
                         return rc;
@@ -1357 +1357 @@
  *
  */
-errno_t ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *inode_ref,
+int ext4_filesystem_set_inode_data_block_index(ext4_inode_ref_t *inode_ref,
     aoff64_t iblock, uint32_t fblock)
 {
@@ -1407 +1407 @@
         if (current_block == 0) {
                 /* Allocate new indirect block */
-                errno_t rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr);
+                int rc = ext4_balloc_alloc_block(inode_ref, &new_block_addr);
                 if (rc != EOK)
                         return rc;
@@ -1441 +1441 @@
          */
         while (level > 0) {
-                errno_t rc = block_get(&block, fs->device, current_block, 0);
+                int rc = block_get(&block, fs->device, current_block, 0);
                 if (rc != EOK)
                         return rc;
@@ -1518 +1518 @@
  *
  */
-errno_t ext4_filesystem_release_inode_block(ext4_inode_ref_t *inode_ref,
+int ext4_filesystem_release_inode_block(ext4_inode_ref_t *inode_ref,
     uint32_t iblock)
 {
@@ -1575 +1575 @@
                         return EOK;
                 
-                errno_t rc = block_get(&block, fs->device, current_block, 0);
+                int rc = block_get(&block, fs->device, current_block, 0);
                 if (rc != EOK)
                         return rc;
@@ -1625 +1625 @@
  *
  */
-errno_t ext4_filesystem_append_inode_block(ext4_inode_ref_t *inode_ref,
+int ext4_filesystem_append_inode_block(ext4_inode_ref_t *inode_ref,
     uint32_t *fblock, uint32_t *iblock)
 {
@@ -1649 +1649 @@
         /* Allocate new physical block */
         uint32_t phys_block;
-        errno_t rc = ext4_balloc_alloc_block(inode_ref, &phys_block);
+        int rc = ext4_balloc_alloc_block(inode_ref, &phys_block);
         if (rc != EOK)
                 return rc;