static void
__sandbox_stat_fini(stat_t * pstat)
{
PROC_BEGIN("__sandbox_stat_fini(%p)", pstat);
assert(pstat);
PROC_END("__sandbox_stat_fini()");
}
static void
__sandbox_stat_init(stat_t * pstat)
{
PROC_BEGIN("__sandbox_stat_init(%p)", pstat);
assert(pstat);
memset(pstat, 0, sizeof(stat_t));
PROC_END("__sandbox_stat_init()");
}
void
flush_cache(void)
{
PROC_BEGIN("flush_cache()");
unsigned int i;
unsigned int sum = 0;
for (i = 0; i < CACHE_SIZE / sizeof(int); i++) cache[i] = 3;
for (i = 0; i < CACHE_SIZE / sizeof(int); i++) sum += cache[i];
sink = sum;
PROC_END("flush_cache()");
}
void
cache_flush(void)
{
PROC_BEGIN();
unsigned int i;
unsigned int sum = 0;
for (i = 0; i < CACHE_SIZE / sizeof(int); i++) cache[i] = 3;
for (i = 0; i < CACHE_SIZE / sizeof(int); i++) sum += cache[i];
cache_sink = sum;
PROC_END();
}
static void
__sandbox_task_fini(task_t * ptask)
{
PROC_BEGIN("__sandbox_task_fini(%p)", ptask);
assert(ptask);
/* TODO */
PROC_END("__sandbox_task_fini()");
}
static void
__sandbox_default_policy(const policy_t * ppolicy, const event_t * pevent,
action_t * paction)
{
PROC_BEGIN("__sandbox_default_policy(%p,%p,%p)", ppolicy, pevent, paction);
assert(pevent && paction);
switch (pevent->type)
{
case S_EVENT_SYSCALL:
case S_EVENT_SYSRET:
*paction = (action_t){S_ACTION_CONT};
break;
case S_EVENT_EXIT:
switch (pevent->data._EXIT.code)
{
case EXIT_SUCCESS:
*paction = (action_t){S_ACTION_FINI, {{S_RESULT_OK}}};
break;
default:
*paction = (action_t){S_ACTION_FINI, {{S_RESULT_AT}}};
break;
}
break;
case S_EVENT_ERROR:
*paction = (action_t){S_ACTION_KILL, {{S_RESULT_IE}}};
break;
case S_EVENT_SIGNAL:
*paction = (action_t){S_ACTION_KILL, {{S_RESULT_RT}}};
break;
case S_EVENT_QUOTA:
switch (pevent->data._QUOTA.type)
{
case S_QUOTA_WALLCLOCK:
case S_QUOTA_CPU:
*paction = (action_t){S_ACTION_KILL, {{S_RESULT_TL}}};
break;
case S_QUOTA_MEMORY:
*paction = (action_t){S_ACTION_KILL, {{S_RESULT_ML}}};
break;
case S_QUOTA_DISK:
*paction = (action_t){S_ACTION_KILL, {{S_RESULT_OL}}};
break;
}
break;
default:
*paction = (action_t){S_ACTION_KILL, {{S_RESULT_IE}}};
break;
}
PROC_END("__sandbox_default_policy()");
}
static void
__sandbox_ctrl_fini(ctrl_t * pctrl)
{
PROC_BEGIN("__sandbox_ctrl_fini(%p)", pctrl);
assert(pctrl);
P(&pctrl->mutex);
pctrl->idle = true;
pthread_cond_broadcast(&pctrl->sched);
V(&pctrl->mutex);
P(&pctrl->mutex);
pctrl->tracer = pctrl->monitor = NULL;
pthread_cond_destroy(&pctrl->sched);
V(&pctrl->mutex);
pthread_mutex_destroy(&pctrl->mutex);
PROC_END("__sandbox_ctrl_fini()");
}
static void
__sandbox_ctrl_init(ctrl_t * pctrl, thread_func_t tft, thread_func_t tfm)
{
PROC_BEGIN("__sandbox_ctrl_init(%p,%p,%p)", pctrl, tft, tfm);
assert(pctrl);
memset(pctrl, 0, sizeof(ctrl_t));
pthread_mutex_init(&pctrl->mutex, NULL);
P(&pctrl->mutex);
pthread_cond_init(&pctrl->sched, NULL);
pctrl->policy.entry = (void *)__sandbox_default_policy;
pctrl->policy.data = 0L;
pctrl->tracer = tft;
pctrl->monitor = tfm;
V(&pctrl->mutex);
P(&pctrl->mutex);
pctrl->idle = true;
pthread_cond_broadcast(&pctrl->sched);
V(&pctrl->mutex);
PROC_END("__sandbox_ctrl_init()");
}
static void
__sandbox_task_init(task_t * ptask, const char * argv[])
{
PROC_BEGIN("__sandbox_task_init(%p)", ptask);
assert(ptask); /* argv could be NULL */
memset(ptask, 0, sizeof(task_t));
int argc = 0;
size_t offset = 0;
if (argv != NULL)
{
while (argv[argc] != NULL)
{
size_t delta = strlen(argv[argc]) + 1;
if (offset + delta >= sizeof(ptask->comm.buff))
{
break;
}
strcpy(ptask->comm.buff + offset, argv[argc]);
ptask->comm.args[argc++] = offset;
offset += delta;
}
}
ptask->comm.buff[offset] = '\0';
ptask->comm.args[argc] = -1;
strcpy(ptask->jail, "/");
ptask->uid = getuid();
ptask->gid = getgid();
ptask->ifd = STDIN_FILENO;
ptask->ofd = STDOUT_FILENO;
ptask->efd = STDERR_FILENO;
ptask->quota[S_QUOTA_WALLCLOCK] = RES_INFINITY;
ptask->quota[S_QUOTA_CPU] = RES_INFINITY;
ptask->quota[S_QUOTA_MEMORY] = RES_INFINITY;
ptask->quota[S_QUOTA_DISK] = RES_INFINITY;
PROC_END("__sandbox_task_init()");
}
