/*
* Wrap the kernel time call so that it also
* returns a time_t (longlong). The kernel ABI
* doesn't deal in 64bit return values.
*/
time_t time(time_t *t) {
time_t tmp;
if (t) {
_time(t);
return *t;
}
_time(&tmp);
return tmp;
}
MouseAction MouseController::getMouseAction(float IQ, ItemType itemtype, Vec2 dis, Vec2 speed, float range) {
if (rand_0_1() * maxIQ > IQ) {
return RUN;
}
Vec2 _time((speed.x != 0 ? dis.x / speed.x : 99999), (speed.y != 0 ? dis.y / speed.y : 99999));
switch (itemtype) {
case HOLE:
return JUMP;
break;
case DENGEROUS_CUCRBIT:
if (cmpFloat(_time.x, _time.y, range) == 0) {
if (dis.x > Mouse::mouseWidth)
return SLOWDOWN;
return SPEEDUP;
}
break;
case BENEFICATE_CUCRBIT:
if (cmpFloat(_time.x, _time.y, range) == 1) {
return SPEEDUP;
}
else if (cmpFloat(_time.x, _time.y, range) == -1) {
return SLOWDOWN;
}
break;
case SCOOTER:
return JUMP;
break;
default: break;
}
return RUN;
}
int time(int *tp) {
int t;
t = _time();
if (tp) *tp = t;
return t;
}
void SqlDelayThread::run()
{
#ifndef DO_POSTGRESQL
mysql_thread_init();
#endif
SqlAsyncTask * s = NULL;
ACE_Time_Value _time(2);
while (m_running)
{
// if the running state gets turned off while sleeping
// empty the queue before exiting
s = dynamic_cast<SqlAsyncTask*> (m_sqlQueue.dequeue());
if (s)
{
s->call();
delete s;
}
}
#ifndef DO_POSTGRESQL
mysql_thread_end();
#endif
}
int mkstemps(char *s, int slen)
{
__ktime_t t;
char *p = s + strlen(s) - slen;
char *n;
int fd;
if (p < s)
goto bad;
if (memcmp(p, "XXXXXX", 6))
goto bad;
_time(&t, 0);
n = _itoa(getuid() << 8 + getpid() + (uint16_t)t.time);
do {
n += 7919; /* Any old prime ought to do */
memcpy(p, "000000", 6);
memcpy(p + 6 - strlen(n), n, strlen(n));
fd = open(s, O_CREAT|O_EXCL|O_RDWR, 0600);
}
while(fd == -1 && errno == EEXIST);
return fd;
bad:
errno = EINVAL;
return -1;
}
FileLogger::~FileLogger() {
std::stringstream ss;
ss << "************************************************" << std::endl
<< " End " << m_title << " - " << _date() << " at " << _time() << std::endl
<< "************************************************" << std::endl;
_write(ss.str());
}
/* _gettimeofday -- implement in terms of time. */
int _gettimeofday (struct timeval *tv, void *tzvp)
{
struct timezone *tz = tzvp;
if (tz)
tz->tz_minuteswest = tz->tz_dsttime = 0;
tv->tv_usec = 0;
tv->tv_sec = _time (0);
return 0;
}
void INpcObject::update()
{
if (m_data->getTextCount() &&
_time() >= m_nextText)
{
if (m_world->isPlayerInLocalArea(this))
{
sendToLocalArea(IPacketCreator::chat(m_id, m_data->getText(m_text).Str.c_str()));
}
m_nextText = _time() + random(m_data->getText(m_text).Delay, 2 * m_data->getText(m_text).Delay);
++m_text;
//reset the current text
if (m_text == m_data->getTextCount())
{
m_text = 0;
}
}
}
static void write_entry(int level, time_t *t, char *str)
{
if ((logt_mode & LOG_MODE_OUTPUT_FILE) &&
(level <= logt_logfile_priority) && logt_logfile_fp) {
fprintf(logt_logfile_fp, "%s %s %s", _time(t), logt_name, str);
fflush(logt_logfile_fp);
}
if ((logt_mode & LOG_MODE_OUTPUT_SYSLOG) &&
(level <= logt_syslog_priority))
syslog(level, "%s", str);
}
static int session_uptime(lua_State *L)
{
struct ap_session *ses = luaL_checkudata(L, 1, LUA_AP_SESSION);
time_t t;
if (!ses)
return 0;
t = ses->stop_time ?: _time();
lua_pushinteger(L, t - ses->start_time);
return 1;
}
TEST_F(DateTimeTests,FromStringTest)
{
const std::string expected = "2017-07-02T09:47:10.00Z";
DateTime parsed = DateTime::Parse(expected);
tm stm;
stm.tm_sec = 10;
stm.tm_min = 47;
stm.tm_hour = 9;
stm.tm_year = 2017-1900;
stm.tm_mon = 7-1;
stm.tm_mday = 2;
DateTime _time(stm);
ASSERT_EQ(parsed==_time,true);
}
/**
* Interrupt 80h. Handles the system calls.
*
* @param regs Pointer to struct containing micro's registers.
*/
void int80(registers* regs) {
switch (regs->eax) {
case _SYS_READ:
regs->eax = _read((unsigned int)regs->ebx, (char*)regs->ecx, (size_t)regs->edx);
break;
case _SYS_WRITE:
regs->eax = _write((unsigned int)regs->ebx, (const char*)regs->ecx, (size_t)regs->edx);
break;
case _SYS_TIME:
regs->eax = _time(regs->ebx);
break;
case _SYS_IOCTL:
regs->eax = _ioctl(regs->ebx, regs->ecx, (void*)regs->edx);
break;
case _SYS_TICKS:
regs->eax = _getTicksSinceStart();
break;
case _SYS_YIELD:
// This just makes sure we call the scheduler again, for now
break;
case _SYS_EXIT:
_exit();
break;
case _SYS_GETPID:
regs->eax = _getpid();
break;
case _SYS_GETPPID:
regs->eax = _getppid();
break;
case _SYS_RUN:
regs->eax = _run((void(*)(char*)) regs->ebx, (char*) regs->ecx, regs->edx);
break;
case _SYS_WAIT:
regs->eax = _wait();
break;
case _SYS_KILL:
_kill((pid_t) regs->ebx);
break;
case _SYS_PINFO:
regs->eax = _pinfo(regs->ebx, (size_t)regs->ecx);
break;
}
}
void __attribute__((naked,noinline)) capt_seq_hook_set_nr()
{
asm volatile("STMFD SP!, {R0-R12,LR}\n");
switch (core_get_noise_reduction_value()){
case NOISE_REDUCTION_AUTO_CANON:
// leave it alone
break;
case NOISE_REDUCTION_OFF:
*nrflag = NR_OFF;
break;
case NOISE_REDUCTION_ON:
*nrflag = NR_ON;
break;
};
shutter_open_time=_time((void*)0);
asm volatile("LDMFD SP!, {R0-R12,PC}\n");
}
FileLogger::FileLogger(const std::string& filePath, const std::string& title, bool overwrite)
: m_file(filePath), m_title(title) {
if (overwrite) {
m_file.rm();
}
if (!m_file.exists()) {
m_file.create();
}
m_file.open("ab");
std::stringstream ss;
ss << "************************************************" << std::endl
<< " Start " << m_title << " - " << _date() << " at " << _time() << std::endl
<< "************************************************" << std::endl;
_write(ss.str());
}
/*
* Report message on stdout/syslog if dbg_channel_mask permits.
*/
void dbg_wrapped(unsigned long channel, const char *fmt, ...)
{
va_list ap;
if ((channel & dbg_channel_mask) == channel) {
char buf[DBG_BUFLEN];
va_start(ap, fmt);
vsnprintf(buf, DBG_BUFLEN, fmt, ap); /* overflow ignored on purpose */
va_end(ap);
if (dbg_ttyvalid)
fprintf(stderr, "%s %s: %s\n",
_time(), _channel_name(channel), buf);
else
syslog(LOG_DEBUG, "%s: %s",
_channel_name(channel), buf);
}
}
int main()
{
time_t t1, t2;
struct tm tm1, tm2;
time( &t1 );
tm1 = *localtime(&t1);
t1 = mktime(&tm1);
tm1 = *gmtime(&t1);
_time( &t2 );
tm2 = *_localtime(&t2);
t2 = _mktime(&tm2);
tm2 = *_gmtime(&t2);
// time, mktime
if( t1==t2 )
OutputDebugString( "ok\n" );
else
{
static char buf[128];
wsprintf( buf, "ng : %d, %d\n", t1, t2 );
OutputDebugString( buf );
}
// localtime, gmtime
if( 0==memcmp( &tm1, &tm2, sizeof(struct tm) ) )
OutputDebugString( "ok\n" );
else
OutputDebugString( "ng\n" );
// ctime
OutputDebugString( ctime(&t1) );
OutputDebugString( _ctime(&t2) );
// asctime
OutputDebugString( asctime(&tm1) );
OutputDebugString( _asctime(&tm2) );
return 0;
}
void SqlDelayThread::run()
{
#ifndef DO_POSTGRESQL
mysql_thread_init();
#endif
//lets wait for next async task no more than 2 secs...
ACE_Time_Value _time(2);
while (m_running)
{
// if the running state gets turned off while sleeping
// empty the queue before exiting
SqlAsyncTask * s = dynamic_cast<SqlAsyncTask*> (m_sqlQueue.dequeue(/*&_time*/));
if(s)
{
s->call();
delete s;
}
}
#ifndef DO_POSTGRESQL
mysql_thread_end();
#endif
}
void
IsotropicSphereModel::doGenerate(Catalog& catalog)
{
if (catalog.getType() != _catType)
{
std::stringstream ss;
ss << "Generate failed. Model '" << ModelMapper::instance()->getKey(getType())
<< "'. Provided catalog type doesn't match requested one.";
Exception exc(type::EXCEPTION_WARNING + type::EXCEPTION_MOD_NO_PREFIX,
ss.str(), PRETTY_FUNCTION);
throw exc;
}
for (std::size_t i = 0; i < getNumberOfEntries(); ++i)
{
CatalogEntryGrbcat* entry = createEntry();
entry->getCoordFlag() = 0.0;
entry->getCoodinates().getX0() = _time(getGenerator());
entry->getCoodinates().getX1() = 1.0;
entry->getCoodinates().getX2() = _phi(getGenerator());
entry->getCoodinates().getX3() = _theta(getGenerator());
catalog.getEntries().push_back(entry);
}
}
time_t time(time_t *tp) {
return _time(tp);
}
unsigned long time(unsigned long *timer) {
return _time(timer);
}
void createProcess(struct Process* process, EntryPoint entryPoint, struct Process* parent, char* args, int terminal, int kernel) {
process->pid = ++pid;
process->kernel = !!kernel;
process->terminal = terminal;
process->active = 0;
process->parent = parent;
process->firstChild = NULL;
process->cycles = 0;
process->curr_cycles = 0;
process->prev_cycles = 0;
process->timeStart = _time(NULL);
process->uid = 0;
process->gid = 0;
if (parent != NULL) {
process->uid = parent->uid;
process->gid = parent->gid;
}
process->prev = NULL;
if (parent == NULL) {
process->ppid = 0;
process->next = NULL;
process->cwd = kalloc(2 * sizeof(char));
strcpy(process->cwd, "/");
} else {
process->ppid = parent->pid;
process->next = parent->firstChild;
if (parent->firstChild) {
parent->firstChild->prev = process;
}
parent->firstChild = process;
process->cwd = kalloc(strlen(parent->cwd) + 1);
strcpy(process->cwd, parent->cwd);
}
process->entryPoint = entryPoint;
if (args == NULL) {
process->args[0] = 0;
} else {
int i;
for (i = 0; *(args + i) && i < ARGV_SIZE - 1; i++) {
process->args[i] = args[i];
}
process->args[i] = 0;
}
process->schedule.priority = 2;
process->schedule.status = StatusReady;
process->schedule.inWait = 0;
process->schedule.ioWait = 0;
process->schedule.done = 0;
for (size_t i = 0; i < MAX_OPEN_FILES; i++) {
if (parent && parent->fdTable[i].inode) {
fs_dup(&process->fdTable[i], parent->fdTable[i]);
} else {
process->fdTable[i].inode = NULL;
}
}
{
process->mm.pagesInKernelStack = KERNEL_STACK_PAGES;
struct Pages* mem = reserve_pages(process, process->mm.pagesInKernelStack);
assert(mem != NULL);
process->mm.esp0 = (char*)mem->start + PAGE_SIZE * process->mm.pagesInKernelStack;
process->mm.kernelStack = process->mm.esp0;
}
if (kernel) {
process->mm.pagesInHeap = 0;
process->mm.mallocContext = NULL;
} else {
process->mm.pagesInHeap = 256;
struct Pages* mem = reserve_pages(process, process->mm.pagesInHeap);
assert(mem != NULL);
process->mm.mallocContext = mm_create_context(mem->start, process->mm.pagesInHeap * PAGE_SIZE);
mem_check();
}
if (!kernel) {
process->mm.pagesInStack = 16;
struct Pages* mem = reserve_pages(process, process->mm.pagesInStack);
assert(mem != NULL);
process->mm.esp = (char*)mem->start + PAGE_SIZE * process->mm.pagesInStack;
} else {
process->mm.pagesInStack = 0;
process->mm.esp = NULL;
}
setup_page_directory(process, kernel);
if (!kernel) {
struct Pages* ungetPage = reserve_pages(process, 1);
assert(ungetPage != NULL);
mm_pagination_map(process, (unsigned int)ungetPage->start, (unsigned int)STACK_TOP_MAPPING, 1, 1, 1);
FILE* files;
for (int i = 0; i < 3; i++) {
files = ungetPage->start + i * sizeof(FILE);
files->fd = i;
files->flag = 0;
files->unget = 0;
}
}
int codeSegment, dataSegment;
if (kernel) {
codeSegment = KERNEL_CODE_SEGMENT;
dataSegment = KERNEL_DATA_SEGMENT;
char* esp0 = (char*) process->mm.esp0 - ARGV_SIZE;
for (size_t i = 0; i < ARGV_SIZE; i++) {
esp0[i] = process->args[i];
}
process->mm.esp0 = esp0;
push((unsigned int**) &process->mm.esp0, (unsigned int) process->mm.esp0);
push((unsigned int**) &process->mm.esp0, (unsigned int) exit);
push((unsigned int**) &process->mm.esp0, 0x202);
} else {
codeSegment = USER_CODE_SEGMENT;
dataSegment = USER_DATA_SEGMENT;
char* esp = (char*) process->mm.esp - ARGV_SIZE;
for (size_t i = 0; i < ARGV_SIZE; i++) {
esp[i] = process->args[i];
}
process->mm.esp = esp;
push((unsigned int**) &process->mm.esp, STACK_TOP_MAPPING - ARGV_SIZE);
push((unsigned int**) &process->mm.esp, (unsigned int) exit);
push((unsigned int**) &process->mm.esp0, dataSegment);
push((unsigned int**) &process->mm.esp0, STACK_TOP_MAPPING - 2 * sizeof(int) - ARGV_SIZE);
push((unsigned int**) &process->mm.esp0, 0x3202);
}
push((unsigned int**) &process->mm.esp0, codeSegment);
push((unsigned int**) &process->mm.esp0, (unsigned int) entryPoint);
push((unsigned int**) &process->mm.esp0, dataSegment);
push((unsigned int**) &process->mm.esp0, dataSegment);
push((unsigned int**) &process->mm.esp0, dataSegment);
push((unsigned int**) &process->mm.esp0, dataSegment);
push((unsigned int**) &process->mm.esp0, (unsigned int) _interruptEnd);
push((unsigned int**) &process->mm.esp0, (unsigned int) signalPIC);
push((unsigned int**) &process->mm.esp0, 0);
}
uint64_t getctime(void) {
return _time(TIME_CPU);
}
STKUNIT_UNIT_TEST(UnitTestTimer, UnitTest)
{
stk_classic::diag::TimeBlock root_time_block(unitTestTimer());
std::ostringstream strout;
// Create subtimer and test lap time
{
static stk_classic::diag::Timer lap_timer("One second Wall time twice", unitTestTimer());
stk_classic::diag::TimeBlock _time(lap_timer);
double x = quick_work();
x = x;
std::ostringstream oss;
oss << x << std::endl;
::sleep(1);
lap_timer.lap();
stk_classic::diag::MetricTraits<stk_classic::diag::WallTime>::Type lap_time = lap_timer.getMetric<stk_classic::diag::WallTime>().getLap();
STKUNIT_ASSERT(lap_time >= 1.0);
::sleep(1);
lap_timer.stop();
lap_time = lap_timer.getMetric<stk_classic::diag::WallTime>().getLap();
STKUNIT_ASSERT(lap_time >= 2.0);
}
//
{
static stk_classic::diag::Timer run_timer("Run 100 times twice", unitTestTimer());
for (int i = 0; i < 100; ++i) {
stk_classic::diag::TimeBlock _time(run_timer);
work();
}
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = run_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT(lap_count == 100);
}
// Create second timer set
{
static stk_classic::diag::Timer second_timer("Second timer set", unitTestTimer(), unitTestSecondTimerSet());
static stk_classic::diag::Timer second_timer_on_default("On default", second_timer);
static stk_classic::diag::Timer second_timer_on("On", TIMER_APP_3, second_timer);
static stk_classic::diag::Timer second_timer_off("Off", TIMER_APP_1, second_timer);
stk_classic::diag::TimeBlock _time(second_timer);
stk_classic::diag::TimeBlock _time1(second_timer_on_default);
stk_classic::diag::TimeBlock _time2(second_timer_on);
stk_classic::diag::TimeBlock _time3(second_timer_off);
::sleep(1);
}
// Grab previous subtimer and run 100 laps
{
static stk_classic::diag::Timer run_timer("Run 100 times twice", unitTestTimer());
for (int i = 0; i < 100; ++i) {
stk_classic::diag::TimeBlock _time(run_timer);
work();
}
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = run_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT(lap_count == 200);
}
// Create root object
RootObject root_object;
{
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = root_object.m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT(lap_count == 0);
}
// Create object
{
Object time_object("One object", root_object);
for (int i = 0; i < 100; ++i) {
time_object.run();
}
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = time_object.m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT(lap_count == 100);
}
// Create object tree
{
std::vector<Object> object_vector;
object_vector.push_back(Object("Object Tree", root_object));
int id = 0;
for (size_t i = 0; i < 2; ++i) {
size_t ix = object_vector.size();
object_vector.push_back(Object(id++, object_vector[0]));
for (size_t j = 0; j < 2; ++j) {
size_t jx = object_vector.size();
object_vector.push_back(Object(id++, object_vector[ix]));
for (int k = 0; k < 2; ++k) {
object_vector.push_back(Object(id++, object_vector[jx]));
}
}
}
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, false);
stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type lap_count = 0;
for (size_t j = 0; j < object_vector.size(); ++j)
lap_count += object_vector[j].m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT_EQUAL(lap_count, stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type(0));
for (size_t j = 0; j < object_vector.size(); ++j)
object_vector[j].run();
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, false);
lap_count = 0;
for (size_t j = 0; j < object_vector.size(); ++j)
lap_count += object_vector[j].m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT_EQUAL(lap_count, stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type(object_vector.size()));
for (size_t i = 1; i < 100; ++i)
for (size_t j = 0; j < object_vector.size(); ++j)
object_vector[j].run();
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, false);
lap_count = 0;
for (size_t j = 0; j < object_vector.size(); ++j)
lap_count += object_vector[j].m_timer.getMetric<stk_classic::diag::LapCount>().getAccumulatedLap(false);
STKUNIT_ASSERT_EQUAL(lap_count, stk_classic::diag::MetricTraits<stk_classic::diag::LapCount>::Type(100*object_vector.size()));
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, true);
for (size_t i = 1; i < 100; ++i)
for (size_t j = 0; j < object_vector.size(); ++j)
object_vector[j].run();
stk_classic::diag::printTimersTable(strout, unitTestTimer(), stk_classic::diag::METRICS_ALL, true);
std::cout << strout.str() << std::endl;
// dw().m(LOG_TIMER) << strout.str() << stk_classic::diag::dendl;
}
}
static void
p_rtentry(struct rtentry *rt)
{
static struct ifnet *ifnet, *lastif;
struct rtentry *parent;
static char buffer[128];
static char prettyname[128];
struct sockaddr *sa;
sa_u addr, mask;
/*
* Don't print protocol-cloned routes unless -a.
*/
if (rt->rt_flags & RTF_WASCLONED && !aflag)
{
//kget(rt->rt_parent, parent);
parent = rt->rt_parent;
if (parent->rt_flags & RTF_PRCLONING)
return;
}
bzero(&addr, sizeof(addr));
if ((sa = kgetsa(rt_key(rt))))
bcopy(sa, &addr, sa->sa_len);
bzero(&mask, sizeof(mask));
if (rt_mask(rt) && (sa = kgetsa(rt_mask(rt))))
bcopy(sa, &mask, sa->sa_len);
p_sockaddr(&addr.u_sa, &mask.u_sa, rt->rt_flags, wid_dst);
p_sockaddr(kgetsa(rt->rt_gateway), NULL, RTF_HOST, wid_gw);
snprintf(buffer, sizeof(buffer), "%%-%d.%ds ", wid_flags, wid_flags);
p_flags(rt->rt_flags, buffer);
if (addr.u_sa.sa_family == AF_INET || Wflag)
{
printf("%*ld %*lu ", wid_refs, rt->rt_refcnt,
wid_use, rt->rt_use);
if (Wflag)
{
if (rt->rt_rmx.rmx_mtu != 0)
printf("%*lu ", wid_mtu, rt->rt_rmx.rmx_mtu);
else
printf("%*s ", wid_mtu, "");
}
}
if (rt->rt_ifp)
{
if (rt->rt_ifp != lastif)
{
//kget(rt->rt_ifp, ifnet);
ifnet = rt->rt_ifp;
lastif = rt->rt_ifp;
strlcpy(prettyname, ifnet->if_xname, sizeof(prettyname));
}
printf("%*.*s", wid_if, wid_if, prettyname);
if (rt->rt_rmx.rmx_expire)
{
time_t expire_time;
if ((expire_time =
rt->rt_rmx.rmx_expire - _time((time_t *)0)) > 0)
printf(" %*d", wid_expire, (int)expire_time);
}
if (rt->rt_nodes[0].rn_dupedkey)
printf(" =>");
}
printf("\n");
}
/**
* Interrupt 80h. Handles the system calls.
*
* @param regs Pointer to struct containing micro's registers.
*/
void int80(registers* regs) {
switch (regs->eax) {
case _SYS_READ:
regs->eax = _read((unsigned int)regs->ebx, (char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_WRITE:
regs->eax = _write((unsigned int)regs->ebx, (const char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_TIME:
regs->eax = _time((time_t*)translate(regs->ebx));
break;
case _SYS_IOCTL:
regs->eax = _ioctl(regs->ebx, regs->ecx, (void*)translate(regs->edx));
break;
case _SYS_TICKS:
regs->eax = _getTicksSinceStart();
break;
case _SYS_YIELD:
// This just makes sure we call the scheduler again, for now
break;
case _SYS_EXIT:
_exit();
break;
case _SYS_GETPID:
regs->eax = _getpid();
break;
case _SYS_GETPPID:
regs->eax = _getppid();
break;
case _SYS_RUN:
regs->eax = _run((EntryPoint) translate(regs->ebx), (char*) translate(regs->ecx), regs->edx);
break;
case _SYS_WAIT:
regs->eax = _wait();
break;
case _SYS_KILL:
_kill((pid_t) regs->ebx);
break;
case _SYS_PINFO:
regs->eax = _pinfo((struct ProcessInfo*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_SLEEP:
_sleep(regs->ebx);
break;
case _SYS_NICE:
regs->eax = _nice(regs->ebx);
break;
case _SYS_RENICE:
regs->eax = _renice(regs->ebx, regs->ecx);
break;
case _SYS_CLOSE:
regs->eax = _close(regs->ebx);
break;
case _SYS_OPEN:
regs->eax = _open((char*)translate(regs->ebx), regs->ecx, regs->edx);
break;
case _SYS_CREAT:
regs->eax = _creat((char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_MKDIR:
regs->eax = _mkdir((const char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_RMDIR:
regs->eax = _rmdir((const char*)translate(regs->ebx));
break;
case _SYS_UNLINK:
regs->eax = _unlink((const char*)translate(regs->ebx));
break;
case _SYS_RENAME:
regs->eax = _rename((const char*)translate(regs->ebx), (const char*)translate(regs->ecx));
break;
case _SYS_CHDIR:
regs->eax = _chdir((const char*)translate(regs->ebx));
break;
case _SYS_GETCWD:
regs->eax = _getcwd((char*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_READDIR:
regs->eax = _readdir(regs->ebx, (struct fs_DirectoryEntry*)translate(regs->ecx), regs->edx);
break;
case _SYS_SETPPERSONA:
_setProcessPersona(regs->ebx, regs->ecx, regs->edx);
break;
case _SYS_GETPPERSONA:
_getProcessPersona(regs->ebx, (int*)translate(regs->ecx), (int*) translate(regs->edx));
break;
case _SYS_SYMLINK:
regs->eax = _symlink((const char *)translate(regs->ebx), (const char *)translate(regs->ecx));
break;
case _SYS_MKFIFO:
regs->eax = _mkfifo((const char*)translate(regs->ebx));
break;
case _SYS_CHMOD:
regs->eax = _chmod(regs->ebx, (const char*)translate(regs->ecx));
break;
case _SYS_STAT:
regs->eax = _stat((const char*)translate(regs->ebx), (struct stat*)translate(regs->ecx));
break;
case _SYS_CHOWN:
regs->eax = _chown((const char*)translate(regs->ebx));
break;
case _SYS_LOG:
_loglevel(regs->ebx);
break;
case _SYS_STACKSIZE:
regs->eax = _stacksize();
}
}
uint64_t getktime(void) {
return _time(TIME_KERNEL);
}
