VirtualBox

Changeset 77303 in vbox


Ignore:
Timestamp:
Feb 13, 2019 2:49:11 PM (6 years ago)
Author:
vboxsync
Message:

linux/vboxsf: Cleaned out the VBOXSF_USE_DEPRECATED_VBGL_INTERFACE #ifdefs. bugref:9172

Location:
trunk/src/VBox/Additions/linux/sharedfolders
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/linux/sharedfolders/Makefile.module

    r77057 r77303  
    6565 MOD_DEFS += -DRT_ARCH_X86
    6666endif
    67 ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    68  MOD_DEFS += -DVBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    69 endif
    7067
    7168ifeq ($(KERN_VERSION), 24)

  • trunk/src/VBox/Additions/linux/sharedfolders/dirops.c

    r77054 r77303  
    3232#include <iprt/err.h>
    3333
    34 /** Reads or re-reads a directory.
     34
     35/**
     36 * Reads or re-reads a directory.
    3537 *
    3638 * @note As suggested a couple of other places, we should probably stop
    … …  
    4244    int rc;
    4345    int err;
    44 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    45     SHFLCREATEPARMS CreateParms;
    46     SHFLCREATEPARMS *pCreateParms = &CreateParms;
    47 #else
    4846    union SfDirOpenCloseReq
    4947    {
    … …  
    5250    } *pReq;
    5351    SHFLCREATEPARMS *pCreateParms;
    54 #endif
    55 
    56 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
     52
    5753    pReq = (union SfDirOpenCloseReq *)VbglR0PhysHeapAlloc(RT_UOFFSETOF(VBOXSFCREATEREQ, StrPath.String)
    5854                                                          + sf_i->path->u16Size);
    … …  
    6662            return -ENOMEM;
    6763    }
    68 #endif
    6964
    7065    RT_ZERO(*pCreateParms);
    … …  
    7570                              | SHFL_CF_ACCESS_READ;
    7671
    77 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    78     LogFunc(("calling VbglR0SfCreate, folder %s, flags %#x [caller: %s]\n",
    79              sf_i->path->String.utf8, pCreateParms->CreateFlags, pszCaller));
    80     rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, pCreateParms);
    81 #else
    8272    LogFunc(("calling VbglR0SfHostReqCreate on folder %s, flags %#x [caller: %s]\n",
    8373             sf_i->path->String.utf8, pCreateParms->CreateFlags, pszCaller));
    8474    rc = VbglR0SfHostReqCreate(sf_g->map.root, &pReq->Create);
    85 #endif
    8675    if (RT_SUCCESS(rc)) {
    8776            if (pCreateParms->Result == SHFL_FILE_EXISTS) {
    … …  
    10089                    err = -ENOENT;
    10190
    102 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    103             rc = VbglR0SfClose(&client_handle, &sf_g->map, pCreateParms->Handle);
    104             if (RT_FAILURE(rc))
    105                     LogFunc(("VbglR0SfClose(%s) after err=%d failed rc=%Rrc caller=%s\n",
    106                              sf_i->path->String.utf8, err, rc, pszCaller));
    107 #else
    10891            AssertCompile(RTASSERT_OFFSET_OF(VBOXSFCREATEREQ, CreateParms.Handle) > sizeof(VBOXSFCLOSEREQ)); /* no aliasing issues */
    10992            if (pCreateParms->Handle != SHFL_HANDLE_NIL)
    … …  
    11497                                 sf_i->path->String.utf8, err, rc, pszCaller));
    11598            }
    116 #endif
    11799    } else
    118100            err = -EPERM;
    119101
    120 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    121102    VbglR0PhysHeapFree(pReq);
    122 #endif
    123 
    124103    return err;
    125104}
    … …  
    579558        struct sf_glob_info *sf_g = GET_GLOB_INFO(parent->i_sb);
    580559        SHFLSTRING *path;
    581 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    582         SHFLCREATEPARMS CreateParms;
    583         SHFLCREATEPARMS *pCreateParms = &CreateParms;
    584 #else
    585560        union CreateAuxReq
    586561        {
    … …  
    589564        } *pReq;
    590565        SHFLCREATEPARMS *pCreateParms;
    591 #endif
    592566
    593567        TRACE();
    … …  
    599573                goto fail0;
    600574
    601 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    602575        /** @todo combine with sf_path_from_dentry? */
    603576        pReq = (union CreateAuxReq *)VbglR0PhysHeapAlloc(RT_UOFFSETOF(VBOXSFCREATEREQ, StrPath.String) + path->u16Size);
    … …  
    609582                goto fail1;
    610583        }
    611 #endif
    612584
    613585        RT_ZERO(*pCreateParms);
    … …  
    621593        pCreateParms->Info.Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
    622594
    623 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    624         LogFunc(("calling VbglR0SfCreate, folder %s, flags %#x\n", path->String.utf8, pCreateParms->CreateFlags));
    625         rc = VbglR0SfCreate(&client_handle, &sf_g->map, path, pCreateParms);
    626 #else
    627595        LogFunc(("calling VbglR0SfHostReqCreate, folder %s, flags %#x\n", path->String.ach, pCreateParms->CreateFlags));
    628596        rc = VbglR0SfHostReqCreate(sf_g->map.root, &pReq->Create);
    629 #endif
    630597        if (RT_FAILURE(rc)) {
    631598                if (rc == VERR_WRITE_PROTECT) {
    … …  
    660627         */
    661628        if (fDirectory) {
    662 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    663                 rc = VbglR0SfClose(&client_handle, &sf_g->map, pCreateParms->Handle);
    664                 if (RT_FAILURE(rc))
    665                         LogFunc(("(%d): VbglR0SfClose failed rc=%Rrc\n",
    666                                  fDirectory, rc));
    667 #else
    668629                AssertCompile(RTASSERT_OFFSET_OF(VBOXSFCREATEREQ, CreateParms.Handle) > sizeof(VBOXSFCLOSEREQ)); /* no aliasing issues */
    669630                rc = VbglR0SfHostReqClose(sf_g->map.root, &pReq->Close, pCreateParms->Handle);
    670631                if (RT_FAILURE(rc))
    671632                        LogFunc(("(%d): VbglR0SfHostReqClose failed rc=%Rrc\n", fDirectory, rc));
    672 #endif
    673633        }
    674634
    675635        sf_i->force_restat = 1;
    676 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    677636        VbglR0PhysHeapFree(pReq);
    678 #endif
    679637        return 0;
    680638
    681639 fail3:
    682 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    683         rc = VbglR0SfClose(&client_handle, &sf_g->map, pCreateParms->Handle);
    684         if (RT_FAILURE(rc))
    685                 LogFunc(("(%d): VbglR0SfClose failed rc=%Rrc\n", fDirectory,
    686                          rc));
    687 #else
    688640        rc = VbglR0SfHostReqClose(sf_g->map.root, &pReq->Close, pCreateParms->Handle);
    689641        if (RT_FAILURE(rc))
    690642                LogFunc(("(%d): VbglR0SfHostReqCloseSimple failed rc=%Rrc\n", fDirectory, rc));
    691 #endif
    692643 fail2:
    693 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    694644        VbglR0PhysHeapFree(pReq);
    695 #endif
    696645 fail1:
    697646        kfree(path);
    … …  
    766715        err = sf_path_from_dentry(__func__, sf_g, sf_i, dentry, &path);
    767716        if (!err) {
    768 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    769717                VBOXSFREMOVEREQ *pReq = (VBOXSFREMOVEREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF(VBOXSFREMOVEREQ, StrPath.String)
    770718                                                                               + path->u16Size);
    771719                if (pReq) {
    772720                        memcpy(&pReq->StrPath, path, SHFLSTRING_HEADER_SIZE + path->u16Size);
    773 #endif
    774721                        uint32_t fFlags = fDirectory ? SHFL_REMOVE_DIR : SHFL_REMOVE_FILE;
    775722                        if (dentry->d_inode && ((dentry->d_inode->i_mode & S_IFLNK) == S_IFLNK))
    776723                                fFlags |= SHFL_REMOVE_SYMLINK;
    777724
    778 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    779                         rc = VbglR0SfRemove(&client_handle, &sf_g->map, path, fFlags);
    780 #else
    781725                        rc = VbglR0SfHostReqRemove(sf_g->map.root, pReq, fFlags);
    782 #endif
    783726                        if (RT_SUCCESS(rc)) {
    784727                                /* directory access/change time changed */
    … …  
    793736                                err = -RTErrConvertToErrno(rc);
    794737                        }
    795 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    796738                        VbglR0PhysHeapFree(pReq);
    797739                } else
    798740                        err = -ENOMEM;
    799 #endif
    800741                kfree(path);
    801742        }
    … …  
    881822                        LogFunc(("failed to create new path\n"));
    882823                else {
    883 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    884                         int fDir =
    885                             ((old_dentry->d_inode->i_mode & S_IFDIR) != 0);
    886                         rc = VbglR0SfRename(&client_handle, &sf_g->map,
    887                                             old_path, new_path,
    888                                             fDir ? 0 : SHFL_RENAME_FILE |
    889                                             SHFL_RENAME_REPLACE_IF_EXISTS);
    890 #else
    891824                        VBOXSFRENAMEWITHSRCBUFREQ *pReq;
    892825                        pReq = (VBOXSFRENAMEWITHSRCBUFREQ *)VbglR0PhysHeapAlloc(RT_UOFFSETOF(VBOXSFRENAMEWITHSRCBUFREQ,
    … …  
    902835                        } else
    903836                                rc = VERR_NO_MEMORY;
    904 #endif
    905837                        if (RT_SUCCESS(rc)) {
    906838                                kfree(old_path);

  • trunk/src/VBox/Additions/linux/sharedfolders/regops.c

    r77141 r77303  
    3535#include "vfsmod.h"
    3636
    37 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    38 
    39 static void *alloc_bounce_buffer(size_t * tmp_sizep, PRTCCPHYS physp, size_t
    40                                  xfer_size, const char *caller)
    41 {
    42         size_t tmp_size;
    43         void *tmp;
    44 
    45         /* try for big first. */
    46         tmp_size = RT_ALIGN_Z(xfer_size, PAGE_SIZE);
    47         if (tmp_size > 16U * _1K)
    48                 tmp_size = 16U * _1K;
    49         tmp = kmalloc(tmp_size, GFP_KERNEL);
    50         if (!tmp) {
    51                 /* fall back on a page sized buffer. */
    52                 tmp = kmalloc(PAGE_SIZE, GFP_KERNEL);
    53                 if (!tmp) {
    54                         LogRel(("%s: could not allocate bounce buffer for xfer_size=%zu %s\n", caller, xfer_size));
    55                         return NULL;
    56                 }
    57                 tmp_size = PAGE_SIZE;
    58         }
    59 
    60         *tmp_sizep = tmp_size;
    61         *physp = virt_to_phys(tmp);
    62         return tmp;
    63 }
    64 
    65 static void free_bounce_buffer(void *tmp)
    66 {
    67         kfree(tmp);
    68 }
    69 
    70 #else  /* !VBOXSF_USE_DEPRECATED_VBGL_INTERFACE */
    71 # if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
     37#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
    7238
    7339/*
    7440 * inode compatibility glue.
    7541 */
    76 # include <iprt/asm.h>
     42#include <iprt/asm.h>
    7743
    7844DECLINLINE(loff_t) i_size_read(struct inode *inode)
    … …  
    8854}
    8955
    90 # endif /* < 2.6.0 */
    91 #endif /* !VBOXSF_USE_DEPRECATED_VBGL_INTERFACE */
     56#endif /* < 2.6.0 */
    9257
    9358/* fops */
    … …  
    201166        size_t nsent = 0;
    202167
     168/** @todo rig up a FsPerf test for this code  */
    203169        TRACE();
    204170        if (!S_ISREG(inode->i_mode)) {
    … …  
    329295
    330296
    331 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    332297/**
    333298 * Fallback case of sf_reg_read() that locks the user buffers and let the host
    … …  
    437402        return cbRet;
    438403}
    439 #endif /* VBOXSF_USE_DEPRECATED_VBGL_INTERFACE */
    440404
    441405
    … …  
    452416                           loff_t *off)
    453417{
    454 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    455         int err;
    456         void *tmp;
    457         RTCCPHYS tmp_phys;
    458         size_t tmp_size;
    459         size_t left = size;
    460         ssize_t total_bytes_read = 0;
    461         loff_t pos = *off;
    462 #endif
    463418        struct inode *inode = GET_F_DENTRY(file)->d_inode;
    464419        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
    … …  
    476431                return 0;
    477432
    478 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    479         tmp = alloc_bounce_buffer(&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
    480         if (!tmp)
    481                 return -ENOMEM;
    482 
    483         while (left) {
    484                 uint32_t to_read, nread;
    485 
    486                 to_read = tmp_size;
    487                 if (to_read > left)
    488                         to_read = (uint32_t) left;
    489 
    490                 nread = to_read;
    491 
    492                 err = sf_reg_read_aux(__func__, sf_g, sf_r, tmp, &nread, pos);
    493                 if (err)
    494                         goto fail;
    495 
    496                 if (copy_to_user(buf, tmp, nread)) {
    497                         err = -EFAULT;
    498                         goto fail;
    499                 }
    500 
    501                 pos += nread;
    502                 left -= nread;
    503                 buf += nread;
    504                 total_bytes_read += nread;
    505                 if (nread != to_read)
    506                         break;
    507         }
    508 
    509         *off += total_bytes_read;
    510         free_bounce_buffer(tmp);
    511         return total_bytes_read;
    512 
    513  fail:
    514         free_bounce_buffer(tmp);
    515         return err;
    516 
    517 #else  /* !VBOXSF_USE_DEPRECATED_VBGL_INTERFACE */
    518433        /*
    519434         * For small requests, try use an embedded buffer provided we get a heap block
    … …  
    574489
    575490        return sf_reg_read_fallback(file, buf, size, off, sf_g, sf_r);
    576 #endif /* !VBOXSF_USE_DEPRECATED_VBGL_INTERFACE */
    577 }
    578 
    579 
    580 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
     491}
     492
     493
    581494/**
    582495 * Fallback case of sf_reg_write() that locks the user buffers and let the host
    … …  
    689602        return cbRet;
    690603}
    691 #endif /* VBOXSF_USE_DEPRECATED_VBGL_INTERFACE */
     604
    692605
    693606/**
    … …  
    703616                            loff_t * off)
    704617{
    705 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    706         int err;
    707         void *tmp;
    708         RTCCPHYS tmp_phys;
    709         size_t tmp_size;
    710         size_t left = size;
    711         ssize_t total_bytes_written = 0;
    712 #endif
    713618        loff_t pos;
    714619        struct inode *inode = GET_F_DENTRY(file)->d_inode;
    … …  
    730635        /** @todo This should be handled by the host, it returning the new file
    731636         *        offset when appending.  We may have an outdated i_size value here! */
    732         if (file->f_flags & O_APPEND) {
    733 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    734                 pos = inode->i_size;
    735                 *off = pos;
    736 #else
     637        if (file->f_flags & O_APPEND)
    737638                pos = i_size_read(inode);
    738 #endif
    739         }
    740639
    741640        /** @todo XXX Check write permission according to inode->i_mode! */
    742641
    743642        if (!size) {
    744 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    745643                if (file->f_flags & O_APPEND)  /** @todo check if this is the consensus behavior... */
    746644                        *off = pos;
    747 #endif
    748645                return 0;
    749646        }
    750 
    751 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    752         tmp = alloc_bounce_buffer(&tmp_size, &tmp_phys, size,
    753                                   __PRETTY_FUNCTION__);
    754         if (!tmp)
    755                 return -ENOMEM;
    756 
    757         while (left) {
    758                 uint32_t to_write, nwritten;
    759 
    760                 to_write = tmp_size;
    761                 if (to_write > left)
    762                         to_write = (uint32_t) left;
    763 
    764                 nwritten = to_write;
    765 
    766                 if (copy_from_user(tmp, buf, to_write)) {
    767                         err = -EFAULT;
    768                         goto fail;
    769                 }
    770 
    771                 err =
    772                     VbglR0SfWritePhysCont(&client_handle, &sf_g->map,
    773                                           sf_r->handle, pos, &nwritten,
    774                                           tmp_phys);
    775                 err = RT_FAILURE(err) ? -EPROTO : 0;
    776                 if (err)
    777                         goto fail;
    778 
    779                 pos += nwritten;
    780                 left -= nwritten;
    781                 buf += nwritten;
    782                 total_bytes_written += nwritten;
    783                 if (nwritten != to_write)
    784                         break;
    785         }
    786 
    787         *off += total_bytes_written;
    788         if (*off > inode->i_size)
    789                 inode->i_size = *off;
    790 
    791         sf_i->force_restat = 1;
    792         free_bounce_buffer(tmp);
    793         return total_bytes_written;
    794 
    795  fail:
    796         free_bounce_buffer(tmp);
    797         return err;
    798 #else  /* !VBOXSF_USE_DEPRECATED_VBGL_INTERFACE */
    799647
    800648        /*
    … …  
    867715
    868716        return sf_reg_write_fallback(file, buf, size, off, pos, inode, sf_i, sf_g, sf_r);
    869 #endif /* !VBOXSF_USE_DEPRECATED_VBGL_INTERFACE */
    870 }
     717}
     718
    871719
    872720/**
    … …  
    883731        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
    884732        struct sf_reg_info *sf_r;
    885 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    886         SHFLCREATEPARMS params;
    887 #else
    888733        VBOXSFCREATEREQ *pReq;
    889 #endif
    890734        SHFLCREATEPARMS *pCreateParms;  /* temp glue */
    891735
    … …  
    917761        }
    918762
    919 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    920         RT_ZERO(params);
    921         pCreateParms = &params;
    922 #else
    923763        pReq = (VBOXSFCREATEREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq) + sf_i->path->u16Size);
    924764        if (!pReq) {
    … …  
    930770        RT_ZERO(pReq->CreateParms);
    931771        pCreateParms = &pReq->CreateParms;
    932 #endif
    933772        pCreateParms->Handle = SHFL_HANDLE_NIL;
    934773
    … …  
    981820
    982821        pCreateParms->Info.Attr.fMode = inode->i_mode;
    983 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    984         LogFunc(("sf_reg_open: calling VbglR0SfCreate, file %s, flags=%#x, %#x\n", sf_i->path->String.utf8, file->f_flags, pCreateParms->CreateFlags));
    985         rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, pCreateParms);
    986 #else
    987822        LogFunc(("sf_reg_open: calling VbglR0SfHostReqCreate, file %s, flags=%#x, %#x\n", sf_i->path->String.utf8, file->f_flags, pCreateParms->CreateFlags));
    988823        rc = VbglR0SfHostReqCreate(sf_g->map.root, pReq);
    989 #endif
    990824        if (RT_FAILURE(rc)) {
    991 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    992                 LogFunc(("VbglR0SfCreate failed flags=%d,%#x rc=%Rrc\n", file->f_flags, pCreateParms->CreateFlags, rc));
    993 #else
    994825                LogFunc(("VbglR0SfHostReqCreate failed flags=%d,%#x rc=%Rrc\n", file->f_flags, pCreateParms->CreateFlags, rc));
    995 #endif
    996826                kfree(sf_r);
    997 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    998827                VbglR0PhysHeapFree(pReq);
    999 #endif
    1000828                return -RTErrConvertToErrno(rc);
    1001829        }
    … …  
    1019847        sf_i->file = file;
    1020848        file->private_data = sf_r;
    1021 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    1022849        VbglR0PhysHeapFree(pReq);
    1023 #endif
    1024850        return rc_linux;
    1025851}
    … …  
    1056882                filemap_fdatawait(inode->i_mapping);
    1057883#endif
    1058 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    1059         rc = VbglR0SfClose(&client_handle, &sf_g->map, sf_r->handle);
    1060         if (RT_FAILURE(rc))
    1061                 LogFunc(("VbglR0SfClose failed rc=%Rrc\n", rc));
    1062 #else
    1063884        rc = VbglR0SfHostReqCloseSimple(sf_g->map.root, sf_r->handle);
    1064885        if (RT_FAILURE(rc))
    1065886                LogFunc(("VbglR0SfHostReqCloseSimple failed rc=%Rrc\n", rc));
    1066887        sf_r->handle = SHFL_HANDLE_NIL;
    1067 #endif
    1068888
    1069889        kfree(sf_r);
    … …  
    12701090        TRACE();
    12711091
     1092/** @todo rig up a FsPerf testcase for this code! */
     1093
    12721094        if (page->index >= end_index)
    12731095                nwritten = inode->i_size & (PAGE_SIZE - 1);
    … …  
    13191141
    13201142        TRACE();
     1143
     1144/** @todo rig up a FsPerf testcase for this code! */
    13211145
    13221146        buf = kmap(page);

  • trunk/src/VBox/Additions/linux/sharedfolders/utils.c

    r77250 r77303  
    189189{
    190190        int rc;
    191 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    192         SHFLCREATEPARMS params;
    193 #else
    194191        VBOXSFCREATEREQ *pReq;
    195 #endif
    196192        NOREF(caller);
    197193
    198194        TRACE();
    199195
    200 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    201         RT_ZERO(params);
    202         params.Handle = SHFL_HANDLE_NIL;
    203         params.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
    204         LogFunc(("sf_stat: calling VbglR0SfCreate, file %s, flags %#x\n",
    205                  path->String.utf8, params.CreateFlags));
    206         rc = VbglR0SfCreate(&client_handle, &sf_g->map, path, &params);
    207         if (rc == VERR_INVALID_NAME) {
    208                 /* this can happen for names like 'foo*' on a Windows host */
    209                 return -ENOENT;
    210         }
    211         if (RT_FAILURE(rc)) {
    212                 LogFunc(("VbglR0SfCreate(%s) failed.  caller=%s, rc=%Rrc\n",
    213                          path->String.utf8, rc, caller));
    214                 return -EPROTO;
    215         }
    216         if (params.Result != SHFL_FILE_EXISTS) {
    217                 if (!ok_to_fail)
    218                         LogFunc(("VbglR0SfCreate(%s) file does not exist.  caller=%s, result=%d\n", path->String.utf8, params.Result, caller));
    219                 return -ENOENT;
    220         }
    221 
    222         *result = params.Info;
    223         return 0;
    224 #else
    225196        pReq = (VBOXSFCREATEREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq) + path->u16Size);
    226197        if (pReq) {
    … …  
    253224                rc = -ENOMEM;
    254225        return rc;
    255 #endif
    256226}
    257227
    … …  
    387357        struct sf_glob_info *sf_g;
    388358        struct sf_inode_info *sf_i;
    389 # ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    390         SHFLCREATEPARMS CreateParms;
    391         SHFLCREATEPARMS *pCreateParms = &CreateParms;
    392         SHFLFSOBJINFO InfoBuf;
    393         SHFLFSOBJINFO *pInfo = &InfoBuf;
    394         uint32_t cbBuffer;
    395         int rc, err;
    396 # else
    397359        union SetAttrReqs
    398360        {
    … …  
    408370        int vrc;
    409371        int err = 0;
    410 # endif
    411372
    412373        TRACE();
    … …  
    414375        sf_g = GET_GLOB_INFO(dentry->d_inode->i_sb);
    415376        sf_i = GET_INODE_INFO(dentry->d_inode);
    416 # ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    417         err = 0;
    418 # else
    419377        cbReq = RT_MAX(sizeof(pReq->Info), sizeof(pReq->Create) + SHFLSTRING_HEADER_SIZE + sf_i->path->u16Size);
    420378        pReq = (union SetAttrReqs *)VbglR0PhysHeapAlloc(cbReq);
    … …  
    425383        pCreateParms = &pReq->Create.CreateParms;
    426384        pInfo = &pReq->Info.ObjInfo;
    427 # endif
    428385
    429386        RT_ZERO(*pCreateParms);
    … …  
    437394                pCreateParms->CreateFlags |= SHFL_CF_ACCESS_WRITE;
    438395
    439 # ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    440         rc = VbglR0SfCreate(&client_handle, &sf_g->map, sf_i->path, pCreateParms);
    441         if (RT_FAILURE(rc)) {
    442                 LogFunc(("VbglR0SfCreate(%s) failed rc=%Rrc\n",
    443                          sf_i->path->String.utf8, rc));
    444                 err = -RTErrConvertToErrno(rc);
    445                 goto fail2;
    446         }
    447 # else
    448396        memcpy(&pReq->Create.StrPath, sf_i->path, SHFLSTRING_HEADER_SIZE + sf_i->path->u16Size);
    449397        vrc = VbglR0SfHostReqCreate(sf_g->map.root, &pReq->Create);
    … …  
    455403                goto fail2;
    456404        }
    457 # endif
    458405        if (pCreateParms->Result != SHFL_FILE_EXISTS) {
    459406                LogFunc(("file %s does not exist\n", sf_i->path->String.utf8));
    … …  
    494441                /* ignore ctime (inode change time) as it can't be set from userland anyway */
    495442
    496 # ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    497                 cbBuffer = sizeof(*pInfo);
    498                 rc = VbglR0SfFsInfo(&client_handle, &sf_g->map, pCreateParms->Handle,
    499                                     SHFL_INFO_SET | SHFL_INFO_FILE, &cbBuffer,
    500                                     (PSHFLDIRINFO)pInfo);
    501                 if (RT_FAILURE(rc)) {
    502                         LogFunc(("VbglR0SfFsInfo(%s, FILE) failed rc=%Rrc\n",
    503                                  sf_i->path->String.utf8, rc));
    504                         err = -RTErrConvertToErrno(rc);
    505                         goto fail1;
    506                 }
    507 # else
    508443                vrc = VbglR0SfHostReqSetObjInfo(sf_g->map.root, &pReq->Info, hHostFile);
    509444                if (RT_FAILURE(vrc)) {
    … …  
    512447                        goto fail1;
    513448                }
    514 # endif
    515449        }
    516450
    517451        if (iattr->ia_valid & ATTR_SIZE) {
    518 # ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    519                 RT_ZERO(*pInfo);
    520                 pInfo->cbObject = iattr->ia_size;
    521                 cbBuffer = sizeof(*pInfo);
    522                 rc = VbglR0SfFsInfo(&client_handle, &sf_g->map, pCreateParms->Handle,
    523                                     SHFL_INFO_SET | SHFL_INFO_SIZE, &cbBuffer,
    524                                     (PSHFLDIRINFO)pInfo);
    525                 if (RT_FAILURE(rc)) {
    526                         LogFunc(("VbglR0SfFsInfo(%s, SIZE) failed rc=%Rrc\n",
    527                                  sf_i->path->String.utf8, rc));
    528                         err = -RTErrConvertToErrno(rc);
    529                         goto fail1;
    530                 }
    531 # else
    532452                vrc = VbglR0SfHostReqSetFileSize(sf_g->map.root, &pReq->SetSize, hHostFile, iattr->ia_size);
    533453                /** @todo Implement fallback if host is < 6.0? */
    … …  
    538458                        goto fail1;
    539459                }
    540 # endif
    541         }
    542 
    543 # ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    544         rc = VbglR0SfClose(&client_handle, &sf_g->map, pCreateParms->Handle);
    545         if (RT_FAILURE(rc))
    546                 LogFunc(("VbglR0SfClose(%s) failed rc=%Rrc\n",
    547                          sf_i->path->String.utf8, rc));
    548 # else
     460        }
     461
    549462        vrc = VbglR0SfHostReqClose(sf_g->map.root, &pReq->Close, hHostFile);
    550463        if (RT_FAILURE(vrc))
    551464                LogFunc(("VbglR0SfHostReqClose(%s [%#llx]) failed vrc=%Rrc\n", sf_i->path->String.utf8, hHostFile, vrc));
    552465        VbglR0PhysHeapFree(pReq);
    553 # endif
    554466
    555467        /** @todo r=bird: I guess we're calling revalidate here to update the inode
    … …  
    566478
    567479 fail1:
    568 # ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    569         rc = VbglR0SfClose(&client_handle, &sf_g->map, pCreateParms->Handle);
    570         if (RT_FAILURE(rc))
    571                 LogFunc(("VbglR0SfClose(%s) failed rc=%Rrc\n",
    572                          sf_i->path->String.utf8, rc));
    573 # else
    574480        vrc = VbglR0SfHostReqClose(sf_g->map.root, &pReq->Close, hHostFile);
    575481        if (RT_FAILURE(vrc))
    576482                LogFunc(("VbglR0SfHostReqClose(%s [%#llx]) failed vrc=%Rrc; err=%d\n", sf_i->path->String.utf8, hHostFile, vrc, err));
    577 # endif
    578483
    579484 fail2:
    580 # ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    581485        VbglR0PhysHeapFree(pReq);
    582 # endif
    583486        return err;
    584487}
    … …  
    895798        int err;
    896799        SHFLSTRING *mask;
    897 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    898800        VBOXSFLISTDIRREQ *pReq = NULL;
    899 #endif
    900801
    901802        TRACE();
    … …  
    903804        if (err)
    904805                goto fail0;
    905 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    906806        pReq = (VBOXSFLISTDIRREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
    907807        if (!pReq)
    908808                goto fail1;
    909 #endif
    910809
    911810        for (;;) {
    912811                int rc;
    913812                struct sf_dir_buf *b;
    914 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    915                 void *buf;
    916                 uint32_t cbSize;
    917                 uint32_t cEntries;
    918 #endif
    919813
    920814                b = sf_get_empty_dir_buf(sf_d);
    … …  
    929823                }
    930824
    931 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    932                 buf = b->buf;
    933                 cbSize = b->cbFree;
    934 
    935                 rc = VbglR0SfDirInfo(&client_handle, &sf_g->map, handle, mask,
    936                                      0, 0, &cbSize, buf, &cEntries);
    937                 switch (rc) {
    938                 case VINF_SUCCESS:
    939                         RT_FALL_THRU();
    940                 case VERR_NO_MORE_FILES:
    941                         break;
    942                 case VERR_NO_TRANSLATION:
    943                         LogFunc(("host could not translate entry\n"));
    944                         /* XXX */
    945                         break;
    946                 default:
    947                         err = -RTErrConvertToErrno(rc);
    948                         LogFunc(("VbglR0SfDirInfo failed rc=%Rrc\n", rc));
    949                         goto fail2;
    950                 }
    951 
    952                 b->cEntries += cEntries;
    953                 b->cbFree -= cbSize;
    954                 b->cbUsed += cbSize;
    955 
    956                 if (RT_FAILURE(rc))
    957                         break;
    958 #else
    959825                rc = VbglR0SfHostReqListDirContig2x(sf_g->map.root, pReq, handle, mask, virt_to_phys(mask),
    960826                                                    0 /*fFlags*/, b->buf, virt_to_phys(b->buf), b->cbFree);
    … …  
    970836                        goto fail2;
    971837                }
    972 #endif
    973838        }
    974839        err = 0;
    975840
    976841 fail2:
    977 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    978842        VbglR0PhysHeapFree(pReq);
    979 #endif
    980843 fail1:
    981844        kfree(mask);
    … …  
    988851{
    989852        struct sf_glob_info *sf_g;
    990 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    991         SHFLVOLINFO SHFLVolumeInfo;
    992         SHFLVOLINFO *pVolInfo = &SHFLVolumeInfo;
    993         uint32_t cbBuffer;
    994 #else
    995853        VBOXSFVOLINFOREQ *pReq;
    996854        SHFLVOLINFO *pVolInfo;
    997 #endif
    998855        int rc;
    999856
    1000857        sf_g = GET_GLOB_INFO(sb);
    1001 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    1002         cbBuffer = sizeof(SHFLVolumeInfo);
    1003         rc = VbglR0SfFsInfo(&client_handle, &sf_g->map, 0,
    1004                             SHFL_INFO_GET | SHFL_INFO_VOLUME, &cbBuffer,
    1005                             (PSHFLDIRINFO) & SHFLVolumeInfo);
    1006 #else
    1007858        pReq = VbglR0PhysHeapAlloc(sizeof(*pReq));
    1008859        if (pReq) {
    1009860                pVolInfo = &pReq->VolInfo;
    1010861                rc = VbglR0SfHostReqQueryVolInfo(sf_g->map.root, pReq, SHFL_HANDLE_ROOT);
    1011 #endif
    1012862                if (RT_SUCCESS(rc)) {
    1013863                        stat->f_type   = NFS_SUPER_MAGIC;       /* XXX vboxsf type? */
    … …  
    1035885                } else
    1036886                        rc = -RTErrConvertToErrno(rc);
    1037 #ifndef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    1038887                VbglR0PhysHeapFree(pReq);
    1039888        } else
    1040889                rc = -ENOMEM;
    1041 #endif
    1042890        return rc;
    1043891}

  • trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.c

    r77138 r77303  
    190190#undef _IS_EMPTY
    191191
    192 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    193         rc = VbglR0SfMapFolder(&client_handle, str_name, &sf_g->map);
    194 #else
    195192        rc = VbglR0SfHostReqMapFolderWithContigSimple(str_name, virt_to_phys(str_name), RTPATH_DELIMITER,
    196193                                                      true /*fCaseSensitive*/, &sf_g->map.root);
    197 #endif
    198194        kfree(str_name);
    199195
    … …  
    227223
    228224        TRACE();
    229 #ifdef VBOXSF_USE_DEPRECATED_VBGL_INTERFACE
    230         rc = VbglR0SfUnmapFolder(&client_handle, &sf_g->map);
    231         if (RT_FAILURE(rc))
    232                 LogFunc(("VbglR0SfUnmapFolder failed rc=%d\n", rc));
    233 #else
    234225        rc = VbglR0SfHostReqUnmapFolderSimple(sf_g->map.root);
    235226        if (RT_FAILURE(rc))
    236227                LogFunc(("VbglR0SfHostReqUnmapFolderSimple failed rc=%Rrc\n", rc));
    237 #endif
    238228
    239229        if (sf_g->nls)

  • trunk/src/VBox/Additions/linux/sharedfolders/vfsmod.h

    r77138 r77303  
    3434# pragma once
    3535#endif
    36 
    37 /* VBOXSF_USE_DEPRECATED_VBGL_INTERFACE is also settable in make env. */
    38 /*#define VBOXSF_USE_DEPRECATED_VBGL_INTERFACE*/
    3936
    4037#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
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