Changeset 37823 in vbox for trunk/src/VBox/Additions/solaris/SharedFolders

Timestamp:

Jul 7, 2011 2:47:37 PM (13 years ago)

Author:

vboxsync

Message:

Additions/solaris/SharedFolders: readonly mmap bits.

File:

• trunk/src/VBox/Additions/solaris/SharedFolders/vboxfs_vnode.c (modified) (9 diffs)

trunk/src/VBox/Additions/solaris/SharedFolders/vboxfs_vnode.c

@@ -84 +84 @@
 #include <sys/vfs.h>
 #include <sys/vmsystm.h>
+#include <vm/seg_kpm.h>
+#include <vm/pvn.h>
 #if !defined(VBOX_VFS_SOLARIS_10U6)
 #include <sys/vfs_opreg.h>
@@ -1456 +1458 @@
 
 #if 0
+static caddr_t
+sffs_page_map(
+        page_t *ppage,
+        enum seg_rw segaccess)
+{
+        /* Use seg_kpm driver if possible (64-bit) */
+        if (kpm_enable)
+                return (hat_kpm_mapin(ppage, NULL));
+        ASSERT(segaccess == S_READ || segaccess == S_WRITE);
+        return (ppmapin(ppage, PROT_READ | ((segaccess == S_WRITE) ? PROT_WRITE : 0), (caddr_t)-1));
+}
+
+
+static void
+sffs_page_unmap(
+        page_t *ppage,
+        caddr_t addr)
+{
+        if (kpm_enable)
+                hat_kpm_mapout(ppage, NULL, addr);
+        else
+                ppmapout(addr);
+}
+
+
+/*
+ * Called when there's no page in the cache. This will create new page(s) and read
+ * the file data into it.
+ */
+static int
+sffs_readpages(
+        vnode_t         *dvp,
+        offset_t        off,
+        page_t          *pagelist[],
+        size_t          pagelistsize,
+        struct seg  *segp,
+        caddr_t         addr,
+        enum seg_rw     segaccess)
+{
+        ASSERT(MUTEX_HELD(&sffs_lock));
+
+        int error = 0;
+        u_offset_t io_off, total;
+        size_t io_len;
+        page_t *ppages;
+        page_t *pcur;
+
+        sfnode_t *node = VN2SFN(dvp);
+        ASSERT(node);
+        ASSERT(node->sf_file);
+
+        if (pagelistsize == PAGESIZE)
+        {
+                io_off = off;
+                io_len = PAGESIZE;
+
+                ppages = page_create_va(dvp, io_off, io_len, PG_WAIT | PG_EXCL, segp, addr);
+        }
+        else
+                ppages = pvn_read_kluster(dvp, off, segp, addr, &io_off, &io_len, off, pagelistsize, 0);
+
+        /* If page already exists return success */
+        if (!ppages)
+        {
+                *pagelist = NULL;
+                return (0);
+        }
+
+        /*
+         * Map & read page-by-page.
+         */
+        total = io_off + io_len;
+        pcur = ppages;
+        while (io_off < total)
+        {
+                ASSERT3U(io_off, ==, pcur->p_offset);
+
+                caddr_t virtaddr = sffs_page_map(pcur, segaccess);
+                uint32_t bytes = PAGESIZE;
+                error = sfprov_read(node->sf_file, virtaddr, io_off, &bytes);
+                sffs_page_unmap(pcur, virtaddr);
+                if (error != 0 || bytes < PAGESIZE)
+                {
+                        /* Get rid of all kluster pages read & bail.  */
+                        pvn_read_done(ppages,  B_ERROR);
+                        return (error);
+                }
+                pcur = pcur->p_next;
+                io_off += PAGESIZE;
+        }
+
+        /*
+         * Fill in the pagelist from kluster at the requested offset.
+         */
+        pvn_plist_init(ppages, pagelist, pagelistsize, off, io_len, segaccess);
+        ASSERT(pagelist == NULL || (*pagelist)->p_offset == off);
+        return (0);
+}
+
+
 /*ARGSUSED*/
 static int
@@ -1474 +1576 @@
         )
 {
+        int error = 0;
+        page_t **pageliststart = pagelist;
+
+        if (segaccess == S_WRITE)
+                return (ENOSYS);        /* Will this ever happen? */
+
+        if (protp)
+                *protp = PROT_ALL;
+
+        /* We don't really support async ops, pretend success. */
+        if (pagelist == NULL)
+                return (0);
+
+        if (len > pagelistsize)
+                len = pagelistsize;
+        else
+                len = P2ROUNDUP(len, PAGESIZE);
+        ASSERT(pagelistsize >= len);
+
+        mutex_enter(&sffs_lock);
+
+        while (len > 0)
+        {
+                /*
+                 * Look for pages in the requested offset range, or create them if we can't find any.
+                 */
+                if ((*pagelist = page_lookup(dvp, off, SE_SHARED)) != NULL)
+                        *(pagelist + 1) = NULL;
+                else if ((error = sffs_readpages(dvp, off, pagelist, pagelistsize, segp, addr, segaccess)) != 0)
+                {
+                        while (pagelist > pageliststart)
+                                page_unlock(*--pagelist);
+
+                        *pagelist = NULL;
+                        mutex_exit(&sffs_lock);
+                        return (error);
+                }
+
+                while (*pagelist)
+                {
+                        ASSERT3U((*pagelist)->p_offset, ==, off);
+                        off += PAGESIZE;
+                        addr += PAGESIZE;
+                        if (len > 0)
+                        {
+                                ASSERT3U(len, >=, PAGESIZE);
+                                len -= PAGESIZE;
+                        }
+
+                        ASSERT3U(pagelistsize,  >=, PAGESIZE);
+                        pagelistsize -= PAGESIZE;
+                        pagelist++;
+                }
+
+                /*
+                 * Fill the page list array with any pages left in the cache.
+                 */
+                while (pagelistsize > 0)
+                {
+                        if ((*pagelist++ = page_lookup_nowait(dvp, off, SE_SHARED)) != NULL)
+                        {
+                                off += PAGESIZE;
+                                pagelistsize -= PAGESIZE;
+                        }
+                        else
+                                break;
+                }
+        }
+
+        *pagelist = NULL;
+        mutex_exit(&sffs_lock);
+        return (error);
 }
 
@@ -1490 +1664 @@
         )
 {
+        /*
+         * We don't support PROT_WRITE mmaps. For normal writes we do not map and IO via
+         * vop_putpage() either, therefore, afaik this shouldn't ever be called.
+         */
+        return (ENOSYS);
 }
 
@@ -1511 +1690 @@
 {
         /*
-         * Invocation: mmap()-smmap_common()->VOP_MAP()->sffs_map(). Once the segment driver
-         * creates the new segment in segvn_create(), it'll invoke down the line VOP_ADDMAP()->sffs_addmap()
+         * Invocation: mmap()->smmap_common()->VOP_MAP()->sffs_map(). Once the
+         * segment driver creates the new segment via segvn_create(), it'll
+         * invoke down the line VOP_ADDMAP()->sffs_addmap()
          */
         int error;
+        sfnode_t *node = VN2SFN(dvp);
+        ASSERT(node);
         if ((prot & PROT_WRITE))
                 return (ENOTSUP);
@@ -1526 +1708 @@
         if (dvp->v_flag & VNOMAP)
                 return (ENOSYS);
+
+        if (vn_has_mandatory_locks(dvp, node->sf_stat.sf_mode))
+                return (EAGAIN);
 
         mutex_enter(&sffs_lock);
@@ -1576 +1761 @@
         uint64_t npages = btopr(len);
 
+        if (dvp->v_flag & VNOMAP)
+                return (ENOSYS);
+
         ASSERT(node);
         ASMAtomicAddU64(&node->sf_mapcnt, npages);
@@ -1601 +1789 @@
         sfnode_t *node = VN2SFN(dvp);
         uint64_t npages = btopr(len);
+
+        if (dvp->v_flag & VNOMAP)
+                return (ENOSYS);
 
         ASSERT(node->sf_mapcnt >= npages);
@@ -1947 +2138 @@
         VOPNAME_WRITE,          { .vop_write = sffs_write },
 
-#if 0
+# if 0
         VOPNAME_MAP,            { .vop_map = sffs_map },
         VOPNAME_ADDMAP,         { .vop_addmap = sffs_addmap },