Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 3a5ee6c in mainline


Ignore:
Timestamp:
2011-09-04T14:08:37Z (9 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
master
Children:
bbd4c72
Parents:
c699b0c
Message:

rename functions to avoid conflicts

Location:
uspace/srv/fs/minixfs
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/minixfs/mfs.h

    rc699b0c r3a5ee6c  
    155155/*mfs_inode.c*/
    156156extern int
    157 get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
     157mfs_get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
    158158          fs_index_t index);
    159159
    160160extern int
    161 put_inode(struct mfs_node *mnode);
    162 
    163 extern int
    164 inode_shrink(struct mfs_node *mnode, size_t size_shrink);
     161mfs_put_inode(struct mfs_node *mnode);
     162
     163extern int
     164mfs_inode_shrink(struct mfs_node *mnode, size_t size_shrink);
    165165
    166166/*mfs_rw.c*/
    167167extern int
    168 read_map(uint32_t *b, const struct mfs_node *mnode, const uint32_t pos);
    169 
    170 extern int
    171 write_map(struct mfs_node *mnode, uint32_t pos, uint32_t new_zone,
     168mfs_read_map(uint32_t *b, const struct mfs_node *mnode, const uint32_t pos);
     169
     170extern int
     171mfs_write_map(struct mfs_node *mnode, uint32_t pos, uint32_t new_zone,
    172172          uint32_t *old_zone);
    173173
    174174extern int
    175 prune_ind_zones(struct mfs_node *mnode, size_t new_size);
     175mfs_prune_ind_zones(struct mfs_node *mnode, size_t new_size);
    176176
    177177/*mfs_dentry.c*/
    178178extern int
    179 read_dentry(struct mfs_node *mnode,
     179mfs_read_dentry(struct mfs_node *mnode,
    180180                     struct mfs_dentry_info *d_info, unsigned index);
    181181
    182182extern int
    183 write_dentry(struct mfs_dentry_info *d_info);
    184 
    185 extern int
    186 remove_dentry(struct mfs_node *mnode, const char *d_name);
    187 
    188 extern int
    189 insert_dentry(struct mfs_node *mnode, const char *d_name, fs_index_t d_inum);
     183mfs_write_dentry(struct mfs_dentry_info *d_info);
     184
     185extern int
     186mfs_remove_dentry(struct mfs_node *mnode, const char *d_name);
     187
     188extern int
     189mfs_insert_dentry(struct mfs_node *mnode, const char *d_name, fs_index_t d_inum);
    190190
    191191/*mfs_balloc.c*/
  • uspace/srv/fs/minixfs/mfs_dentry.c

    rc699b0c r3a5ee6c  
    4343 */
    4444int
    45 read_dentry(struct mfs_node *mnode,
     45mfs_read_dentry(struct mfs_node *mnode,
    4646                     struct mfs_dentry_info *d_info, unsigned index)
    4747{
     
    5252        block_t *b;
    5353
    54         int r = read_map(&block, mnode, index * sbi->dirsize);
     54        int r = mfs_read_map(&block, mnode, index * sbi->dirsize);
    5555        if (r != EOK)
    5656                goto out_err;
     
    104104 */
    105105int
    106 write_dentry(struct mfs_dentry_info *d_info)
     106mfs_write_dentry(struct mfs_dentry_info *d_info)
    107107{
    108108        struct mfs_node *mnode = d_info->node;
     
    114114        int r;
    115115
    116         r = read_map(&block, mnode, d_off_bytes);
     116        r = mfs_read_map(&block, mnode, d_off_bytes);
    117117        if (r != EOK)
    118118                goto out;
     
    155155 */
    156156int
    157 remove_dentry(struct mfs_node *mnode, const char *d_name)
     157mfs_remove_dentry(struct mfs_node *mnode, const char *d_name)
    158158{
    159159        struct mfs_sb_info *sbi = mnode->instance->sbi;
     
    169169        unsigned i;
    170170        for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize ; ++i) {
    171                 r = read_dentry(mnode, &d_info, i);
     171                r = mfs_read_dentry(mnode, &d_info, i);
    172172                if (r != EOK)
    173173                        return r;
     
    178178                                !bcmp(d_info.d_name, d_name, name_len)) {
    179179                        d_info.d_inum = 0;
    180                         r = write_dentry(&d_info);
     180                        r = mfs_write_dentry(&d_info);
    181181                        return r;
    182182                }
     
    195195 */
    196196int
    197 insert_dentry(struct mfs_node *mnode, const char *d_name, fs_index_t d_inum)
     197mfs_insert_dentry(struct mfs_node *mnode, const char *d_name, fs_index_t d_inum)
    198198{
    199199        int r;
     
    210210        unsigned i;
    211211        for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize; ++i) {
    212                 r = read_dentry(mnode, &d_info, i);
     212                r = mfs_read_dentry(mnode, &d_info, i);
    213213                if (r != EOK)
    214214                        return r;
     
    224224                uint32_t b, pos;
    225225                pos = mnode->ino_i->i_size;
    226                 r = read_map(&b, mnode, pos);
     226                r = mfs_read_map(&b, mnode, pos);
    227227                if (r != EOK)
    228228                        goto out;
     
    235235                        if (r != EOK)
    236236                                goto out;
    237                         r = write_map(mnode, pos, b, &dummy);
     237                        r = mfs_write_map(mnode, pos, b, &dummy);
    238238                        if (r != EOK)
    239239                                goto out;
     
    251251        d_info.d_name[name_len] = 0;
    252252
    253         r = write_dentry(&d_info);
     253        r = mfs_write_dentry(&d_info);
    254254out:
    255255        return r;
  • uspace/srv/fs/minixfs/mfs_inode.c

    rc699b0c r3a5ee6c  
    5050
    5151int
    52 get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
     52mfs_get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
    5353          fs_index_t index)
    5454{
     
    186186
    187187int
    188 put_inode(struct mfs_node *mnode)
     188mfs_put_inode(struct mfs_node *mnode)
    189189{
    190190        int rc = EOK;
     
    300300
    301301int
    302 inode_shrink(struct mfs_node *mnode, size_t size_shrink)
     302mfs_inode_shrink(struct mfs_node *mnode, size_t size_shrink)
    303303{
    304304        struct mfs_sb_info *sbi = mnode->instance->sbi;
     
    333333                uint32_t old_zone;
    334334
    335                 r = write_map(mnode, pos, 0, &old_zone);
     335                r = mfs_write_map(mnode, pos, 0, &old_zone);
    336336                if (r != EOK)
    337337                        goto exit_error;
     
    349349        ino_i->i_size = new_size;
    350350
    351         return prune_ind_zones(mnode, new_size);
     351        return mfs_prune_ind_zones(mnode, new_size);
    352352
    353353exit_error:
  • uspace/srv/fs/minixfs/mfs_ops.c

    rc699b0c r3a5ee6c  
    183183        sb = malloc(MFS_SUPERBLOCK_SIZE);
    184184        if (!sb) {
     185                free(instance);
     186                free(sbi);
    185187                block_fini(service_id);
    186188                return ENOMEM;
     
    190192        rc = block_read_direct(service_id, MFS_SUPERBLOCK << 1, 1, sb);
    191193        if (rc != EOK) {
     194                free(instance);
     195                free(sbi);
     196                free(sb);
    192197                block_fini(service_id);
    193198                return rc;
     
    204209        if (!check_magic_number(sb3->s_magic, &native, &version, &longnames)) {
    205210                mfsdebug("magic number not recognized\n");
     211                free(instance);
     212                free(sbi);
     213                free(sb);
    206214                block_fini(service_id);
    207215                return ENOTSUP;
     
    262270        rc = block_cache_init(service_id, sbi->block_size, 0, cmode);
    263271        if (rc != EOK) {
     272                free(instance);
    264273                free(sbi);
    265                 free(instance);
     274                free(sb);
    266275                block_cache_fini(service_id);
    267276                block_fini(service_id);
     
    433442        unsigned i;
    434443        for (i = 0; i < mnode->ino_i->i_size / sbi->dirsize; ++i) {
    435                 r = read_dentry(mnode, &d_info, i);
     444                r = mfs_read_dentry(mnode, &d_info, i);
    436445                if (r != EOK)
    437446                        return r;
     
    504513                assert(mnode->instance->open_nodes_cnt > 0);
    505514                mnode->instance->open_nodes_cnt--;
    506                 rc = put_inode(mnode);
     515                rc = mfs_put_inode(mnode);
    507516                free(mnode->ino_i);
    508517                free(mnode);
     
    586595        struct mfs_ino_info *ino_i;
    587596
    588         rc = get_inode(inst, &ino_i, index);
     597        rc = mfs_get_inode(inst, &ino_i, index);
    589598        if (rc != EOK)
    590599                goto out_err;
     
    645654                return ENAMETOOLONG;
    646655
    647         int r = insert_dentry(parent, name, child->ino_i->index);
     656        int r = mfs_insert_dentry(parent, name, child->ino_i->index);
    648657        if (r != EOK)
    649658                goto exit_error;
    650659
    651660        if (S_ISDIR(child->ino_i->i_mode)) {
    652                 r = insert_dentry(child, ".", child->ino_i->index);
     661                r = mfs_insert_dentry(child, ".", child->ino_i->index);
    653662                if (r != EOK)
    654663                        goto exit_error;
    655664                //child->ino_i->i_nlinks++;
    656665                //child->ino_i->dirty = true;
    657                 r = insert_dentry(child, "..", parent->ino_i->index);
     666                r = mfs_insert_dentry(child, "..", parent->ino_i->index);
    658667                if (r != EOK)
    659668                        goto exit_error;
     
    686695                return ENOTEMPTY;
    687696
    688         r = remove_dentry(parent, name);
     697        r = mfs_remove_dentry(parent, name);
    689698        if (r != EOK)
    690699                return r;
     
    722731        unsigned i;
    723732        for (i = 2; i < mnode->ino_i->i_size / sbi->dirsize; ++i) {
    724                 r = read_dentry(mnode, &d_info, i);
     733                r = mfs_read_dentry(mnode, &d_info, i);
    725734                if (r != EOK)
    726735                        return r;
     
    774783
    775784                for (; pos < mnode->ino_i->i_size / sbi->dirsize; ++pos) {
    776                         rc = read_dentry(mnode, &d_info, pos);
     785                        rc = mfs_read_dentry(mnode, &d_info, pos);
    777786                        if (rc != EOK)
    778787                                goto out_error;
     
    807816                block_t *b;
    808817
    809                 rc = read_map(&zone, mnode, pos);
     818                rc = mfs_read_map(&zone, mnode, pos);
    810819                if (rc != EOK)
    811820                        goto out_error;
     
    883892
    884893        if (pos < boundary) {
    885                 r = read_map(&block, mnode, pos);
     894                r = mfs_read_map(&block, mnode, pos);
    886895                if (r != EOK)
    887896                        goto out_err;
     
    901910                        goto out_err;
    902911
    903                 r = write_map(mnode, pos, block, &dummy);
     912                r = mfs_write_map(mnode, pos, block, &dummy);
    904913                if (r != EOK)
    905914                        goto out_err;
     
    972981
    973982        /*Free the entire inode content*/
    974         r = inode_shrink(mnode, mnode->ino_i->i_size);
     983        r = mfs_inode_shrink(mnode, mnode->ino_i->i_size);
    975984        if (r != EOK)
    976985                goto out;
     
    10001009                r = EOK;
    10011010        else
    1002                 r = inode_shrink(mnode, ino_i->i_size - size);
     1011                r = mfs_inode_shrink(mnode, ino_i->i_size - size);
    10031012
    10041013        mfs_node_put(fn);
  • uspace/srv/fs/minixfs/mfs_rw.c

    rc699b0c r3a5ee6c  
    5656 */
    5757int
    58 read_map(uint32_t *b, const struct mfs_node *mnode, uint32_t pos)
     58mfs_read_map(uint32_t *b, const struct mfs_node *mnode, uint32_t pos)
    5959{
    6060        int r;
     
    7878
    7979int
    80 write_map(struct mfs_node *mnode, const uint32_t pos, uint32_t new_zone,
     80mfs_write_map(struct mfs_node *mnode, const uint32_t pos, uint32_t new_zone,
    8181          uint32_t *old_zone)
    8282{
     
    229229/*Free unused indirect zones*/
    230230int
    231 prune_ind_zones(struct mfs_node *mnode, size_t new_size)
     231mfs_prune_ind_zones(struct mfs_node *mnode, size_t new_size)
    232232{
    233233        struct mfs_instance *inst = mnode->instance;
Note: See TracChangeset for help on using the changeset viewer.