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

Changeset 05fb96b in mainline


Ignore:
Timestamp:
2011-09-10T10:58:51Z (10 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
2f72c67a
Parents:
cccc091 (diff), 40a2af3 (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:
6 edited

Legend:

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

    rcccc091 r05fb96b  
    159159
    160160extern int
    161 mfs_put_inode_core(struct mfs_node *mnode);
     161mfs_put_inode(struct mfs_node *mnode);
    162162
    163163extern int
  • uspace/srv/fs/mfs/mfs_balloc.c

    rcccc091 r05fb96b  
    122122        block_t *b;
    123123
    124         assert(inst != NULL);
    125124        sbi = inst->sbi;
    126         assert(sbi != NULL);
    127125
    128126        if (bid == BMAP_ZONE) {
     
    192190        int r, freebit;
    193191
    194         assert(inst != NULL);
    195192        sbi = inst->sbi;
    196         assert(sbi != NULL);
    197193
    198194        if (bid == BMAP_ZONE) {
  • uspace/srv/fs/mfs/mfs_dentry.c

    rcccc091 r05fb96b  
    7676                d_info->d_inum = conv32(sbi->native, d3->d_inum);
    7777                memcpy(d_info->d_name, d3->d_name, MFS3_MAX_NAME_LEN);
     78                d_info->d_name[MFS3_MAX_NAME_LEN] = 0;
    7879        } else {
    7980                const int namelen = longnames ? MFS_L_MAX_NAME_LEN :
     
    8687                d_info->d_inum = conv16(sbi->native, d->d_inum);
    8788                memcpy(d_info->d_name, d->d_name, namelen);
     89                d_info->d_name[namelen] = 0;
    8890        }
    8991
     
    249251        d_info.d_inum = d_inum;
    250252        memcpy(d_info.d_name, d_name, name_len);
    251         d_info.d_name[name_len] = 0;
     253        if (name_len < sbi->max_name_len)
     254                d_info.d_name[name_len] = 0;
    252255
    253256        r = mfs_write_dentry(&d_info);
  • uspace/srv/fs/mfs/mfs_inode.c

    rcccc091 r05fb96b  
    4848                struct mfs_ino_info **ino_ptr, uint32_t inum);
    4949
    50 
     50/**Read a MINIX inode from disk
     51 *
     52 * @param inst          Pointer to the filesystem instance.
     53 * @param ino_i         Pointer to the generic MINIX inode
     54 *                      where the inode content will be stored.
     55 * @param index         index of the inode to read.
     56 *
     57 * @return              EOK on success or a negative error code.
     58 */
    5159int
    5260mfs_get_inode(struct mfs_instance *inst, struct mfs_ino_info **ino_i,
     
    7785
    7886        sbi = instance->sbi;
    79         assert(sbi);
    8087
    8188        /*inode 0 does not exist*/
     
    142149
    143150        sbi = instance->sbi;
    144         assert(sbi);
    145151
    146152        /*inode 0 does not exist*/
     
    185191}
    186192
     193/**Write a MINIX inode on disk (if marked as dirty)
     194 *
     195 * @param mnode         Pointer to the generic MINIX inode in memory.
     196 *
     197 * @return              EOK on success or a negative error code.
     198 */
    187199int
    188 mfs_put_inode_core(struct mfs_node *mnode)
     200mfs_put_inode(struct mfs_node *mnode)
    189201{
    190202        int rc = EOK;
    191 
    192         assert(mnode);
    193         assert(mnode->ino_i);
    194203
    195204        if (!mnode->ino_i->dirty)
     
    197206
    198207        struct mfs_instance *inst = mnode->instance;
    199         assert(inst);
    200208        struct mfs_sb_info *sbi = inst->sbi;
    201         assert(sbi);
    202209
    203210        if (sbi->fs_version == MFS_VERSION_V1)
     
    299306}
    300307
     308/**Reduce the inode size of a given number of bytes
     309 *
     310 * @param mnode         Pointer to the generic MINIX inode in memory.
     311 * @param size_shrink   Number of bytes that will be subtracted to the inode.
     312 *
     313 * @return              EOK on success or a negative error code.
     314 */
    301315int
    302316mfs_inode_shrink(struct mfs_node *mnode, size_t size_shrink)
  • uspace/srv/fs/mfs/mfs_ops.c

    rcccc091 r05fb96b  
    468468static aoff64_t mfs_size_get(fs_node_t *node)
    469469{
    470         assert(node);
    471 
    472470        const struct mfs_node *mnode = node->data;
    473         assert(mnode);
    474         assert(mnode->ino_i);
    475 
    476471        return mnode->ino_i->i_size;
    477472}
     
    513508                assert(mnode->instance->open_nodes_cnt > 0);
    514509                mnode->instance->open_nodes_cnt--;
    515                 rc = mfs_put_inode_core(mnode);
     510                rc = mfs_put_inode(mnode);
    516511                free(mnode->ino_i);
    517512                free(mnode);
     
    535530{
    536531        struct mfs_node *mnode = fsnode->data;
    537 
    538         assert(mnode->ino_i);
    539532        return mnode->ino_i->index;
    540533}
  • uspace/srv/fs/mfs/mfs_rw.c

    rcccc091 r05fb96b  
    5353 *bytes, this function returns the on-disk block
    5454 *relative to that position.
    55  *Returns zero if the block does not exist.
     55 *
     56 * @param b     Pointer to a 32bit number where the block number will be stored
     57 * @param mnode Pointer to a generic MINIX inode in memory.
     58 * @param pos   Position in file.
     59 *
     60 * @return      EOK on success or a negative error code.
    5661 */
    5762int
     
    227232}
    228233
    229 /*Free unused indirect zones*/
     234/**Free unused indirect zones from a MINIX inode according to it's new size.
     235 *
     236 * @param mnode         Pointer to a generic MINIX inode in memory.
     237 * @param new_size      The new size of the inode.
     238 *
     239 * @return              EOK on success or a negative error code.
     240 */
    230241int
    231242mfs_prune_ind_zones(struct mfs_node *mnode, size_t new_size)
     
    239250        mfs_version_t fs_version = sbi->fs_version;
    240251       
     252        assert(new_size <= ino_i->i_size);
     253
    241254        if (fs_version == MFS_VERSION_V1) {
    242255                nr_direct = V1_NR_DIRECT_ZONES;
Note: See TracChangeset for help on using the changeset viewer.