Changeset 739

Timestamp:

07/07/08 15:23:30 (2 months ago)

Author:

mwhitworth

Message:

Add start of SysMemoryProtect system call.

Location:

Whitix/trunk/memory

Files:

• mmap.c (modified) (14 diffs)
• shmem.c (modified) (1 diff)

Whitix/trunk/memory/mmap.c

@@ -28 +28 @@
 #include <sys.h>
 #include <print.h>
+#include <preempt.h>
 
 extern struct Cache* areaCache,*mapCache;
@@ -53 +54 @@
         struct PhysPage* newPage;
         int ret;
-
-//      KePrint("VmHandleNoPage(%#X)\n", address);
 
         if (area->areaOps && area->areaOps->handleNoPage)
@@ -69 +68 @@
                         MachineHalt();
                 }else{
+                        PreemptDisable(); /* Needed? */
                         newPage=PageAlloc();
 
                         if (!newPage)
+                        {
+                                PreemptEnable();
                                 return -ENOMEM;
+                        }
 
                         VirtMemMapPage(address,newPage->physAddr,area->protection);
+
+                        PreemptEnable();
 
                         if (area->vNode->fileOps->mMap)
@@ -154 +159 @@
 }
 
-/***********************************************************************
- *
- * FUNCTION:    MMapAddArea
- *
- * DESCRIPTION: Add an area to the process's area list. The list is
- *                              sorted by start address, as this makes it much easier
- *                              for MMapFindAddress.
- *
- * PARAMETERS:  process - process in question.
- *                              area - area to be added.
- *
- * RETURNS:             Usual error codes.
- *
- ***********************************************************************/
-
 int MmapHandleFault(struct Process* process,DWORD address,int error)
 {
@@ -218 +208 @@
  ***********************************************************************/
 
-static void MMapAddArea(struct Process* process,struct VMArea* area)
-{
-        struct VMArea* curr=NULL;
-
+static void MMapAddArea(struct Process* process, struct VMArea* area)
+{
         if (ListEmpty(&process->areaList))
                 ListAdd(&area->list,&process->areaList);
         else
         {
+                struct VMArea* curr=NULL;
+
                 ListForEachEntry(curr,&process->areaList,list)
                         if (curr->start > area->start)
@@ -299 +289 @@
 void MmapProcessRemove(struct Process* process)
 {
-        struct VMArea* curr,*curr2;
+        struct VMArea* curr, *curr2;
         DWORD i;
+        DWORD flags;
+
+        IrqSaveFlags(flags);
 
         ListForEachEntrySafe(curr, curr2, &process->areaList, list)
@@ -309 +302 @@
                 MMapRemoveArea(curr);
         }
+
+        IrqRestoreFlags(flags);
 }
 
@@ -365 +360 @@
  ***********************************************************************/
 
-void MMapMerge(struct VMArea* first,struct VMArea* second,int isAnon)
+void MMapMerge(struct VMArea* first, struct VMArea* second)
 {
         if (first->start+first->length != second->start)
@@ -376 +371 @@
                 return;
 
-        if (!(isAnon))
-                /* Check offsets */
-                if (second->offset != first->offset+first->length)
-                        return;
-
         if (first->flags != second->flags)
                 return;
 
+        /* Check offsets */
+        if (second->offset != first->offset+first->length)
+                return;
+
         /* Ok to merge now */
-
         first->length+=second->length;
-
         MMapRemoveArea(second);
 }
 
-void MMapMergeMappings(struct Process* process,struct VMArea* area,int isAnon)
+void MMapMergeMappings(struct Process* process, struct VMArea* area)
 {
         /* Get neighbours of this area (in terms of memory), and see whether they are 
@@ -401 +393 @@
 
         if (area->list.next != &process->areaList)
-                MMapMerge(area,next,isAnon);
+                MMapMerge(area, next);
 
         if (area->list.prev != &process->areaList)
-                MMapMerge(prev,area,isAnon);
+                MMapMerge(prev, area);
 }
 
@@ -430 +422 @@
 {
         struct VMArea* area=(struct VMArea*)MemCacheAlloc(areaCache);
-        int isAnon=!vNode;
 
         if (!process || !length || !area)
@@ -455 +446 @@
                 if (NameToVNode(&vNode,DEVICES_PATH "Special/Zero",0))
                         return 0;
+
+                flags |= MMAP_ANON;
         }
 
@@ -469 +462 @@
 
         MMapAddArea(process,area);
-        MMapMergeMappings(process,area,isAnon);
+        MMapMergeMappings(process, area);
 
         return address;
@@ -603 +596 @@
 }
 
-int SysMemoryProtect(DWORD address, size_t length, int protection)
-{
-        KePrint("SysMemoryProtect(%#X, %d)\n", address, length);
-        return -ENOTIMPL;
+int MMapProtectionFixAll(struct VMArea* area, int protection)
+{
+        area->protection=protection;
+        return 0;
+}
+
+int MMapProtectionChange(struct VMArea* area, DWORD start, DWORD end, int protection)
+{
+        int error=-ENOTIMPL;
+
+        if (protection ==  area->protection)
+                return 0;
+
+        if (start == area->start)
+        {
+                if (end == area->start+area->length)
+                        error=MMapProtectionFixAll(area, protection);
+                else
+                        KePrint("MMapProtectionChange: TODO\n");
+        }else{
+                KePrint("MMapProtectionChange: TODO\n");
+        }
+
+        if (error)
+                return error;
+
+        VirtChangeProtection(start, end, protection);
+
+        return 0;
+}
+
+int SysMemoryProtect(DWORD start, size_t length, int protection)
+{
+        int error=-EINVAL;
+        size_t end;
+        size_t address;
+        struct VMArea* area, *next;
+
+        PreemptDisable();
+
+        /* Can only deal with changing the protection of whole pages. */
+        if (PAGE_OFFSET(start))
+                goto out;
+
+        length=PAGE_ALIGN_UP(length);
+        end=start+length;
+
+        if (end < start)
+                goto out;
+
+        /* Check protection bits. */
+
+        error=0;
+
+        /* A zero length is valid, but useless. */
+        if (start == end)
+                goto out;
+
+        area=VmLookupAddress(current, start);
+
+        error=-EFAULT;
+
+        if (!area)
+                goto out;
+
+        /* The change of protection may extend over one or more mappings. */
+        address=start;
+
+        while (1)
+        {
+                if ((area->start + area->length) >= end)
+                {
+                        error=MMapProtectionChange(area, address, end, protection);
+                        break;
+                }
+
+                KePrint("SysMemoryProtect: todo\n");
+        }
+
+//      MMapMergeMappings(current, start, end);
+
+out:
+        PreemptEnable();
+        return error;
 }
 

Whitix/trunk/memory/shmem.c

@@ -27 +27 @@
 #include <sys.h>
 #include <module.h>
+#include <print.h>
 
 #define SHMEM_MAX_DESCS         10