mirror of
https://github.com/Mathewnd/Astral.git
synced 2026-10-27 20:58:22 +00:00
Matheus
126 lines
3.0 KiB
C
126 lines
3.0 KiB
C
#include <kernel/syscalls.h>
|
|
#include <kernel/abi.h>
|
|
#include <errno.h>
|
|
#include <kernel/mm.h>
|
|
#include <logging.h>
|
|
|
|
#define PROT_READ 0x01
|
|
#define PROT_WRITE 0x02
|
|
#define PROT_EXEC 0x04
|
|
|
|
#define MAP_SHARED 0x01
|
|
#define MAP_PRIVATE 0x02
|
|
#define MAP_FIXED 0x10
|
|
#define MAP_ANON 0x20
|
|
#define MAP_FIXED_NOREPLACE 0x100000
|
|
#define MAP_ANONYMOUS MAP_ANON
|
|
#define MAP_NORESERVE 0x4000
|
|
|
|
#define KNOWN_PROT (PROT_READ | PROT_WRITE | PROT_EXEC)
|
|
#define KNOWN_FLAGS (MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS | MAP_NORESERVE | MAP_FIXED_NOREPLACE)
|
|
|
|
syscallret_t syscall_mmap(context_t *context, void *hint, size_t len, int prot, int flags, int fd, off_t offset) {
|
|
syscallret_t ret = {
|
|
.errno = 0,
|
|
.ret = -1
|
|
};
|
|
|
|
if ((~KNOWN_FLAGS & flags))
|
|
printf("mmap: unknown flags: %x\n", flags);
|
|
|
|
if ((~KNOWN_PROT & prot)) {
|
|
printf("mmap: bad prot: %x\n", prot);
|
|
ret.errno = EINVAL;
|
|
return ret;
|
|
}
|
|
|
|
if (!IS_USER_ADDRESS(hint)) {
|
|
ret.errno = EINVAL;
|
|
return ret;
|
|
}
|
|
|
|
if ((flags & MAP_PRIVATE) && (flags & MAP_SHARED)) {
|
|
ret.errno = EINVAL;
|
|
return ret;
|
|
}
|
|
|
|
// check alignment
|
|
if (len == 0 || (uintptr_t)hint % PAGE_SIZE) {
|
|
ret.errno = EINVAL;
|
|
return ret;
|
|
}
|
|
|
|
mmuflags_t mmuflags = ARCH_MMU_FLAGS_USER | ARCH_MMU_REQUIRED_FLAGS;
|
|
if (prot & PROT_READ)
|
|
mmuflags |= ARCH_MMU_FLAGS_READ;
|
|
if (prot & PROT_WRITE)
|
|
mmuflags |= ARCH_MMU_FLAGS_WRITE;
|
|
if ((prot & PROT_EXEC) == 0)
|
|
mmuflags |= ARCH_MMU_FLAGS_NOEXEC;
|
|
|
|
bool isfile = (flags & MAP_ANONYMOUS) == 0;
|
|
int mm_flags = 0;
|
|
|
|
if (flags & MAP_FIXED)
|
|
mm_flags |= MM_RANGE_FLAGS_REPLACE;
|
|
|
|
if (flags & MAP_FIXED_NOREPLACE)
|
|
mm_flags |= MM_RANGE_FLAGS_EXACT;
|
|
|
|
if ((flags & MAP_ANONYMOUS) == 0)
|
|
mm_flags |= MM_RANGE_FLAGS_FILE;
|
|
|
|
if (flags & MAP_SHARED)
|
|
mm_flags |= MM_RANGE_FLAGS_SHARED;
|
|
|
|
mm_map_file_desc_t vfd;
|
|
file_t *file = NULL;
|
|
if (isfile) {
|
|
// make sure offset is page aligned
|
|
if (offset % PAGE_SIZE) {
|
|
ret.errno = EINVAL;
|
|
return ret;
|
|
}
|
|
|
|
file = fd_get(fd);
|
|
if (file == NULL) {
|
|
ret.errno = EBADF;
|
|
return ret;
|
|
}
|
|
|
|
// check if the file is of a type that can be mapped
|
|
// and if the fd was opened with the required permissions
|
|
int type = file->vnode->type;
|
|
if ((type != V_TYPE_REGULAR && type != V_TYPE_BLKDEV && type != V_TYPE_CHDEV)
|
|
|| ((prot & PROT_READ) && (file->flags & FILE_READ) == 0)
|
|
|| ((flags & MAP_SHARED) && (prot & PROT_WRITE) && (file->flags & FILE_WRITE) == 0)) {
|
|
ret.errno = EACCES;
|
|
goto cleanup;
|
|
}
|
|
|
|
// if the vnode is not cacheable, we need to make sure we can map it
|
|
// TODO move this check to mm_map once the return value of mmap is fixed to return an errno
|
|
if (vfs_iscacheable(file->vnode) == false) {
|
|
ret.errno = VOP_MMAP(file->vnode, VOP_MMAP_ADDRESS_MMAP_SUPPORTED, 0, 0, NULL);
|
|
if (ret.errno)
|
|
goto cleanup;
|
|
}
|
|
|
|
vfd.node = file->vnode;
|
|
vfd.offset = offset;
|
|
}
|
|
|
|
if (hint < USERSPACE_START)
|
|
hint = USERSPACE_MMAP_START;
|
|
|
|
ret.ret = (uint64_t)mm_map(hint, len, mm_flags, mmuflags, &vfd);
|
|
if (ret.ret == 0)
|
|
ret.errno = ENOMEM;
|
|
|
|
cleanup:
|
|
if (isfile)
|
|
fd_release(file);
|
|
|
|
return ret;
|
|
}
|