Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/mfs/mfs_ops.c

    rdf3caec5 r36cb22f  
    4343
    4444static bool check_magic_number(uint16_t magic, bool *native,
    45     mfs_version_t *version, bool *longfilenames);
     45                               mfs_version_t *version, bool *longfilenames);
    4646static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
    47     fs_index_t index);
     47                             fs_index_t index);
     48
    4849static int mfs_node_put(fs_node_t *fsnode);
    4950static int mfs_node_open(fs_node_t *fsnode);
    … …  
    6364static hash_index_t open_nodes_hash(unsigned long key[]);
    6465static int open_nodes_compare(unsigned long key[], hash_count_t keys,
    65     link_t *item);
     66                link_t *item);
    6667static void open_nodes_remove_cb(link_t *link);
     68
    6769static int mfs_node_get(fs_node_t **rfn, service_id_t service_id,
    68     fs_index_t index);
    69 static int mfs_instance_get(service_id_t service_id,
    70     struct mfs_instance **instance);
    71 static int mfs_check_sanity(struct mfs_sb_info *sbi);
    72 static bool is_power_of_two(uint32_t n);
     70                        fs_index_t index);
     71static int
     72mfs_instance_get(service_id_t service_id, struct mfs_instance **instance);
     73
    7374
    7475static hash_table_t open_nodes;
    … …  
    9596
    9697/* Hash table interface for open nodes hash table */
    97 static hash_index_t
    98 open_nodes_hash(unsigned long key[])
     98static hash_index_t open_nodes_hash(unsigned long key[])
    9999{
    100100        /* TODO: This is very simple and probably can be improved */
    … …  
    102102}
    103103
    104 static int
    105 open_nodes_compare(unsigned long key[], hash_count_t keys,
    106     link_t *item)
     104static int open_nodes_compare(unsigned long key[], hash_count_t keys,
     105                link_t *item)
    107106{
    108107        struct mfs_node *mnode = hash_table_get_instance(item, struct mfs_node, link);
    … …  
    119118}
    120119
    121 static void
    122 open_nodes_remove_cb(link_t *link)
     120static void open_nodes_remove_cb(link_t *link)
    123121{
    124122        /* We don't use remove callback for this hash table */
    … …  
    131129};
    132130
    133 int
    134 mfs_global_init(void)
     131int mfs_global_init(void)
    135132{
    136133        if (!hash_table_create(&open_nodes, OPEN_NODES_BUCKETS,
    137             OPEN_NODES_KEYS, &open_nodes_ops)) {
     134                        OPEN_NODES_KEYS, &open_nodes_ops)) {
    138135                return ENOMEM;
    139136        }
    … …  
    143140static int
    144141mfs_mounted(service_id_t service_id, const char *opts, fs_index_t *index,
    145     aoff64_t *size, unsigned *linkcnt)
     142                aoff64_t *size, unsigned *linkcnt)
    146143{
    147144        enum cache_mode cmode;
    … …  
    166163                return rc;
    167164
    168         /* Allocate space for generic MFS superblock */
     165        /*Allocate space for generic MFS superblock*/
    169166        sbi = malloc(sizeof(*sbi));
    170167        if (!sbi) {
    … …  
    173170        }
    174171
    175         /* Allocate space for filesystem instance */
     172        /*Allocate space for filesystem instance*/
    176173        instance = malloc(sizeof(*instance));
    177174        if (!instance) {
    … …  
    194191
    195192        if (check_magic_number(sb->s_magic, &native, &version, &longnames)) {
    196                 /* This is a V1 or V2 Minix filesystem */
     193                /*This is a V1 or V2 Minix filesystem*/
    197194                magic = sb->s_magic;
    198195        } else if (check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
    199                 /* This is a V3 Minix filesystem */
     196                /*This is a V3 Minix filesystem*/
    200197                magic = sb3->s_magic;
    201198        } else {
    202                 /* Not recognized */
     199                /*Not recognized*/
    203200                mfsdebug("magic number not recognized\n");
    204201                rc = ENOTSUP;
    … …  
    208205        mfsdebug("magic number recognized = %04x\n", magic);
    209206
    210         /* Fill superblock info structure */
     207        /*Fill superblock info structure*/
    211208
    212209        sbi->fs_version = version;
    … …  
    246243                sbi->dirsize = longnames ? MFSL_DIRSIZE : MFS_DIRSIZE;
    247244                sbi->max_name_len = longnames ? MFS_L_MAX_NAME_LEN :
    248                     MFS_MAX_NAME_LEN;
     245                                    MFS_MAX_NAME_LEN;
    249246        }
    250247
    … …  
    262259
    263260        sbi->itable_off = 2 + sbi->ibmap_blocks + sbi->zbmap_blocks;
    264         if ((rc = mfs_check_sanity(sbi)) != EOK) {
    265                 fprintf(stderr, "Filesystem corrupted, invalid superblock");
    266                 goto out_error;
    267         }
    268261
    269262        rc = block_cache_init(service_id, sbi->block_size, 0, cmode);
    … …  
    274267        }
    275268
    276         /* Initialize the instance structure and remember it */
     269        /*Initialize the instance structure and remember it*/
    277270        instance->service_id = service_id;
    278271        instance->sbi = sbi;
    … …  
    280273        rc = fs_instance_create(service_id, instance);
    281274        if (rc != EOK) {
     275                free(instance);
     276                free(sbi);
    282277                block_cache_fini(service_id);
     278                block_fini(service_id);
    283279                mfsdebug("fs instance creation failed\n");
    284                 goto out_error;
     280                return rc;
    285281        }
    286282
    … …  
    335331}
    336332
    337 service_id_t
    338 mfs_service_get(fs_node_t *fsnode)
     333service_id_t mfs_service_get(fs_node_t *fsnode)
    339334{
    340335        struct mfs_node *node = fsnode->data;
    … …  
    342337}
    343338
    344 static int
    345 mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
     339static int mfs_create_node(fs_node_t **rfn, service_id_t service_id, int flags)
    346340{
    347341        int r;
    … …  
    357351                return r;
    358352
    359         /* Alloc a new inode */
     353        /*Alloc a new inode*/
    360354        r = mfs_alloc_inode(inst, &inum);
    361355        if (r != EOK)
    … …  
    384378        if (flags & L_DIRECTORY) {
    385379                ino_i->i_mode = S_IFDIR;
    386                 ino_i->i_nlinks = 2; /* This accounts for the '.' dentry */
     380                ino_i->i_nlinks = 2; /*This accounts for the '.' dentry*/
    387381        } else {
    388382                ino_i->i_mode = S_IFREG;
    … …  
    437431}
    438432
    439 static int
    440 mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
     433static int mfs_match(fs_node_t **rfn, fs_node_t *pfn, const char *component)
    441434{
    442435        struct mfs_node *mnode = pfn->data;
    … …  
    460453
    461454                if (!d_info.d_inum) {
    462                         /* This entry is not used */
     455                        /*This entry is not used*/
    463456                        continue;
    464457                }
    … …  
    467460
    468461                if (comp_size == dentry_name_size &&
    469                     !bcmp(component, d_info.d_name, dentry_name_size)) {
    470                         /* Hit! */
     462                        !bcmp(component, d_info.d_name, dentry_name_size)) {
     463                        /*Hit!*/
    471464                        mfs_node_core_get(rfn, mnode->instance,
    472                             d_info.d_inum);
     465                                          d_info.d_inum);
    473466                        goto found;
    474467                }
    … …  
    479472}
    480473
    481 static aoff64_t
    482 mfs_size_get(fs_node_t *node)
     474static aoff64_t mfs_size_get(fs_node_t *node)
    483475{
    484476        const struct mfs_node *mnode = node->data;
    … …  
    488480static int
    489481mfs_node_get(fs_node_t **rfn, service_id_t service_id,
    490     fs_index_t index)
     482                        fs_index_t index)
    491483{
    492484        int rc;
    … …  
    532524}
    533525
    534 static int
    535 mfs_node_open(fs_node_t *fsnode)
     526static int mfs_node_open(fs_node_t *fsnode)
    536527{
    537528        /*
    … …  
    542533}
    543534
    544 static fs_index_t
    545 mfs_index_get(fs_node_t *fsnode)
     535static fs_index_t mfs_index_get(fs_node_t *fsnode)
    546536{
    547537        struct mfs_node *mnode = fsnode->data;
    … …  
    549539}
    550540
    551 static unsigned
    552 mfs_lnkcnt_get(fs_node_t *fsnode)
     541static unsigned mfs_lnkcnt_get(fs_node_t *fsnode)
    553542{
    554543        struct mfs_node *mnode = fsnode->data;
    … …  
    565554}
    566555
    567 static int
    568 mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
    569     fs_index_t index)
     556static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
     557                             fs_index_t index)
    570558{
    571559        fs_node_t *node = NULL;
    … …  
    639627}
    640628
    641 static bool
    642 mfs_is_directory(fs_node_t *fsnode)
     629static bool mfs_is_directory(fs_node_t *fsnode)
    643630{
    644631        const struct mfs_node *node = fsnode->data;
    … …  
    646633}
    647634
    648 static bool
    649 mfs_is_file(fs_node_t *fsnode)
     635static bool mfs_is_file(fs_node_t *fsnode)
    650636{
    651637        struct mfs_node *node = fsnode->data;
    … …  
    653639}
    654640
    655 static int
    656 mfs_root_get(fs_node_t **rfn, service_id_t service_id)
     641static int mfs_root_get(fs_node_t **rfn, service_id_t service_id)
    657642{
    658643        int rc = mfs_node_get(rfn, service_id, MFS_ROOT_INO);
    … …  
    660645}
    661646
    662 static int
    663 mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
     647static int mfs_link(fs_node_t *pfn, fs_node_t *cfn, const char *name)
    664648{
    665649        struct mfs_node *parent = pfn->data;
    … …  
    736720}
    737721
    738 static int
    739 mfs_has_children(bool *has_children, fs_node_t *fsnode)
     722static int mfs_has_children(bool *has_children, fs_node_t *fsnode)
    740723{
    741724        struct mfs_node *mnode = fsnode->data;
    … …  
    758741
    759742                if (d_info.d_inum) {
    760                         /* A valid entry has been found */
     743                        /*A valid entry has been found*/
    761744                        *has_children = true;
    762745                        break;
    … …  
    770753static int
    771754mfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    772     size_t *rbytes)
     755                size_t *rbytes)
    773756{
    774757        int rc;
    … …  
    800783
    801784                if (pos < 2) {
    802                         /* Skip the first two dentries ('.' and '..') */
     785                        /*Skip the first two dentries ('.' and '..')*/
    803786                        pos = 2;
    804787                }
    … …  
    810793
    811794                        if (d_info.d_inum) {
    812                                 /* Dentry found! */
     795                                /*Dentry found!*/
    813796                                goto found;
    814797                        }
    … …  
    826809
    827810                if (pos >= (size_t) ino_i->i_size) {
    828                         /* Trying to read beyond the end of file */
     811                        /*Trying to read beyond the end of file*/
    829812                        bytes = 0;
    830813                        (void) async_data_read_finalize(callid, NULL, 0);
    … …  
    843826
    844827                if (zone == 0) {
    845                         /* sparse file */
     828                        /*sparse file*/
    846829                        uint8_t *buf = malloc(sbi->block_size);
    847830                        if (!buf) {
    … …  
    851834                        memset(buf, 0, sizeof(sbi->block_size));
    852835                        async_data_read_finalize(callid,
    853                             buf + pos % sbi->block_size, bytes);
     836                                                buf + pos % sbi->block_size, bytes);
    854837                        free(buf);
    855838                        goto out_success;
    … …  
    861844
    862845                async_data_read_finalize(callid, b->data +
    863                     pos % sbi->block_size, bytes);
     846                                        pos % sbi->block_size, bytes);
    864847
    865848                rc = block_put(b);
    … …  
    882865static int
    883866mfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    884     size_t *wbytes, aoff64_t *nsize)
     867                size_t *wbytes, aoff64_t *nsize)
    885868{
    886869        fs_node_t *fn;
    … …  
    917900
    918901        if (block == 0) {
     902                /*Writing in a sparse block*/
    919903                uint32_t dummy;
    920904
    … …  
    974958                return ENOENT;
    975959
    976         /* Destroy the inode */
     960        /*Destroy the inode*/
    977961        return mfs_destroy_node(fn);
    978962}
    … …  
    993977        assert(!has_children);
    994978
    995         /* Free the entire inode content */
     979        /*Free the entire inode content*/
    996980        r = mfs_inode_shrink(mnode, mnode->ino_i->i_size);
    997981        if (r != EOK)
    998982                goto out;
    999983
    1000         /* Mark the inode as free in the bitmap */
     984        /*Mark the inode as free in the bitmap*/
    1001985        r = mfs_free_inode(mnode->instance, mnode->ino_i->index);
    1002986
    … …  
    10371021
    10381022        rc = fs_instance_get(service_id, &data);
    1039         if (rc == EOK)
     1023        if (rc == EOK) {
    10401024                *instance = (struct mfs_instance *) data;
    1041         else {
     1025        } else {
    10421026                mfsdebug("instance not found\n");
    10431027        }
    … …  
    10461030}
    10471031
    1048 static bool
    1049 check_magic_number(uint16_t magic, bool *native,
    1050                 mfs_version_t *version, bool *longfilenames)
     1032static bool check_magic_number(uint16_t magic, bool *native,
     1033                               mfs_version_t *version, bool *longfilenames)
    10511034{
    10521035        bool rc = true;
    … …  
    10761059}
    10771060
    1078 /** Filesystem sanity check
    1079  *
    1080  * @param Pointer to the MFS superblock.
    1081  *
    1082  * @return EOK on success, ENOTSUP otherwise.
    1083  */
    1084 static int
    1085 mfs_check_sanity(struct mfs_sb_info *sbi)
    1086 {
    1087         if (!is_power_of_two(sbi->block_size) ||
    1088             sbi->block_size < MFS_MIN_BLOCKSIZE ||
    1089             sbi->block_size > MFS_MAX_BLOCKSIZE)
    1090                 return ENOTSUP;
    1091         else if (sbi->ibmap_blocks == 0 || sbi->zbmap_blocks == 0)
    1092                 return ENOTSUP;
    1093         else if (sbi->ninodes == 0 || sbi->nzones == 0)
    1094                 return ENOTSUP;
    1095         else if (sbi->firstdatazone == 0)
    1096                 return ENOTSUP;
    1097 
    1098         return EOK;
    1099 }
    1100 
    11011061static int
    11021062mfs_close(service_id_t service_id, fs_index_t index)
    … …  
    11191079
    11201080        return mfs_node_put(fn);
    1121 }
    1122 
    1123 /** Check if a given number is a power of two.
    1124  *
    1125  * @param n     The number to check.
    1126  *
    1127  * @return      true if it is a power of two, false otherwise.
    1128  */
    1129 static bool
    1130 is_power_of_two(uint32_t n)
    1131 {
    1132         if (n == 0)
    1133                 return false;
    1134 
    1135         return (n & (n - 1)) == 0;
    11361081}
    11371082
Note: See TracChangeset for help on using the changeset viewer.