X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fbinary.c;h=5213bf2d50cd203a4e44df153509f478f74e4d75;hb=30c11f371da98d13344e8bed3766d3e574a65ac9;hp=fdb4dbaefe18c383ac01e2cf7945dac2b7e3b4c5;hpb=263e8355dbbcee8d38db03753811c0a8246d04e9;p=tpg%2Facess2.git

diff --git a/Kernel/binary.c b/Kernel/binary.c
index fdb4dbae..5213bf2d 100644
--- a/Kernel/binary.c
+++ b/Kernel/binary.c
@@ -7,6 +7,7 @@
 #include <binary.h>
 #include <mm_virt.h>
 #include <hal_proc.h>
+#include <vfs_threads.h>
 
 // === CONSTANTS ===
 #define BIN_LOWEST	MM_USER_MIN		// 1MiB
@@ -30,7 +31,7 @@ extern tKernelSymbol	gKernelSymbolsEnd[];
 extern tBinaryType	gELF_Info;
 
 // === PROTOTYPES ===
- int	Proc_Execve(const char *File, const char **ArgV, const char **EnvP);
+ int	Binary_int_CacheArgs(const char **Path, const char ***ArgV, const char ***EnvP, void *DestBuffer);
 tVAddr	Binary_Load(const char *Path, tVAddr *EntryPoint);
 tBinary	*Binary_GetInfo(tMount MountID, tInode InodeID);
 tVAddr	Binary_MapIn(tBinary *Binary, const char *Path, tVAddr LoadMin, tVAddr LoadMax);
@@ -78,12 +79,12 @@ int Proc_Spawn(const char *Path)
 	
 	LOG("stackPath = '%s'", stackPath);
 	
-	if(Proc_Clone(CLONE_VM) == 0)
+	if(Proc_Clone(CLONE_VM|CLONE_NOUSER) == 0)
 	{
 		// CHILD
 		const char	*args[2] = {stackPath, NULL};
 		LOG("stackPath = '%s'", stackPath);
-		Proc_Execve(stackPath, args, &args[1]);
+		Proc_Execve(stackPath, args, &args[1], 0);
 		for(;;);
 	}
 	LEAVE('i', 0);
@@ -91,98 +92,181 @@ int Proc_Spawn(const char *Path)
 }
 
 /**
- * \fn int Proc_Execve(char *File, char **ArgV, char **EnvP)
+ * \todo Document
+ */
+int Binary_int_CacheArgs(const char **Path, const char ***ArgV, const char ***EnvP, void *DestBuffer)
+{
+	 int	size, argc=0, envc=0;
+	 int	i;
+	char	*strbuf;
+	const char	**arrays;
+	
+	// Calculate size
+	size = 0;
+	if( ArgV && *ArgV )
+	{
+		const char	**argv = *ArgV;
+		for( argc = 0; argv[argc]; argc ++ )
+			size += strlen( argv[argc] ) + 1;
+	}
+	if( EnvP && *EnvP )
+	{
+		const char	**envp = *EnvP;
+		for( envc = 0; envp[envc]; envc ++ )
+			size += strlen( envp[envc] ) + 1;
+	}
+	size = (size + sizeof(void*)-1) & ~(sizeof(void*)-1);	// Word align
+	size += (argc+1+envc+1)*sizeof(void*);	// Arrays
+	if( Path )
+	{
+		size += strlen( *Path ) + 1;
+	}
+
+	if( DestBuffer )	
+	{
+		arrays = DestBuffer;
+		strbuf = (void*)&arrays[argc+1+envc+1];
+	
+		// Fill ArgV
+		if( ArgV && *ArgV )
+		{
+			const char	**argv = *ArgV;
+			for( i = 0; argv[i]; i ++ )
+			{
+				arrays[i] = strbuf;
+				strcpy(strbuf, argv[i]);
+				strbuf += strlen( argv[i] ) + 1;
+			}
+			*ArgV = arrays;
+			arrays += i;
+		}
+		*arrays++ = NULL;
+		// Fill EnvP
+		if( EnvP && *EnvP )
+		{
+			const char	**envp = *EnvP;
+			for( i = 0; envp[i]; i ++ )
+			{
+				arrays[i] = strbuf;
+				strcpy(strbuf, envp[i]);
+				strbuf += strlen( envp[i] ) + 1;
+			}
+			*EnvP = arrays;
+			arrays += i;
+		}
+		*arrays++ = NULL;
+		// Fill path
+		if( Path )
+		{
+			strcpy(strbuf, *Path);
+			*Path = strbuf;
+		}
+	}
+	
+	return size;
+}
+
+/**
+ * \brief Create a new process with the specified set of file descriptors
+ */
+int Proc_SysSpawn(const char *Binary, const char **ArgV, const char **EnvP, int nFD, int *FDs)
+{
+	void	*handles;
+	void	*cachebuf;
+	 int	size;
+	tPID	ret;
+	
+	// --- Save File, ArgV and EnvP
+	size = Binary_int_CacheArgs( &Binary, &ArgV, &EnvP, NULL );
+	cachebuf = malloc( size );
+	Binary_int_CacheArgs( &Binary, &ArgV, &EnvP, cachebuf );
+
+	// Cache the VFS handles	
+	handles = VFS_SaveHandles(nFD, FDs);
+
+	// Create new process	
+	ret = Proc_Clone(CLONE_VM|CLONE_NOUSER);
+	if( ret == 0 )
+	{
+		VFS_RestoreHandles(nFD, handles);
+		VFS_FreeSavedHandles(nFD, handles);
+		// Frees cachebuf
+		Proc_Execve(Binary, ArgV, EnvP, size);
+		for(;;);
+	}
+	if( ret < 0 )
+	{
+		VFS_FreeSavedHandles(nFD, handles);
+	}
+	
+	return ret;
+}
+
+/**
  * \brief Replace the current user image with another
  * \param File	File to load as the next image
  * \param ArgV	Arguments to pass to user
  * \param EnvP	User's environment
  * \note Called Proc_ for historical reasons
  */
-int Proc_Execve(const char *File, const char **ArgV, const char **EnvP)
+int Proc_Execve(const char *File, const char **ArgV, const char **EnvP, int DataSize)
 {
-	 int	argc, envc, i;
-	 int	argenvBytes;
-	char	**argenvBuf, *strBuf;
-	char	**argvSaved, **envpSaved;
-	char	*savedFile;
+	void	*cachebuf;
 	tVAddr	entry;
-	Uint	bases[2] = {0};	// Uint because Proc_StartUser wants it
+	Uint	base;	// Uint because Proc_StartUser wants it
+	 int	argc;
 	
 	ENTER("sFile pArgV pEnvP", File, ArgV, EnvP);
 	
-	// --- Save File, ArgV and EnvP (also get argc)
-	
-	// Count Arguments, Environment Variables and total string sizes
-	argenvBytes = 0;
-	for( argc = 0; ArgV && ArgV[argc]; argc++ )
-		argenvBytes += strlen(ArgV[argc])+1;
-	for( envc = 0; EnvP && EnvP[envc]; envc++ )
-		argenvBytes += strlen(EnvP[envc])+1;
-	argenvBytes = (argenvBytes + sizeof(void*)-1) & ~(sizeof(void*)-1);
-	argenvBytes += (argc+1)*sizeof(void*) + (envc+1)*sizeof(void*);
-	
-	// Allocate
-	argenvBuf = malloc(argenvBytes);
-	if(argenvBuf == NULL) {
-		Log_Error("Binary", "Proc_Execve - What the hell? The kernel is out of heap space");
-		LEAVE('i', 0);
-		return 0;
-	}
-	strBuf = (char*)argenvBuf + (argc+1)*sizeof(void*) + (envc+1)*sizeof(void*);
-	
-	// Populate
-	argvSaved = argenvBuf;
-	for( i = 0; i < argc; i++ )
-	{
-		argvSaved[i] = strBuf;
-		strcpy(argvSaved[i], ArgV[i]);
-		strBuf += strlen(ArgV[i])+1;
-	}
-	argvSaved[i] = NULL;
-	envpSaved = &argvSaved[i+1];
-	for( i = 0; i < envc; i++ )
+	// --- Save File, ArgV and EnvP
+	if( DataSize == 0 )
 	{
-		envpSaved[i] = strBuf;
-		strcpy(envpSaved[i], EnvP[i]);
-		strBuf += strlen(EnvP[i])+1;
+		DataSize = Binary_int_CacheArgs( &File, &ArgV, &EnvP, NULL );
+		cachebuf = malloc( DataSize );
+		Binary_int_CacheArgs( &File, &ArgV, &EnvP, cachebuf );
 	}
-	envpSaved[i] = NULL;
-	
-	savedFile = malloc(strlen(File)+1);
-	strcpy(savedFile, File);
+
+	// --- Get argc	
+	for( argc = 0; ArgV && ArgV[argc]; argc ++ );
 	
 	// --- Set Process Name
 	Threads_SetName(File);
 	
 	// --- Clear User Address space
-	MM_ClearUser();
+	// NOTE: This is a little roundabout, maybe telling ClearUser to not touch the
+	//       PPD area would be a better idea.
+	{
+		 int	nfd = *Threads_GetMaxFD();
+		void	*handles;
+		handles = VFS_SaveHandles(nfd, NULL);
+		VFS_CloseAllUserHandles();
+		MM_ClearUser();
+		VFS_RestoreHandles(nfd, handles);
+		VFS_FreeSavedHandles(nfd, handles);
+	}
 	
 	// --- Load new binary
-	bases[0] = Binary_Load(savedFile, &entry);
-	free(savedFile);
-	if(bases[0] == 0)
+	base = Binary_Load(File, &entry);
+	if(base == 0)
 	{
-		Log_Warning("Binary", "Proc_Execve - Unable to load '%s'", Threads_GetName(-1));
+		Log_Warning("Binary", "Proc_Execve - Unable to load '%s'", File);
 		LEAVE('-');
 		Threads_Exit(0, -10);
 		for(;;);
 	}
 	
-	LOG("entry = 0x%x, bases[0] = 0x%x", entry, bases[0]);
-
-//	MM_DumpTables(0, KERNEL_BASE);
-
+	LOG("entry = 0x%x, base = 0x%x", entry, base);
 	LEAVE('-');
 	// --- And... Jump to it
-	Proc_StartUser(entry, bases, argc, argvSaved, envpSaved, argenvBytes);
+	Proc_StartUser(entry, base, argc, ArgV, DataSize);
 	for(;;);	// Tell GCC that we never return
 }
 
 /**
- * \fn tVAddr Binary_Load(char *Path, tVAddr *EntryPoint)
  * \brief Load a binary into the current address space
  * \param Path	Path to binary to load
  * \param EntryPoint	Pointer for exectuable entry point
+ * \return Virtual address where the binary has been loaded
  */
 tVAddr Binary_Load(const char *Path, tVAddr *EntryPoint)
 {
@@ -217,6 +301,7 @@ tVAddr Binary_Load(const char *Path, tVAddr *EntryPoint)
 		VFS_Close(fd);
 		mount_id = info.mount;
 		inode = info.inode;
+		LOG("mount_id = %i, inode = %i", mount_id, inode);
 	}
 
 	// TODO: Also get modifcation time?
@@ -260,26 +345,29 @@ tVAddr Binary_Load(const char *Path, tVAddr *EntryPoint)
 
 /**
  * \brief Finds a matching binary entry
- * \param TruePath	File Identifier (True path name)
+ * \param MountID	Mountpoint ID of binary file
+ * \param InodeID	Inode ID of the file
+ * \return Pointer to the binary definition (if already loaded)
  */
 tBinary *Binary_GetInfo(tMount MountID, tInode InodeID)
 {
 	tBinary	*pBinary;
-	pBinary = glLoadedBinaries;
-	while(pBinary)
+	for(pBinary = glLoadedBinaries; pBinary; pBinary = pBinary->Next)
 	{
 		if(pBinary->MountID == MountID && pBinary->Inode == InodeID)
 			return pBinary;
-		pBinary = pBinary->Next;
 	}
 	return NULL;
 }
 
 /**
- \fn Uint Binary_MapIn(tBinary *binary)
- \brief Maps an already-loaded binary into an address space.
- \param binary	Pointer to globally stored data.
-*/
+ * \brief Maps an already-loaded binary into an address space.
+ * \param Binary	Pointer to globally stored binary definition
+ * \param Path	Path to the binary's file (for debug)
+ * \param LoadMin	Lowest location to map to
+ * \param LoadMax	Highest location to map to
+ * \return Base load address
+ */
 tVAddr Binary_MapIn(tBinary *Binary, const char *Path, tVAddr LoadMin, tVAddr LoadMax)
 {
 	tVAddr	base;
@@ -297,7 +385,7 @@ tVAddr Binary_MapIn(tBinary *Binary, const char *Path, tVAddr LoadMin, tVAddr Lo
 	if(base != 0)
 	{
 		LOG("Checking base %p", base);
-		for(i=0;i<Binary->NumSections;i++)
+		for( i = 0; i < Binary->NumSections; i ++ )
 		{
 			if( Binary_int_CheckMemFree( Binary->LoadSections[i].Virtual, Binary->LoadSections[i].MemSize ) )
 			{
@@ -343,13 +431,14 @@ tVAddr Binary_MapIn(tBinary *Binary, const char *Path, tVAddr LoadMin, tVAddr Lo
 		tBinarySection	*sect = &Binary->LoadSections[i];
 		Uint	protflags, mapflags;
 		tVAddr	addr = sect->Virtual - Binary->Base + base;
-		LOG("%i - %p to 0x%llx (%x)", i, addr, sect->Offset, sect->Flags);
+		LOG("%i - %p to offset 0x%llx (%x)", i, addr, sect->Offset, sect->Flags);
 
 		protflags = MMAP_PROT_READ;
 		mapflags = MMAP_MAP_FIXED;
 
 		if( sect->Flags & BIN_SECTFLAG_EXEC )
 			protflags |= MMAP_PROT_EXEC;
+		// Read only pages are COW
 		if( sect->Flags & BIN_SECTFLAG_RO  ) {
 			VFS_MMap( (void*)addr, sect->FileSize, protflags, MMAP_MAP_SHARED|mapflags, fd, sect->Offset );
 		}
@@ -357,6 +446,8 @@ tVAddr Binary_MapIn(tBinary *Binary, const char *Path, tVAddr LoadMin, tVAddr Lo
 			protflags |= MMAP_PROT_WRITE;
 			VFS_MMap( (void*)addr, sect->FileSize, protflags, MMAP_MAP_PRIVATE|mapflags, fd, sect->Offset );
 		}
+		
+		// Apply anonymous memory for BSS
 		if( sect->FileSize < sect->MemSize ) {
 			mapflags |= MMAP_MAP_ANONYMOUS;
 			VFS_MMap(
@@ -364,15 +455,12 @@ tVAddr Binary_MapIn(tBinary *Binary, const char *Path, tVAddr LoadMin, tVAddr Lo
 				protflags, MMAP_MAP_PRIVATE|mapflags,
 				0, 0
 				);
-//			memset((void*)(addr + sect->FileSize), 0, sect->MemSize - sect->FileSize);
 		}
 	}
 	
-	Log_Debug("Binary", "PID %i - Mapped '%s' to 0x%x", Threads_GetPID(), Path, base);
+	Log_Debug("Binary", "PID %i - Mapped '%s' to %p", Threads_GetPID(), Path, base);
 	VFS_Close(fd);
 	
-	//LOG("*0x%x = 0x%x\n", binary->Pages[0].Virtual, *(Uint*)binary->Pages[0].Virtual);
-	
 	LEAVE('p', base);
 	return base;
 }
@@ -414,7 +502,7 @@ tBinary *Binary_DoLoad(tMount MountID, tInode Inode, const char *Path)
 {
 	tBinary	*pBinary;
 	 int	fp;
-	Uint	ident;
+	Uint32	ident;
 	tBinaryType	*bt = gRegBinTypes;
 	
 	ENTER("iMountID XInode sPath", MountID, Inode, Path);
@@ -426,20 +514,25 @@ tBinary *Binary_DoLoad(tMount MountID, tInode Inode, const char *Path)
 		LEAVE('n');
 		return NULL;
 	}
+
+	LOG("fp = 0x%x", fp);
 	
 	// Read File Type
 	VFS_Read(fp, 4, &ident);
 	VFS_Seek(fp, 0, SEEK_SET);
 
+	LOG("ident = 0x%x", ident);
+
 	// Determine the type	
 	for(; bt; bt = bt->Next)
 	{
-		if( (ident & bt->Mask) != (Uint)bt->Ident )
+		if( (ident & bt->Mask) != (Uint32)bt->Ident )
 			continue;
+		LOG("bt = %p (%s)", bt, bt->Name);
 		pBinary = bt->Load(fp);
 		break;
 	}
-	
+
 	// Close File
 	VFS_Close(fp);
 	
@@ -451,6 +544,8 @@ tBinary *Binary_DoLoad(tMount MountID, tInode Inode, const char *Path)
 		return NULL;
 	}
 	
+	LOG("pBinary = %p", pBinary);
+	
 	// Error Check
 	if(pBinary == NULL) {
 		LEAVE('n');