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

Changeset bb7e8382 in mainline


Ignore:
Timestamp:
2011-04-22T20:12:58Z (11 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master
Children:
6b40ea7
Parents:
48de019
Message:

Add the mfs_write() function implementation.

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

Legend:

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

    r48de019 rbb7e8382  
    120120                        break;
    121121                case VFS_OUT_WRITE:
    122                         mfsdebug("write()\n");
     122                        mfs_write(callid, &call);
    123123                        break;
    124124                default:
  • uspace/srv/fs/minixfs/mfs.h

    r48de019 rbb7e8382  
    163163mfs_read(ipc_callid_t rid, ipc_call_t *request);
    164164
     165extern void
     166mfs_write(ipc_callid_t rid, ipc_call_t *request);
    165167
    166168/*mfs_inode.c*/
  • uspace/srv/fs/minixfs/mfs_ops.c

    r48de019 rbb7e8382  
    3636#include <fibril_synch.h>
    3737#include <errno.h>
     38#include <align.h>
    3839#include "mfs.h"
    3940#include "mfs_utils.h"
     
    525526        struct mfs_sb_info *sbi = parent->instance->sbi;
    526527
     528        mfsdebug("mfs_link() %d\n", (int) child->ino_i->index);
     529
    527530        if (str_size(name) > sbi->max_name_len)
    528531                return ENAMETOOLONG;
    529 
    530         mfsdebug("mfs_link() %d\n", (int) child->ino_i->index);
    531532
    532533        int r = insert_dentry(parent, name, child->ino_i->index);
     
    701702        async_answer_0(callid, tmp != EOK ? tmp : rc);
    702703        async_answer_0(rid, tmp != EOK ? tmp : rc);
     704}
     705
     706void
     707mfs_write(ipc_callid_t rid, ipc_call_t *request)
     708{
     709        mfsdebug("mfs_write()\n");
     710
     711        devmap_handle_t handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     712        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     713        aoff64_t pos = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request),
     714                                                IPC_GET_ARG4(*request));
     715
     716        fs_node_t *fn;
     717        int r;
     718        int flags = BLOCK_FLAGS_NONE;
     719
     720        r = mfs_node_get(&fn, handle, index);
     721        if (r != EOK) {
     722                async_answer_0(rid, r);
     723                return;
     724        }
     725
     726        if (!fn) {
     727                async_answer_0(rid, ENOENT);
     728                return;
     729        }
     730
     731        ipc_callid_t callid;
     732        size_t len;
     733
     734        if (!async_data_write_receive(&callid, &len)) {
     735                r = EINVAL;
     736                goto out_err;
     737        }
     738
     739        struct mfs_node *mnode = fn->data;
     740        struct mfs_sb_info *sbi = mnode->instance->sbi;
     741        struct mfs_ino_info *ino_i = mnode->ino_i;
     742        const size_t bs = sbi->block_size;
     743        size_t bytes = min(len, bs - pos % bs);
     744        size_t boundary = ROUND_UP(ino_i->i_size, bs);
     745        uint32_t block;
     746
     747        if (bytes == bs)
     748                flags = BLOCK_FLAGS_NOREAD;
     749
     750        if (pos < boundary) {
     751                r = read_map(&block, mnode, pos);
     752                on_error(r, goto out_err);
     753
     754                if (block == 0) {
     755                        /*Writing in a sparse block*/
     756                        r = mfs_alloc_bit(mnode->instance, &block, BMAP_ZONE);
     757                        on_error(r, goto out_err);
     758                        flags = BLOCK_FLAGS_NOREAD;
     759                }
     760        } else {
     761                uint32_t dummy;
     762
     763                r = mfs_alloc_bit(mnode->instance, &block, BMAP_ZONE);
     764                on_error(r, goto out_err);
     765
     766                r = write_map(mnode, pos, block, &dummy);
     767                on_error(r, goto out_err);
     768        }
     769
     770        block_t *b;
     771        r = block_get(&b, handle, block, flags);
     772        on_error(r, goto out_err);
     773
     774        async_data_write_finalize(callid, b->data + pos % bs, bytes);
     775        b->dirty = true;
     776
     777        r = block_put(b);
     778        if (r != EOK) {
     779                mfs_node_put(fn);
     780                async_answer_0(rid, r);
     781                return;
     782        }
     783
     784        ino_i->i_size = pos + bytes;
     785        ino_i->dirty = true;
     786        r = mfs_node_put(fn);
     787        async_answer_2(rid, r, bytes, pos + bytes);
     788        return;
     789
     790out_err:
     791        mfs_node_put(fn);
     792        async_answer_0(callid, r);
     793        async_answer_0(rid, r);
    703794}
    704795
Note: See TracChangeset for help on using the changeset viewer.