Astral/kernel-src/sys/syscalls/open.c

#include <kernel/syscalls.h>
#include <kernel/file.h>
#include <kernel/abi.h>
#include <kernel/alloc.h>
#include <errno.h>
#include <logging.h>
#include <kernel/auth.h>

syscallret_t syscall_openat(context_t *context, int dirfd, char *path, int flags, mode_t mode) {
	syscallret_t ret = {
		.ret = -1,
		.errno = -1
	};

	// transform O_RDONLY, O_WRONLY, O_RDWR into FILE_READ and FILE_WRITE
	++flags;

	vnode_t *dirnode = NULL;
	file_t *dirfile = NULL;

	size_t pathsize;
	ret.errno = usercopy_strlen(path, &pathsize);
	if (ret.errno)
		return ret;

	char *pathbuf = alloc(pathsize + 1);
	if (pathbuf == NULL) {
		ret.errno = ENOMEM;
		return ret;
	}

	ret.errno = usercopy_fromuser(pathbuf, path, pathsize);
	if (ret.errno) {
		free(pathbuf);
		return ret;
	}

	ret.errno = dirfd_enter(pathbuf, dirfd, &dirfile, &dirnode);
	if (ret.errno) {
		free(pathbuf);
		return ret;
	}

	retry_open:
	file_t *newfile = NULL;
	vnode_t *vnode = NULL;
	int newfd;
	ret.errno = fd_new(flags & O_CLOEXEC, &newfile, &newfd);
	if (ret.errno)
		goto cleanup;

	ret.errno = vfs_open(dirnode, pathbuf, fileflagstovnodeflags(flags), &vnode);
	if (ret.errno == 0 && (flags & O_CREAT) && (flags & O_EXCL)) {
		// exclusive and file already exists
		ret.errno = EEXIST;
		goto cleanup;
	} else if (ret.errno == ENOENT && (flags & O_CREAT)) {
		// create file
		vattr_t attr = {
			.mode = UMASK(mode),
			.gid = current_thread()->proc->cred.egid,
			.uid = current_thread()->proc->cred.euid
		};

		ret.errno = vfs_create(dirnode, pathbuf, &attr, V_TYPE_REGULAR, &vnode);
		if (ret.errno == EEXIST && (flags & O_EXCL) == 0)
			goto retry_open;
		else if (ret.errno == 0) {
			VOP_UNLOCK(vnode);
		}
	}

	if (ret.errno)
		goto cleanup;

	if ((flags & O_DIRECTORY) && vnode->type != V_TYPE_DIR) {
		ret.errno = ENOTDIR;
		goto cleanup;
	}

	vattr_t attr;
	VOP_LOCK(vnode);

	ret.errno = VOP_GETATTR(vnode, &attr, &current_thread()->proc->cred);

	VOP_UNLOCK(vnode);
	if (ret.errno)
		goto cleanup;

	if (vnode->type == V_TYPE_REGULAR && (flags & O_TRUNC) && (flags & FILE_WRITE)) {
		MUTEX_ACQUIRE(&vnode->size_lock);
		VOP_LOCK(vnode);

		ret.errno = VOP_RESIZE(vnode, 0, &current_thread()->proc->cred);

		VOP_UNLOCK(vnode);
		MUTEX_RELEASE(&vnode->size_lock);
		if (ret.errno)
			goto cleanup;
	}

	// node refcount is already increased by open
	newfile->vnode = vnode;
	newfile->flags = flags;
	newfile->offset = 0;
	newfile->mode = attr.mode;

	ret.errno = 0;
	ret.ret = newfd;

	cleanup:
	if (vnode && ret.errno) {
		vfs_close(vnode, fileflagstovnodeflags(flags));
		VOP_RELEASE(vnode);
	}

	if (newfile && ret.errno)
		__assert(fd_close(newfd) == 0);

	if (pathbuf)
		free(pathbuf);

	if (dirnode)
		dirfd_leave(dirnode, dirfile);

	return ret;
}