repo_name
stringlengths 6
97
| path
stringlengths 3
341
| text
stringlengths 8
1.02M
|
|---|---|---|
willmexe/opuntiaOS | boot/libboot/log/log.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _BOOT_LIBBOOT_LOG_LOG_H
#define _BOOT_LIBBOOT_LOG_LOG_H
#include <libboot/types.h>
typedef int (*uart_put_char_t)(uint8_t ch);
void log_init(uart_put_char_t ur);
int vsnprintf(char* s, size_t n, const char* format, va_list arg);
int vsprintf(char* s, const char* format, va_list arg);
int snprintf(char* s, size_t n, const char* format, ...);
int sprintf(char* s, const char* format, ...);
int log(const char* format, ...);
int log_warn(const char* format, ...);
int log_error(const char* format, ...);
int log_not_formatted(const char* format, ...);
#endif // _BOOT_LIBBOOT_LOG_LOG_H |
willmexe/opuntiaOS | libs/libipc/include/libipc/Decodable.h | #pragma once
#include <cstddef>
template <typename T>
class Decodable {
public:
virtual void decode(const char* buf, size_t& offset) { }
}; |
willmexe/opuntiaOS | kernel/include/mem/vm_alloc.h | <gh_stars>0
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_MEM_VM_ALLOC_H
#define _KERNEL_MEM_VM_ALLOC_H
#include <libkern/libkern.h>
#include <mem/bits/vm.h>
#include <mem/kmemzone.h>
uintptr_t vm_alloc_pdir_paddr();
uintptr_t vm_alloc_ptable_paddr();
uintptr_t vm_alloc_ptables_to_cover_page();
void vm_free_ptables_to_cover_page(uintptr_t addr);
uintptr_t vm_alloc_page_paddr();
void vm_free_page_paddr(uintptr_t addr);
kmemzone_t vm_alloc_mapped_zone(size_t size, size_t alignment);
int vm_free_mapped_zone(kmemzone_t zone);
pdirectory_t* vm_alloc_pdir();
void vm_free_pdir(pdirectory_t* pdir);
#endif // _KERNEL_MEM_VM_ALLOC_H
|
willmexe/opuntiaOS | kernel/include/platform/generic/system.h | #ifdef __i386__
#include <platform/x86/system.h>
#elif __arm__
#include <platform/aarch32/system.h>
#endif |
willmexe/opuntiaOS | kernel/include/libkern/syscall_structs.h | #ifndef _KERNEL_LIBKERN_SYSCALL_STRUCTS_H
#define _KERNEL_LIBKERN_SYSCALL_STRUCTS_H
#include <libkern/bits/fcntl.h>
#include <libkern/bits/sys/ioctls.h>
#include <libkern/bits/sys/mman.h>
#include <libkern/bits/sys/select.h>
#include <libkern/bits/sys/socket.h>
#include <libkern/bits/sys/stat.h>
#include <libkern/bits/sys/utsname.h>
#include <libkern/bits/syscalls.h>
#include <libkern/bits/thread.h>
#endif /* _KERNEL_LIBKERN_SYSCALL_STRUCTS_H */ |
willmexe/opuntiaOS | kernel/include/drivers/x86/display.h | <filename>kernel/include/drivers/x86/display.h
#ifndef _KERNEL_DRIVERS_X86_DISPLAY_H
#define _KERNEL_DRIVERS_X86_DISPLAY_H
#include <libkern/libkern.h>
#include <libkern/types.h>
#include <platform/x86/memmap.h>
#include <platform/x86/port.h>
#define VIDEO_MEMORY (char*)(0xb8000 + BIOS_SETTING_BASE)
#define VIDEO_ADDRESS (char*)(0xb8000 + BIOS_SETTING_BASE)
#define MAX_ROWS 25
#define MAX_COLS 80
#define WHITE_ON_BLACK 0x0f
#define BLACK_ON_WHITE 0xf0
#define RED_ON_BLACK 0x04
#define REG_SCREEN_CTRL 0x3d4
#define REG_SCREEN_DATA 0x3d5
#define TRUE 1
#define FALSE 0
typedef unsigned int u_int;
void print_char(char symbol, unsigned char color, int col, int row);
void ext_print_char(char symbol, unsigned char color, int col, int row, int minus_offset);
void delete_char(unsigned char color, int col, int row, int minus_offset);
void print_string(const char* string, unsigned char color, int col, int row);
void print_hex(uint32_t hex, unsigned char color, int col, int row);
void kprintf(const char* string, ...);
void kprinth(uint32_t hex);
void print_dec(uint32_t dec, unsigned char color, int col, int row);
void kprintd(uint32_t dec);
void clean_screen();
void scroll(unsigned char lines);
char col_in_field(int col);
char row_in_field(int row);
void set_cursor_offset(unsigned short offset);
int get_cursor_offet();
int get_offset(int col, int row);
#endif
|
willmexe/opuntiaOS | libs/libc/socket/socket.c | #include <sys/socket.h>
#include <sysdep.h>
int socket(int domain, int type, int protocol)
{
int res = DO_SYSCALL_3(SYS_SOCKET, domain, type, protocol);
RETURN_WITH_ERRNO(res, res, -1);
}
int bind(int sockfd, const char* name, int len)
{
int res = DO_SYSCALL_3(SYS_BIND, sockfd, name, len);
RETURN_WITH_ERRNO(res, 0, -1);
}
int connect(int sockfd, const char* name, int len)
{
int res = DO_SYSCALL_3(SYS_CONNECT, sockfd, name, len);
RETURN_WITH_ERRNO(res, 0, -1);
} |
willmexe/opuntiaOS | kernel/include/mem/bits/mmu.h | <filename>kernel/include/mem/bits/mmu.h<gh_stars>0
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_MEM_BITS_MMU_H
#define _KERNEL_MEM_BITS_MMU_H
#include <libkern/types.h>
enum MMU_FLAGS {
MMU_FLAG_PERM_WRITE = (1 << 0),
MMU_FLAG_PERM_READ = (1 << 1),
MMU_FLAG_PERM_EXEC = (1 << 2),
MMU_FLAG_UNCACHED = (1 << 3),
MMU_FLAG_NONPRIV = (1 << 4),
MMU_FLAG_INVALID = (1 << 5),
MMU_FLAG_COW = (1 << 6), // TODO: Remove this flag.
MMU_FLAG_DEVICE = MMU_FLAG_PERM_READ | MMU_FLAG_PERM_WRITE | MMU_FLAG_UNCACHED,
};
typedef uint32_t mmu_flags_t;
#endif // _KERNEL_MEM_BITS_MMU_H |
willmexe/opuntiaOS | libs/libc/time/strftime.c | <reponame>willmexe/opuntiaOS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sysdep.h>
#include <time.h>
static const char __wday_snames[7][4] = {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
static const char __wday_lnames[7][11] = {
"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
};
static const char __mon_snames[12][4] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
static const char __mon_lnames[12][11] = {
"January", "February", "March", "April", "May", "June", "July", "Auguest", "September", "October", "November", "December"
};
static inline size_t strftime_append(char* s, size_t remaining, const char* appendee)
{
size_t copy_size = min(remaining, strlen(appendee));
memcpy(s, appendee, copy_size);
return copy_size;
}
size_t strftime(char* s, size_t remaining, const char* format, const tm_t* tm)
{
char buf[32];
const char* p = format;
size_t written = 0;
remaining--;
while (*p) {
if (*p == '%' && *(p + 1)) {
p++;
size_t wr = 0;
switch (*p) {
case 'a':
wr = strftime_append((char*)(s + written), remaining, __wday_snames[tm->tm_wday]);
written += wr;
remaining -= wr;
break;
case 'A':
wr = strftime_append((char*)(s + written), remaining, __wday_lnames[tm->tm_wday]);
written += wr;
remaining -= wr;
break;
case 'R':
if (tm->tm_min < 10) {
snprintf(buf, 32, "%d:0%d", tm->tm_hour, tm->tm_min);
} else {
snprintf(buf, 32, "%d:%d", tm->tm_hour, tm->tm_min);
}
wr = strftime_append((char*)(s + written), remaining, buf);
written += wr;
remaining -= wr;
break;
}
p++;
} else {
if (remaining) {
s[written] = *p;
written++;
remaining--;
}
p++;
}
}
s[written] = '\0';
return written;
} |
willmexe/opuntiaOS | libs/libfoundation/include/libfoundation/helpers/LoggerStreamBuf.h | #include <__std_streambuffer>
namespace LFoundation::Logger {
class StreamBuf : public std::__stdoutbuf<char> {
public:
StreamBuf(FILE* file)
: __stdoutbuf<char>(file)
{
}
~StreamBuf() = default;
};
} // namespace LFoundation::Logger
|
willmexe/opuntiaOS | libs/libc/sysdeps/opuntiaos/generic/shared_buffer.c | #include <opuntia/shared_buffer.h>
#include <sysdep.h>
int shared_buffer_create(uint8_t** buffer, size_t size)
{
int res = DO_SYSCALL_2(SYS_SHBUF_CREATE, buffer, size);
RETURN_WITH_ERRNO(res, res, res);
}
int shared_buffer_get(int id, uint8_t** buffer)
{
int res = DO_SYSCALL_2(SYS_SHBUF_GET, id, buffer);
RETURN_WITH_ERRNO(res, res, res);
}
int shared_buffer_free(int id)
{
int res = DO_SYSCALL_1(SYS_SHBUF_FREE, id);
RETURN_WITH_ERRNO(res, res, res);
}
|
willmexe/opuntiaOS | test/kernel/fs/fourfiles/main.c | <reponame>willmexe/opuntiaOS<filename>test/kernel/fs/fourfiles/main.c
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>
char buf[512];
int main(int argc, char** argv)
{
int fd, pid, i, j, n, total, pi;
char* names[] = { "f0.e", "f1.e", "f2.e", "f3.e" };
char* fname;
int pids[4];
for (pi = 0; pi < 4; pi++) {
fname = names[pi];
unlink(fname);
pid = fork();
pids[pi] = pid;
if (pid < 0) {
TestErr("fork failed");
}
if (pid == 0) {
fd = open(fname, O_CREAT | O_RDWR);
if (fd < 0) {
TestErr("create failed");
}
memset(buf, '0' + pi, 512);
for (i = 0; i < 12; i++) {
if ((n = write(fd, buf, 500)) != 500) {
TestErr("write failed");
}
}
exit(0);
}
}
for (pi = 0; pi < 4; pi++) {
wait(pids[pi]);
}
for (i = 0; i < 4; i++) {
fname = names[i];
fd = open(fname, O_RDONLY);
total = 0;
while ((n = read(fd, buf, sizeof(buf))) > 0) {
for (j = 0; j < n; j++) {
if (buf[j] != '0' + i) {
TestErr("wrong char");
}
}
total += n;
}
close(fd);
if (total != 12 * 500) {
TestErr("wrong length");
}
unlink(fname);
}
return 0;
} |
willmexe/opuntiaOS | kernel/include/libkern/_types/_va_list.h | #ifndef _KERNEL_LIBKERN__TYPES__VA_LIST_H
#define _KERNEL_LIBKERN__TYPES__VA_LIST_H
typedef __builtin_va_list va_list;
#endif // _KERNEL_LIBKERN__TYPES__VA_LIST_H |
willmexe/opuntiaOS | boot/libboot/mem/malloc.h | <gh_stars>0
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _BOOT_LIBBOOT_MEM_MALLOC_H
#define _BOOT_LIBBOOT_MEM_MALLOC_H
#include <libboot/mem/mem.h>
static inline void malloc_init(void* addr, size_t size)
{
extern void* _malloc_next_addr;
extern void* _malloc_end_addr;
_malloc_next_addr = addr;
_malloc_end_addr = _malloc_next_addr + size;
}
// Current implementation is a simple linear allocator.
static void* malloc(size_t size)
{
extern void* _malloc_next_addr;
extern void* _malloc_end_addr;
if (!_malloc_next_addr) {
return NULL;
}
if (_malloc_next_addr >= _malloc_end_addr) {
return NULL;
}
void* res = _malloc_next_addr;
size = align_size(size, sizeof(void*));
_malloc_next_addr += size;
return res;
}
// Current implementation is a simple linear allocator.
static inline void* malloc_aligned(size_t size, size_t alignment)
{
extern void* _malloc_next_addr;
if ((size_t)_malloc_next_addr % alignment) {
malloc(alignment - ((size_t)_malloc_next_addr % alignment));
}
return malloc(size);
}
static inline void free(void* ptr)
{
UNUSED(ptr);
}
#endif // _BOOT_LIBBOOT_MEM_MALLOC_H |
willmexe/opuntiaOS | libs/libc/posix/tasking.c | #include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sysdep.h>
#include <unistd.h>
int fork()
{
int res = DO_SYSCALL_0(SYS_FORK);
RETURN_WITH_ERRNO(res, res, -1);
}
int execve(const char* path, char* const argv[], char* const envp[])
{
int res = DO_SYSCALL_3(SYS_EXECVE, (int)path, (int)argv, (int)envp);
RETURN_WITH_ERRNO(res, -1, -1);
}
int execvpe(const char* path, char* const argv[], char* const envp[])
{
if (strchr(path, '/')) {
return execve(path, argv, envp);
}
char* full_path = malloc(256);
size_t namelen = strlen(path);
char* env_path = getenv("PATH");
if (!env_path) {
// Get it from confstr
env_path = "/bin:/usr/bin";
}
int len = 0;
int cnt = 0;
for (int i = 0; env_path[i]; i += len) {
len = 0;
while (env_path[i + len] && env_path[i + len] != ':') {
len++;
}
memcpy(full_path, &env_path[i], len);
full_path[len] = '/';
memcpy(&full_path[len + 1], path, namelen + 1);
int err = execve(full_path, argv, envp);
if (env_path[i + len] == ':') {
len++;
}
}
free(full_path);
return -ENOENT;
}
int execvp(const char* path, char* const argv[])
{
return execvpe(path, argv, environ);
}
int execlp(const char* path, const char* arg0, ...)
{
const char* args[16];
int nxt = 0;
args[nxt++] = arg0;
va_list va;
va_start(va, arg0);
for (;;) {
const char* arg = va_arg(va, const char*);
if (!arg) {
break;
}
args[nxt++] = arg;
}
va_end(va);
args[nxt++] = NULL;
return execvpe(path, (char* const*)args, environ);
}
int wait(int pid)
{
int res = DO_SYSCALL_3(SYS_WAITPID, pid, NULL, 0);
RETURN_WITH_ERRNO(res, pid, -1);
}
int waitpid(int pid, int* status, int options)
{
int res = DO_SYSCALL_3(SYS_WAITPID, pid, status, options);
RETURN_WITH_ERRNO(res, pid, -1);
}
pid_t getpid()
{
int res = DO_SYSCALL_0(SYS_GETPID);
RETURN_WITH_ERRNO(res, (pid_t)res, -1);
}
int setpgid(pid_t pid, pid_t pgid)
{
int res = DO_SYSCALL_2(SYS_SETPGID, pid, pgid);
RETURN_WITH_ERRNO(res, 0, -1);
}
pid_t getpgid(pid_t pid)
{
int res = DO_SYSCALL_1(SYS_GETPGID, pid);
RETURN_WITH_ERRNO(res, (pid_t)res, -1);
}
uint32_t sleep(uint32_t seconds)
{
uint32_t res = DO_SYSCALL_1(SYS_NANOSLEEP, seconds);
RETURN_WITH_ERRNO(res, seconds, 0);
} |
willmexe/opuntiaOS | kernel/include/platform/generic/tasking/context.h | <reponame>willmexe/opuntiaOS
#ifdef __i386__
#include <platform/x86/tasking/context.h>
#elif __arm__
#include <platform/aarch32/tasking/context.h>
#endif |
willmexe/opuntiaOS | libs/libc/include/sys/wait.h | #ifndef _LIBC_SYS_WAIT_H
#define _LIBC_SYS_WAIT_H
#include <bits/sys/wait.h>
#include <fcntl.h>
#include <stddef.h>
#include <sys/cdefs.h>
#include <sys/types.h>
__BEGIN_DECLS
int wait(int pid);
int waitpid(int pid, int* status, int options);
__END_DECLS
#endif // _LIBC_SYS_WAIT_H |
willmexe/opuntiaOS | kernel/kernel/syscalls/fs.c | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <libkern/bits/errno.h>
#include <libkern/libkern.h>
#include <libkern/log.h>
#include <mem/kmalloc.h>
#include <platform/generic/syscalls/params.h>
#include <syscalls/handlers.h>
#include <syscalls/interruptible_area.h>
#include <tasking/tasking.h>
void sys_open(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
file_descriptor_t* fd = proc_get_free_fd(p);
dentry_t* file;
const char* path = (char*)SYSCALL_VAR1(tf);
char* kpath = 0;
if (!str_validate_len(path, 128)) {
return_with_val(-EINVAL);
}
uint32_t flags = SYSCALL_VAR2(tf);
size_t path_len = strlen(path);
kpath = kmem_bring_to_kernel(path, path_len + 1);
// Only permission flags
mode_t mode = SYSCALL_VAR3(tf) & 0x777;
if (TEST_FLAG(flags, O_CREAT)) {
char* kname = vfs_helper_split_path_with_name(kpath, path_len);
if (!kname) {
kfree(kpath);
return_with_val(-EINVAL);
}
size_t name_len = strlen(kname);
dentry_t* dir;
if (vfs_resolve_path_start_from(p->cwd, kpath, &dir) < 0) {
kfree(kname);
kfree(kpath);
return_with_val(-ENOENT);
}
int err = vfs_create(dir, kname, name_len, mode, p->uid, p->gid);
if (err && TEST_FLAG(flags, O_EXCL)) {
dentry_put(dir);
kfree(kname);
kfree(kpath);
return_with_val(err);
}
vfs_helper_restore_full_path_after_split(kpath, kname);
dentry_put(dir);
kfree(kname);
}
if (vfs_resolve_path_start_from(p->cwd, kpath, &file) < 0) {
return_with_val(-ENOENT);
}
int err = vfs_open(file, fd, flags);
dentry_put(file);
if (err) {
return_with_val(err);
}
return_with_val(proc_get_fd_id(p, fd));
}
void sys_close(trapframe_t* tf)
{
file_descriptor_t* fd = proc_get_fd(RUNNING_THREAD->process, SYSCALL_VAR1(tf));
if (!fd) {
return_with_val(-EBADF);
}
return_with_val(vfs_close(fd));
}
void sys_read(trapframe_t* tf)
{
file_descriptor_t* fd = proc_get_fd(RUNNING_THREAD->process, (int)SYSCALL_VAR1(tf));
if (!fd) {
return_with_val(-EBADF);
}
if (TEST_FLAG(fd->flags, O_DIRECTORY)) {
return_with_val(-EISDIR);
}
if (!TEST_FLAG(fd->flags, O_RDONLY)) {
return_with_val(-EBADF);
}
init_read_blocker(RUNNING_THREAD, fd);
int res = vfs_read(fd, (uint8_t*)SYSCALL_VAR2(tf), (uint32_t)SYSCALL_VAR3(tf));
return_with_val(res);
}
/* TODO: copying to/from user! */
void sys_write(trapframe_t* tf)
{
file_descriptor_t* fd = proc_get_fd(RUNNING_THREAD->process, (int)SYSCALL_VAR1(tf));
if (!fd) {
return_with_val(-EBADF);
}
if (!TEST_FLAG(fd->flags, O_WRONLY)) {
return_with_val(-EBADF);
}
init_write_blocker(RUNNING_THREAD, fd);
int res = vfs_write(fd, (uint8_t*)SYSCALL_VAR2(tf), (uint32_t)SYSCALL_VAR3(tf));
return_with_val(res);
}
void sys_lseek(trapframe_t* tf)
{
file_descriptor_t* fd = proc_get_fd(RUNNING_THREAD->process, (int)SYSCALL_VAR1(tf));
if (!fd) {
return_with_val(-EBADF);
}
int whence = SYSCALL_VAR3(tf);
switch (whence) {
case SEEK_SET:
fd->offset = SYSCALL_VAR2(tf);
break;
case SEEK_CUR:
fd->offset += SYSCALL_VAR2(tf);
break;
case SEEK_END:
fd->offset = fd->dentry->inode->size - SYSCALL_VAR2(tf);
break;
default:
return_with_val(-EINVAL);
}
if (fd->offset >= fd->dentry->inode->size) {
return_with_val(-EOVERFLOW);
}
return_with_val(0);
}
void sys_unlink(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
const char* path = (char*)SYSCALL_VAR1(tf);
char* kpath = 0;
if (!str_validate_len(path, 128)) {
return_with_val(-EINVAL);
}
int name_len = strlen(path);
kpath = kmem_bring_to_kernel(path, name_len + 1);
dentry_t* file;
if (vfs_resolve_path_start_from(p->cwd, kpath, &file) < 0) {
return_with_val(-ENOENT);
}
int ret = vfs_unlink(file);
dentry_put(file);
kfree(kpath);
return_with_val(ret);
}
void sys_creat(trapframe_t* tf)
{
uint32_t tmp_storage_2 = SYSCALL_VAR2(tf);
uint32_t tmp_storage_3 = SYSCALL_VAR3(tf);
SYSCALL_VAR2(tf) = O_CREAT | O_WRONLY | O_TRUNC;
SYSCALL_VAR3(tf) = SYSCALL_VAR2(tf);
sys_open(tf);
uint32_t result = return_val;
SYSCALL_VAR2(tf) = tmp_storage_2;
SYSCALL_VAR3(tf) = tmp_storage_3;
return_with_val(result);
}
void sys_fstat(trapframe_t* tf)
{
file_descriptor_t* fd = proc_get_fd(RUNNING_THREAD->process, (int)SYSCALL_VAR1(tf));
fstat_t* stat = (fstat_t*)SYSCALL_VAR2(tf);
if (!fd) {
return_with_val(-EBADF);
}
if (!stat) {
return_with_val(-EINVAL);
}
int res = vfs_fstat(fd, stat);
return_with_val(res);
}
void sys_fsync(trapframe_t* tf)
{
file_descriptor_t* fd = proc_get_fd(RUNNING_THREAD->process, (int)SYSCALL_VAR1(tf));
dentry_flush(fd->dentry);
return_with_val(0);
}
void sys_mkdir(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
const char* path = (char*)SYSCALL_VAR1(tf);
char* kpath = 0;
if (!str_validate_len(path, 128)) {
return_with_val(-EINVAL);
}
size_t path_len = strlen(path);
kpath = kmem_bring_to_kernel(path, path_len + 1);
char* kname = vfs_helper_split_path_with_name(kpath, path_len);
if (!kname) {
kfree(kpath);
return_with_val(-EINVAL);
}
size_t name_len = strlen(kname);
dentry_t* dir;
if (vfs_resolve_path_start_from(p->cwd, kpath, &dir) < 0) {
kfree(kname);
kfree(kpath);
return_with_val(-ENOENT);
}
mode_t dir_mode = S_IFDIR | S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
int res = vfs_mkdir(dir, kname, name_len, dir_mode, p->uid, p->gid);
kfree(kname);
kfree(kpath);
return_with_val(res);
}
void sys_rmdir(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
const char* path = (char*)SYSCALL_VAR1(tf);
char* kpath = 0;
if (!str_validate_len(path, 128)) {
return_with_val(-EINVAL);
}
int name_len = strlen(path);
kpath = kmem_bring_to_kernel(path, name_len + 1);
dentry_t* dir;
if (vfs_resolve_path_start_from(p->cwd, kpath, &dir) < 0) {
return_with_val(-ENOENT);
}
int res = vfs_rmdir(dir);
dentry_put(dir);
kfree(kpath);
return_with_val(res);
}
void sys_chdir(trapframe_t* tf)
{
/* proc lock */
const char* path = (char*)SYSCALL_VAR1(tf);
return_with_val(proc_chdir(RUNNING_THREAD->process, path));
}
void sys_getcwd(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
char* buf = (char*)SYSCALL_VAR1(tf);
size_t len = (size_t)SYSCALL_VAR2(tf);
int req_len = vfs_get_absolute_path(p->cwd, NULL, 0);
if (len < req_len) {
return_with_val(-EFAULT);
}
char* kbuf = (char*)kmalloc(req_len + 1);
req_len = vfs_get_absolute_path(p->cwd, (char*)kbuf, req_len);
vmm_copy_to_user(buf, kbuf, req_len + 1);
return_with_val(0);
}
void sys_getdents(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
file_descriptor_t* fd = (file_descriptor_t*)proc_get_fd(p, (uint32_t)SYSCALL_VAR1(tf));
int read = vfs_getdents(fd, (uint8_t*)SYSCALL_VAR2(tf), SYSCALL_VAR3(tf));
return_with_val(read);
}
void sys_select(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
file_descriptor_t* fd;
int nfds = SYSCALL_VAR1(tf);
fd_set_t* readfds = (fd_set_t*)SYSCALL_VAR2(tf);
fd_set_t* writefds = (fd_set_t*)SYSCALL_VAR3(tf);
fd_set_t* exceptfds = (fd_set_t*)SYSCALL_VAR4(tf);
timeval_t* timeout = (timeval_t*)SYSCALL_VAR5(tf);
if (nfds < 0 || nfds > FD_SETSIZE) {
return_with_val(-EINVAL);
}
for (int i = 0; i < nfds; i++) {
if ((readfds && FD_ISSET(i, readfds)) || (writefds && FD_ISSET(i, writefds)) || (exceptfds && FD_ISSET(i, exceptfds))) {
if (!proc_get_fd(p, i)) {
return_with_val(-EBADF);
}
}
}
init_select_blocker(RUNNING_THREAD, nfds, readfds, writefds, exceptfds, timeout);
if (readfds) {
FD_ZERO(readfds);
}
if (writefds) {
FD_ZERO(writefds);
}
if (exceptfds) {
FD_ZERO(exceptfds);
}
for (int i = 0; i < nfds; i++) {
fd = proc_get_fd(p, i);
if (readfds && FD_ISSET(i, &(RUNNING_THREAD->blocker_data.select.readfds))) {
if (fd->ops->can_read && fd->ops->can_read(fd->dentry, fd->offset)) {
FD_SET(i, readfds);
}
}
if (writefds && FD_ISSET(i, &(RUNNING_THREAD->blocker_data.select.writefds))) {
if (fd->ops->can_write && fd->ops->can_write(fd->dentry, fd->offset)) {
FD_SET(i, writefds);
}
}
}
return_with_val(0);
}
void sys_mmap(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
mmap_params_t* params = (mmap_params_t*)SYSCALL_VAR1(tf);
bool map_shared = ((params->flags & MAP_SHARED) > 0);
bool map_anonymous = ((params->flags & MAP_ANONYMOUS) > 0);
bool map_private = ((params->flags & MAP_PRIVATE) > 0);
bool map_stack = ((params->flags & MAP_STACK) > 0);
bool map_fixed = ((params->flags & MAP_FIXED) > 0);
bool map_exec = ((params->prot & PROT_EXEC) > 0);
bool map_read = ((params->prot & PROT_READ) > 0);
bool map_write = ((params->prot & PROT_WRITE) > 0);
memzone_t* zone;
if (map_private && map_shared) {
return_with_val(-EINVAL);
}
if (!map_private && !map_shared) {
return_with_val(-EINVAL);
}
if (map_stack) {
zone = memzone_new_random_backward(p, params->size);
} else if (map_anonymous) {
zone = memzone_new_random(p, params->size);
} else {
file_descriptor_t* fd = proc_get_fd(p, params->fd);
/* TODO: Check for read access to the file */
if (!fd) {
return_with_val(-EBADFD);
}
zone = vfs_mmap(fd, params);
}
if (!zone) {
return_with_val(-ENOMEM);
}
zone->type |= ZONE_TYPE_MAPPED;
if (map_read) {
zone->flags |= ZONE_READABLE;
}
if (map_write) {
zone->flags |= ZONE_WRITABLE;
}
if (map_exec) {
zone->flags |= ZONE_EXECUTABLE;
}
return_with_val(zone->start);
}
void sys_munmap(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
void* ptr = (void*)SYSCALL_VAR1(tf);
memzone_t* zone = memzone_find(p, (uint32_t)ptr);
if (!zone) {
return_with_val(-EFAULT);
}
if (!TEST_FLAG(zone->type, ZONE_TYPE_MAPPED)) {
return_with_val(-EPERM);
}
if (TEST_FLAG(zone->type, ZONE_TYPE_MAPPED_FILE_PRIVATLY) || TEST_FLAG(zone->type, ZONE_TYPE_MAPPED_FILE_SHAREDLY)) {
return_with_val(vfs_munmap(p, zone));
}
// TODO: Split or remove zone
return_with_val(0);
}
void sys_dup(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
file_descriptor_t* fd = proc_get_fd(RUNNING_THREAD->process, (int)SYSCALL_VAR1(tf));
if (!fd) {
return_with_val(-EBADF);
}
file_descriptor_t* newfd = proc_get_free_fd(p);
if (!newfd) {
return_with_val(-EBADF);
}
int err = proc_copy_fd(fd, newfd);
ASSERT(!err);
return_with_val(proc_get_fd_id(p, newfd));
}
void sys_dup2(trapframe_t* tf)
{
proc_t* p = RUNNING_THREAD->process;
file_descriptor_t* fd = proc_get_fd(RUNNING_THREAD->process, (int)SYSCALL_VAR1(tf));
if (!fd) {
return_with_val(-EBADF);
}
file_descriptor_t* newfd = proc_get_fd(RUNNING_THREAD->process, (int)SYSCALL_VAR2(tf));
if (!newfd) {
return_with_val(-EBADF);
}
int err = proc_copy_fd(fd, newfd);
ASSERT(!err);
return_with_val(proc_get_fd_id(p, newfd));
} |
willmexe/opuntiaOS | kernel/include/tasking/bits/dump.h | <filename>kernel/include/tasking/bits/dump.h<gh_stars>100-1000
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_TASKING_BITS_DUMP_H
#define _KERNEL_TASKING_BITS_DUMP_H
#include <libkern/types.h>
#include <tasking/proc.h>
typedef int (*dump_saver_t)(const char*);
typedef ssize_t (*sym_resolver_t)(void* symtab, size_t syms_n, uint32_t tp);
struct dump_data {
proc_t* p;
uint32_t entry_point;
void* syms;
size_t symsn;
char* strs;
dump_saver_t writer;
sym_resolver_t sym_resolver;
};
typedef struct dump_data dump_data_t;
#endif // _KERNEL_TASKING_BITS_DUMP_H |
willmexe/opuntiaOS | libs/libc/stdlib/tools.c | <filename>libs/libc/stdlib/tools.c
#include <stdlib.h>
#include <string.h>
int atoi(const char* s)
{
// FIXME: Add overflow checks
int res = 0;
int len = strlen(s);
int mul = 1;
for (int i = 0; i < len; i++) {
mul *= 10;
}
for (int i = 0; i < len; i++) {
mul /= 10;
res += (s[i] - '0') * mul;
}
return res;
} |
willmexe/opuntiaOS | libs/libc/malloc/slab.c | #include "malloc.h"
#include <stdbool.h>
#include <string.h>
#include <sys/mman.h>
// Fast allocator for sizes 16, 32, 48, 64 bytes
malloc_header_t* free_blocks[5];
void prepare_free_blocks(size_t size)
{
int block_id = size >> 4;
const size_t alloc_size = MALLOC_DEFAULT_BLOCK_SIZE;
int ret = (int)mmap(NULL, alloc_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
if (ret < 0) {
free_blocks[block_id] = NULL;
return;
}
void* raw_area = (void*)ret;
const size_t sizeof_block_with_header = size + sizeof(malloc_header_t);
size_t passed = 0;
free_blocks[block_id] = (malloc_header_t*)raw_area;
malloc_header_t* prev_header = NULL;
while (passed + sizeof_block_with_header <= alloc_size) {
malloc_header_t* current = (malloc_header_t*)raw_area;
current->flags = FLAG_SLAB | FLAG_ALLOCATED;
current->next = NULL;
current->prev = prev_header;
current->size = size;
prev_header = current;
raw_area += sizeof_block_with_header;
passed += sizeof_block_with_header;
}
malloc_header_t* next_header = NULL;
while (prev_header) {
prev_header->next = next_header;
prev_header = prev_header->prev;
}
}
void _slab_init()
{
prepare_free_blocks(16);
prepare_free_blocks(32);
prepare_free_blocks(48);
prepare_free_blocks(64);
}
void* slab_alloc(size_t size)
{
if (size > 64) {
return NULL;
}
int block_id = ((size + 15) >> 4);
malloc_header_t* zone = free_blocks[block_id];
if (!zone) {
return NULL;
}
free_blocks[block_id] = zone->next;
return (void*)&((malloc_header_t*)zone)[1];
}
void slab_free(malloc_header_t* mem_header)
{
malloc_header_t* next = free_blocks[((mem_header->size) >> 4)];
free_blocks[((mem_header->size) >> 4)] = mem_header;
mem_header->next = next;
mem_header->prev = NULL;
if (next) {
next->prev = mem_header;
}
} |
willmexe/opuntiaOS | kernel/kernel/drivers/x86/display.c | <filename>kernel/kernel/drivers/x86/display.c
#include <drivers/x86/display.h>
#include <drivers/x86/uart.h>
// prints
void ext_print_char(char symbol, unsigned char color, int col, int row, int minus_offset)
{
char* mem = VIDEO_MEMORY;
unsigned short offset_types[2] = { get_cursor_offet(), get_offset(col, row) };
unsigned short offset = offset_types[(col_in_field(col) && row_in_field(row))] - minus_offset;
if (symbol == '\n') {
offset += MAX_COLS - (offset % MAX_COLS) - 1; // -1 to make it works (offset + 1 further)
} else {
mem[offset * 2] = symbol;
mem[offset * 2 + 1] = color;
}
if (offset + 1 >= MAX_COLS * MAX_ROWS) {
scroll(1); // scroll for 1 line
} else {
set_cursor_offset(offset + 1);
}
}
void delete_char(unsigned char color, int col, int row, int minus_offset)
{
char* mem = VIDEO_MEMORY;
unsigned short offset_types[2] = { get_cursor_offet(), get_offset(col, row) };
unsigned short offset = offset_types[(col_in_field(col) && row_in_field(row))] - minus_offset;
mem[offset * 2] = ' ';
mem[offset * 2 + 1] = color;
set_cursor_offset(offset);
}
void print_char(char symbol, unsigned char color, int col, int row)
{
char* mem = VIDEO_MEMORY;
unsigned short offset_types[2] = { get_cursor_offet(), get_offset(col, row) };
unsigned short offset = offset_types[(col_in_field(col) && row_in_field(row))];
if (symbol == '\n') {
offset += MAX_COLS - (offset % MAX_COLS) - 1; // -1 to make it works (offset + 1 further)
} else {
mem[offset * 2] = symbol;
mem[offset * 2 + 1] = color;
}
if (offset + 1 >= MAX_COLS * MAX_ROWS) {
scroll(1); // scroll for 1 line
} else {
set_cursor_offset(offset + 1);
}
}
void print_string(const char* string, unsigned char color, int col, int row)
{
int i = 0;
while (string[i] != 0) {
print_char(string[i++], color, col, row);
col = row = -1;
}
}
void print_hex(uint32_t hex, unsigned char color, int col, int row)
{
uint32_t pk = (uint32_t)0x10000000;
bool was_not_zero = 0;
if (hex == 0) {
print_char('0', color, col, row);
} else {
print_char('0', color, col, row);
print_char('x', color, col, row);
}
while (pk > 0) {
uint32_t pp = hex / pk;
if (was_not_zero || pp > 0) {
if (pp >= 10) {
print_char(pp - 10 + 'A', color, col, row);
} else {
print_char(pp + '0', color, col, row);
}
was_not_zero = 1;
}
hex -= pp * pk;
pk /= 16;
}
}
void print_dec(uint32_t dec, unsigned char color, int col, int row)
{
uint32_t pk = 1000000000;
bool was_not_zero = 0;
while (pk > 0) {
uint32_t pp = dec / pk;
if (was_not_zero || pp > 0) {
print_char(pp + '0', color, col, row);
was_not_zero = 1;
}
dec -= pp * pk;
pk /= 10;
}
if (!was_not_zero) {
print_char('0', color, col, row);
}
}
void kprintf(const char* format, ...)
{
char* ptr_to_next_arg = (char*)((uint32_t)&format + sizeof(void*));
while (*format) {
if (*format == '%') {
format++;
if (*format == 'x') {
uint32_t* arg = (uint32_t*)ptr_to_next_arg;
ptr_to_next_arg += sizeof(uint32_t);
kprinth(*arg);
} else if (*format == 'd') {
uint32_t* arg = (uint32_t*)ptr_to_next_arg;
ptr_to_next_arg += sizeof(uint32_t);
kprintd(*arg);
} else if (*format == 's') {
char** arg = (char**)ptr_to_next_arg;
ptr_to_next_arg += sizeof(char**);
print_string(*arg, WHITE_ON_BLACK, -1, -1);
}
} else {
print_char(*format, WHITE_ON_BLACK, -1, -1);
}
format++;
}
// print_string(string, WHITE_ON_BLACK, -1, -1);
}
void kprinth(uint32_t hex)
{
print_hex(hex, WHITE_ON_BLACK, -1, -1);
}
void kprintd(uint32_t dec)
{
print_dec(dec, WHITE_ON_BLACK, -1, -1);
}
// clean screen
void clean_screen()
{
char* mem = VIDEO_MEMORY;
for (int i = 0; i < 2 * MAX_COLS * MAX_ROWS; i += 2) {
mem[i] = ' ';
mem[i + 1] = WHITE_ON_BLACK;
}
set_cursor_offset(0);
}
// scroll
void scroll(unsigned char lines)
{
char* mem = VIDEO_MEMORY;
unsigned int mem_offset = (unsigned int)lines * MAX_COLS;
unsigned int bytes_2_del = 2 * (MAX_COLS * MAX_ROWS - mem_offset);
char* src = (mem + mem_offset * 2);
memcpy(mem, src, bytes_2_del);
for (unsigned int i = bytes_2_del; i < 2 * MAX_COLS * MAX_ROWS; i += 2) {
mem[i] = ' ';
mem[i + 1] = WHITE_ON_BLACK;
}
set_cursor_offset(bytes_2_del / 2);
}
// cursor
void set_cursor_offset(unsigned short offset)
{
port_byte_out(REG_SCREEN_CTRL, 14);
port_byte_out(REG_SCREEN_DATA, (unsigned char)(offset >> 8));
port_byte_out(REG_SCREEN_CTRL, 15);
port_byte_out(REG_SCREEN_DATA, (unsigned char)(offset & 0xff));
}
int get_cursor_offet()
{
port_byte_out(REG_SCREEN_CTRL, 14);
unsigned short offset = port_byte_in(REG_SCREEN_DATA);
offset <<= 8;
port_byte_out(REG_SCREEN_CTRL, 15);
offset += port_byte_in(REG_SCREEN_DATA);
return offset;
}
// helpers
int get_offset(int col, int row) { return row * MAX_COLS + col; }
char col_in_field(int col) { return (0 <= col && col <= MAX_COLS); }
char row_in_field(int row) { return (0 <= row && row <= MAX_ROWS); }
|
willmexe/opuntiaOS | kernel/include/drivers/generic/uart.h | #ifdef __i386__
#include <drivers/x86/uart.h>
#elif __arm__
#include <drivers/aarch32/uart.h>
#endif |
willmexe/opuntiaOS | libs/libc/include/string.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
* + Contributed by bellrise <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _LIBC_STRING_H
#define _LIBC_STRING_H
#include <stddef.h>
#include <sys/cdefs.h>
#include <sys/types.h>
__BEGIN_DECLS
/* Set 'nbytes' to 'fill' starting from 'dest'. */
void* memset(void* dest, int fill, size_t nbytes);
/* Move 'nbytes' from 'src' to 'dest' */
void* memmove(void* dest, const void* __restrict src, size_t nbytes);
/* Copy 'nbytes' from 'src' to 'dest'. See the comment in the source file
about optimization and restricting pointers. */
void* memcpy(void* __restrict dest, const void* __restrict src, size_t nbytes);
/* Copy 'nbytes' from 'src' to 'dest', stopping if the current byte matches
'stop'. Note that the stop byte also gets copied over. */
void* memccpy(void* dest, const void* __restrict src, int stop, size_t nbytes);
/* Compare 'nbytes' from 'src1' and 'src2'. Return 0 if all the bytes match,
otherwise return the difference. */
int memcmp(const void* src1, const void* src2, size_t nbytes);
/* Calculate the string length starting from 'str'. */
size_t strlen(const char* str);
/* Copy 'src' into 'dest' until it finds a null byte in the source string.
Note that this is dangerous because it writes memory no matter the size
the 'dest' buffer is. */
char* strcpy(char* dest, const char* src);
int strcmp(const char* a, const char* b);
int strncmp(const char* a, const char* b, size_t nbytes);
/* Copy 'src' into 'dest' until it finds a null byte or reaches the 'nbytes'
limit provided by the user. This is the recommended way of copying strings,
instead of using regular strcpy. Note that this will fill the 'dest' buffer
with null bytes if the amount of copied bytes is lower than 'nbytes'. */
char* strncpy(char* dest, const char* src, size_t nbytes);
/* Returns a pointer to the first occurrence of character in the C string str. */
char* strchr(const char* s, int c);
__END_DECLS
#endif // _LIBC_STRING_H
|
willmexe/opuntiaOS | kernel/kernel/tasking/elf.c | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <fs/vfs.h>
#include <libkern/bits/errno.h>
#include <libkern/libkern.h>
#include <libkern/log.h>
#include <mem/kmalloc.h>
#include <mem/kmemzone.h>
#include <tasking/elf.h>
#include <tasking/tasking.h>
// #define ELF_DEBUG
#ifdef __i386__
#define MACHINE_ARCH EM_386
#elif __arm__
#define MACHINE_ARCH EM_ARM
#endif
#define PAGES_PER_COPING_BUFFER 8
#define COPING_BUFFER_LEN (PAGES_PER_COPING_BUFFER * VMM_PAGE_SIZE)
#define USER_STACK_SIZE VMM_PAGE_SIZE
static int _elf_load_do_copy_to_ram(proc_t* p, file_descriptor_t* fd, elf_program_header_32_t* ph)
{
pdirectory_t* prev_pdir = vmm_get_active_pdir();
vmm_switch_pdir(p->pdir);
uint32_t zones_count = proc->zones.size;
for (uint32_t i = 0; i < zones_count; i++) {
memzone_t* zone = (memzone_t*)dynarr_get(&proc->zones, i);
if (zone->type == ZONE_TYPE_BSS) {
memset((void*)zone->start, 0, zone->len);
}
}
kmemzone_t coping_zone = kmemzone_new(COPING_BUFFER_LEN);
uint32_t mem_remaining = ph->p_memsz;
uint32_t file_remaining = ph->p_filesz;
uint32_t mem_offset = ph->p_vaddr;
uint32_t file_offset = ph->p_offset;
while (mem_remaining) {
memset(coping_zone.ptr, 0, COPING_BUFFER_LEN);
if (file_remaining) {
uint32_t file_read_len = min(file_remaining, COPING_BUFFER_LEN);
fd->ops->read(fd->dentry, coping_zone.ptr, file_offset, file_read_len);
file_offset += file_read_len;
file_remaining -= file_read_len;
}
void* write_ptr = coping_zone.ptr;
for (int i = 0; i < PAGES_PER_COPING_BUFFER && mem_remaining; i++) {
uint32_t mem_write_len = min(mem_remaining, VMM_PAGE_SIZE);
if (memzone_find(p, mem_offset)) {
vmm_copy_to_user((void*)mem_offset, write_ptr, mem_write_len);
}
mem_offset += mem_write_len;
mem_remaining -= mem_write_len;
write_ptr += VMM_PAGE_SIZE;
}
}
kmemzone_free(coping_zone);
return vmm_switch_pdir(prev_pdir);
}
static int _elf_load_interpret_program_header_entry(proc_t* p, file_descriptor_t* fd)
{
elf_program_header_32_t ph;
int err = vfs_read(fd, &ph, sizeof(ph));
if (err != sizeof(ph)) {
return err;
}
#ifdef ELF_DEBUG
log("Header type %x %x - %x", ph.p_type, ph.p_vaddr, ph.p_memsz);
#endif
switch (ph.p_type) {
case PT_LOAD:
_elf_load_do_copy_to_ram(p, fd, &ph);
break;
default:
break;
}
return 0;
}
static int _elf_load_interpret_section_header_entry(proc_t* p, file_descriptor_t* fd)
{
elf_section_header_32_t sh;
int err = vfs_read(fd, &sh, sizeof(sh));
if (err != sizeof(sh)) {
return err;
}
#ifdef ELF_DEBUG
log("Section type %x %x - %x", sh.sh_type, sh.sh_addr, sh.sh_size);
#endif
if (sh.sh_flags & SHF_ALLOC) {
uint32_t zone_flags = ZONE_READABLE;
uint32_t zone_type = ZONE_TYPE_NULL;
if (sh.sh_flags & SHF_WRITE) {
zone_flags |= ZONE_WRITABLE;
}
if (sh.sh_flags & SHF_EXECINSTR) {
zone_flags |= ZONE_EXECUTABLE;
}
// FIXME: Mapping of zone types is bad.
switch (sh.sh_type) {
case SHT_PROGBITS:
zone_type = ZONE_TYPE_CODE;
break;
case SHT_NOBITS:
zone_type = ZONE_TYPE_BSS;
break;
case SHT_INIT_ARRAY:
zone_type = ZONE_TYPE_DATA;
break;
case SHT_FINI_ARRAY:
zone_type = ZONE_TYPE_DATA;
break;
case SHT_PREINIT_ARRAY:
zone_type = ZONE_TYPE_DATA;
break;
default:
break;
}
if (zone_type) {
memzone_t* zone = memzone_extend(p, sh.sh_addr, sh.sh_size);
if (zone) {
zone->type = zone_type;
zone->flags |= zone_flags;
}
}
}
return 0;
}
static int _elf_load_alloc_stack(proc_t* p)
{
memzone_t* stack_zone = memzone_new_random_backward(p, USER_STACK_SIZE);
stack_zone->type = ZONE_TYPE_STACK;
stack_zone->flags |= ZONE_READABLE | ZONE_WRITABLE;
set_base_pointer(p->main_thread->tf, stack_zone->start + USER_STACK_SIZE);
set_stack_pointer(p->main_thread->tf, stack_zone->start + USER_STACK_SIZE);
return 0;
}
static inline int _elf_do_load(proc_t* p, file_descriptor_t* fd, elf_header_32_t* header)
{
fd->offset = header->e_shoff;
int sh_num = header->e_shnum;
for (int i = 0; i < sh_num; i++) {
_elf_load_interpret_section_header_entry(p, fd);
}
fd->offset = header->e_phoff;
int ph_num = header->e_phnum;
for (int i = 0; i < ph_num; i++) {
_elf_load_interpret_program_header_entry(p, fd);
}
memzone_new(p, 0, VMM_PAGE_SIZE); // Forbid 0 allocations to handle NULLptrs.
_elf_load_alloc_stack(p);
set_instruction_pointer(p->main_thread->tf, header->e_entry);
return 0;
}
int elf_check_header(elf_header_32_t* header)
{
static const char elf_signature[] = { 0x7F, 0x45, 0x4c, 0x46 };
if (memcmp(header->e_ident, elf_signature, sizeof(elf_signature)) != 0) {
return -ENOEXEC;
}
// Currently we support only 32bit execs
if (header->e_ident[EI_CLASS] != ELF_CLASS_32) {
return -EBADARCH;
}
if (header->e_type != ET_EXEC) {
return -ENOEXEC;
}
if (header->e_machine != MACHINE_ARCH) {
return -EBADARCH;
}
return 0;
}
int elf_load(proc_t* p, file_descriptor_t* fd)
{
elf_header_32_t header;
int err = vfs_read(fd, &header, sizeof(header));
if (err != sizeof(header)) {
return err;
}
err = elf_check_header(&header);
if (err) {
return err;
}
return _elf_do_load(p, fd, &header);
}
int elf_find_symtab_unchecked(void* mapped_data, void** symtab, size_t* symtab_entries, char** strtab)
{
*symtab = NULL;
*symtab_entries = 0;
*strtab = NULL;
elf_header_32_t* header = (elf_header_32_t*)mapped_data;
int sh_num = header->e_shnum;
elf_section_header_32_t* headers_array = (elf_section_header_32_t*)(mapped_data + header->e_shoff);
for (int i = 0; i < sh_num; i++) {
if (headers_array[i].sh_type == SHT_SYMTAB) {
*symtab = (void*)(mapped_data + headers_array[i].sh_offset);
*symtab_entries = headers_array[i].sh_size / sizeof(elf_sym_32_t);
}
if (headers_array[i].sh_type == SHT_STRTAB && header->e_shstrndx != i) {
*strtab = (void*)(mapped_data + headers_array[i].sh_offset);
}
}
return 0;
}
ssize_t elf_find_function_in_symtab(void* symtab_p, size_t syms_n, uint32_t ip)
{
elf_sym_32_t* symtab = (elf_sym_32_t*)(symtab_p);
uint32_t prev = 0;
ssize_t ans = -1;
for (size_t i = 0; i < syms_n; i++) {
if (prev <= symtab[i].st_value && symtab[i].st_value <= ip) {
prev = symtab[i].st_value;
ans = symtab[i].st_name;
}
}
return ans;
} |
willmexe/opuntiaOS | kernel/include/mem/bits/swap.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_MEM_BITS_SWAP_H
#define _KERNEL_MEM_BITS_SWAP_H
enum SWAP_TYPE {
SWAP_TO_DEV,
SWAP_DROP,
SWAP_NOT_ALLOWED,
};
#endif // _KERNEL_MEM_BITS_SWAP_H |
willmexe/opuntiaOS | userland/tests/sigtest/main.c | #include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
void save_on_terminate()
{
printf("Saving file and exiting");
fflush(stdout);
}
int main(int argc, char** argv)
{
sigaction(SIGTERM, save_on_terminate);
while (1) {
// infinite loop
}
return 0;
} |
willmexe/opuntiaOS | libs/libc/pwd/shadow.c | #include <assert.h>
#include <shadow.h>
#include <stdio.h>
#include <string.h>
static FILE* spwdfile = NULL;
static char tmp_buf[512];
// spwd struct contains pointers to data which is
// stored in spwd_buf
static char spwd_buf[512];
static spwd_t spwd_entry;
static inline int spwd_part_to_int(char* part)
{
int res = 0;
sscanf(part, "%d", &res);
return res;
}
static inline uint32_t spwd_part_to_uint(char* part)
{
uint32_t res = 0;
sscanf(part, "%u", &res);
return res;
}
static spwd_t* parse_spwd_entry(char* res)
{
int len = strlen(res);
int nxt_part = 0;
char* parts[10];
memcpy(spwd_buf, res, len);
parts[nxt_part++] = &spwd_buf[0];
for (int i = 0; i < len; i++) {
if (spwd_buf[i] == ':') {
parts[nxt_part++] = &spwd_buf[i + 1];
spwd_buf[i] = '\0';
if (nxt_part > 9) {
// More than 9 block.
return NULL;
}
}
}
spwd_buf[len] = '\0';
if (nxt_part != 9) {
return NULL;
}
spwd_entry.sp_namp = parts[0];
spwd_entry.sp_pwdp = parts[1];
spwd_entry.sp_lstchg = spwd_part_to_int(parts[2]);
spwd_entry.sp_min = spwd_part_to_int(parts[3]);
spwd_entry.sp_max = spwd_part_to_int(parts[4]);
spwd_entry.sp_warn = spwd_part_to_int(parts[5]);
spwd_entry.sp_inact = spwd_part_to_int(parts[6]);
spwd_entry.sp_expire = spwd_part_to_int(parts[7]);
spwd_entry.sp_flag = spwd_part_to_uint(parts[8]);
return &spwd_entry;
}
void setspent()
{
spwdfile = fopen("/etc/shadow", "r");
if (spwdfile == NULL) {
// Raise an error
}
}
void endspent()
{
if (spwdfile) {
fclose(spwdfile);
spwdfile = NULL;
}
memset(&spwd_entry, 0, sizeof(spwd_entry));
}
spwd_t* getspent()
{
if (!spwdfile) {
setspent();
}
while (1) {
if (feof(spwdfile)) {
return NULL;
}
char* res = fgets(spwd_buf, 512, spwdfile);
if (!res || !res[0]) {
return NULL;
}
if (parse_spwd_entry(res)) {
return &spwd_entry;
}
}
return NULL;
}
spwd_t* getspnam(const char* name)
{
spwd_t* spwd;
setspent();
while ((spwd = getspent())) {
if (!strcmp(spwd->sp_namp, name)) {
return spwd;
}
}
return NULL;
} |
willmexe/opuntiaOS | kernel/kernel/platform/x86/interrupts/isr_handler.c | <reponame>willmexe/opuntiaOS
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
* + Contributed by bellrise <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <drivers/x86/fpu.h>
#include <libkern/kassert.h>
#include <libkern/log.h>
#include <mem/vmm.h>
#include <platform/generic/registers.h>
#include <platform/generic/system.h>
#include <platform/x86/isr_handler.h>
#include <tasking/cpu.h>
#include <tasking/dump.h>
#include <tasking/sched.h>
#include <tasking/tasking.h>
#include <tasking/thread.h>
#define ERR_BUF_SIZE 64
static char err_buf[ERR_BUF_SIZE];
static const char* exception_messages[32] = {
"Division by zero",
"Debug",
"Non-maskable interrupt",
"Breakpoint",
"Detected overflow",
"Out-of-bounds",
"Invalid opcode",
"No coprocessor",
"Double fault",
"Coprocessor segment overrun",
"Bad TSS",
"Segment not present",
"Stack fault",
"General protection fault",
"Page fault",
"Unknown interrupt",
"Coprocessor fault",
"Alignment check",
"Machine check",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved",
"Reserved"
};
void isr_handler(trapframe_t* frame)
{
int res;
proc_t* proc;
system_disable_interrupts();
cpu_enter_kernel_space();
proc = NULL;
if (likely(RUNNING_THREAD)) {
proc = RUNNING_THREAD->process;
if (RUNNING_THREAD->process->is_kthread)
RUNNING_THREAD->tf = frame;
}
switch (frame->int_no) {
/* Division by 0 or kernel trap (if no process). */
case 0:
if (proc) {
log_warn("Crash: division by zero in T%d\n", RUNNING_THREAD->tid);
dump_and_kill(proc);
} else {
snprintf(
err_buf, ERR_BUF_SIZE, "Kernel trap at %x, type %d=%s",
frame->eip, frame->int_no,
&exception_messages[frame->int_no]);
kpanic_tf(err_buf, frame);
}
break;
/* Debug, non-maskable interrupt, breakpoint, detected overflow,
out of bounds. */
case 1:
case 2:
case 3:
case 4:
case 5:
log_error("Int w/o handler: %d: %s: %d", frame->int_no,
exception_messages[frame->int_no], frame->err);
system_stop();
break;
/* Invalid opcode or kernel trap (if no process). */
case 6:
if (proc) {
log_warn("Crash: invalid opcode in %d tid\n", RUNNING_THREAD->tid);
dump_and_kill(proc);
} else {
snprintf(
err_buf, ERR_BUF_SIZE, "Kernel trap at %x, type %d=%s",
frame->eip, frame->int_no, &exception_messages[frame->int_no]);
kpanic_tf(err_buf, frame);
}
break;
/* No coprocessor */
case 7:
fpu_handler();
break;
/* Double fault and other. */
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
log_error("Int w/o handler: %d: %s: %d", frame->int_no,
exception_messages[frame->int_no], frame->err);
system_stop();
break;
case 14:
res = vmm_page_fault_handler(frame->err, read_cr2());
if (res == 0)
break;
if (proc) {
log_warn("Crash: pf err %d at %x: %d pid, %x eip\n",
frame->err, read_cr2(), proc->pid, frame->eip);
dump_and_kill(proc);
} else {
snprintf(
err_buf, ERR_BUF_SIZE, "Kernel trap at %x, type %d=%s",
frame->eip, frame->int_no, &exception_messages[frame->int_no]);
kpanic_tf(err_buf, frame);
}
break;
case 15:
log_error("Int w/o handler: %d: %s: %d", frame->int_no,
exception_messages[frame->int_no], frame->err);
system_stop();
break;
default:
log_error("Int w/o handler: %d: %d", frame->int_no, frame->err);
system_stop();
}
/* When we are leaving the interrupt handler, we want to jump back into
user space and enable the x86 PIC again */
cpu_leave_kernel_space();
system_enable_interrupts_only_counter();
}
|
willmexe/opuntiaOS | libs/libc/include/assert.h | #ifndef _LIBC_ASSERT_H
#define _LIBC_ASSERT_H
#include <stddef.h>
#include <stdio.h>
#include <sys/_structs.h>
#include <sys/cdefs.h>
#include <sys/types.h>
__BEGIN_DECLS
#ifndef assert
#define assert(x) \
if (!(x)) [[unlikely]] { \
printf("Assertion failed: %s, function %s, file %s:%d\n", #x, __func__, __FILE__, __LINE__); \
fflush(stdout); \
abort(); \
}
#endif // assert
__END_DECLS
#endif // _LIBC_ASSERT_H |
willmexe/opuntiaOS | libs/libc/posix/identity.c | #include <assert.h>
#include <pwd.h>
#include <string.h>
#include <sysdep.h>
#include <unistd.h>
uid_t getuid()
{
return (uid_t)DO_SYSCALL_0(SYS_GETUID);
}
uid_t geteuid()
{
return 0;
}
int setuid(uid_t uid)
{
return DO_SYSCALL_1(SYS_SETUID, uid);
}
int setgid(gid_t gid)
{
return DO_SYSCALL_1(SYS_SETGID, gid);
}
int setreuid(uid_t ruid, uid_t euid)
{
return DO_SYSCALL_2(SYS_SETREUID, ruid, euid);
}
int setregid(gid_t rgid, gid_t egid)
{
return DO_SYSCALL_2(SYS_SETREGID, rgid, egid);
}
static char loginbuf[128];
char* getlogin()
{
passwd_t* passwd = getpwuid(getuid());
strncpy(loginbuf, passwd->pw_name, 128);
endpwent();
return loginbuf;
} |
willmexe/opuntiaOS | kernel/include/libkern/bits/sys/mman.h | #ifndef _KERNEL_LIBKERN_BITS_SYS_MMAN_H
#define _KERNEL_LIBKERN_BITS_SYS_MMAN_H
#include <libkern/types.h>
#define MAP_SHARED 0x01
#define MAP_PRIVATE 0x02
#define MAP_FIXED 0x10
#define MAP_ANONYMOUS 0x20
#define MAP_STACK 0x40
#define PROT_READ 0x1
#define PROT_WRITE 0x2
#define PROT_EXEC 0x4
#define PROT_NONE 0x0
struct mmap_params {
void* addr;
size_t size;
int prot;
int flags;
int fd;
off_t offset;
};
typedef struct mmap_params mmap_params_t;
#endif // _KERNEL_LIBKERN_BITS_SYS_MMAN_H |
willmexe/opuntiaOS | libs/libc/include/stdarg.h | <reponame>willmexe/opuntiaOS
#ifndef _LIBC_STDARG_H
#define _LIBC_STDARG_H
#include <sys/cdefs.h>
#include <sys/types.h>
__BEGIN_DECLS
#define va_start(v, l) __builtin_va_start(v, l)
#define va_end(v) __builtin_va_end(v)
#define va_arg(v, l) __builtin_va_arg(v, l)
__END_DECLS
#endif // _LIBC_STDARG_H |
willmexe/opuntiaOS | libs/libipc/include/libipc/MessageDecoder.h | <reponame>willmexe/opuntiaOS
#pragma once
#include <libipc/Message.h>
#include <memory>
class MessageDecoder {
public:
MessageDecoder() = default;
virtual ~MessageDecoder() = default;
virtual int magic() { return 0; }
virtual std::unique_ptr<Message> decode(const char* buf, size_t size, size_t& decoded_msg_len) { return nullptr; }
virtual std::unique_ptr<Message> handle(Message&) { return nullptr; }
}; |
willmexe/opuntiaOS | kernel/include/platform/x86/gdt.h | <filename>kernel/include/platform/x86/gdt.h
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_PLATFORM_X86_GDT_H
#define _KERNEL_PLATFORM_X86_GDT_H
#include <libkern/c_attrs.h>
#include <libkern/types.h>
#define GDT_MAX_ENTRIES 6
#define GDT_SEG_NULL 0 // kernel code
#define GDT_SEG_KCODE 1 // kernel code
#define GDT_SEG_KDATA 2 // kernel data+stack
#define GDT_SEG_UCODE 3 // user code
#define GDT_SEG_UDATA 4 // user data+stack
#define GDT_SEG_TSS 5 // task state NOT USED CURRENTLY
#define GDT_SEGF_X 0x8 // exec
#define GDT_SEGF_A 0x1 // accessed
#define GDT_SEGF_R 0x2 // readable (if exec)
#define GDT_SEGF_C 0x4 // conforming seg (if exec)
#define GDT_SEGF_W 0x2 // writeable (if non-exec)
#define GDT_SEGF_D 0x4 // grows down (if non-exec)
#define FL_IF 0x00000200
#define DPL_KERN 0x0
#define DPL_USER 0x3
struct PACKED gdt_desc {
uint32_t lim_15_0 : 16;
uint32_t base_15_0 : 16;
uint32_t base_23_16 : 8;
uint32_t type : 4;
uint32_t dt : 1;
uint32_t dpl : 2;
uint32_t p : 1;
uint32_t lim_19_16 : 4;
uint32_t avl : 1;
uint32_t rsv1 : 1;
uint32_t db : 1;
uint32_t g : 1;
uint32_t base_31_24 : 8;
};
typedef struct gdt_desc gdt_desc_t;
extern gdt_desc_t gdt[GDT_MAX_ENTRIES];
// segment with page granularity
#define GDT_SEG_PG(type, base, limit, dpl) \
(gdt_desc_t) \
{ \
((limit) >> 12) & 0xffff, (uint32_t)(base)&0xffff, \
((uint32_t)(base) >> 16) & 0xff, type, 1, dpl, 1, \
((uint32_t)(limit) >> 28), 0, 0, 1, 1, (uint32_t)(base) >> 24 \
}
// segment with byte granularity
#define GDT_SEG_BG(type, base, limit, dpl) \
(gdt_desc_t) \
{ \
((limit)) & 0xffff, (uint32_t)(base)&0xffff, \
((uint32_t)(base) >> 16) & 0xff, type, 0, dpl, 1, \
(((uint32_t)(limit) >> 16) & 0xf), 0, 0, 0, 0, (uint32_t)(base) >> 24 \
}
void gdt_setup();
#endif // _KERNEL_PLATFORM_X86_GDT_H |
willmexe/opuntiaOS | test/kernel/fs/dup/main.c | #include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
int main(int argc, char** argv)
{
int fd = -1;
fd = open("/boot/kernel.config", O_RDONLY);
if (fd < 0) {
TestErr("Can't open kernel.config");
}
int dupfd = dup(fd);
if (dupfd < 0) {
TestErr("Can't dup file");
}
int err = write(dupfd, "abcd", 5);
if (!err) {
TestErr("Succesfully write to read only file");
}
fstat_t stat;
if (fstat(fd, &stat) < 0) {
TestErr("Can't read fstat of orig file");
}
fstat_t newstat;
if (fstat(dupfd, &newstat) < 0) {
TestErr("Can't read fstat of dup file");
}
if (memcmp(&stat, &newstat, sizeof(fstat_t)) != 0) {
TestErr("Different stat info of files");
}
return 0;
} |
willmexe/opuntiaOS | userland/utilities/mkdir/main.c | #include <sys/stat.h>
#include <unistd.h>
int main(int argc, char** argv)
{
if (argc < 2) {
write(1, "Usage: mkdir files...\n", 22);
return 0;
}
for (int i = 1; i < argc; i++) {
if (mkdir(argv[i]) < 0) {
write(1, "mkdir: failed to create\n", 26);
return 1;
}
}
return 0;
} |
willmexe/opuntiaOS | libs/libui/include/libui/ContextManager.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#pragma once
#include <libg/Context.h>
namespace UI {
static inline void graphics_push_context(LG::Context&& context)
{
extern std::vector<LG::Context> s_ui_graphics_contexts;
s_ui_graphics_contexts.push_back(std::move(context));
}
static inline void graphics_push_context(const LG::Context& context)
{
extern std::vector<LG::Context> s_ui_graphics_contexts;
s_ui_graphics_contexts.push_back(context);
}
static inline void graphics_pop_context()
{
extern std::vector<LG::Context> s_ui_graphics_contexts;
s_ui_graphics_contexts.pop_back();
}
static inline LG::Context& graphics_current_context()
{
extern std::vector<LG::Context> s_ui_graphics_contexts;
return s_ui_graphics_contexts.back();
}
} // namespace UI |
willmexe/opuntiaOS | boot/libboot/abi/drivers.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _BOOT_LIBBOOT_ABI_DRIVERS_H
#define _BOOT_LIBBOOT_ABI_DRIVERS_H
#include <libboot/types.h>
#define MASKDEFINE(N, P, S) \
N##_POS = (P), \
N##_SIZE = (S), \
N##_MASK = ((~(~0 << (S))) << (P))
#define TOKEN_PASTE_IMPL(x, y) x##y
#define TOKEN_PASTE(x, y) TOKEN_PASTE_IMPL(x, y)
#define SKIP(x, y) char TOKEN_PASTE(prefix, __LINE__)[y - x - 8]
struct drive_desc {
void* init;
void* read;
void* write;
};
typedef struct drive_desc drive_desc_t;
struct fs_desc {
void* read;
};
typedef struct fs_desc fs_desc_t;
#endif // _BOOT_LIBBOOT_ABI_DRIVERS_H |
willmexe/opuntiaOS | kernel/kernel/mem/swapfile.c | <gh_stars>100-1000
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <fs/vfs.h>
#include <libkern/bits/errno.h>
#include <libkern/log.h>
#include <mem/swapfile.h>
static dentry_t* _swapfile = NULL;
static int _nextid = 0;
int swapfile_init()
{
dentry_t* var_dir = NULL;
if (vfs_resolve_path("/var", &var_dir) < 0) {
// Instead of panicing we can create the dir here.
kpanic("No /var dir is found");
}
vfs_create(var_dir, "swapfile", 8, 600, 0, 0);
if (vfs_resolve_path("/var/swapfile", &_swapfile) < 0) {
_swapfile = NULL;
}
return 0;
}
int swapfile_load(uintptr_t vaddr, int id)
{
if (!_swapfile) {
return -ENODEV;
}
if (id > _nextid) {
return -ENOENT;
}
size_t offset = (id - 1) * VMM_PAGE_SIZE;
_swapfile->ops->file.read(_swapfile, (void*)PAGE_START(vaddr), offset, VMM_PAGE_SIZE);
return 0;
}
int swapfile_store(uintptr_t vaddr)
{
if (!_swapfile) {
return -ENODEV;
}
_swapfile->ops->file.write(_swapfile, (void*)PAGE_START(vaddr), _nextid * VMM_PAGE_SIZE, VMM_PAGE_SIZE);
_nextid++;
return _nextid;
} |
willmexe/opuntiaOS | servers/window_server/src/Managers/Compositor.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#pragma once
#include "../shared/Connections/WSConnection.h"
#include "IPC/ServerDecoder.h"
#include <libipc/ServerConnection.h>
#include <vector>
namespace WinServer {
class CursorManager;
class ResourceManager;
class MenuBar;
#ifdef TARGET_MOBILE
class ControlBar;
#endif // TARGET_MOBILE
class Popup;
class Compositor {
public:
inline static Compositor& the()
{
extern Compositor* s_WinServer_Compositor_the;
return *s_WinServer_Compositor_the;
}
Compositor();
void refresh();
void optimized_invalidate_insert(std::vector<LG::Rect>& data, const LG::Rect& inv_area)
{
auto area = inv_area;
bool intersects = false;
int int_index = 0;
for (auto& rect : data) {
if (rect.contains(area)) {
return;
}
}
for (auto& rect : data) {
if (rect.intersects(area)) {
intersects = true;
break;
}
int_index++;
}
if (!intersects) {
data.push_back(area);
return;
}
data[int_index].unite(area);
for (int i = int_index + 1; i < data.size(); i++) {
if (data[int_index].intersects(data[i])) {
data[int_index].unite(data[i]);
std::swap(data[i], data.back());
data.pop_back();
i--;
}
}
}
inline void invalidate(const LG::Rect& area) { optimized_invalidate_insert(m_invalidated_areas, area); }
inline CursorManager& cursor_manager() { return m_cursor_manager; }
inline const CursorManager& cursor_manager() const { return m_cursor_manager; }
inline ResourceManager& resource_manager() { return m_resource_manager; }
inline const ResourceManager& resource_manager() const { return m_resource_manager; }
inline Popup& popup() { return m_popup; }
inline const Popup& popup() const { return m_popup; }
inline MenuBar& menu_bar() { return m_menu_bar; }
inline const MenuBar& menu_bar() const { return m_menu_bar; }
#ifdef TARGET_MOBILE
inline ControlBar& control_bar()
{
return m_control_bar;
}
inline const ControlBar& control_bar() const { return m_control_bar; }
#endif // TARGET_MOBILE
private:
void copy_changes_to_second_buffer(const std::vector<LG::Rect>& areas);
std::vector<LG::Rect> m_invalidated_areas;
MenuBar& m_menu_bar;
Popup& m_popup;
CursorManager& m_cursor_manager;
ResourceManager& m_resource_manager;
#ifdef TARGET_MOBILE
ControlBar& m_control_bar;
#endif // TARGET_MOBILE
};
} // namespace WinServer |
willmexe/opuntiaOS | boot/aarch32/drivers/uart.c | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "uart.h"
#include <libboot/devtree/devtree.h>
volatile uint32_t* output = NULL;
void uart_init()
{
devtree_entry_t* dev = devtree_find_device("uart");
if (!dev) {
while (1) { };
}
output = (uint32_t*)dev->paddr;
}
int uart_write(uint8_t data)
{
if (!output) {
return 1;
}
*output = data;
return 0;
} |
willmexe/opuntiaOS | kernel/include/platform/generic/cpu.h | <reponame>willmexe/opuntiaOS
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_TASKING_BITS_CPU_H
#define _KERNEL_TASKING_BITS_CPU_H
#include <drivers/generic/fpu.h>
#include <libkern/types.h>
#include <mem/kmemzone.h>
#include <mem/vmm.h>
#include <platform/generic/tasking/context.h>
#include <tasking/bits/sched.h>
#define CPU_CNT 4
#define THIS_CPU (&cpus[system_cpu_id()])
#define FPU_ENABLED
struct thread;
typedef int cpu_state_t;
enum CPU_STATE {
CPU_IN_KERNEL,
CPU_IN_USERLAND,
};
typedef struct {
int id;
int int_depth_counter;
pdirectory_t* pdir;
kmemzone_t sched_stack_zone;
context_t* sched_context; // context of sched's registers
struct thread* running_thread;
cpu_state_t current_state;
struct thread* idle_thread;
sched_data_t sched;
/* Stat */
time_t stat_ticks_since_boot;
time_t stat_system_and_idle_ticks;
time_t stat_user_ticks;
#ifdef FPU_ENABLED
// Information about current state of fpu.
struct thread* fpu_for_thread;
pid_t fpu_for_pid;
#endif // FPU_ENABLED
} cpu_t;
extern cpu_t cpus[CPU_CNT];
#endif // _KERNEL_TASKING_BITS_CPU_H |
willmexe/opuntiaOS | servers/window_server/shared/Connections/WSConnection.h | <reponame>willmexe/opuntiaOS<filename>servers/window_server/shared/Connections/WSConnection.h
// Auto generated with utils/ConnectionCompiler
// See .ipc file
#pragma once
#include <libg/Rect.h>
#include <libipc/ClientConnection.h>
#include <libipc/Encoder.h>
#include <libipc/ServerConnection.h>
#include <libipc/StringEncoder.h>
#include <libipc/VectorEncoder.h>
#include <new>
class GreetMessage : public Message {
public:
GreetMessage(message_key_t key)
: m_key(key)
{
}
int id() const override { return 1; }
int reply_id() const override { return 2; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
return buffer;
}
private:
message_key_t m_key;
};
class GreetMessageReply : public Message {
public:
GreetMessageReply(message_key_t key, uint32_t connection_id)
: m_key(key)
, m_connection_id(connection_id)
{
}
int id() const override { return 2; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t connection_id() const { return m_connection_id; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_connection_id);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_connection_id;
};
class CreateWindowMessage : public Message {
public:
CreateWindowMessage(message_key_t key, int type, uint32_t width, uint32_t height, int buffer_id, LIPC::StringEncoder title, LIPC::StringEncoder icon_path, LIPC::StringEncoder bundle_id, uint32_t color, uint32_t menubar_style)
: m_key(key)
, m_type(type)
, m_width(width)
, m_height(height)
, m_buffer_id(buffer_id)
, m_title(title)
, m_icon_path(icon_path)
, m_bundle_id(bundle_id)
, m_color(color)
, m_menubar_style(menubar_style)
{
}
int id() const override { return 3; }
int reply_id() const override { return 4; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
int type() const { return m_type; }
uint32_t width() const { return m_width; }
uint32_t height() const { return m_height; }
int buffer_id() const { return m_buffer_id; }
LIPC::StringEncoder& title() { return m_title; }
LIPC::StringEncoder& icon_path() { return m_icon_path; }
LIPC::StringEncoder& bundle_id() { return m_bundle_id; }
uint32_t color() const { return m_color; }
uint32_t menubar_style() const { return m_menubar_style; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_type);
Encoder::append(buffer, m_width);
Encoder::append(buffer, m_height);
Encoder::append(buffer, m_buffer_id);
Encoder::append(buffer, m_title);
Encoder::append(buffer, m_icon_path);
Encoder::append(buffer, m_bundle_id);
Encoder::append(buffer, m_color);
Encoder::append(buffer, m_menubar_style);
return buffer;
}
private:
message_key_t m_key;
int m_type;
uint32_t m_width;
uint32_t m_height;
int m_buffer_id;
LIPC::StringEncoder m_title;
LIPC::StringEncoder m_icon_path;
LIPC::StringEncoder m_bundle_id;
uint32_t m_color;
uint32_t m_menubar_style;
};
class CreateWindowMessageReply : public Message {
public:
CreateWindowMessageReply(message_key_t key, uint32_t window_id)
: m_key(key)
, m_window_id(window_id)
{
}
int id() const override { return 4; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
};
class DestroyWindowMessage : public Message {
public:
DestroyWindowMessage(message_key_t key, uint32_t window_id)
: m_key(key)
, m_window_id(window_id)
{
}
int id() const override { return 5; }
int reply_id() const override { return 6; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
};
class DestroyWindowMessageReply : public Message {
public:
DestroyWindowMessageReply(message_key_t key, uint32_t status)
: m_key(key)
, m_status(status)
{
}
int id() const override { return 6; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t status() const { return m_status; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_status);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_status;
};
class SetBufferMessage : public Message {
public:
SetBufferMessage(message_key_t key, uint32_t window_id, int buffer_id, int format, LG::Rect bounds)
: m_key(key)
, m_window_id(window_id)
, m_buffer_id(buffer_id)
, m_format(format)
, m_bounds(bounds)
{
}
int id() const override { return 7; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
int buffer_id() const { return m_buffer_id; }
int format() const { return m_format; }
LG::Rect& bounds() { return m_bounds; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
Encoder::append(buffer, m_buffer_id);
Encoder::append(buffer, m_format);
Encoder::append(buffer, m_bounds);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
int m_buffer_id;
int m_format;
LG::Rect m_bounds;
};
class SetBarStyleMessage : public Message {
public:
SetBarStyleMessage(message_key_t key, uint32_t window_id, uint32_t color, uint32_t menubar_style)
: m_key(key)
, m_window_id(window_id)
, m_color(color)
, m_menubar_style(menubar_style)
{
}
int id() const override { return 8; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
uint32_t color() const { return m_color; }
uint32_t menubar_style() const { return m_menubar_style; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
Encoder::append(buffer, m_color);
Encoder::append(buffer, m_menubar_style);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
uint32_t m_color;
uint32_t m_menubar_style;
};
class SetTitleMessage : public Message {
public:
SetTitleMessage(message_key_t key, uint32_t window_id, LIPC::StringEncoder title)
: m_key(key)
, m_window_id(window_id)
, m_title(title)
{
}
int id() const override { return 9; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
LIPC::StringEncoder& title() { return m_title; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
Encoder::append(buffer, m_title);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
LIPC::StringEncoder m_title;
};
class InvalidateMessage : public Message {
public:
InvalidateMessage(message_key_t key, uint32_t window_id, LG::Rect rect)
: m_key(key)
, m_window_id(window_id)
, m_rect(rect)
{
}
int id() const override { return 10; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
LG::Rect& rect() { return m_rect; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
Encoder::append(buffer, m_rect);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
LG::Rect m_rect;
};
class AskBringToFrontMessage : public Message {
public:
AskBringToFrontMessage(message_key_t key, uint32_t window_id, uint32_t target_window_id)
: m_key(key)
, m_window_id(window_id)
, m_target_window_id(target_window_id)
{
}
int id() const override { return 11; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
uint32_t target_window_id() const { return m_target_window_id; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
Encoder::append(buffer, m_target_window_id);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
uint32_t m_target_window_id;
};
class MenuBarCreateMenuMessage : public Message {
public:
MenuBarCreateMenuMessage(message_key_t key, uint32_t window_id, LIPC::StringEncoder title)
: m_key(key)
, m_window_id(window_id)
, m_title(title)
{
}
int id() const override { return 12; }
int reply_id() const override { return 13; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
LIPC::StringEncoder& title() { return m_title; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
Encoder::append(buffer, m_title);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
LIPC::StringEncoder m_title;
};
class MenuBarCreateMenuMessageReply : public Message {
public:
MenuBarCreateMenuMessageReply(message_key_t key, int status, int menu_id)
: m_key(key)
, m_status(status)
, m_menu_id(menu_id)
{
}
int id() const override { return 13; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
int status() const { return m_status; }
int menu_id() const { return m_menu_id; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_status);
Encoder::append(buffer, m_menu_id);
return buffer;
}
private:
message_key_t m_key;
int m_status;
int m_menu_id;
};
class MenuBarCreateItemMessage : public Message {
public:
MenuBarCreateItemMessage(message_key_t key, uint32_t window_id, int menu_id, int item_id, LIPC::StringEncoder title)
: m_key(key)
, m_window_id(window_id)
, m_menu_id(menu_id)
, m_item_id(item_id)
, m_title(title)
{
}
int id() const override { return 14; }
int reply_id() const override { return 15; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
int menu_id() const { return m_menu_id; }
int item_id() const { return m_item_id; }
LIPC::StringEncoder& title() { return m_title; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
Encoder::append(buffer, m_menu_id);
Encoder::append(buffer, m_item_id);
Encoder::append(buffer, m_title);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
int m_menu_id;
int m_item_id;
LIPC::StringEncoder m_title;
};
class MenuBarCreateItemMessageReply : public Message {
public:
MenuBarCreateItemMessageReply(message_key_t key, int status)
: m_key(key)
, m_status(status)
{
}
int id() const override { return 15; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
int status() const { return m_status; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_status);
return buffer;
}
private:
message_key_t m_key;
int m_status;
};
class PopupShowMenuMessage : public Message {
public:
PopupShowMenuMessage(message_key_t key, uint32_t window_id, LG::Point<int> point, LIPC::VectorEncoder<LIPC::StringEncoder> data)
: m_key(key)
, m_window_id(window_id)
, m_point(point)
, m_data(data)
{
}
int id() const override { return 16; }
int reply_id() const override { return 17; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
uint32_t window_id() const { return m_window_id; }
LG::Point<int>& point() { return m_point; }
LIPC::VectorEncoder<LIPC::StringEncoder>& data() { return m_data; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_window_id);
Encoder::append(buffer, m_point);
Encoder::append(buffer, m_data);
return buffer;
}
private:
message_key_t m_key;
uint32_t m_window_id;
LG::Point<int> m_point;
LIPC::VectorEncoder<LIPC::StringEncoder> m_data;
};
class PopupShowMenuMessageReply : public Message {
public:
PopupShowMenuMessageReply(message_key_t key, int status, int menu_id)
: m_key(key)
, m_status(status)
, m_menu_id(menu_id)
{
}
int id() const override { return 17; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 320; }
int status() const { return m_status; }
int menu_id() const { return m_menu_id; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_status);
Encoder::append(buffer, m_menu_id);
return buffer;
}
private:
message_key_t m_key;
int m_status;
int m_menu_id;
};
class BaseWindowServerDecoder : public MessageDecoder {
public:
BaseWindowServerDecoder() { }
int magic() const { return 320; }
std::unique_ptr<Message> decode(const char* buf, size_t size, size_t& decoded_msg_len) override
{
int msg_id, decoder_magic;
size_t saved_dml = decoded_msg_len;
Encoder::decode(buf, decoded_msg_len, decoder_magic);
Encoder::decode(buf, decoded_msg_len, msg_id);
if (magic() != decoder_magic) {
decoded_msg_len = saved_dml;
return nullptr;
}
message_key_t secret_key;
Encoder::decode(buf, decoded_msg_len, secret_key);
uint32_t var_connection_id;
int var_type;
uint32_t var_width;
uint32_t var_height;
int var_buffer_id;
LIPC::StringEncoder var_title;
LIPC::StringEncoder var_icon_path;
LIPC::StringEncoder var_bundle_id;
uint32_t var_color;
uint32_t var_menubar_style;
uint32_t var_window_id;
uint32_t var_status;
int var_format;
LG::Rect var_bounds;
LG::Rect var_rect;
uint32_t var_target_window_id;
int var_menu_id;
int var_item_id;
LG::Point<int> var_point;
LIPC::VectorEncoder<LIPC::StringEncoder> var_data;
switch (msg_id) {
case 1:
return new GreetMessage(secret_key);
case 2:
Encoder::decode(buf, decoded_msg_len, var_connection_id);
return new GreetMessageReply(secret_key, var_connection_id);
case 3:
Encoder::decode(buf, decoded_msg_len, var_type);
Encoder::decode(buf, decoded_msg_len, var_width);
Encoder::decode(buf, decoded_msg_len, var_height);
Encoder::decode(buf, decoded_msg_len, var_buffer_id);
Encoder::decode(buf, decoded_msg_len, var_title);
Encoder::decode(buf, decoded_msg_len, var_icon_path);
Encoder::decode(buf, decoded_msg_len, var_bundle_id);
Encoder::decode(buf, decoded_msg_len, var_color);
Encoder::decode(buf, decoded_msg_len, var_menubar_style);
return new CreateWindowMessage(secret_key, var_type, var_width, var_height, var_buffer_id, var_title, var_icon_path, var_bundle_id, var_color, var_menubar_style);
case 4:
Encoder::decode(buf, decoded_msg_len, var_window_id);
return new CreateWindowMessageReply(secret_key, var_window_id);
case 5:
Encoder::decode(buf, decoded_msg_len, var_window_id);
return new DestroyWindowMessage(secret_key, var_window_id);
case 6:
Encoder::decode(buf, decoded_msg_len, var_status);
return new DestroyWindowMessageReply(secret_key, var_status);
case 7:
Encoder::decode(buf, decoded_msg_len, var_window_id);
Encoder::decode(buf, decoded_msg_len, var_buffer_id);
Encoder::decode(buf, decoded_msg_len, var_format);
Encoder::decode(buf, decoded_msg_len, var_bounds);
return new SetBufferMessage(secret_key, var_window_id, var_buffer_id, var_format, var_bounds);
case 8:
Encoder::decode(buf, decoded_msg_len, var_window_id);
Encoder::decode(buf, decoded_msg_len, var_color);
Encoder::decode(buf, decoded_msg_len, var_menubar_style);
return new SetBarStyleMessage(secret_key, var_window_id, var_color, var_menubar_style);
case 9:
Encoder::decode(buf, decoded_msg_len, var_window_id);
Encoder::decode(buf, decoded_msg_len, var_title);
return new SetTitleMessage(secret_key, var_window_id, var_title);
case 10:
Encoder::decode(buf, decoded_msg_len, var_window_id);
Encoder::decode(buf, decoded_msg_len, var_rect);
return new InvalidateMessage(secret_key, var_window_id, var_rect);
case 11:
Encoder::decode(buf, decoded_msg_len, var_window_id);
Encoder::decode(buf, decoded_msg_len, var_target_window_id);
return new AskBringToFrontMessage(secret_key, var_window_id, var_target_window_id);
case 12:
Encoder::decode(buf, decoded_msg_len, var_window_id);
Encoder::decode(buf, decoded_msg_len, var_title);
return new MenuBarCreateMenuMessage(secret_key, var_window_id, var_title);
case 13:
Encoder::decode(buf, decoded_msg_len, var_status);
Encoder::decode(buf, decoded_msg_len, var_menu_id);
return new MenuBarCreateMenuMessageReply(secret_key, var_status, var_menu_id);
case 14:
Encoder::decode(buf, decoded_msg_len, var_window_id);
Encoder::decode(buf, decoded_msg_len, var_menu_id);
Encoder::decode(buf, decoded_msg_len, var_item_id);
Encoder::decode(buf, decoded_msg_len, var_title);
return new MenuBarCreateItemMessage(secret_key, var_window_id, var_menu_id, var_item_id, var_title);
case 15:
Encoder::decode(buf, decoded_msg_len, var_status);
return new MenuBarCreateItemMessageReply(secret_key, var_status);
case 16:
Encoder::decode(buf, decoded_msg_len, var_window_id);
Encoder::decode(buf, decoded_msg_len, var_point);
Encoder::decode(buf, decoded_msg_len, var_data);
return new PopupShowMenuMessage(secret_key, var_window_id, var_point, var_data);
case 17:
Encoder::decode(buf, decoded_msg_len, var_status);
Encoder::decode(buf, decoded_msg_len, var_menu_id);
return new PopupShowMenuMessageReply(secret_key, var_status, var_menu_id);
default:
decoded_msg_len = saved_dml;
return nullptr;
}
}
std::unique_ptr<Message> handle(Message& msg) override
{
if (magic() != msg.decoder_magic()) {
return nullptr;
}
switch (msg.id()) {
case 1:
return handle(static_cast<GreetMessage&>(msg));
case 3:
return handle(static_cast<CreateWindowMessage&>(msg));
case 5:
return handle(static_cast<DestroyWindowMessage&>(msg));
case 7:
return handle(static_cast<SetBufferMessage&>(msg));
case 8:
return handle(static_cast<SetBarStyleMessage&>(msg));
case 9:
return handle(static_cast<SetTitleMessage&>(msg));
case 10:
return handle(static_cast<InvalidateMessage&>(msg));
case 11:
return handle(static_cast<AskBringToFrontMessage&>(msg));
case 12:
return handle(static_cast<MenuBarCreateMenuMessage&>(msg));
case 14:
return handle(static_cast<MenuBarCreateItemMessage&>(msg));
case 16:
return handle(static_cast<PopupShowMenuMessage&>(msg));
default:
return nullptr;
}
}
virtual std::unique_ptr<Message> handle(GreetMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(CreateWindowMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(DestroyWindowMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(SetBufferMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(SetBarStyleMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(SetTitleMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(InvalidateMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(AskBringToFrontMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(MenuBarCreateMenuMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(MenuBarCreateItemMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(PopupShowMenuMessage& msg) { return nullptr; }
};
class MouseMoveMessage : public Message {
public:
MouseMoveMessage(message_key_t key, int win_id, uint32_t x, uint32_t y)
: m_key(key)
, m_win_id(win_id)
, m_x(x)
, m_y(y)
{
}
int id() const override { return 1; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
uint32_t x() const { return m_x; }
uint32_t y() const { return m_y; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_x);
Encoder::append(buffer, m_y);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
uint32_t m_x;
uint32_t m_y;
};
class MouseActionMessage : public Message {
public:
MouseActionMessage(message_key_t key, int win_id, int type, uint32_t x, uint32_t y)
: m_key(key)
, m_win_id(win_id)
, m_type(type)
, m_x(x)
, m_y(y)
{
}
int id() const override { return 2; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
int type() const { return m_type; }
uint32_t x() const { return m_x; }
uint32_t y() const { return m_y; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_type);
Encoder::append(buffer, m_x);
Encoder::append(buffer, m_y);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
int m_type;
uint32_t m_x;
uint32_t m_y;
};
class MouseLeaveMessage : public Message {
public:
MouseLeaveMessage(message_key_t key, int win_id, uint32_t x, uint32_t y)
: m_key(key)
, m_win_id(win_id)
, m_x(x)
, m_y(y)
{
}
int id() const override { return 3; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
uint32_t x() const { return m_x; }
uint32_t y() const { return m_y; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_x);
Encoder::append(buffer, m_y);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
uint32_t m_x;
uint32_t m_y;
};
class MouseWheelMessage : public Message {
public:
MouseWheelMessage(message_key_t key, int win_id, int wheel_data, uint32_t x, uint32_t y)
: m_key(key)
, m_win_id(win_id)
, m_wheel_data(wheel_data)
, m_x(x)
, m_y(y)
{
}
int id() const override { return 4; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
int wheel_data() const { return m_wheel_data; }
uint32_t x() const { return m_x; }
uint32_t y() const { return m_y; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_wheel_data);
Encoder::append(buffer, m_x);
Encoder::append(buffer, m_y);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
int m_wheel_data;
uint32_t m_x;
uint32_t m_y;
};
class KeyboardMessage : public Message {
public:
KeyboardMessage(message_key_t key, int win_id, uint32_t kbd_key)
: m_key(key)
, m_win_id(win_id)
, m_kbd_key(kbd_key)
{
}
int id() const override { return 5; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
uint32_t kbd_key() const { return m_kbd_key; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_kbd_key);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
uint32_t m_kbd_key;
};
class DisplayMessage : public Message {
public:
DisplayMessage(message_key_t key, LG::Rect rect)
: m_key(key)
, m_rect(rect)
{
}
int id() const override { return 6; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
LG::Rect& rect() { return m_rect; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_rect);
return buffer;
}
private:
message_key_t m_key;
LG::Rect m_rect;
};
class WindowCloseRequestMessage : public Message {
public:
WindowCloseRequestMessage(message_key_t key, int win_id)
: m_key(key)
, m_win_id(win_id)
{
}
int id() const override { return 7; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
};
class ResizeMessage : public Message {
public:
ResizeMessage(message_key_t key, int win_id, LG::Rect rect)
: m_key(key)
, m_win_id(win_id)
, m_rect(rect)
{
}
int id() const override { return 8; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
LG::Rect& rect() { return m_rect; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_rect);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
LG::Rect m_rect;
};
class DisconnectMessage : public Message {
public:
DisconnectMessage(message_key_t key, int reason)
: m_key(key)
, m_reason(reason)
{
}
int id() const override { return 9; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int reason() const { return m_reason; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_reason);
return buffer;
}
private:
message_key_t m_key;
int m_reason;
};
class MenuBarActionMessage : public Message {
public:
MenuBarActionMessage(message_key_t key, int win_id, int menu_id, int item_id)
: m_key(key)
, m_win_id(win_id)
, m_menu_id(menu_id)
, m_item_id(item_id)
{
}
int id() const override { return 10; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
int menu_id() const { return m_menu_id; }
int item_id() const { return m_item_id; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_menu_id);
Encoder::append(buffer, m_item_id);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
int m_menu_id;
int m_item_id;
};
class PopupActionMessage : public Message {
public:
PopupActionMessage(message_key_t key, int win_id, int menu_id, int item_id)
: m_key(key)
, m_win_id(win_id)
, m_menu_id(menu_id)
, m_item_id(item_id)
{
}
int id() const override { return 11; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
int menu_id() const { return m_menu_id; }
int item_id() const { return m_item_id; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_menu_id);
Encoder::append(buffer, m_item_id);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
int m_menu_id;
int m_item_id;
};
class NotifyWindowCreateMessage : public Message {
public:
NotifyWindowCreateMessage(message_key_t key, int win_id, LIPC::StringEncoder bundle_id, LIPC::StringEncoder icon_path, int changed_window_id, int changed_window_type)
: m_key(key)
, m_win_id(win_id)
, m_bundle_id(bundle_id)
, m_icon_path(icon_path)
, m_changed_window_id(changed_window_id)
, m_changed_window_type(changed_window_type)
{
}
int id() const override { return 12; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
LIPC::StringEncoder& bundle_id() { return m_bundle_id; }
LIPC::StringEncoder& icon_path() { return m_icon_path; }
int changed_window_id() const { return m_changed_window_id; }
int changed_window_type() const { return m_changed_window_type; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_bundle_id);
Encoder::append(buffer, m_icon_path);
Encoder::append(buffer, m_changed_window_id);
Encoder::append(buffer, m_changed_window_type);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
LIPC::StringEncoder m_bundle_id;
LIPC::StringEncoder m_icon_path;
int m_changed_window_id;
int m_changed_window_type;
};
class NotifyWindowStatusChangedMessage : public Message {
public:
NotifyWindowStatusChangedMessage(message_key_t key, int win_id, int changed_window_id, int type)
: m_key(key)
, m_win_id(win_id)
, m_changed_window_id(changed_window_id)
, m_type(type)
{
}
int id() const override { return 13; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
int changed_window_id() const { return m_changed_window_id; }
int type() const { return m_type; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_changed_window_id);
Encoder::append(buffer, m_type);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
int m_changed_window_id;
int m_type;
};
class NotifyWindowTitleChangedMessage : public Message {
public:
NotifyWindowTitleChangedMessage(message_key_t key, int win_id, int changed_window_id, LIPC::StringEncoder title)
: m_key(key)
, m_win_id(win_id)
, m_changed_window_id(changed_window_id)
, m_title(title)
{
}
int id() const override { return 14; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
int changed_window_id() const { return m_changed_window_id; }
LIPC::StringEncoder& title() { return m_title; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_changed_window_id);
Encoder::append(buffer, m_title);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
int m_changed_window_id;
LIPC::StringEncoder m_title;
};
class NotifyWindowIconChangedMessage : public Message {
public:
NotifyWindowIconChangedMessage(message_key_t key, int win_id, int changed_window_id, LIPC::StringEncoder icon_path)
: m_key(key)
, m_win_id(win_id)
, m_changed_window_id(changed_window_id)
, m_icon_path(icon_path)
{
}
int id() const override { return 15; }
int reply_id() const override { return -1; }
int key() const override { return m_key; }
int decoder_magic() const override { return 737; }
int win_id() const { return m_win_id; }
int changed_window_id() const { return m_changed_window_id; }
LIPC::StringEncoder& icon_path() { return m_icon_path; }
EncodedMessage encode() const override
{
EncodedMessage buffer;
Encoder::append(buffer, decoder_magic());
Encoder::append(buffer, id());
Encoder::append(buffer, key());
Encoder::append(buffer, m_win_id);
Encoder::append(buffer, m_changed_window_id);
Encoder::append(buffer, m_icon_path);
return buffer;
}
private:
message_key_t m_key;
int m_win_id;
int m_changed_window_id;
LIPC::StringEncoder m_icon_path;
};
class BaseWindowClientDecoder : public MessageDecoder {
public:
BaseWindowClientDecoder() { }
int magic() const { return 737; }
std::unique_ptr<Message> decode(const char* buf, size_t size, size_t& decoded_msg_len) override
{
int msg_id, decoder_magic;
size_t saved_dml = decoded_msg_len;
Encoder::decode(buf, decoded_msg_len, decoder_magic);
Encoder::decode(buf, decoded_msg_len, msg_id);
if (magic() != decoder_magic) {
decoded_msg_len = saved_dml;
return nullptr;
}
message_key_t secret_key;
Encoder::decode(buf, decoded_msg_len, secret_key);
int var_win_id;
uint32_t var_x;
uint32_t var_y;
int var_type;
int var_wheel_data;
uint32_t var_kbd_key;
LG::Rect var_rect;
int var_reason;
int var_menu_id;
int var_item_id;
LIPC::StringEncoder var_bundle_id;
LIPC::StringEncoder var_icon_path;
int var_changed_window_id;
int var_changed_window_type;
LIPC::StringEncoder var_title;
switch (msg_id) {
case 1:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_x);
Encoder::decode(buf, decoded_msg_len, var_y);
return new MouseMoveMessage(secret_key, var_win_id, var_x, var_y);
case 2:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_type);
Encoder::decode(buf, decoded_msg_len, var_x);
Encoder::decode(buf, decoded_msg_len, var_y);
return new MouseActionMessage(secret_key, var_win_id, var_type, var_x, var_y);
case 3:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_x);
Encoder::decode(buf, decoded_msg_len, var_y);
return new MouseLeaveMessage(secret_key, var_win_id, var_x, var_y);
case 4:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_wheel_data);
Encoder::decode(buf, decoded_msg_len, var_x);
Encoder::decode(buf, decoded_msg_len, var_y);
return new MouseWheelMessage(secret_key, var_win_id, var_wheel_data, var_x, var_y);
case 5:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_kbd_key);
return new KeyboardMessage(secret_key, var_win_id, var_kbd_key);
case 6:
Encoder::decode(buf, decoded_msg_len, var_rect);
return new DisplayMessage(secret_key, var_rect);
case 7:
Encoder::decode(buf, decoded_msg_len, var_win_id);
return new WindowCloseRequestMessage(secret_key, var_win_id);
case 8:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_rect);
return new ResizeMessage(secret_key, var_win_id, var_rect);
case 9:
Encoder::decode(buf, decoded_msg_len, var_reason);
return new DisconnectMessage(secret_key, var_reason);
case 10:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_menu_id);
Encoder::decode(buf, decoded_msg_len, var_item_id);
return new MenuBarActionMessage(secret_key, var_win_id, var_menu_id, var_item_id);
case 11:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_menu_id);
Encoder::decode(buf, decoded_msg_len, var_item_id);
return new PopupActionMessage(secret_key, var_win_id, var_menu_id, var_item_id);
case 12:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_bundle_id);
Encoder::decode(buf, decoded_msg_len, var_icon_path);
Encoder::decode(buf, decoded_msg_len, var_changed_window_id);
Encoder::decode(buf, decoded_msg_len, var_changed_window_type);
return new NotifyWindowCreateMessage(secret_key, var_win_id, var_bundle_id, var_icon_path, var_changed_window_id, var_changed_window_type);
case 13:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_changed_window_id);
Encoder::decode(buf, decoded_msg_len, var_type);
return new NotifyWindowStatusChangedMessage(secret_key, var_win_id, var_changed_window_id, var_type);
case 14:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_changed_window_id);
Encoder::decode(buf, decoded_msg_len, var_title);
return new NotifyWindowTitleChangedMessage(secret_key, var_win_id, var_changed_window_id, var_title);
case 15:
Encoder::decode(buf, decoded_msg_len, var_win_id);
Encoder::decode(buf, decoded_msg_len, var_changed_window_id);
Encoder::decode(buf, decoded_msg_len, var_icon_path);
return new NotifyWindowIconChangedMessage(secret_key, var_win_id, var_changed_window_id, var_icon_path);
default:
decoded_msg_len = saved_dml;
return nullptr;
}
}
std::unique_ptr<Message> handle(Message& msg) override
{
if (magic() != msg.decoder_magic()) {
return nullptr;
}
switch (msg.id()) {
case 1:
return handle(static_cast<MouseMoveMessage&>(msg));
case 2:
return handle(static_cast<MouseActionMessage&>(msg));
case 3:
return handle(static_cast<MouseLeaveMessage&>(msg));
case 4:
return handle(static_cast<MouseWheelMessage&>(msg));
case 5:
return handle(static_cast<KeyboardMessage&>(msg));
case 6:
return handle(static_cast<DisplayMessage&>(msg));
case 7:
return handle(static_cast<WindowCloseRequestMessage&>(msg));
case 8:
return handle(static_cast<ResizeMessage&>(msg));
case 9:
return handle(static_cast<DisconnectMessage&>(msg));
case 10:
return handle(static_cast<MenuBarActionMessage&>(msg));
case 11:
return handle(static_cast<PopupActionMessage&>(msg));
case 12:
return handle(static_cast<NotifyWindowCreateMessage&>(msg));
case 13:
return handle(static_cast<NotifyWindowStatusChangedMessage&>(msg));
case 14:
return handle(static_cast<NotifyWindowTitleChangedMessage&>(msg));
case 15:
return handle(static_cast<NotifyWindowIconChangedMessage&>(msg));
default:
return nullptr;
}
}
virtual std::unique_ptr<Message> handle(MouseMoveMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(MouseActionMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(MouseLeaveMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(MouseWheelMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(KeyboardMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(DisplayMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(WindowCloseRequestMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(ResizeMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(DisconnectMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(MenuBarActionMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(PopupActionMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(NotifyWindowCreateMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(NotifyWindowStatusChangedMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(NotifyWindowTitleChangedMessage& msg) { return nullptr; }
virtual std::unique_ptr<Message> handle(NotifyWindowIconChangedMessage& msg) { return nullptr; }
};
|
willmexe/opuntiaOS | libs/libc/include/errno.h | <gh_stars>100-1000
#ifndef _LIBC_ERRNO_H
#define _LIBC_ERRNO_H
#include <bits/errno.h>
extern int errno;
#define set_errno(x) (errno = x)
#endif |
willmexe/opuntiaOS | libs/libc/posix/signal.c | <filename>libs/libc/posix/signal.c
#include <signal.h>
#include <sysdep.h>
#include <unistd.h>
int sigaction(int signo, void* callback)
{
int res = DO_SYSCALL_2(SYS_SIGACTION, signo, callback);
RETURN_WITH_ERRNO(res, 0, -1);
}
int raise(int signo)
{
return kill(getpid(), signo);
}
int kill(pid_t pid, int signo)
{
int res = DO_SYSCALL_2(SYS_KILL, pid, signo);
RETURN_WITH_ERRNO(res, 0, -1);
}
|
willmexe/opuntiaOS | libs/libc/include/sys/_structs.h | <filename>libs/libc/include/sys/_structs.h
#ifndef _LIBC_SYS__STRUCTS_H
#define _LIBC_SYS__STRUCTS_H
#endif |
willmexe/opuntiaOS | kernel/kernel/algo/ringbuffer.c | <filename>kernel/kernel/algo/ringbuffer.c<gh_stars>100-1000
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <algo/ringbuffer.h>
ringbuffer_t ringbuffer_create(size_t size)
{
ringbuffer_t buf;
buf.zone = kmemzone_new(size);
if (!buf.zone.start) {
return buf;
}
buf.start = 0;
buf.end = 0;
return buf;
}
void ringbuffer_free(ringbuffer_t* buf)
{
kmemzone_free(buf->zone);
buf->start = 0;
buf->end = 0;
}
size_t ringbuffer_space_to_read(ringbuffer_t* buf)
{
size_t res = buf->zone.len - buf->start + buf->end;
if (buf->start <= buf->end) {
res = buf->end - buf->start;
}
return res;
}
size_t ringbuffer_space_to_read_with_custom_start(ringbuffer_t* buf, size_t start)
{
start %= buf->zone.len;
size_t res = buf->zone.len - start + buf->end;
if (start <= buf->end) {
res = buf->end - start;
}
return res;
}
size_t ringbuffer_space_to_write(ringbuffer_t* buf)
{
size_t res = buf->zone.len - buf->end + buf->start;
if (buf->start > buf->end) {
res = buf->start - buf->end;
}
return res;
}
size_t ringbuffer_read(ringbuffer_t* buf, uint8_t* holder, size_t siz)
{
size_t i = 0;
if (buf->start > buf->end) {
for (; i < siz && buf->start < buf->zone.len; i++, buf->start++) {
holder[i] = buf->zone.ptr[buf->start];
}
if (buf->start == buf->zone.len) {
buf->start = 0;
}
}
for (; i < siz && buf->start < buf->end; i++, buf->start++) {
holder[i] = buf->zone.ptr[buf->start];
}
return i;
}
size_t ringbuffer_read_with_start(ringbuffer_t* buf, size_t start, uint8_t* holder, size_t siz)
{
size_t i = 0;
start %= buf->zone.len;
if (start > buf->end) {
for (; i < siz && start < buf->zone.len; i++, start++) {
holder[i] = buf->zone.ptr[start];
}
if (start == buf->zone.len) {
start = 0;
}
}
for (; i < siz && start < buf->end; i++, start++) {
holder[i] = buf->zone.ptr[start];
}
return i;
}
size_t ringbuffer_read_one(ringbuffer_t* buf, uint8_t* data)
{
if (buf->start != buf->end) {
*data = buf->zone.ptr[buf->start];
buf->start++;
if (buf->start == buf->zone.len) {
buf->start = 0;
}
return 1;
}
return 0;
}
size_t ringbuffer_write(ringbuffer_t* buf, const uint8_t* holder, size_t siz)
{
size_t i = 0;
if (buf->end >= buf->start) {
for (; i < siz && buf->end < buf->zone.len; i++, buf->end++) {
buf->zone.ptr[buf->end] = holder[i];
}
if (buf->end == buf->zone.len) {
buf->end = 0;
}
}
for (; i < siz && buf->end < buf->start; i++, buf->end++) {
buf->zone.ptr[buf->end] = holder[i];
}
return i;
}
size_t ringbuffer_write_ignore_bounds(ringbuffer_t* buf, const uint8_t* holder, size_t siz)
{
size_t i = 0;
for (; i < siz; i++) {
buf->zone.ptr[buf->end++] = holder[i];
if (buf->end == buf->zone.len) {
buf->end = 0;
}
}
return i;
}
size_t ringbuffer_write_one(ringbuffer_t* buf, uint8_t data)
{
if (buf->end + 1 != buf->start) {
buf->zone.ptr[buf->end] = data;
buf->end++;
if (buf->end == buf->zone.len) {
buf->end = 0;
}
return 1;
}
return 0;
}
void ringbuffer_clear(ringbuffer_t* buf)
{
buf->start = 0;
buf->end = 0;
} |
willmexe/opuntiaOS | kernel/include/platform/x86/registers.h | <filename>kernel/include/platform/x86/registers.h
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_PLATFORM_X86_REGISTERS_H
#define _KERNEL_PLATFORM_X86_REGISTERS_H
#include <libkern/types.h>
extern uintptr_t read_ip();
static inline uintptr_t read_cr2()
{
uintptr_t val;
asm volatile("movl %%cr2,%0"
: "=r"(val));
return val;
}
static inline uintptr_t read_cr3()
{
uintptr_t val;
asm volatile("movl %%cr3,%0"
: "=r"(val));
return val;
}
static inline uintptr_t read_sp()
{
uintptr_t val;
asm volatile("movl %%esp,%0"
: "=r"(val));
return val;
}
static inline uintptr_t read_bp()
{
uintptr_t val;
asm volatile("movl %%ebp,%0"
: "=r"(val));
return val;
}
static inline uintptr_t read_cr0()
{
uintptr_t val;
asm volatile("movl %%cr0, %0"
: "=r"(val));
return val;
}
static inline void write_cr0(uintptr_t val)
{
asm volatile("movl %0, %%cr0"
:
: "r"(val));
}
#endif /* _KERNEL_PLATFORM_X86_REGISTERS_H */ |
willmexe/opuntiaOS | libs/libc/malloc/malloc.c | #include "malloc.h"
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <sys/mman.h>
#define ALIGNMENT (4)
#define DEVIDE_SPACE_BOUNDARY (32)
static malloc_header_t* memory[MALLOC_MAX_ALLOCATED_BLOCKS];
static size_t allocated_blocks = 0;
static int _alloc_new_block(size_t sz);
static int _alloc_new_block(size_t sz)
{
sz += sizeof(malloc_header_t);
// this will reduce system calls for the small memory allocations
size_t allocated_sz = sz > MALLOC_DEFAULT_BLOCK_SIZE ? sz : MALLOC_DEFAULT_BLOCK_SIZE;
int ret = (int)mmap(NULL, allocated_sz, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
if (ret < 0) {
return -1;
}
memory[allocated_blocks] = (void*)ret; // allocating a new block of memory
memory[allocated_blocks]->flags = 0;
memory[allocated_blocks]->next = 0;
memory[allocated_blocks]->prev = 0;
memory[allocated_blocks]->size = allocated_sz - sizeof(malloc_header_t);
allocated_blocks++;
return 0;
}
static inline char _malloc_need_to_divide_space(malloc_header_t* space, size_t alloc_size)
{
return alloc_size + DEVIDE_SPACE_BOUNDARY <= space->size;
}
static inline char _malloc_can_fit_allocation(malloc_header_t* space, size_t alloc_size)
{
uint32_t add[] = { 0, sizeof(malloc_header_t) };
return space->size >= (alloc_size + add[_malloc_need_to_divide_space(space, alloc_size)]);
}
void* malloc(size_t sz)
{
if (!sz) {
return NULL;
}
sz += (ALIGNMENT - 1);
sz &= ~(uint32_t)(ALIGNMENT - 1);
void* res = slab_alloc(sz);
if (res) {
return res;
}
/* iterating over allocated by mmap blocks
and finding a first fit memory chunk */
malloc_header_t* first_fit = 0;
for (size_t i = 0; i < allocated_blocks; i++) {
malloc_header_t* cur_block = memory[i];
while (cur_block->next && !(block_is_free(cur_block) && _malloc_can_fit_allocation(cur_block, sz))) {
cur_block = cur_block->next;
}
if (block_is_free(cur_block) && _malloc_can_fit_allocation(cur_block, sz)) {
first_fit = cur_block;
break;
}
}
if (!first_fit) {
int err = _alloc_new_block(sz);
if (err) {
return NULL;
}
first_fit = memory[allocated_blocks - 1];
}
malloc_header_t* copy_next = first_fit->next;
size_t copy_size = first_fit->size;
first_fit->flags |= FLAG_ALLOCATED;
if (_malloc_need_to_divide_space(first_fit, sz)) {
first_fit->size = sz;
first_fit->next = (malloc_header_t*)((uintptr_t)first_fit + sz + sizeof(malloc_header_t));
// adjust the firstfit chunk
first_fit->next->flags = 0;
first_fit->next->size = copy_size - sz - sizeof(malloc_header_t);
first_fit->next->next = copy_next;
first_fit->next->prev = first_fit;
if (first_fit->next->next) {
first_fit->next->next->prev = first_fit->next;
}
}
return (void*)&((malloc_header_t*)first_fit)[1];
}
void free(void* mem)
{
if (!mem) {
return;
}
malloc_header_t* mem_header = &((malloc_header_t*)mem)[-1];
if (block_is_slab(mem_header)) {
return slab_free(mem_header);
}
block_rem_flags(mem_header, FLAG_ALLOCATED);
while (mem_header->prev && block_is_free(mem_header->prev)) {
mem_header = mem_header->prev;
}
// Trying to glue the freed chunk with its neighbours.
while (mem_header->next && block_is_free(mem_header->next)) {
mem_header->size += mem_header->next->size + sizeof(malloc_header_t);
if (mem_header->next->next) {
mem_header->next->next->prev = mem_header;
}
mem_header->next = mem_header->next->next;
}
}
void* calloc(size_t num, size_t size)
{
void* mem = malloc(num * size);
if (!mem) {
return NULL;
}
memset(mem, 0, num * size);
return mem;
}
void* realloc(void* ptr, size_t new_size)
{
if (!ptr) {
return malloc(new_size);
}
size_t old_size = ((malloc_header_t*)ptr)[-1].size;
if (old_size == new_size) {
return ptr;
}
uint8_t* new_area = malloc(new_size);
if (!new_area) {
return NULL;
}
memcpy(new_area, ptr, new_size < old_size ? new_size : old_size);
free(ptr);
return new_area;
}
void _malloc_init()
{
_slab_init();
} |
willmexe/opuntiaOS | libs/libipc/include/libipc/Encodable.h | #pragma once
#include <libipc/Encoder.h>
template <typename T>
class Encodable {
public:
virtual void encode(EncodedMessage& buf) const { }
}; |
willmexe/opuntiaOS | libs/libc/malloc/malloc.h | #ifndef _LIBC_MALLOC_MALLOC_H
#define _LIBC_MALLOC_MALLOC_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <sys/cdefs.h>
#include <sys/types.h>
__BEGIN_DECLS
#define MALLOC_DEFAULT_BLOCK_SIZE 4096
#define MALLOC_MAX_ALLOCATED_BLOCKS 64
#define FLAG_ALLOCATED (0x1)
#define FLAG_SLAB (0x2)
struct __malloc_header {
size_t size;
uint32_t flags;
struct __malloc_header* next;
struct __malloc_header* prev;
};
typedef struct __malloc_header malloc_header_t;
static inline bool block_has_flags(malloc_header_t* block, uint32_t flags)
{
return ((block->flags & flags) == flags);
}
static inline void block_set_flags(malloc_header_t* block, uint32_t flags)
{
block->flags |= flags;
}
static inline void block_rem_flags(malloc_header_t* block, uint32_t flags)
{
block->flags &= (~flags);
}
static inline bool block_is_allocated(malloc_header_t* block)
{
return block_has_flags(block, FLAG_ALLOCATED);
}
static inline bool block_is_free(malloc_header_t* block)
{
return !block_has_flags(block, FLAG_ALLOCATED);
}
static inline bool block_is_slab(malloc_header_t* block)
{
return block_has_flags(block, FLAG_SLAB);
}
void _malloc_init();
void _slab_init();
void* malloc(size_t);
void free(void*);
void* calloc(size_t, size_t);
void* realloc(void*, size_t);
void* slab_alloc(size_t);
void slab_free(malloc_header_t* mem_header);
__END_DECLS
#endif // _LIBC_MALLOC_MALLOC_H
|
willmexe/opuntiaOS | kernel/include/libkern/log.h | #ifndef _KERNEL_LIBKERN_LOG_H
#define _KERNEL_LIBKERN_LOG_H
#include <libkern/printf.h>
#include <libkern/types.h>
void logger_setup();
int log(const char* format, ...);
int log_warn(const char* format, ...);
int log_error(const char* format, ...);
int log_not_formatted(const char* format, ...);
#endif // _KERNEL_LIBKERN_LOG_H |
willmexe/opuntiaOS | libs/libc/include/bits/sys/mman.h | <filename>libs/libc/include/bits/sys/mman.h<gh_stars>100-1000
#ifndef _LIBC_BITS_SYS_MMAN_H
#define _LIBC_BITS_SYS_MMAN_H
#include <stddef.h>
#include <sys/types.h>
#define MAP_SHARED 0x01
#define MAP_PRIVATE 0x02
#define MAP_FIXED 0x10
#define MAP_ANONYMOUS 0x20
#define MAP_STACK 0x40
#define PROT_READ 0x1
#define PROT_WRITE 0x2
#define PROT_EXEC 0x4
#define PROT_NONE 0x0
struct mmap_params {
void* addr;
size_t size;
int prot;
int flags;
int fd;
off_t offset;
};
typedef struct mmap_params mmap_params_t;
#endif // _LIBC_BITS_SYS_MMAN_H |
willmexe/opuntiaOS | libs/libc/include/bits/sys/ptrace.h | #ifndef _LIBC_BITS_SYS_PTRACE_H
#define _LIBC_BITS_SYS_PTRACE_H
#include <stddef.h>
#include <sys/types.h>
typedef int ptrace_request_t;
#define PTRACE_TRACEME (0x1)
#define PTRACE_CONT (0x2)
#define PTRACE_PEEKTEXT (0x3)
#define PTRACE_PEEKDATA (0x4)
#endif // _LIBC_BITS_SYS_PTRACE_H |
willmexe/opuntiaOS | kernel/include/mem/vm_pspace.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_MEM_VM_PSPACE_H
#define _KERNEL_MEM_VM_PSPACE_H
#include <libkern/libkern.h>
#include <mem/bits/vm.h>
ptable_t* vm_pspace_get_nth_active_ptable(size_t n);
ptable_t* vm_pspace_get_vaddr_of_active_ptable(uintptr_t vaddr);
page_desc_t* vm_pspace_get_page_desc(uintptr_t vaddr);
void vm_pspace_init();
void vm_pspace_gen(pdirectory_t* pdir);
void vm_pspace_free(pdirectory_t* pdir);
int vm_pspace_on_ptable_mapped(uintptr_t vaddr, uintptr_t ptable_paddr, ptable_lv_t level);
#endif // _KERNEL_MEM_VM_PSPACE_H
|
willmexe/opuntiaOS | userland/utilities/edit/main.c | #include "file.h"
#include "lifetime.h"
#include "menu.h"
#include "mode.h"
#include "viewer.h"
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define STDIN 0
#define STDOUT 1
uint32_t mode;
mode_disc_t mode_disc;
void viewing_accept_key(char key)
{
if (key == ':') {
menu_enter_mode();
return;
}
if (key == 'w') {
viewer_cursor_up();
return;
}
if (key == 's') {
viewer_cursor_down();
return;
}
if (key == 'a') {
viewer_cursor_left();
return;
}
if (key == 'd') {
viewer_cursor_right();
return;
}
file_paste_char(key, viewer_get_cursor_offset_in_file());
}
char get_key()
{
char c;
if (read(STDIN, &c, 1) != 1) {
crash_app();
}
return c;
}
void process_input()
{
for (;;) {
char key = get_key();
mode_disc.accept_key(key);
}
}
void display_file(char* path)
{
int fd = file_open(path);
}
void init_mode()
{
mode = VIEWING;
mode_disc.accept_key = viewing_accept_key;
}
int main(int argc, char** argv)
{
if (argc < 2) {
return 0;
}
enable_raw_mode();
init_mode();
display_file(argv[1]);
process_input();
exit_app();
} |
willmexe/opuntiaOS | libs/libc/stdlib/exit.c | <filename>libs/libc/stdlib/exit.c
#include <signal.h>
#include <stdlib.h>
#include <sysdep.h>
void exit(int status)
{
DO_SYSCALL_1(SYS_EXIT, status);
__builtin_unreachable();
}
void abort()
{
raise(SIGABRT);
exit(127);
}
|
willmexe/opuntiaOS | kernel/include/drivers/aarch32/fpuv4.h | <filename>kernel/include/drivers/aarch32/fpuv4.h<gh_stars>100-1000
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_DRIVERS_AARCH32_FPUV4_H
#define _KERNEL_DRIVERS_AARCH32_FPUV4_H
#include <drivers/driver_manager.h>
#include <libkern/mask.h>
#include <libkern/types.h>
#include <platform/aarch32/interrupts.h>
#include <platform/aarch32/registers.h>
#include <platform/aarch32/target/cortex-a15/device_settings.h>
#define FPU_STATE_ALIGNMENT (16)
typedef struct {
uint64_t d[32];
} __attribute__((aligned(FPU_STATE_ALIGNMENT))) fpu_state_t;
void fpuv4_install();
void fpu_init_state(fpu_state_t* new_fpu_state);
extern uint32_t read_fpexc();
extern void write_fpexc(uint32_t);
extern void fpu_save(void*);
extern void fpu_restore(void*);
static inline void fpu_enable()
{
write_fpexc(read_fpexc() | (1 << 30));
}
static inline void fpu_disable()
{
write_fpexc(read_fpexc() & (~(1 << 30)));
}
static inline int fpu_is_avail()
{
return (((read_cpacr() >> 20) & 0b1111) == 0b1111);
}
static inline void fpu_make_avail()
{
write_cpacr(read_cpacr() | ((0b1111) << 20));
}
static inline void fpu_make_unavail()
{
// Simply turn it off to make it unavailble.
uint32_t val = read_cpacr() & (~((0b1111) << 20));
write_cpacr(val | ((0b0101) << 20));
}
#endif //_KERNEL_DRIVERS_AARCH32_FPUV4_H
|
willmexe/opuntiaOS | kernel/include/platform/x86/tasking/context.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_PLATFORM_X86_TASKING_CONTEXT_H
#define _KERNEL_PLATFORM_X86_TASKING_CONTEXT_H
#include <libkern/c_attrs.h>
#include <libkern/types.h>
struct PACKED context {
uint32_t edi;
uint32_t esi;
uint32_t ebx;
uint32_t ebp;
uint32_t eip;
};
typedef struct context context_t;
static inline uintptr_t context_get_instruction_pointer(context_t* ctx)
{
return ctx->eip;
}
static inline void context_set_instruction_pointer(context_t* ctx, uintptr_t ip)
{
ctx->eip = ip;
}
#endif // _KERNEL_PLATFORM_X86_TASKING_CONTEXT_H |
willmexe/opuntiaOS | kernel/include/platform/aarch32/vmm/pde.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_PLATFORM_AARCH32_VMM_PDE_H
#define _KERNEL_PLATFORM_AARCH32_VMM_PDE_H
#include <libkern/c_attrs.h>
#include <libkern/types.h>
struct PACKED table_desc {
union {
struct {
int valid : 1; /* Valid mapping */
int zero1 : 1;
int zero2 : 1;
int ns : 1;
int zero3 : 1;
int domain : 4;
int imp : 1;
int baddr : 22;
};
uint32_t data;
};
};
typedef struct table_desc table_desc_t;
#define pde_t table_desc_t
#define TABLE_DESC_FRAME_OFFSET 10
enum TABLE_DESC_PAGE_FLAGS {
TABLE_DESC_PRESENT = 0x1,
TABLE_DESC_WRITABLE = 0x2,
TABLE_DESC_USER = 0x4,
TABLE_DESC_PWT = 0x8,
TABLE_DESC_PCD = 0x10,
TABLE_DESC_ACCESSED = 0x20,
TABLE_DESC_DIRTY = 0x40,
TABLE_DESC_4MB = 0x80,
TABLE_DESC_CPU_GLOBAL = 0x100,
TABLE_DESC_LV4_GLOBAL = 0x200,
TABLE_DESC_COPY_ON_WRITE = 0x400,
TABLE_DESC_ZEROING_ON_DEMAND = 0x800
};
void table_desc_init(table_desc_t* pde);
void table_desc_set_allocated_state(table_desc_t* pde);
bool table_desc_is_in_allocated_state(table_desc_t* pde);
void table_desc_clear(table_desc_t* pde);
void table_desc_set_attrs(table_desc_t* pde, uint32_t attrs);
void table_desc_del_attrs(table_desc_t* pde, uint32_t attrs);
bool table_desc_has_attrs(table_desc_t pde, uint32_t attrs);
void table_desc_set_frame(table_desc_t* pde, uint32_t frame);
void table_desc_del_frame(table_desc_t* pde);
bool table_desc_is_present(table_desc_t pde);
bool table_desc_is_writable(table_desc_t pde);
bool table_desc_is_4mb(table_desc_t pde);
bool table_desc_is_copy_on_write(table_desc_t pde);
uint32_t table_desc_get_frame(table_desc_t pde);
#endif //_KERNEL_PLATFORM_AARCH32_VMM_PDE_H
|
willmexe/opuntiaOS | kernel/include/platform/generic/pmm/settings.h | #ifdef __i386__
#include <platform/x86/pmm/settings.h>
#elif __arm__
#include <platform/aarch32/pmm/settings.h>
#endif |
willmexe/opuntiaOS | userland/utilities/rm/main.c | <gh_stars>100-1000
#include <unistd.h>
int main(int argc, char** argv)
{
if (argc < 2) {
write(1, "Usage: rm files...\n", 21);
return 0;
}
for (int i = 1; i < argc; i++) {
if (unlink(argv[i]) < 0) {
write(1, "rm: failed to delete\n", 21);
break;
}
}
return 0;
} |
willmexe/opuntiaOS | libs/libc/include/bits/sys/wait.h | #ifndef _LIBC_BITS_SYS_WAIT_H
#define _LIBC_BITS_SYS_WAIT_H
#define WNOHANG 0x1
#define WUNTRACED 0x2
#endif // _LIBC_BITS_SYS_WAIT_H |
willmexe/opuntiaOS | servers/window_server/src/Components/Popup/Popup.h | <filename>servers/window_server/src/Components/Popup/Popup.h
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#pragma once
#include "../../Managers/Compositor.h"
#include "../../Managers/CursorManager.h"
#include <functional>
#include <libg/Color.h>
#include <libg/Context.h>
#include <string>
#include <vector>
namespace WinServer {
struct PopupItem {
int id;
std::string text;
std::function<void(int)> callback;
static const int InternalId = -1;
};
using PopupData = std::vector<PopupItem>;
class Popup {
public:
inline static Popup& the()
{
extern Popup* s_WinServer_Popup_the;
return *s_WinServer_Popup_the;
}
Popup();
~Popup() = default;
constexpr int spacing() const { return 8; }
constexpr size_t min_width() const { return 180u; }
void set_preferred_origin(const LG::Point<int>& origin);
inline LG::Rect& bounds() { return m_bounds; }
inline const LG::Rect& bounds() const { return m_bounds; }
inline LG::Rect draw_frame() const
{
const int shadow_spread = LG::Shading::SystemSpread;
return LG::Rect(bounds().min_x() - shadow_spread, bounds().min_y() - shadow_spread, bounds().width() + 2 * shadow_spread, bounds().height() + 2 * shadow_spread);
}
inline void set_visible(bool vis)
{
if (m_visible != vis) {
Compositor::the().invalidate(draw_frame());
}
m_visible = vis;
}
inline bool visible() const { return m_visible; }
void show(const LG::Point<int>& origin, PopupData& data)
{
set_visible(false);
set_data(data);
set_preferred_origin(origin);
set_visible(true);
}
void hide()
{
m_hovered_item = HoveredItem::No;
set_visible(false);
}
void on_set_data();
void set_data(const PopupData& data) { m_data = data, on_set_data(); }
void set_data(PopupData&& data) { m_data = std::move(data), on_set_data(); }
void on_mouse_move(const CursorManager& cursor_manager)
{
// A simple implemetation to get hover effect and clicks.
if (!visible()) {
return;
}
size_t data_size = m_data.size();
const size_t line_height = (m_font.glyph_height() + 8);
int prev_hovered_item = m_hovered_item;
int rel_y = cursor_manager.y() - bounds().min_y();
rel_y -= 4; // Offset of the first element;
m_hovered_item = rel_y / line_height;
if (m_hovered_item >= data_size) {
m_hovered_item = HoveredItem::No;
}
if (m_hovered_item != prev_hovered_item && prev_hovered_item != HoveredItem::No) {
Compositor::the().invalidate(LG::Rect(bounds().min_x(), bounds().min_y() + 4 + line_height * prev_hovered_item, bounds().width(), line_height));
}
if (m_hovered_item != prev_hovered_item && m_hovered_item != HoveredItem::No) {
Compositor::the().invalidate(LG::Rect(bounds().min_x(), bounds().min_y() + 4 + line_height * m_hovered_item, bounds().width(), line_height));
}
}
inline void on_mouse_status_change(const CursorManager& cursor_manager)
{
if (m_hovered_item == HoveredItem::No) {
return;
}
if (!visible()) {
return;
}
auto& data = m_data;
if (cursor_manager.pressed<CursorManager::Params::LeftButton>()) {
data[m_hovered_item].callback((int)data[m_hovered_item].id);
hide();
}
}
void on_mouse_leave(const CursorManager& cursor_manager)
{
if (m_hovered_item == HoveredItem::No) {
return;
}
if (!visible()) {
return;
}
const size_t line_height = (m_font.glyph_height() + 8);
Compositor::the().invalidate(LG::Rect(bounds().min_x(), bounds().min_y() + 4 + line_height * m_hovered_item, bounds().width(), line_height));
m_hovered_item = HoveredItem::No;
}
void draw(LG::Context& ctx);
private:
enum HoveredItem {
No = -1,
};
LG::Rect m_bounds { 0, 0, 0, 0 };
bool m_visible { false };
PopupData m_data;
int m_hovered_item { HoveredItem::No };
LG::Font& m_font { LG::Font::system_font() };
};
} // namespace WinServer |
willmexe/opuntiaOS | libs/libg/include/libg/CornerMask.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#pragma once
#include <cstddef>
#include <sys/types.h>
namespace LG {
class CornerMask {
public:
static constexpr bool Masked = true;
static constexpr bool NonMasked = false;
static constexpr size_t SystemRadius = 4;
CornerMask() = default;
CornerMask(size_t radius, bool top_rounded = Masked, bool bottom_rounded = Masked)
: m_radius(radius)
, m_top_rounded(top_rounded)
, m_bottom_rounded(bottom_rounded)
{
}
~CornerMask() = default;
static CornerMask Standard() { return CornerMask(SystemRadius, Masked, Masked); }
size_t radius() const { return m_radius; }
bool top_rounded() const { return m_top_rounded; }
bool bottom_rounded() const { return m_bottom_rounded; }
private:
size_t m_radius { 0 };
bool m_top_rounded { Masked };
bool m_bottom_rounded { Masked };
};
} // namespace LG |
willmexe/opuntiaOS | kernel/include/libkern/mem.h | <filename>kernel/include/libkern/mem.h
#ifndef _KERNEL_LIBKERN_MEM_H
#define _KERNEL_LIBKERN_MEM_H
#include <libkern/types.h>
void* memset(void* dest, uint8_t fll, uint32_t nbytes);
void* memcpy(void* dest, const void* src, uint32_t nbytes);
void* memccpy(void* dest, const void* src, uint8_t stop, uint32_t nbytes);
void* memmove(void* dest, const void* src, uint32_t nbytes);
int memcmp(const void* src1, const void* src2, uint32_t nbytes);
char* kmem_bring_to_kernel(const char* data, uint32_t size);
char** kmem_bring_to_kernel_ptrarr(const char** data, uint32_t size);
#endif // _KERNEL_LIBKERN_MEM_H
|
willmexe/opuntiaOS | kernel/include/libkern/bits/syscalls.h | <gh_stars>100-1000
// Compiled with utils/legacy/syscall_parser.py
#ifndef _KERNEL_LIBKERN_BITS_SYSCALLS_H
#define _KERNEL_LIBKERN_BITS_SYSCALLS_H
#ifdef __i386__
enum __sysid {
SYS_RESTART_SYSCALL = 0,
SYS_EXIT = 1,
SYS_FORK = 2,
SYS_READ = 3,
SYS_WRITE = 4,
SYS_OPEN = 5,
SYS_CLOSE = 6,
SYS_WAITPID = 7,
SYS_CREAT = 8,
SYS_LINK = 9,
SYS_UNLINK = 10,
SYS_EXECVE = 11,
SYS_CHDIR = 12,
SYS_TIME = 13,
SYS_MKNOD = 14,
SYS_CHMOD = 15,
SYS_LCHOWN = 16,
SYS_BREAK = 17,
SYS_OLDSTAT = 18,
SYS_LSEEK = 19,
SYS_GETPID = 20,
SYS_MOUNT = 21,
SYS_UMOUNT = 22,
SYS_SETUID = 23,
SYS_GETUID = 24,
SYS_STIME = 25,
SYS_PTRACE = 26,
SYS_ALARM = 27,
SYS_OLDFSTAT = 28,
SYS_PAUSE = 29,
SYS_UTIME = 30,
SYS_STTY = 31,
SYS_GTTY = 32,
SYS_ACCESS = 33,
SYS_NICE = 34,
SYS_FTIME = 35,
SYS_SYNC = 36,
SYS_KILL = 37,
SYS_RENAME = 38,
SYS_MKDIR = 39,
SYS_RMDIR = 40,
SYS_DUP = 41,
SYS_PIPE = 42,
SYS_TIMES = 43,
SYS_PROF = 44,
SYS_BRK = 45,
SYS_SETGID = 46,
SYS_GETGID = 47,
SYS_SIGNAL = 48,
SYS_GETEUID = 49,
SYS_GETEGID = 50,
SYS_ACCT = 51,
SYS_UMOUNT2 = 52,
SYS_LOCK = 53,
SYS_IOCTL = 54,
SYS_FCNTL = 55,
SYS_MPX = 56,
SYS_SETPGID = 57,
SYS_ULIMIT = 58,
SYS_OLDOLDUNAME = 59,
SYS_UMASK = 60,
SYS_CHROOT = 61,
SYS_USTAT = 62,
SYS_DUP2 = 63,
SYS_GETPPID = 64,
SYS_GETPGRP = 65,
SYS_SETSID = 66,
SYS_SIGACTION = 67,
SYS_SGETMASK = 68,
SYS_SSETMASK = 69,
SYS_SETREUID = 70,
SYS_SETREGID = 71,
SYS_SIGSUSPEND = 72,
SYS_SIGPENDING = 73,
SYS_SETHOSTNAME = 74,
SYS_SETRLIMIT = 75,
SYS_GETRLIMIT = 76,
SYS_GETRUSAGE = 77,
SYS_GETTIMEOFDAY = 78,
SYS_SETTIMEOFDAY = 79,
SYS_GETGROUPS = 80,
SYS_SETGROUPS = 81,
SYS_SELECT = 82,
SYS_SYMLINK = 83,
SYS_OLDLSTAT = 84,
SYS_READLINK = 85,
SYS_USELIB = 86,
SYS_SWAPON = 87,
SYS_REBOOT = 88,
SYS_READDIR = 89,
SYS_MMAP = 90,
SYS_MUNMAP = 91,
SYS_TRUNCATE = 92,
SYS_FTRUNCATE = 93,
SYS_FCHMOD = 94,
SYS_FCHOWN = 95,
SYS_GETPRIORITY = 96,
SYS_SETPRIORITY = 97,
SYS_PROFIL = 98,
SYS_STATFS = 99,
SYS_FSTATFS = 100,
SYS_IOPERM = 101,
SYS_SOCKETCALL = 102,
SYS_SYSLOG = 103,
SYS_SETITIMER = 104,
SYS_GETITIMER = 105,
SYS_STAT = 106,
SYS_LSTAT = 107,
SYS_FSTAT = 108,
SYS_OLDUNAME = 109,
SYS_IOPL = 110,
SYS_VHANGUP = 111,
SYS_IDLE = 112,
SYS_VM86OLD = 113,
SYS_WAIT4 = 114,
SYS_SWAPOFF = 115,
SYS_SYSINFO = 116,
SYS_IPC = 117,
SYS_FSYNC = 118,
SYS_SIGRETURN = 119,
SYS_CLONE = 120,
SYS_SETDOMAINNAME = 121,
SYS_UNAME = 122,
SYS_MODIFY_LDT = 123,
SYS_ADJTIMEX = 124,
SYS_MPROTECT = 125,
SYS_SIGPROCMASK = 126,
SYS_CREATE_MODULE = 127,
SYS_INIT_MODULE = 128,
SYS_DELETE_MODULE = 129,
SYS_GET_KERNEL_SYMS = 130,
SYS_QUOTACTL = 131,
SYS_GETPGID = 132,
SYS_FCHDIR = 133,
SYS_BDFLUSH = 134,
SYS_SYSFS = 135,
SYS_PERSONALITY = 136,
SYS_AFS_SYSCALL = 137,
SYS_SETFSUID = 138,
SYS_SETFSGID = 139,
SYS__LLSEEK = 140,
SYS_GETDENTS = 141,
SYS__NEWSELECT = 142,
SYS_FLOCK = 143,
SYS_MSYNC = 144,
SYS_READV = 145,
SYS_WRITEV = 146,
SYS_GETSID = 147,
SYS_FDATASYNC = 148,
SYS__SYSCTL = 149,
SYS_MLOCK = 150,
SYS_MUNLOCK = 151,
SYS_MLOCKALL = 152,
SYS_MUNLOCKALL = 153,
SYS_SCHED_SETPARAM = 154,
SYS_SCHED_GETPARAM = 155,
SYS_SCHED_SETSCHEDULER = 156,
SYS_SCHED_GETSCHEDULER = 157,
SYS_SCHED_YIELD = 158,
SYS_SCHED_GET_PRIORITY_MAX = 159,
SYS_SCHED_GET_PRIORITY_MIN = 160,
SYS_SCHED_RR_GET_INTERVAL = 161,
SYS_NANOSLEEP = 162,
SYS_MREMAP = 163,
SYS_SETRESUID = 164,
SYS_GETRESUID = 165,
SYS_VM86 = 166,
SYS_QUERY_MODULE = 167,
SYS_POLL = 168,
SYS_NFSSERVCTL = 169,
SYS_SETRESGID = 170,
SYS_GETRESGID = 171,
SYS_PRCTL = 172,
SYS_RT_SIGRETURN = 173,
SYS_RT_SIGACTION = 174,
SYS_RT_SIGPROCMASK = 175,
SYS_RT_SIGPENDING = 176,
SYS_RT_SIGTIMEDWAIT = 177,
SYS_RT_SIGQUEUEINFO = 178,
SYS_RT_SIGSUSPEND = 179,
SYS_PREAD64 = 180,
SYS_PWRITE64 = 181,
SYS_CHOWN = 182,
SYS_GETCWD = 183,
SYS_CAPGET = 184,
SYS_CAPSET = 185,
SYS_SIGALTSTACK = 186,
SYS_SENDFILE = 187,
SYS_GETPMSG = 188,
SYS_PUTPMSG = 189,
SYS_VFORK = 190,
SYS_UGETRLIMIT = 191,
SYS_MMAP2 = 192,
SYS_TRUNCATE64 = 193,
SYS_FTRUNCATE64 = 194,
SYS_STAT64 = 195,
SYS_LSTAT64 = 196,
SYS_FSTAT64 = 197,
SYS_LCHOWN32 = 198,
SYS_GETUID32 = 199,
SYS_GETGID32 = 200,
SYS_GETEUID32 = 201,
SYS_GETEGID32 = 202,
SYS_SETREUID32 = 203,
SYS_SETREGID32 = 204,
SYS_GETGROUPS32 = 205,
SYS_SETGROUPS32 = 206,
SYS_FCHOWN32 = 207,
SYS_SETRESUID32 = 208,
SYS_GETRESUID32 = 209,
SYS_SETRESGID32 = 210,
SYS_GETRESGID32 = 211,
SYS_CHOWN32 = 212,
SYS_SETUID32 = 213,
SYS_SETGID32 = 214,
SYS_SETFSUID32 = 215,
SYS_SETFSGID32 = 216,
SYS_PIVOT_ROOT = 217,
SYS_MINCORE = 218,
SYS_MADVISE = 219,
SYS_GETDENTS64 = 220,
SYS_FCNTL64 = 221,
SYS_GETTID = 224,
SYS_READAHEAD = 225,
SYS_SETXATTR = 226,
SYS_LSETXATTR = 227,
SYS_FSETXATTR = 228,
SYS_GETXATTR = 229,
SYS_LGETXATTR = 230,
SYS_FGETXATTR = 231,
SYS_LISTXATTR = 232,
SYS_LLISTXATTR = 233,
SYS_FLISTXATTR = 234,
SYS_REMOVEXATTR = 235,
SYS_LREMOVEXATTR = 236,
SYS_FREMOVEXATTR = 237,
SYS_TKILL = 238,
SYS_SENDFILE64 = 239,
SYS_FUTEX = 240,
SYS_SCHED_SETAFFINITY = 241,
SYS_SCHED_GETAFFINITY = 242,
SYS_SET_THREAD_AREA = 243,
SYS_GET_THREAD_AREA = 244,
SYS_IO_SETUP = 245,
SYS_IO_DESTROY = 246,
SYS_IO_GETEVENTS = 247,
SYS_IO_SUBMIT = 248,
SYS_IO_CANCEL = 249,
SYS_FADVISE64 = 250,
SYS_EXIT_GROUP = 252,
SYS_LOOKUP_DCOOKIE = 253,
SYS_EPOLL_CREATE = 254,
SYS_EPOLL_CTL = 255,
SYS_EPOLL_WAIT = 256,
SYS_REMAP_FILE_PAGES = 257,
SYS_SET_TID_ADDRESS = 258,
SYS_TIMER_CREATE = 259,
SYS_TIMER_SETTIME = 260,
SYS_TIMER_GETTIME = 261,
SYS_TIMER_GETOVERRUN = 262,
SYS_TIMER_DELETE = 263,
SYS_CLOCK_SETTIME = 264,
SYS_CLOCK_GETTIME = 265,
SYS_CLOCK_GETRES = 266,
SYS_CLOCK_NANOSLEEP = 267,
SYS_STATFS64 = 268,
SYS_FSTATFS64 = 269,
SYS_TGKILL = 270,
SYS_UTIMES = 271,
SYS_FADVISE64_64 = 272,
SYS_VSERVER = 273,
SYS_MBIND = 274,
SYS_GET_MEMPOLICY = 275,
SYS_SET_MEMPOLICY = 276,
SYS_MQ_OPEN = 277,
SYS_MQ_UNLINK = 278,
SYS_MQ_TIMEDSEND = 279,
SYS_MQ_TIMEDRECEIVE = 280,
SYS_MQ_NOTIFY = 281,
SYS_MQ_GETSETATTR = 282,
SYS_KEXEC_LOAD = 283,
SYS_WAITID = 284,
SYS_ADD_KEY = 286,
SYS_REQUEST_KEY = 287,
SYS_KEYCTL = 288,
SYS_IOPRIO_SET = 289,
SYS_IOPRIO_GET = 290,
SYS_INOTIFY_INIT = 291,
SYS_INOTIFY_ADD_WATCH = 292,
SYS_INOTIFY_RM_WATCH = 293,
SYS_MIGRATE_PAGES = 294,
SYS_OPENAT = 295,
SYS_MKDIRAT = 296,
SYS_MKNODAT = 297,
SYS_FCHOWNAT = 298,
SYS_FUTIMESAT = 299,
SYS_FSTATAT64 = 300,
SYS_UNLINKAT = 301,
SYS_RENAMEAT = 302,
SYS_LINKAT = 303,
SYS_SYMLINKAT = 304,
SYS_READLINKAT = 305,
SYS_FCHMODAT = 306,
SYS_FACCESSAT = 307,
SYS_PSELECT6 = 308,
SYS_PPOLL = 309,
SYS_UNSHARE = 310,
SYS_SET_ROBUST_LIST = 311,
SYS_GET_ROBUST_LIST = 312,
SYS_SPLICE = 313,
SYS_SYNC_FILE_RANGE = 314,
SYS_TEE = 315,
SYS_VMSPLICE = 316,
SYS_MOVE_PAGES = 317,
SYS_GETCPU = 318,
SYS_EPOLL_PWAIT = 319,
SYS_UTIMENSAT = 320,
SYS_SIGNALFD = 321,
SYS_TIMERFD_CREATE = 322,
SYS_EVENTFD = 323,
SYS_FALLOCATE = 324,
SYS_TIMERFD_SETTIME = 325,
SYS_TIMERFD_GETTIME = 326,
SYS_SIGNALFD4 = 327,
SYS_EVENTFD2 = 328,
SYS_EPOLL_CREATE1 = 329,
SYS_DUP3 = 330,
SYS_PIPE2 = 331,
SYS_INOTIFY_INIT1 = 332,
SYS_PREADV = 333,
SYS_PWRITEV = 334,
SYS_RT_TGSIGQUEUEINFO = 335,
SYS_PERF_EVENT_OPEN = 336,
SYS_RECVMMSG = 337,
SYS_FANOTIFY_INIT = 338,
SYS_FANOTIFY_MARK = 339,
SYS_PRLIMIT64 = 340,
SYS_NAME_TO_HANDLE_AT = 341,
SYS_OPEN_BY_HANDLE_AT = 342,
SYS_CLOCK_ADJTIME = 343,
SYS_SYNCFS = 344,
SYS_SENDMMSG = 345,
SYS_SETNS = 346,
SYS_PROCESS_VM_READV = 347,
SYS_PROCESS_VM_WRITEV = 348,
SYS_KCMP = 349,
SYS_FINIT_MODULE = 350,
SYS_SCHED_SETATTR = 351,
SYS_SCHED_GETATTR = 352,
SYS_RENAMEAT2 = 353,
SYS_SECCOMP = 354,
SYS_GETRANDOM = 355,
SYS_MEMFD_CREATE = 356,
SYS_BPF = 357,
SYS_EXECVEAT = 358,
SYS_SOCKET = 359,
SYS_SOCKETPAIR = 360,
SYS_BIND = 361,
SYS_CONNECT = 362,
SYS_LISTEN = 363,
SYS_ACCEPT4 = 364,
SYS_GETSOCKOPT = 365,
SYS_SETSOCKOPT = 366,
SYS_GETSOCKNAME = 367,
SYS_GETPEERNAME = 368,
SYS_SENDTO = 369,
SYS_SENDMSG = 370,
SYS_RECVFROM = 371,
SYS_RECVMSG = 372,
SYS_SHUTDOWN = 373,
SYS_USERFAULTFD = 374,
SYS_MEMBARRIER = 375,
SYS_MLOCK2 = 376,
SYS_COPY_FILE_RANGE = 377,
SYS_PREADV2 = 378,
SYS_PWRITEV2 = 379,
SYS_PKEY_MPROTECT = 380,
SYS_PKEY_ALLOC = 381,
SYS_PKEY_FREE = 382,
SYS_STATX = 383,
SYS_ARCH_PRCTL = 384,
// -----
SYS_SHBUF_CREATE,
SYS_SHBUF_GET,
SYS_SHBUF_FREE,
SYS_PTHREAD_CREATE,
};
#elif __arm__
enum __sysid {
SYS_RESTART_SYSCALL = 0,
SYS_EXIT = 1,
SYS_FORK = 2,
SYS_READ = 3,
SYS_WRITE = 4,
SYS_OPEN = 5,
SYS_CLOSE = 6,
SYS_CREAT = 8,
SYS_LINK = 9,
SYS_UNLINK = 10,
SYS_EXECVE = 11,
SYS_CHDIR = 12,
SYS_MKNOD = 14,
SYS_CHMOD = 15,
SYS_LCHOWN = 16,
SYS_LSEEK = 19,
SYS_GETPID = 20,
SYS_MOUNT = 21,
SYS_SETUID = 23,
SYS_GETUID = 24,
SYS_PTRACE = 26,
SYS_PAUSE = 29,
SYS_ACCESS = 33,
SYS_NICE = 34,
SYS_SYNC = 36,
SYS_KILL = 37,
SYS_RENAME = 38,
SYS_MKDIR = 39,
SYS_RMDIR = 40,
SYS_DUP = 41,
SYS_PIPE = 42,
SYS_TIMES = 43,
SYS_BRK = 45,
SYS_SETGID = 46,
SYS_GETGID = 47,
SYS_GETEUID = 49,
SYS_GETEGID = 50,
SYS_ACCT = 51,
SYS_UMOUNT2 = 52,
SYS_IOCTL = 54,
SYS_FCNTL = 55,
SYS_SETPGID = 57,
SYS_UMASK = 60,
SYS_CHROOT = 61,
SYS_USTAT = 62,
SYS_DUP2 = 63,
SYS_GETPPID = 64,
SYS_GETPGRP = 65,
SYS_SETSID = 66,
SYS_SIGACTION = 67,
SYS_SETREUID = 70,
SYS_SETREGID = 71,
SYS_SIGSUSPEND = 72,
SYS_SIGPENDING = 73,
SYS_SETHOSTNAME = 74,
SYS_SETRLIMIT = 75,
SYS_GETRUSAGE = 77,
SYS_GETTIMEOFDAY = 78,
SYS_SETTIMEOFDAY = 79,
SYS_GETGROUPS = 80,
SYS_SETGROUPS = 81,
SYS_SYMLINK = 83,
SYS_READLINK = 85,
SYS_USELIB = 86,
SYS_SWAPON = 87,
SYS_REBOOT = 88,
SYS_MUNMAP = 91,
SYS_TRUNCATE = 92,
SYS_FTRUNCATE = 93,
SYS_FCHMOD = 94,
SYS_FCHOWN = 95,
SYS_GETPRIORITY = 96,
SYS_SETPRIORITY = 97,
SYS_STATFS = 99,
SYS_FSTATFS = 100,
SYS_SYSLOG = 103,
SYS_SETITIMER = 104,
SYS_GETITIMER = 105,
SYS_STAT = 106,
SYS_LSTAT = 107,
SYS_FSTAT = 108,
SYS_VHANGUP = 111,
SYS_WAIT4 = 114,
SYS_SWAPOFF = 115,
SYS_SYSINFO = 116,
SYS_FSYNC = 118,
SYS_SIGRETURN = 119,
SYS_CLONE = 120,
SYS_SETDOMAINNAME = 121,
SYS_UNAME = 122,
SYS_ADJTIMEX = 124,
SYS_MPROTECT = 125,
SYS_SIGPROCMASK = 126,
SYS_INIT_MODULE = 128,
SYS_DELETE_MODULE = 129,
SYS_QUOTACTL = 131,
SYS_GETPGID = 132,
SYS_FCHDIR = 133,
SYS_BDFLUSH = 134,
SYS_SYSFS = 135,
SYS_PERSONALITY = 136,
SYS_SETFSUID = 138,
SYS_SETFSGID = 139,
SYS__LLSEEK = 140,
SYS_GETDENTS = 141,
SYS__NEWSELECT = 142,
SYS_FLOCK = 143,
SYS_MSYNC = 144,
SYS_READV = 145,
SYS_WRITEV = 146,
SYS_GETSID = 147,
SYS_FDATASYNC = 148,
SYS__SYSCTL = 149,
SYS_MLOCK = 150,
SYS_MUNLOCK = 151,
SYS_MLOCKALL = 152,
SYS_MUNLOCKALL = 153,
SYS_SCHED_SETPARAM = 154,
SYS_SCHED_GETPARAM = 155,
SYS_SCHED_SETSCHEDULER = 156,
SYS_SCHED_GETSCHEDULER = 157,
SYS_SCHED_YIELD = 158,
SYS_SCHED_GET_PRIORITY_MAX = 159,
SYS_SCHED_GET_PRIORITY_MIN = 160,
SYS_SCHED_RR_GET_INTERVAL = 161,
SYS_NANOSLEEP = 162,
SYS_MREMAP = 163,
SYS_SETRESUID = 164,
SYS_GETRESUID = 165,
SYS_POLL = 168,
SYS_NFSSERVCTL = 169,
SYS_SETRESGID = 170,
SYS_GETRESGID = 171,
SYS_PRCTL = 172,
SYS_RT_SIGRETURN = 173,
SYS_RT_SIGACTION = 174,
SYS_RT_SIGPROCMASK = 175,
SYS_RT_SIGPENDING = 176,
SYS_RT_SIGTIMEDWAIT = 177,
SYS_RT_SIGQUEUEINFO = 178,
SYS_RT_SIGSUSPEND = 179,
SYS_PREAD64 = 180,
SYS_PWRITE64 = 181,
SYS_CHOWN = 182,
SYS_GETCWD = 183,
SYS_CAPGET = 184,
SYS_CAPSET = 185,
SYS_SIGALTSTACK = 186,
SYS_SENDFILE = 187,
SYS_VFORK = 190,
SYS_UGETRLIMIT = 191,
SYS_MMAP2 = 192,
SYS_TRUNCATE64 = 193,
SYS_FTRUNCATE64 = 194,
SYS_STAT64 = 195,
SYS_LSTAT64 = 196,
SYS_FSTAT64 = 197,
SYS_LCHOWN32 = 198,
SYS_GETUID32 = 199,
SYS_GETGID32 = 200,
SYS_GETEUID32 = 201,
SYS_GETEGID32 = 202,
SYS_SETREUID32 = 203,
SYS_SETREGID32 = 204,
SYS_GETGROUPS32 = 205,
SYS_SETGROUPS32 = 206,
SYS_FCHOWN32 = 207,
SYS_SETRESUID32 = 208,
SYS_GETRESUID32 = 209,
SYS_SETRESGID32 = 210,
SYS_GETRESGID32 = 211,
SYS_CHOWN32 = 212,
SYS_SETUID32 = 213,
SYS_SETGID32 = 214,
SYS_SETFSUID32 = 215,
SYS_SETFSGID32 = 216,
SYS_GETDENTS64 = 217,
SYS_PIVOT_ROOT = 218,
SYS_MINCORE = 219,
SYS_MADVISE = 220,
SYS_FCNTL64 = 221,
SYS_GETTID = 224,
SYS_READAHEAD = 225,
SYS_SETXATTR = 226,
SYS_LSETXATTR = 227,
SYS_FSETXATTR = 228,
SYS_GETXATTR = 229,
SYS_LGETXATTR = 230,
SYS_FGETXATTR = 231,
SYS_LISTXATTR = 232,
SYS_LLISTXATTR = 233,
SYS_FLISTXATTR = 234,
SYS_REMOVEXATTR = 235,
SYS_LREMOVEXATTR = 236,
SYS_FREMOVEXATTR = 237,
SYS_TKILL = 238,
SYS_SENDFILE64 = 239,
SYS_FUTEX = 240,
SYS_SCHED_SETAFFINITY = 241,
SYS_SCHED_GETAFFINITY = 242,
SYS_IO_SETUP = 243,
SYS_IO_DESTROY = 244,
SYS_IO_GETEVENTS = 245,
SYS_IO_SUBMIT = 246,
SYS_IO_CANCEL = 247,
SYS_EXIT_GROUP = 248,
SYS_LOOKUP_DCOOKIE = 249,
SYS_EPOLL_CREATE = 250,
SYS_EPOLL_CTL = 251,
SYS_EPOLL_WAIT = 252,
SYS_REMAP_FILE_PAGES = 253,
SYS_SET_TID_ADDRESS = 256,
SYS_TIMER_CREATE = 257,
SYS_TIMER_SETTIME = 258,
SYS_TIMER_GETTIME = 259,
SYS_TIMER_GETOVERRUN = 260,
SYS_TIMER_DELETE = 261,
SYS_CLOCK_SETTIME = 262,
SYS_CLOCK_GETTIME = 263,
SYS_CLOCK_GETRES = 264,
SYS_CLOCK_NANOSLEEP = 265,
SYS_STATFS64 = 266,
SYS_FSTATFS64 = 267,
SYS_TGKILL = 268,
SYS_UTIMES = 269,
SYS_ARM_FADVISE64_64 = 270,
SYS_PCICONFIG_IOBASE = 271,
SYS_PCICONFIG_READ = 272,
SYS_PCICONFIG_WRITE = 273,
SYS_MQ_OPEN = 274,
SYS_MQ_UNLINK = 275,
SYS_MQ_TIMEDSEND = 276,
SYS_MQ_TIMEDRECEIVE = 277,
SYS_MQ_NOTIFY = 278,
SYS_MQ_GETSETATTR = 279,
SYS_WAITID = 280,
SYS_SOCKET = 281,
SYS_BIND = 282,
SYS_CONNECT = 283,
SYS_LISTEN = 284,
SYS_ACCEPT = 285,
SYS_GETSOCKNAME = 286,
SYS_GETPEERNAME = 287,
SYS_SOCKETPAIR = 288,
SYS_SEND = 289,
SYS_SENDTO = 290,
SYS_RECV = 291,
SYS_RECVFROM = 292,
SYS_SHUTDOWN = 293,
SYS_SETSOCKOPT = 294,
SYS_GETSOCKOPT = 295,
SYS_SENDMSG = 296,
SYS_RECVMSG = 297,
SYS_SEMOP = 298,
SYS_SEMGET = 299,
SYS_SEMCTL = 300,
SYS_MSGSND = 301,
SYS_MSGRCV = 302,
SYS_MSGGET = 303,
SYS_MSGCTL = 304,
SYS_SHMAT = 305,
SYS_SHMDT = 306,
SYS_SHMGET = 307,
SYS_SHMCTL = 308,
SYS_ADD_KEY = 309,
SYS_REQUEST_KEY = 310,
SYS_KEYCTL = 311,
SYS_SEMTIMEDOP = 312,
SYS_VSERVER = 313,
SYS_IOPRIO_SET = 314,
SYS_IOPRIO_GET = 315,
SYS_INOTIFY_INIT = 316,
SYS_INOTIFY_ADD_WATCH = 317,
SYS_INOTIFY_RM_WATCH = 318,
SYS_MBIND = 319,
SYS_GET_MEMPOLICY = 320,
SYS_SET_MEMPOLICY = 321,
SYS_OPENAT = 322,
SYS_MKDIRAT = 323,
SYS_MKNODAT = 324,
SYS_FCHOWNAT = 325,
SYS_FUTIMESAT = 326,
SYS_FSTATAT64 = 327,
SYS_UNLINKAT = 328,
SYS_RENAMEAT = 329,
SYS_LINKAT = 330,
SYS_SYMLINKAT = 331,
SYS_READLINKAT = 332,
SYS_FCHMODAT = 333,
SYS_FACCESSAT = 334,
SYS_PSELECT6 = 335,
SYS_PPOLL = 336,
SYS_UNSHARE = 337,
SYS_SET_ROBUST_LIST = 338,
SYS_GET_ROBUST_LIST = 339,
SYS_SPLICE = 340,
SYS_SELECT = 341,
SYS_SYNC_FILE_RANGE2 = 341,
SYS_TEE = 342,
SYS_VMSPLICE = 343,
SYS_MOVE_PAGES = 344,
SYS_GETCPU = 345,
SYS_EPOLL_PWAIT = 346,
SYS_KEXEC_LOAD = 347,
SYS_UTIMENSAT = 348,
SYS_SIGNALFD = 349,
SYS_TIMERFD_CREATE = 350,
SYS_EVENTFD = 351,
SYS_FALLOCATE = 352,
SYS_TIMERFD_SETTIME = 353,
SYS_TIMERFD_GETTIME = 354,
SYS_SIGNALFD4 = 355,
SYS_EVENTFD2 = 356,
SYS_EPOLL_CREATE1 = 357,
SYS_DUP3 = 358,
SYS_PIPE2 = 359,
SYS_INOTIFY_INIT1 = 360,
SYS_PREADV = 361,
SYS_PWRITEV = 362,
SYS_RT_TGSIGQUEUEINFO = 363,
SYS_PERF_EVENT_OPEN = 364,
SYS_RECVMMSG = 365,
SYS_ACCEPT4 = 366,
SYS_FANOTIFY_INIT = 367,
SYS_FANOTIFY_MARK = 368,
SYS_PRLIMIT64 = 369,
SYS_NAME_TO_HANDLE_AT = 370,
SYS_OPEN_BY_HANDLE_AT = 371,
SYS_CLOCK_ADJTIME = 372,
SYS_SYNCFS = 373,
SYS_SENDMMSG = 374,
SYS_SETNS = 375,
SYS_PROCESS_VM_READV = 376,
SYS_PROCESS_VM_WRITEV = 377,
SYS_KCMP = 378,
SYS_FINIT_MODULE = 379,
SYS_SCHED_SETATTR = 380,
SYS_SCHED_GETATTR = 381,
SYS_RENAMEAT2 = 382,
SYS_SECCOMP = 383,
SYS_GETRANDOM = 384,
SYS_MEMFD_CREATE = 385,
SYS_BPF = 386,
SYS_EXECVEAT = 387,
SYS_USERFAULTFD = 388,
SYS_MEMBARRIER = 389,
SYS_MLOCK2 = 390,
SYS_COPY_FILE_RANGE = 391,
SYS_PREADV2 = 392,
SYS_PWRITEV2 = 393,
SYS_PKEY_MPROTECT = 394,
SYS_PKEY_ALLOC = 395,
SYS_PKEY_FREE = 396,
SYS_STATX = 397,
// -----
SYS_SHBUF_CREATE,
SYS_SHBUF_GET,
SYS_SHBUF_FREE,
SYS_PTHREAD_CREATE,
SYS_MMAP,
SYS_WAITPID,
};
#endif
typedef enum __sysid sysid_t;
#endif // _KERNEL_LIBKERN_BITS_SYSCALLS_H
|
willmexe/opuntiaOS | kernel/include/platform/generic/registers.h | #ifdef __i386__
#include <platform/x86/registers.h>
#elif __arm__
#include <platform/aarch32/registers.h>
#endif |
willmexe/opuntiaOS | boot/x86/stage2/drivers/port.c | <filename>boot/x86/stage2/drivers/port.c
#include "port.h"
unsigned char port_byte_in(unsigned short port)
{
unsigned char result_data;
asm volatile("inb %%dx, %%al"
: "=a"(result_data)
: "d"(port));
return result_data;
}
void port_byte_out(unsigned short port, unsigned char data)
{
asm volatile("outb %%al, %%dx"
:
: "a"(data), "d"(port));
}
unsigned short port_word_in(unsigned short port)
{
unsigned short result_data;
asm volatile("inw %%dx, %%ax"
: "=a"(result_data)
: "d"(port));
return result_data;
}
void port_word_out(unsigned short port, unsigned short data)
{
asm volatile("outw %%ax, %%dx"
:
: "a"(data), "d"(port));
}
unsigned int port_dword_in(unsigned short port)
{
unsigned int result_data;
asm volatile("inl %%dx, %%eax"
: "=a"(result_data)
: "d"(port));
return result_data;
}
void port_dword_out(unsigned short port, unsigned int data)
{
asm volatile("outl %%eax, %%dx"
:
: "a"(data), "d"(port));
}
unsigned char port_8bit_in(unsigned short port)
{
unsigned char result_data;
asm volatile("inb %%dx, %%al"
: "=a"(result_data)
: "d"(port));
return result_data;
}
void port_8bit_out(unsigned short port, unsigned char data)
{
asm volatile("outb %%al, %%dx"
:
: "a"(data), "d"(port));
}
unsigned short port_16bit_in(unsigned short port)
{
unsigned short result_data;
asm volatile("inw %%dx, %%ax"
: "=a"(result_data)
: "d"(port));
return result_data;
}
void port_16bit_out(unsigned short port, unsigned short data)
{
asm volatile("outw %%ax, %%dx"
:
: "a"(data), "d"(port));
}
unsigned int port_32bit_in(unsigned short port)
{
unsigned int result_data;
asm volatile("inl %%dx, %%eax"
: "=a"(result_data)
: "d"(port));
return result_data;
}
void port_32bit_out(unsigned short port, unsigned int data)
{
asm volatile("outl %%eax, %%dx"
:
: "a"(data), "d"(port));
}
void io_wait()
{
asm volatile("out %%al, $0x80"
:
: "a"(0)); // writing to "unused" port
} |
willmexe/opuntiaOS | kernel/include/mem/kmemzone.h | <reponame>willmexe/opuntiaOS
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_MEM_KMEMZONE_H
#define _KERNEL_MEM_KMEMZONE_H
#include <libkern/types.h>
#include <mem/bits/zone.h>
extern char __text_start[];
extern char __text_end[];
extern char __rodata_start[];
extern char __rodata_end[];
extern char __data_start[];
extern char __data_end[];
extern char __bss_start[];
extern char __bss_end[];
extern char __stack_start[];
extern char __stack__end[];
extern char _end[];
struct __kmemzone {
union {
uintptr_t start;
uint8_t* ptr;
};
size_t len;
};
typedef struct __kmemzone kmemzone_t;
void kmemzone_init();
void kmemzone_init_stage2();
kmemzone_t kmemzone_new(size_t size);
kmemzone_t kmemzone_new_aligned(size_t size, size_t alignment);
int kmemzone_free(kmemzone_t zone);
#endif // _KERNEL_MEM_KMEMZONE_H |
willmexe/opuntiaOS | kernel/include/libkern/platform.h | <filename>kernel/include/libkern/platform.h
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_LIBKERN_PLATFORM_H
#define _KERNEL_LIBKERN_PLATFORM_H
#include <libkern/c_attrs.h>
ALWAYS_INLINE int ctz32(unsigned int val)
{
return __builtin_ctz(val);
}
#endif // _KERNEL_LIBKERN_PLATFORM_H |
willmexe/opuntiaOS | kernel/include/drivers/x86/ide.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_DRIVERS_X86_IDE_H
#define _KERNEL_DRIVERS_X86_IDE_H
#include <drivers/x86/ata.h>
#include <libkern/types.h>
#include <platform/x86/idt.h>
void ide_install();
int ide_init_with_dev(device_t* dev);
#endif // _KERNEL_DRIVERS_X86_IDE_H
|
willmexe/opuntiaOS | kernel/include/platform/generic/tasking/signal_impl.h | <gh_stars>100-1000
#ifdef __i386__
#include <platform/x86/tasking/signal_impl.h>
#elif __arm__
#include <platform/aarch32/tasking/signal_impl.h>
#endif |
willmexe/opuntiaOS | libs/libc/include/sys/_types/_va_list.h | <reponame>willmexe/opuntiaOS<gh_stars>100-1000
#ifndef _LIBC_SYS__TYPES__VA_LIST_H
#define _LIBC_SYS__TYPES__VA_LIST_H
typedef __builtin_va_list va_list;
#endif // _LIBC_SYS__TYPES__VA_LIST_H |
willmexe/opuntiaOS | libs/libui/include/libui/Window.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#pragma once
#include "../../../servers/window_server/shared/Connections/WSConnection.h"
#include "../../../servers/window_server/shared/MessageContent/Window.h"
#include <libfoundation/Event.h>
#include <libfoundation/EventReceiver.h>
#include <libfoundation/SharedBuffer.h>
#include <libg/Color.h>
#include <libg/PixelBitmap.h>
#include <libg/Size.h>
#include <libui/MenuBar.h>
#include <libui/PopupMenu.h>
#include <libui/View.h>
#include <libui/ViewController.h>
#include <string>
#include <sys/types.h>
namespace UI {
using ::WindowStatusUpdateType;
using ::WindowType;
class Connection;
class Window : public LFoundation::EventReceiver {
UI_OBJECT();
friend Connection;
public:
Window(const std::string& title, const LG::Size& size, WindowType type = WindowType::Standard);
Window(const std::string& title, const LG::Size& size, const std::string& path);
Window(const std::string& title, const LG::Size& size, const std::string& path, const StatusBarStyle& style);
int id() const { return m_id; }
inline WindowType type() const { return m_type; }
inline const LG::Rect& bounds() const { return m_bounds; }
LFoundation::SharedBuffer<LG::Color>& buffer() { return m_buffer; }
const LFoundation::SharedBuffer<LG::Color>& buffer() const { return m_buffer; }
LG::PixelBitmap& bitmap() { return m_bitmap; }
const LG::PixelBitmap& bitmap() const { return m_bitmap; }
inline void set_bitmap_format(LG::PixelBitmapFormat format) { m_bitmap.set_format(format), did_format_change(); }
template <class ViewT, class ViewControllerT, class... Args>
inline ViewT& create_superview(Args&&... args)
{
ViewT* new_view = new ViewT(nullptr, this, bounds(), args...);
m_superview = new_view;
m_root_view_controller = new ViewControllerT(*new_view);
setup_superview();
m_superview->set_needs_display();
LFoundation::EventLoop::the().add(*m_root_view_controller, new ViewDidLoadEvent());
return *new_view;
}
inline View* superview() const { return m_superview; }
inline void set_focused_view(View& view) { m_focused_view = &view; }
inline View* focused_view() { return m_focused_view; }
MenuBar& menubar() { return m_menubar; }
PopupMenu& popup_manager() { return m_popup; }
bool set_title(const std::string& title);
bool set_status_bar_style(StatusBarStyle style);
bool did_format_change();
bool did_buffer_change();
inline const std::string& title() const { return m_title; }
inline const std::string& icon_path() const { return m_icon_path; }
inline const StatusBarStyle& status_bar_style() const { return m_status_bar_style; }
void receive_event(std::unique_ptr<LFoundation::Event> event) override;
private:
void resize(ResizeEvent&);
void setup_superview();
void fill_with_opaque(const LG::Rect&);
uint32_t m_id;
BaseViewController* m_root_view_controller { nullptr };
View* m_superview { nullptr };
View* m_focused_view { nullptr };
LG::Rect m_bounds;
LG::PixelBitmap m_bitmap;
LFoundation::SharedBuffer<LG::Color> m_buffer;
std::string m_title { "" };
std::string m_icon_path { "/res/icons/apps/missing.icon" };
LG::Color m_color;
StatusBarStyle m_status_bar_style;
WindowType m_type { WindowType::Standard };
MenuBar m_menubar;
PopupMenu m_popup;
};
} // namespace UI |
willmexe/opuntiaOS | servers/window_server/src/Managers/WindowManager.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#pragma once
#include "../../shared/Connections/WSConnection.h"
#include "../Components/ControlBar/ControlBar.h"
#include "../Components/MenuBar/MenuBar.h"
#include "../Components/Security/Violations.h"
#include "../Devices/Screen.h"
#include "../IPC/Connection.h"
#include "../IPC/Event.h"
#include "../IPC/ServerDecoder.h"
#include "../Managers/Compositor.h"
#include "../SystemApps/SystemApp.h"
#include "../Target/Generic/Window.h"
#include <algorithm>
#include <libfoundation/EventLoop.h>
#include <libfoundation/EventReceiver.h>
#include <libipc/ServerConnection.h>
#include <list>
#include <vector>
namespace WinServer {
class WindowManager : public LFoundation::EventReceiver {
#ifdef TARGET_DESKTOP
using Window = WinServer::Desktop::Window;
#elif TARGET_MOBILE
using Window = WinServer::Mobile::Window;
#endif
public:
inline static WindowManager& the()
{
extern WindowManager* s_WinServer_WindowManager_the;
return *s_WinServer_WindowManager_the;
}
WindowManager();
void add_window(Window* window);
void remove_window(Window* window);
void resize_window(Window& window, const LG::Size& size);
void close_window(Window& window) { send_event(new WindowCloseRequestMessage(window.connection_id(), window.id())); }
void minimize_window(Window& window);
void maximize_window(Window& window);
template <typename Callback>
void minimize_windows(Callback callback)
{
std::vector<Window*> hided;
for (auto* window : m_windows) {
if (window && window->type() == WindowType::Standard && callback(window)) {
window->set_visible(false);
hided.push_back(window);
on_window_became_invisible(window);
remove_attention_from_window(window);
}
}
for (auto* window : hided) {
m_windows.erase(std::find(m_windows.begin(), m_windows.end(), window));
m_windows.push_back(window);
}
}
Window* top_window_in_view(WindowType type) const;
inline Window* window(int id)
{
for (auto* window : m_windows) {
if (window->id() == id) {
return window;
}
}
return nullptr;
}
inline void move_window(Window* window, int x_offset, int y_offset)
{
y_offset = std::max(y_offset, (int)visible_area().min_y() - (int)Desktop::WindowFrame::std_top_border_frame_size() - window->bounds().min_y());
if (m_dock.has_value()) [[likely]] {
y_offset = std::min(y_offset, (int)(visible_area().max_y() - window->content_bounds().min_y()));
}
window->bounds().offset_by(x_offset, y_offset);
window->content_bounds().offset_by(x_offset, y_offset);
}
inline void do_bring_to_front(Window& window)
{
auto* window_ptr = &window;
m_windows.erase(std::find(m_windows.begin(), m_windows.end(), window_ptr));
m_windows.push_front(window_ptr);
}
void bring_to_front(Window& window);
inline std::list<Window*>& windows() { return m_windows; }
inline const std::list<Window*>& windows() const { return m_windows; }
inline int next_win_id() { return ++m_next_win_id; }
const LG::Rect& visible_area() const { return m_visible_area; }
void shrink_visible_area(int top, int bottom) { m_visible_area.set_y(m_visible_area.min_y() + top), m_visible_area.set_height(m_visible_area.height() - top - bottom); }
void receive_event(std::unique_ptr<LFoundation::Event> event) override;
// Notifiers
bool notify_listner_about_window_creation(const Window& window, int changed_window_id);
bool notify_listner_about_window_status(const Window& window, int changed_window_id, WindowStatusUpdateType type);
bool notify_listner_about_changed_icon(const Window&, int changed_window_id);
bool notify_listner_about_changed_title(const Window&, int changed_window_id);
void notify_window_creation(int changed_window_id);
void notify_window_status_changed(int changed_window_id, WindowStatusUpdateType type);
void notify_window_icon_changed(int changed_window_id);
void notify_window_title_changed(int changed_window_id);
inline void ask_to_set_active_window(Window* win) { set_active_window(win); }
inline void ask_to_set_active_window(Window& win) { set_active_window(win); }
void on_window_misbehave(Window& window, ViolationClass);
void on_window_style_change(Window& win);
void on_window_menubar_change(Window& window);
// Popup & Menubar
inline Popup& popup() { return m_compositor.popup(); }
inline const Popup& popup() const { return m_compositor.popup(); }
inline MenuBar& menu_bar() { return m_compositor.menu_bar(); }
inline const MenuBar& menu_bar() const { return m_compositor.menu_bar(); }
private:
void add_system_window(Window* window);
void bring_system_windows_to_front();
void setup_dock(Window* window);
void setup_applist(Window* window);
void remove_attention_from_window(Window* window);
void start_window_move(Window& window);
bool continue_window_move();
void update_mouse_position(std::unique_ptr<LFoundation::Event> mouse_event);
void receive_mouse_event(std::unique_ptr<LFoundation::Event> event);
void receive_keyboard_event(std::unique_ptr<LFoundation::Event> event);
inline Window* movable_window() { return m_movable_window; }
inline Window* hovered_window() { return m_hovered_window; }
inline void set_hovered_window(Window* win) { m_hovered_window = win; }
inline Window* active_window() { return m_active_window; }
inline void set_active_window(Window* win) { on_active_window_will_change(), bring_to_front(*win), m_active_window = win, on_active_window_did_change(); }
inline void set_active_window(Window& win) { on_active_window_will_change(), bring_to_front(win), m_active_window = &win, on_active_window_did_change(); }
inline void set_active_window(std::nullptr_t) { on_active_window_will_change(), m_active_window = nullptr, on_active_window_did_change(); }
void on_window_became_invisible(Window* window);
void on_active_window_will_change();
void on_active_window_did_change();
inline void send_event(Message* msg) { m_event_loop.add(m_connection, new SendEvent(msg)); }
std::list<Window*> m_windows;
Screen& m_screen;
Connection& m_connection;
Compositor& m_compositor;
CursorManager& m_cursor_manager;
LFoundation::EventLoop& m_event_loop;
std::vector<MenuDir> m_std_menubar_content;
LG::Rect m_visible_area;
SystemApp m_dock;
SystemApp m_applist;
// TODO: implement with std::weak_ptr.
Window* m_movable_window {};
Window* m_active_window {};
Window* m_hovered_window {};
int m_next_win_id { 0 };
};
} // namespace WinServer |
willmexe/opuntiaOS | kernel/kernel/syscalls/system.c | <reponame>willmexe/opuntiaOS<filename>kernel/kernel/syscalls/system.c
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <libkern/bits/errno.h>
#include <libkern/libkern.h>
#include <libkern/log.h>
#include <libkern/version.h>
#include <mem/vmm.h>
#include <platform/generic/syscalls/params.h>
#include <syscalls/handlers.h>
void sys_uname(trapframe_t* tf)
{
utsname_t* buf = (utsname_t*)SYSCALL_VAR1(tf);
vmm_copy_to_user(buf->sysname, OSTYPE, sizeof(OSTYPE));
vmm_copy_to_user(buf->release, OSRELEASE, sizeof(OSRELEASE));
vmm_copy_to_user(buf->version, VERSION_VARIANT, sizeof(VERSION_VARIANT));
vmm_copy_to_user(buf->machine, MACHINE, sizeof(MACHINE));
return_with_val(0);
} |
willmexe/opuntiaOS | libs/libc/include/bits/fcntl.h | #ifndef _LIBC_BITS_FCNTL_H
#define _LIBC_BITS_FCNTL_H
#define SEEK_SET 0x1
#define SEEK_CUR 0x2
#define SEEK_END 0x3
/* OPEN */
#define O_RDONLY 0x1
#define O_WRONLY 0x2
#define O_RDWR (O_RDONLY | O_WRONLY)
#define O_DIRECTORY 0x4
#define O_CREAT 0x8
#define O_TRUNC 0x10
#define O_APPEND 0x20
#define O_EXCL 0x40
#define O_EXEC 0x80
#endif // _LIBC_BITS_FCNTL_H |
willmexe/opuntiaOS | libs/libc/include/sys/_types/_devs.h | #ifndef _LIBC_SYS__TYPES__DEVS_H
#define _LIBC_SYS__TYPES__DEVS_H
#define MINORBITS 20
#define MINORMASK ((1U << MINORBITS) - 1)
#define major(dev) ((unsigned int)((dev) >> MINORBITS))
#define minor(dev) ((unsigned int)((dev)&MINORMASK))
#define makedev(ma, mi) (((ma) << MINORBITS) | (mi))
#endif // _LIBC_SYS__TYPES__DEVS_H |
willmexe/opuntiaOS | kernel/include/drivers/generic/fpu.h | <reponame>willmexe/opuntiaOS
#ifdef __i386__
#include <drivers/x86/fpu.h>
#elif __arm__
#include <drivers/aarch32/fpuv4.h>
#endif |
willmexe/opuntiaOS | kernel/include/libkern/scanf.h | <reponame>willmexe/opuntiaOS
#ifndef _KERNEL_LIBKERN_SCANF_H
#define _KERNEL_LIBKERN_SCANF_H
#include <libkern/types.h>
#define EOF (-1)
typedef int (*scanf_lookupch_callback)(void* callback_params);
typedef int (*scanf_getch_callback)(void* callback_params);
typedef int (*scanf_putch_callback)(char ch, char* buf_base, size_t* written, void* callback_params);
int vsscanf(const char* buf, const char* fmt, va_list arg);
int sscanf(const char* buf, const char* fmt, ...);
int scanf_engine(const char* format, scanf_lookupch_callback lookupch, scanf_getch_callback getch, void* callback_params, va_list arg);
#endif // _KERNEL_LIBKERN_SCANF_H |
willmexe/opuntiaOS | libs/libc/include/sysdep.h | <gh_stars>100-1000
#ifndef _LIBC_SYSDEP_H
#define _LIBC_SYSDEP_H
#include <bits/syscalls.h>
#include <errno.h>
#include <sys/cdefs.h>
__BEGIN_DECLS
static inline int _syscall_impl(sysid_t sysid, int p1, int p2, int p3, int p4, int p5)
{
int ret;
#ifdef __i386__
asm volatile("push %%ebx;movl %2,%%ebx;int $0x80;pop %%ebx"
: "=a"(ret)
: "0"(sysid), "r"((int)(p1)), "c"((int)(p2)), "d"((int)(p3)), "S"((int)(p4)), "D"((int)(p5))
: "memory");
#elif __arm__
asm volatile(
"mov r7, %1;\
mov r0, %2;\
mov r1, %3;\
mov r2, %4;\
mov r3, %5;\
mov r4, %6;\
swi 1;\
mov %0, r0;"
: "=r"(ret)
: "r"(sysid), "r"((int)(p1)), "r"((int)(p2)), "r"((int)(p3)), "r"((int)(p4)), "r"((int)(p5))
: "memory", "r0", "r1", "r2", "r3", "r4", "r7");
#endif
return ret;
}
#define DO_SYSCALL_0(type) _syscall_impl(type, 0, 0, 0, 0, 0)
#define DO_SYSCALL_1(type, a) _syscall_impl(type, (int)a, 0, 0, 0, 0)
#define DO_SYSCALL_2(type, a, b) _syscall_impl(type, (int)a, (int)b, 0, 0, 0)
#define DO_SYSCALL_3(type, a, b, c) _syscall_impl(type, (int)a, (int)b, (int)c, 0, 0)
#define DO_SYSCALL_4(type, a, b, c, d) _syscall_impl(type, (int)a, (int)b, (int)c, (int)d, 0)
#define DO_SYSCALL_5(type, a, b, c, d, e) _syscall_impl(type, (int)a, (int)b, (int)c, (int)d, (int)e);
#define RETURN_WITH_ERRNO(res, on_suc, on_fail) \
do { \
if ((int)res < 0) { \
set_errno(res); \
return (on_fail); \
} \
set_errno(0); \
return on_suc; \
} while (0);
__END_DECLS
#endif // _LIBC_SYSDEP_H |
willmexe/opuntiaOS | userland/system/dock/DockEntity.h | #pragma once
#include "WindowEntity.h"
#include <libg/PixelBitmap.h>
#include <list>
#include <string>
class DockEntity {
public:
DockEntity() = default;
void set_icon(LG::PixelBitmap&& icon) { m_icon = std::move(icon); }
const LG::PixelBitmap& icon() const { return m_icon; }
void set_path_to_exec(const std::string& path) { m_path_to_exec = path; }
const std::string& path_to_exec() const { return m_path_to_exec; }
void set_bundle_id(const std::string& bid) { m_bundle_id = bid; }
const std::string& bundle_id() const { return m_bundle_id; }
void add_window(const WindowEntity& went) { m_windows.push_front(went); }
const std::list<WindowEntity>& windows() const { return m_windows; }
std::list<WindowEntity>& windows() { return m_windows; }
private:
LG::PixelBitmap m_icon;
std::string m_path_to_exec {};
std::string m_bundle_id {};
std::list<WindowEntity> m_windows {};
}; |
willmexe/opuntiaOS | boot/libboot/types.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _BOOT_LIBBOOT_TYPES_H
#define _BOOT_LIBBOOT_TYPES_H
typedef char int8_t;
typedef short int16_t;
typedef int int32_t;
typedef long long int64_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
typedef uint32_t size_t;
typedef int32_t ssize_t;
typedef _Bool bool;
typedef __builtin_va_list va_list;
#define va_start(v, l) __builtin_va_start(v, l)
#define va_end(v) __builtin_va_end(v)
#define va_arg(v, l) __builtin_va_arg(v, l)
#define true (1)
#define false (0)
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#define NULL ((void*)0)
#define UNUSED(x) (void)(x)
#define ALIGNED(x) __attribute__((aligned(x)))
#define PACKED __attribute__((packed))
#endif // _BOOT_LIBBOOT_TYPES_H |
willmexe/opuntiaOS | kernel/include/libkern/kernel_self_test.h | <filename>kernel/include/libkern/kernel_self_test.h
#ifndef _KERNEL_LIBKERN_KERNEL_SELF_TEST_H
#define _KERNEL_LIBKERN_KERNEL_SELF_TEST_H
#include <libkern/types.h>
void kpanic_at_test(char* t_err_msg, uint16_t test_no);
bool kernel_self_test(bool throw_kernel_panic);
#endif // _KERNEL_LIBKERN_KERNEL_SELF_TEST_H
|
willmexe/opuntiaOS | libs/libc/include/sys/mman.h | #ifndef _LIBC_SYS_MMAN_H
#define _LIBC_SYS_MMAN_H
#include <bits/sys/mman.h>
#include <stddef.h>
#include <sys/cdefs.h>
#include <sys/types.h>
__BEGIN_DECLS
void* mmap(void* addr, size_t length, int prot, int flags, int fd, off_t offset);
int munmap(void* addr, size_t length);
__END_DECLS
#endif // _LIBC_SYS_MMAN_H |
willmexe/opuntiaOS | kernel/kernel/platform/x86/gdt.c | <gh_stars>0
/*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include <mem/kmalloc.h>
#include <mem/vmm.h>
#include <platform/x86/gdt.h>
#include <platform/x86/tasking/tss.h>
gdt_desc_t gdt[GDT_MAX_ENTRIES];
void lgdt(void* p, uint16_t size)
{
volatile uint16_t pd[3];
pd[0] = size - 1;
pd[1] = (uint32_t)p;
pd[2] = (uint32_t)p >> 16;
asm volatile("lgdt (%0)"
:
: "r"(pd));
}
void gdt_setup()
{
gdt[GDT_SEG_KCODE] = GDT_SEG_PG(GDT_SEGF_X | GDT_SEGF_R, 0, 0xffffffff, 0);
gdt[GDT_SEG_KDATA] = GDT_SEG_PG(GDT_SEGF_W, 0, 0xffffffff, 0);
gdt[GDT_SEG_UCODE] = GDT_SEG_PG(GDT_SEGF_X | GDT_SEGF_R, 0, 0xffffffff, DPL_USER);
gdt[GDT_SEG_UDATA] = GDT_SEG_PG(GDT_SEGF_W, 0, 0xffffffff, DPL_USER);
lgdt(gdt, sizeof(gdt));
} |
willmexe/opuntiaOS | boot/x86/stage2/drivers/ata.h | <gh_stars>100-1000
#ifndef _BOOT_X86_STAGE2_DRIVERS_ATA_H
#define _BOOT_X86_STAGE2_DRIVERS_ATA_H
#include "port.h"
#include <libboot/abi/drivers.h>
#include <libboot/types.h>
typedef struct { // LBA28 | LBA48
uint32_t data_port; // 16bit | 16 bits
uint32_t error_port; // 8 bit | 16 bits
uint32_t sector_count_port; // 8 bit | 16 bits
uint32_t lba_lo_port; // 8 bit | 16 bits
uint32_t lba_mid_port; // 8 bit | 16 bits
uint32_t lba_hi_port; // 8 bit | 16 bits
uint32_t device_port; // 8 bit
uint32_t command_port; // 8 bit
uint32_t control_port; // 8 bit
char is_master;
} ata_t;
void init_ata(uint32_t port, char is_master);
int indentify_ata_device(drive_desc_t* drive_desc);
int ata_read(uint32_t sector, uint8_t* read_to);
// extern uint16_t ata_read_to_ram(ata_t *dev, uint32_t sectorNum, uint32_t toRam, uint8_t offset);
#endif |
willmexe/opuntiaOS | libs/libfoundation/include/libfoundation/Logger.h | <gh_stars>100-1000
#include <ostream>
namespace LFoundation::Logger {
extern std::ostream debug;
} // namespace LFoundation::Logger
namespace Logger {
using LFoundation::Logger::debug;
} // namespace Logger |
willmexe/opuntiaOS | boot/x86/stage2/drivers/ata.c | <gh_stars>100-1000
/**
* Ata Stage2 driver. This is a lite version, since it can work with
* only one drive at time. The @active_ata_drive is a boot drive.
*/
#include "ata.h"
ata_t active_ata_drive;
void init_ata(uint32_t port, char is_master)
{
active_ata_drive.is_master = is_master;
active_ata_drive.data_port = port;
active_ata_drive.error_port = port + 0x1;
active_ata_drive.sector_count_port = port + 0x2;
active_ata_drive.lba_lo_port = port + 0x3;
active_ata_drive.lba_mid_port = port + 0x4;
active_ata_drive.lba_hi_port = port + 0x5;
active_ata_drive.device_port = port + 0x6;
active_ata_drive.command_port = port + 0x7;
active_ata_drive.control_port = port + 0x206;
}
int indentify_ata_device(drive_desc_t* drive_desc)
{
port_8bit_out(active_ata_drive.device_port, active_ata_drive.is_master ? 0xA0 : 0xB0);
port_8bit_out(active_ata_drive.sector_count_port, 0);
port_8bit_out(active_ata_drive.lba_lo_port, 0);
port_8bit_out(active_ata_drive.lba_mid_port, 0);
port_8bit_out(active_ata_drive.lba_hi_port, 0);
port_8bit_out(active_ata_drive.command_port, 0xEC);
// check the acceptance of a command
uint8_t status = port_8bit_in(active_ata_drive.command_port);
if (status == 0x00) {
// printf("Cmd isn't accepted");
return -1;
}
// waiting for processing
// while BSY is on
while ((status & 0x80) == 0x80) {
status = port_8bit_in(active_ata_drive.command_port);
}
// check if drive isn't ready to transer DRQ
if ((status & 0x08) != 0x08) {
// printf("Don't ready for transport");
return -1;
}
// transfering 256 bytes of data
for (int i = 0; i < 256; i++) {
uint16_t data = port_16bit_in(active_ata_drive.data_port);
char* text = " \0";
text[0] = (data >> 8) & 0xFF;
text[1] = data & 0xFF;
if (i == 1) {
// printf("Logical cylindres");
// printd(data);
// printf("\n");
}
if (i == 3) {
// printf("Logical heads");
// printd(data);
// printf("\n");
}
if (i == 6) {
// printf("Logical sectors");
// printd(data);
// printf("\n");
}
if (i == 49) {
if (((data >> 8) & 0x1) == 1) {
// printf("Dma supported\n");
}
if (((data >> 9) & 0x1) == 1) {
// printf("Lba supported\n");
}
}
}
drive_desc->read = ata_read;
return 0;
}
// Returning 2 head read bytes (used to get size of kernel)
int ata_read(uint32_t sector, uint8_t* read_to)
{
uint8_t dev_config = 0xA0;
// lba support
dev_config |= (1 << 6);
if (!active_ata_drive.is_master) {
dev_config |= (1 << 4);
}
port_8bit_out(active_ata_drive.device_port, dev_config);
port_8bit_out(active_ata_drive.sector_count_port, 1);
port_8bit_out(active_ata_drive.lba_lo_port, sector & 0x000000FF);
port_8bit_out(active_ata_drive.lba_mid_port, (sector & 0x0000FF00) >> 8);
port_8bit_out(active_ata_drive.lba_hi_port, (sector & 0x00FF0000) >> 16);
port_8bit_out(active_ata_drive.error_port, 0);
port_8bit_out(active_ata_drive.command_port, 0x21);
// waiting for processing
// while BSY is on and no Errors
uint8_t status = port_8bit_in(active_ata_drive.command_port);
while (((status >> 7) & 1) == 1 && ((status >> 0) & 1) != 1) {
status = port_8bit_in(active_ata_drive.command_port);
}
// check if drive isn't ready to transer DRQ
if (((status >> 0) & 1) == 1) {
return -1;
}
if (((status >> 3) & 1) == 0) {
return -1;
}
for (int i = 0; i < 256; i++) {
uint16_t data = port_16bit_in(active_ata_drive.data_port);
read_to[2 * i + 1] = (data >> 8) & 0xFF;
read_to[2 * i] = data & 0xFF;
}
return 0;
} |
willmexe/opuntiaOS | libs/libc/termios/termios.c | #include <sys/ioctl.h>
#include <termios.h>
int tcgetpgrp(int fd)
{
return ioctl(fd, TIOCGPGRP, 0);
}
int tcsetpgrp(int fd, pid_t pgid)
{
return ioctl(fd, TIOCSPGRP, pgid);
}
int tcgetattr(int fd, termios_t* termios_p)
{
return ioctl(0, TCGETS, (int)termios_p);
}
int tcsetattr(int fd, int optional_actions, const termios_t* termios_p)
{
if (optional_actions == TCSANOW) {
return ioctl(0, TCSETS, (int)termios_p);
}
if (optional_actions == TCSADRAIN) {
return ioctl(0, TCSETSW, (int)termios_p);
}
if (optional_actions == TCSAFLUSH) {
return ioctl(0, TCSETSF, (int)termios_p);
}
return -1;
} |
willmexe/opuntiaOS | libs/libc/include/setjmp.h | <filename>libs/libc/include/setjmp.h
#ifndef _LIBC_SETJMP_H
#define _LIBC_SETJMP_H
#include <sys/cdefs.h>
#include <sys/types.h>
__BEGIN_DECLS
#ifdef __i386__
/**
* x86_32 (6 * 4):
* - ebx
* - esp
* - ebp
* - esi
* - edi
* - return address
*/
#define _jblen (6 * 4)
#elif defined(__arm__) && defined(__ARM_NEON__)
/**
* ARMv7 (11 * 4 + 8 * 8):
* - r4 - r12, sp, lr
* - d8-d15
*/
#define _jblen (11 * 4 + 8 * 8)
#elif defined(__arm__) && !defined(__ARM_NEON__)
/**
* ARMv7 (11 * 4):
* - r4 - r12, sp, lr
*/
#define _jblen (11 * 4)
#endif
struct __jmp_buf {
char regs[_jblen];
};
typedef struct __jmp_buf jmp_buf[1];
typedef struct __jmp_buf sigjmp_buf[1];
extern int setjmp(jmp_buf);
extern void longjmp(jmp_buf, int val);
__END_DECLS
#endif |
willmexe/opuntiaOS | libs/libipc/include/libipc/ClientConnection.h | #pragma once
#include <cstdlib>
#include <libfoundation/Event.h>
#include <libfoundation/EventLoop.h>
#include <libfoundation/EventReceiver.h>
#include <libfoundation/Logger.h>
#include <libipc/Message.h>
#include <libipc/MessageDecoder.h>
#include <unistd.h>
#include <vector>
template <typename ServerDecoder, typename ClientDecoder>
class ClientConnection : public LFoundation::EventReceiver {
public:
ClientConnection(int sock_fd, ServerDecoder& server_decoder, ClientDecoder& client_decoder)
: m_connection_fd(sock_fd)
, m_server_decoder(server_decoder)
, m_client_decoder(client_decoder)
, m_messages()
{
}
void set_accepted_key(int key) { m_accepted_key = key; }
bool send_message(const Message& msg) const
{
auto encoded_msg = msg.encode();
int wrote = write(m_connection_fd, encoded_msg.data(), encoded_msg.size());
return wrote == encoded_msg.size();
}
std::unique_ptr<Message> send_sync(const Message& msg)
{
bool status = send_message(msg);
return wait_for_answer(msg);
}
std::unique_ptr<Message> wait_for_answer(const Message& msg)
{
for (;;) {
for (int i = 0; i < m_messages.size(); i++) {
if (m_messages[i] && m_messages[i]->key() == msg.key() && m_messages[i]->id() == msg.reply_id()) {
return m_messages[i].release();
}
}
pump_messages();
}
}
void pump_messages()
{
std::vector<char> buf;
char tmpbuf[1024];
int read_cnt;
while ((read_cnt = read(m_connection_fd, tmpbuf, sizeof(tmpbuf)))) {
if (read_cnt <= 0) {
Logger::debug << getpid() << " :: ClientConnection read error" << std::endl;
return;
}
size_t buf_size = buf.size();
buf.resize(buf_size + read_cnt);
memcpy((uint8_t*)&buf.data()[buf_size], (uint8_t*)tmpbuf, read_cnt);
if (read_cnt < sizeof(tmpbuf)) {
break;
}
}
size_t msg_len = 0;
size_t buf_size = buf.size();
for (size_t i = 0; i < buf_size; i += msg_len) {
msg_len = 0;
if (auto response = m_client_decoder.decode((buf.data() + i), read_cnt - i, msg_len)) {
m_messages.push_back(std::move(response));
} else if (auto response = m_server_decoder.decode((buf.data() + i), read_cnt - i, msg_len)) {
m_messages.push_back(std::move(response));
} else {
Logger::debug << getpid() << " :: ClientConnection read error" << std::endl;
std::abort();
}
}
if (m_messages.size() > 0) {
// Note: We send an event to ourselves and use CallEvent to recognize the
// event as sign to start processing of messages.
LFoundation::EventLoop::the().add(*this, new LFoundation::CallEvent(nullptr));
}
}
void receive_event(std::unique_ptr<LFoundation::Event> event) override
{
if (event->type() == LFoundation::Event::Type::DeferredInvoke) {
// Note: The event was sent from pump_messages() and callback of CallEvent is 0!
// Do NOT call callback here!
auto msg = std::move(m_messages);
for (int i = 0; i < msg.size(); i++) {
if (msg[i] && msg[i]->decoder_magic() == m_client_decoder.magic() && msg[i]->key() == m_accepted_key) {
m_client_decoder.handle(*msg[i]);
}
}
}
}
private:
int m_accepted_key { -1 };
int m_connection_fd;
std::vector<std::unique_ptr<Message>> m_messages;
ServerDecoder& m_server_decoder;
ClientDecoder& m_client_decoder;
}; |
willmexe/opuntiaOS | libs/libfoundation/include/libfoundation/json/Parser.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#pragma once
#include <libfoundation/json/Lexer.h>
#include <libfoundation/json/Object.h>
#include <string>
namespace LFoundation::Json {
class Parser {
public:
Parser(const std::string& filepath)
{
int err = m_lexer.set_file(filepath);
if (err) {
m_root_object = new InvalidObject();
}
}
~Parser() = default;
Object* object()
{
if (!m_root_object) {
m_root_object = parse_object();
}
return m_root_object;
}
private:
StringObject* parse_string();
DictObject* parse_dict();
Object* parse_object();
Object* m_root_object { nullptr };
Lexer m_lexer;
};
} // namespace LFoundation |
willmexe/opuntiaOS | kernel/include/libkern/bits/sys/ioctls.h | <reponame>willmexe/opuntiaOS
#ifndef _KERNEL_LIBKERN_BITS_SYS_IOCTLS_H
#define _KERNEL_LIBKERN_BITS_SYS_IOCTLS_H
/* TTY */
#define TIOCGPGRP 0x0101
#define TIOCSPGRP 0x0102
#define TCGETS 0x0103
#define TCSETS 0x0104
#define TCSETSW 0x0105
#define TCSETSF 0x0106
/* BGA */
#define BGA_SWAP_BUFFERS 0x0101
#define BGA_GET_HEIGHT 0x0102
#define BGA_GET_WIDTH 0x0103
#endif // _KERNEL_LIBKERN_BITS_SYS_IOCTLS_H |
willmexe/opuntiaOS | kernel/include/libkern/version.h | <gh_stars>100-1000
#ifndef _KERNEL_LIBKERN_VERSION_H
#define _KERNEL_LIBKERN_VERSION_H
#define OSTYPE "opuntiaOS"
#define OSRELEASE "1.0.0-dev"
#define VERSION_MAJOR 1
#define VERSION_MINOR 0
#define VERSION_REVISION 0
#define VERSION_VARIANT "0"
#ifdef __i386__
#define MACHINE "x86"
#elif __arm__
#define MACHINE "arm"
#endif
#endif // _KERNEL_LIBKERN_VERSION_H |
willmexe/opuntiaOS | kernel/include/drivers/bits/driver.h | /*
* Copyright (C) 2020-2022 The opuntiaOS Project Authors.
* + Contributed by <NAME> <<EMAIL>>
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef _KERNEL_DRIVERS_BITS_DRIVER_H
#define _KERNEL_DRIVERS_BITS_DRIVER_H
#include <libkern/types.h>
#define MAX_DRIVER_FUNCTION_COUNT 32
// Supported driver's types
enum DRIVERS_TYPE {
DRIVER_STORAGE_DEVICE = (1 << 0),
DRIVER_VIDEO_DEVICE = (1 << 1),
DRIVER_SOUND_DEVICE = (1 << 2),
DRIVER_INPUT_SYSTEMS_DEVICE = (1 << 3),
DRIVER_NETWORK_DEVICE = (1 << 4),
DRIVER_BUS_CONTROLLER = (1 << 5),
DRIVER_CHAR_DEVICE = (1 << 6),
DRIVER_VIRTUAL_FILE_SYSTEM = (1 << 7),
DRIVER_FILE_SYSTEM = (1 << 8),
DRIVER_VIRTUAL = (1 << 9),
};
// Api function of DRIVER_STORAGE type
enum DRIVER_VIDEO_OPERTAION {
DRIVER_VIDEO_INIT = 0x1, // function called when a device is found
DRIVER_VIDEO_SET_RESOLUTION,
};
// Api function of DRIVER_STORAGE type
enum DRIVER_STORAGE_OPERTAION {
DRIVER_STORAGE_ADD_DEVICE = 0x1, // function called when a device is found
DRIVER_STORAGE_READ,
DRIVER_STORAGE_WRITE,
DRIVER_STORAGE_FLUSH,
DRIVER_STORAGE_CAPACITY,
};
// Api function of DRIVER_INPUT_SYSTEMS type
enum DRIVER_INPUT_SYSTEMS_OPERTAION {
DRIVER_INPUT_SYSTEMS_ADD_DEVICE = 0x1, // function called when a device is found
DRIVER_INPUT_SYSTEMS_GET_LAST_KEY,
DRIVER_INPUT_SYSTEMS_DISCARD_LAST_KEY
};
// Api function of DRIVER_CONTROLLER type
enum DRIVER_BUS_CONTROLLER_OPERTAION {
DRIVER_BUS_CONTROLLER_FIND_DEVICE = 0x1, // function called when a device is found
};
// Api function of DRIVER_VIRTUAL_FILE_SYSTEM type
enum DRIVER_VIRTUAL_FILE_SYSTEM_OPERTAION {
DRIVER_VIRTUAL_FILE_SYSTEM_ADD_DRIVER = 0x1,
DRIVER_VIRTUAL_FILE_SYSTEM_ADD_DEVICE,
DRIVER_VIRTUAL_FILE_SYSTEM_EJECT_DEVICE,
};
// Api function of DRIVER_FILE_SYSTEM type
enum DRIVER_FILE_SYSTEM_OPERTAION {
DRIVER_FILE_SYSTEM_RECOGNIZE = 0x1,
DRIVER_FILE_SYSTEM_PREPARE_FS,
DRIVER_FILE_SYSTEM_EJECT_DEVICE,
DRIVER_FILE_SYSTEM_OPEN,
DRIVER_FILE_SYSTEM_CAN_READ,
DRIVER_FILE_SYSTEM_CAN_WRITE,
DRIVER_FILE_SYSTEM_READ,
DRIVER_FILE_SYSTEM_WRITE,
DRIVER_FILE_SYSTEM_TRUNCATE,
DRIVER_FILE_SYSTEM_MKDIR,
DRIVER_FILE_SYSTEM_RMDIR,
DRIVER_FILE_SYSTEM_READ_INODE,
DRIVER_FILE_SYSTEM_WRITE_INODE,
DRIVER_FILE_SYSTEM_FREE_INODE,
DRIVER_FILE_SYSTEM_GET_FSDATA,
DRIVER_FILE_SYSTEM_LOOKUP,
DRIVER_FILE_SYSTEM_GETDENTS,
DRIVER_FILE_SYSTEM_CREATE,
DRIVER_FILE_SYSTEM_UNLINK,
DRIVER_FILE_SYSTEM_FSTAT,
DRIVER_FILE_SYSTEM_IOCTL,
DRIVER_FILE_SYSTEM_MMAP,
};
struct driver;
struct device;
typedef struct {
void (*recieve_notification)(uint32_t key, uint32_t val);
int (*on_start)();
int (*on_stop)();
int (*init_with_dev)(struct device* device);
} driver_system_funcs_t;
enum DRIVER_DESC_FLAGS {
DRIVER_DESC_FLAG_START = (1 << 0),
};
struct driver_desc {
int type;
uint32_t flags;
uint32_t listened_device_mask;
uint32_t listened_driver_mask;
void* functions[MAX_DRIVER_FUNCTION_COUNT];
driver_system_funcs_t system_funcs;
};
typedef struct driver_desc driver_desc_t;
struct driver {
int id;
int status;
driver_desc_t desc;
const char* name;
};
typedef struct driver driver_t;
#endif // _KERNEL_DRIVERS_BITS_DRIVER_H |
willmexe/opuntiaOS | libs/libc/include/fcntl.h | <reponame>willmexe/opuntiaOS
#ifndef _LIBC_FCNTL_H
#define _LIBC_FCNTL_H
#include <bits/fcntl.h>
#include <sys/cdefs.h>
#include <sys/types.h>
__BEGIN_DECLS
int open(const char* pathname, int flags);
int creat(const char* path, mode_t mode);
__END_DECLS
#endif // _LIBC_FCNTL_H |
willmexe/opuntiaOS | kernel/include/platform/generic/vmm/consts.h | <reponame>willmexe/opuntiaOS<gh_stars>100-1000
#ifdef __i386__
#include <platform/x86/vmm/consts.h>
#elif __arm__
#include <platform/aarch32/vmm/consts.h>
#endif |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.