Changes in uspace/srv/fs/cdfs/cdfs_ops.c [94e3a03:b7fd2a0] in mainline

File:

• uspace/srv/fs/cdfs/cdfs_ops.c (modified) (38 diffs)

uspace/srv/fs/cdfs/cdfs_ops.c

@@ -331 +331 @@
 };
 
-static int cdfs_node_get(fs_node_t **rfn, service_id_t service_id,
+static errno_t cdfs_node_get(fs_node_t **rfn, service_id_t service_id,
     fs_index_t index)
 {
@@ -351 +351 @@
 }
 
-static int cdfs_root_get(fs_node_t **rfn, service_id_t service_id)
+static errno_t cdfs_root_get(fs_node_t **rfn, service_id_t service_id)
 {
         return cdfs_node_get(rfn, service_id, CDFS_SOME_ROOT);
@@ -371 +371 @@
 }
 
-static int create_node(fs_node_t **rfn, cdfs_t *fs, int lflag,
+static errno_t create_node(fs_node_t **rfn, cdfs_t *fs, int lflag,
     fs_index_t index)
 {
@@ -392 +392 @@
         
         fs_node_t *rootfn;
-        int rc = cdfs_root_get(&rootfn, fs->service_id);
+        errno_t rc = cdfs_root_get(&rootfn, fs->service_id);
         
         assert(rc == EOK);
@@ -417 +417 @@
 }
 
-static int link_node(fs_node_t *pfn, fs_node_t *fn, const char *name)
+static errno_t link_node(fs_node_t *pfn, fs_node_t *fn, const char *name)
 {
         cdfs_node_t *parent = CDFS_NODE(pfn);
@@ -460 +460 @@
 static char *cdfs_decode_str(void *data, size_t dsize, cdfs_enc_t enc)
 {
-        int rc;
+        errno_t rc;
         char *str;
         uint16_t *buf;
@@ -566 +566 @@
 }
 
-static int cdfs_readdir(cdfs_t *fs, fs_node_t *fs_node)
+static errno_t cdfs_readdir(cdfs_t *fs, fs_node_t *fs_node)
 {
         cdfs_node_t *node = CDFS_NODE(fs_node);
@@ -580 +580 @@
         for (uint32_t i = 0; i < blocks; i++) {
                 block_t *block;
-                int rc = block_get(&block, fs->service_id, node->lba + i, BLOCK_FLAGS_NONE);
+                errno_t rc = block_get(&block, fs->service_id, node->lba + i, BLOCK_FLAGS_NONE);
                 if (rc != EOK)
                         return rc;
@@ -614 +614 @@
                         
                         fs_node_t *fn;
-                        int rc = create_node(&fn, fs, dentry_type,
+                        errno_t rc = create_node(&fn, fs, dentry_type,
                             (node->lba + i) * BLOCK_SIZE + offset);
                         if (rc != EOK)
@@ -652 +652 @@
         
         block_t *block;
-        int rc = block_get(&block, fs->service_id, lba, BLOCK_FLAGS_NONE);
+        errno_t rc = block_get(&block, fs->service_id, lba, BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return NULL;
@@ -698 +698 @@
 }
 
-static int cdfs_match(fs_node_t **fn, fs_node_t *pfn, const char *component)
+static errno_t cdfs_match(fs_node_t **fn, fs_node_t *pfn, const char *component)
 {
         cdfs_node_t *parent = CDFS_NODE(pfn);
         
         if (!parent->processed) {
-                int rc = cdfs_readdir(parent->fs, pfn);
+                errno_t rc = cdfs_readdir(parent->fs, pfn);
                 if (rc != EOK)
                         return rc;
@@ -719 +719 @@
 }
 
-static int cdfs_node_open(fs_node_t *fn)
+static errno_t cdfs_node_open(fs_node_t *fn)
 {
         cdfs_node_t *node = CDFS_NODE(fn);
@@ -730 +730 @@
 }
 
-static int cdfs_node_put(fs_node_t *fn)
+static errno_t cdfs_node_put(fs_node_t *fn)
 {
         /* Nothing to do */
@@ -736 +736 @@
 }
 
-static int cdfs_create_node(fs_node_t **fn, service_id_t service_id, int lflag)
+static errno_t cdfs_create_node(fs_node_t **fn, service_id_t service_id, int lflag)
 {
         /* Read-only */
@@ -742 +742 @@
 }
 
-static int cdfs_destroy_node(fs_node_t *fn)
+static errno_t cdfs_destroy_node(fs_node_t *fn)
 {
         /* Read-only */
@@ -748 +748 @@
 }
 
-static int cdfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+static errno_t cdfs_link_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
 {
         /* Read-only */
@@ -754 +754 @@
 }
 
-static int cdfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
+static errno_t cdfs_unlink_node(fs_node_t *pfn, fs_node_t *cfn, const char *name)
 {
         /* Read-only */
@@ -760 +760 @@
 }
 
-static int cdfs_has_children(bool *has_children, fs_node_t *fn)
+static errno_t cdfs_has_children(bool *has_children, fs_node_t *fn)
 {
         cdfs_node_t *node = CDFS_NODE(fn);
@@ -806 +806 @@
 }
 
-static int cdfs_size_block(service_id_t service_id, uint32_t *size)
+static errno_t cdfs_size_block(service_id_t service_id, uint32_t *size)
 {
         *size = BLOCK_SIZE;
@@ -813 +813 @@
 }
 
-static int cdfs_total_block_count(service_id_t service_id, uint64_t *count)
+static errno_t cdfs_total_block_count(service_id_t service_id, uint64_t *count)
 {
         *count = 0;
@@ -820 +820 @@
 }
 
-static int cdfs_free_block_count(service_id_t service_id, uint64_t *count)
+static errno_t cdfs_free_block_count(service_id_t service_id, uint64_t *count)
 {
         *count = 0;
@@ -851 +851 @@
 /** Verify that escape sequence corresonds to one of the allowed encoding
  * escape sequences allowed for Joliet. */
-static int cdfs_verify_joliet_esc_seq(uint8_t *seq)
+static errno_t cdfs_verify_joliet_esc_seq(uint8_t *seq)
 {
         size_t i, j, k;
@@ -895 +895 @@
  * @return              EOK if found, ENOENT if not
  */
-static int cdfs_find_joliet_svd(service_id_t sid, cdfs_lba_t altroot,
+static errno_t cdfs_find_joliet_svd(service_id_t sid, cdfs_lba_t altroot,
     uint32_t *rlba, uint32_t *rsize, char **vol_ident)
 {
@@ -902 +902 @@
         for (bi = altroot + 17; ; bi++) {
                 block_t *block;
-                int rc = block_get(&block, sid, bi, BLOCK_FLAGS_NONE);
+                errno_t rc = block_get(&block, sid, bi, BLOCK_FLAGS_NONE);
                 if (rc != EOK)
                         break;
@@ -963 +963 @@
 
 /** Read the volume descriptors. */
-static int iso_read_vol_desc(service_id_t sid, cdfs_lba_t altroot,
+static errno_t iso_read_vol_desc(service_id_t sid, cdfs_lba_t altroot,
     uint32_t *rlba, uint32_t *rsize, cdfs_enc_t *enc, char **vol_ident)
 {
         /* First 16 blocks of isofs are empty */
         block_t *block;
-        int rc = block_get(&block, sid, altroot + 16, BLOCK_FLAGS_NONE);
+        errno_t rc = block_get(&block, sid, altroot + 16, BLOCK_FLAGS_NONE);
         if (rc != EOK)
                 return rc;
@@ -1036 +1036 @@
 }
 
-static int iso_readfs(cdfs_t *fs, fs_node_t *rfn,
+static errno_t iso_readfs(cdfs_t *fs, fs_node_t *rfn,
     cdfs_lba_t altroot)
 {
         cdfs_node_t *node = CDFS_NODE(rfn);
         
-        int rc = iso_read_vol_desc(fs->service_id, altroot, &node->lba,
+        errno_t rc = iso_read_vol_desc(fs->service_id, altroot, &node->lba,
             &node->size, &fs->enc, &fs->vol_ident);
         if (rc != EOK)
@@ -1064 +1064 @@
         
         /* Create root node */
-        int rc = create_node(&rfn, fs, L_DIRECTORY, cdfs_index++);
+        errno_t rc = create_node(&rfn, fs, L_DIRECTORY, cdfs_index++);
         
         if ((rc != EOK) || (!rfn))
@@ -1086 +1086 @@
 }
 
-static int cdfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
+static errno_t cdfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
 {
         char *vol_ident;
 
         /* Initialize the block layer */
-        int rc = block_init(service_id, BLOCK_SIZE);
+        errno_t rc = block_init(service_id, BLOCK_SIZE);
         if (rc != EOK)
                 return rc;
@@ -1144 +1144 @@
 }
 
-static int cdfs_mounted(service_id_t service_id, const char *opts,
+static errno_t cdfs_mounted(service_id_t service_id, const char *opts,
     fs_index_t *index, aoff64_t *size)
 {
         /* Initialize the block layer */
-        int rc = block_init(service_id, BLOCK_SIZE);
+        errno_t rc = block_init(service_id, BLOCK_SIZE);
         if (rc != EOK)
                 return rc;
@@ -1238 +1238 @@
 }
 
-static int cdfs_unmounted(service_id_t service_id)
+static errno_t cdfs_unmounted(service_id_t service_id)
 {
         cdfs_t *fs;
@@ -1250 +1250 @@
 }
 
-static int cdfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
+static errno_t cdfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *rbytes)
 {
@@ -1266 +1266 @@
         
         if (!node->processed) {
-                int rc = cdfs_readdir(node->fs, FS_NODE(node));
+                errno_t rc = cdfs_readdir(node->fs, FS_NODE(node));
                 if (rc != EOK)
                         return rc;
@@ -1290 +1290 @@
                         
                         block_t *block;
-                        int rc = block_get(&block, service_id, node->lba + lba,
+                        errno_t rc = block_get(&block, service_id, node->lba + lba,
                             BLOCK_FLAGS_NONE);
                         if (rc != EOK) {
@@ -1321 +1321 @@
 }
 
-static int cdfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
+static errno_t cdfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     size_t *wbytes, aoff64_t *nsize)
 {
@@ -1332 +1332 @@
 }
 
-static int cdfs_truncate(service_id_t service_id, fs_index_t index,
+static errno_t cdfs_truncate(service_id_t service_id, fs_index_t index,
     aoff64_t size)
 {
@@ -1373 +1373 @@
 }
 
-static int cdfs_close(service_id_t service_id, fs_index_t index)
+static errno_t cdfs_close(service_id_t service_id, fs_index_t index)
 {
         /* Root node is always in memory */
@@ -1399 +1399 @@
 }
 
-static int cdfs_destroy(service_id_t service_id, fs_index_t index)
+static errno_t cdfs_destroy(service_id_t service_id, fs_index_t index)
 {
         /*
@@ -1409 +1409 @@
 }
 
-static int cdfs_sync(service_id_t service_id, fs_index_t index)
+static errno_t cdfs_sync(service_id_t service_id, fs_index_t index)
 {
         /*