Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/vfs/vfs_ops.c

    r4cac2d69 r3a4b3ba  
    3838#include "vfs.h"
    3939#include <ipc/ipc.h>
     40#include <macros.h>
     41#include <stdint.h>
    4042#include <async.h>
    4143#include <errno.h>
    4244#include <stdio.h>
    4345#include <stdlib.h>
    44 #include <string.h>
     46#include <str.h>
    4547#include <bool.h>
    4648#include <fibril_synch.h>
    … …  
    5355
    5456/* Forward declarations of static functions. */
    55 static int vfs_truncate_internal(fs_handle_t, dev_handle_t, fs_index_t, size_t);
     57static int vfs_truncate_internal(fs_handle_t, devmap_handle_t, fs_index_t,
     58    aoff64_t);
    5659
    5760/**
    … …  
    6366vfs_pair_t rootfs = {
    6467        .fs_handle = 0,
    65         .dev_handle = 0
     68        .devmap_handle = 0
    6669};
    6770
    68 static void vfs_mount_internal(ipc_callid_t rid, dev_handle_t dev_handle,
     71static void vfs_mount_internal(ipc_callid_t rid, devmap_handle_t devmap_handle,
    6972    fs_handle_t fs_handle, char *mp, char *opts)
    7073{
    … …  
    123126                        phone = vfs_grab_phone(fs_handle);
    124127                        msg = async_send_1(phone, VFS_OUT_MOUNTED,
    125                             (ipcarg_t) dev_handle, &answer);
     128                            (ipcarg_t) devmap_handle, &answer);
    126129                        /* send the mount options */
    127130                        rc = async_data_write_start(phone, (void *)opts,
    … …  
    129132                        if (rc != EOK) {
    130133                                async_wait_for(msg, NULL);
    131                                 vfs_release_phone(phone);
     134                                vfs_release_phone(fs_handle, phone);
    132135                                fibril_rwlock_write_unlock(&namespace_rwlock);
    133136                                ipc_answer_0(rid, rc);
    … …  
    135138                        }
    136139                        async_wait_for(msg, &rc);
    137                         vfs_release_phone(phone);
     140                        vfs_release_phone(fs_handle, phone);
    138141                       
    139142                        if (rc != EOK) {
    … …  
    148151                       
    149152                        mr_res.triplet.fs_handle = fs_handle;
    150                         mr_res.triplet.dev_handle = dev_handle;
     153                        mr_res.triplet.devmap_handle = devmap_handle;
    151154                        mr_res.triplet.index = rindex;
    152155                        mr_res.size = rsize;
    … …  
    155158                       
    156159                        rootfs.fs_handle = fs_handle;
    157                         rootfs.dev_handle = dev_handle;
     160                        rootfs.devmap_handle = devmap_handle;
    158161                       
    159162                        /* Add reference to the mounted root. */
    … …  
    185188        phone = vfs_grab_phone(mp_res.triplet.fs_handle);
    186189        msg = async_send_4(phone, VFS_OUT_MOUNT,
    187             (ipcarg_t) mp_res.triplet.dev_handle,
     190            (ipcarg_t) mp_res.triplet.devmap_handle,
    188191            (ipcarg_t) mp_res.triplet.index,
    189192            (ipcarg_t) fs_handle,
    190             (ipcarg_t) dev_handle, &answer);
     193            (ipcarg_t) devmap_handle, &answer);
    191194       
    192195        /* send connection */
    … …  
    194197        if (rc != EOK) {
    195198                async_wait_for(msg, NULL);
    196                 vfs_release_phone(mountee_phone);
    197                 vfs_release_phone(phone);
     199                vfs_release_phone(fs_handle, mountee_phone);
     200                vfs_release_phone(mp_res.triplet.fs_handle, phone);
    198201                /* Mount failed, drop reference to mp_node. */
    199202                if (mp_node)
    … …  
    204207        }
    205208
    206         vfs_release_phone(mountee_phone);
     209        vfs_release_phone(fs_handle, mountee_phone);
    207210       
    208211        /* send the mount options */
    … …  
    210213        if (rc != EOK) {
    211214                async_wait_for(msg, NULL);
    212                 vfs_release_phone(phone);
     215                vfs_release_phone(mp_res.triplet.fs_handle, phone);
    213216                /* Mount failed, drop reference to mp_node. */
    214217                if (mp_node)
    … …  
    219222        }
    220223        async_wait_for(msg, &rc);
    221         vfs_release_phone(phone);
     224        vfs_release_phone(mp_res.triplet.fs_handle, phone);
    222225       
    223226        if (rc == EOK) {
    … …  
    227230       
    228231                mr_res.triplet.fs_handle = fs_handle;
    229                 mr_res.triplet.dev_handle = dev_handle;
     232                mr_res.triplet.devmap_handle = devmap_handle;
    230233                mr_res.triplet.index = rindex;
    231234                mr_res.size = rsize;
    … …  
    248251void vfs_mount(ipc_callid_t rid, ipc_call_t *request)
    249252{
     253        devmap_handle_t devmap_handle;
     254
    250255        /*
    251256         * We expect the library to do the device-name to device-handle
    … …  
    253258         * in the request.
    254259         */
    255         dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
     260        devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    256261       
    257262        /*
    … …  
    289294         */
    290295        char *fs_name;
    291         rc = async_data_write_accept((void **) &fs_name, true, 0, FS_NAME_MAXLEN,
    292             0, NULL);
     296        rc = async_data_write_accept((void **) &fs_name, true, 0,
     297            FS_NAME_MAXLEN, 0, NULL);
    293298        if (rc != EOK) {
    294299                free(mp);
    … …  
    341346       
    342347        /* Do the mount */
    343         vfs_mount_internal(rid, dev_handle, fs_handle, mp, opts);
     348        vfs_mount_internal(rid, devmap_handle, fs_handle, mp, opts);
    344349        free(mp);
    345350        free(fs_name);
    … …  
    353358        vfs_lookup_res_t mp_res;
    354359        vfs_lookup_res_t mr_res;
    355         vfs_node_t *mp_node;
    356360        vfs_node_t *mr_node;
    357361        int phone;
    … …  
    401405         */
    402406        if (vfs_nodes_refcount_sum_get(mr_node->fs_handle,
    403             mr_node->dev_handle) != 2) {
     407            mr_node->devmap_handle) != 2) {
    404408                fibril_rwlock_write_unlock(&namespace_rwlock);
    405409                vfs_node_put(mr_node);
    … …  
    421425                phone = vfs_grab_phone(mr_node->fs_handle);
    422426                rc = async_req_1_0(phone, VFS_OUT_UNMOUNTED,
    423                     mr_node->dev_handle);
    424                 vfs_release_phone(phone);
     427                    mr_node->devmap_handle);
     428                vfs_release_phone(mr_node->fs_handle, phone);
    425429                if (rc != EOK) {
    426430                        fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    430434                }
    431435                rootfs.fs_handle = 0;
    432                 rootfs.dev_handle = 0;
     436                rootfs.devmap_handle = 0;
    433437        } else {
    434438
    … …  
    457461
    458462                phone = vfs_grab_phone(mp_node->fs_handle);
    459                 rc = async_req_2_0(phone, VFS_OUT_UNMOUNT, mp_node->dev_handle,
    460                     mp_node->index);
    461                 vfs_release_phone(phone);
     463                rc = async_req_2_0(phone, VFS_OUT_UNMOUNT,
     464                    mp_node->devmap_handle, mp_node->index);
     465                vfs_release_phone(mp_node->fs_handle, phone);
    462466                if (rc != EOK) {
    463467                        fibril_rwlock_write_unlock(&namespace_rwlock);
    … …  
    503507        int oflag = IPC_GET_ARG2(*request);
    504508        int mode = IPC_GET_ARG3(*request);
    505         size_t len;
    506509
    507510        /* Ignore mode for now. */
    … …  
    569572                if (node->size) {
    570573                        rc = vfs_truncate_internal(node->fs_handle,
    571                             node->dev_handle, node->index, 0);
     574                            node->devmap_handle, node->index, 0);
    572575                        if (rc) {
    573576                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    … …  
    592595        }
    593596        vfs_file_t *file = vfs_file_get(fd);
     597        assert(file);
    594598        file->node = node;
    595599        if (oflag & O_APPEND)
    … …  
    625629       
    626630        lr.triplet.fs_handle = IPC_GET_ARG1(*request);
    627         lr.triplet.dev_handle = IPC_GET_ARG2(*request);
     631        lr.triplet.devmap_handle = IPC_GET_ARG2(*request);
    628632        lr.triplet.index = IPC_GET_ARG3(*request);
    629633        int oflag = IPC_GET_ARG4(*request);
    … …  
    646650                if (node->size) {
    647651                        rc = vfs_truncate_internal(node->fs_handle,
    648                             node->dev_handle, node->index, 0);
     652                            node->devmap_handle, node->index, 0);
    649653                        if (rc) {
    650654                                fibril_rwlock_write_unlock(&node->contents_rwlock);
    … …  
    708712        aid_t msg;
    709713        ipc_call_t answer;
    710         msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->dev_handle,
     714        msg = async_send_2(fs_phone, VFS_OUT_SYNC, file->node->devmap_handle,
    711715            file->node->index, &answer);
    712716
    … …  
    715719        async_wait_for(msg, &rc);
    716720       
    717         vfs_release_phone(fs_phone);
     721        vfs_release_phone(file->node->fs_handle, fs_phone);
    718722        fibril_mutex_unlock(&file->lock);
    719723       
    … …  
    739743                aid_t msg;
    740744                ipc_call_t answer;
    741                 msg = async_send_2(fs_phone, VFS_OUT_CLOSE, file->node->dev_handle,
    742                     file->node->index, &answer);
     745                msg = async_send_2(fs_phone, VFS_OUT_CLOSE,
     746                    file->node->devmap_handle, file->node->index, &answer);
    743747               
    744748                /* Wait for reply from the FS server. */
    … …  
    746750                async_wait_for(msg, &rc);
    747751               
    748                 vfs_release_phone(fs_phone);
     752                vfs_release_phone(file->node->fs_handle, fs_phone);
    749753                fibril_mutex_unlock(&file->lock);
    750754               
    … …  
    833837        ipc_call_t answer;
    834838        if (read) {
     839                rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ,
     840                    file->node->devmap_handle, file->node->index, file->pos,
     841                    &answer);
     842        } else {
    835843                if (file->append)
    836844                        file->pos = file->node->size;
    837845               
    838                 rc = async_data_read_forward_3_1(fs_phone, VFS_OUT_READ,
    839                     file->node->dev_handle, file->node->index, file->pos,
     846                rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE,
     847                    file->node->devmap_handle, file->node->index, file->pos,
    840848                    &answer);
    841         } else {
    842                 rc = async_data_write_forward_3_1(fs_phone, VFS_OUT_WRITE,
    843                     file->node->dev_handle, file->node->index, file->pos,
    844                     &answer);
    845         }
    846        
    847         vfs_release_phone(fs_phone);
     849        }
     850       
     851        vfs_release_phone(file->node->fs_handle, fs_phone);
    848852       
    849853        size_t bytes = IPC_GET_ARG1(answer);
    … …  
    887891{
    888892        int fd = (int) IPC_GET_ARG1(*request);
    889         off_t off = (off_t) IPC_GET_ARG2(*request);
    890         int whence = (int) IPC_GET_ARG3(*request);
    891 
    892 
     893        off64_t off = (off64_t) MERGE_LOUP32(IPC_GET_ARG2(*request),
     894            IPC_GET_ARG3(*request));
     895        int whence = (int) IPC_GET_ARG4(*request);
     896       
    893897        /* Lookup the file structure corresponding to the file descriptor. */
    894898        vfs_file_t *file = vfs_file_get(fd);
    … …  
    897901                return;
    898902        }
    899 
    900         off_t newpos;
     903       
    901904        fibril_mutex_lock(&file->lock);
    902         if (whence == SEEK_SET) {
    903                 file->pos = off;
    904                 fibril_mutex_unlock(&file->lock);
    905                 ipc_answer_1(rid, EOK, off);
    906                 return;
    907         }
    908         if (whence == SEEK_CUR) {
    909                 if (file->pos + off < file->pos) {
     905       
     906        off64_t newoff;
     907        switch (whence) {
     908        case SEEK_SET:
     909                if (off >= 0) {
     910                        file->pos = (aoff64_t) off;
     911                        fibril_mutex_unlock(&file->lock);
     912                        ipc_answer_1(rid, EOK, off);
     913                        return;
     914                }
     915                break;
     916        case SEEK_CUR:
     917                if ((off >= 0) && (file->pos + off < file->pos)) {
    910918                        fibril_mutex_unlock(&file->lock);
    911919                        ipc_answer_0(rid, EOVERFLOW);
    912920                        return;
    913921                }
    914                 file->pos += off;
    915                 newpos = file->pos;
    916                 fibril_mutex_unlock(&file->lock);
    917                 ipc_answer_1(rid, EOK, newpos);
    918                 return;
    919         }
    920         if (whence == SEEK_END) {
    921                 fibril_rwlock_read_lock(&file->node->contents_rwlock);
    922                 size_t size = file->node->size;
    923                 fibril_rwlock_read_unlock(&file->node->contents_rwlock);
    924                 if (size + off < size) {
     922               
     923                if ((off < 0) && (file->pos < (aoff64_t) -off)) {
    925924                        fibril_mutex_unlock(&file->lock);
    926925                        ipc_answer_0(rid, EOVERFLOW);
    927926                        return;
    928927                }
    929                 newpos = size + off;
    930                 file->pos = newpos;
     928               
     929                file->pos += off;
     930                newoff = (file->pos > OFF64_MAX) ?  OFF64_MAX : file->pos;
     931               
    931932                fibril_mutex_unlock(&file->lock);
    932                 ipc_answer_1(rid, EOK, newpos);
    933                 return;
    934         }
     933                ipc_answer_2(rid, EOK, LOWER32(newoff),
     934                    UPPER32(newoff));
     935                return;
     936        case SEEK_END:
     937                fibril_rwlock_read_lock(&file->node->contents_rwlock);
     938                aoff64_t size = file->node->size;
     939               
     940                if ((off >= 0) && (size + off < size)) {
     941                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
     942                        fibril_mutex_unlock(&file->lock);
     943                        ipc_answer_0(rid, EOVERFLOW);
     944                        return;
     945                }
     946               
     947                if ((off < 0) && (size < (aoff64_t) -off)) {
     948                        fibril_rwlock_read_unlock(&file->node->contents_rwlock);
     949                        fibril_mutex_unlock(&file->lock);
     950                        ipc_answer_0(rid, EOVERFLOW);
     951                        return;
     952                }
     953               
     954                file->pos = size + off;
     955                newoff = (file->pos > OFF64_MAX) ?  OFF64_MAX : file->pos;
     956               
     957                fibril_rwlock_read_unlock(&file->node->contents_rwlock);
     958                fibril_mutex_unlock(&file->lock);
     959                ipc_answer_2(rid, EOK, LOWER32(newoff), UPPER32(newoff));
     960                return;
     961        }
     962       
    935963        fibril_mutex_unlock(&file->lock);
    936964        ipc_answer_0(rid, EINVAL);
    937965}
    938966
    939 int
    940 vfs_truncate_internal(fs_handle_t fs_handle, dev_handle_t dev_handle,
    941     fs_index_t index, size_t size)
     967int vfs_truncate_internal(fs_handle_t fs_handle, devmap_handle_t devmap_handle,
     968    fs_index_t index, aoff64_t size)
    942969{
    943970        ipcarg_t rc;
    … …  
    945972       
    946973        fs_phone = vfs_grab_phone(fs_handle);
    947         rc = async_req_3_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t)dev_handle,
    948             (ipcarg_t)index, (ipcarg_t)size);
    949         vfs_release_phone(fs_phone);
     974        rc = async_req_4_0(fs_phone, VFS_OUT_TRUNCATE, (ipcarg_t) devmap_handle,
     975            (ipcarg_t) index, LOWER32(size), UPPER32(size));
     976        vfs_release_phone(fs_handle, fs_phone);
    950977        return (int)rc;
    951978}
    … …  
    954981{
    955982        int fd = IPC_GET_ARG1(*request);
    956         size_t size = IPC_GET_ARG2(*request);
     983        aoff64_t size = (aoff64_t) MERGE_LOUP32(IPC_GET_ARG2(*request),
     984            IPC_GET_ARG3(*request));
    957985        int rc;
    958986
    … …  
    966994        fibril_rwlock_write_lock(&file->node->contents_rwlock);
    967995        rc = vfs_truncate_internal(file->node->fs_handle,
    968             file->node->dev_handle, file->node->index, size);
     996            file->node->devmap_handle, file->node->index, size);
    969997        if (rc == EOK)
    970998                file->node->size = size;
    … …  
    9981026       
    9991027        aid_t msg;
    1000         msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->dev_handle,
     1028        msg = async_send_3(fs_phone, VFS_OUT_STAT, file->node->devmap_handle,
    10011029            file->node->index, true, NULL);
    10021030        ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    10031031        async_wait_for(msg, &rc);
    1004         vfs_release_phone(fs_phone);
     1032        vfs_release_phone(file->node->fs_handle, fs_phone);
    10051033
    10061034        fibril_mutex_unlock(&file->lock);
    … …  
    10471075        int fs_phone = vfs_grab_phone(node->fs_handle);
    10481076        aid_t msg;
    1049         msg = async_send_3(fs_phone, VFS_OUT_STAT, node->dev_handle,
     1077        msg = async_send_3(fs_phone, VFS_OUT_STAT, node->devmap_handle,
    10501078            node->index, false, NULL);
    10511079        ipc_forward_fast(callid, fs_phone, 0, 0, 0, IPC_FF_ROUTE_FROM_ME);
    … …  
    10531081        ipcarg_t rv;
    10541082        async_wait_for(msg, &rv);
    1055         vfs_release_phone(fs_phone);
     1083        vfs_release_phone(node->fs_handle, fs_phone);
    10561084
    10571085        ipc_answer_0(rid, rv);
    … …  
    12211249        /* Check whether linking to the same file system instance. */
    12221250        if ((old_node->fs_handle != new_par_lr.triplet.fs_handle) ||
    1223             (old_node->dev_handle != new_par_lr.triplet.dev_handle)) {
     1251            (old_node->devmap_handle != new_par_lr.triplet.devmap_handle)) {
    12241252                fibril_rwlock_write_unlock(&namespace_rwlock);
    12251253                ipc_answer_0(rid, EXDEV);       /* different file systems */
    … …  
    13311359                int ret = vfs_close_internal(newfile);
    13321360                if (ret != EOK) {
     1361                        fibril_mutex_unlock(&oldfile->lock);
    13331362                        ipc_answer_0(rid, ret);
    13341363                        return;
    … …  
    13371366                ret = vfs_fd_free(newfd);
    13381367                if (ret != EOK) {
     1368                        fibril_mutex_unlock(&oldfile->lock);
    13391369                        ipc_answer_0(rid, ret);
    13401370                        return;
Note: See TracChangeset for help on using the changeset viewer.