예제 #1
0
        public static void Reprotect(IntPtr address, ulong size, MemoryPermission permission, bool throwOnFail)
        {
            bool result;

            if (OperatingSystem.IsWindows())
            {
                IntPtr sizeNint = new IntPtr((long)size);

                result = MemoryManagementWindows.Reprotect(address, sizeNint, permission);
            }
            else if (OperatingSystem.IsLinux() ||
                     OperatingSystem.IsMacOS())
            {
                result = MemoryManagementUnix.Reprotect(address, size, permission);
            }
            else
            {
                throw new PlatformNotSupportedException();
            }

            if (!result && throwOnFail)
            {
                throw new MemoryProtectionException(permission);
            }
        }
예제 #2
0
        public static void Reprotect(IntPtr address, ulong size, MemoryPermission permission, bool forView, bool force4KBMap, bool throwOnFail)
        {
            bool result;

            if (OperatingSystem.IsWindows())
            {
                if (forView && force4KBMap)
                {
                    result = MemoryManagementWindows.Reprotect4KB(address, (IntPtr)size, permission, forView);
                }
                else
                {
                    result = MemoryManagementWindows.Reprotect(address, (IntPtr)size, permission, forView);
                }
            }
            else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
            {
                result = MemoryManagementUnix.Reprotect(address, size, permission);
            }
            else
            {
                throw new PlatformNotSupportedException();
            }

            if (!result && throwOnFail)
            {
                throw new MemoryProtectionException(permission);
            }
        }
예제 #3
0
        public static void Reprotect(IntPtr address, ulong size, MemoryPermission permission, bool throwOnFail)
        {
            bool result;

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                IntPtr sizeNint = new IntPtr((long)size);

                result = MemoryManagementWindows.Reprotect(address, sizeNint, permission);
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
                     RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                result = MemoryManagementUnix.Reprotect(address, size, permission);
            }
            else
            {
                throw new PlatformNotSupportedException();
            }

            if (!result && throwOnFail)
            {
                throw new MemoryProtectionException(permission);
            }
        }
예제 #4
0
 public static IntPtr Remap(IntPtr target, IntPtr source, ulong size)
 {
     if (OperatingSystem.IsLinux() ||
         OperatingSystem.IsMacOS())
     {
         return(MemoryManagementUnix.Remap(target, source, size));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #5
0
 public static IntPtr Remap(IntPtr target, IntPtr source, ulong size)
 {
     if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
         RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
     {
         return(MemoryManagementUnix.Remap(target, source, size));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #6
0
 public static void UnmapView(IntPtr sharedMemory, IntPtr address, ulong size, MemoryBlock owner)
 {
     if (OperatingSystem.IsWindows())
     {
         MemoryManagementWindows.UnmapView(sharedMemory, address, (IntPtr)size, owner);
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         MemoryManagementUnix.UnmapView(address, size);
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #7
0
 public static bool Decommit(IntPtr address, ulong size)
 {
     if (OperatingSystem.IsWindows())
     {
         return(MemoryManagementWindows.Decommit(address, (IntPtr)size));
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         return(MemoryManagementUnix.Decommit(address, size));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #8
0
 public static void UnmapSharedMemory(IntPtr address, ulong size)
 {
     if (OperatingSystem.IsWindows())
     {
         MemoryManagementWindows.UnmapSharedMemory(address);
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         MemoryManagementUnix.UnmapSharedMemory(address, size);
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #9
0
 public static IntPtr Reserve(ulong size, bool viewCompatible)
 {
     if (OperatingSystem.IsWindows())
     {
         return(MemoryManagementWindows.Reserve((IntPtr)size, viewCompatible));
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         return(MemoryManagementUnix.Reserve(size));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #10
0
 public static void DestroySharedMemory(IntPtr handle)
 {
     if (OperatingSystem.IsWindows())
     {
         MemoryManagementWindows.DestroySharedMemory(handle);
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         MemoryManagementUnix.DestroySharedMemory(handle);
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #11
0
 public static IntPtr MapSharedMemory(IntPtr handle, ulong size)
 {
     if (OperatingSystem.IsWindows())
     {
         return(MemoryManagementWindows.MapSharedMemory(handle));
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         return(MemoryManagementUnix.MapSharedMemory(handle, size));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #12
0
 public static IntPtr Allocate(ulong size)
 {
     if (OperatingSystem.IsWindows())
     {
         return(MemoryManagementWindows.Allocate((IntPtr)size));
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         return(MemoryManagementUnix.Allocate(size));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #13
0
 public static IntPtr CreateSharedMemory(ulong size, bool reserve)
 {
     if (OperatingSystem.IsWindows())
     {
         return(MemoryManagementWindows.CreateSharedMemory((IntPtr)size, reserve));
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         return(MemoryManagementUnix.CreateSharedMemory(size, reserve));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #14
0
 public static bool Free(IntPtr address, ulong size, bool force4KBMap)
 {
     if (OperatingSystem.IsWindows())
     {
         return(MemoryManagementWindows.Free(address, (IntPtr)size, force4KBMap));
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         return(MemoryManagementUnix.Free(address));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #15
0
 public static IntPtr MapSharedMemory(IntPtr handle)
 {
     if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
     {
         return(MemoryManagementWindows.MapSharedMemory(handle));
     }
     else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
              RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
     {
         return(MemoryManagementUnix.MapSharedMemory(handle));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #16
0
 public static bool Free(IntPtr address)
 {
     if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
     {
         return(MemoryManagementWindows.Free(address));
     }
     else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
              RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
     {
         return(MemoryManagementUnix.Free(address));
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #17
0
 public static void UnmapSharedMemory(IntPtr address)
 {
     if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
     {
         MemoryManagementWindows.UnmapSharedMemory(address);
     }
     else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
              RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
     {
         MemoryManagementUnix.UnmapSharedMemory(address);
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #18
0
 public static void DestroySharedMemory(IntPtr handle)
 {
     if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
     {
         MemoryManagementWindows.DestroySharedMemory(handle);
     }
     else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
              RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
     {
         MemoryManagementUnix.DestroySharedMemory(handle);
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #19
0
        public static IntPtr Reserve(ulong size)
        {
            if (OperatingSystem.IsWindows())
            {
                IntPtr sizeNint = new IntPtr((long)size);

                return(MemoryManagementWindows.Reserve(sizeNint));
            }
            else if (OperatingSystem.IsLinux() ||
                     OperatingSystem.IsMacOS())
            {
                return(MemoryManagementUnix.Reserve(size));
            }
            else
            {
                throw new PlatformNotSupportedException();
            }
        }
예제 #20
0
        public static IntPtr Allocate(ulong size)
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                IntPtr sizeNint = new IntPtr((long)size);

                return(MemoryManagementWindows.Allocate(sizeNint));
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
                     RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                return(MemoryManagementUnix.Allocate(size));
            }
            else
            {
                throw new PlatformNotSupportedException();
            }
        }
예제 #21
0
        public static bool Decommit(IntPtr address, ulong size)
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                IntPtr sizeNint = new IntPtr((long)size);

                return(MemoryManagementWindows.Decommit(address, sizeNint));
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
                     RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                return(MemoryManagementUnix.Decommit(address, size));
            }
            else
            {
                throw new PlatformNotSupportedException();
            }
        }
예제 #22
0
        public static IntPtr CreateSharedMemory(ulong size, bool reserve)
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                IntPtr sizeNint = new IntPtr((long)size);

                return(MemoryManagementWindows.CreateSharedMemory(sizeNint, reserve));
            }
            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
                     RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                return(MemoryManagementUnix.CreateSharedMemory(size, reserve));
            }
            else
            {
                throw new PlatformNotSupportedException();
            }
        }
예제 #23
0
 public static void MapView(IntPtr sharedMemory, ulong srcOffset, IntPtr address, ulong size, MemoryBlock owner)
 {
     if (OperatingSystem.IsWindows())
     {
         if (owner.ForceWindows4KBView)
         {
             MemoryManagementWindows.MapView4KB(sharedMemory, srcOffset, address, (IntPtr)size);
         }
         else
         {
             MemoryManagementWindows.MapView(sharedMemory, srcOffset, address, (IntPtr)size, owner);
         }
     }
     else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
     {
         MemoryManagementUnix.MapView(sharedMemory, srcOffset, address, size);
     }
     else
     {
         throw new PlatformNotSupportedException();
     }
 }
예제 #24
0
        public static void MapView(IntPtr sharedMemory, ulong srcOffset, IntPtr address, ulong size, bool force4KBMap)
        {
            if (OperatingSystem.IsWindows())
            {
                IntPtr sizeNint = new IntPtr((long)size);

                if (force4KBMap)
                {
                    MemoryManagementWindows.MapView4KB(sharedMemory, srcOffset, address, sizeNint);
                }
                else
                {
                    MemoryManagementWindows.MapView(sharedMemory, srcOffset, address, sizeNint);
                }
            }
            else if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
            {
                MemoryManagementUnix.MapView(sharedMemory, srcOffset, address, size);
            }
            else
            {
                throw new PlatformNotSupportedException();
            }
        }