X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=AcessNative%2Facesskernel_src%2Fsyscalls.c;h=f19fe69ce9729c522b05a8fcfed2ec7055d19319;hb=b7a55f71ed629d076996e2373da0b32e9c61925e;hp=b41e3544fa354f38c67e2be3679b48e02f4e705e;hpb=a6f11cb266052c58ae7e2d6d6e8abd34a9e93214;p=tpg%2Facess2.git

diff --git a/AcessNative/acesskernel_src/syscalls.c b/AcessNative/acesskernel_src/syscalls.c
index b41e3544..f19fe69c 100644
--- a/AcessNative/acesskernel_src/syscalls.c
+++ b/AcessNative/acesskernel_src/syscalls.c
@@ -4,17 +4,35 @@
  *
  * Syscall Distribution
  */
+#define DEBUG	1
 #include <acess.h>
 #include <threads.h>
+#include <events.h>
+#if DEBUG == 0
+# define DONT_INCLUDE_SYSCALL_NAMES
+#endif
 #include "../syscalls.h"
 
 // === IMPORTS ===
 extern int	Threads_Fork(void);	// AcessNative only function
+extern int	Threads_Spawn(int nFD, int FDs[], const void *info);
 
 // === TYPES ===
 typedef int	(*tSyscallHandler)(Uint *Errno, const char *Format, void *Args, int *Sizes);
 
 // === MACROS ===
+#define SYSCALL6(_name, _fmtstr, _t0, _t1, _t2, _t3, _t4, _t5, _call) int _name(Uint*Errno,const char*Fmt,void*Args,int*Sizes){\
+	_t0 a0;_t1 a1;_t2 a2;_t3 a3;_t4 a4;_t5 a5;\
+	if(strcmp(Fmt,_fmtstr)!=0)return 0;\
+	a0 = *(_t0*)Args;Args+=sizeof(_t0);\
+	a1 = *(_t1*)Args;Args+=sizeof(_t1);\
+	a2 = *(_t2*)Args;Args+=sizeof(_t2);\
+	a3 = *(_t3*)Args;Args+=sizeof(_t3);\
+	a4 = *(_t4*)Args;Args+=sizeof(_t4);\
+	a5 = *(_t5*)Args;Args+=sizeof(_t5);\
+	LOG("SYSCALL6 '%s' %p %p %p %p %p %p", Fmt, (intptr_t)a0,(intptr_t)a1,(intptr_t)a2,(intptr_t)a3,(intptr_t)a4,(intptr_t)a5);\
+	_call\
+}
 #define SYSCALL5(_name, _fmtstr, _t0, _t1, _t2, _t3, _t4, _call) int _name(Uint*Errno,const char*Fmt,void*Args,int*Sizes){\
 	_t0 a0;_t1 a1;_t2 a2;_t3 a3;_t4 a4;\
 	if(strcmp(Fmt,_fmtstr)!=0)return 0;\
@@ -23,6 +41,7 @@ typedef int	(*tSyscallHandler)(Uint *Errno, const char *Format, void *Args, int
 	a2 = *(_t2*)Args;Args+=sizeof(_t2);\
 	a3 = *(_t3*)Args;Args+=sizeof(_t3);\
 	a4 = *(_t4*)Args;Args+=sizeof(_t4);\
+	LOG("SYSCALL5 '%s' %p %p %p %p %p", Fmt, (intptr_t)a0,(intptr_t)a1,(intptr_t)a2,(intptr_t)a3,(intptr_t)a4);\
 	_call\
 }
 #define SYSCALL4(_name, _fmtstr, _t0, _t1, _t2, _t3, _call) int _name(Uint*Errno,const char*Fmt,void*Args,int*Sizes){\
@@ -32,6 +51,7 @@ typedef int	(*tSyscallHandler)(Uint *Errno, const char *Format, void *Args, int
 	a1 = *(_t1*)Args;Args+=sizeof(_t1);\
 	a2 = *(_t2*)Args;Args+=sizeof(_t2);\
 	a3 = *(_t3*)Args;Args+=sizeof(_t3);\
+	LOG("SYSCALL4 '%s' %p %p %p %p", Fmt, (intptr_t)a0,(intptr_t)a1,(intptr_t)a2,(intptr_t)a3);\
 	_call\
 }
 
@@ -41,6 +61,7 @@ typedef int	(*tSyscallHandler)(Uint *Errno, const char *Format, void *Args, int
 	a0 = *(_t0*)Args;Args+=sizeof(_t0);\
 	a1 = *(_t1*)Args;Args+=sizeof(_t1);\
 	a2 = *(_t2*)Args;Args+=sizeof(_t2);\
+	LOG("SYSCALL3 '%s' %p %p %p", Fmt, (intptr_t)a0,(intptr_t)a1,(intptr_t)a2);\
 	_call\
 }
 
@@ -49,6 +70,7 @@ typedef int	(*tSyscallHandler)(Uint *Errno, const char *Format, void *Args, int
 	if(strcmp(Fmt,_fmtstr)!=0)return 0;\
 	a0 = *(_t0*)Args;Args+=sizeof(_t0);\
 	a1 = *(_t1*)Args;Args+=sizeof(_t1);\
+	LOG("SYSCALL2 '%s' %p %p", Fmt, (intptr_t)a0,(intptr_t)a1);\
 	_call;\
 }
 
@@ -56,16 +78,18 @@ typedef int	(*tSyscallHandler)(Uint *Errno, const char *Format, void *Args, int
 	_t0 a0;\
 	if(strcmp(Fmt,_fmtstr)!=0)return 0;\
 	a0 = *(_t0*)Args;Args+=sizeof(_t0);\
+	LOG("SYSCALL1 '%s' %p", Fmt,(intptr_t)a0);\
 	_call;\
 }
 
 #define SYSCALL0(_name, _call) int _name(Uint*Errno,const char*Fmt, void*Args,int*Sizes){\
 	if(strcmp(Fmt,"")!=0)return 0;\
+	LOG("SYSCALL0");\
 	_call;\
 }
 
 // === CODE ===
-int Syscall_Null(Uint*Errno, const char *Format, void *Args, int *Sizes)
+int Syscall_Null(Uint *Errno, const char *Format, void *Args, int *Sizes)
 {
 	return 0;
 }
@@ -76,7 +100,9 @@ SYSCALL1(Syscall_Exit, "i", int,
 );
 
 SYSCALL2(Syscall_Open, "si", const char *, int,
-	return VFS_Open(a0, a1|VFS_OPENFLAG_USER);
+	int rv = VFS_Open(a0, a1|VFS_OPENFLAG_USER);
+	if(rv == -1)	*Errno = errno;
+	return rv;
 );
 SYSCALL1(Syscall_Close, "i", int,
 	VFS_Close(a0);
@@ -87,12 +113,19 @@ SYSCALL3(Syscall_Read, "iid", int, int, void *,
 		Log_Warning("Syscalls", "Read - %i < %i", Sizes[2], a1);
 		return -1;
 	}
-	return VFS_Read(a0, a1, a2);
+	size_t rv = VFS_Read(a0, a1, a2);
+	if(rv == -1)	*Errno = errno;
+	return rv;
 );
 SYSCALL3(Syscall_Write, "iid", int, int, const void *,
-	if( Sizes[2] < a1 )
+	if( Sizes[2] < a1 ) {
+		Log_Warning("Syscalls", "Write - %i < %i", Sizes[2], a1);
+		*Errno = EINVAL;
 		return -1;
-	return VFS_Write(a0, a1, a2);
+	}
+	size_t rv = VFS_Write(a0, a1, a2);
+	if(rv == -1)	*Errno = errno;
+	return rv;
 );
 SYSCALL3(Syscall_Seek, "iIi", int, int64_t, int,
 	return VFS_Seek(a0, a1, a2);
@@ -104,8 +137,12 @@ SYSCALL3(Syscall_IOCtl, "iid", int, int, void *,
 	return VFS_IOCtl(a0, a1, a2);
 );
 SYSCALL3(Syscall_FInfo, "idi", int, void *, int,
-	if( Sizes[1] < sizeof(tFInfo)+a2*sizeof(tVFS_ACL))
+	if( Sizes[1] < sizeof(tFInfo)+a2*sizeof(tVFS_ACL)) {
+		//LOG("offsetof(size) = %i", offsetof(tFInfo, size));
+		LOG("Bad size %i < %i", Sizes[1], sizeof(tFInfo)+a2*sizeof(tVFS_ACL));
+		*Errno = -EINVAL;
 		return -1;
+	}
 	return VFS_FInfo(a0, a1, a2);
 );
 SYSCALL2(Syscall_ReadDir, "id", int, char *,
@@ -113,11 +150,11 @@ SYSCALL2(Syscall_ReadDir, "id", int, char *,
 		return -1;
 	return VFS_ReadDir(a0, a1);
 );
-SYSCALL5(Syscall_select, "idddd", int, fd_set *, fd_set *, fd_set *, time_t *,
-	return VFS_Select(a0, a1, a2, a3, a4, 0);
+SYSCALL6(Syscall_select, "iddddi", int, fd_set *, fd_set *, fd_set *, tTime *, unsigned int,
+	return VFS_Select(a0, a1, a2, a3, a4, a5, 0);
 );
 SYSCALL3(Syscall_OpenChild, "isi", int, const char *, int,
-	return VFS_OpenChild(NULL, a0, a1, a2|VFS_OPENFLAG_USER);
+	return VFS_OpenChild(a0, a1, a2|VFS_OPENFLAG_USER);
 );
 SYSCALL2(Syscall_GetACL, "id", int, void *,
 	if(Sizes[1] < sizeof(tVFS_ACL))
@@ -144,23 +181,60 @@ SYSCALL1(Syscall_SetUID, "i", int,
 		*Errno = -EINVAL;	// TODO: Better message
 		return -1;
 	}
-	return Threads_SetUID(Errno, a0);
+	return Threads_SetUID(a0);
 );
 SYSCALL1(Syscall_SetGID, "i", int,
 	if(Sizes[0] < sizeof(int)) {
 		*Errno = -EINVAL;	// TODO: Better message
 		return -1;
 	}
-	return Threads_SetGID(Errno, a0);
+	return Threads_SetGID(a0);
 );
 
-SYSCALL1(Syscall_Fork, "d", int *,
+SYSCALL0(Syscall_GetTID, return Threads_GetTID());
+SYSCALL0(Syscall_GetPID, return Threads_GetPID());
+SYSCALL0(Syscall_GetUID, return Threads_GetUID());
+SYSCALL0(Syscall_GetGID, return Threads_GetGID());
+
+SYSCALL1(Syscall_AN_Fork, "d", int *,
 	if(Sizes[0] < sizeof(int))
 		return -1;
 	*a0 = Threads_Fork();
 	return *a0;
 );
 
+SYSCALL3(Syscall_AN_Spawn, "ddd", int *, int *, void *,
+	if(Sizes[0] < sizeof(int))
+		return -1;
+	*a0 = Threads_Spawn(Sizes[1] / sizeof(int), a1, a2);
+	return *a0;
+);
+
+SYSCALL2(Syscall_SendMessage, "id", int, void *,
+	return Proc_SendMessage(a0, Sizes[1], a1);
+);
+
+SYSCALL2(Syscall_GetMessage, "dd", uint32_t *, void *,
+	if( a0 && Sizes[0] < sizeof(*a0) ) {
+		Log_Notice("Syscalls", "Syscall_GetMessage - Arg 1 Undersize (%i < %i)",
+			Sizes[0], sizeof(*a0));
+		return -1;
+	}
+	Uint	tmp;
+	 int	rv;
+	if( a0 ) {
+		rv = Proc_GetMessage(&tmp, Sizes[1], a1);
+		*a0 = tmp;
+	}
+	else
+		rv = Proc_GetMessage(NULL, Sizes[1], a1);
+	return rv;
+);
+
+SYSCALL1(Syscall_WaitEvent, "i", int,
+	return Threads_WaitEvents(a0);
+);
+
 const tSyscallHandler	caSyscalls[] = {
 	Syscall_Null,
 	Syscall_Exit,
@@ -183,12 +257,19 @@ const tSyscallHandler	caSyscalls[] = {
 	Syscall_SetUID,
 	Syscall_SetGID,
 	
+	Syscall_GetTID,
+	Syscall_GetPID,
+	Syscall_GetUID,
+	Syscall_GetGID,
+
 	Syscall_Sleep,
-	Syscall_Fork,
+	Syscall_AN_Fork,
+	Syscall_AN_Spawn,
 
-	NULL,
-	NULL,
-	Syscall_select
+	Syscall_SendMessage,
+	Syscall_GetMessage,
+	Syscall_select,
+	Syscall_WaitEvent
 };
 const int	ciNumSyscalls = sizeof(caSyscalls)/sizeof(caSyscalls[0]);
 /**
@@ -201,12 +282,15 @@ tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength)
 	 int	argListLen = 0;
 	 int	i, retVal;
 	tRequestHeader	*ret;
-	 int	retValueCount = 1;
-	 int	retDataLen = sizeof(Uint64);
+	 int	retValueCount;
+	 int	retDataLen;
 	void	*returnData[Request->NParams];
 	 int	argSizes[Request->NParams];
 	Uint	ret_errno = 0;
 	
+	// Clear errno (Acess verson) at the start of the request
+	errno = 0;
+	
 	// Sanity check
 	if( Request->CallID >= ciNumSyscalls ) {
 		Log_Notice("Syscalls", "Unknown syscall number %i", Request->CallID);
@@ -217,7 +301,11 @@ tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength)
 		Log_Notice("Syscalls", "Unimplemented syscall %i", Request->CallID);
 		return NULL;
 	}
-	
+
+	// Init return count/size
+	retValueCount = 2;
+	retDataLen = sizeof(Uint64) + sizeof(Uint32);	
+
 	// Get size of argument list
 	for( i = 0; i < Request->NParams; i ++ )
 	{
@@ -238,12 +326,19 @@ tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength)
 		case ARG_TYPE_DATA:
 			formatString[i] = 'd';
 			argListLen += sizeof(void*);
+			// Prepare the return values
+			if( Request->Params[i].Flags & ARG_FLAG_RETURN )
+			{
+				retDataLen += Request->Params[i].Length;
+				retValueCount ++;
+			}
 			break;
 		case ARG_TYPE_STRING:
 			formatString[i] = 's';
 			argListLen += sizeof(char*);
 			break;
 		default:
+			Log_Error("Syscalls", "Unknown param type %i", Request->Params[i].Type);
 			return NULL;	// ERROR!
 		}
 	}
@@ -263,19 +358,19 @@ tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength)
 			case ARG_TYPE_VOID:
 				break;
 			case ARG_TYPE_INT32:
-				LOG("Syscalls", "%i INT32: 0x%x", i, *(Uint32*)inData);
+				//LOG("%i INT32: 0x%x", i, *(Uint32*)inData);
 				*(Uint32*)&argListData[argListLen] = *(Uint32*)inData;
 				argListLen += sizeof(Uint32);
 				inData += sizeof(Uint32);
 				break;
 			case ARG_TYPE_INT64:
-				LOG("Syscalls", "%i INT64: 0x%llx", i, *(Uint64*)inData);
+				//LOG("%i INT64: 0x%llx", i, *(Uint64*)inData);
 				*(Uint64*)&argListData[argListLen] = *(Uint64*)inData;
 				argListLen += sizeof(Uint64);
 				inData += sizeof(Uint64);
 				break;
 			case ARG_TYPE_STRING:
-				LOG("Syscalls", "%i STR: '%s'", i, (char*)inData);
+				//LOG("%i STR: '%s'", i, (char*)inData);
 				*(char**)&argListData[argListLen] = (char*)inData;
 				argListLen += sizeof(void*);
 				inData += Request->Params[i].Length;
@@ -284,28 +379,27 @@ tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength)
 			// Data gets special handling, because only it can be returned to the user
 			// (ARG_TYPE_DATA is a pointer)
 			case ARG_TYPE_DATA:
-				// Prepare the return values
-				if( Request->Params[i].Flags & ARG_FLAG_RETURN )
+				// Check for non-resident data
+				if( Request->Params[i].Length == 0 )
 				{
-					retDataLen += Request->Params[i].Length;
-					retValueCount ++;
+					returnData[i] = NULL;
+					*(void**)&argListData[argListLen] = NULL;
+					argListLen += sizeof(void*);
 				}
-				
-				// Check for non-resident data
-				if( Request->Params[i].Flags & ARG_FLAG_ZEROED )
+				else if( Request->Params[i].Flags & ARG_FLAG_ZEROED )
 				{
 					// Allocate and zero the buffer
 					returnData[i] = calloc(1, Request->Params[i].Length);
-					LOG("Syscalls", "%i ZDAT: %i %p", i,
-						Request->Params[i].Length, returnData[i]);
+					//LOG("%i ZDAT: %i %p", i,
+					//	Request->Params[i].Length, returnData[i]);
 					*(void**)&argListData[argListLen] = returnData[i];
 					argListLen += sizeof(void*);
 				}
 				else
 				{
 					returnData[i] = (void*)inData;
-					LOG("Syscalls", "%i DATA: %i %p", i,
-						Request->Params[i].Length, returnData[i]);
+					//LOG("%i DATA: %i %p", i,
+					//	Request->Params[i].Length, returnData[i]);
 					*(void**)&argListData[argListLen] = (void*)inData;
 					argListLen += sizeof(void*);
 					inData += Request->Params[i].Length;
@@ -314,15 +408,24 @@ tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength)
 			}
 		}
 		
+		// --- Perform request
 		retVal = caSyscalls[Request->CallID](&ret_errno, formatString, argListData, argSizes);
 	}
 	
+	// ---------- Return
+	
+	if( ret_errno == 0 && errno != 0 ) {
+		ret_errno = errno;
+		LOG("errno = %i", errno);
+	}
+	
 	// Allocate the return
-	ret = malloc(sizeof(tRequestHeader) + retValueCount * sizeof(tRequestValue)
-		+ retDataLen);
+	size_t	msglen = sizeof(tRequestHeader) + retValueCount * sizeof(tRequestValue) + retDataLen;
+	ret = malloc(msglen);
 	ret->ClientID = Request->ClientID;
 	ret->CallID = Request->CallID;
 	ret->NParams = retValueCount;
+	ret->MessageLength = msglen;
 	inData = (char*)&ret->Params[ ret->NParams ];
 	
 	// Static Uint64 return value
@@ -332,9 +435,18 @@ tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength)
 	*(Uint64*)inData = retVal;
 	inData += sizeof(Uint64);
 	
-	Log_Debug("Syscalls", "Return 0x%llx", retVal);
+	// Static Uint32 errno value
+	ret->Params[1].Type = ARG_TYPE_INT32;
+	ret->Params[1].Flags = 0;
+	ret->Params[1].Length = sizeof(Uint32);
+	*(Uint32*)inData = ret_errno;
+	inData += sizeof(Uint32);
+
+	LOG("Ret: %llx, errno=%i", retVal, ret_errno);	
+
+	//Log_Debug("Syscalls", "Return 0x%llx", retVal);
 	
-	retValueCount = 1;
+	retValueCount = 2;
 	for( i = 0; i < Request->NParams; i ++ )
 	{
 		if( Request->Params[i].Type != ARG_TYPE_DATA )	continue;
@@ -344,7 +456,7 @@ tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength)
 		ret->Params[retValueCount].Flags = 0;
 		ret->Params[retValueCount].Length = Request->Params[i].Length;
 		
-		LOG("Syscalls", "Ret %i: Type %i, Len %i",
+		LOG("Ret %i: Type %i, Len %i",
 			i, Request->Params[i].Type, Request->Params[i].Length);
 		
 		memcpy(inData, returnData[i], Request->Params[i].Length);
@@ -355,9 +467,7 @@ tRequestHeader *SyscallRecieve(tRequestHeader *Request, int *ReturnLength)
 		retValueCount ++;
 	}
 	
-	*ReturnLength = sizeof(tRequestHeader)
-		+ retValueCount * sizeof(tRequestValue)
-		+ retDataLen;
+	*ReturnLength = ret->MessageLength;
 	
 	return ret;
 }