Changeset be39fc6 in mainline


Ignore:
Timestamp:
2017-05-11T22:26:39Z (7 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
de5b708
Parents:
4bfad34
Message:

Adjust prefixes ext4fs → ext4 after moving code.

Location:
uspace
Files:
5 edited
1 moved

Legend:

Unmodified
Added
Removed

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

    r4bfad34 rbe39fc6  
    3939#include "ext4/types.h"
    4040
    41 extern int ext4_filesystem_init(ext4_filesystem_t *, ext4fs_instance_t *,
     41extern int ext4_filesystem_init(ext4_filesystem_t *, ext4_instance_t *,
    4242    service_id_t, enum cache_mode, aoff64_t *);
    4343extern int ext4_filesystem_fini(ext4_filesystem_t *);

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

    r4bfad34 rbe39fc6  
    11/*
     2 * Copyright (c) 2011 Martin Sucha
    23 * Copyright (c) 2012 Frantisek Princ
    34 * All rights reserved.
    … …  
    3132 */
    3233
    33 #ifndef LIBEXT4_H_
    34 #define LIBEXT4_H_
     34#ifndef LIBEXT4_FSTYPES_H_
     35#define LIBEXT4_FSTYPES_H_
    3536
    36 #include "ext4/balloc.h"
    37 #include "ext4/bitmap.h"
    38 #include "ext4/block_group.h"
    39 #include "ext4/directory.h"
    40 #include "ext4/directory_index.h"
    41 #include "ext4/extent.h"
    42 #include "ext4/filesystem.h"
    43 #include "ext4/hash.h"
    44 #include "ext4/ialloc.h"
    45 #include "ext4/inode.h"
    46 #include "ext4/superblock.h"
     37#include <adt/list.h>
     38#include <libfs.h>
     39#include <loc.h>
    4740#include "ext4/types.h"
    4841
    49 #include <stdio.h>
    50 #define EXT4FS_DBG(format, ...) \
    51         printf("ext4fs: %s: " format "\n", \
    52             __FUNCTION__, ##__VA_ARGS__) \
     42/**
     43 * Type for holding an instance of mounted partition.
     44 */
     45typedef struct ext4_instance {
     46        link_t link;
     47        service_id_t service_id;
     48        ext4_filesystem_t *filesystem;
     49        unsigned int open_nodes_count;
     50} ext4_instance_t;
     51
     52/**
     53 * Type for wrapping common fs_node and add some useful pointers.
     54 */
     55typedef struct ext4_node {
     56        ext4_instance_t *instance;
     57        ext4_inode_ref_t *inode_ref;
     58        fs_node_t *fs_node;
     59        ht_link_t link;
     60        unsigned int references;
     61} ext4_node_t;
     62
     63#define EXT4_NODE(node) \
     64        ((node) ? (ext4_node_t *) (node)->data : NULL)
    5365
    5466#endif

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

    r4bfad34 rbe39fc6  
    3737#include "ext4/fstypes.h"
    3838
    39 extern vfs_out_ops_t ext4fs_ops;
    40 extern libfs_ops_t ext4fs_libfs_ops;
     39extern vfs_out_ops_t ext4_ops;
     40extern libfs_ops_t ext4_libfs_ops;
    4141
    42 extern int ext4fs_global_init(void);
    43 extern int ext4fs_global_fini(void);
     42extern int ext4_global_init(void);
     43extern int ext4_global_fini(void);
    4444
    45 extern int ext4fs_node_get_core(fs_node_t **, ext4fs_instance_t *, fs_index_t);
    46 extern int ext4fs_node_put(fs_node_t *);
     45extern int ext4_node_get_core(fs_node_t **, ext4_instance_t *, fs_index_t);
     46extern int ext4_node_put(fs_node_t *);
    4747
    4848

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

    r4bfad34 rbe39fc6  
    6969 *
    7070 */
    71 int ext4_filesystem_init(ext4_filesystem_t *fs, ext4fs_instance_t *inst,
     71int ext4_filesystem_init(ext4_filesystem_t *fs, ext4_instance_t *inst,
    7272    service_id_t service_id, enum cache_mode cmode, aoff64_t *size)
    7373{
    … …  
    135135        /* Read root node */
    136136        fs_node_t *root_node;
    137         rc = ext4fs_node_get_core(&root_node, inst, EXT4_INODE_ROOT_INDEX);
     137        rc = ext4_node_get_core(&root_node, inst, EXT4_INODE_ROOT_INDEX);
    138138        if (rc != EOK)
    139139                goto err_2;
    … …  
    148148        ext4_superblock_set_mount_count(fs->superblock, mnt_count + 1);
    149149
    150         ext4fs_node_t *enode = EXT4FS_NODE(root_node);
     150        ext4_node_t *enode = EXT4_NODE(root_node);
    151151       
    152152        *size = ext4_inode_get_size(fs->superblock, enode->inode_ref->inode);
    153153
    154         ext4fs_node_put(root_node);
     154        ext4_node_put(root_node);
    155155        return EOK;
    156156err_3:
    157         ext4fs_node_put(root_node);
     157        ext4_node_put(root_node);
    158158err_2:
    159159        block_cache_fini(fs->device);

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

    r4bfad34 rbe39fc6  
    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"
     54#include "ext4/filesystem.h"
    4855#include "ext4/fstypes.h"
     56#include "ext4/superblock.h"
    4957
    5058/* Forward declarations of auxiliary functions */
    5159
    52 static int ext4fs_read_directory(ipc_callid_t, aoff64_t, size_t,
    53     ext4fs_instance_t *, ext4_inode_ref_t *, size_t *);
    54 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 *,
    5563    ext4_inode_ref_t *, size_t *);
    56 static bool ext4fs_is_dots(const uint8_t *, size_t);
    57 static int ext4fs_instance_get(service_id_t, ext4fs_instance_t **);
     64static bool ext4_is_dots(const uint8_t *, size_t);
     65static int ext4_instance_get(service_id_t, ext4_instance_t **);
    5866
    5967/* Forward declarations of ext4 libfs operations. */
    6068
    61 static int ext4fs_root_get(fs_node_t **, service_id_t);
    62 static int ext4fs_match(fs_node_t **, fs_node_t *, const char *);
    63 static int ext4fs_node_get(fs_node_t **, service_id_t, fs_index_t);
    64 static int ext4fs_node_open(fs_node_t *);
    65        int ext4fs_node_put(fs_node_t *);
    66 static int ext4fs_create_node(fs_node_t **, service_id_t, int);
    67 static int ext4fs_destroy_node(fs_node_t *);
    68 static int ext4fs_link(fs_node_t *, fs_node_t *, const char *);
    69 static int ext4fs_unlink(fs_node_t *, fs_node_t *, const char *);
    70 static int ext4fs_has_children(bool *, fs_node_t *);
    71 static fs_index_t ext4fs_index_get(fs_node_t *);
    72 static aoff64_t ext4fs_size_get(fs_node_t *);
    73 static unsigned ext4fs_lnkcnt_get(fs_node_t *);
    74 static bool ext4fs_is_directory(fs_node_t *);
    75 static bool ext4fs_is_file(fs_node_t *node);
    76 static service_id_t ext4fs_service_get(fs_node_t *node);
    77 static int ext4fs_size_block(service_id_t, uint32_t *);
    78 static int ext4fs_total_block_count(service_id_t, uint64_t *);
    79 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 *);
    8088
    8189/* Static variables */
    … …  
    101109static size_t open_nodes_hash(const ht_link_t *item)
    102110{
    103         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);
    104112        return hash_combine(enode->instance->service_id, enode->inode_ref->index);     
    105113}
    … …  
    108116{
    109117        node_key_t *key = (node_key_t *)key_arg;
    110         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);
    111119       
    112120        return key->service_id == enode->instance->service_id
    … …  
    130138 *
    131139 */
    132 int ext4fs_global_init(void)
     140int ext4_global_init(void)
    133141{
    134142        if (!hash_table_create(&open_nodes, 0, 0, &open_nodes_ops))
    … …  
    144152 * @return Error code
    145153 */
    146 int ext4fs_global_fini(void)
     154int ext4_global_fini(void)
    147155{
    148156        hash_table_destroy(&open_nodes);
    … …  
    162170 *
    163171 */
    164 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)
    165173{
    166174        fibril_mutex_lock(&instance_list_mutex);
    … …  
    171179        }
    172180       
    173         list_foreach(instance_list, link, ext4fs_instance_t, tmp) {
     181        list_foreach(instance_list, link, ext4_instance_t, tmp) {
    174182                if (tmp->service_id == service_id) {
    175183                        *inst = tmp;
    … …  
    191199 *
    192200 */
    193 int ext4fs_root_get(fs_node_t **rfn, service_id_t service_id)
    194 {
    195         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);
    196204}
    197205
    … …  
    207215 *
    208216 */
    209 int ext4fs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    210 {
    211         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);
    212220        ext4_filesystem_t *fs = eparent->instance->filesystem;
    213221       
    … …  
    231239        /* Load node from search result */
    232240        uint32_t inode = ext4_directory_entry_ll_get_inode(result.dentry);
    233         rc = ext4fs_node_get_core(rfn, eparent->instance, inode);
     241        rc = ext4_node_get_core(rfn, eparent->instance, inode);
    234242        if (rc != EOK)
    235243                goto exit;
    … …  
    254262 *
    255263 */
    256 int ext4fs_node_get(fs_node_t **rfn, service_id_t service_id, fs_index_t index)
    257 {
    258         ext4fs_instance_t *inst;
    259         int rc = ext4fs_instance_get(service_id, &inst);
    260         if (rc != EOK)
    261                 return rc;
    262        
    263         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);
    264272}
    265273
    … …  
    273281 *
    274282 */
    275 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,
    276284    fs_index_t index)
    277285{
    … …  
    285293       
    286294        ht_link_t *already_open = hash_table_find(&open_nodes, &key);
    287         ext4fs_node_t *enode = NULL;
     295        ext4_node_t *enode = NULL;
    288296        if (already_open) {
    289                 enode = hash_table_get_inst(already_open, ext4fs_node_t, link);
     297                enode = hash_table_get_inst(already_open, ext4_node_t, link);
    290298                *rfn = enode->fs_node;
    291299                enode->references++;
    … …  
    296304       
    297305        /* Prepare new enode */
    298         enode = malloc(sizeof(ext4fs_node_t));
     306        enode = malloc(sizeof(ext4_node_t));
    299307        if (enode == NULL) {
    300308                fibril_mutex_unlock(&open_nodes_lock);
    … …  
    347355 *
    348356 */
    349 static int ext4fs_node_put_core(ext4fs_node_t *enode)
     357static int ext4_node_put_core(ext4_node_t *enode)
    350358{
    351359        hash_table_remove_item(&open_nodes, &enode->link);
    … …  
    374382 *
    375383 */
    376 int ext4fs_node_open(fs_node_t *fn)
     384int ext4_node_open(fs_node_t *fn)
    377385{
    378386        /* Stateless operation */
    … …  
    388396 *
    389397 */
    390 int ext4fs_node_put(fs_node_t *fn)
     398int ext4_node_put(fs_node_t *fn)
    391399{
    392400        fibril_mutex_lock(&open_nodes_lock);
    393401       
    394         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     402        ext4_node_t *enode = EXT4_NODE(fn);
    395403        assert(enode->references > 0);
    396404        enode->references--;
    397405        if (enode->references == 0) {
    398                 int rc = ext4fs_node_put_core(enode);
     406                int rc = ext4_node_put_core(enode);
    399407                if (rc != EOK) {
    400408                        fibril_mutex_unlock(&open_nodes_lock);
    … …  
    417425 *
    418426 */
    419 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)
    420428{
    421429        /* Allocate enode */
    422         ext4fs_node_t *enode;
    423         enode = malloc(sizeof(ext4fs_node_t));
     430        ext4_node_t *enode;
     431        enode = malloc(sizeof(ext4_node_t));
    424432        if (enode == NULL)
    425433                return ENOMEM;
    … …  
    434442       
    435443        /* Load instance */
    436         ext4fs_instance_t *inst;
    437         int rc = ext4fs_instance_get(service_id, &inst);
     444        ext4_instance_t *inst;
     445        int rc = ext4_instance_get(service_id, &inst);
    438446        if (rc != EOK) {
    439447                free(enode);
    … …  
    478486 *
    479487 */
    480 int ext4fs_destroy_node(fs_node_t *fn)
     488int ext4_destroy_node(fs_node_t *fn)
    481489{
    482490        /* If directory, check for children */
    483491        bool has_children;
    484         int rc = ext4fs_has_children(&has_children, fn);
    485         if (rc != EOK) {
    486                 ext4fs_node_put(fn);
     492        int rc = ext4_has_children(&has_children, fn);
     493        if (rc != EOK) {
     494                ext4_node_put(fn);
    487495                return rc;
    488496        }
    489497       
    490498        if (has_children) {
    491                 ext4fs_node_put(fn);
     499                ext4_node_put(fn);
    492500                return EINVAL;
    493501        }
    494502       
    495         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     503        ext4_node_t *enode = EXT4_NODE(fn);
    496504        ext4_inode_ref_t *inode_ref = enode->inode_ref;
    497505       
    … …  
    499507        rc = ext4_filesystem_truncate_inode(inode_ref, 0);
    500508        if (rc != EOK) {
    501                 ext4fs_node_put(fn);
     509                ext4_node_put(fn);
    502510                return rc;
    503511        }
    … …  
    513521        rc = ext4_filesystem_free_inode(inode_ref);
    514522        if (rc != EOK) {
    515                 ext4fs_node_put(fn);
    516                 return rc;
    517         }
    518        
    519         return ext4fs_node_put(fn);
     523                ext4_node_put(fn);
     524                return rc;
     525        }
     526       
     527        return ext4_node_put(fn);
    520528}
    521529
    … …  
    529537 *
    530538 */
    531 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)
    532540{
    533541        /* Check maximum name length */
    … …  
    535543                return ENAMETOOLONG;
    536544       
    537         ext4fs_node_t *parent = EXT4FS_NODE(pfn);
    538         ext4fs_node_t *child = EXT4FS_NODE(cfn);
     545        ext4_node_t *parent = EXT4_NODE(pfn);
     546        ext4_node_t *child = EXT4_NODE(cfn);
    539547        ext4_filesystem_t *fs = parent->instance->filesystem;
    540548       
    … …  
    602610 *
    603611 */
    604 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)
    605613{
    606614        bool has_children;
    607         int rc = ext4fs_has_children(&has_children, cfn);
     615        int rc = ext4_has_children(&has_children, cfn);
    608616        if (rc != EOK)
    609617                return rc;
    … …  
    614622       
    615623        /* Remove entry from parent directory */
    616         ext4_inode_ref_t *parent = EXT4FS_NODE(pfn)->inode_ref;
     624        ext4_inode_ref_t *parent = EXT4_NODE(pfn)->inode_ref;
    617625        rc = ext4_directory_remove_entry(parent, name);
    618626        if (rc != EOK)
    … …  
    620628       
    621629        /* Decrement links count */
    622         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;
    623631       
    624632        uint32_t lnk_count =
    … …  
    627635       
    628636        /* If directory - handle links from parent */
    629         if ((lnk_count <= 1) && (ext4fs_is_directory(cfn))) {
     637        if ((lnk_count <= 1) && (ext4_is_directory(cfn))) {
    630638                assert(lnk_count == 1);
    631639               
    632640                lnk_count--;
    633641               
    634                 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;
    635643               
    636644                uint32_t parent_lnk_count = ext4_inode_get_links_count(
    … …  
    675683 *
    676684 */
    677 int ext4fs_has_children(bool *has_children, fs_node_t *fn)
    678 {
    679         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);
    680688        ext4_filesystem_t *fs = enode->instance->filesystem;
    681689       
    … …  
    699707                            ext4_directory_entry_ll_get_name_length(fs->superblock,
    700708                            it.current);
    701                         if (!ext4fs_is_dots(it.current->name, name_size)) {
     709                        if (!ext4_is_dots(it.current->name, name_size)) {
    702710                                found = true;
    703711                                break;
    … …  
    728736 *
    729737 */
    730 fs_index_t ext4fs_index_get(fs_node_t *fn)
    731 {
    732         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);
    733741        return enode->inode_ref->index;
    734742}
    … …  
    741749 *
    742750 */
    743 aoff64_t ext4fs_size_get(fs_node_t *fn)
    744 {
    745         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);
    746754        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
    747755        return ext4_inode_get_size(sb, enode->inode_ref->inode);
    … …  
    755763 *
    756764 */
    757 unsigned ext4fs_lnkcnt_get(fs_node_t *fn)
    758 {
    759         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     765unsigned ext4_lnkcnt_get(fs_node_t *fn)
     766{
     767        ext4_node_t *enode = EXT4_NODE(fn);
    760768        uint32_t lnkcnt = ext4_inode_get_links_count(enode->inode_ref->inode);
    761769       
    762         if (ext4fs_is_directory(fn)) {
     770        if (ext4_is_directory(fn)) {
    763771                if (lnkcnt > 1)
    764772                        return 1;
    … …  
    778786 *
    779787 */
    780 bool ext4fs_is_directory(fs_node_t *fn)
    781 {
    782         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     788bool ext4_is_directory(fs_node_t *fn)
     789{
     790        ext4_node_t *enode = EXT4_NODE(fn);
    783791        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
    784792       
    … …  
    794802 *
    795803 */
    796 bool ext4fs_is_file(fs_node_t *fn)
    797 {
    798         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     804bool ext4_is_file(fs_node_t *fn)
     805{
     806        ext4_node_t *enode = EXT4_NODE(fn);
    799807        ext4_superblock_t *sb = enode->instance->filesystem->superblock;
    800808       
    … …  
    810818 *
    811819 */
    812 service_id_t ext4fs_service_get(fs_node_t *fn)
    813 {
    814         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);
    815823        return enode->instance->service_id;
    816824}
    817825
    818 int ext4fs_size_block(service_id_t service_id, uint32_t *size)
    819 {
    820         ext4fs_instance_t *inst;
    821         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);
    822830        if (rc != EOK)
    823831                return rc;
    … …  
    832840}
    833841
    834 int ext4fs_total_block_count(service_id_t service_id, uint64_t *count)
    835 {
    836         ext4fs_instance_t *inst;
    837         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);
    838846        if (rc != EOK)
    839847                return rc;
    … …  
    848856}
    849857
    850 int ext4fs_free_block_count(service_id_t service_id, uint64_t *count)
    851 {
    852         ext4fs_instance_t *inst;
    853         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);
    854862        if (rc != EOK)
    855863                return rc;
    … …  
    864872 * libfs operations.
    865873 */
    866 libfs_ops_t ext4fs_libfs_ops = {
    867         .root_get = ext4fs_root_get,
    868         .match = ext4fs_match,
    869         .node_get = ext4fs_node_get,
    870         .node_open = ext4fs_node_open,
    871         .node_put = ext4fs_node_put,
    872         .create = ext4fs_create_node,
    873         .destroy = ext4fs_destroy_node,
    874         .link = ext4fs_link,
    875         .unlink = ext4fs_unlink,
    876         .has_children = ext4fs_has_children,
    877         .index_get = ext4fs_index_get,
    878         .size_get = ext4fs_size_get,
    879         .lnkcnt_get = ext4fs_lnkcnt_get,
    880         .is_directory = ext4fs_is_directory,
    881         .is_file = ext4fs_is_file,
    882         .service_get = ext4fs_service_get,
    883         .size_block = ext4fs_size_block,
    884         .total_block_count = ext4fs_total_block_count,
    885         .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
    886894};
    887895
    … …  
    899907 * @return Error code
    900908 */
    901 static int ext4fs_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
     909static int ext4_fsprobe(service_id_t service_id, vfs_fs_probe_info_t *info)
    902910{
    903911        return ENOTSUP;
    … …  
    917925 *
    918926 */
    919 static int ext4fs_mounted(service_id_t service_id, const char *opts,
     927static int ext4_mounted(service_id_t service_id, const char *opts,
    920928    fs_index_t *index, aoff64_t *size, unsigned *lnkcnt)
    921929{
    … …  
    927935       
    928936        /* Allocate instance structure */
    929         ext4fs_instance_t *inst = (ext4fs_instance_t *)
    930             malloc(sizeof(ext4fs_instance_t));
     937        ext4_instance_t *inst = (ext4_instance_t *)
     938            malloc(sizeof(ext4_instance_t));
    931939        if (inst == NULL) {
    932940                free(fs);
    … …  
    976984 *
    977985 */
    978 static int ext4fs_unmounted(service_id_t service_id)
    979 {
    980         ext4fs_instance_t *inst;
    981         int rc = ext4fs_instance_get(service_id, &inst);
     986static int ext4_unmounted(service_id_t service_id)
     987{
     988        ext4_instance_t *inst;
     989        int rc = ext4_instance_get(service_id, &inst);
    982990        if (rc != EOK)
    983991                return rc;
    … …  
    10101018 *
    10111019 */
    1012 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,
    10131021    size_t *rbytes)
    10141022{
    … …  
    10231031        }
    10241032       
    1025         ext4fs_instance_t *inst;
    1026         int rc = ext4fs_instance_get(service_id, &inst);
     1033        ext4_instance_t *inst;
     1034        int rc = ext4_instance_get(service_id, &inst);
    10271035        if (rc != EOK) {
    10281036                async_answer_0(callid, rc);
    … …  
    10411049        if (ext4_inode_is_type(inst->filesystem->superblock, inode_ref->inode,
    10421050            EXT4_INODE_MODE_FILE)) {
    1043                 rc = ext4fs_read_file(callid, pos, size, inst, inode_ref,
     1051                rc = ext4_read_file(callid, pos, size, inst, inode_ref,
    10441052                    rbytes);
    10451053        } else if (ext4_inode_is_type(inst->filesystem->superblock,
    10461054            inode_ref->inode, EXT4_INODE_MODE_DIRECTORY)) {
    1047                 rc = ext4fs_read_directory(callid, pos, size, inst, inode_ref,
     1055                rc = ext4_read_directory(callid, pos, size, inst, inode_ref,
    10481056                    rbytes);
    10491057        } else {
    … …  
    10661074 *
    10671075 */
    1068 bool ext4fs_is_dots(const uint8_t *name, size_t name_size)
     1076bool ext4_is_dots(const uint8_t *name, size_t name_size)
    10691077{
    10701078        if ((name_size == 1) && (name[0] == '.'))
    … …  
    10891097 *
    10901098 */
    1091 int ext4fs_read_directory(ipc_callid_t callid, aoff64_t pos, size_t size,
    1092     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)
    10931101{
    10941102        ext4_directory_iterator_t it;
    … …  
    11131121               
    11141122                /* Skip . and .. */
    1115                 if (ext4fs_is_dots(it.current->name, name_size))
     1123                if (ext4_is_dots(it.current->name, name_size))
    11161124                        goto skip;
    11171125               
    … …  
    11801188 *
    11811189 */
    1182 int ext4fs_read_file(ipc_callid_t callid, aoff64_t pos, size_t size,
    1183     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)
    11841192{
    11851193        ext4_superblock_t *sb = inst->filesystem->superblock;
    … …  
    12691277 *
    12701278 */
    1271 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,
    12721280    size_t *wbytes, aoff64_t *nsize)
    12731281{
    12741282        fs_node_t *fn;
    1275         int rc = ext4fs_node_get(&fn, service_id, index);
     1283        int rc = ext4_node_get(&fn, service_id, index);
    12761284        if (rc != EOK)
    12771285                return rc;
    … …  
    12851293        }
    12861294       
    1287         ext4fs_node_t *enode = EXT4FS_NODE(fn);
     1295        ext4_node_t *enode = EXT4_NODE(fn);
    12881296        ext4_filesystem_t *fs = enode->instance->filesystem;
    12891297       
    … …  
    13911399        ;
    13921400
    1393         int const rc2 = ext4fs_node_put(fn);
     1401        int const rc2 = ext4_node_put(fn);
    13941402        return rc == EOK ? rc2 : rc;
    13951403}
    … …  
    14061414 *
    14071415 */
    1408 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,
    14091417    aoff64_t new_size)
    14101418{
    14111419        fs_node_t *fn;
    1412         int rc = ext4fs_node_get(&fn, service_id, index);
    1413         if (rc != EOK)
    1414                 return rc;
    1415        
    1416         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);
    14171425        ext4_inode_ref_t *inode_ref = enode->inode_ref;
    14181426       
    14191427        rc = ext4_filesystem_truncate_inode(inode_ref, new_size);
    1420         int const rc2 = ext4fs_node_put(fn);
     1428        int const rc2 = ext4_node_put(fn);
    14211429       
    14221430        return rc == EOK ? rc2 : rc;
    … …  
    14311439 *
    14321440 */
    1433 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)
    14341442{
    14351443        return EOK;
    … …  
    14441452 *
    14451453 */
    1446 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)
    14471455{
    14481456        fs_node_t *fn;
    1449         int rc = ext4fs_node_get(&fn, service_id, index);
     1457        int rc = ext4_node_get(&fn, service_id, index);
    14501458        if (rc != EOK)
    14511459                return rc;
    14521460       
    14531461        /* Destroy the inode */
    1454         return ext4fs_destroy_node(fn);
     1462        return ext4_destroy_node(fn);
    14551463}
    14561464
    … …  
    14611469 *
    14621470 */
    1463 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)
    14641472{
    14651473        fs_node_t *fn;
    1466         int rc = ext4fs_node_get(&fn, service_id, index);
    1467         if (rc != EOK)
    1468                 return rc;
    1469        
    1470         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);
    14711479        enode->inode_ref->dirty = true;
    14721480       
    1473         return ext4fs_node_put(fn);
     1481        return ext4_node_put(fn);
    14741482}
    14751483
    … …  
    14771485 *
    14781486 */
    1479 vfs_out_ops_t ext4fs_ops = {
    1480         .fsprobe = ext4fs_fsprobe,
    1481         .mounted = ext4fs_mounted,
    1482         .unmounted = ext4fs_unmounted,
    1483         .read = ext4fs_read,
    1484         .write = ext4fs_write,
    1485         .truncate = ext4fs_truncate,
    1486         .close = ext4fs_close,
    1487         .destroy = ext4fs_destroy,
    1488         .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
    14891497};
    14901498

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

    r4bfad34 rbe39fc6  
    7272        }
    7373       
    74         int rc = ext4fs_global_init();
     74        int rc = ext4_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, &ext4fs_ops,
    81             &ext4fs_libfs_ops);
     80        rc = fs_register(vfs_sess, &ext4fs_vfs_info, &ext4_ops,
     81            &ext4_libfs_ops);
    8282        if (rc != EOK) {
    8383                printf("%s: Failed to register file system\n", NAME);
Note: See TracChangeset for help on using the changeset viewer.