VirtualBox

忽略:
時間撮記:
2010-6-10 下午04:23:36 (14 年 以前)
作者:
vboxsync
訊息:

Linux shared folders: spaces

檔案:
修改 1 筆資料

圖例:

未更動
新增
刪除

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

    r29935 r30153  
    2424
    2525
    26 static void *alloc_bounch_buffer (size_t *tmp_sizep, PRTCCPHYS physp, size_t xfer_size, const char *caller)
     26static void *alloc_bounch_buffer(size_t *tmp_sizep, PRTCCPHYS physp, size_t xfer_size, const char *caller)
    2727{
    2828    size_t tmp_size;
    … …  
    3333    if (tmp_size > 16U*_1K)
    3434        tmp_size = 16U*_1K;
    35     tmp = kmalloc (tmp_size, GFP_KERNEL);
     35    tmp = kmalloc(tmp_size, GFP_KERNEL);
    3636    if (!tmp) {
    3737
    3838        /* fall back on a page sized buffer. */
    39         tmp = kmalloc (PAGE_SIZE, GFP_KERNEL);
     39        tmp = kmalloc(PAGE_SIZE, GFP_KERNEL);
    4040        if (!tmp) {
    4141            LogRel(("%s: could not allocate bounce buffer for xfer_size=%zu %s\n", caller, xfer_size));
    … …  
    5050}
    5151
    52 static void free_bounch_buffer (void *tmp)
     52static void free_bounch_buffer(void *tmp)
    5353{
    5454    kfree (tmp);
    … …  
    5858/* fops */
    5959static int
    60 sf_reg_read_aux (const char *caller, struct sf_glob_info *sf_g,
    61                  struct sf_reg_info *sf_r, void *buf, uint32_t *nread,
    62                  uint64_t pos)
     60sf_reg_read_aux(const char *caller, struct sf_glob_info *sf_g,
     61                struct sf_reg_info *sf_r, void *buf, uint32_t *nread,
     62                uint64_t pos)
    6363{
    6464        /** @todo bird: yes, kmap() and kmalloc() input only. Since the buffer is
    6565         *        contiguous in physical memory (kmalloc or single page), we should
    6666         *        use a physical address here to speed things up. */
    67         int rc = vboxCallRead (&client_handle, &sf_g->map, sf_r->handle,
    68                                pos, nread, buf, false /* already locked? */);
    69         if (RT_FAILURE (rc)) {
     67        int rc = vboxCallRead(&client_handle, &sf_g->map, sf_r->handle,
     68                              pos, nread, buf, false /* already locked? */);
     69        if (RT_FAILURE(rc)) {
    7070                LogFunc(("vboxCallRead failed. caller=%s, rc=%Rrc\n",
    7171                         caller, rc));
    … …  
    7676
    7777static int
    78 sf_reg_write_aux (const char *caller, struct sf_glob_info *sf_g,
     78sf_reg_write_aux(const char *caller, struct sf_glob_info *sf_g,
    7979                  struct sf_reg_info *sf_r, void *buf, uint32_t *nwritten,
    8080                  uint64_t pos)
    … …  
    8383         *        contiguous in physical memory (kmalloc or single page), we should
    8484         *        use a physical address here to speed things up. */
    85         int rc = vboxCallWrite (&client_handle, &sf_g->map, sf_r->handle,
     85        int rc = vboxCallWrite(&client_handle, &sf_g->map, sf_r->handle,
    8686                                pos, nwritten, buf, false /* already locked? */);
    87         if (RT_FAILURE (rc)) {
     87        if (RT_FAILURE(rc)) {
    8888                LogFunc(("vboxCallWrite failed. caller=%s, rc=%Rrc\n",
    8989                         caller, rc));
    … …  
    9494
    9595static ssize_t
    96 sf_reg_read (struct file *file, char *buf, size_t size, loff_t *off)
     96sf_reg_read(struct file *file, char *buf, size_t size, loff_t *off)
    9797{
    9898        int err;
    … …  
    103103        ssize_t total_bytes_read = 0;
    104104        struct inode *inode = file->f_dentry->d_inode;
    105         struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
     105        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
    106106        struct sf_reg_info *sf_r = file->private_data;
    107107        loff_t pos = *off;
    108108
    109         TRACE ();
    110         if (!S_ISREG (inode->i_mode)) {
     109        TRACE();
     110        if (!S_ISREG(inode->i_mode)) {
    111111                LogFunc(("read from non regular file %d\n", inode->i_mode));
    112112                return -EINVAL;
    … …  
    119119        }
    120120
    121         tmp = alloc_bounch_buffer (&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
     121        tmp = alloc_bounch_buffer(&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
    122122        if (!tmp)
    123123            return -ENOMEM;
    … …  
    132132                nread = to_read;
    133133
    134                 err = sf_reg_read_aux (__func__, sf_g, sf_r, tmp, &nread, pos);
     134                err = sf_reg_read_aux(__func__, sf_g, sf_r, tmp, &nread, pos);
    135135                if (err)
    136136                        goto fail;
    137137
    138                 if (copy_to_user (buf, tmp, nread)) {
     138                if (copy_to_user(buf, tmp, nread)) {
    139139                        err = -EFAULT;
    140140                        goto fail;
    … …  
    151151
    152152        *off += total_bytes_read;
    153         free_bounch_buffer (tmp);
     153        free_bounch_buffer(tmp);
    154154        return total_bytes_read;
    155155
    156156 fail:
    157         free_bounch_buffer (tmp);
     157        free_bounch_buffer(tmp);
    158158        return err;
    159159}
    160160
    161161static ssize_t
    162 sf_reg_write (struct file *file, const char *buf, size_t size, loff_t *off)
     162sf_reg_write(struct file *file, const char *buf, size_t size, loff_t *off)
    163163{
    164164        int err;
    … …  
    169169        ssize_t total_bytes_written = 0;
    170170        struct inode *inode = file->f_dentry->d_inode;
    171         struct sf_inode_info *sf_i = GET_INODE_INFO (inode);
    172         struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
     171        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
     172        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
    173173        struct sf_reg_info *sf_r = file->private_data;
    174174        loff_t pos;
    175175
    176         TRACE ();
    177         BUG_ON (!sf_i);
    178         BUG_ON (!sf_g);
    179         BUG_ON (!sf_r);
    180 
    181         if (!S_ISREG (inode->i_mode)) {
     176        TRACE();
     177        BUG_ON(!sf_i);
     178        BUG_ON(!sf_g);
     179        BUG_ON(!sf_r);
     180
     181        if (!S_ISREG(inode->i_mode)) {
    182182                LogFunc(("write to non regular file %d\n",  inode->i_mode));
    183183                return -EINVAL;
    … …  
    196196                return 0;
    197197
    198         tmp = alloc_bounch_buffer (&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
     198        tmp = alloc_bounch_buffer(&tmp_size, &tmp_phys, size, __PRETTY_FUNCTION__);
    199199        if (!tmp)
    200200                return -ENOMEM;
    … …  
    209209                nwritten = to_write;
    210210
    211                 if (copy_from_user (tmp, buf, to_write)) {
     211                if (copy_from_user(tmp, buf, to_write)) {
    212212                        err = -EFAULT;
    213213                        goto fail;
    … …  
    216216#if 1
    217217                if (VbglR0CanUsePhysPageList()) {
    218                     err = VbglR0SfWritePhysCont (&client_handle, &sf_g->map, sf_r->handle,
    219                                                  pos, &nwritten, tmp_phys);
     218                    err = VbglR0SfWritePhysCont(&client_handle, &sf_g->map, sf_r->handle,
     219                                                pos, &nwritten, tmp_phys);
    220220                    err = RT_FAILURE(err) ? -EPROTO : 0;
    221221                } else
    222222#endif
    223                     err = sf_reg_write_aux (__func__, sf_g, sf_r, tmp, &nwritten, pos);
     223                    err = sf_reg_write_aux(__func__, sf_g, sf_r, tmp, &nwritten, pos);
    224224                if (err)
    225225                        goto fail;
    … …  
    238238
    239239        sf_i->force_restat = 1;
    240         free_bounch_buffer (tmp);
     240        free_bounch_buffer(tmp);
    241241        return total_bytes_written;
    242242
    243243 fail:
    244         free_bounch_buffer (tmp);
     244        free_bounch_buffer(tmp);
    245245        return err;
    246246}
    247247
    248248static int
    249 sf_reg_open (struct inode *inode, struct file *file)
     249sf_reg_open(struct inode *inode, struct file *file)
    250250{
    251251        int rc, rc_linux = 0;
    252         struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
    253         struct sf_inode_info *sf_i = GET_INODE_INFO (inode);
     252        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
     253        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
    254254        struct sf_reg_info *sf_r;
    255255        SHFLCREATEPARMS params;
    256256
    257         TRACE ();
    258         BUG_ON (!sf_g);
    259         BUG_ON (!sf_i);
     257        TRACE();
     258        BUG_ON(!sf_g);
     259        BUG_ON(!sf_i);
    260260
    261261        LogFunc(("open %s\n", sf_i->path->String.utf8));
    262262
    263         sf_r = kmalloc (sizeof (*sf_r), GFP_KERNEL);
     263        sf_r = kmalloc(sizeof(*sf_r), GFP_KERNEL);
    264264        if (!sf_r) {
    265265                LogRelFunc(("could not allocate reg info\n"));
    … …  
    342342        LogFunc(("sf_reg_open: calling vboxCallCreate, file %s, flags=%#x, %#x\n",
    343343                 sf_i->path->String.utf8 , file->f_flags, params.CreateFlags));
    344         rc = vboxCallCreate (&client_handle, &sf_g->map, sf_i->path, &params);
    345 
    346         if (RT_FAILURE (rc)) {
     344        rc = vboxCallCreate(&client_handle, &sf_g->map, sf_i->path, &params);
     345
     346        if (RT_FAILURE(rc)) {
    347347                LogFunc(("vboxCallCreate failed flags=%d,%#x rc=%Rrc\n",
    348348                         file->f_flags, params.CreateFlags, rc));
    349                 kfree (sf_r);
     349                kfree(sf_r);
    350350                return -RTErrConvertToErrno(rc);
    351351        }
    … …  
    373373
    374374static int
    375 sf_reg_release (struct inode *inode, struct file *file)
     375sf_reg_release(struct inode *inode, struct file *file)
    376376{
    377377        int rc;
    378378        struct sf_reg_info *sf_r;
    379379        struct sf_glob_info *sf_g;
    380         struct sf_inode_info *sf_i = GET_INODE_INFO (inode);
    381 
    382         TRACE ();
    383         sf_g = GET_GLOB_INFO (inode->i_sb);
     380        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
     381
     382        TRACE();
     383        sf_g = GET_GLOB_INFO(inode->i_sb);
    384384        sf_r = file->private_data;
    385385
    386         BUG_ON (!sf_g);
    387         BUG_ON (!sf_r);
    388 
    389         rc = vboxCallClose (&client_handle, &sf_g->map, sf_r->handle);
    390         if (RT_FAILURE (rc)) {
     386        BUG_ON(!sf_g);
     387        BUG_ON(!sf_r);
     388
     389        rc = vboxCallClose(&client_handle, &sf_g->map, sf_r->handle);
     390        if (RT_FAILURE(rc)) {
    391391                LogFunc(("vboxCallClose failed rc=%Rrc\n", rc));
    392392        }
    393393
    394         kfree (sf_r);
     394        kfree(sf_r);
    395395        sf_i->file = NULL;
    396396        sf_i->handle = SHFL_HANDLE_NIL;
    … …  
    399399}
    400400
    401 #if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
     401#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
    402402static int
    403403sf_reg_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
    404 #elif LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
     404#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
    405405static struct page *
    406 sf_reg_nopage (struct vm_area_struct *vma, unsigned long vaddr, int *type)
     406sf_reg_nopage(struct vm_area_struct *vma, unsigned long vaddr, int *type)
    407407# define SET_TYPE(t) *type = (t)
    408408#else /* LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0) */
    409409static struct page *
    410 sf_reg_nopage (struct vm_area_struct *vma, unsigned long vaddr, int unused)
     410sf_reg_nopage(struct vm_area_struct *vma, unsigned long vaddr, int unused)
    411411# define SET_TYPE(t)
    412412#endif
    … …  
    419419        struct file *file = vma->vm_file;
    420420        struct inode *inode = file->f_dentry->d_inode;
    421         struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
     421        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
    422422        struct sf_reg_info *sf_r = file->private_data;
    423423
    424         TRACE ();
    425 #if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
     424        TRACE();
     425#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
    426426        if (vmf->pgoff > vma->vm_end)
    427427                return VM_FAULT_SIGBUS;
    428428#else
    429429        if (vaddr > vma->vm_end) {
    430                 SET_TYPE (VM_FAULT_SIGBUS);
     430                SET_TYPE(VM_FAULT_SIGBUS);
    431431                return NOPAGE_SIGBUS;
    432432        }
    433433#endif
    434434
    435         page = alloc_page (GFP_HIGHUSER);
     435        page = alloc_page(GFP_HIGHUSER);
    436436        if (!page) {
    437437                LogRelFunc(("failed to allocate page\n"));
    438 #if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
     438#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
    439439                return VM_FAULT_OOM;
    440440#else
    441                 SET_TYPE (VM_FAULT_OOM);
     441                SET_TYPE(VM_FAULT_OOM);
    442442                return NOPAGE_OOM;
    443443#endif
    444444        }
    445445
    446         buf = kmap (page);
    447 #if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
     446        buf = kmap(page);
     447#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
    448448        off = (vmf->pgoff << PAGE_SHIFT);
    449449#else
    450450        off = (vaddr - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);
    451451#endif
    452         err = sf_reg_read_aux (__func__, sf_g, sf_r, buf, &nread, off);
     452        err = sf_reg_read_aux(__func__, sf_g, sf_r, buf, &nread, off);
    453453        if (err) {
    454                 kunmap (page);
    455                 put_page (page);
    456 #if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
     454                kunmap(page);
     455                put_page(page);
     456#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
    457457                return VM_FAULT_SIGBUS;
    458458#else
    459                 SET_TYPE (VM_FAULT_SIGBUS);
     459                SET_TYPE(VM_FAULT_SIGBUS);
    460460                return NOPAGE_SIGBUS;
    461461#endif
    … …  
    464464        BUG_ON (nread > PAGE_SIZE);
    465465        if (!nread) {
    466 #if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
    467                 clear_user_page (page_address (page), vmf->pgoff, page);
    468 #elif LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
    469                 clear_user_page (page_address (page), vaddr, page);
    470 #else
    471                 clear_user_page (page_address (page), vaddr);
     466#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
     467                clear_user_page(page_address(page), vmf->pgoff, page);
     468#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
     469                clear_user_page(page_address(page), vaddr, page);
     470#else
     471                clear_user_page(page_address(page), vaddr);
    472472#endif
    473473        }
    474474        else {
    475                 memset (buf + nread, 0, PAGE_SIZE - nread);
    476         }
    477 
    478         flush_dcache_page (page);
    479         kunmap (page);
    480 #if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
     475                memset(buf + nread, 0, PAGE_SIZE - nread);
     476        }
     477
     478        flush_dcache_page(page);
     479        kunmap(page);
     480#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
    481481        vmf->page = page;
    482482        return 0;
    483483#else
    484         SET_TYPE (VM_FAULT_MAJOR);
     484        SET_TYPE(VM_FAULT_MAJOR);
    485485        return page;
    486486#endif
    … …  
    488488
    489489static struct vm_operations_struct sf_vma_ops = {
    490 #if LINUX_VERSION_CODE > KERNEL_VERSION (2, 6, 25)
     490#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 25)
    491491        .fault = sf_reg_fault
    492492#else
    … …  
    496496
    497497static int
    498 sf_reg_mmap (struct file *file, struct vm_area_struct *vma)
    499 {
    500         TRACE ();
     498sf_reg_mmap(struct file *file, struct vm_area_struct *vma)
     499{
     500        TRACE();
    501501        if (vma->vm_flags & VM_SHARED) {
    502502                LogFunc(("shared mmapping not available\n"));
    … …  
    514514        .release     = sf_reg_release,
    515515        .mmap        = sf_reg_mmap,
    516 #if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
    517 # if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 23)
     516#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
     517# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23)
    518518        .splice_read = generic_file_splice_read,
    519519# else
    … …  
    522522        .aio_read    = generic_file_aio_read,
    523523        .aio_write   = generic_file_aio_write,
    524 # if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 35)
     524# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)
    525525        .fsync       = noop_fsync,
    526526# else
    … …  
    533533
    534534struct inode_operations sf_reg_iops = {
    535 #if LINUX_VERSION_CODE < KERNEL_VERSION (2, 6, 0)
     535#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 0)
    536536        .revalidate = sf_inode_revalidate
    537537#else
    … …  
    542542
    543543
    544 #if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 0)
     544#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
    545545static int
    546546sf_readpage(struct file *file, struct page *page)
    547547{
    548548        struct inode *inode = file->f_dentry->d_inode;
    549         struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
     549        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
    550550        struct sf_reg_info *sf_r = file->private_data;
    551551        uint32_t nread = PAGE_SIZE;
    … …  
    554554        int ret;
    555555
    556         TRACE ();
     556        TRACE();
    557557
    558558        buf = kmap(page);
    559         ret = sf_reg_read_aux (__func__, sf_g, sf_r, buf, &nread, off);
     559        ret = sf_reg_read_aux(__func__, sf_g, sf_r, buf, &nread, off);
    560560        if (ret) {
    561             kunmap (page);
     561            kunmap(page);
    562562            if (PageLocked(page))
    563563                unlock_page(page);
    564564            return ret;
    565565        }
    566         BUG_ON (nread > PAGE_SIZE);
     566        BUG_ON(nread > PAGE_SIZE);
    567567        memset(&buf[nread], 0, PAGE_SIZE - nread);
    568         flush_dcache_page (page);
    569         kunmap (page);
     568        flush_dcache_page(page);
     569        kunmap(page);
    570570        SetPageUptodate(page);
    571571            unlock_page(page);
    … …  
    578578        struct address_space *mapping = page->mapping;
    579579        struct inode *inode = mapping->host;
    580         struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
    581         struct sf_inode_info *sf_i = GET_INODE_INFO (inode);
     580        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
     581        struct sf_inode_info *sf_i = GET_INODE_INFO(inode);
    582582        struct file *file = sf_i->file;
    583583        struct sf_reg_info *sf_r = file->private_data;
    … …  
    588588        int err;
    589589
    590         TRACE ();
     590        TRACE();
    591591
    592592        if (page->index >= end_index)
    … …  
    595595        buf = kmap(page);
    596596
    597         err = sf_reg_write_aux (__func__, sf_g, sf_r, buf, &nwritten, off);
     597        err = sf_reg_write_aux(__func__, sf_g, sf_r, buf, &nwritten, off);
    598598        if (err < 0) {
    599599                ClearPageUptodate(page);
    … …  
    614614}
    615615
    616 # if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 24)
     616# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
    617617int
    618618sf_write_begin(struct file *file, struct address_space *mapping, loff_t pos,
    619619               unsigned len, unsigned flags, struct page **pagep, void **fsdata)
    620620{
    621         TRACE ();
     621        TRACE();
    622622
    623623        return simple_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
    … …  
    629629{
    630630        struct inode *inode = mapping->host;
    631         struct sf_glob_info *sf_g = GET_GLOB_INFO (inode->i_sb);
     631        struct sf_glob_info *sf_g = GET_GLOB_INFO(inode->i_sb);
    632632        struct sf_reg_info *sf_r = file->private_data;
    633633        void *buf;
    … …  
    636636        int err;
    637637
    638         TRACE ();
     638        TRACE();
    639639
    640640        buf = kmap(page);
    641         err = sf_reg_write_aux (__func__, sf_g, sf_r, buf+from, &nwritten, pos);
     641        err = sf_reg_write_aux(__func__, sf_g, sf_r, buf+from, &nwritten, pos);
    642642        kunmap(page);
    643643
    … …  
    662662        .readpage      = sf_readpage,
    663663        .writepage     = sf_writepage,
    664 # if LINUX_VERSION_CODE >= KERNEL_VERSION (2, 6, 24)
     664# if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24)
    665665        .write_begin   = sf_write_begin,
    666666        .write_end     = sf_write_end,
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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