Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/tmpfs/tmpfs_ops.c

    r472c09d r19f857a  
    2929/** @addtogroup fs
    3030 * @{
    31  */ 
     31 */
    3232
    3333/**
     
    4040#include "../../vfs/vfs.h"
    4141#include <ipc/ipc.h>
     42#include <macros.h>
     43#include <limits.h>
    4244#include <async.h>
    4345#include <errno.h>
    4446#include <atomic.h>
    4547#include <stdlib.h>
    46 #include <string.h>
     48#include <str.h>
    4749#include <stdio.h>
    4850#include <assert.h>
     
    9395}
    9496
    95 static size_t tmpfs_size_get(fs_node_t *fn)
     97static aoff64_t tmpfs_size_get(fs_node_t *fn)
    9698{
    9799        return TMPFS_NODE(fn)->size;
     
    168170                    (nodep->index == key[NODES_KEY_INDEX]));
    169171        default:
    170                 abort();
    171         }
     172                assert((keys == 1) || (keys == 2));
     173        }
     174
     175        return 0;
    172176}
    173177
     
    439443{
    440444        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    441        
    442         /* Accept the mount options */
     445        fs_node_t *rootfn;
     446        int rc;
     447       
     448        /* Accept the mount options. */
    443449        char *opts;
    444         int rc = async_string_receive(&opts, 0, NULL);
    445        
     450        rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    446451        if (rc != EOK) {
    447452                ipc_answer_0(rid, rc);
     453                return;
     454        }
     455
     456        /* Check if this device is not already mounted. */
     457        rc = tmpfs_root_get(&rootfn, dev_handle);
     458        if ((rc == EOK) && (rootfn)) {
     459                (void) tmpfs_node_put(rootfn);
     460                free(opts);
     461                ipc_answer_0(rid, EEXIST);
    448462                return;
    449463        }
     
    456470        }
    457471
    458         fs_node_t *rootfn;
    459472        rc = tmpfs_root_get(&rootfn, dev_handle);
    460473        assert(rc == EOK);
     
    498511void tmpfs_read(ipc_callid_t rid, ipc_call_t *request)
    499512{
    500         dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    501         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    502         off_t pos = (off_t)IPC_GET_ARG3(*request);
    503 
     513        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     514        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     515        aoff64_t pos =
     516            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     517       
    504518        /*
    505519         * Lookup the respective TMPFS node.
     
    517531        tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
    518532            nh_link);
    519 
     533       
    520534        /*
    521535         * Receive the read request.
     
    524538        size_t size;
    525539        if (!async_data_read_receive(&callid, &size)) {
    526                 ipc_answer_0(callid, EINVAL);   
     540                ipc_answer_0(callid, EINVAL);
    527541                ipc_answer_0(rid, EINVAL);
    528542                return;
     
    531545        size_t bytes;
    532546        if (nodep->type == TMPFS_FILE) {
    533                 bytes = max(0, min(nodep->size - pos, size));
     547                bytes = min(nodep->size - pos, size);
    534548                (void) async_data_read_finalize(callid, nodep->data + pos,
    535549                    bytes);
     
    537551                tmpfs_dentry_t *dentryp;
    538552                link_t *lnk;
    539                 int i;
     553                aoff64_t i;
    540554               
    541555                assert(nodep->type == TMPFS_DIRECTORY);
     
    547561                 */
    548562                for (i = 0, lnk = nodep->cs_head.next;
    549                     i < pos && lnk != &nodep->cs_head;
     563                    (i < pos) && (lnk != &nodep->cs_head);
    550564                    i++, lnk = lnk->next)
    551565                        ;
     
    572586void tmpfs_write(ipc_callid_t rid, ipc_call_t *request)
    573587{
    574         dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    575         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    576         off_t pos = (off_t)IPC_GET_ARG3(*request);
    577 
     588        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     589        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     590        aoff64_t pos =
     591            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     592       
    578593        /*
    579594         * Lookup the respective TMPFS node.
     
    636651void tmpfs_truncate(ipc_callid_t rid, ipc_call_t *request)
    637652{
     653        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     654        fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
     655        aoff64_t size =
     656            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     657       
     658        /*
     659         * Lookup the respective TMPFS node.
     660         */
     661        unsigned long key[] = {
     662                [NODES_KEY_DEV] = dev_handle,
     663                [NODES_KEY_INDEX] = index
     664        };
     665        link_t *hlp = hash_table_find(&nodes, key);
     666        if (!hlp) {
     667                ipc_answer_0(rid, ENOENT);
     668                return;
     669        }
     670        tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
     671            nh_link);
     672       
     673        if (size == nodep->size) {
     674                ipc_answer_0(rid, EOK);
     675                return;
     676        }
     677       
     678        if (size > SIZE_MAX) {
     679                ipc_answer_0(rid, ENOMEM);
     680                return;
     681        }
     682       
     683        void *newdata = realloc(nodep->data, size);
     684        if (!newdata) {
     685                ipc_answer_0(rid, ENOMEM);
     686                return;
     687        }
     688       
     689        if (size > nodep->size) {
     690                size_t delta = size - nodep->size;
     691                memset(newdata + nodep->size, 0, delta);
     692        }
     693       
     694        nodep->size = size;
     695        nodep->data = newdata;
     696        ipc_answer_0(rid, EOK);
     697}
     698
     699void tmpfs_close(ipc_callid_t rid, ipc_call_t *request)
     700{
     701        ipc_answer_0(rid, EOK);
     702}
     703
     704void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
     705{
    638706        dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    639707        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    640         size_t size = (off_t)IPC_GET_ARG3(*request);
    641 
    642         /*
    643          * Lookup the respective TMPFS node.
    644          */
     708        int rc;
     709
    645710        link_t *hlp;
    646711        unsigned long key[] = {
     
    655720        tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
    656721            nh_link);
    657 
    658         if (size == nodep->size) {
    659                 ipc_answer_0(rid, EOK);
    660                 return;
    661         }
    662 
    663         void *newdata = realloc(nodep->data, size);
    664         if (!newdata) {
    665                 ipc_answer_0(rid, ENOMEM);
    666                 return;
    667         }
    668         if (size > nodep->size) {
    669                 size_t delta = size - nodep->size;
    670                 memset(newdata + nodep->size, 0, delta);
    671         }
    672         nodep->size = size;
    673         nodep->data = newdata;
    674         ipc_answer_0(rid, EOK);
    675 }
    676 
    677 void tmpfs_close(ipc_callid_t rid, ipc_call_t *request)
    678 {
    679         ipc_answer_0(rid, EOK);
    680 }
    681 
    682 void tmpfs_destroy(ipc_callid_t rid, ipc_call_t *request)
    683 {
    684         dev_handle_t dev_handle = (dev_handle_t)IPC_GET_ARG1(*request);
    685         fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    686         int rc;
    687 
    688         link_t *hlp;
    689         unsigned long key[] = {
    690                 [NODES_KEY_DEV] = dev_handle,
    691                 [NODES_KEY_INDEX] = index
    692         };
    693         hlp = hash_table_find(&nodes, key);
    694         if (!hlp) {
    695                 ipc_answer_0(rid, ENOENT);
    696                 return;
    697         }
    698         tmpfs_node_t *nodep = hash_table_get_instance(hlp, tmpfs_node_t,
    699             nh_link);
    700722        rc = tmpfs_destroy_node(FS_NODE(nodep));
    701723        ipc_answer_0(rid, rc);
Note: See TracChangeset for help on using the changeset viewer.