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

Changeset 8a49fed in mainline


Ignore:
Timestamp:
2011-04-30T11:45:33Z (11 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master
Children:
44c6091f
Parents:
2874547
Message:

Added implementation of mfs_truncate(), it does not prune indirect blocks yet.

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

Legend:

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

    r2874547 r8a49fed  
    122122                        mfs_write(callid, &call);
    123123                        break;
     124                case VFS_OUT_TRUNCATE:
     125                        mfs_truncate(callid, &call);
     126                        break;
    124127                default:
    125128                        async_answer_0(callid, ENOTSUP);
  • uspace/srv/fs/minixfs/mfs.h

    r2874547 r8a49fed  
    2929/** @addtogroup fs
    3030 * @{
    31  */ 
     31 */
    3232
    3333#ifndef _MFS_H_
     
    111111/*Generic MinixFS inode*/
    112112struct mfs_ino_info {
    113         uint16_t        i_mode;
    114         uint16_t        i_nlinks;
    115         int16_t         i_uid;
    116         uint16_t        i_gid;
    117         size_t          i_size;
    118         int32_t         i_atime;
    119         int32_t         i_mtime;
    120         int32_t         i_ctime;
    121         /*Block numbers for direct zones*/
    122         uint32_t        i_dzone[V2_NR_DIRECT_ZONES];
    123         /*Block numbers for indirect zones*/
    124         uint32_t        i_izone[V2_NR_INDIRECT_ZONES];
     113        uint16_t        i_mode;
     114        uint16_t        i_nlinks;
     115        int16_t         i_uid;
     116        uint16_t        i_gid;
     117        size_t          i_size;
     118        int32_t         i_atime;
     119        int32_t         i_mtime;
     120        int32_t         i_ctime;
     121        /*Block numbers for direct zones*/
     122        uint32_t        i_dzone[V2_NR_DIRECT_ZONES];
     123        /*Block numbers for indirect zones*/
     124        uint32_t        i_izone[V2_NR_INDIRECT_ZONES];
    125125
    126126        /*The following fields do not exist on disk but only in memory*/
     
    159159extern void mfs_lookup(ipc_callid_t rid, ipc_call_t *request);
    160160extern int mfs_instance_get(devmap_handle_t handle,
    161                                 struct mfs_instance **instance);
     161                            struct mfs_instance **instance);
    162162
    163163extern void mfs_stat(ipc_callid_t rid, ipc_call_t *request);
     
    171171mfs_write(ipc_callid_t rid, ipc_call_t *request);
    172172
     173extern void
     174mfs_truncate(ipc_callid_t rid, ipc_call_t *request);
     175
    173176/*mfs_inode.c*/
    174 int
     177extern int
    175178get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
    176                                 fs_index_t index);
     179          fs_index_t index);
    177180
    178181extern int
    179182put_inode(struct mfs_node *mnode);
    180183
    181 int
     184extern int
    182185inode_grow(struct mfs_node *mnode, size_t size_grow);
    183186
     187extern int
     188inode_shrink(struct mfs_node *mnode, size_t size_shrink);
     189
    184190/*mfs_rw.c*/
    185191extern int
     
    188194extern int
    189195write_map(struct mfs_node *mnode, uint32_t pos, uint32_t new_zone,
    190                                 uint32_t *old_zone);
     196          uint32_t *old_zone);
    191197
    192198extern int
     
    196202extern int
    197203read_directory_entry(struct mfs_node *mnode,
    198                         struct mfs_dentry_info **d_info, unsigned index);
     204                     struct mfs_dentry_info **d_info, unsigned index);
    199205
    200206extern int
    201207write_dentry(struct mfs_dentry_info *d_info);
    202208
    203 int
     209extern int
    204210insert_dentry(struct mfs_node *mnode, const char *d_name, fs_index_t d_inum);
    205211
     
    215221/**
    216222 * @}
    217  */ 
    218 
     223 */
     224
  • uspace/srv/fs/minixfs/mfs_balloc.c

    r2874547 r8a49fed  
    7272
    7373        r = block_get(&b, inst->handle, block, BLOCK_FLAGS_NONE);
    74         if (r != EOK)
    75                 goto out_err;
     74        on_error(r, goto out_err);
    7675
    7776        /*Compute the bit index in the block*/
     
    8584        ptr[idx / chunk_bits] = conv32(sbi->native, chunk);
    8685        b->dirty = true;
    87         r = EOK;
    88         block_put(b);
     86        r = block_put(b);
    8987
    9088out_err:
     
    128126                                BLOCK_FLAGS_NONE);
    129127
    130                 if (r != EOK)
    131                         goto out;
     128                on_error(r, goto out);
    132129
    133130                freebit = find_free_bit_and_set(b->data, sbi->block_size,
     
    145142                if (*idx > limit) {
    146143                        /*Index is beyond the limit, it is invalid*/
    147                         block_put(b);
     144                        r = block_put(b);
     145                        on_error(r, goto out);
    148146                        break;
    149147                }
     
    151149                *search = *idx;
    152150                b->dirty = true;
    153                 block_put(b);
    154                 goto found;
     151                r = block_put(b);
     152                goto out;
    155153        }
    156154
     
    163161        /*Free bit not found, return error*/
    164162        return ENOSPC;
    165 
    166 found:
    167         r = EOK;
    168163
    169164out:
  • uspace/srv/fs/minixfs/mfs_inode.c

    r2874547 r8a49fed  
    302302
    303303int
     304inode_shrink(struct mfs_node *mnode, size_t size_shrink)
     305{
     306        struct mfs_sb_info *sbi = mnode->instance->sbi;
     307        struct mfs_ino_info *ino_i = mnode->ino_i;
     308        const size_t bs = sbi->block_size;
     309        int r;
     310
     311        assert(size_shrink > 0);
     312
     313        const size_t old_size = ino_i->i_size;
     314        const size_t new_size = ino_i->i_size - size_shrink;
     315
     316        assert(size_shrink <= old_size);
     317
     318        ino_i->dirty = true;
     319
     320        /*Compute the number of zones to free*/
     321        unsigned zones_to_free = 0;
     322        if (new_size == 0)
     323                ++zones_to_free;
     324
     325        zones_to_free += (old_size / bs) - (new_size / bs);
     326
     327        mfsdebug("zones to free = %u\n", zones_to_free);
     328
     329        uint32_t pos = old_size - 1;
     330        unsigned i;
     331        for (i = 0; i < zones_to_free; ++i, pos -= bs) {
     332                uint32_t old_zone;
     333
     334                r = write_map(mnode, pos, 0, &old_zone);
     335                on_error(r, goto exit_error);
     336
     337                ino_i->i_size -= bs;
     338
     339                if (old_zone == 0)
     340                        continue; /*Sparse block*/
     341
     342                r = mfs_free_bit(mnode->instance, old_zone, BMAP_ZONE);
     343                on_error(r, goto exit_error);
     344        }
     345
     346        ino_i->i_size = new_size;
     347        return EOK;
     348
     349exit_error:
     350        return r;
     351}
     352
     353int
    304354inode_grow(struct mfs_node *mnode, size_t size_grow)
    305355{
  • uspace/srv/fs/minixfs/mfs_ops.c

    r2874547 r8a49fed  
    791791}
    792792
     793void
     794mfs_truncate(ipc_callid_t rid, ipc_call_t *request)
     795{
     796        devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     797        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     798        aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
     799                                                IPC_GET_ARG4(*request));
     800        fs_node_t *fn;
     801        int r;
     802
     803        mfsdebug("mfs_truncate()\n");
     804
     805        r = mfs_node_get(&fn, handle, index);
     806        if (r != EOK) {
     807                async_answer_0(rid, r);
     808                return;
     809        }
     810
     811        if (!fn) {
     812                async_answer_0(rid, r);
     813                return;
     814        }
     815
     816        struct mfs_node *mnode = fn->data;
     817        struct mfs_ino_info *ino_i = mnode->ino_i;
     818
     819        if (ino_i->i_size == size)
     820                r = EOK;
     821        else
     822                r = inode_shrink(mnode, ino_i->i_size - size);
     823
     824        async_answer_0(rid, r);
     825        mfs_node_put(fn);
     826}
     827
    793828int mfs_instance_get(devmap_handle_t handle, struct mfs_instance **instance)
    794829{
  • uspace/srv/fs/minixfs/mfs_rw.c

    r2874547 r8a49fed  
    8383{
    8484        const struct mfs_sb_info *sbi = mnode->instance->sbi;
    85         const int block_size = sbi->block_size;
    8685
    8786        /*Compute the relative block number in file*/
    88         int rblock = pos / block_size;
     87        int rblock = pos / sbi->block_size;
    8988
    9089        return rw_map_ondisk(old_zone, mnode, rblock, true, new_zone);
Note: See TracChangeset for help on using the changeset viewer.