Add access, rmdir, chroot and stubs for chmod, chown and fsync (#72)

* Implement access syscall

* Implement empty() function in ramfs

* Route rmdir

* Add rmdir inode operation

* Fixes in do_rmdir implementation

* Rmdir in libcos + cosh

* Format

* Ditch empty() op + fixes

* Unlink should reject trailing slashes

* Trailing slash should always check for directory

* Format

* Remove unnecessary print statement

* Wire up (in libcos) chmod, chown, fsync and chroot

* Make chroot visible always in the patch

* Implement chroot (chdir but changes root?)

* Contain processes to their new root (only if they start within it)

* Add chmod + i_perms field

* Format

* Add chown + i_uid and i_gid fields

* Add fsync (stubbed out)

* Sort vfs declarations and syscall regs

Author: ryuukumar

kernel/include/kernel/fs/ramfs.h

@@ -37,6 +37,8 @@ int symlink (char* target, char* linkname, inode** result, inode* parent);
 int readlink (inode* node, char* buf, size_t bufsz);
 int rename (inode* old_node, inode* old_parent, const char* old_name, inode* new_parent,
 			const char* new_name);
+int rmdir (inode* parent, inode* node);
+int fsync (file* f);
 
 typedef struct {
 	char*  c_name;

kernel/include/kernel/fs/stat.h

@@ -57,7 +57,7 @@ typedef struct {
 #define S_IXUSR	  0000100 /* execute/search permission, owner */
 #define S_IRWXG	  (S_IRGRP | S_IWGRP | S_IXGRP)
 #define S_IRGRP	  0000040 /* read permission, group */
-#define S_IWGRP	  0000020 /* write permission, grougroup */
+#define S_IWGRP	  0000020 /* write permission, group */
 #define S_IXGRP	  0000010 /* execute/search permission, group */
 #define S_IRWXO	  (S_IROTH | S_IWOTH | S_IXOTH)
 #define S_IROTH	  0000004 /* read permission, other */

kernel/include/kernel/fs/vfs.h

@@ -44,6 +44,11 @@
 #define L_DCHK	0x0004
 #define L_NDCHK 0x0008
 
+#define F_OK 0x0000
+#define R_OK 0x0004
+#define W_OK 0x0002
+#define X_OK 0x0001
+
 #define ALIGN_UP(value, alignment) (((value) + (alignment) - 1) & ~((alignment) - 1))
 
 typedef enum { UNDEF, EFILE, DIRECTORY, LINK, CHAR_DEV, PIPE } file_type_t;
@@ -66,6 +71,7 @@ typedef struct {
 	int (*readlink) (inode*, char*, size_t);
 	int (*link) (inode*, char*, inode*);
 	int (*rename) (inode*, inode*, const char*, inode*, const char*);
+	int (*rmdir) (inode*, inode*);
 } inode_operations;
 
 typedef struct {
@@ -77,16 +83,18 @@ typedef struct {
 	int (*getdents) (inode*, file*, void*, size_t);
 	int (*fstat) (inode*, file*, stat*);
 	int (*ioctl) (inode*, file*, uint64_t, uint64_t);
+	int (*fsync) (file*);
 } file_operations;
 
 struct inode {
-	uint64_t		  i_no, i_sz, i_cnt;
+	uint64_t		  i_no, i_sz, i_cnt, i_uid, i_gid;
 	void*			  i_pvt;
 	void*			  i_fsinfo;
 	inode_operations* i_iops;
 	file_operations*  i_fops;
 	file_type_t		  i_type;
 	inode*			  i_parent;
+	uint16_t		  i_perms;
 	union {
 		chardev_info_t* chardev_info;
 		ramfs_info_t*	ramfs_info;
@@ -107,47 +115,58 @@ int	 lookup_inode_by_path (const char* path, inode* proc_root, inode* proc_cwd,
 int	 resolve_parent_and_childname (char* path, inode* proc_root, inode* proc_cwd,
 								   inode** result_parent, char** result_childname);
 
-int do_mkdir (char* dirname, inode** result, inode* parent);
+int do_access (const char* path, uint8_t flags);
 int do_chdir (const char* path);
-int do_getcwd (char* buf, size_t size);
-int do_create (char* filename, inode** result, inode* parent);
-int do_unlink (const char* path);
-int do_rename (const char* old, const char* new);
-
-int do_read (struct file* f, void* buf, size_t size);
-int do_seek (struct file* f, size_t offset, int whence);
-int do_write (struct file* f, void* buf, size_t size);
-int do_open (inode* file, struct file* dest_fd);
+int do_chmod (const char* path, uint16_t mode);
+int do_chown (const char* path, uint64_t uid, uint64_t gid);
+int do_chroot (const char* path);
 int do_close (struct file* fd);
-int do_getdents (struct file* f, void* buf, size_t count);
+int do_create (char* filename, inode** result, inode* parent);
 int do_fstat (struct file* fd, stat* buf);
-int do_lstat (const char* restrict path, stat* restrict buf);
-int do_stat (const char* restrict path, stat* restrict buf);
+int do_fsync (struct file* fd);
+int do_getcwd (char* buf, size_t size);
+int do_getdents (struct file* f, void* buf, size_t count);
 int do_ioctl (struct file* fd, uint64_t req, uint64_t arg);
 int do_link (const char* oldpath, const char* newpath);
-int do_symlink (const char* restrict target, const char* restrict linkpath);
+int do_lstat (const char* restrict path, stat* restrict buf);
+int do_mkdir (char* dirname, inode** result, inode* parent);
+int do_open (inode* file, struct file* dest_fd);
+int do_read (struct file* f, void* buf, size_t size);
 int do_readlink (const char* path, char* buf, size_t bufsz);
+int do_rename (const char* old, const char* new);
+int do_rmdir (const char* path);
+int do_seek (struct file* f, size_t offset, int whence);
+int do_stat (const char* restrict path, stat* restrict buf);
+int do_symlink (const char* restrict target, const char* restrict linkpath);
+int do_unlink (const char* path);
+int do_write (struct file* f, void* buf, size_t size);
 
-uint64_t sys_read (uint64_t fd, uint64_t buf, uint64_t size);
-uint64_t sys_write (uint64_t fd, uint64_t buf, uint64_t size);
-uint64_t sys_seek (uint64_t fd, uint64_t offset, uint64_t whence);
-uint64_t sys_open (uint64_t filename_ptr, uint64_t flags, uint64_t mode);
-uint64_t sys_close (uint64_t fd);
-uint64_t sys_mkdir (uint64_t path, uint64_t mode);
+uint64_t sys_access (uint64_t path, uint64_t mode);
 uint64_t sys_chdir (uint64_t path);
-uint64_t sys_getdents (uint64_t fd, uint64_t buf, uint64_t count);
-uint64_t sys_getcwd (uint64_t buf, uint64_t size);
+uint64_t sys_chmod (uint64_t path, uint64_t mode);
+uint64_t sys_chown (uint64_t path, uint64_t uid, uint64_t gid);
+uint64_t sys_chroot (uint64_t path);
+uint64_t sys_close (uint64_t fd);
+uint64_t sys_dup (uint64_t fd);
+uint64_t sys_dup2 (uint64_t oldfd, uint64_t newfd);
 uint64_t sys_fstat (uint64_t fd, uint64_t buf);
-uint64_t sys_lstat (uint64_t path, uint64_t buf);
-uint64_t sys_stat (uint64_t path, uint64_t buf);
+uint64_t sys_fsync (uint64_t fd);
+uint64_t sys_getcwd (uint64_t buf, uint64_t size);
+uint64_t sys_getdents (uint64_t fd, uint64_t buf, uint64_t count);
 uint64_t sys_ioctl (uint64_t fd, uint64_t req, uint64_t arg);
 uint64_t sys_link (uint64_t oldpath, uint64_t newpath);
-uint64_t sys_unlink (uint64_t path);
-uint64_t sys_symlink (uint64_t target, uint64_t linkpath);
+uint64_t sys_lstat (uint64_t path, uint64_t buf);
+uint64_t sys_mkdir (uint64_t path, uint64_t mode);
+uint64_t sys_open (uint64_t filename_ptr, uint64_t flags, uint64_t mode);
+uint64_t sys_read (uint64_t fd, uint64_t buf, uint64_t size);
 uint64_t sys_readlink (uint64_t path, uint64_t buf, uint64_t bufsz);
-uint64_t sys_dup (uint64_t fd);
-uint64_t sys_dup2 (uint64_t oldfd, uint64_t newfd);
 uint64_t sys_rename (uint64_t old, uint64_t new);
+uint64_t sys_rmdir (uint64_t path);
+uint64_t sys_seek (uint64_t fd, uint64_t offset, uint64_t whence);
+uint64_t sys_stat (uint64_t path, uint64_t buf);
+uint64_t sys_symlink (uint64_t target, uint64_t linkpath);
+uint64_t sys_unlink (uint64_t path);
+uint64_t sys_write (uint64_t fd, uint64_t buf, uint64_t size);
 
 inode* get_absolute_root (void);
 void   init_vfs (inode* absolute_root);

kernel/include/kernel/syscall.h

@@ -46,6 +46,12 @@
 #define SYSCALL_SYS_DUP2	 21
 #define SYSCALL_SYS_PIPE	 22
 #define SYSCALL_SYS_RENAME	 23
+#define SYSCALL_SYS_ACCESS	 24
+#define SYSCALL_SYS_RMDIR	 25
+#define SYSCALL_SYS_CHMOD	 26
+#define SYSCALL_SYS_CHOWN	 27
+#define SYSCALL_SYS_FSYNC	 28
+#define SYSCALL_SYS_CHROOT	 29
 
 /* Memory syscalls */
 
@@ -64,6 +70,12 @@
 #define SYSCALL_SYS_TIMES		 49
 #define SYSCALL_SYS_WAITPID		 50
 
+/* User syscalls */
+
+#define SYSCALL_SYS_GETLOGIN 71
+#define SYSCALL_SYS_SETLOGIN 72
+#define SYSCALL_SYS_GETUID	 73
+
 /* Utility syscalls */
 
 #define SYSCALL_SYS_GETTIMEOFDAY 81

kernel/src/kernel/fs/ramfs/ramfs.c

@@ -33,14 +33,16 @@ static inode_operations i_ops = {.lookup = lookup,
 								 .unlink = unlink,
 								 .symlink = symlink,
 								 .readlink = readlink,
-								 .rename = rename};
+								 .rename = rename,
+								 .rmdir = rmdir};
 static file_operations	f_ops = {.read = read,
 								 .write = write,
 								 .seek = seek,
 								 .open = nullptr,
 								 .close = close,
 								 .getdents = getdents,
-								 .fstat = fstat};
+								 .fstat = fstat,
+								 .fsync = fsync};
 
 int mkdir (char* dirname, inode** result, inode* root) {
 	// requires: guarantee that vfs input is valid
@@ -294,6 +296,22 @@ static void remove_dirent (inode* parent, char* name) {
 	}
 }
 
+static void remove_dirent_by_node (inode* parent, inode* node) {
+	dir_content_t* dir = (dir_content_t*)parent->i_pvt;
+	for (uint64_t i = 0; i < dir->d_count; i++) {
+		if (dir->d_children[i].c_inode == node) {
+			kfree (dir->d_children[i].c_name);
+			dir->d_children[i] = dir->d_children[--dir->d_count];
+			void* tmp = krealloc (dir->d_children, dir->d_count * sizeof (child_t));
+			if (tmp)
+				dir->d_children = tmp;
+			else
+				kmemset (&dir->d_children[dir->d_count], 0, sizeof (child_t));
+			return;
+		}
+	}
+}
+
 static void free_inode (inode* node) {
 	if (node->i_pvt) kfree (node->i_pvt);
 	if (node->i_fsinfo) kfree (node->i_fsinfo);
@@ -359,6 +377,20 @@ int rename (inode* old_node, inode* old_parent, const char* old_name, inode* new
 	return 0;
 }
 
+int rmdir (inode* parent, inode* node) {
+	if (node->i_type != DIRECTORY) return -ENOTDIR;
+	if (((dir_content_t*)node->i_pvt)->d_count > 2) return -ENOTEMPTY;
+
+	remove_dirent_by_node (parent, node);
+	if (--node->i_cnt == 0) free_inode (node);
+	return 0;
+}
+
+int fsync (file* f) {
+	(void)f;
+	return 0;
+}
+
 inode* init_ramfs_root (void) {
 	root_inode = kmalloc (sizeof (inode));
 	kmemset ((void*)root_inode, 0, sizeof (inode));

kernel/src/kernel/fs/vfs/access.c

@@ -0,0 +1,49 @@
+/*
+ * access.c
+ * Copyright (C) 2026  Aditya Kumar
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License as published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program; if
+ * not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <kclib/string.h>
+#include <kernel/error.h>
+#include <kernel/fs/vfs.h>
+#include <kernel/process.h>
+#include <liballoc/liballoc.h>
+
+int do_access (const char* path, uint8_t flags) {
+	(void)flags;
+
+	process* current = get_current_process ();
+	inode*	 result = nullptr;
+
+	int error = lookup_inode_by_path (path, current->p_root, current->p_wd, &result, L_FLNK);
+	if (error) return error;
+
+	bool access_ok = true;
+
+	// TODO: check for permissions, when implemented
+
+	return access_ok;
+}
+
+uint64_t sys_access (uint64_t path, uint64_t flags) {
+	char* path_norm = nullptr;
+
+	int error = path_normalise_from_user ((char*)path, &path_norm);
+	if (error < 0) return error;
+
+	error = do_access (path_norm, (uint8_t)(flags & 0xF));
+
+	kfree ((void*)path_norm);
+	return error;
+}

kernel/src/kernel/fs/vfs/chmod.c

@@ -0,0 +1,41 @@
+/*
+ * chmod.c
+ * Copyright (C) 2026  Aditya Kumar
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License as published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program; if
+ * not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <kernel/error.h>
+#include <kernel/fs/vfs.h>
+#include <kernel/process.h>
+#include <liballoc/liballoc.h>
+
+int do_chmod (const char* path, uint16_t mode) {
+	if (!path) return -EINVAL;
+	inode*	 node = nullptr;
+	process* current = get_current_process ();
+
+	char* norm_path = nullptr;
+	int	  error = path_normalise_from_user (path, &norm_path);
+	if (error < 0) return error;
+	error = lookup_inode_by_path ((char*)norm_path, current->p_root, current->p_wd, &node, L_FLNK);
+	kfree (norm_path);
+	if (error != 0) return error;
+
+	node->i_perms = (node->i_perms & ~07777) | (uint16_t)(mode & 07777);
+
+	return 0;
+}
+
+uint64_t sys_chmod (uint64_t path, uint64_t mode) {
+	return (uint64_t)do_chmod ((const char*)path, mode);
+}

kernel/src/kernel/fs/vfs/chown.c

@@ -0,0 +1,42 @@
+/*
+ * chown.c
+ * Copyright (C) 2026  Aditya Kumar
+ *
+ * This program is free software; you can redistribute it and/or modify it under the terms of the
+ * GNU General Public License as published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with this program; if
+ * not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <kernel/error.h>
+#include <kernel/fs/vfs.h>
+#include <kernel/process.h>
+#include <liballoc/liballoc.h>
+
+int do_chown (const char* path, uint64_t uid, uint64_t gid) {
+	if (!path) return -EINVAL;
+	inode*	 node = nullptr;
+	process* current = get_current_process ();
+
+	char* norm_path = nullptr;
+	int	  error = path_normalise_from_user (path, &norm_path);
+	if (error < 0) return error;
+	error = lookup_inode_by_path ((char*)norm_path, current->p_root, current->p_wd, &node, L_FLNK);
+	kfree (norm_path);
+	if (error != 0) return error;
+
+	node->i_uid = uid;
+	node->i_gid = gid;
+
+	return 0;
+}
+
+uint64_t sys_chown (uint64_t path, uint64_t uid, uint64_t gid) {
+	return (uint64_t)do_chown ((const char*)path, uid, gid);
+}