void do_syscall_trace_exit(struct pt_regs *regs)
{
long errno;
/*
* We may come here right after calling schedule_user()
* in which case we can be in RCU user mode.
*/
user_exit();
/*
* The standard tile calling convention returns the value (or negative
* errno) in r0, and zero (or positive errno) in r1.
* It saves a couple of cycles on the hot path to do this work in
* registers only as we return, rather than updating the in-memory
* struct ptregs.
*/
errno = (long) regs->regs[0];
if (errno < 0 && errno > -4096)
regs->regs[1] = -errno;
else
regs->regs[1] = 0;
if (test_thread_flag(TIF_SYSCALL_TRACE))
tracehook_report_syscall_exit(regs, 0);
if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
trace_sys_exit(regs, regs->regs[0]);
}
int
main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr,"usage: cutewiki <wikiname> \n");
exit(1);
}
/* Try to set different non-UTF-8 locale */
if (!setlocale(LC_ALL, "")) {
fprintf(stderr, "Error: Setting locale failed!\n");
exit(1);
}
//svr_init();
wiki_init(argv[1]);
user_init();
rcs_init();
pagelist_init(wiki->pagedir);
fprintf(stderr, "Info: CuteWiki started with configuration '%s'.\n", wiki->wikiname);
wiki_loop();
pagelist_exit();
user_exit();
wiki_exit();
svr_exit();
return 0;
}
/**
* Quit from the game
* @param response message following action command
* @param user User making action request
* @param manager Global resource manager
*/
void *action_quit( const char *response, User user, Management manager)
{
user_lock( user );
user_exit( user );
user_unlock( user );
return NULL;
}
/*
* Notification of system call entry/exit
* - triggered by current->work.syscall_trace
*/
asmlinkage long syscall_trace_enter(struct pt_regs *regs, long syscall)
{
long ret = 0;
user_exit();
current_thread_info()->syscall = syscall;
if (secure_computing() == -1)
return -1;
if (test_thread_flag(TIF_SYSCALL_TRACE) &&
tracehook_report_syscall_entry(regs))
ret = -1;
#ifdef CONFIG_GRKERNSEC_SETXID
if (unlikely(test_and_clear_thread_flag(TIF_GRSEC_SETXID)))
gr_delayed_cred_worker();
#endif
if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
trace_sys_enter(regs, regs->regs[2]);
audit_syscall_entry(syscall, regs->regs[4], regs->regs[5],
regs->regs[6], regs->regs[7]);
return syscall;
}
main(int argc, char **argv )
{
initialize_socket( atoi(argv[1]) );
while( ! user_exit() ) {
read_message();
print_message();
}
close(socket_descriptor);
}
void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, unsigned long thread_info_flags)
{
user_exit();
if (thread_info_flags & _TIF_SIGPENDING)
do_signal(regs, orig_i0);
if (thread_info_flags & _TIF_NOTIFY_RESUME) {
clear_thread_flag(TIF_NOTIFY_RESUME);
tracehook_notify_resume(regs);
}
user_enter();
}
void addons_client::wait_for_transfer_done(const std::string& status_message)
{
check_connected();
if(!stat_) {
stat_ = new gui2::tnetwork_transmission(*conn_, _("Add-ons Manager"), status_message);
} else {
stat_->set_subtitle(status_message);
}
if(!stat_->show(disp_.video())) {
// Notify the caller chain that the user aborted the operation.
throw user_exit();
}
}
/*
* Notification of system call entry/exit
* - triggered by current->work.syscall_trace
*/
asmlinkage long syscall_trace_enter(struct pt_regs *regs, long syscall)
{
user_exit();
current_thread_info()->syscall = syscall;
if (test_thread_flag(TIF_SYSCALL_TRACE)) {
if (tracehook_report_syscall_entry(regs))
return -1;
syscall = current_thread_info()->syscall;
}
#ifdef CONFIG_SECCOMP
if (unlikely(test_thread_flag(TIF_SECCOMP))) {
int ret, i;
struct seccomp_data sd;
unsigned long args[6];
sd.nr = syscall;
sd.arch = syscall_get_arch();
syscall_get_arguments(current, regs, 0, 6, args);
for (i = 0; i < 6; i++)
sd.args[i] = args[i];
sd.instruction_pointer = KSTK_EIP(current);
ret = __secure_computing(&sd);
if (ret == -1)
return ret;
syscall = current_thread_info()->syscall;
}
#endif
if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
trace_sys_enter(regs, regs->regs[2]);
audit_syscall_entry(syscall, regs->regs[4], regs->regs[5],
regs->regs[6], regs->regs[7]);
/*
* Negative syscall numbers are mistaken for rejected syscalls, but
* won't have had the return value set appropriately, so we do so now.
*/
if (syscall < 0)
syscall_set_return_value(current, regs, -ENOSYS, 0);
return syscall;
}
/*
* notification of userspace execution resumption
* - triggered by the TIF_WORK_MASK flags
*/
asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
__u32 thread_info_flags)
{
local_irq_enable();
user_exit();
/* deal with pending signal delivery */
if (thread_info_flags & _TIF_SIGPENDING)
do_signal(regs);
if (thread_info_flags & _TIF_NOTIFY_RESUME) {
clear_thread_flag(TIF_NOTIFY_RESUME);
tracehook_notify_resume(regs);
}
user_enter();
}
/*
* Notification of system call entry/exit
* - triggered by current->work.syscall_trace
*/
asmlinkage void syscall_trace_leave(struct pt_regs *regs)
{
/*
* We may come here right after calling schedule_user()
* or do_notify_resume(), in which case we can be in RCU
* user mode.
*/
user_exit();
audit_syscall_exit(regs);
if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
trace_sys_exit(regs, regs_return_value(regs));
if (test_thread_flag(TIF_SYSCALL_TRACE))
tracehook_report_syscall_exit(regs, 0);
user_enter();
}
/*
* Notification of system call entry/exit
* - triggered by current->work.syscall_trace
*/
asmlinkage long syscall_trace_enter(struct pt_regs *regs, long syscall)
{
long ret = 0;
user_exit();
if (secure_computing(syscall) == -1)
return -1;
if (test_thread_flag(TIF_SYSCALL_TRACE) &&
tracehook_report_syscall_entry(regs))
ret = -1;
if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
trace_sys_enter(regs, regs->regs[2]);
audit_syscall_entry(syscall, regs->regs[4], regs->regs[5],
regs->regs[6], regs->regs[7]);
return syscall;
}
int do_syscall_trace_enter(struct pt_regs *regs)
{
u32 work = ACCESS_ONCE(current_thread_info()->flags);
/*
* If TIF_NOHZ is set, we are required to call user_exit() before
* doing anything that could touch RCU.
*/
if (work & _TIF_NOHZ)
user_exit();
if (work & _TIF_SYSCALL_TRACE) {
if (tracehook_report_syscall_entry(regs))
regs->regs[TREG_SYSCALL_NR] = -1;
}
if (work & _TIF_SYSCALL_TRACEPOINT)
trace_sys_enter(regs, regs->regs[TREG_SYSCALL_NR]);
return regs->regs[TREG_SYSCALL_NR];
}
/* Called on entry from user mode with IRQs off. */
__visible void enter_from_user_mode(void)
{
CT_WARN_ON(ct_state() != CONTEXT_USER);
user_exit();
}
long syscall_emu(long call, long arg1, long arg2, long arg3,
long arg4, long arg5, long arg6)
{
long ret;
switch (call)
{
case __NR_brk:
case __NR_mmap2:
case __NR_mmap:
case __NR_mremap:
case __NR_mprotect:
case __NR_madvise:
case __NR_sigaltstack:
case __NR_signal:
case __NR_sigaction:
case __NR_sigreturn:
case __NR_rt_sigaction:
case __NR_rt_sigreturn:
case __NR_fork:
case __NR_vfork:
case __NR_clone:
case __NR_exit:
case __NR_execve:
case __NR_exit_group:
break;
case __NR_read:
case __NR_readv:
case __NR_open:
case __NR_creat:
case __NR_dup:
case __NR_dup2:
case __NR_openat:
case __NR_pipe:
case __NR_socketcall:
ret = syscall_intr(call,arg1,arg2,arg3,arg4,arg5,arg6);
if ( taint_flag == TAINT_ON )
do_taint(ret,call,arg1,arg2,arg3,arg4,arg5,arg6);
return ret;
case __NR_ipc:
if ( arg1 == SHMAT )
break;
/* fall through */
default:
return syscall_intr(call,arg1,arg2,arg3,arg4,arg5,arg6);
}
ret = call;
if (!try_block_signals())
return ret; /* we have a signal in progress, revert to pre-syscall state */
switch (call)
{
/* these calls are all non-blocking right?
* blocked signals during blocking calls is a bad thing
*/
case __NR_brk:
ret = user_brk(arg1);
break;
case __NR_mmap2:
ret = user_mmap2(arg1,arg2,arg3,arg4,arg5,arg6);
break;
case __NR_mmap:
ret = user_old_mmap((struct kernel_mmap_args *)arg1);
break;
case __NR_mremap:
ret = user_mremap(arg1,arg2,arg3,arg4,arg5);
break;
case __NR_mprotect:
ret = user_mprotect(arg1,arg2,arg3);
break;
case __NR_madvise:
ret = user_madvise(arg1,arg2,arg3);
break;
case __NR_ipc:
if (arg1 == SHMAT)
ret = user_shmat(arg2,(char *)arg5,arg3,(unsigned long *)arg4);
else
die("should not have caught IPC call: %d", arg1);
break;
case __NR_sigaltstack:
ret = user_sigaltstack((stack_t *)arg1, (stack_t *)arg2);
break;
case __NR_signal:
{
ret = (long)user_signal(arg1, (kernel_sighandler_t)arg2);
break;
}
case __NR_sigaction:
ret = user_sigaction(arg1, (struct kernel_old_sigaction *)arg2,
(struct kernel_old_sigaction *)arg3);
break;
case __NR_rt_sigaction:
ret = user_rt_sigaction(arg1, (struct kernel_sigaction *)arg2,
(struct kernel_sigaction *)arg3, arg4);
break;
case __NR_sigreturn:
user_sigreturn();
break;
case __NR_rt_sigreturn:
user_rt_sigreturn();
break;
case __NR_vfork:
ret = user_clone(SIGCHLD, 0, NULL, NULL, NULL);
// ret = user_clone(CLONE_VFORK | CLONE_VM | SIGCHLD, 0, NULL, NULL, NULL);
break;
case __NR_fork:
ret = user_clone(SIGCHLD, 0, NULL, NULL, NULL);
break;
case __NR_clone:
ret = user_clone(arg1, arg2, (void *)arg3, (void *)arg4, (void*)arg5);
break;
case __NR_exit:
user_exit(arg1);
break;
case __NR_execve:
ret = user_execve((char *)arg1, (char **)arg2, (char **)arg3);
break;
case __NR_exit_group:
if (dump_on_exit)
{
long regs[] = { call, arg2, arg3, arg1, get_thread_ctx()->user_esp, arg6, arg4, arg5 };
do_taint_dump(regs);
}
sys_exit_group(arg1);
default:
die("unimplemented syscall");
break;
}
unblock_signals();
return ret;
}