Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r395df52 r81dd2ed  
    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
Note: See TracChangeset for help on using the changeset viewer.