VirtualBox

Ignore:
Timestamp:
Nov 22, 2018 9:16:48 PM (6 years ago)
Author:
vboxsync
Message:

darwin/VBoxSF: Started rewriting this...

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/darwin/VBoxSF/VBoxSF-VNodeOps.cpp

    r75666 r75675  
    2121*   Header Files                                                                                                                 *
    2222*********************************************************************************************************************************/
     23#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
    2324#include "VBoxSFInternal.h"
    2425
    2526#include <iprt/mem.h>
    2627#include <iprt/assert.h>
    27 
    28 
    29 
    30 int vboxvfs_dfl_error(void)
    31 {
    32     PDEBUG("vboxvfs_dfl_error is called");
    33 
     28#include <VBox/log.h>
     29
     30
     31/*********************************************************************************************************************************
     32*   Structures and Typedefs                                                                                                      *
     33*********************************************************************************************************************************/
     34struct default_error_args_hack
     35{
     36    struct default_error_vdesc_hack
     37    {
     38        int vdesc_offset;
     39        const char *vdesc_name;
     40    } const *a_desc;
     41};
     42
     43
     44
     45/**
     46 * Default implementation that returns ENOTSUP.
     47 */
     48static int vboxSfDwnVnDefaultError(struct default_error_args_hack *pArgs)
     49{
     50    Log(("vboxSfDwnVnDefaultError: %s\n", RT_VALID_PTR(pArgs) && RT_VALID_PTR(pArgs->a_desc) ? pArgs->a_desc->vdesc_name : "??"));
     51    RT_NOREF(pArgs);
    3452    return ENOTSUP;
    3553}
    3654
    37 int vboxvfs_vnode_getattr(struct vnop_getattr_args *args)
    38 {
     55
     56static int vboxFsDwnVnGetAttr(struct vnop_getattr_args *pArgs)
     57{
     58#if 1
     59    RT_NOREF(pArgs);
     60    return ENOTSUP;
     61#else
     62
    3963    vboxvfs_mount_t   *pMount;
    4064    struct vnode_attr *vnode_args;
    … …  
    5074    PDEBUG("Getting vnode attribute...");
    5175
    52     AssertReturn(args, EINVAL);
    53 
    54     vnode                = args->a_vp;                                   AssertReturn(vnode,           EINVAL);
    55     vnode_args           = args->a_vap;                                  AssertReturn(vnode_args,      EINVAL);
     76    AssertReturn(pArgs, EINVAL);
     77
     78    vnode                = pArgs->a_vp;                                   AssertReturn(vnode,           EINVAL);
     79    vnode_args           = pArgs->a_vap;                                  AssertReturn(vnode_args,      EINVAL);
    5680    mp                   = vnode_mount(vnode);                           AssertReturn(mp,              EINVAL);
    5781    pMount      = (vboxvfs_mount_t *)vfs_fsprivate(mp);     AssertReturn(pMount, EINVAL);
    … …  
    125149
    126150    return rc;
    127 }
    128 
     151#endif
     152}
     153
     154#if 0
    129155/**
    130156 * Helper function for vboxvfs_vnode_lookup(): create new vnode.
    … …  
    217243 */
    218244static int
    219 vboxvfs_vnode_lookup_dot_handler(struct vnop_lookup_args *args, vnode_t *result_vnode)
     245vboxvfs_vnode_lookup_dot_handler(struct vnop_lookup_args *pArgs, vnode_t *result_vnode)
    220246{
    221247    vnode_t vnode = NULL;
    222248
    223     if (args->a_cnp->cn_flags & ISDOTDOT)
    224     {
    225         vnode = vnode_getparent(args->a_dvp);
     249    if (pArgs->a_cnp->cn_flags & ISDOTDOT)
     250    {
     251        vnode = vnode_getparent(pArgs->a_dvp);
    226252        if (vnode)
    227253        {
    … …  
    233259        {
    234260            PDEBUG("return parent directory not found, return current directory");
    235             *result_vnode = args->a_dvp;
     261            *result_vnode = pArgs->a_dvp;
    236262            return 0;
    237263        }
    238264    }
    239     else if ((strncmp(args->a_cnp->cn_nameptr, ".", 1) == 0) &&
    240              args->a_cnp->cn_namelen == 1)
     265    else if ((strncmp(pArgs->a_cnp->cn_nameptr, ".", 1) == 0) &&
     266             pArgs->a_cnp->cn_namelen == 1)
    241267    {
    242268        PDEBUG("return current directory");
    243         *result_vnode = args->a_dvp;
     269        *result_vnode = pArgs->a_dvp;
    244270        return 0;
    245271    }
    … …  
    247273    return ENOENT;
    248274}
    249 
    250 int vboxvfs_vnode_lookup(struct vnop_lookup_args *args)
    251 {
     275#endif
     276
     277static int vboxSfDwnVnLookup(struct vnop_lookup_args *pArgs)
     278{
     279#if 1
     280    RT_NOREF(pArgs);
     281    return ENOTSUP;
     282#else
    252283    int rc;
    253284
    … …  
    257288    PDEBUG("Looking up for vnode...");
    258289
    259     AssertReturn(args,                      EINVAL);
    260     AssertReturn(args->a_dvp,               EINVAL);
    261     AssertReturn(vnode_isdir(args->a_dvp),  EINVAL);
    262     AssertReturn(args->a_cnp,               EINVAL);
    263     AssertReturn(args->a_cnp->cn_nameptr,   EINVAL);
    264     AssertReturn(args->a_vpp,               EINVAL);
    265 
    266     pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(args->a_dvp);
     290    AssertReturn(pArgs,                      EINVAL);
     291    AssertReturn(pArgs->a_dvp,               EINVAL);
     292    AssertReturn(vnode_isdir(pArgs->a_dvp),  EINVAL);
     293    AssertReturn(pArgs->a_cnp,               EINVAL);
     294    AssertReturn(pArgs->a_cnp->cn_nameptr,   EINVAL);
     295    AssertReturn(pArgs->a_vpp,               EINVAL);
     296
     297    pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(pArgs->a_dvp);
    267298    AssertReturn(pVnodeData, EINVAL);
    268299    AssertReturn(pVnodeData->pLock, EINVAL);
    269300
    270301    /*
    271     todo: take care about args->a_cnp->cn_nameiop
     302    todo: take care about pArgs->a_cnp->cn_nameiop
    272303    */
    273304
    274     if      (args->a_cnp->cn_nameiop == LOOKUP) PDEBUG("LOOKUP");
    275     else if (args->a_cnp->cn_nameiop == CREATE) PDEBUG("CREATE");
    276     else if (args->a_cnp->cn_nameiop == RENAME) PDEBUG("RENAME");
    277     else if (args->a_cnp->cn_nameiop == DELETE) PDEBUG("DELETE");
    278     else PDEBUG("Unknown cn_nameiop: 0x%X", (int)args->a_cnp->cn_nameiop);
     305    if      (pArgs->a_cnp->cn_nameiop == LOOKUP) PDEBUG("LOOKUP");
     306    else if (pArgs->a_cnp->cn_nameiop == CREATE) PDEBUG("CREATE");
     307    else if (pArgs->a_cnp->cn_nameiop == RENAME) PDEBUG("RENAME");
     308    else if (pArgs->a_cnp->cn_nameiop == DELETE) PDEBUG("DELETE");
     309    else PDEBUG("Unknown cn_nameiop: 0x%X", (int)pArgs->a_cnp->cn_nameiop);
    279310
    280311    lck_rw_lock_exclusive(pVnodeData->pLock);
    281312
    282313    /* Take care about '.' and '..' entries */
    283     if (vboxvfs_vnode_lookup_dot_handler(args, &vnode) == 0)
     314    if (vboxvfs_vnode_lookup_dot_handler(pArgs, &vnode) == 0)
    284315    {
    285316        vnode_get(vnode);
    286         *args->a_vpp = vnode;
     317        *pArgs->a_vpp = vnode;
    287318
    288319        lck_rw_unlock_exclusive(pVnodeData->pLock);
    … …  
    292323
    293324    /* Look into VFS cache and attempt to find previously allocated vnode there. */
    294     rc = cache_lookup(args->a_dvp, &vnode, args->a_cnp);
     325    rc = cache_lookup(pArgs->a_dvp, &vnode, pArgs->a_cnp);
    295326    if (rc == -1) /* Record found */
    296327    {
    … …  
    302333            /* Prepare & return cached vnode */
    303334            vnode_get(vnode);
    304             *args->a_vpp = vnode;
     335            *pArgs->a_vpp = vnode;
    305336
    306337            rc = 0;
    … …  
    318349        PDEBUG("cache_lookup() returned %d, create new VFS vnode", rc);
    319350
    320         rc = vboxvfs_vnode_lookup_instantinate_vnode(args->a_dvp, args->a_cnp->cn_nameptr, &vnode);
     351        rc = vboxvfs_vnode_lookup_instantinate_vnode(pArgs->a_dvp, pArgs->a_cnp->cn_nameptr, &vnode);
    321352        if (rc == 0)
    322353        {
    323             cache_enter(args->a_dvp, vnode, args->a_cnp);
    324             *args->a_vpp = vnode;
     354            cache_enter(pArgs->a_dvp, vnode, pArgs->a_cnp);
     355            *pArgs->a_vpp = vnode;
    325356        }
    326357        else
    … …  
    333364
    334365    return rc;
    335 }
    336 
    337 int vboxvfs_vnode_open(struct vnop_open_args *args)
    338 {
     366#endif
     367}
     368
     369static int vboxSfDwnVnOpen(struct vnop_open_args *pArgs)
     370{
     371#if 1
     372    RT_NOREF(pArgs);
     373    return ENOTSUP;
     374#else
    339375    vnode_t           vnode;
    340376    vboxvfs_vnode_t  *pVnodeData;
    … …  
    347383    PDEBUG("Opening vnode...");
    348384
    349     AssertReturn(args, EINVAL);
    350 
    351     vnode           = args->a_vp;                              AssertReturn(vnode,      EINVAL);
     385    AssertReturn(pArgs, EINVAL);
     386
     387    vnode           = pArgs->a_vp;                              AssertReturn(vnode,      EINVAL);
    352388    pVnodeData      = (vboxvfs_vnode_t *)vnode_fsnode(vnode);  AssertReturn(pVnodeData, EINVAL);
    353389    mp              = vnode_mount(vnode);                      AssertReturn(mp,         EINVAL);
    … …  
    374410    //}
    375411
    376     fHostFlags  = vboxvfs_g2h_mode_inernal(args->a_mode);
     412    fHostFlags  = vboxvfs_g2h_mode_inernal(pArgs->a_mode);
    377413    fHostFlags |= (vnode_isdir(vnode) ? SHFL_CF_DIRECTORY : 0);
    378414
    … …  
    397433
    398434    return rc;
    399 }
    400 
    401 int vboxvfs_vnode_close(struct vnop_close_args *args)
    402 {
     435#endif
     436}
     437
     438static int vboxSfDwnVnClose(struct vnop_close_args *pArgs)
     439{
     440#if 1
     441    RT_NOREF(pArgs);
     442    return ENOTSUP;
     443#else
     444
    403445    vnode_t          vnode;
    404446    mount_t          mp;
    … …  
    410452    PDEBUG("Closing vnode...");
    411453
    412     AssertReturn(args, EINVAL);
    413 
    414     vnode           = args->a_vp;                              AssertReturn(vnode,      EINVAL);
     454    AssertReturn(pArgs, EINVAL);
     455
     456    vnode           = pArgs->a_vp;                              AssertReturn(vnode,      EINVAL);
    415457    pVnodeData      = (vboxvfs_vnode_t *)vnode_fsnode(vnode);  AssertReturn(pVnodeData, EINVAL);
    416458    mp              = vnode_mount(vnode);                      AssertReturn(mp,         EINVAL);
    … …  
    457499
    458500    return rc;
    459 }
    460 
     501#endif
     502}
     503
     504#if 0
    461505/**
    462506 * Convert SHFLDIRINFO to struct dirent and copy it back to user.
    … …  
    501545    return rc;
    502546}
    503 
    504 int vboxvfs_vnode_readdir(struct vnop_readdir_args *args)
    505 {
     547#endif
     548
     549static int vboxSfDwnVnReadDir(struct vnop_readdir_args *pArgs)
     550{
     551#if 1
     552    RT_NOREF(pArgs);
     553    return ENOTSUP;
     554#else
    506555    vboxvfs_mount_t *pMount;
    507556    vboxvfs_vnode_t *pVnodeData;
    … …  
    516565    PDEBUG("Reading directory...");
    517566
    518     AssertReturn(args,              EINVAL);
    519     AssertReturn(args->a_eofflag,   EINVAL);
    520     AssertReturn(args->a_numdirent, EINVAL);
    521 
    522     uio             = args->a_uio;                             AssertReturn(uio,        EINVAL);
    523     vnode           = args->a_vp;                              AssertReturn(vnode,      EINVAL); AssertReturn(vnode_isdir(vnode), EINVAL);
     567    AssertReturn(pArgs,              EINVAL);
     568    AssertReturn(pArgs->a_eofflag,   EINVAL);
     569    AssertReturn(pArgs->a_numdirent, EINVAL);
     570
     571    uio             = pArgs->a_uio;                             AssertReturn(uio,        EINVAL);
     572    vnode           = pArgs->a_vp;                              AssertReturn(vnode,      EINVAL); AssertReturn(vnode_isdir(vnode), EINVAL);
    524573    pVnodeData      = (vboxvfs_vnode_t *)vnode_fsnode(vnode);  AssertReturn(pVnodeData, EINVAL);
    525574    mp              = vnode_mount(vnode);                      AssertReturn(mp,         EINVAL);
    … …  
    572621            uint32_t cbReturned = cbInfo;
    573622            //rc = VbglR0SfDirInfo(&g_vboxSFClient, &pMount->pMap, Handle, pMask, SHFL_LIST_RETURN_ONE, 0, &cbReturned, (PSHFLDIRINFO)Info, &cFiles);
    574             rc = VbglR0SfDirInfo(&g_SfClient, &pMount->pMap, Handle, 0, SHFL_LIST_RETURN_ONE, 0,
     623            rc = VbglR0SfDirInfo(&g_SfClientDarwin, &pMount->pMap, Handle, 0, SHFL_LIST_RETURN_ONE, 0,
    575624                                 &cbReturned, (PSHFLDIRINFO)Info, &cFiles);
    576625
    … …  
    598647        case VINF_SUCCESS:
    599648        {
    600             rc = vboxvfs_vnode_readdir_copy_data((ino_t)(index + 1), Info, uio, args->a_numdirent);
     649            rc = vboxvfs_vnode_readdir_copy_data((ino_t)(index + 1), Info, uio, pArgs->a_numdirent);
    601650            break;
    602651        }
    … …  
    605654        {
    606655            PDEBUG("No more entries in directory");
    607             *(args->a_eofflag) = 1;
     656            *(pArgs->a_eofflag) = 1;
    608657            break;
    609658        }
    … …  
    621670
    622671    return rc;
    623 }
    624 
    625 
    626 int vboxvfs_vnode_access(struct vnop_access_args *args)
     672#endif
     673}
     674
     675
     676static int vboxSfDwnVnPathConf(struct vnop_pathconf_args *pArgs)
    627677{
    628678    PDEBUG("here");
    … …  
    631681
    632682
    633 int vboxvfs_vnode_readdirattr(struct vnop_readdirattr_args *args)
    634 {
    635     PDEBUG("here");
    636     return 0;
    637 }
    638 
    639 int vboxvfs_vnode_pathconf(struct vnop_pathconf_args *args)
    640 {
    641     PDEBUG("here");
    642     return 0;
    643 }
    644 
    645683/**
     684 * vnop_reclaim implementation.
     685 *
    646686 * VBoxVFS reclaim callback.
    647687 * Called when vnode is going to be deallocated. Should release
    … …  
    652692 * @return 0 on success, BSD error code otherwise.
    653693 */
    654 int vboxvfs_vnode_reclaim(struct vnop_reclaim_args *pArgs)
    655 {
    656     PDEBUG("Releasing vnode resources...");
    657 
    658     AssertReturn(pArgs, EINVAL);
    659 
    660     vnode_t          pVnode;
    661     vboxvfs_vnode_t *pVnodeData;
    662     vboxvfs_mount_t *pMount;
    663     mount_t          mp;
    664 
    665     pVnode = pArgs->a_vp;
    666     AssertReturn(pVnode, EINVAL);
    667 
    668     mp = vnode_mount(pVnode);
    669     AssertReturn(mp, EINVAL);
    670 
    671     pMount = (vboxvfs_mount_t *)vfs_fsprivate(mp);
    672     AssertReturn(pMount, EINVAL);
    673 
    674     pVnodeData = (vboxvfs_vnode_t *)vnode_fsnode(pVnode);
    675     AssertReturn(pVnodeData, EINVAL);
    676     AssertReturn(pVnodeData->pPath, EINVAL);
    677     AssertReturn(pVnodeData->pLockAttr, EINVAL);
    678     AssertReturn(pVnodeData->pLock, EINVAL);
    679 
    680     RTMemFree(pVnodeData->pPath);
    681     pVnodeData->pPath = NULL;
    682 
    683     lck_rw_free(pVnodeData->pLock, pMount->pLockGroup);
    684     pVnodeData->pLock = NULL;
    685 
    686     lck_attr_free(pVnodeData->pLockAttr);
    687     pVnodeData->pLockAttr = NULL;
    688 
     694static int vboxSfDwnVnReclaim(struct vnop_reclaim_args *pArgs)
     695{
     696    AssertReturn(pArgs && pArgs->a_vp, EINVAL);
     697
     698    /* Check that it's not a root node that's in use. */
     699    PVBOXSFMNT pMntData = (PVBOXSFMNT)vfs_fsprivate(vnode_mount(pArgs->a_vp));
     700    AssertReturn(!pMntData || pMntData->pVnRoot != pArgs->a_vp, EBUSY);
     701
     702    /* Get the private data and free it. */
     703    PVBOXSFDWNVNDATA pVnData = (PVBOXSFDWNVNDATA)vnode_fsnode(pArgs->a_vp);
     704    AssertPtrReturn(pVnData, 0);
     705
     706    if (pVnData->hHandle != SHFL_HANDLE_NIL)
     707    {
     708        /** @todo can this happen? */
     709        pVnData->hHandle = SHFL_HANDLE_NIL;
     710    }
     711
     712    RTMemFree(pVnData);
    689713    return 0;
     714}
     715
     716
     717/**
     718 * Allocates a vnode.
     719 *
     720 * @returns Pointer to the new VNode, NULL if out of memory.
     721 * @param   pMount          The file system mount structure.
     722 * @param   enmType         The vnode type.
     723 * @param   pParent         The parent vnode, NULL if root.
     724 * @param   cbFile          The file size
     725 */
     726vnode_t vboxSfDwnVnAlloc(mount_t pMount, enum vtype enmType, vnode_t pParent, uint64_t cbFile)
     727{
     728    /*
     729     * Create our private data.
     730     */
     731    PVBOXSFDWNVNDATA pVnData = (PVBOXSFDWNVNDATA)RTMemAllocZ(sizeof(*pVnData));
     732    if (pVnData)
     733    {
     734        pVnData->hHandle = SHFL_HANDLE_NIL;
     735
     736        struct vnode_fsparam VnParms;
     737        RT_ZERO(VnParms);
     738        VnParms.vnfs_mp         = pMount;
     739        VnParms.vnfs_vtype      = enmType;
     740        VnParms.vnfs_str        = "vboxsf";
     741        VnParms.vnfs_dvp        = pParent;
     742        VnParms.vnfs_fsnode     = pVnData;
     743        VnParms.vnfs_vops       = g_papfnVBoxVFSVnodeDirOpsVector;
     744        VnParms.vnfs_markroot   = pParent == NULL;
     745        VnParms.vnfs_marksystem = 0;
     746        VnParms.vnfs_rdev       = 0;
     747        VnParms.vnfs_filesize   = cbFile;
     748        VnParms.vnfs_cnp        = 0;
     749        VnParms.vnfs_flags      = VNFS_NOCACHE;
     750
     751        vnode_t pVnRet;
     752        int rc = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &VnParms, &pVnRet);
     753        if (rc == 0)
     754            return pVnRet;
     755        RTMemFree(pVnData);
     756    }
     757    printf("vboxSfDwnVnAlloc: out of memory!\n");
     758    return NULL;
    690759}
    691760
    … …  
    697766{
    698767#define VNODEOPFUNC int(*)(void *)
    699     { &vnop_default_desc,     (VNODEOPFUNC)vboxvfs_dfl_error },
    700     { &vnop_lookup_desc,      (VNODEOPFUNC)vboxvfs_vnode_lookup },
    701     { &vnop_create_desc,      (VNODEOPFUNC)vboxvfs_dfl_error },
    702     { &vnop_whiteout_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    703     { &vnop_mknod_desc,       (VNODEOPFUNC)vboxvfs_dfl_error },
    704     { &vnop_open_desc,        (VNODEOPFUNC)vboxvfs_vnode_open },
    705     { &vnop_close_desc,       (VNODEOPFUNC)vboxvfs_vnode_close },
    706     { &vnop_access_desc,      (VNODEOPFUNC)vboxvfs_vnode_access },
    707     { &vnop_getattr_desc,     (VNODEOPFUNC)vboxvfs_vnode_getattr },
    708     { &vnop_setattr_desc,     (VNODEOPFUNC)vboxvfs_dfl_error },
    709     { &vnop_read_desc,        (VNODEOPFUNC)vboxvfs_dfl_error },
    710     { &vnop_write_desc,       (VNODEOPFUNC)vboxvfs_dfl_error },
    711     { &vnop_ioctl_desc,       (VNODEOPFUNC)vboxvfs_dfl_error },
    712     { &vnop_select_desc,      (VNODEOPFUNC)vboxvfs_dfl_error },
    713     { &vnop_exchange_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    714     { &vnop_revoke_desc,      (VNODEOPFUNC)vboxvfs_dfl_error },
    715     { &vnop_mmap_desc,        (VNODEOPFUNC)vboxvfs_dfl_error },
    716     { &vnop_mnomap_desc,      (VNODEOPFUNC)vboxvfs_dfl_error },
    717     { &vnop_fsync_desc,       (VNODEOPFUNC)vboxvfs_dfl_error },
    718     { &vnop_remove_desc,      (VNODEOPFUNC)vboxvfs_dfl_error },
    719     { &vnop_link_desc,        (VNODEOPFUNC)vboxvfs_dfl_error },
    720     { &vnop_rename_desc,      (VNODEOPFUNC)vboxvfs_dfl_error },
    721     { &vnop_mkdir_desc,       (VNODEOPFUNC)vboxvfs_dfl_error },
    722     { &vnop_rmdir_desc,       (VNODEOPFUNC)vboxvfs_dfl_error },
    723     { &vnop_symlink_desc,     (VNODEOPFUNC)vboxvfs_dfl_error },
    724     { &vnop_readdir_desc,     (VNODEOPFUNC)vboxvfs_vnode_readdir },
    725     { &vnop_readdirattr_desc, (VNODEOPFUNC)vboxvfs_vnode_readdirattr },
    726     { &vnop_readlink_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    727     { &vnop_inactive_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    728     { &vnop_reclaim_desc,     (VNODEOPFUNC)vboxvfs_vnode_reclaim },
    729     /* { &vnop_print_desc,       (VNODEOPFUNC)vboxvfs_dfl_error }, undefined in ML */
    730     { &vnop_pathconf_desc,    (VNODEOPFUNC)vboxvfs_vnode_pathconf },
    731     { &vnop_advlock_desc,     (VNODEOPFUNC)vboxvfs_dfl_error },
    732     /* { &vnop_truncate_desc,    (VNODEOPFUNC)vboxvfs_dfl_error }, undefined in ML */
    733     { &vnop_allocate_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    734     { &vnop_pagein_desc,      (VNODEOPFUNC)vboxvfs_dfl_error },
    735     { &vnop_pageout_desc,     (VNODEOPFUNC)vboxvfs_dfl_error },
    736     { &vnop_searchfs_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    737     { &vnop_copyfile_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    738     { &vnop_blktooff_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    739     { &vnop_offtoblk_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    740     { &vnop_blockmap_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    741     { &vnop_strategy_desc,    (VNODEOPFUNC)vboxvfs_dfl_error },
    742     { &vnop_bwrite_desc,      (VNODEOPFUNC)vboxvfs_dfl_error },
     768    { &vnop_default_desc,     (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     769    //{ &vnop_access_desc,      (VNODEOPFUNC)vboxSfDwnVnDefaultError }, - probably not needed.
     770    //{ &vnop_advlock_desc,     (VNODEOPFUNC)vboxSfDwnVnDefaultError }, - later.
     771    //{ &vnop_allocate_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError }, - maybe, need shfl function
     772    { &vnop_blktooff_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     773    //{ &vnop_blockmap_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     774    //{ &vnop_bwrite_desc,      (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     775    { &vnop_close_desc,       (VNODEOPFUNC)vboxSfDwnVnClose },
     776    //{ &vnop_copyfile_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     777    { &vnop_create_desc,      (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     778    //{ &vnop_exchange_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     779    { &vnop_fsync_desc,       (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     780    { &vnop_getattr_desc,     (VNODEOPFUNC)vboxFsDwnVnGetAttr },
     781    //{ &vnop_getnamedstream_desc, (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     782    //{ &vnop_getxattr_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     783    { &vnop_inactive_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     784    { &vnop_ioctl_desc,       (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     785    { &vnop_link_desc,        (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     786    //{ &vnop_listxattr_desc,   (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     787    { &vnop_lookup_desc,      (VNODEOPFUNC)vboxSfDwnVnLookup },
     788    { &vnop_mkdir_desc,       (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     789    { &vnop_mknod_desc,       (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     790    { &vnop_mmap_desc,        (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     791    { &vnop_mnomap_desc,      (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     792    { &vnop_offtoblk_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     793    { &vnop_open_desc,        (VNODEOPFUNC)vboxSfDwnVnOpen },
     794    { &vnop_pagein_desc,      (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     795    { &vnop_pageout_desc,     (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     796    { &vnop_pathconf_desc,    (VNODEOPFUNC)vboxSfDwnVnPathConf },
     797    /* { &vnop_print_desc,       (VNODEOPFUNC)vboxSfDwnVnDefaultError }, undefined in ML */
     798    { &vnop_read_desc,        (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     799    { &vnop_readdir_desc,     (VNODEOPFUNC)vboxSfDwnVnReadDir },
     800    //{ &vnop_readdirattr_desc, (VNODEOPFUNC)vboxSfDwnVnDefaultError }, - hfs specific.
     801    { &vnop_readlink_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     802    { &vnop_reclaim_desc,     (VNODEOPFUNC)vboxSfDwnVnReclaim },
     803    { &vnop_remove_desc,      (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     804    //{ &vnop_removexattr_desc, (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     805    { &vnop_rename_desc,      (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     806    //{ &vnop_revoke_desc,      (VNODEOPFUNC)vboxSfDwnVnDefaultError }, - not needed
     807    { &vnop_rmdir_desc,       (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     808    { &vnop_searchfs_desc,    (VNODEOPFUNC)err_searchfs },
     809    //{ &vnop_select_desc,      (VNODEOPFUNC)vboxSfDwnVnDefaultError }, - not needed
     810    { &vnop_setattr_desc,     (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     811    { &vnop_setxattr_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     812    //{ &vnop_strategy_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError }, - not needed
     813    { &vnop_symlink_desc,     (VNODEOPFUNC)vboxSfDwnVnDefaultError },
     814    /* { &vnop_truncate_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError }, undefined in ML */
     815    //{ &vnop_whiteout_desc,    (VNODEOPFUNC)vboxSfDwnVnDefaultError }, - not needed/supported
     816    { &vnop_write_desc,       (VNODEOPFUNC)vboxSfDwnVnDefaultError },
    743817    { NULL,                   (VNODEOPFUNC)NULL              },
    744818#undef VNODEOPFUNC
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette