lib.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdarg.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "debug.h"
#include "stockfw.h"
#include "dirent.h"

// NOTE: cache flushing for a specific memory range is currently not stable!
/*
void cache_flush(void *addr, size_t size)
{
	uintptr_t idx;
	uintptr_t begin = (uintptr_t)addr;
	uintptr_t end = begin + size - 1;

    // Hit_Writeback_D
    for (idx = begin; idx <= end; idx += 16)
        asm volatile("cache 0x19, 0(%0)" : : "r"(idx));
    asm volatile("sync 0; nop; nop");
    // Hit_Invalidate_I
    for (idx = begin; idx <= end; idx += 16)
        asm volatile("cache 0x10, 0(%0)" : : "r"(idx));
    asm volatile("nop; nop; nop; nop; nop; nop; nop; nop"); // ehb may be nop on this core
}*/

void full_cache_flush()
{
	unsigned idx;

	// Index_Writeback_Inv_D
	for (idx = 0x80000000; idx <= 0x80004000; idx += 16) // all of D-cache
		asm volatile("cache 1, 0(%0); cache 1, 0(%0)" : : "r"(idx));

	asm volatile("sync 0; nop; nop");

	// Index_Invalidate_I
	for (idx = 0x80000000; idx <= 0x80004000; idx += 16) // all of I-cache
		asm volatile("cache 0, 0(%0); cache 0, 0(%0)" : : "r"(idx));

	asm volatile("nop; nop; nop; nop; nop"); // ehb may be nop on this core
}

// a call to this function is generated by gcc when __builtin__clear_cache is used
void _flush_cache(void *buf, size_t sz, int flags)
{
	// note: params are ignored and *all* the cache is cleared instead.
	// this seems to produce the most stable behavior for running dynarec code.

	full_cache_flush();
}

extern int g_errno;

extern void (*__xlog)(const char *fmt, ...);
// #define __xlog(...)

void *sbrk(ptrdiff_t incr)
{
	static void *s_heap_end;
	static void *s_heap_ptr = NULL;
	if (!s_heap_ptr)
	{
		s_heap_ptr = gp_buf_64m;	// use stock's 64MB scratch buffer
		s_heap_end = gp_buf_64m + 0x4000000;
	}

	void *curr_ptr = s_heap_ptr;
	void *new_ptr = s_heap_ptr + incr;

	if (new_ptr >= s_heap_end)
		lcd_bsod("sbrk: out of memory");

	s_heap_ptr = new_ptr;

// __xlog("sbrk: ret=%p incr=%d s_heap_ptr=%p\n", curr_ptr, (int)incr, s_heap_ptr);
	
	return curr_ptr;
}

int open(const char *path, int flags, ...)
{
	int fs_flags = 0;
	int fs_perms = 0666;    // all access?
	
	if (flags & O_RDONLY) fs_flags |= FS_O_RDONLY;
	if (flags & O_WRONLY) fs_flags |= FS_O_WRONLY;
	if (flags & O_RDWR)   fs_flags |= FS_O_RDWR;
	if (flags & O_APPEND) fs_flags |= FS_O_APPEND;
	if (flags & O_CREAT)  fs_flags |= FS_O_CREAT;
	if (flags & O_TRUNC)  fs_flags |= FS_O_TRUNC;

// __xlog("open: path=%s flags=%d fs_flags=%d\n", path, flags, fs_flags);

int ret = fs_open(path, fs_flags, fs_perms);
	if (ret < 0)
		errno = g_errno;
	else
		ret += 5;

// __xlog("open: ret=%d\n", ret);
	return ret;
}

ssize_t read(int fd, void *buf, size_t count)
{
if (fd == 0 || fd == 1 || fd == 2)
		return 0;

	fd -= 5;

// __xlog("read: fd=%d buf=%p count=%u\n", fd, buf, count);
	ssize_t ret = fs_read(fd, buf, count);
	if (ret < 0)
		errno = g_errno;
// __xlog("read: ret=%d\n", ret);
	return ret;
}

ssize_t write(int fd, const void *buf, size_t count)
{
	if (fd == 0)
		return -1;
	else if (fd == 1 || fd == 2)
	{
		xlog("%.*s", count, buf);
		return count;
	}

	fd -= 5;

// __xlog("write: fd=%d buf=%p count=%u\n", fd, buf, count);
	ssize_t ret = fs_write(fd, buf, count);
	if (ret < 0)
		errno = g_errno;
// __xlog("write: ret=%d\n", ret);
	return ret;
}

off_t lseek(int fd, off_t offset, int whence)
{
	if (fd == 0 || fd == 1 || fd == 2)
		return -1;

// __xlog("lseek: fd=%d offset=%d whence=%d\n", fd, (int)offset, whence);

	fd -= 5;

	int64_t ret = fs_lseek(fd, offset, whence);
	if (ret < 0)
		errno = g_errno;
// __xlog("lseek: ret=%d\n", (int)ret);

	return ret;
}

int close(int fd)
{
	if (fd == 0 || fd == 1 || fd == 2)
		return -1;

// __xlog("close: fd=%d\n", fd);

	fd -= 5;

	int ret = fs_close(fd);
	if (ret < 0)
		errno = g_errno;
// __xlog("close: ret=%d\n", ret);
	return ret;
}

typedef struct {
	union {
		struct {
			uint8_t	_1[0x18];	// type is at offset 0x18
			uint32_t type;		// 0x81b6 - file,	0x41ff - dir
		};
		struct {
			uint8_t	_2[0x38];	// size is at offset 0x38
			uint32_t size;		// filesize if type is a file
		};
		uint8_t	__[160];		// total struct size is 160
	};
} fs_stat_t;

static int stat_common(int ret, fs_stat_t *buffer, struct stat *sbuf)
{
	if (ret == 0)
	{
		memset(sbuf, 0, sizeof(*sbuf));
		sbuf->st_mode = S_ISREG(buffer->type)*S_IFREG | S_ISDIR(buffer->type)*S_IFDIR | (S_IRUSR|S_IWUSR);
		sbuf->st_size = buffer->size;
		return 0;
	}
	else
		return -1;
}

// wrap fs_stat to supply a more standard stat implementation
// for now only `type` (for dir or file) and `size` fields of `struct stat` are filled
int	stat(const char *path, struct stat *sbuf)
{
	fs_stat_t buffer = {0};
	int ret = fs_stat(path, &buffer);
	return stat_common(ret, &buffer, sbuf);
}

int	fstat(int fd, struct stat *sbuf)
{
	fs_stat_t buffer = {0};
	int ret = fs_fstat(fd, &buffer);
	return stat_common(ret, &buffer, sbuf);
}

int access(const char *path, int mode)
{
    struct stat buffer;
    return stat(path, &buffer);
}

int mkdir(const char *path, mode_t mode)
{
	return fs_mkdir(path, mode);
}

char *getcwd(char *buf, size_t size)
{
	return NULL;
}

int chdir(const char *path)
{
	return -1;
}

int rmdir(const char *path)
{
	return -1;
}

int unlink(const char *path)
{
	return -1;
}

int chmod(const char *path, mode_t mode)
{
	return -1;
}

int kill(pid_t pid, int sig)
{
	return -1;
}

pid_t getpid(void)
{
	return 1;
}

void abort(void)
{
	unsigned ra;
	asm volatile ("move %0, $ra" : "=r" (ra));
	lcd_bsod("abort() called from 0x%08x", ra);
}

void exit(int status)
{
	unsigned ra;
	asm volatile ("move %0, $ra" : "=r" (ra));
	lcd_bsod("exit(%d) called from 0x%08x", status, ra);
}

/* wrappers were not compiled in, but vfs drivers likely support these ops */
int rename(const char *old, const char* new)
{
	return -1;
}

int isatty(int fd)
{
    return 0;
}

clock_t clock(void)
{
	// clock function should return cpu clock ticks, so since os_get_tick_count() returns milliseconds,
	// we devide by 1000 to get the seconds and multiply by CLOCKS_PER_SEC to get the clock ticks.
    return (clock_t)(os_get_tick_count() * CLOCKS_PER_SEC / 1000);
}

int gettimeofday(struct timeval *tv, void *tz)
{
	if (tv == NULL)
		return -1;

	uint32_t msec = os_get_tick_count();

	tv->tv_sec = msec / 1000;
	tv->tv_usec = (msec % 1000) * 1000;

	return 0;
}

DIR *opendir(const char *path)
{
	int fd = fs_opendir(path);
	if (fd < 0)
		return NULL;

	return (DIR*)(fd + 1);
}

int closedir(DIR *dir)
{
	int fd = (int)dir - 1;
	if (fd < 0)
		return -1;

	return fs_closedir(fd);
}

struct dirent *readdir(DIR *dir)
{
	int fd = (int)dir - 1;
	if (fd < 0)
		return NULL;

	struct {
		union {
			struct {
				uint8_t _1[0x10];
				uint32_t type;
			};
			struct {
				uint8_t _2[0x22];
				char    d_name[0x225];
			};
			uint8_t __[0x428];
		};
	} buffer = {0};

	if (fs_readdir(fd, &buffer) < 0)
		return NULL;

	// TODO: not thread safe
	static struct dirent d;

	d.d_type = S_ISREG(buffer.type)*DTYPE_FILE | S_ISDIR(buffer.type)*DTYPE_DIRECTORY;
	strncpy(d.d_name, buffer.d_name, sizeof(d.d_name));
	return &d;
}