Changeset 747a1e71 in mainline


Ignore:
Timestamp:
2011-09-27T13:54:53Z (12 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8c9e71a, e231d26
Parents:
ab545980 (diff), 36cb22f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:mfs.

Location:
uspace/srv/fs/mfs
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/mfs/mfs_ops.c

    rab545980 r747a1e71  
    143143{
    144144        enum cache_mode cmode;
    145         struct mfs_superblock *sb;
    146         struct mfs3_superblock *sb3;
    147         struct mfs_sb_info *sbi;
    148         struct mfs_instance *instance;
     145        struct mfs_superblock *sb = NULL;
     146        struct mfs3_superblock *sb3 = NULL;
     147        struct mfs_sb_info *sbi = NULL;
     148        struct mfs_instance *instance = NULL;
    149149        bool native, longnames;
    150150        mfs_version_t version;
     
    166166        sbi = malloc(sizeof(*sbi));
    167167        if (!sbi) {
    168                 block_fini(service_id);
    169                 return ENOMEM;
     168                rc = ENOMEM;
     169                goto out_error;
    170170        }
    171171
     
    173173        instance = malloc(sizeof(*instance));
    174174        if (!instance) {
    175                 free(sbi);
    176                 block_fini(service_id);
    177                 return ENOMEM;
     175                rc = ENOMEM;
     176                goto out_error;
    178177        }
    179178
    180179        sb = malloc(MFS_SUPERBLOCK_SIZE);
    181180        if (!sb) {
    182                 free(instance);
    183                 free(sbi);
    184                 block_fini(service_id);
    185                 return ENOMEM;
     181                rc = ENOMEM;
     182                goto out_error;
    186183        }
    187184
    188185        /* Read the superblock */
    189186        rc = block_read_direct(service_id, MFS_SUPERBLOCK << 1, 2, sb);
    190         if (rc != EOK) {
    191                 free(instance);
    192                 free(sbi);
    193                 free(sb);
    194                 block_fini(service_id);
    195                 return rc;
    196         }
     187        if (rc != EOK)
     188                goto out_error;
    197189
    198190        sb3 = (struct mfs3_superblock *) sb;
     
    207199                /*Not recognized*/
    208200                mfsdebug("magic number not recognized\n");
    209                 free(instance);
    210                 free(sbi);
    211                 free(sb);
    212                 block_fini(service_id);
    213                 return ENOTSUP;
     201                rc = ENOTSUP;
     202                goto out_error;
    214203        }
    215204
     
    256245                                    MFS_MAX_NAME_LEN;
    257246        }
     247
     248        if (sbi->log2_zone_size != 0) {
     249                /* In MFS, file space is allocated per zones.
     250                 * Zones are a collection of consecutive blocks on disk.
     251                 *
     252                 * The current MFS implementation supports only filesystems
     253                 * where the size of a zone is equal to the
     254                 * size of a block.
     255                 */
     256                rc = ENOTSUP;
     257                goto out_error;
     258        }
     259
    258260        sbi->itable_off = 2 + sbi->ibmap_blocks + sbi->zbmap_blocks;
    259 
    260         free(sb);
    261261
    262262        rc = block_cache_init(service_id, sbi->block_size, 0, cmode);
    263263        if (rc != EOK) {
    264                 free(instance);
    265                 free(sbi);
    266                 block_cache_fini(service_id);
    267                 block_fini(service_id);
    268264                mfsdebug("block cache initialization failed\n");
    269                 return EINVAL;
     265                rc = EINVAL;
     266                goto out_error;
    270267        }
    271268
     
    295292        *linkcnt = 1;
    296293
     294        free(sb);
     295
    297296        return mfs_node_put(fn);
     297
     298out_error:
     299        block_fini(service_id);
     300        if (sb)
     301                free(sb);
     302        if (sbi)
     303                free(sbi);
     304        if(instance)
     305                free(instance);
     306        return rc;
    298307}
    299308
     
    880889        struct mfs_ino_info *ino_i = mnode->ino_i;
    881890        const size_t bs = sbi->block_size;
    882         size_t bytes = min(len, bs - pos % bs);
    883         size_t boundary = ROUND_UP(ino_i->i_size, bs);
     891        size_t bytes = min(len, bs - (pos % bs));
    884892        uint32_t block;
    885893
     
    887895                flags = BLOCK_FLAGS_NOREAD;
    888896
    889         if (pos < boundary) {
    890                 r = mfs_read_map(&block, mnode, pos);
    891                 if (r != EOK)
    892                         goto out_err;
    893 
    894                 if (block == 0) {
    895                         /*Writing in a sparse block*/
    896                         r = mfs_alloc_zone(mnode->instance, &block);
    897                         if (r != EOK)
    898                                 goto out_err;
    899                         flags = BLOCK_FLAGS_NOREAD;
    900                 }
    901         } else {
     897        r = mfs_read_map(&block, mnode, pos);
     898        if (r != EOK)
     899                goto out_err;
     900
     901        if (block == 0) {
     902                /*Writing in a sparse block*/
    902903                uint32_t dummy;
    903904
     
    905906                if (r != EOK)
    906907                        goto out_err;
    907 
     908               
    908909                r = mfs_write_map(mnode, pos, block, &dummy);
    909910                if (r != EOK)
    910911                        goto out_err;
     912
     913                flags = BLOCK_FLAGS_NOREAD;
    911914        }
    912915
     
    916919                goto out_err;
    917920
    918         async_data_write_finalize(callid, b->data + pos % bs, bytes);
     921        if (flags == BLOCK_FLAGS_NOREAD)
     922                memset(b->data, 0, sbi->block_size);
     923
     924        async_data_write_finalize(callid, b->data + (pos % bs), bytes);
    919925        b->dirty = true;
    920926
     
    925931        }
    926932
    927         ino_i->i_size = pos + bytes;
    928         ino_i->dirty = true;
     933        if (pos + bytes > ino_i->i_size) {
     934                ino_i->i_size = pos + bytes;
     935                ino_i->dirty = true;
     936        }
    929937        r = mfs_node_put(fn);
    930         *nsize = pos + bytes;
     938        *nsize = ino_i->i_size;
    931939        *wbytes = bytes;
    932940        return r;
  • uspace/srv/fs/mfs/mfs_rw.c

    rab545980 r747a1e71  
    3131 */
    3232
     33#include <align.h>
    3334#include "mfs.h"
    3435
     
    7071        int rblock = pos / block_size;
    7172
    72         if (mnode->ino_i->i_size < pos) {
     73        if (ROUND_UP(mnode->ino_i->i_size, sbi->block_size) < pos) {
    7374                /*Trying to read beyond the end of file*/
    7475                r = EOK;
Note: See TracChangeset for help on using the changeset viewer.