Changes in / [e48947e:02082f3] in mainline


Ignore:
Location:
uspace
Files:
1 added
1 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/init/init.c

    re48947e r02082f3  
    316316        }
    317317       
    318         /* Make sure file systems are running. */
     318        /* Make sure tmpfs is running. */
    319319        if (str_cmp(STRING(RDFMT), "tmpfs") != 0)
    320320                srv_start("/srv/tmpfs");
    321         if (str_cmp(STRING(RDFMT), "exfat") != 0)
    322                 srv_start("/srv/exfat");
    323         if (str_cmp(STRING(RDFMT), "fat") != 0)
    324                 srv_start("/srv/fat");
    325         srv_start("/srv/cdfs");
     321       
    326322        srv_start("/srv/mfs");
    327323       

  • uspace/lib/c/include/types/vol.h

    re48947e r02082f3  
    5252        fs_fat,
    5353        fs_minix,
    54         fs_ext4,
    55         fs_cdfs
     54        fs_ext4
    5655} vol_fstype_t;
    5756

  • uspace/lib/ext4/include/ext4/filesystem.h

    re48947e r02082f3  
    3636
    3737#include <block.h>
    38 #include "ext4/fstypes.h"
    3938#include "ext4/types.h"
    4039
    41 extern int ext4_filesystem_probe(service_id_t);
    42 extern int ext4_filesystem_open(ext4_instance_t *, service_id_t,
    43     enum cache_mode, aoff64_t *, ext4_filesystem_t **);
    44 extern int ext4_filesystem_close(ext4_filesystem_t *);
     40extern int ext4_filesystem_init(ext4_filesystem_t *, service_id_t,
     41    enum cache_mode);
     42extern int ext4_filesystem_fini(ext4_filesystem_t *);
     43extern int ext4_filesystem_check_features(ext4_filesystem_t *, bool *);
    4544extern uint32_t ext4_filesystem_blockaddr2_index_in_group(ext4_superblock_t *,
    4645    uint32_t);

  • uspace/lib/ext4/include/ext4/ops.h

    re48947e r02082f3  
    3535
    3636#include <libfs.h>
    37 #include "ext4/fstypes.h"
    3837
    39 extern vfs_out_ops_t ext4_ops;
    40 extern libfs_ops_t ext4_libfs_ops;
     38extern vfs_out_ops_t ext4fs_ops;
     39extern libfs_ops_t ext4fs_libfs_ops;
    4140
    42 extern int ext4_global_init(void);
    43 extern int ext4_global_fini(void);
    44 
    45 extern int ext4_node_get_core(fs_node_t **, ext4_instance_t *, fs_index_t);
    46 extern int ext4_node_put(fs_node_t *);
     41extern int ext4fs_global_init(void);
     42extern int ext4fs_global_fini(void);
    4743
    4844

  • uspace/lib/ext4/src/balloc.c

    re48947e r02082f3  
    3131 */
    3232/**
    33  * @file  balloc.c
     33 * @file  libext4_balloc.c
    3434 * @brief Physical block allocator.
    3535 */

  • uspace/lib/ext4/src/bitmap.c

    re48947e r02082f3  
    3131 */
    3232/**
    33  * @file  bitmap.c
     33 * @file  libext4_bitmap.c
    3434 * @brief Ext4 bitmap operations.
    3535 */

  • uspace/lib/ext4/src/block_group.c

    re48947e r02082f3  
    3232 */
    3333/**
    34  * @file  block_group.c
     34 * @file  libext4_block_group.c
    3535 * @brief Ext4 block group structure operations.
    3636 */

  • uspace/lib/ext4/src/directory.c

    re48947e r02082f3  
    3232 */
    3333/**
    34  * @file  directory.c
     34 * @file  libext4_directory.c
    3535 * @brief Ext4 directory structure operations.
    3636 */

  • uspace/lib/ext4/src/directory_index.c

    re48947e r02082f3  
    3131 */
    3232/**
    33  * @file  directory_index.c
     33 * @file  libext4_directory_index.c
    3434 * @brief Ext4 directory index operations.
    3535 */

  • uspace/lib/ext4/src/extent.c

    re48947e r02082f3  
    3131 */
    3232/**
    33  * @file  extent.c
     33 * @file  libext4_extent.c
    3434 * @brief Ext4 extent structures operations.
    3535 */

  • uspace/lib/ext4/src/filesystem.c

    re48947e r02082f3  
    3232 */
    3333/**
    34  * @file  filesystem.c
     34 * @file  libext4_filesystem.c
    3535 * @brief More complex filesystem operations.
    3636 */
    … …  
    4242#include <crypto.h>
    4343#include <ipc/vfs.h>
    44 #include <libfs.h>
    4544#include <stdlib.h>
    4645#include "ext4/balloc.h"
    … …  
    5150#include "ext4/ialloc.h"
    5251#include "ext4/inode.h"
    53 #include "ext4/ops.h"
    5452#include "ext4/superblock.h"
    5553
    56 static int ext4_filesystem_check_features(ext4_filesystem_t *, bool *);
    57 
    58 /** Initialize filesystem for opening.
    59  *
    60  * But do not mark mounted just yet.
     54/** Initialize filesystem and read all needed data.
    6155 *
    6256 * @param fs         Filesystem instance to be initialized
    63  * @param service_id Block device to open
    64  * @param cmode      Cache mode
    65  *
    66  * @return Error code
    67  *
    68  */
    69 static int ext4_filesystem_init(ext4_filesystem_t *fs, service_id_t service_id,
     57 * @param service_id Identifier if device with the filesystem
     58 *
     59 * @return Error code
     60 *
     61 */
     62int ext4_filesystem_init(ext4_filesystem_t *fs, service_id_t service_id,
    7063    enum cache_mode cmode)
    7164{
    … …  
    120113                goto err_2;
    121114        }
    122 
     115       
    123116        rc = ext4_superblock_check_sanity(fs->superblock);
    124117        if (rc != EOK)
    125118                goto err_2;
    126119
    127         /* Check flags */
    128         bool read_only;
    129         rc = ext4_filesystem_check_features(fs, &read_only);
     120        /* Mark system as mounted */
     121        ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_ERROR_FS);
     122        rc = ext4_superblock_write_direct(fs->device, fs->superblock);
    130123        if (rc != EOK)
    131124                goto err_2;
    132125
     126        uint16_t mnt_count = ext4_superblock_get_mount_count(fs->superblock);
     127        ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1);
     128
    133129        return EOK;
     130
    134131err_2:
    135132        block_cache_fini(fs->device);
    … …  
    142139}
    143140
    144 /** Finalize filesystem.
    145  *
    146  * @param fs Filesystem to be finalized
    147  *
    148  */
    149 static void ext4_filesystem_fini(ext4_filesystem_t *fs)
    150 {
     141/** Destroy filesystem instance (used by unmount operation).
     142 *
     143 * @param fs Filesystem to be destroyed
     144 *
     145 * @return Error code
     146 *
     147 */
     148int ext4_filesystem_fini(ext4_filesystem_t *fs)
     149{
     150        /* Write the superblock to the device */
     151        ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_VALID_FS);
     152        int rc = ext4_superblock_write_direct(fs->device, fs->superblock);
     153       
    151154        /* Release memory space for superblock */
    152155        free(fs->superblock);
    … …  
    155158        block_cache_fini(fs->device);
    156159        block_fini(fs->device);
    157 }
    158 
    159 /** Probe filesystem.
    160  *
    161  * @param service_id Block device to probe
    162  *
    163  * @return EOK or negative error code.
    164  *
    165  */
    166 int ext4_filesystem_probe(service_id_t service_id)
    167 {
    168         ext4_filesystem_t *fs = NULL;
    169         int rc;
    170 
    171         fs = calloc(1, sizeof(ext4_filesystem_t));
    172         if (fs == NULL)
    173                 return ENOMEM;
    174 
    175         /* Initialize the file system for opening */
    176         rc = ext4_filesystem_init(fs, service_id, CACHE_MODE_WT);
    177         if (rc != EOK) {
    178                 free(fs);
    179                 return rc;
    180         }
    181 
    182         ext4_filesystem_fini(fs);
    183         return EOK;
    184 }
    185 
    186 /** Open filesystem and read all needed data.
    187  *
    188  * @param fs         Filesystem to be initialized
    189  * @param inst       Instance
    190  * @param service_id Identifier if device with the filesystem
    191  * @param cmode      Cache mode
    192  * @param size       Output value - size of root node
    193  *
    194  * @return Error code
    195  *
    196  */
    197 int ext4_filesystem_open(ext4_instance_t *inst, service_id_t service_id,
    198     enum cache_mode cmode, aoff64_t *size, ext4_filesystem_t **rfs)
    199 {
    200         ext4_filesystem_t *fs = NULL;
    201         fs_node_t *root_node = NULL;
    202         int rc;
    203 
    204         fs = calloc(1, sizeof(ext4_filesystem_t));
    205         if (fs == NULL) {
    206                 rc = ENOMEM;
    207                 goto error;
    208         }
    209 
    210         inst->filesystem = fs;
    211 
    212         /* Initialize the file system for opening */
    213         rc = ext4_filesystem_init(fs, service_id, cmode);
    214         if (rc != EOK)
    215                 goto error;
    216 
    217         /* Read root node */
    218         rc = ext4_node_get_core(&root_node, inst, EXT4_INODE_ROOT_INDEX);
    219         if (rc != EOK)
    220                 goto error;
    221 
    222         /* Mark system as mounted */
    223         ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_ERROR_FS);
    224         rc = ext4_superblock_write_direct(fs->device, fs->superblock);
    225         if (rc != EOK)
    226                 goto error;
    227 
    228         uint16_t mnt_count = ext4_superblock_get_mount_count(fs->superblock);
    229         ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1);
    230 
    231         ext4_node_t *enode = EXT4_NODE(root_node);
    232 
    233         *size = ext4_inode_get_size(fs->superblock, enode->inode_ref->inode);
    234 
    235         ext4_node_put(root_node);
    236         *rfs = fs;
    237         return EOK;
    238 error:
    239         if (root_node != NULL)
    240                 ext4_node_put(root_node);
    241 
    242         if (fs != NULL) {
    243                 ext4_filesystem_fini(fs);
    244                 free(fs);
    245         }
    246 
     160       
    247161        return rc;
    248 }
    249 
    250 /** Close filesystem.
    251  *
    252  * @param fs Filesystem to be destroyed
    253  *
    254  * @return EOK or negative error code. On error the state of the file
    255  *         system is unchanged.
    256  *
    257  */
    258 int ext4_filesystem_close(ext4_filesystem_t *fs)
    259 {
    260         /* Write the superblock to the device */
    261         ext4_superblock_set_state(fs->superblock, EXT4_SUPERBLOCK_STATE_VALID_FS);
    262         int rc = ext4_superblock_write_direct(fs->device, fs->superblock);
    263         if (rc != EOK)
    264                 return rc;
    265 
    266         ext4_filesystem_fini(fs);
    267         return EOK;
    268162}
    269163
    … …  
    275169 *
    276170 * @param fs        Filesystem to be checked
    277  * @param read_only Place to write flag saying whether filesystem
    278  *                  should be mounted only for reading
    279  *
    280  * @return Error code
    281  *
    282  */
    283 static int ext4_filesystem_check_features(ext4_filesystem_t *fs,
    284     bool *read_only)
     171 * @param read_only Flag if filesystem should be mounted only for reading
     172 *
     173 * @return Error code
     174 *
     175 */
     176int ext4_filesystem_check_features(ext4_filesystem_t *fs, bool *read_only)
    285177{
    286178        /* Feature flags are present only in higher revisions */

  • uspace/lib/ext4/src/hash.c

    re48947e r02082f3  
    3131 */
    3232/**
    33  * @file  hash.c
     33 * @file  libext4_hash.c
    3434 * @brief Hashing algorithms for ext4 HTree.
    3535 */

  • uspace/lib/ext4/src/ialloc.c

    re48947e r02082f3  
    3131 */
    3232/**
    33  * @file  ialloc.c
     33 * @file  libext4_ialloc.c
    3434 * @brief I-node (de)allocation operations.
    3535 */

  • uspace/lib/ext4/src/inode.c

    re48947e r02082f3  
    3232 */
    3333/**
    34  * @file  inode.c
     34 * @file  libext4_inode.c
    3535 * @brief Ext4 i-node structure operations.
    3636 */

  • uspace/lib/ext4/src/ops.c

    re48947e r02082f3  
    3232 */
    3333/**
    34  * @file  ops.c
     34 * @file  ext4fs_ops.c
    3535 * @brief Operations for ext4 filesystem.
    3636 */
    3737
    38 #include <adt/hash_table.h>
    39 #include <adt/hash.h>
    4038#include <errno.h>
     39#include <ext4/libext4.h>
    4140#include <fibril_synch.h>
    4241#include <libfs.h>
    4342#include <macros.h>
    4443#include <malloc.h>
    45 #include <mem.h>
    46 #include <str.h>
     44#include <adt/hash_table.h>
     45#include <adt/hash.h>
    4746#include <ipc/loc.h>
    48 #include "ext4/balloc.h"
    49 #include "ext4/directory.h"
    50 #include "ext4/directory_index.h"
    51 #include "ext4/extent.h"
    52 #include "ext4/inode.h"
    5347#include "ext4/ops.h"
    54 #include "ext4/filesystem.h"
    55 #include "ext4/fstypes.h"
    56 #include "ext4/superblock.h"
     48//#include "../../vfs/vfs.h"
     49
     50#define EXT4FS_NODE(node) \
     51        ((node) ? (ext4fs_node_t *) (node)->data : NULL)
     52
     53/**
     54 * Type for holding an instance of mounted partition.
     55 */
     56typedef struct ext4fs_instance {
     57        link_t link;
     58        service_id_t service_id;
     59        ext4_filesystem_t *filesystem;
     60        unsigned int open_nodes_count;
     61} ext4fs_instance_t;
     62
     63/**
     64 * Type for wrapping common fs_node and add some useful pointers.
     65 */
     66typedef struct ext4fs_node {
     67        ext4fs_instance_t *instance;
     68        ext4_inode_ref_t *inode_ref;
     69        fs_node_t *fs_node;
     70        ht_link_t link;
     71        unsigned int references;
     72} ext4fs_node_t;
    5773
    5874/* Forward declarations of auxiliary functions */
    5975
    60 static int ext4_read_directory(ipc_callid_t, aoff64_t, size_t,
    61     ext4_instance_t *, ext4_inode_ref_t *, size_t *);
    62 static int ext4_read_file(ipc_callid_t, aoff64_t, size_t, ext4_instance_t *,
     76static int ext4fs_read_directory(ipc_callid_t, aoff64_t, size_t,
     77    ext4fs_instance_t *, ext4_inode_ref_t *, size_t *);
     78static int ext4fs_read_file(ipc_callid_t, aoff64_t, size_t, ext4fs_instance_t *,
    6379    ext4_inode_ref_t *, size_t *);
    64 static bool ext4_is_dots(const uint8_t *, size_t);
    65 static int ext4_instance_get(service_id_t, ext4_instance_t **);
     80static bool ext4fs_is_dots(const uint8_t *, size_t);
     81static int ext4fs_instance_get(service_id_t, ext4fs_instance_t **);
     82static int ext4fs_node_get_core(fs_node_t **, ext4fs_instance_t *, fs_index_t);
     83static int ext4fs_node_put_core(ext4fs_node_t *);
    6684
    6785/* Forward declarations of ext4 libfs operations. */
    6886
    69 static int ext4_root_get(fs_node_t **, service_id_t);
    70 static int ext4_match(fs_node_t **, fs_node_t *, const char *);
    71 static int ext4_node_get(fs_node_t **, service_id_t, fs_index_t);
    72 static int ext4_node_open(fs_node_t *);
    73        int ext4_node_put(fs_node_t *);
    74 static int ext4_create_node(fs_node_t **, service_id_t, int);
    75 static int ext4_destroy_node(fs_node_t *);
    76 static int ext4_link(fs_node_t *, fs_node_t *, const char *);
    77 static int ext4_unlink(fs_node_t *, fs_node_t *, const char *);
    78 static int ext4_has_children(bool *, fs_node_t *);
    79 static fs_index_t ext4_index_get(fs_node_t *);
    80 static aoff64_t ext4_size_get(fs_node_t *);
    81 static unsigned ext4_lnkcnt_get(fs_node_t *);
    82 static bool ext4_is_directory(fs_node_t *);
    83 static bool ext4_is_file(fs_node_t *node);
    84 static service_id_t ext4_service_get(fs_node_t *node);
    85 static int ext4_size_block(service_id_t, uint32_t *);
    86 static int ext4_total_block_count(service_id_t, uint64_t *);
    87 static int ext4_free_block_count(service_id_t, uint64_t *);
     87static int ext4fs_root_get(fs_node_t **, service_id_t);
     88static int ext4fs_match(fs_node_t **, fs_node_t *, const char *);
     89static int ext4fs_node_get(fs_node_t **, service_id_t, fs_index_t);
     90static int ext4fs_node_open(fs_node_t *);
     91static int ext4fs_node_put(fs_node_t *);
     92static int ext4fs_create_node(fs_node_t **, service_id_t, int);
     93static int ext4fs_destroy_node(fs_node_t *);
     94static int ext4fs_link(fs_node_t *, fs_node_t *, const char *);
     95static int ext4fs_unlink(fs_node_t *, fs_node_t *, const char *);
     96static int ext4fs_has_children(bool *, fs_node_t *);
     97static fs_index_t ext4fs_index_get(fs_node_t *);
     98static aoff64_t ext4fs_size_get(fs_node_t *);
     99static unsigned ext4fs_lnkcnt_get(fs_node_t *);
     100static bool ext4fs_is_directory(fs_node_t *);
     101static bool ext4fs_is_file(fs_node_t *node);
     102static service_id_t ext4fs_service_get(fs_node_t *node);
     103static int ext4fs_size_block(service_id_t, uint32_t *);
     104static int ext4fs_total_block_count(service_id_t, uint64_t *);
     105static int ext4fs_free_block_count(service_id_t, uint64_t *);
    88106
    89107/* Static variables */
    … …  
    109127static size_t open_nodes_hash(const ht_link_t *item)
    110128{
    111         ext4_node_t *enode = hash_table_get_inst(item, ext4_node_t, link);
     129        ext4fs_node_t *enode = hash_table_get_inst(item, ext4fs_node_t, link);
    112130        return hash_combine(enode->instance->service_id, enode->inode_ref->index);     
    113131}
    … …  
    116134{
    117135        node_key_t *key = (node_key_t *)key_arg;
    118         ext4_node_t *enode = hash_table_get_inst(item, ext4_node_t, link);
     136        ext4fs_node_t *enode = hash_table_get_inst(item, ext4fs_node_t, link);
    119137       
    120138        return key->service_id == enode->instance->service_id
    … …  
    138156 *
    139157 */
    140 int ext4_global_init(void)
     158int ext4fs_global_init(void)
    141159{
    142160        if (!hash_table_create(&open_nodes, 0, 0, &open_nodes_ops))
    … …  
    152170 * @return Error code
    153171 */
    154 int ext4_global_fini(void)
     172int ext4fs_global_fini(void)
    155173{
    156174        hash_table_destroy(&open_nodes);
    … …  
    170188 *
    171189 */
    172 int ext4_instance_get(service_id_t service_id, ext4_instance_t **inst)
     190int ext4fs_instance_get(service_id_t service_id, ext4fs_instance_t **inst)
    173191{
    174192        fibril_mutex_lock(&instance_list_mutex);
    … …  
    179197        }
    180198       
    181         list_foreach(instance_list, link, ext4_instance_t, tmp) {
     199        list_foreach(instance_list, link, ext4fs_instance_t, tmp) {
    182200                if (tmp->service_id == service_id) {
    183201                        *inst = tmp;
    … …  
    199217 *
    200218 */
    201 int ext4_root_get(fs_node_t **rfn, service_id_t service_id)
    202 {
    203         return ext4_node_get(rfn, service_id, EXT4_INODE_ROOT_INDEX);
     219int ext4fs_root_get(fs_node_t **rfn, service_id_t service_id)
     220{
     221        return ext4fs_node_get(rfn, service_id, EXT4_INODE_ROOT_INDEX);
    204222}
    205223
    … …  
    215233 *
    216234 */
    217 int ext4_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    218 {
    219         ext4_node_t *eparent = EXT4_NODE(pfn);
     235int ext4fs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     236{
     237        ext4fs_node_t *eparent = EXT4FS_NODE(pfn);
    220238        ext4_filesystem_t *fs = eparent->instance->filesystem;
    221239       
    … …  
    239257        /* Load node from search result */
    240258        uint32_t inode = ext4_directory_entry_ll_get_inode(result.dentry);
    241         rc = ext4_node_get_core(rfn, eparent->instance, inode);
     259        rc = ext4fs_node_get_core(rfn, eparent->instance, inode);
    242260        if (rc != EOK)
    243261                goto exit;
    … …  
    262280 *
    263281 */
    264 int ext4_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    265 {
    266         ext4_instance_t *inst;
    267         int rc = ext4_instance_get(service_id, &inst);
    268         if (rc != EOK)
    269                 return rc;
    270        
    271         return ext4_node_get_core(rfn, inst, index);
     282int ext4fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
     283{
     284        ext4fs_instance_t *inst;
     285        int rc = ext4fs_instance_get(service_id, &inst);
     286        if (rc != EOK)
     287                return rc;
     288       
     289        return ext4fs_node_get_core(rfn, inst, index);
    272290}
    273291
    … …  
    281299 *
    282300 */
    283 int ext4_node_get_core(fs_node_t **rfn, ext4_instance_t *inst,
     301int ext4fs_node_get_core(fs_node_t **rfn, ext4fs_instance_t *inst,
    284302    fs_index_t index)
    285303{
    … …  
    293311       
    294312        ht_link_t *already_open = hash_table_find(&open_nodes, &key);
    295         ext4_node_t *enode = NULL;
     313        ext4fs_node_t *enode = NULL;
    296314        if (already_open) {
    297                 enode = hash_table_get_inst(already_open, ext4_node_t, link);
     315                enode = hash_table_get_inst(already_open, ext4fs_node_t, link);
    298316                *rfn = enode->fs_node;
    299317                enode->references++;
    … …  
    304322       
    305323        /* Prepare new enode */
    306         enode = malloc(sizeof(ext4_node_t));
     324        enode = malloc(sizeof(ext4fs_node_t));
    307325        if (enode == NULL) {
    308326                fibril_mutex_unlock(&open_nodes_lock);
    … …  
    355373 *
    356374 */
    357 static int ext4_node_put_core(ext4_node_t *enode)
     375int ext4fs_node_put_core(ext4fs_node_t *enode)
    358376{
    359377        hash_table_remove_item(&open_nodes, &enode->link);
    … …  
    382400 *
    383401 */
    384 int ext4_node_open(fs_node_t *fn)
     402int ext4fs_node_open(fs_node_t *fn)
    385403{
    386404        /* Stateless operation */
    … …  
    396414 *
    397415 */
    398 int ext4_node_put(fs_node_t *fn)
     416int ext4fs_node_put(fs_node_t *fn)
    399417{
    400418        fibril_mutex_lock(&open_nodes_lock);
    401419       
    402         ext4_node_t *enode = EXT4_NODE(fn);
     420        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    403421        assert(enode->references > 0);
    404422        enode->references--;
    405423        if (enode->references == 0) {
    406                 int rc = ext4_node_put_core(enode);
     424                int rc = ext4fs_node_put_core(enode);
    407425                if (rc != EOK) {
    408426                        fibril_mutex_unlock(&open_nodes_lock);
    … …  
    425443 *
    426444 */
    427 int ext4_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     445int ext4fs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    428446{
    429447        /* Allocate enode */
    430         ext4_node_t *enode;
    431         enode = malloc(sizeof(ext4_node_t));
     448        ext4fs_node_t *enode;
     449        enode = malloc(sizeof(ext4fs_node_t));
    432450        if (enode == NULL)
    433451                return ENOMEM;
    … …  
    442460       
    443461        /* Load instance */
    444         ext4_instance_t *inst;
    445         int rc = ext4_instance_get(service_id, &inst);
     462        ext4fs_instance_t *inst;
     463        int rc = ext4fs_instance_get(service_id, &inst);
    446464        if (rc != EOK) {
    447465                free(enode);
    … …  
    486504 *
    487505 */
    488 int ext4_destroy_node(fs_node_t *fn)
     506int ext4fs_destroy_node(fs_node_t *fn)
    489507{
    490508        /* If directory, check for children */
    491509        bool has_children;
    492         int rc = ext4_has_children(&has_children, fn);
    493         if (rc != EOK) {
    494                 ext4_node_put(fn);
     510        int rc = ext4fs_has_children(&has_children, fn);
     511        if (rc != EOK) {
     512                ext4fs_node_put(fn);
    495513                return rc;
    496514        }
    497515       
    498516        if (has_children) {
    499                 ext4_node_put(fn);
     517                ext4fs_node_put(fn);
    500518                return EINVAL;
    501519        }
    502520       
    503         ext4_node_t *enode = EXT4_NODE(fn);
     521        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    504522        ext4_inode_ref_t *inode_ref = enode->inode_ref;
    505523       
    … …  
    507525        rc = ext4_filesystem_truncate_inode(inode_ref, 0);
    508526        if (rc != EOK) {
    509                 ext4_node_put(fn);
     527                ext4fs_node_put(fn);
    510528                return rc;
    511529        }
    … …  
    521539        rc = ext4_filesystem_free_inode(inode_ref);
    522540        if (rc != EOK) {
    523                 ext4_node_put(fn);
    524                 return rc;
    525         }
    526        
    527         return ext4_node_put(fn);
     541                ext4fs_node_put(fn);
     542                return rc;
     543        }
     544       
     545        return ext4fs_node_put(fn);
    528546}
    529547
    … …  
    537555 *
    538556 */
    539 int ext4_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     557int ext4fs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    540558{
    541559        /* Check maximum name length */
    … …  
    543561                return ENAMETOOLONG;
    544562       
    545         ext4_node_t *parent = EXT4_NODE(pfn);
    546         ext4_node_t *child = EXT4_NODE(cfn);
     563        ext4fs_node_t *parent = EXT4FS_NODE(pfn);
     564        ext4fs_node_t *child = EXT4FS_NODE(cfn);
    547565        ext4_filesystem_t *fs = parent->instance->filesystem;
    548566       
    … …  
    610628 *
    611629 */
    612 int ext4_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     630int ext4fs_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    613631{
    614632        bool has_children;
    615         int rc = ext4_has_children(&has_children, cfn);
     633        int rc = ext4fs_has_children(&has_children, cfn);
    616634        if (rc != EOK)
    617635                return rc;
    … …  
    622640       
    623641        /* Remove entry from parent directory */
    624         ext4_inode_ref_t *parent = EXT4_NODE(pfn)->inode_ref;
     642        ext4_inode_ref_t *parent = EXT4FS_NODE(pfn)->inode_ref;
    625643        rc = ext4_directory_remove_entry(parent, name);
    626644        if (rc != EOK)
    … …  
    628646       
    629647        /* Decrement links count */
    630         ext4_inode_ref_t *child_inode_ref = EXT4_NODE(cfn)->inode_ref;
     648        ext4_inode_ref_t *child_inode_ref = EXT4FS_NODE(cfn)->inode_ref;
    631649       
    632650        uint32_t lnk_count =
    … …  
    635653       
    636654        /* If directory - handle links from parent */
    637         if ((lnk_count <= 1) && (ext4_is_directory(cfn))) {
     655        if ((lnk_count <= 1) && (ext4fs_is_directory(cfn))) {
    638656                assert(lnk_count == 1);
    639657               
    640658                lnk_count--;
    641659               
    642                 ext4_inode_ref_t *parent_inode_ref = EXT4_NODE(pfn)->inode_ref;
     660                ext4_inode_ref_t *parent_inode_ref = EXT4FS_NODE(pfn)->inode_ref;
    643661               
    644662                uint32_t parent_lnk_count = ext4_inode_get_links_count(
    … …  
    683701 *
    684702 */
    685 int ext4_has_children(bool *has_children, fs_node_t *fn)
    686 {
    687         ext4_node_t *enode = EXT4_NODE(fn);
     703int ext4fs_has_children(bool *has_children, fs_node_t *fn)
     704{
     705        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    688706        ext4_filesystem_t *fs = enode->instance->filesystem;
    689707       
    … …  
    707725                            ext4_directory_entry_ll_get_name_length(fs->superblock,
    708726                            it.current);
    709                         if (!ext4_is_dots(it.current->name, name_size)) {
     727                        if (!ext4fs_is_dots(it.current->name, name_size)) {
    710728                                found = true;
    711729                                break;
    … …  
    736754 *
    737755 */
    738 fs_index_t ext4_index_get(fs_node_t *fn)
    739 {
    740         ext4_node_t *enode = EXT4_NODE(fn);
     756fs_index_t ext4fs_index_get(fs_node_t *fn)
     757{
     758        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    741759        return enode->inode_ref->index;
    742760}
    … …  
    749767 *
    750768 */
    751 aoff64_t ext4_size_get(fs_node_t *fn)
    752 {
    753         ext4_node_t *enode = EXT4_NODE(fn);
     769aoff64_t ext4fs_size_get(fs_node_t *fn)
     770{
     771        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    754772        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
    755773        return ext4_inode_get_size(sb, enode->inode_ref->inode);
    … …  
    763781 *
    764782 */
    765 unsigned ext4_lnkcnt_get(fs_node_t *fn)
    766 {
    767         ext4_node_t *enode = EXT4_NODE(fn);
     783unsigned ext4fs_lnkcnt_get(fs_node_t *fn)
     784{
     785        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    768786        uint32_t lnkcnt = ext4_inode_get_links_count(enode->inode_ref->inode);
    769787       
    770         if (ext4_is_directory(fn)) {
     788        if (ext4fs_is_directory(fn)) {
    771789                if (lnkcnt > 1)
    772790                        return 1;
    … …  
    786804 *
    787805 */
    788 bool ext4_is_directory(fs_node_t *fn)
    789 {
    790         ext4_node_t *enode = EXT4_NODE(fn);
     806bool ext4fs_is_directory(fs_node_t *fn)
     807{
     808        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    791809        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
    792810       
    … …  
    802820 *
    803821 */
    804 bool ext4_is_file(fs_node_t *fn)
    805 {
    806         ext4_node_t *enode = EXT4_NODE(fn);
     822bool ext4fs_is_file(fs_node_t *fn)
     823{
     824        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    807825        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
    808826       
    … …  
    818836 *
    819837 */
    820 service_id_t ext4_service_get(fs_node_t *fn)
    821 {
    822         ext4_node_t *enode = EXT4_NODE(fn);
     838service_id_t ext4fs_service_get(fs_node_t *fn)
     839{
     840        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    823841        return enode->instance->service_id;
    824842}
    825843
    826 int ext4_size_block(service_id_t service_id, uint32_t *size)
    827 {
    828         ext4_instance_t *inst;
    829         int rc = ext4_instance_get(service_id, &inst);
     844int ext4fs_size_block(service_id_t service_id, uint32_t *size)
     845{
     846        ext4fs_instance_t *inst;
     847        int rc = ext4fs_instance_get(service_id, &inst);
    830848        if (rc != EOK)
    831849                return rc;
    … …  
    840858}
    841859
    842 int ext4_total_block_count(service_id_t service_id, uint64_t *count)
    843 {
    844         ext4_instance_t *inst;
    845         int rc = ext4_instance_get(service_id, &inst);
     860int ext4fs_total_block_count(service_id_t service_id, uint64_t *count)
     861{
     862        ext4fs_instance_t *inst;
     863        int rc = ext4fs_instance_get(service_id, &inst);
    846864        if (rc != EOK)
    847865                return rc;
    … …  
    856874}
    857875
    858 int ext4_free_block_count(service_id_t service_id, uint64_t *count)
    859 {
    860         ext4_instance_t *inst;
    861         int rc = ext4_instance_get(service_id, &inst);
     876int ext4fs_free_block_count(service_id_t service_id, uint64_t *count)
     877{
     878        ext4fs_instance_t *inst;
     879        int rc = ext4fs_instance_get(service_id, &inst);
    862880        if (rc != EOK)
    863881                return rc;
    … …  
    872890 * libfs operations.
    873891 */
    874 libfs_ops_t ext4_libfs_ops = {
    875         .root_get = ext4_root_get,
    876         .match = ext4_match,
    877         .node_get = ext4_node_get,
    878         .node_open = ext4_node_open,
    879         .node_put = ext4_node_put,
    880         .create = ext4_create_node,
    881         .destroy = ext4_destroy_node,
    882         .link = ext4_link,
    883         .unlink = ext4_unlink,
    884         .has_children = ext4_has_children,
    885         .index_get = ext4_index_get,
    886         .size_get = ext4_size_get,
    887         .lnkcnt_get = ext4_lnkcnt_get,
    888         .is_directory = ext4_is_directory,
    889         .is_file = ext4_is_file,
    890         .service_get = ext4_service_get,
    891         .size_block = ext4_size_block,
    892         .total_block_count = ext4_total_block_count,
    893         .free_block_count = ext4_free_block_count
     892libfs_ops_t ext4fs_libfs_ops = {
     893        .root_get = ext4fs_root_get,
     894        .match = ext4fs_match,
     895        .node_get = ext4fs_node_get,
     896        .node_open = ext4fs_node_open,
     897        .node_put = ext4fs_node_put,
     898        .create = ext4fs_create_node,
     899        .destroy = ext4fs_destroy_node,
     900        .link = ext4fs_link,
     901        .unlink = ext4fs_unlink,
     902        .has_children = ext4fs_has_children,
     903        .index_get = ext4fs_index_get,
     904        .size_get = ext4fs_size_get,
     905        .lnkcnt_get = ext4fs_lnkcnt_get,
     906        .is_directory = ext4fs_is_directory,
     907        .is_file = ext4fs_is_file,
     908        .service_get = ext4fs_service_get,
     909        .size_block = ext4fs_size_block,
     910        .total_block_count = ext4fs_total_block_count,
     911        .free_block_count = ext4fs_free_block_count
    894912};
    895913
    … …  
    907925 * @return Error code
    908926 */
    909 static int ext4_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    910 {
    911         return ext4_filesystem_probe(service_id);
     927static int ext4fs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     928{
     929        return ENOTSUP;
    912930}
    913931
    … …  
    925943 *
    926944 */
    927 static int ext4_mounted(service_id_t service_id, const char *opts,
     945static int ext4fs_mounted(service_id_t service_id, const char *opts,
    928946    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
    929947{
    930         ext4_filesystem_t *fs;
     948        /* Allocate libext4 filesystem structure */
     949        ext4_filesystem_t *fs = (ext4_filesystem_t *)
     950            malloc(sizeof(ext4_filesystem_t));
     951        if (fs == NULL)
     952                return ENOMEM;
    931953       
    932954        /* Allocate instance structure */
    933         ext4_instance_t *inst = (ext4_instance_t *)
    934             malloc(sizeof(ext4_instance_t));
    935         if (inst == NULL)
     955        ext4fs_instance_t *inst = (ext4fs_instance_t *)
     956            malloc(sizeof(ext4fs_instance_t));
     957        if (inst == NULL) {
     958                free(fs);
    936959                return ENOMEM;
     960        }
    937961       
    938962        enum cache_mode cmode;
    … …  
    942966                cmode = CACHE_MODE_WB;
    943967       
     968        /* Initialize the filesystem */
     969        int rc = ext4_filesystem_init(fs, service_id, cmode);
     970        if (rc != EOK) {
     971                free(fs);
     972                free(inst);
     973                return rc;
     974        }
     975       
     976        /* Check flags */
     977        bool read_only;
     978        rc = ext4_filesystem_check_features(fs, &read_only);
     979        if (rc != EOK) {
     980                ext4_filesystem_fini(fs);
     981                free(fs);
     982                free(inst);
     983                return rc;
     984        }
     985       
    944986        /* Initialize instance */
    945987        link_initialize(&inst->link);
    946988        inst->service_id = service_id;
     989        inst->filesystem = fs;
    947990        inst->open_nodes_count = 0;
    948991       
    949         /* Initialize the filesystem */
    950         aoff64_t rnsize;
    951         int rc = ext4_filesystem_open(inst, service_id, cmode, &rnsize, &fs);
    952         if (rc != EOK) {
     992        /* Read root node */
     993        fs_node_t *root_node;
     994        rc = ext4fs_node_get_core(&root_node, inst, EXT4_INODE_ROOT_INDEX);
     995        if (rc != EOK) {
     996                ext4_filesystem_fini(fs);
     997                free(fs);
    953998                free(inst);
    954999                return rc;
    … …  
    9601005        fibril_mutex_unlock(&instance_list_mutex);
    9611006       
     1007        ext4fs_node_t *enode = EXT4FS_NODE(root_node);
     1008       
    9621009        *index = EXT4_INODE_ROOT_INDEX;
    963         *size = rnsize;
     1010        *size = ext4_inode_get_size(fs->superblock, enode->inode_ref->inode);
    9641011        *lnkcnt = 1;
    9651012       
    966         return EOK;
     1013        return ext4fs_node_put(root_node);
    9671014}
    9681015
    … …  
    9761023 *
    9771024 */
    978 static int ext4_unmounted(service_id_t service_id)
    979 {
    980         ext4_instance_t *inst;
    981         int rc = ext4_instance_get(service_id, &inst);
     1025static int ext4fs_unmounted(service_id_t service_id)
     1026{
     1027        ext4fs_instance_t *inst;
     1028        int rc = ext4fs_instance_get(service_id, &inst);
    9821029        if (rc != EOK)
    9831030                return rc;
    … …  
    9971044        fibril_mutex_unlock(&open_nodes_lock);
    9981045       
    999         rc = ext4_filesystem_close(inst->filesystem);
    1000         if (rc != EOK) {
    1001                 fibril_mutex_lock(&instance_list_mutex);
    1002                 list_append(&inst->link, &instance_list);
    1003                 fibril_mutex_unlock(&instance_list_mutex);
    1004         }
    1005 
    1006         free(inst);
    1007         return EOK;
     1046        return ext4_filesystem_fini(inst->filesystem);
    10081047}
    10091048
    … …  
    10181057 *
    10191058 */
    1020 static int ext4_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1059static int ext4fs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    10211060    size_t *rbytes)
    10221061{
    … …  
    10311070        }
    10321071       
    1033         ext4_instance_t *inst;
    1034         int rc = ext4_instance_get(service_id, &inst);
     1072        ext4fs_instance_t *inst;
     1073        int rc = ext4fs_instance_get(service_id, &inst);
    10351074        if (rc != EOK) {
    10361075                async_answer_0(callid, rc);
    … …  
    10491088        if (ext4_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
    10501089            EXT4_INODE_MODE_FILE)) {
    1051                 rc = ext4_read_file(callid, pos, size, inst, inode_ref,
     1090                rc = ext4fs_read_file(callid, pos, size, inst, inode_ref,
    10521091                    rbytes);
    10531092        } else if (ext4_inode_is_type(inst->filesystem->superblock,
    10541093            inode_ref->inode, EXT4_INODE_MODE_DIRECTORY)) {
    1055                 rc = ext4_read_directory(callid, pos, size, inst, inode_ref,
     1094                rc = ext4fs_read_directory(callid, pos, size, inst, inode_ref,
    10561095                    rbytes);
    10571096        } else {
    … …  
    10741113 *
    10751114 */
    1076 bool ext4_is_dots(const uint8_t *name, size_t name_size)
     1115bool ext4fs_is_dots(const uint8_t *name, size_t name_size)
    10771116{
    10781117        if ((name_size == 1) && (name[0] == '.'))
    … …  
    10971136 *
    10981137 */
    1099 int ext4_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size,
    1100     ext4_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
     1138int ext4fs_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size,
     1139    ext4fs_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
    11011140{
    11021141        ext4_directory_iterator_t it;
    … …  
    11211160               
    11221161                /* Skip . and .. */
    1123                 if (ext4_is_dots(it.current->name, name_size))
     1162                if (ext4fs_is_dots(it.current->name, name_size))
    11241163                        goto skip;
    11251164               
    … …  
    11881227 *
    11891228 */
    1190 int ext4_read_file(ipc_callid_t callid, aoff64_t pos, size_t size,
    1191     ext4_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
     1229int ext4fs_read_file(ipc_callid_t callid, aoff64_t pos, size_t size,
     1230    ext4fs_instance_t *inst, ext4_inode_ref_t *inode_ref, size_t *rbytes)
    11921231{
    11931232        ext4_superblock_t *sb = inst->filesystem->superblock;
    … …  
    12771316 *
    12781317 */
    1279 static int ext4_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1318static int ext4fs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    12801319    size_t *wbytes, aoff64_t *nsize)
    12811320{
    12821321        fs_node_t *fn;
    1283         int rc = ext4_node_get(&fn, service_id, index);
     1322        int rc = ext4fs_node_get(&fn, service_id, index);
    12841323        if (rc != EOK)
    12851324                return rc;
    … …  
    12931332        }
    12941333       
    1295         ext4_node_t *enode = EXT4_NODE(fn);
     1334        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    12961335        ext4_filesystem_t *fs = enode->instance->filesystem;
    12971336       
    … …  
    13991438        ;
    14001439
    1401         int const rc2 = ext4_node_put(fn);
     1440        int const rc2 = ext4fs_node_put(fn);
    14021441        return rc == EOK ? rc2 : rc;
    14031442}
    … …  
    14141453 *
    14151454 */
    1416 static int ext4_truncate(service_id_t service_id, fs_index_t index,
     1455static int ext4fs_truncate(service_id_t service_id, fs_index_t index,
    14171456    aoff64_t new_size)
    14181457{
    14191458        fs_node_t *fn;
    1420         int rc = ext4_node_get(&fn, service_id, index);
    1421         if (rc != EOK)
    1422                 return rc;
    1423        
    1424         ext4_node_t *enode = EXT4_NODE(fn);
     1459        int rc = ext4fs_node_get(&fn, service_id, index);
     1460        if (rc != EOK)
     1461                return rc;
     1462       
     1463        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    14251464        ext4_inode_ref_t *inode_ref = enode->inode_ref;
    14261465       
    14271466        rc = ext4_filesystem_truncate_inode(inode_ref, new_size);
    1428         int const rc2 = ext4_node_put(fn);
     1467        int const rc2 = ext4fs_node_put(fn);
    14291468       
    14301469        return rc == EOK ? rc2 : rc;
    … …  
    14391478 *
    14401479 */
    1441 static int ext4_close(service_id_t service_id, fs_index_t index)
     1480static int ext4fs_close(service_id_t service_id, fs_index_t index)
    14421481{
    14431482        return EOK;
    … …  
    14521491 *
    14531492 */
    1454 static int ext4_destroy(service_id_t service_id, fs_index_t index)
     1493static int ext4fs_destroy(service_id_t service_id, fs_index_t index)
    14551494{
    14561495        fs_node_t *fn;
    1457         int rc = ext4_node_get(&fn, service_id, index);
     1496        int rc = ext4fs_node_get(&fn, service_id, index);
    14581497        if (rc != EOK)
    14591498                return rc;
    14601499       
    14611500        /* Destroy the inode */
    1462         return ext4_destroy_node(fn);
     1501        return ext4fs_destroy_node(fn);
    14631502}
    14641503
    … …  
    14691508 *
    14701509 */
    1471 static int ext4_sync(service_id_t service_id, fs_index_t index)
     1510static int ext4fs_sync(service_id_t service_id, fs_index_t index)
    14721511{
    14731512        fs_node_t *fn;
    1474         int rc = ext4_node_get(&fn, service_id, index);
    1475         if (rc != EOK)
    1476                 return rc;
    1477        
    1478         ext4_node_t *enode = EXT4_NODE(fn);
     1513        int rc = ext4fs_node_get(&fn, service_id, index);
     1514        if (rc != EOK)
     1515                return rc;
     1516       
     1517        ext4fs_node_t *enode = EXT4FS_NODE(fn);
    14791518        enode->inode_ref->dirty = true;
    14801519       
    1481         return ext4_node_put(fn);
     1520        return ext4fs_node_put(fn);
    14821521}
    14831522
    … …  
    14851524 *
    14861525 */
    1487 vfs_out_ops_t ext4_ops = {
    1488         .fsprobe = ext4_fsprobe,
    1489         .mounted = ext4_mounted,
    1490         .unmounted = ext4_unmounted,
    1491         .read = ext4_read,
    1492         .write = ext4_write,
    1493         .truncate = ext4_truncate,
    1494         .close = ext4_close,
    1495         .destroy = ext4_destroy,
    1496         .sync = ext4_sync
     1526vfs_out_ops_t ext4fs_ops = {
     1527        .fsprobe = ext4fs_fsprobe,
     1528        .mounted = ext4fs_mounted,
     1529        .unmounted = ext4fs_unmounted,
     1530        .read = ext4fs_read,
     1531        .write = ext4fs_write,
     1532        .truncate = ext4fs_truncate,
     1533        .close = ext4fs_close,
     1534        .destroy = ext4fs_destroy,
     1535        .sync = ext4fs_sync
    14971536};
    14981537

  • uspace/lib/ext4/src/superblock.c

    re48947e r02082f3  
    3333
    3434/**
    35  * @file  superblock.c
     35 * @file  libext4_superblock.c
    3636 * @brief Ext4 superblock operations.
    3737 */

  • uspace/lib/fdisk/src/fdisk.c

    re48947e r02082f3  
    824824                sfstype = "Ext4";
    825825                break;
    826         case fs_cdfs:
    827                 sfstype = "ISO 9660";
    828                 break;
    829826        }
    830827
    … …  
    996993                pcnt = lpc_ext4;
    997994                break;
    998         case fs_cdfs:
    999                 return EINVAL; /* You cannot create an ISO partition */
    1000995        }
    1001996

  • uspace/srv/fs/cdfs/cdfs_ops.c

    re48947e r02082f3  
    906906}
    907907
    908 /** Read the volume descriptors. */
    909 static bool iso_read_vol_desc(service_id_t sid, cdfs_lba_t altroot,
    910     uint32_t *rlba, uint32_t *rsize, cdfs_enc_t *enc)
     908static bool iso_readfs(cdfs_t *fs, fs_node_t *rfn,
     909    cdfs_lba_t altroot)
    911910{
    912911        /* First 16 blocks of isofs are empty */
    913912        block_t *block;
    914         int rc = block_get(&block, sid, altroot + 16, BLOCK_FLAGS_NONE);
     913        int rc = block_get(&block, fs->service_id, altroot + 16, BLOCK_FLAGS_NONE);
    915914        if (rc != EOK)
    916915                return false;
    … …  
    957956        // TODO: implement path table support
    958957       
     958        cdfs_node_t *node = CDFS_NODE(rfn);
     959       
    959960        /* Search for Joliet SVD */
    960961       
    … …  
    962963        uint32_t jrsize;
    963964       
    964         rc = cdfs_find_joliet_svd(sid, altroot, &jrlba, &jrsize);
     965        rc = cdfs_find_joliet_svd(fs->service_id, altroot, &jrlba, &jrsize);
    965966        if (rc == EOK) {
    966967                /* Found */
    967                 *rlba = jrlba;
    968                 *rsize = jrsize;
    969                 *enc = enc_ucs2;
     968                node->lba = jrlba;
     969                node->size = jrsize;
     970                fs->enc = enc_ucs2;
    970971        } else {
    971                 *rlba = uint32_lb(vol_desc->data.prisec.root_dir.lba);
    972                 *rsize = uint32_lb(vol_desc->data.prisec.root_dir.size);
    973                 *enc = enc_ascii;
     972                node->lba = uint32_lb(vol_desc->data.prisec.root_dir.lba);
     973                node->size = uint32_lb(vol_desc->data.prisec.root_dir.size);
     974                fs->enc = enc_ascii;
     975        }
     976       
     977        if (!cdfs_readdir(fs, rfn)) {
     978                block_put(block);
     979                return false;
    974980        }
    975981       
    976982        block_put(block);
    977983        return true;
    978 }
    979 
    980 static bool iso_readfs(cdfs_t *fs, fs_node_t *rfn,
    981     cdfs_lba_t altroot)
    982 {
    983         int rc;
    984        
    985         cdfs_node_t *node = CDFS_NODE(rfn);
    986        
    987         rc = iso_read_vol_desc(fs->service_id, altroot, &node->lba,
    988             &node->size, &fs->enc);
    989         if (rc != EOK)
    990                 return false;
    991        
    992         return cdfs_readdir(fs, rfn);
    993984}
    994985
    … …  
    10321023static int cdfs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    10331024{
    1034         /* Initialize the block layer */
    1035         int rc = block_init(service_id, BLOCK_SIZE);
    1036         if (rc != EOK)
    1037                 return rc;
    1038        
    1039         cdfs_lba_t altroot = 0;
    1040        
    1041         /*
    1042          * Read TOC multisession information and get the start address
    1043          * of the first track in the last session
    1044          */
    1045         scsi_toc_multisess_data_t toc;
    1046 
    1047         rc = block_read_toc(service_id, 1, &toc, sizeof(toc));
    1048         if (rc == EOK && (uint16_t_be2host(toc.toc_len) == 10))
    1049                 altroot = uint32_t_be2host(toc.ftrack_lsess.start_addr);
    1050        
    1051         /* Initialize the block cache */
    1052         rc = block_cache_init(service_id, BLOCK_SIZE, 0, CACHE_MODE_WT);
    1053         if (rc != EOK) {
    1054                 block_fini(service_id);
    1055                 return rc;
    1056         }
    1057        
    1058         /* Check if this device is not already mounted */
    1059         fs_node_t *rootfn;
    1060         rc = cdfs_root_get(&rootfn, service_id);
    1061         if ((rc == EOK) && (rootfn)) {
    1062                 cdfs_node_put(rootfn);
    1063                 block_cache_fini(service_id);
    1064                 block_fini(service_id);
    1065                 return EOK;
    1066         }
    1067        
    1068         /* Read volume descriptors */
    1069         uint32_t rlba;
    1070         uint32_t rsize;
    1071         cdfs_enc_t enc;
    1072         if (!iso_read_vol_desc(service_id, altroot, &rlba, &rsize, &enc)) {
    1073                 block_cache_fini(service_id);
    1074                 block_fini(service_id);
    1075                 return EIO;
    1076         }
    1077        
    1078         return EOK;
     1025        return ENOTSUP;
    10791026}
    10801027

  • uspace/srv/fs/exfat/exfat_fat.c

    re48947e r02082f3  
    540540 * does not contain a exfat file system.
    541541 */
    542 int exfat_sanity_check(exfat_bs_t *bs)
     542int exfat_sanity_check(exfat_bs_t *bs, service_id_t service_id)
    543543{
    544544        if (str_cmp((char const *)bs->oem_name, "EXFAT   "))

  • uspace/srv/fs/exfat/exfat_fat.h

    re48947e r02082f3  
    7272extern int exfat_set_cluster(struct exfat_bs *, service_id_t, exfat_cluster_t,
    7373    exfat_cluster_t);
    74 extern int exfat_sanity_check(struct exfat_bs *);
     74extern int exfat_sanity_check(struct exfat_bs *, service_id_t);
    7575
    7676extern int exfat_append_clusters(struct exfat_bs *, struct exfat_node *,

  • uspace/srv/fs/exfat/exfat_ops.c

    re48947e r02082f3  
    10531053static int exfat_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    10541054{
    1055         int rc;
    1056         exfat_bs_t *bs;
    1057 
    1058         /* initialize libblock */
    1059         rc = block_init(service_id, BS_SIZE);
    1060         if (rc != EOK)
    1061                 return rc;
    1062 
    1063         /* prepare the boot block */
    1064         rc = block_bb_read(service_id, BS_BLOCK);
    1065         if (rc != EOK) {
    1066                 block_fini(service_id);
    1067                 return rc;
    1068         }
    1069 
    1070         /* get the buffer with the boot sector */
    1071         bs = block_bb_get(service_id);
    1072 
    1073         /* Do some simple sanity checks on the file system. */
    1074         rc = exfat_sanity_check(bs);
    1075 
    1076         (void) block_cache_fini(service_id);
    1077         block_fini(service_id);
    1078         return rc;
     1055        return ENOTSUP;
    10791056}
    10801057
    … …  
    11091086        bs = block_bb_get(service_id);
    11101087
    1111         /* Do some simple sanity checks on the file system. */
    1112         rc = exfat_sanity_check(bs);
    1113         if (rc != EOK) {
    1114                 (void) block_cache_fini(service_id);
    1115                 block_fini(service_id);
    1116                 return rc;
    1117         }
    1118 
    11191088        /* Initialize the block cache */
    11201089        rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, cmode);
    11211090        if (rc != EOK) {
     1091                block_fini(service_id);
     1092                return rc;
     1093        }
     1094
     1095        /* Do some simple sanity checks on the file system. */
     1096        rc = exfat_sanity_check(bs, service_id);
     1097        if (rc != EOK) {
     1098                (void) block_cache_fini(service_id);
    11221099                block_fini(service_id);
    11231100                return rc;

  • uspace/srv/fs/ext4fs/ext4fs.c

    re48947e r02082f3  
    7272        }
    7373       
    74         int rc = ext4_global_init();
     74        int rc = ext4fs_global_init();
    7575        if (rc != EOK) {
    7676                printf("%s: Global initialization failed\n", NAME);
    … …  
    7878        }
    7979       
    80         rc = fs_register(vfs_sess, &ext4fs_vfs_info, &ext4_ops,
    81             &ext4_libfs_ops);
     80        rc = fs_register(vfs_sess, &ext4fs_vfs_info, &ext4fs_ops,
     81            &ext4fs_libfs_ops);
    8282        if (rc != EOK) {
    8383                printf("%s: Failed to register file system\n", NAME);

  • uspace/srv/fs/fat/fat_ops.c

    re48947e r02082f3  
    915915static int fat_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    916916{
    917         fat_bs_t *bs;
    918         int rc;
    919 
    920         /* initialize libblock */
    921         rc = block_init(service_id, BS_SIZE);
    922         if (rc != EOK)
    923                 return rc;
    924 
    925         /* prepare the boot block */
    926         rc = block_bb_read(service_id, BS_BLOCK);
    927         if (rc != EOK) {
    928                 block_fini(service_id);
    929                 return rc;
    930         }
    931 
    932         /* get the buffer with the boot sector */
    933         bs = block_bb_get(service_id);
    934 
    935         if (BPS(bs) != BS_SIZE) {
    936                 block_fini(service_id);
    937                 return ENOTSUP;
    938         }
    939 
    940         /* Initialize the block cache */
    941         rc = block_cache_init(service_id, BPS(bs), 0 /* XXX */, CACHE_MODE_WB);
    942         if (rc != EOK) {
    943                 block_fini(service_id);
    944                 return rc;
    945         }
    946 
    947         /* Do some simple sanity checks on the file system. */
    948         rc = fat_sanity_check(bs, service_id);
    949 
    950         (void) block_cache_fini(service_id);
    951         block_fini(service_id);
    952 
    953         return rc;
     917        return ENOTSUP;
    954918}
    955919

  • uspace/srv/volsrv/mkfs.c

    re48947e r02082f3  
    119119                break;
    120120        case fs_ext4:
    121         case fs_cdfs:
    122121                cmd = NULL;
    123122                break;

  • uspace/srv/volsrv/part.c

    re48947e r02082f3  
    5353static FIBRIL_MUTEX_INITIALIZE(vol_parts_lock);
    5454
    55 struct fsname_type {
    56         const char *name;
    57         vol_fstype_t fstype;
    58 };
    59 
    60 static struct fsname_type fstab[] = {
    61         { "ext4fs", fs_ext4 },
    62         { "cdfs", fs_cdfs },
    63         { "exfat", fs_exfat },
    64         { "fat", fs_fat },
    65         { "mfs", fs_minix },
    66         { NULL, 0 }
    67 };
    68 
    6955/** Check for new partitions */
    7056static int vol_part_check_new(void)
    … …  
    148134        bool empty;
    149135        vfs_fs_probe_info_t info;
    150         struct fsname_type *fst;
    151136        int rc;
    152137
    … …  
    172157
    173158        log_msg(LOG_DEFAULT, LVL_NOTE, "Probe partition %s", part->svc_name);
    174 
    175         fst = &fstab[0];
    176         while (fst->name != NULL) {
    177                 rc = vfs_fsprobe(fst->name, sid, &info);
    178                 if (rc == EOK)
    179                         break;
    180                 ++fst;
    181         }
    182 
    183         if (fst->name != NULL) {
    184                 log_msg(LOG_DEFAULT, LVL_NOTE, "Found %s", fst->name);
     159        rc = vfs_fsprobe("mfs", sid, &info);
     160        if (rc == EOK) {
    185161                part->pcnt = vpc_fs;
    186                 part->fstype = fst->fstype;
     162                part->fstype = fs_minix;
    187163        } else {
    188164                log_msg(LOG_DEFAULT, LVL_NOTE, "Partition does not contain "
Note: See TracChangeset for help on using the changeset viewer.