VirtualBox

Changeset 58195 in vbox for trunk/src/VBox/Additions/haiku


Ignore:
Timestamp:
Oct 12, 2015 3:13:47 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
103309
Message:

VBoxGuestR0LibSharedFolders: Prefixed functions ('vbox' wasn't a very good one). Hope I found all places these functions are called...

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/haiku/SharedFolders/vboxsf.c

    r43415 r58195  
    6161    if (RT_LIKELY(rc == B_OK)
    6262    {
    63         rc = vboxInit();
     63        rc = VbglR0SfInit();
    6464        if (RT_SUCCESS(rc))
    6565        {
    66             rc = vboxConnect(&g_clientHandle);
     66            rc = VbglR0SfConnect(&g_clientHandle);
    6767            if (RT_SUCCESS(rc))
    6868            {
    69                 rc = vboxCallSetUtf8(&g_clientHandle);
     69                rc = VbglR0SfSetUtf8(&g_clientHandle);
    7070                if (RT_SUCCESS(rc))
    7171                {
    72                     rc = vboxCallSetSymlinks(&g_clientHandle);
     72                    rc = VbglR0SfSetSymlinks(&g_clientHandle);
    7373                    if (RT_FAILURE(rc))
    74                         LogRel((FS_NAME ":Warning! vboxCallSetSymlinks failed (rc=%d) - symlink will appear as copies.\n", rc));
     74                        LogRel((FS_NAME ": Warning! VbglR0SfSetSymlinks failed (rc=%d) - symlink will appear as copies.\n", rc));
    7575
    7676                    mutex_init(&g_vnodeCacheLock, "vboxsf vnode cache lock");
    77                     Log((FS_NAME ":init_module succeeded.\n");
     77                    Log((FS_NAME ": init_module succeeded.\n");
    7878                    return B_OK;
    7979                }
    8080                else
    81                     LogRel((FS_NAME ":vboxCallSetUtf8 failed. rc=%d\n", rc));
     81                    LogRel((FS_NAME ": VbglR0SfSetUtf8 failed. rc=%d\n", rc));
    8282            }
    8383            else
    84                 LogRel((FS_NAME ":vboxConnect failed. rc=%d\n", rc));
     84                LogRel((FS_NAME ": VbglR0SfConnect failed. rc=%d\n", rc));
    8585        }
    8686        else
    87             LogRel((FS_NAME ":vboxInit failed. rc=%d\n", rc));
     87            LogRel((FS_NAME ": VbglR0SfInit failed. rc=%d\n", rc));
    8888    }
    8989    else
    90         LogRel((FS_NAME ":get_module failed for '%s'. rc=%d\n", VBOXGUEST_MODULE_NAME, rc));
     90        LogRel((FS_NAME ": get_module failed for '%s'. rc=%d\n", VBOXGUEST_MODULE_NAME, rc));
    9191
    9292    return B_ERROR;
    … …  
    9999    }
    100100
    101     if (RT_FAILURE(vboxInit()))
    102     {
    103         dprintf("vboxInit failed\n");
     101    if (RT_FAILURE(VbglR0SfInit()))
     102    {
     103        dprintf("VbglR0SfInit failed\n");
    104104        return B_ERROR;
    105105    }
    106106
    107     if (RT_FAILURE(vboxConnect(&g_clientHandle)))
    108     {
    109         dprintf("vboxConnect failed\n");
     107    if (RT_FAILURE(VbglR0SfConnect(&g_clientHandle)))
     108    {
     109        dprintf("VbglR0SfConnect failed\n");
    110110        return B_ERROR;
    111111    }
    112112
    113     if (RT_FAILURE(vboxCallSetUtf8(&g_clientHandle)))
    114     {
    115         dprintf("vboxCallSetUtf8 failed\n");
     113    if (RT_FAILURE(VbglR0SfSetUtf8(&g_clientHandle)))
     114    {
     115        dprintf("VbglR0SfSetUtf8 failed\n");
    116116        return B_ERROR;
    117117    }
    118118
    119     if (RT_FAILURE(vboxCallSetSymlinks(&g_clientHandle)))
    120     {
    121         dprintf("warning: vboxCallSetSymlinks failed (old vbox?) - symlinks will appear as copies\n");
     119    if (RT_FAILURE(VbglR0SfSetSymlinks(&g_clientHandle)))
     120    {
     121        dprintf("warning: VbglR0SfSetSymlinks failed (old vbox?) - symlinks will appear as copies\n");
    122122    }
    123123
    … …  
    227227    vboxsf_volume* vbsfvolume = malloc(sizeof(vboxsf_volume));
    228228    volume->private_volume = vbsfvolume;
    229     int rv = vboxCallMapFolder(&g_clientHandle, sharename, &(vbsfvolume->map));
     229    int rv = VbglR0SfMapFolder(&g_clientHandle, sharename, &(vbsfvolume->map));
    230230    free(sharename);
    231231
    … …  
    258258    else
    259259    {
    260         dprintf(FS_NAME ": vboxCallMapFolder failed (%d)\n", rv);
     260        dprintf(FS_NAME ": VbglR0SfMapFolder failed (%d)\n", rv);
    261261        free(volume->private_volume);
    262262        return vbox_err_to_haiku_err(rv);
    … …  
    268268{
    269269    dprintf(FS_NAME ": unmount\n");
    270     vboxCallUnmapFolder(&g_clientHandle, volume->private_volume);
     270    VbglR0SfUnmapFolder(&g_clientHandle, volume->private_volume);
    271271    return B_OK;
    272272}
    … …  
    284284    params.Handle = SHFL_HANDLE_NIL;
    285285    params.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
    286     dprintf("sf_stat: calling vboxCallCreate, file %s, flags %x\n", vnode->path->String.utf8, params.CreateFlags);
    287     rc = vboxCallCreate(&g_clientHandle, &volume->map, vnode->path, &params);
     286    dprintf("sf_stat: calling VbglR0SfCreate, file %s, flags %x\n", vnode->path->String.utf8, params.CreateFlags);
     287    rc = VbglR0SfCreate(&g_clientHandle, &volume->map, vnode->path, &params);
    288288    if (rc == VERR_INVALID_NAME)
    289289    {
    … …  
    293293    if (RT_FAILURE(rc))
    294294    {
    295         dprintf("vboxCallCreate: %d\n", params.Result);
     295        dprintf("VbglR0SfCreate: %d\n", params.Result);
    296296        return vbox_err_to_haiku_err(params.Result);
    297297    }
    298298    if (params.Result != SHFL_FILE_EXISTS)
    299299    {
    300         dprintf("vboxCallCreate: %d\n", params.Result);
     300        dprintf("VbglR0SfCreate: %d\n", params.Result);
    301301        return B_ENTRY_NOT_FOUND;
    302302    }
    … …  
    329329    params.CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_OPEN_IF_EXISTS | SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
    330330
    331     int rc = vboxCallCreate(&g_clientHandle, &volume->map, vnode->path, &params);
     331    int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, vnode->path, &params);
    332332    if (RT_SUCCESS(rc))
    333333    {
    … …  
    349349    else
    350350    {
    351         dprintf(FS_NAME ": vboxCallCreate: %d\n", rc);
     351        dprintf(FS_NAME ": VbglR0SfCreate: %d\n", rc);
    352352        return vbox_err_to_haiku_err(rc);
    353353    }
    … …  
    368368        cookie->buffer_start = cookie->buffer = malloc(cookie->buffer_length);
    369369
    370         int rc = vboxCallDirInfo(&g_clientHandle, &volume->map, cookie->handle, cookie->path, 0, cookie->index,
     370        int rc = VbglR0SfDirInfo(&g_clientHandle, &volume->map, cookie->handle, cookie->path, 0, cookie->index,
    371371                                 &cookie->buffer_length, cookie->buffer, &cookie->num_files);
    372372
    373373        if (rc != 0 && rc != VERR_NO_MORE_FILES)
    374374        {
    375             dprintf(FS_NAME ": vboxCallDirInfo failed: %d\n", rc);
     375            dprintf(FS_NAME ": VbglR0SfDirInfo failed: %d\n", rc);
    376376            free(cookie->buffer_start);
    377377            cookie->buffer_start = NULL;
    … …  
    462462    vboxsf_dir_cookie* cookie = _cookie;
    463463
    464     vboxCallClose(&g_clientHandle, &volume->map, cookie->handle);
     464    VbglR0SfClose(&g_clientHandle, &volume->map, cookie->handle);
    465465    free(cookie->path);
    466466    free(cookie);
    … …  
    477477    uint32_t bytes = sizeof(SHFLVOLINFO);
    478478
    479     int rc = vboxCallFSInfo(&g_clientHandle, &volume->map, 0,
    480         (SHFL_INFO_GET | SHFL_INFO_VOLUME), &bytes, (PSHFLDIRINFO)&volume_info);
    481 
     479    int rc = VbglR0SfFsInfo(&g_clientHandle, &volume->map, 0, SHFL_INFO_GET | SHFL_INFO_VOLUME,
     480                            &bytes, (PSHFLDIRINFO)&volume_info);
    482481    if (RT_FAILURE(rc))
    483482    {
    484         dprintf(FS_NAME ": vboxCallFSInfo failed (%d)\n", rc);
     483        dprintf(FS_NAME ": VbglR0SfFsInfo failed (%d)\n", rc);
    485484        return vbox_err_to_haiku_err(rc);
    486485    }
    … …  
    520519    }
    521520
    522     int rc = vboxCallCreate(&g_clientHandle, &volume->map, path, &params);
     521    int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, path, &params);
    523522    if (RT_SUCCESS(rc))
    524523    {
    … …  
    543542    {
    544543        free(path);
    545         dprintf(FS_NAME ": vboxCallCreate: %d\n", rc);
     544        dprintf(FS_NAME ": VbglR0SfCreate: %d\n", rc);
    546545        return vbox_err_to_haiku_err(rc);
    547546    }
    … …  
    638637    }
    639638
    640     int rc = vboxCallCreate(&g_clientHandle, &volume->map, vnode->path, &params);
     639    int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, vnode->path, &params);
    641640    if (!RT_SUCCESS(rc))
    642641    {
    643         dprintf("vboxCallCreate returned %d\n", rc);
     642        dprintf("VbglR0SfCreate returned %d\n", rc);
    644643        return vbox_err_to_haiku_err(rc);
    645644    }
    … …  
    700699
    701700    PSHFLSTRING path = build_path(_dir->private_node, name);
    702     int rc = vboxCallCreate(&g_clientHandle, &volume->map, path, &params);
     701    int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, path, &params);
    703702
    704703    if (!RT_SUCCESS(rc))
    705704    {
    706         dprintf("vboxCallCreate returned %d\n", rc);
     705        dprintf("VbglR0SfCreate returned %d\n", rc);
    707706        free(path);
    708707        return vbox_err_to_haiku_err(rc);
    … …  
    730729    vboxsf_file_cookie* cookie = _cookie;
    731730
    732     int rc = vboxCallClose(&g_clientHandle, &volume->map, cookie->handle);
    733     dprintf("vboxCallClose returned %d\n", rc);
     731    int rc = VbglR0SfClose(&g_clientHandle, &volume->map, cookie->handle);
     732    dprintf("VbglR0SfClose returned %d\n", rc);
    734733    return vbox_err_to_haiku_err(rc);
    735734}
    … …  
    768767    uint32_t l = *length;
    769768    void* other_buffer = malloc(l);  /* @todo map the user memory into kernel space here for efficiency */
    770     int rc = vboxCallRead(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false);
     769    int rc = VbglR0SfRead(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false /*fLocked*/);
    771770    memcpy(buffer, other_buffer, l);
    772771    free(other_buffer);
    773772
    774     dprintf("vboxCallRead returned %d\n", rc);
     773    dprintf("VbglR0SfRead returned %d\n", rc);
    775774    *length = l;
    776775    return vbox_err_to_haiku_err(rc);
    … …  
    790789    void* other_buffer = malloc(l);  /* @todo map the user memory into kernel space here for efficiency */
    791790    memcpy(other_buffer, buffer, l);
    792     int rc = vboxCallWrite(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false);
     791    int rc = VbglR0SfWrite(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false /*fLocked*/);
    793792    free(other_buffer);
    794793
    … …  
    816815
    817816    PSHFLSTRING path = build_path(parent->private_node, name);
    818     int rc = vboxCallCreate(&g_clientHandle, &volume->map, path, &params);
     817    int rc = VbglR0SfCreate(&g_clientHandle, &volume->map, path, &params);
    819818    free(path);
    820819    /** @todo r=ramshankar: we should perhaps also check rc here and change
    … …  
    822821    if (params.Handle == SHFL_HANDLE_NIL)
    823822        return vbox_err_to_haiku_err(rc);
    824     else
    825     {
    826         vboxCallClose(&g_clientHandle, &volume->map, params.Handle);
    827         return B_OK;
    828     }
     823    VbglR0SfClose(&g_clientHandle, &volume->map, params.Handle);
     824    return B_OK;
    829825}
    830826
    … …  
    835831
    836832    PSHFLSTRING path = build_path(parent->private_node, name);
    837     int rc = vboxCallRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_DIR);
     833    int rc = VbglR0SfRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_DIR);
    838834    free(path);
    839835
    … …  
    847843
    848844    PSHFLSTRING path = build_path(parent->private_node, name);
    849     int rc = vboxCallRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_FILE);
     845    int rc = VbglR0SfRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_FILE);
    850846    free(path);
    851847
    … …  
    865861    PSHFLSTRING oldpath = build_path(fromDir->private_node, fromName);
    866862    PSHFLSTRING newpath = build_path(toDir->private_node, toName);
    867     int rc = vboxCallRename(&g_clientHandle, &volume->map, oldpath, newpath, SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS);
     863    int rc = VbglR0SfRename(&g_clientHandle, &volume->map, oldpath, newpath, SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS);
    868864    free(oldpath);
    869865    free(newpath);
    … …  
    882878    RT_ZERO(stuff);
    883879
    884     int rc = vboxCallSymlink(&g_clientHandle, &volume->map, linkpath, target, &stuff);
     880    int rc = VbglR0SfSymlink(&g_clientHandle, &volume->map, linkpath, target, &stuff);
    885881
    886882    free(target);
    … …  
    896892    vboxsf_vnode* vnode = link->private_node;
    897893
    898     int rc = vboxReadLink(&g_clientHandle, &volume->map, vnode->path, *_bufferSize, buffer);
     894    int rc = VbglR0SfReadLink(&g_clientHandle, &volume->map, vnode->path, *_bufferSize, buffer);
    899895    *_bufferSize = strlen(buffer);
    900896
Note: See TracChangeset for help on using the changeset viewer.

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