* Mm: Add MmMapViewOfObject, MmMapViewOfFile.

  We also need to implement this in the page fault handler, and then
  add tests for it.

* Io: Add IoIsSeekable - checks if an I/O file object is mappable/seekable.
  Devices such as keyboards are not mappable, but block devices and file system
  backed files are.  They're characterized by the fact they can or cannot seek
  (so, don't have random access), which is an important part of whether a file
  is pageable.

* Ob: Return the pointer to the object when calling ObReferenceObjectByPointer.

* Style Guide: Modify the section on parenthesis layout in function declarations.

Author: iProgramMC

boron/include/io/dispatch.h

@@ -1,6 +1,6 @@
 /***
 	The Boron Operating System
-	Copyright (C) 2024 iProgramInCpp
+	Copyright (C) 2024-2025 iProgramInCpp
 
 Module name:
 	io/dispatch.h
@@ -24,6 +24,10 @@ Module name:
 //
 // - The BSTATUS returned must have the same value as the value inside the "Status" pointer, if it exists.
 //
+// - IO_SEEKABLE_METHOD returns whether or not the file is seekable.  This is, in this case, equal to whether the file
+//   is mappable.  Block devices and file system backed files should return TRUE, while stream I/O devices such as
+//   keyboards and serial ports should return FALSE.
+//
 // - If IsEntryFromReadDir is TRUE, IO_LOOKUP_DIR_METHOD, IO_UNLINK_METHOD and IO_REMOVE_DIR_METHOD may optimize by opening
 //   the inode/file according to the other fields of the IO_DIRECTORY_ENTRY, instead of performing a potentially expensive
 //   lookup again on the name.  If it is false, the other fields must be IGNORED and the file name must be taken into
@@ -91,6 +95,7 @@ typedef void   (*IO_CREATE_OBJ_METHOD) (PFCB Fcb, void* FileObject);
 typedef void   (*IO_DELETE_METHOD)     (PFCB Fcb);
 typedef void   (*IO_DELETE_OBJ_METHOD) (PFCB Fcb, void* FileObject);
 typedef void   (*IO_DEREFERENCE_METHOD)(PFCB Fcb);
+typedef bool   (*IO_SEEKABLE_METHOD)   (PFCB Fcb);
 typedef BSTATUS(*IO_OPEN_METHOD)       (PFCB Fcb, uint32_t OpenFlags);
 typedef BSTATUS(*IO_CLOSE_METHOD)      (PFCB Fcb, int LastHandleCount);
 typedef BSTATUS(*IO_READ_METHOD)       (PIO_STATUS_BLOCK Iosb, PFCB Fcb, uint64_t Offset, PMDL MdlBuffer, uint32_t Flags);
@@ -154,6 +159,7 @@ typedef struct _IO_DISPATCH_TABLE
 	IO_CREATE_OBJ_METHOD  CreateObject;
 	IO_DELETE_OBJ_METHOD  DeleteObject;
 	IO_DEREFERENCE_METHOD Dereference;
+	IO_SEEKABLE_METHOD    Seekable;
 	IO_OPEN_METHOD        Open;
 	IO_CLOSE_METHOD       Close;
 	IO_READ_METHOD        Read;

boron/include/io/fileobj.h

@@ -30,3 +30,5 @@ typedef struct _FILE_OBJECT
 	uint32_t OpenFlags;
 }
 FILE_OBJECT, *PFILE_OBJECT;
+
+bool IoIsSeekable(PFILE_OBJECT Object);

boron/include/mm.h

@@ -28,8 +28,8 @@ Module name:
 #include <mm/probe.h>
 #include <mm/mdl.h>
 #include <mm/cache.h>
-#include <mm/vad.h>
 #include <mm/section.h>
+#include <mm/vad.h>
 #include <mm/heap.h>
 #include <mm/services.h>
 

boron/include/mm/section.h

@@ -15,6 +15,7 @@ Module name:
 
 typedef struct
 {
-	
+	// TODO
+	int X;
 }
 MMSECTION, *PMMSECTION;

boron/include/mm/vad.h

@@ -45,6 +45,9 @@ typedef union
 
 		// If this region is private (so, not duplicated across forks for example)
 		int Private : 1;
+		
+		// If this region is a file object, as opposed to a section object, or nothing.
+		int IsFile : 1;
 	};
 
 	uint32_t LongFlags;
@@ -63,11 +66,12 @@ typedef struct _MMVAD_ENTRY
 	{
 		void* Object;
 		PFILE_OBJECT FileObject;
+		PMMSECTION SectionObject;
 	}
 	Mapped;
 
-	// If this is a file, then the offset within the file.
-	uint64_t OffsetInFile;
+	// If this is a file or section, then the offset within it.
+	uint64_t SectionOffset;
 }
 MMVAD, *PMMVAD;
 
@@ -93,7 +97,7 @@ void MmUnlockVadList(PMMVAD_LIST);
 // Looks up a VAD by address in a VAD list previously locked with MmLockVadListProcess.
 PMMVAD MmLookUpVadByAddress(PMMVAD_LIST VadList, uintptr_t Address);
 
-// Reserves a bunch of virtual memory and returns an address.
+// Reserves a range of virtual memory and returns an address.
 BSTATUS MmReserveVirtualMemory(size_t SizePages, void** OutAddress, int AllocationType, int Protection);
 
 // Releases a region of virtual memory.

boron/include/ob.h

@@ -284,7 +284,7 @@ BSTATUS ObCreateSymbolicLinkObject(
 );
 
 // Adds 1 to the internal reference count of the object.
-void ObReferenceObjectByPointer(void* Object);
+void* ObReferenceObjectByPointer(void* Object);
 
 // Takes a reference away from the internal ref count of the object.
 // If the reference count hits zero, the object will be deleted.

boron/source/io/file.c

@@ -13,6 +13,18 @@ Module name:
 ***/
 #include "iop.h"
 
+// Checks if this file is seekable.
+bool IoIsSeekable(PFILE_OBJECT FileObject)
+{
+	PFCB Fcb = FileObject->Fcb;
+	IO_SEEKABLE_METHOD Seekable = Fcb->DispatchTable->Seekable;
+	
+	if (!Seekable)
+		return false;
+	
+	return Seekable(Fcb);
+}
+
 // Create a file object. This doesn't actually open the object.
 BSTATUS IopCreateFileObject(PFCB Fcb, PFILE_OBJECT* OutObject, uint32_t Flags, uint32_t OpenFlags)
 {

boron/source/mm/mi.h

@@ -252,4 +252,10 @@ PMMPTE MmGetPteLocation(uintptr_t Address);
 // been generated if GenerateMissingLevels is true).
 bool MmCheckPteLocation(uintptr_t Address, bool GenerateMissingLevels);
 
+// Reserves a range of virtual memory and returns a VAD.
+//
+// Note: This leaves the VAD list locked, if the function succeeds, so you must call MmUnlockVadList!
+// Note: All of the parameters are presumed valid!
+BSTATUS MmReserveVirtualMemoryVad(size_t SizePages, int AllocationType, int Protection, PMMVAD* OutVad, PMMVAD_LIST* OutVadList);
+
 #endif//NS64_MI_H

boron/source/mm/vad.c

@@ -38,15 +38,8 @@ void MmInitializeVadList(PMMVAD_LIST VadList)
 	InitializeRbTree(&VadList->Tree);
 }
 
-// Reserves a range of virtual memory.
-BSTATUS MmReserveVirtualMemory(size_t SizePages, void** OutAddress, int AllocationType, int Protection)
+BSTATUS MmReserveVirtualMemoryVad(size_t SizePages, int AllocationType, int Protection, PMMVAD* OutVad, PMMVAD_LIST* OutVadList)
 {
-	if (Protection & ~(PAGE_READ | PAGE_WRITE | PAGE_EXECUTE))
-		return STATUS_INVALID_PARAMETER;
-	
-	if (AllocationType & ~(MEM_RESERVE | MEM_COMMIT | MEM_SHARED | MEM_TOP_DOWN))
-		return STATUS_INVALID_PARAMETER;
-	
 	PEPROCESS Process = PsGetCurrentProcess();
 	PMMADDRESS_NODE AddrNode;
 
@@ -70,14 +63,33 @@ BSTATUS MmReserveVirtualMemory(size_t SizePages, void** OutAddress, int Allocati
 	// Clear all the fields in the VAD.
 	Vad->Flags.LongFlags  = 0;
 	Vad->Mapped.Object    = NULL;
-	Vad->OffsetInFile     = 0;
+	Vad->SectionOffset    = 0;
 	Vad->Flags.Committed  =  (AllocationType & MEM_COMMIT) != 0;
 	Vad->Flags.Private    = (~AllocationType & MEM_SHARED) != 0;
 	Vad->Flags.Protection = Protection;
 
-	*OutAddress = (void*) Vad->Node.StartVa;
+	*OutVad = Vad;
+	*OutVadList = &Process->VadList;
+	return STATUS_SUCCESS;
+}
+
+// Reserves a range of virtual memory.
+BSTATUS MmReserveVirtualMemory(size_t SizePages, void** OutAddress, int AllocationType, int Protection)
+{
+	if (Protection & ~(PAGE_READ | PAGE_WRITE | PAGE_EXECUTE))
+		return STATUS_INVALID_PARAMETER;
 
-	MmUnlockVadList(&Process->VadList);
+	if (AllocationType & ~(MEM_RESERVE | MEM_COMMIT | MEM_SHARED | MEM_TOP_DOWN))
+		return STATUS_INVALID_PARAMETER;
+	
+	PMMVAD Vad;
+	PMMVAD_LIST VadList;
+	BSTATUS Status = MmReserveVirtualMemoryVad(SizePages, AllocationType, Protection, &Vad, &VadList);
+	if (FAILED(Status))
+		return Status;
+	
+	*OutAddress = (void*) Vad->Node.StartVa;
+	MmUnlockVadList(VadList);
 	return STATUS_SUCCESS;
 }
 
@@ -125,35 +137,23 @@ BSTATUS MiReleaseVad(PMMVAD Vad)
 
 	MmUnlockSpace(Ipl, Vad->Node.StartVa);
 
-	// Step 4. Finally, add the range into the heap/free list.
+	// Step 4. Remove the reference to the object if needed.
+	if (Vad->Mapped.Object)
+	{
+		ObDereferenceObject(Vad->Mapped.Object);
+		Vad->Mapped.Object = NULL;
+	}
+	
+	// Step 5. Finally, add the range into the heap/free list.
 	BSTATUS Status = MmFreeAddressSpace(&Process->Heap, &Vad->Node);
 	if (FAILED(Status))
 	{
-		// NOTE: This should never happen.  But perhaps it's a good time
-		// to consider that we should probably own both the VAD list mutex
-		// and the heap mutex at the same time, with a single
-		// KeWaitForMultipleObjects call.
+		// NOTE: This should never happen.
 		//
-		// An argument against it is that there's no way for this region
-		// to be used if it's not part of either the heap or the VAD list.
-		
-	#ifdef DEBUG
+		// Why? Because there's no way for this region to be used if it's
+		// not part of either the heap or the VAD list.
 		KeCrash("MmDereserveVad: Failed to insert VAD into free-heap (address %p)", Vad->Node.StartVa);
-	#endif
-		
-		// Re-insert it?
-		MiLockVadList(&Process->VadList);
-		bool Inserted = InsertItemRbTree(&Process->VadList.Tree, &Vad->Node.Entry);
-		MmUnlockVadList(&Process->VadList);
-		
-		if (!Inserted)
-		{
-			// Ohhh.... crap
-		#ifdef DEBUG
-			KeCrash("MmDereserveVad: Unreachable");
-		#endif
-			Status = STATUS_UNIMPLEMENTED;
-		}
+		Status = STATUS_UNIMPLEMENTED;
 	}
 
 	return Status;

boron/source/mm/view.c

@@ -0,0 +1,138 @@
+/***
+	The Boron Operating System
+	Copyright (C) 2025 iProgramInCpp
+
+Module name:
+	mm/view.c
+	
+Abstract:
+	This module defines functions that map and unmap views
+	of files or sections into the virtual memory space.
+	
+Author:
+	iProgramInCpp - 3 April 2025
+***/
+#include "mi.h"
+#include <ex.h>
+#include <io.h>
+
+// NOTE: AllocationType and Protection have been validated.
+BSTATUS MmMapViewOfFile(
+	PFILE_OBJECT FileObject,
+	void** BaseAddressOut,
+	size_t* ViewSizeInOut,
+	int AllocationType,
+	uint64_t SectionOffset,
+	int Protection
+)
+{
+	// You cannot map files that are not seekable.
+	if (!IoIsSeekable(FileObject))
+		return STATUS_UNSUPPORTED_FUNCTION;
+	
+	size_t ViewSize = *ViewSizeInOut;
+	size_t PageOffset = SectionOffset & (PAGE_SIZE - 1);
+	size_t ViewSizePages = (ViewSize + PageOffset + PAGE_SIZE - 1) / PAGE_SIZE;
+	
+	PMMVAD Vad;
+	PMMVAD_LIST VadList;
+	
+	// Reserve the region, and then mark it as committed ourselves.
+	BSTATUS Status = MmReserveVirtualMemoryVad(ViewSizePages, AllocationType | MEM_RESERVE, Protection, &Vad, &VadList);
+	if (FAILED(Status))
+		return Status;
+	
+	// Vad Protection and Private are filled in by MmReserveVirtualMemoryVad.
+	Vad->Flags.Committed = 1;
+	Vad->Flags.IsFile = 1;
+	Vad->Mapped.FileObject = ObReferenceObjectByPointer(FileObject);
+	Vad->SectionOffset = SectionOffset & ~(PAGE_SIZE - 1);
+	
+	*BaseAddressOut = (void*) Vad->Node.StartVa;
+	*ViewSizeInOut = PAGE_SIZE * ViewSizePages;
+	MmUnlockVadList(VadList);
+	
+	return STATUS_UNIMPLEMENTED;
+}
+
+//
+// Maps a view of either a file or a section.  The type will be checked inside.
+// The only supported types of object are MmSectionType and IoFileType.
+//
+// Parameters:
+//     MappedObject - The object of which a view is to be mapped.
+//
+//     BaseAddressOut - The base address of the view.  If MEM_FIXED is specified, then the address
+//                      will be read from this parameter.
+//
+//     ViewSizeInOut - The size of the view in bytes.  This pointer will be accessed to store the
+//                     size of the view after its creation.
+//
+//     AllocationType - The type of allocation.  MEM_TOP_DOWN and MEM_SHARED are the allowed flags.
+//
+//     SectionOffset - The offset within the file or section.  If this isn't aligned to a page boundary,
+//                     then neither will the output base address.
+//
+//     Protection - The protection applied to the pages to be committed.  See OSAllocateVirtualMemory for
+//                  more information.
+//
+BSTATUS MmMapViewOfObject(
+	HANDLE MappedObject,
+	void** BaseAddressOut,
+	size_t* ViewSizeInOut,
+	int AllocationType,
+	uint64_t SectionOffset,
+	int Protection
+)
+{
+	if (Protection & ~(PAGE_READ | PAGE_WRITE | PAGE_EXECUTE))
+		return STATUS_INVALID_PARAMETER;
+	
+	if (AllocationType & ~(MEM_COMMIT | MEM_SHARED | MEM_TOP_DOWN))
+		return STATUS_INVALID_PARAMETER;
+	
+	if (!ViewSizeInOut)
+		return STATUS_INVALID_PARAMETER;
+	
+	BSTATUS Status;
+	PFILE_OBJECT FileObject = NULL;
+	//PMMSECTION SectionObject = NULL;
+	
+	Status = ObReferenceObjectByHandle(MappedObject, IoFileType, (void**) &FileObject);
+	if (SUCCEEDED(Status))
+	{
+		Status = MmMapViewOfFile(
+			FileObject,
+			BaseAddressOut,
+			ViewSizeInOut,
+			AllocationType,
+			SectionOffset,
+			Protection
+		);
+		
+		ObDereferenceObject(FileObject);
+		return Status;
+	}
+	
+	/*
+	TODO:
+	
+	Status = ObReferenceObjectByHandle(MappedObject, MmSectionType, (void**) &FileObject);
+	if (SUCCEEDED(Status))
+	{
+		Status = MmMapViewOfSection(
+			FileObject,
+			BaseAddressOut,
+			ViewSizeInOut,
+			AllocationType,
+			SectionOffset,
+			Protection
+		);
+		
+		ObDereferenceObject(FileObject);
+		return Status;
+	}
+	*/
+	
+	return STATUS_TYPE_MISMATCH;
+}