Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/ext4/src/ops.c

    r81dd2ed r395df52  
    3232 */
    3333/**
    34  * @file  ext4fs_ops.c
     34 * @file  ops.c
    3535 * @brief Operations for ext4 filesystem.
    3636 */
    3737
     38#include <adt/hash_table.h>
     39#include <adt/hash.h>
    3840#include <errno.h>
    39 #include <ext4/libext4.h>
    4041#include <fibril_synch.h>
    4142#include <libfs.h>
    4243#include <macros.h>
    4344#include <malloc.h>
    44 #include <adt/hash_table.h>
    45 #include <adt/hash.h>
     45#include <mem.h>
     46#include <str.h>
    4647#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"
    4753#include "ext4/ops.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  */
    56 typedef 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  */
    66 typedef 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;
     54#include "ext4/filesystem.h"
     55#include "ext4/fstypes.h"
     56#include "ext4/superblock.h"
    7357
    7458/* Forward declarations of auxiliary functions */
    7559
    76 static int ext4fs_read_directory(ipc_callid_t, aoff64_t, size_t,
    77     ext4fs_instance_t *, ext4_inode_ref_t *, size_t *);
    78 static int ext4fs_read_file(ipc_callid_t, aoff64_t, size_t, ext4fs_instance_t *,
     60static int ext4_read_directory(ipc_callid_t, aoff64_t, size_t,
     61    ext4_instance_t *, ext4_inode_ref_t *, size_t *);
     62static int ext4_read_file(ipc_callid_t, aoff64_t, size_t, ext4_instance_t *,
    7963    ext4_inode_ref_t *, size_t *);
    80 static bool ext4fs_is_dots(const uint8_t *, size_t);
    81 static int ext4fs_instance_get(service_id_t, ext4fs_instance_t **);
    82 static int ext4fs_node_get_core(fs_node_t **, ext4fs_instance_t *, fs_index_t);
    83 static int ext4fs_node_put_core(ext4fs_node_t *);
     64static bool ext4_is_dots(const uint8_t *, size_t);
     65static int ext4_instance_get(service_id_t, ext4_instance_t **);
    8466
    8567/* Forward declarations of ext4 libfs operations. */
    8668
    87 static int ext4fs_root_get(fs_node_t **, service_id_t);
    88 static int ext4fs_match(fs_node_t **, fs_node_t *, const char *);
    89 static int ext4fs_node_get(fs_node_t **, service_id_t, fs_index_t);
    90 static int ext4fs_node_open(fs_node_t *);
    91 static int ext4fs_node_put(fs_node_t *);
    92 static int ext4fs_create_node(fs_node_t **, service_id_t, int);
    93 static int ext4fs_destroy_node(fs_node_t *);
    94 static int ext4fs_link(fs_node_t *, fs_node_t *, const char *);
    95 static int ext4fs_unlink(fs_node_t *, fs_node_t *, const char *);
    96 static int ext4fs_has_children(bool *, fs_node_t *);
    97 static fs_index_t ext4fs_index_get(fs_node_t *);
    98 static aoff64_t ext4fs_size_get(fs_node_t *);
    99 static unsigned ext4fs_lnkcnt_get(fs_node_t *);
    100 static bool ext4fs_is_directory(fs_node_t *);
    101 static bool ext4fs_is_file(fs_node_t *node);
    102 static service_id_t ext4fs_service_get(fs_node_t *node);
    103 static int ext4fs_size_block(service_id_t, uint32_t *);
    104 static int ext4fs_total_block_count(service_id_t, uint64_t *);
    105 static int ext4fs_free_block_count(service_id_t, uint64_t *);
     69static int ext4_root_get(fs_node_t **, service_id_t);
     70static int ext4_match(fs_node_t **, fs_node_t *, const char *);
     71static int ext4_node_get(fs_node_t **, service_id_t, fs_index_t);
     72static int ext4_node_open(fs_node_t *);
     73       int ext4_node_put(fs_node_t *);
     74static int ext4_create_node(fs_node_t **, service_id_t, int);
     75static int ext4_destroy_node(fs_node_t *);
     76static int ext4_link(fs_node_t *, fs_node_t *, const char *);
     77static int ext4_unlink(fs_node_t *, fs_node_t *, const char *);
     78static int ext4_has_children(bool *, fs_node_t *);
     79static fs_index_t ext4_index_get(fs_node_t *);
     80static aoff64_t ext4_size_get(fs_node_t *);
     81static unsigned ext4_lnkcnt_get(fs_node_t *);
     82static bool ext4_is_directory(fs_node_t *);
     83static bool ext4_is_file(fs_node_t *node);
     84static service_id_t ext4_service_get(fs_node_t *node);
     85static int ext4_size_block(service_id_t, uint32_t *);
     86static int ext4_total_block_count(service_id_t, uint64_t *);
     87static int ext4_free_block_count(service_id_t, uint64_t *);
    10688
    10789/* Static variables */
     
    127109static size_t open_nodes_hash(const ht_link_t *item)
    128110{
    129         ext4fs_node_t *enode = hash_table_get_inst(item, ext4fs_node_t, link);
     111        ext4_node_t *enode = hash_table_get_inst(item, ext4_node_t, link);
    130112        return hash_combine(enode->instance->service_id, enode->inode_ref->index);     
    131113}
     
    134116{
    135117        node_key_t *key = (node_key_t *)key_arg;
    136         ext4fs_node_t *enode = hash_table_get_inst(item, ext4fs_node_t, link);
     118        ext4_node_t *enode = hash_table_get_inst(item, ext4_node_t, link);
    137119       
    138120        return key->service_id == enode->instance->service_id
     
    156138 *
    157139 */
    158 int ext4fs_global_init(void)
     140int ext4_global_init(void)
    159141{
    160142        if (!hash_table_create(&open_nodes, 0, 0, &open_nodes_ops))
     
    170152 * @return Error code
    171153 */
    172 int ext4fs_global_fini(void)
     154int ext4_global_fini(void)
    173155{
    174156        hash_table_destroy(&open_nodes);
     
    188170 *
    189171 */
    190 int ext4fs_instance_get(service_id_t service_id, ext4fs_instance_t **inst)
     172int ext4_instance_get(service_id_t service_id, ext4_instance_t **inst)
    191173{
    192174        fibril_mutex_lock(&instance_list_mutex);
     
    197179        }
    198180       
    199         list_foreach(instance_list, link, ext4fs_instance_t, tmp) {
     181        list_foreach(instance_list, link, ext4_instance_t, tmp) {
    200182                if (tmp->service_id == service_id) {
    201183                        *inst = tmp;
     
    217199 *
    218200 */
    219 int 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);
     201int 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);
    222204}
    223205
     
    233215 *
    234216 */
    235 int ext4fs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    236 {
    237         ext4fs_node_t *eparent = EXT4FS_NODE(pfn);
     217int ext4_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     218{
     219        ext4_node_t *eparent = EXT4_NODE(pfn);
    238220        ext4_filesystem_t *fs = eparent->instance->filesystem;
    239221       
     
    257239        /* Load node from search result */
    258240        uint32_t inode = ext4_directory_entry_ll_get_inode(result.dentry);
    259         rc = ext4fs_node_get_core(rfn, eparent->instance, inode);
     241        rc = ext4_node_get_core(rfn, eparent->instance, inode);
    260242        if (rc != EOK)
    261243                goto exit;
     
    280262 *
    281263 */
    282 int 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);
     264int 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);
    290272}
    291273
     
    299281 *
    300282 */
    301 int ext4fs_node_get_core(fs_node_t **rfn, ext4fs_instance_t *inst,
     283int ext4_node_get_core(fs_node_t **rfn, ext4_instance_t *inst,
    302284    fs_index_t index)
    303285{
     
    311293       
    312294        ht_link_t *already_open = hash_table_find(&open_nodes, &key);
    313         ext4fs_node_t *enode = NULL;
     295        ext4_node_t *enode = NULL;
    314296        if (already_open) {
    315                 enode = hash_table_get_inst(already_open, ext4fs_node_t, link);
     297                enode = hash_table_get_inst(already_open, ext4_node_t, link);
    316298                *rfn = enode->fs_node;
    317299                enode->references++;
     
    322304       
    323305        /* Prepare new enode */
    324         enode = malloc(sizeof(ext4fs_node_t));
     306        enode = malloc(sizeof(ext4_node_t));
    325307        if (enode == NULL) {
    326308                fibril_mutex_unlock(&open_nodes_lock);
     
    373355 *
    374356 */
    375 int ext4fs_node_put_core(ext4fs_node_t *enode)
     357static int ext4_node_put_core(ext4_node_t *enode)
    376358{
    377359        hash_table_remove_item(&open_nodes, &enode->link);
     
    400382 *
    401383 */
    402 int ext4fs_node_open(fs_node_t *fn)
     384int ext4_node_open(fs_node_t *fn)
    403385{
    404386        /* Stateless operation */
     
    414396 *
    415397 */
    416 int ext4fs_node_put(fs_node_t *fn)
     398int ext4_node_put(fs_node_t *fn)
    417399{
    418400        fibril_mutex_lock(&open_nodes_lock);
    419401       
    420         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     402        ext4_node_t *enode = EXT4_NODE(fn);
    421403        assert(enode->references > 0);
    422404        enode->references--;
    423405        if (enode->references == 0) {
    424                 int rc = ext4fs_node_put_core(enode);
     406                int rc = ext4_node_put_core(enode);
    425407                if (rc != EOK) {
    426408                        fibril_mutex_unlock(&open_nodes_lock);
     
    443425 *
    444426 */
    445 int ext4fs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     427int ext4_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    446428{
    447429        /* Allocate enode */
    448         ext4fs_node_t *enode;
    449         enode = malloc(sizeof(ext4fs_node_t));
     430        ext4_node_t *enode;
     431        enode = malloc(sizeof(ext4_node_t));
    450432        if (enode == NULL)
    451433                return ENOMEM;
     
    460442       
    461443        /* Load instance */
    462         ext4fs_instance_t *inst;
    463         int rc = ext4fs_instance_get(service_id, &inst);
     444        ext4_instance_t *inst;
     445        int rc = ext4_instance_get(service_id, &inst);
    464446        if (rc != EOK) {
    465447                free(enode);
     
    504486 *
    505487 */
    506 int ext4fs_destroy_node(fs_node_t *fn)
     488int ext4_destroy_node(fs_node_t *fn)
    507489{
    508490        /* If directory, check for children */
    509491        bool has_children;
    510         int rc = ext4fs_has_children(&has_children, fn);
    511         if (rc != EOK) {
    512                 ext4fs_node_put(fn);
     492        int rc = ext4_has_children(&has_children, fn);
     493        if (rc != EOK) {
     494                ext4_node_put(fn);
    513495                return rc;
    514496        }
    515497       
    516498        if (has_children) {
    517                 ext4fs_node_put(fn);
     499                ext4_node_put(fn);
    518500                return EINVAL;
    519501        }
    520502       
    521         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     503        ext4_node_t *enode = EXT4_NODE(fn);
    522504        ext4_inode_ref_t *inode_ref = enode->inode_ref;
    523505       
     
    525507        rc = ext4_filesystem_truncate_inode(inode_ref, 0);
    526508        if (rc != EOK) {
    527                 ext4fs_node_put(fn);
     509                ext4_node_put(fn);
    528510                return rc;
    529511        }
     
    539521        rc = ext4_filesystem_free_inode(inode_ref);
    540522        if (rc != EOK) {
    541                 ext4fs_node_put(fn);
    542                 return rc;
    543         }
    544        
    545         return ext4fs_node_put(fn);
     523                ext4_node_put(fn);
     524                return rc;
     525        }
     526       
     527        return ext4_node_put(fn);
    546528}
    547529
     
    555537 *
    556538 */
    557 int ext4fs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     539int ext4_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    558540{
    559541        /* Check maximum name length */
     
    561543                return ENAMETOOLONG;
    562544       
    563         ext4fs_node_t *parent = EXT4FS_NODE(pfn);
    564         ext4fs_node_t *child = EXT4FS_NODE(cfn);
     545        ext4_node_t *parent = EXT4_NODE(pfn);
     546        ext4_node_t *child = EXT4_NODE(cfn);
    565547        ext4_filesystem_t *fs = parent->instance->filesystem;
    566548       
     
    628610 *
    629611 */
    630 int ext4fs_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     612int ext4_unlink(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    631613{
    632614        bool has_children;
    633         int rc = ext4fs_has_children(&has_children, cfn);
     615        int rc = ext4_has_children(&has_children, cfn);
    634616        if (rc != EOK)
    635617                return rc;
     
    640622       
    641623        /* Remove entry from parent directory */
    642         ext4_inode_ref_t *parent = EXT4FS_NODE(pfn)->inode_ref;
     624        ext4_inode_ref_t *parent = EXT4_NODE(pfn)->inode_ref;
    643625        rc = ext4_directory_remove_entry(parent, name);
    644626        if (rc != EOK)
     
    646628       
    647629        /* Decrement links count */
    648         ext4_inode_ref_t *child_inode_ref = EXT4FS_NODE(cfn)->inode_ref;
     630        ext4_inode_ref_t *child_inode_ref = EXT4_NODE(cfn)->inode_ref;
    649631       
    650632        uint32_t lnk_count =
     
    653635       
    654636        /* If directory - handle links from parent */
    655         if ((lnk_count <= 1) && (ext4fs_is_directory(cfn))) {
     637        if ((lnk_count <= 1) && (ext4_is_directory(cfn))) {
    656638                assert(lnk_count == 1);
    657639               
    658640                lnk_count--;
    659641               
    660                 ext4_inode_ref_t *parent_inode_ref = EXT4FS_NODE(pfn)->inode_ref;
     642                ext4_inode_ref_t *parent_inode_ref = EXT4_NODE(pfn)->inode_ref;
    661643               
    662644                uint32_t parent_lnk_count = ext4_inode_get_links_count(
     
    701683 *
    702684 */
    703 int ext4fs_has_children(bool *has_children, fs_node_t *fn)
    704 {
    705         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     685int ext4_has_children(bool *has_children, fs_node_t *fn)
     686{
     687        ext4_node_t *enode = EXT4_NODE(fn);
    706688        ext4_filesystem_t *fs = enode->instance->filesystem;
    707689       
     
    725707                            ext4_directory_entry_ll_get_name_length(fs->superblock,
    726708                            it.current);
    727                         if (!ext4fs_is_dots(it.current->name, name_size)) {
     709                        if (!ext4_is_dots(it.current->name, name_size)) {
    728710                                found = true;
    729711                                break;
     
    754736 *
    755737 */
    756 fs_index_t ext4fs_index_get(fs_node_t *fn)
    757 {
    758         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     738fs_index_t ext4_index_get(fs_node_t *fn)
     739{
     740        ext4_node_t *enode = EXT4_NODE(fn);
    759741        return enode->inode_ref->index;
    760742}
     
    767749 *
    768750 */
    769 aoff64_t ext4fs_size_get(fs_node_t *fn)
    770 {
    771         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     751aoff64_t ext4_size_get(fs_node_t *fn)
     752{
     753        ext4_node_t *enode = EXT4_NODE(fn);
    772754        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
    773755        return ext4_inode_get_size(sb, enode->inode_ref->inode);
     
    781763 *
    782764 */
    783 unsigned ext4fs_lnkcnt_get(fs_node_t *fn)
    784 {
    785         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     765unsigned ext4_lnkcnt_get(fs_node_t *fn)
     766{
     767        ext4_node_t *enode = EXT4_NODE(fn);
    786768        uint32_t lnkcnt = ext4_inode_get_links_count(enode->inode_ref->inode);
    787769       
    788         if (ext4fs_is_directory(fn)) {
     770        if (ext4_is_directory(fn)) {
    789771                if (lnkcnt > 1)
    790772                        return 1;
     
    804786 *
    805787 */
    806 bool ext4fs_is_directory(fs_node_t *fn)
    807 {
    808         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     788bool ext4_is_directory(fs_node_t *fn)
     789{
     790        ext4_node_t *enode = EXT4_NODE(fn);
    809791        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
    810792       
     
    820802 *
    821803 */
    822 bool ext4fs_is_file(fs_node_t *fn)
    823 {
    824         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     804bool ext4_is_file(fs_node_t *fn)
     805{
     806        ext4_node_t *enode = EXT4_NODE(fn);
    825807        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
    826808       
     
    836818 *
    837819 */
    838 service_id_t ext4fs_service_get(fs_node_t *fn)
    839 {
    840         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     820service_id_t ext4_service_get(fs_node_t *fn)
     821{
     822        ext4_node_t *enode = EXT4_NODE(fn);
    841823        return enode->instance->service_id;
    842824}
    843825
    844 int 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);
     826int 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);
    848830        if (rc != EOK)
    849831                return rc;
     
    858840}
    859841
    860 int 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);
     842int 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);
    864846        if (rc != EOK)
    865847                return rc;
     
    874856}
    875857
    876 int 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);
     858int 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);
    880862        if (rc != EOK)
    881863                return rc;
     
    890872 * libfs operations.
    891873 */
    892 libfs_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
     874libfs_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
    912894};
    913895
     
    925907 * @return Error code
    926908 */
    927 static int ext4fs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    928 {
    929         return ENOTSUP;
     909static int ext4_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     910{
     911        return ext4_filesystem_probe(service_id);
    930912}
    931913
     
    943925 *
    944926 */
    945 static int ext4fs_mounted(service_id_t service_id, const char *opts,
     927static int ext4_mounted(service_id_t service_id, const char *opts,
    946928    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
    947929{
    948         /* Allocate libext4 filesystem structure */
    949         ext4_filesystem_t *fs = (ext4_filesystem_t *)
    950             malloc(sizeof(ext4_filesystem_t));
    951         if (fs == NULL)
     930        ext4_filesystem_t *fs;
     931       
     932        /* Allocate instance structure */
     933        ext4_instance_t *inst = (ext4_instance_t *)
     934            malloc(sizeof(ext4_instance_t));
     935        if (inst == NULL)
    952936                return ENOMEM;
    953        
    954         /* Allocate instance structure */
    955         ext4fs_instance_t *inst = (ext4fs_instance_t *)
    956             malloc(sizeof(ext4fs_instance_t));
    957         if (inst == NULL) {
    958                 free(fs);
    959                 return ENOMEM;
    960         }
    961937       
    962938        enum cache_mode cmode;
     
    966942                cmode = CACHE_MODE_WB;
    967943       
    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        
    986944        /* Initialize instance */
    987945        link_initialize(&inst->link);
    988946        inst->service_id = service_id;
    989         inst->filesystem = fs;
    990947        inst->open_nodes_count = 0;
    991948       
    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);
     949        /* Initialize the filesystem */
     950        aoff64_t rnsize;
     951        int rc = ext4_filesystem_open(inst, service_id, cmode, &rnsize, &fs);
     952        if (rc != EOK) {
    998953                free(inst);
    999954                return rc;
     
    1005960        fibril_mutex_unlock(&instance_list_mutex);
    1006961       
    1007         ext4fs_node_t *enode = EXT4FS_NODE(root_node);
    1008        
    1009962        *index = EXT4_INODE_ROOT_INDEX;
    1010         *size = ext4_inode_get_size(fs->superblock, enode->inode_ref->inode);
     963        *size = rnsize;
    1011964        *lnkcnt = 1;
    1012965       
    1013         return ext4fs_node_put(root_node);
     966        return EOK;
    1014967}
    1015968
     
    1023976 *
    1024977 */
    1025 static int ext4fs_unmounted(service_id_t service_id)
    1026 {
    1027         ext4fs_instance_t *inst;
    1028         int rc = ext4fs_instance_get(service_id, &inst);
     978static int ext4_unmounted(service_id_t service_id)
     979{
     980        ext4_instance_t *inst;
     981        int rc = ext4_instance_get(service_id, &inst);
    1029982        if (rc != EOK)
    1030983                return rc;
     
    1044997        fibril_mutex_unlock(&open_nodes_lock);
    1045998       
    1046         return ext4_filesystem_fini(inst->filesystem);
     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;
    10471008}
    10481009
     
    10571018 *
    10581019 */
    1059 static int ext4fs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1020static int ext4_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    10601021    size_t *rbytes)
    10611022{
     
    10701031        }
    10711032       
    1072         ext4fs_instance_t *inst;
    1073         int rc = ext4fs_instance_get(service_id, &inst);
     1033        ext4_instance_t *inst;
     1034        int rc = ext4_instance_get(service_id, &inst);
    10741035        if (rc != EOK) {
    10751036                async_answer_0(callid, rc);
     
    10881049        if (ext4_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
    10891050            EXT4_INODE_MODE_FILE)) {
    1090                 rc = ext4fs_read_file(callid, pos, size, inst, inode_ref,
     1051                rc = ext4_read_file(callid, pos, size, inst, inode_ref,
    10911052                    rbytes);
    10921053        } else if (ext4_inode_is_type(inst->filesystem->superblock,
    10931054            inode_ref->inode, EXT4_INODE_MODE_DIRECTORY)) {
    1094                 rc = ext4fs_read_directory(callid, pos, size, inst, inode_ref,
     1055                rc = ext4_read_directory(callid, pos, size, inst, inode_ref,
    10951056                    rbytes);
    10961057        } else {
     
    11131074 *
    11141075 */
    1115 bool ext4fs_is_dots(const uint8_t *name, size_t name_size)
     1076bool ext4_is_dots(const uint8_t *name, size_t name_size)
    11161077{
    11171078        if ((name_size == 1) && (name[0] == '.'))
     
    11361097 *
    11371098 */
    1138 int 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)
     1099int 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)
    11401101{
    11411102        ext4_directory_iterator_t it;
     
    11601121               
    11611122                /* Skip . and .. */
    1162                 if (ext4fs_is_dots(it.current->name, name_size))
     1123                if (ext4_is_dots(it.current->name, name_size))
    11631124                        goto skip;
    11641125               
     
    12271188 *
    12281189 */
    1229 int 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)
     1190int 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)
    12311192{
    12321193        ext4_superblock_t *sb = inst->filesystem->superblock;
     
    13161277 *
    13171278 */
    1318 static int ext4fs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
     1279static int ext4_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    13191280    size_t *wbytes, aoff64_t *nsize)
    13201281{
    13211282        fs_node_t *fn;
    1322         int rc = ext4fs_node_get(&fn, service_id, index);
     1283        int rc = ext4_node_get(&fn, service_id, index);
    13231284        if (rc != EOK)
    13241285                return rc;
     
    13321293        }
    13331294       
    1334         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     1295        ext4_node_t *enode = EXT4_NODE(fn);
    13351296        ext4_filesystem_t *fs = enode->instance->filesystem;
    13361297       
     
    14381399        ;
    14391400
    1440         int const rc2 = ext4fs_node_put(fn);
     1401        int const rc2 = ext4_node_put(fn);
    14411402        return rc == EOK ? rc2 : rc;
    14421403}
     
    14531414 *
    14541415 */
    1455 static int ext4fs_truncate(service_id_t service_id, fs_index_t index,
     1416static int ext4_truncate(service_id_t service_id, fs_index_t index,
    14561417    aoff64_t new_size)
    14571418{
    14581419        fs_node_t *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);
     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);
    14641425        ext4_inode_ref_t *inode_ref = enode->inode_ref;
    14651426       
    14661427        rc = ext4_filesystem_truncate_inode(inode_ref, new_size);
    1467         int const rc2 = ext4fs_node_put(fn);
     1428        int const rc2 = ext4_node_put(fn);
    14681429       
    14691430        return rc == EOK ? rc2 : rc;
     
    14781439 *
    14791440 */
    1480 static int ext4fs_close(service_id_t service_id, fs_index_t index)
     1441static int ext4_close(service_id_t service_id, fs_index_t index)
    14811442{
    14821443        return EOK;
     
    14911452 *
    14921453 */
    1493 static int ext4fs_destroy(service_id_t service_id, fs_index_t index)
     1454static int ext4_destroy(service_id_t service_id, fs_index_t index)
    14941455{
    14951456        fs_node_t *fn;
    1496         int rc = ext4fs_node_get(&fn, service_id, index);
     1457        int rc = ext4_node_get(&fn, service_id, index);
    14971458        if (rc != EOK)
    14981459                return rc;
    14991460       
    15001461        /* Destroy the inode */
    1501         return ext4fs_destroy_node(fn);
     1462        return ext4_destroy_node(fn);
    15021463}
    15031464
     
    15081469 *
    15091470 */
    1510 static int ext4fs_sync(service_id_t service_id, fs_index_t index)
     1471static int ext4_sync(service_id_t service_id, fs_index_t index)
    15111472{
    15121473        fs_node_t *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);
     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);
    15181479        enode->inode_ref->dirty = true;
    15191480       
    1520         return ext4fs_node_put(fn);
     1481        return ext4_node_put(fn);
    15211482}
    15221483
     
    15241485 *
    15251486 */
    1526 vfs_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
     1487vfs_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
    15361497};
    15371498
Note: See TracChangeset for help on using the changeset viewer.