Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r4c3ad56 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 = 1; /* This accounts for the '.' dentry */
    387         } else
     380                ino_i->i_nlinks = 2; /*This accounts for the '.' dentry*/
     381        } else {
    388382                ino_i->i_mode = S_IFREG;
     383                ino_i->i_nlinks = 1;
     384        }
    389385
    390386        ino_i->i_uid = 0;
    … …  
    435431}
    436432
    437 static int
    438 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)
    439434{
    440435        struct mfs_node *mnode = pfn->data;
    … …  
    458453
    459454                if (!d_info.d_inum) {
    460                         /* This entry is not used */
     455                        /*This entry is not used*/
    461456                        continue;
    462457                }
    … …  
    465460
    466461                if (comp_size == dentry_name_size &&
    467                     !bcmp(component, d_info.d_name, dentry_name_size)) {
    468                         /* Hit! */
     462                        !bcmp(component, d_info.d_name, dentry_name_size)) {
     463                        /*Hit!*/
    469464                        mfs_node_core_get(rfn, mnode->instance,
    470                             d_info.d_inum);
     465                                          d_info.d_inum);
    471466                        goto found;
    472467                }
    … …  
    477472}
    478473
    479 static aoff64_t
    480 mfs_size_get(fs_node_t *node)
     474static aoff64_t mfs_size_get(fs_node_t *node)
    481475{
    482476        const struct mfs_node *mnode = node->data;
    … …  
    486480static int
    487481mfs_node_get(fs_node_t **rfn, service_id_t service_id,
    488     fs_index_t index)
     482                        fs_index_t index)
    489483{
    490484        int rc;
    … …  
    530524}
    531525
    532 static int
    533 mfs_node_open(fs_node_t *fsnode)
     526static int mfs_node_open(fs_node_t *fsnode)
    534527{
    535528        /*
    … …  
    540533}
    541534
    542 static fs_index_t
    543 mfs_index_get(fs_node_t *fsnode)
     535static fs_index_t mfs_index_get(fs_node_t *fsnode)
    544536{
    545537        struct mfs_node *mnode = fsnode->data;
    … …  
    547539}
    548540
    549 static unsigned
    550 mfs_lnkcnt_get(fs_node_t *fsnode)
     541static unsigned mfs_lnkcnt_get(fs_node_t *fsnode)
    551542{
    552543        struct mfs_node *mnode = fsnode->data;
    … …  
    563554}
    564555
    565 static int
    566 mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
    567     fs_index_t index)
     556static int mfs_node_core_get(fs_node_t **rfn, struct mfs_instance *inst,
     557                             fs_index_t index)
    568558{
    569559        fs_node_t *node = NULL;
    … …  
    637627}
    638628
    639 static bool
    640 mfs_is_directory(fs_node_t *fsnode)
     629static bool mfs_is_directory(fs_node_t *fsnode)
    641630{
    642631        const struct mfs_node *node = fsnode->data;
    … …  
    644633}
    645634
    646 static bool
    647 mfs_is_file(fs_node_t *fsnode)
     635static bool mfs_is_file(fs_node_t *fsnode)
    648636{
    649637        struct mfs_node *node = fsnode->data;
    … …  
    651639}
    652640
    653 static int
    654 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)
    655642{
    656643        int rc = mfs_node_get(rfn, service_id, MFS_ROOT_INO);
    … …  
    658645}
    659646
    660 static int
    661 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)
    662648{
    663649        struct mfs_node *parent = pfn->data;
    … …  
    673659        if (r != EOK)
    674660                goto exit_error;
    675 
    676         child->ino_i->i_nlinks++;
    677         child->ino_i->dirty = true;
    678661
    679662        if (S_ISDIR(child->ino_i->i_mode)) {
    … …  
    737720}
    738721
    739 static int
    740 mfs_has_children(bool *has_children, fs_node_t *fsnode)
     722static int mfs_has_children(bool *has_children, fs_node_t *fsnode)
    741723{
    742724        struct mfs_node *mnode = fsnode->data;
    … …  
    759741
    760742                if (d_info.d_inum) {
    761                         /* A valid entry has been found */
     743                        /*A valid entry has been found*/
    762744                        *has_children = true;
    763745                        break;
    … …  
    771753static int
    772754mfs_read(service_id_t service_id, fs_index_t index, aoff64_t pos,
    773     size_t *rbytes)
     755                size_t *rbytes)
    774756{
    775757        int rc;
    … …  
    801783
    802784                if (pos < 2) {
    803                         /* Skip the first two dentries ('.' and '..') */
     785                        /*Skip the first two dentries ('.' and '..')*/
    804786                        pos = 2;
    805787                }
    … …  
    811793
    812794                        if (d_info.d_inum) {
    813                                 /* Dentry found! */
     795                                /*Dentry found!*/
    814796                                goto found;
    815797                        }
    … …  
    827809
    828810                if (pos >= (size_t) ino_i->i_size) {
    829                         /* Trying to read beyond the end of file */
     811                        /*Trying to read beyond the end of file*/
    830812                        bytes = 0;
    831813                        (void) async_data_read_finalize(callid, NULL, 0);
    … …  
    844826
    845827                if (zone == 0) {
    846                         /* sparse file */
     828                        /*sparse file*/
    847829                        uint8_t *buf = malloc(sbi->block_size);
    848830                        if (!buf) {
    … …  
    852834                        memset(buf, 0, sizeof(sbi->block_size));
    853835                        async_data_read_finalize(callid,
    854                             buf + pos % sbi->block_size, bytes);
     836                                                buf + pos % sbi->block_size, bytes);
    855837                        free(buf);
    856838                        goto out_success;
    … …  
    862844
    863845                async_data_read_finalize(callid, b->data +
    864                     pos % sbi->block_size, bytes);
     846                                        pos % sbi->block_size, bytes);
    865847
    866848                rc = block_put(b);
    … …  
    883865static int
    884866mfs_write(service_id_t service_id, fs_index_t index, aoff64_t pos,
    885     size_t *wbytes, aoff64_t *nsize)
     867                size_t *wbytes, aoff64_t *nsize)
    886868{
    887869        fs_node_t *fn;
    … …  
    918900
    919901        if (block == 0) {
     902                /*Writing in a sparse block*/
    920903                uint32_t dummy;
    921904
    … …  
    975958                return ENOENT;
    976959
    977         /* Destroy the inode */
     960        /*Destroy the inode*/
    978961        return mfs_destroy_node(fn);
    979962}
    … …  
    994977        assert(!has_children);
    995978
    996         /* Free the entire inode content */
     979        /*Free the entire inode content*/
    997980        r = mfs_inode_shrink(mnode, mnode->ino_i->i_size);
    998981        if (r != EOK)
    999982                goto out;
    1000983
    1001         /* Mark the inode as free in the bitmap */
     984        /*Mark the inode as free in the bitmap*/
    1002985        r = mfs_free_inode(mnode->instance, mnode->ino_i->index);
    1003986
    … …  
    10381021
    10391022        rc = fs_instance_get(service_id, &data);
    1040         if (rc == EOK)
     1023        if (rc == EOK) {
    10411024                *instance = (struct mfs_instance *) data;
    1042         else {
     1025        } else {
    10431026                mfsdebug("instance not found\n");
    10441027        }
    … …  
    10471030}
    10481031
    1049 static bool
    1050 check_magic_number(uint16_t magic, bool *native,
    1051                 mfs_version_t *version, bool *longfilenames)
     1032static bool check_magic_number(uint16_t magic, bool *native,
     1033                               mfs_version_t *version, bool *longfilenames)
    10521034{
    10531035        bool rc = true;
    … …  
    10771059}
    10781060
    1079 /** Filesystem sanity check
    1080  *
    1081  * @param Pointer to the MFS superblock.
    1082  *
    1083  * @return EOK on success, ENOTSUP otherwise.
    1084  */
    1085 static int
    1086 mfs_check_sanity(struct mfs_sb_info *sbi)
    1087 {
    1088         if (!is_power_of_two(sbi->block_size) ||
    1089             sbi->block_size < MFS_MIN_BLOCKSIZE ||
    1090             sbi->block_size > MFS_MAX_BLOCKSIZE)
    1091                 return ENOTSUP;
    1092         else if (sbi->ibmap_blocks == 0 || sbi->zbmap_blocks == 0)
    1093                 return ENOTSUP;
    1094         else if (sbi->ninodes == 0 || sbi->nzones == 0)
    1095                 return ENOTSUP;
    1096         else if (sbi->firstdatazone == 0)
    1097                 return ENOTSUP;
    1098 
    1099         return EOK;
    1100 }
    1101 
    11021061static int
    11031062mfs_close(service_id_t service_id, fs_index_t index)
    … …  
    11201079
    11211080        return mfs_node_put(fn);
    1122 }
    1123 
    1124 /** Check if a given number is a power of two.
    1125  *
    1126  * @param n     The number to check.
    1127  *
    1128  * @return      true if it is a power of two, false otherwise.
    1129  */
    1130 static bool
    1131 is_power_of_two(uint32_t n)
    1132 {
    1133         if (n == 0)
    1134                 return false;
    1135 
    1136         return (n & (n - 1)) == 0;
    11371081}
    11381082
Note: See TracChangeset for help on using the changeset viewer.