Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/vfs/vfs_lookup.c

    r4198f9c3 rffa2c8ef  
    3737
    3838#include "vfs.h"
    39 #include <ipc/ipc.h>
     39#include <macros.h>
    4040#include <async.h>
    4141#include <errno.h>
    42 #include <string.h>
     42#include <str.h>
    4343#include <stdarg.h>
    4444#include <bool.h>
    45 #include <fibril_sync.h>
     45#include <fibril_synch.h>
    4646#include <adt/list.h>
    4747#include <vfs/canonify.h>
     
    9999        entry.len = len;
    100100
    101         off_t first;    /* the first free index */
    102         off_t last;     /* the last free index */
     101        size_t first;   /* the first free index */
     102        size_t last;    /* the last free index */
    103103
    104104        if (list_empty(&plb_head)) {
     
    160160        ipc_call_t answer;
    161161        int phone = vfs_grab_phone(root->fs_handle);
    162         aid_t req = async_send_5(phone, VFS_OUT_LOOKUP, (ipcarg_t) first,
    163             (ipcarg_t) (first + len - 1) % PLB_SIZE,
    164             (ipcarg_t) root->dev_handle, (ipcarg_t) lflag, (ipcarg_t) index,
     162        aid_t req = async_send_5(phone, VFS_OUT_LOOKUP, (sysarg_t) first,
     163            (sysarg_t) (first + len - 1) % PLB_SIZE,
     164            (sysarg_t) root->devmap_handle, (sysarg_t) lflag, (sysarg_t) index,
    165165            &answer);
    166166       
    167         ipcarg_t rc;
     167        sysarg_t rc;
    168168        async_wait_for(req, &rc);
    169         vfs_release_phone(phone);
     169        vfs_release_phone(root->fs_handle, phone);
    170170       
    171171        fibril_mutex_lock(&plb_mutex);
     
    177177        memset(plb, 0, cnt2);
    178178        fibril_mutex_unlock(&plb_mutex);
    179 
    180         if ((rc == EOK) && (result)) {
    181                 result->triplet.fs_handle = (fs_handle_t) IPC_GET_ARG1(answer);
    182                 result->triplet.dev_handle = (dev_handle_t) IPC_GET_ARG2(answer);
    183                 result->triplet.index = (fs_index_t) IPC_GET_ARG3(answer);
    184                 result->size = (size_t) IPC_GET_ARG4(answer);
    185                 result->lnkcnt = (unsigned) IPC_GET_ARG5(answer);
    186                 if (lflag & L_FILE)
     179       
     180        if ((int) rc < EOK)
     181                return (int) rc;
     182
     183        if (!result)
     184                return EOK;
     185       
     186        result->triplet.fs_handle = (fs_handle_t) rc;
     187        result->triplet.devmap_handle = (devmap_handle_t) IPC_GET_ARG1(answer);
     188        result->triplet.index = (fs_index_t) IPC_GET_ARG2(answer);
     189        result->size =
     190            (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(answer), IPC_GET_ARG4(answer));
     191        result->lnkcnt = (unsigned int) IPC_GET_ARG5(answer);
     192       
     193        if (lflag & L_FILE)
     194                result->type = VFS_NODE_FILE;
     195        else if (lflag & L_DIRECTORY)
     196                result->type = VFS_NODE_DIRECTORY;
     197        else
     198                result->type = VFS_NODE_UNKNOWN;
     199       
     200        return EOK;
     201}
     202
     203/** Perform a node open operation.
     204 *
     205 * @return EOK on success or an error code from errno.h.
     206 *
     207 */
     208int vfs_open_node_internal(vfs_lookup_res_t *result)
     209{
     210        int phone = vfs_grab_phone(result->triplet.fs_handle);
     211       
     212        ipc_call_t answer;
     213        aid_t req = async_send_2(phone, VFS_OUT_OPEN_NODE,
     214            (sysarg_t) result->triplet.devmap_handle,
     215            (sysarg_t) result->triplet.index, &answer);
     216       
     217        sysarg_t rc;
     218        async_wait_for(req, &rc);
     219        vfs_release_phone(result->triplet.fs_handle, phone);
     220       
     221        if (rc == EOK) {
     222                result->size =
     223                    MERGE_LOUP32(IPC_GET_ARG1(answer), IPC_GET_ARG2(answer));
     224                result->lnkcnt = (unsigned int) IPC_GET_ARG3(answer);
     225                if (IPC_GET_ARG4(answer) & L_FILE)
    187226                        result->type = VFS_NODE_FILE;
    188                 else if (lflag & L_DIRECTORY)
     227                else if (IPC_GET_ARG4(answer) & L_DIRECTORY)
    189228                        result->type = VFS_NODE_DIRECTORY;
    190229                else
    191230                        result->type = VFS_NODE_UNKNOWN;
    192231        }
    193 
     232       
    194233        return rc;
    195234}
    196235
    197 /** Perform a node open operation.
    198  *
    199  * @return EOK on success or an error code from errno.h.
    200  *
    201  */
    202 int vfs_open_node_internal(vfs_lookup_res_t *result)
    203 {
    204         int phone = vfs_grab_phone(result->triplet.fs_handle);
    205        
    206         ipc_call_t answer;
    207         aid_t req = async_send_2(phone, VFS_OUT_OPEN_NODE,
    208             (ipcarg_t) result->triplet.dev_handle,
    209             (ipcarg_t) result->triplet.index, &answer);
    210        
    211        
    212         ipcarg_t rc;
    213         async_wait_for(req, &rc);
    214         vfs_release_phone(phone);
    215        
    216         if (rc == EOK) {
    217                 result->size = (size_t) IPC_GET_ARG1(answer);
    218                 result->lnkcnt = (unsigned) IPC_GET_ARG2(answer);
    219                 if (IPC_GET_ARG3(answer) & L_FILE)
    220                         result->type = VFS_NODE_FILE;
    221                 else if (IPC_GET_ARG3(answer) & L_DIRECTORY)
    222                         result->type = VFS_NODE_DIRECTORY;
    223                 else
    224                         result->type = VFS_NODE_UNKNOWN;
    225         }
    226        
    227         return rc;
    228 }
    229 
    230236/**
    231237 * @}
Note: See TracChangeset for help on using the changeset viewer.