stat/fstat/lstat/realpath

Author: maxdev1

kernel/src/kernel/calls/syscall.cpp

@@ -146,6 +146,7 @@ void syscallRegisterAll()
 	_syscallRegister(G_SYSCALL_FS_READ_DIRECTORY, (g_syscall_handler) syscallFsReadDirectory, true);
 	_syscallRegister(G_SYSCALL_FS_CLOSE_DIRECTORY, (g_syscall_handler) syscallFsCloseDirectory, true);
 	_syscallRegister(G_SYSCALL_OPEN_IRQ_DEVICE, (g_syscall_handler) syscallOpenIrqDevice, true);
+	_syscallRegister(G_SYSCALL_FS_REAL_PATH, (g_syscall_handler) syscallFsRealPath, true);
 
 	// System
 	_syscallRegister(G_SYSCALL_LOG, (g_syscall_handler) syscallLog);

kernel/src/kernel/calls/syscall_filesystem.cpp

@@ -95,16 +95,6 @@ void syscallFsTell(g_task* task, g_syscall_fs_tell* data)
 	data->status = G_FS_TELL_SUCCESSFUL;
 }
 
-void syscallFsStat(g_task* task, g_syscall_fs_stat* data)
-{
-	logInfo("%! stat not implemented", "syscall");
-}
-
-void syscallFsFstat(g_task* task, g_syscall_fs_fstat* data)
-{
-	logInfo("%! fstat not implemented", "syscall");
-}
-
 void syscallFsPipe(g_task* task, g_syscall_fs_pipe* data)
 {
 	g_fs_node* pipeNode;
@@ -186,11 +176,11 @@ void syscallFsOpenDirectory(g_task* task, g_syscall_fs_open_directory* data)
 	auto findRes = filesystemFind(nullptr, data->path);
 	if(findRes.status == G_FS_OPEN_SUCCESSFUL)
 	{
-		data->status = filesystemOpenDirectory(findRes.file);
+		data->status = filesystemOpenDirectory(findRes.node);
 
 		if(data->status == G_FS_OPEN_DIRECTORY_SUCCESSFUL)
 		{
-			data->iterator->node_id = findRes.file->id;
+			data->iterator->node_id = findRes.node->id;
 			data->iterator->position = 0;
 		}
 	}
@@ -228,5 +218,20 @@ void syscallFsReadDirectory(g_task* task, g_syscall_fs_read_directory* data)
 
 void syscallFsCloseDirectory(g_task* task, g_syscall_fs_close_directory* data)
 {
-	// TODO: Is this needed?
+	// TODO
+}
+
+void syscallFsRealPath(g_task* task, g_syscall_fs_real_path* data)
+{
+	data->status = filesystemRealPath(task, data->in, data->out);
+}
+
+void syscallFsStat(g_task* task, g_syscall_fs_stat* data)
+{
+	data->status = filesystemStat(task, data->path, data->out);
+}
+
+void syscallFsFstat(g_task* task, g_syscall_fs_fstat* data)
+{
+	data->status = filesystemFstat(task, data->fd, data->out);
 }

kernel/src/kernel/calls/syscall_filesystem.hpp

@@ -54,4 +54,6 @@ void syscallFsReadDirectory(g_task* task, g_syscall_fs_read_directory* data);
 
 void syscallFsCloseDirectory(g_task* task, g_syscall_fs_close_directory* data);
 
+void syscallFsRealPath(g_task* task, g_syscall_fs_real_path* data);
+
 #endif

kernel/src/kernel/calls/syscall_tasking.cpp

@@ -235,17 +235,18 @@ void syscallSetWorkingDirectory(g_task* task, g_syscall_set_working_directory* d
 	auto findRes = filesystemFind(nullptr, data->path);
 	if(findRes.status == G_FS_OPEN_SUCCESSFUL)
 	{
-		if(findRes.file->type == G_FS_NODE_TYPE_FOLDER || findRes.file->type == G_FS_NODE_TYPE_MOUNTPOINT || findRes.
-		   file->type == G_FS_NODE_TYPE_ROOT)
+		if(findRes.node->type == G_FS_NODE_TYPE_FOLDER ||
+		   findRes.node->type == G_FS_NODE_TYPE_MOUNTPOINT ||
+		   findRes.node->type == G_FS_NODE_TYPE_ROOT)
 		{
 			if(task->process->environment.workingDirectory)
 			{
 				heapFree(task->process->environment.workingDirectory);
 			}
 
-			int length = filesystemGetAbsolutePathLength(findRes.file);
+			int length = filesystemGetAbsolutePathLength(findRes.node);
 			task->process->environment.workingDirectory = (char*) heapAllocate(length + 1);
-			filesystemGetAbsolutePath(findRes.file, task->process->environment.workingDirectory);
+			filesystemGetAbsolutePath(findRes.node, task->process->environment.workingDirectory);
 			data->result = G_SET_WORKING_DIRECTORY_SUCCESSFUL;
 		}
 		else

kernel/src/kernel/filesystem/filesystem.cpp

@@ -41,6 +41,8 @@ static g_mutex filesystemNextNodeIdLock;
 
 static g_hashmap<g_fs_virt_id, g_fs_node*>* filesystemNodes;
 
+g_fs_open_status _filesystemChooseOrigin(const char* path, g_task* task, g_fs_node*& origin);
+
 void filesystemInitialize()
 {
 	mutexInitializeTask(&filesystemNextNodeIdLock, __func__);
@@ -269,50 +271,37 @@ g_filesystem_find_result filesystemFind(g_fs_node* parent, const char* path)
 
 	return {
 			status: status,
-			file: node,
+			node: node,
 			foundAllButLast: ((nameEnd - nameStart) > 0),
-			lastFoundNode: lastFoundParent,
+			lastFoundParent: lastFoundParent,
 			fileNameStart: nameStart
 	};
 }
 
 g_fs_open_status filesystemOpen(const char* path, g_file_flag_mode flags, g_task* task, g_fd* outFd)
 {
-	// Decide for relative path origin
-	g_fs_node* origin = nullptr;
-	if(path[0] != '/')
-	{
-		const char* cwd = task->process->environment.workingDirectory;
-		if(cwd == nullptr)
-			cwd = "/";
-
-		auto findCwdRes = filesystemFind(0, cwd);
-		if(findCwdRes.status == G_FS_OPEN_SUCCESSFUL)
-			origin = findCwdRes.file;
-		else
-			return findCwdRes.status;
-	}
-
-	if(!origin)
-		origin = filesystemGetRoot();
+	g_fs_node* origin;
+	g_fs_open_status findOriginStatus = _filesystemChooseOrigin(path, task, origin);
+	if(findOriginStatus != G_FS_OPEN_SUCCESSFUL)
+		return findOriginStatus;
 
 	// Try to find existing node
 	auto findRes = filesystemFind(origin, path);
 
 	// Handle different open cases
 	if(findRes.status == G_FS_OPEN_SUCCESSFUL)
 	{
-		if(findRes.file->type == G_FS_NODE_TYPE_FOLDER)
+		if(findRes.node->type == G_FS_NODE_TYPE_FOLDER)
 		{
 			logInfo("%! tried to open folder", "fs");
 			return G_FS_OPEN_ERROR;
 		}
 
 		if(flags & G_FILE_FLAG_MODE_TRUNCATE)
 		{
-			if(filesystemTruncate(findRes.file) != G_FS_OPEN_SUCCESSFUL)
+			if(filesystemTruncate(findRes.node) != G_FS_OPEN_SUCCESSFUL)
 			{
-				logInfo("%! failed to truncate file %i", "fs", findRes.file->id);
+				logInfo("%! failed to truncate file %i", "fs", findRes.node->id);
 				return G_FS_OPEN_ERROR;
 			}
 		}
@@ -327,7 +316,7 @@ g_fs_open_status filesystemOpen(const char* path, g_file_flag_mode flags, g_task
 				        origin->id);
 				return G_FS_OPEN_ERROR;
 			}
-			else if(filesystemCreateFile(findRes.lastFoundNode, findRes.fileNameStart, &findRes.file) !=
+			else if(filesystemCreateFile(findRes.lastFoundParent, findRes.fileNameStart, &findRes.node) !=
 			        G_FS_OPEN_SUCCESSFUL)
 			{
 				logInfo("%! failed to create file '%s' in parent %i", "fs", path, origin->id);
@@ -345,7 +334,7 @@ g_fs_open_status filesystemOpen(const char* path, g_file_flag_mode flags, g_task
 	}
 
 	// Actually open the file
-	return filesystemOpenNodeFd(findRes.file, flags, task->process->id, outFd);
+	return filesystemOpenNodeFd(findRes.node, flags, task->process->id, outFd);
 }
 
 g_fs_open_status filesystemOpenNode(g_fs_node* file, g_file_flag_mode flags, g_pid process,
@@ -809,3 +798,95 @@ bool filesystemGetFileName(g_fd fd, const char** outName)
 	*outName = node->name;
 	return true;
 }
+
+g_fs_real_path_status filesystemRealPath(g_task* task, const char* in, char* out)
+{
+	g_fs_node* origin;
+	auto findOriginStatus = _filesystemChooseOrigin(in, task, origin);
+	if(findOriginStatus != G_FS_OPEN_SUCCESSFUL)
+		return findOriginStatus;
+
+	auto findResult = filesystemFind(origin, in);
+	if(findResult.status == G_FS_OPEN_NOT_FOUND)
+		return G_FS_REAL_PATH_NOT_FOUND;
+	if(findResult.status != G_FS_OPEN_SUCCESSFUL)
+		return G_FS_REAL_PATH_ERROR;
+
+	filesystemGetAbsolutePath(findResult.node, out);
+	return G_FS_REAL_PATH_SUCCESS;
+}
+
+
+g_fs_open_status _filesystemChooseOrigin(const char* path, g_task* task, g_fs_node*& origin)
+{
+	if(path[0] == '/')
+	{
+		origin = filesystemGetRoot();
+	}
+	else
+	{
+		const char* cwd = task->process->environment.workingDirectory;
+		if(cwd == nullptr)
+			cwd = "/";
+
+		origin = nullptr;
+		auto findCwdRes = filesystemFind(nullptr, cwd);
+		if(findCwdRes.status == G_FS_OPEN_SUCCESSFUL)
+			origin = findCwdRes.node;
+		else
+			return findCwdRes.status;
+	}
+
+	return G_FS_OPEN_SUCCESSFUL;
+}
+
+g_fs_stat_status filesystemStat(g_task* task, const char* path, g_fs_stat_data* out)
+{
+
+	g_fs_node* origin;
+	g_fs_open_status findOriginStatus = _filesystemChooseOrigin(path, task, origin);
+	if(findOriginStatus != G_FS_OPEN_SUCCESSFUL)
+		return findOriginStatus;
+
+	auto findRes = filesystemFind(origin, path);
+	if(findRes.status == G_FS_OPEN_NOT_FOUND)
+		return G_FS_STAT_NOT_FOUND;
+	if(findRes.status != G_FS_OPEN_SUCCESSFUL)
+		return G_FS_STAT_ERROR;
+
+	return filesystemStatNode(findRes.node, out);
+}
+
+g_fs_stat_status filesystemFstat(g_task* task, g_fd fd, g_fs_stat_data* out)
+{
+	g_file_descriptor* descriptor = filesystemProcessGetDescriptor(task->process->id, fd);
+	if(!descriptor)
+		return G_FS_STAT_INVALID_FD;
+
+	g_fs_node* node = filesystemGetNode(descriptor->nodeId);
+	if(!node)
+		return G_FS_STAT_INVALID_FD;
+
+	return filesystemStatNode(node, out);
+}
+
+g_fs_stat_status filesystemStatNode(g_fs_node* node, g_fs_stat_data* out)
+{
+	out->virtual_id = node->id;
+	out->type = node->type;
+
+	auto lengthStatus = filesystemGetLength(node, &out->size);
+	if(lengthStatus != G_FS_LENGTH_SUCCESSFUL)
+	{
+		logInfo("%! failed to stat file %i with get-length error %i", "filesystem", node->id, lengthStatus);
+		out->size = -1;
+	}
+
+	// TODO
+	out->device = -1;
+	out->time_last_access = 0;
+	out->time_last_modification = 0;
+	out->time_creation = 0;
+
+	return G_FS_STAT_SUCCESS;
+}

kernel/src/kernel/filesystem/filesystem.hpp

@@ -90,10 +90,10 @@ struct g_fs_delegate
 struct g_filesystem_find_result
 {
     g_fs_open_status status;
-    g_fs_node* file;
+    g_fs_node* node;
 
     bool foundAllButLast;
-    g_fs_node* lastFoundNode;
+    g_fs_node* lastFoundParent;
     const char* fileNameStart;
 };
 
@@ -248,4 +248,16 @@ g_fs_read_directory_status filesystemReadDirectory(g_fs_node* parent, uint32_t i
  */
 bool filesystemReadToMemory(g_fd fd, size_t offset, uint8_t* buffer, uint64_t len);
 
+/**
+ * Attempts to retrieve the real path of a path in the filesystem.
+ */
+g_fs_real_path_status filesystemRealPath(g_task* task, const char* in, char* out);
+
+/**
+ * Retrieves stats of a path, file descriptor or node.
+ */
+g_fs_stat_status filesystemStat(g_task* task, const char* path, g_fs_stat_data* out);
+g_fs_stat_status filesystemFstat(g_task* task, g_fd fd, g_fs_stat_data* out);
+g_fs_stat_status filesystemStatNode(g_fs_node* node, g_fs_stat_data* out);
+
 #endif

kernel/src/kernel/tasking/elf/elf_object.cpp

@@ -509,7 +509,7 @@ g_fd elfObjectOpenDependency(const char* name)
 	}
 
 	g_fd fd;
-	g_fs_open_status openStatus = filesystemOpenNodeFd(findRes.file, G_FILE_FLAG_MODE_BINARY | G_FILE_FLAG_MODE_READ, taskingGetCurrentTask()->process->id, &fd);
+	g_fs_open_status openStatus = filesystemOpenNodeFd(findRes.node, G_FILE_FLAG_MODE_BINARY | G_FILE_FLAG_MODE_READ, taskingGetCurrentTask()->process->id, &fd);
 	if(openStatus != G_FS_OPEN_SUCCESSFUL)
 	{
 		logInfo("%! unable to open dependency %s", "elf", absolutePath);

libapi/inc/ghost/filesystem.h

@@ -23,7 +23,6 @@
 
 #include "common.h"
 #include "filesystem/types.h"
-#include "tasks.h"
 #include "memory.h"
 
 __BEGIN_C
@@ -312,6 +311,41 @@ g_fd g_clone_fd_ts(g_fd source_fd, g_pid source_process, g_fd target_fd, g_pid t
  */
 g_open_irq_device_status g_open_irq_device(uint8_t irq, g_fd* outFd);
 
+/**
+ * Resolves the path and returns the real path.
+ *
+ * @param in the input path
+ * @param out pointer to a buffer where the real path is written
+ * @return operation status
+ *
+ * @security-level APPLICATION
+ */
+g_fs_real_path_status g_real_path(const char* in, char* out);
+
+/**
+ * Retrieve stats of a node.
+ *
+ * @param path input path
+ * @param out structure for the stat data
+ * @param-opt follow_symlinks whether to follow symbolic links
+ * @return whether the operation was successful
+ *
+ * @security-level APPLICATION
+ */
+g_fs_stat_status g_fs_stat(const char* path, g_fs_stat_data* out);
+g_fs_stat_status g_fs_stat_l(const char* path, g_fs_stat_data* out, g_bool follow_symlinks);
+
+/**
+ * Retrieve stats of a node behind a file descriptor.
+ *
+ * @param fd file descriptor
+ * @param out structure for the stat data
+ * @return whether the operation was successful
+ *
+ * @security-level APPLICATION
+ */
+g_fs_stat_status g_fs_fstat(g_fd fd, g_fs_stat_data* out);
+
 __END_C
 
 #endif