void signal_init(void) {
syscall_register(SYS_WAIT4, (syscall_fn_t)sys_wait4, 4);
syscall_register(SYS_SIGNAL, (syscall_fn_t)sys_signal, 2);
syscall_register(SYS_RT_SIGACTION, (syscall_fn_t)sys_rt_sigaction, 3);
syscall_register(SYS_RT_SIGSUSPEND, (syscall_fn_t)sys_rt_sigsuspend, 2);
memset(CurrentTask->sigact, 0, NSIG * sizeof(struct sigaction));
}
void proc_init(void) {
syscall_register(SYS_EXIT, (syscall_fn_t)sys_exit, 1);
syscall_register(SYS_EXECVE, (syscall_fn_t)sys_execve, 3);
syscall_register(SYS_GETPPID, (syscall_fn_t)sys_getppid, 0);
syscall_register(SYS_GETPID, (syscall_fn_t)sys_getpid, 0);
syscall_register(SYS_FORK, (syscall_fn_t)sys_fork, 0);
syscall_register(SYS_SCHED_YIELD, (syscall_fn_t)sys_sched_yield, 0);
syscall_register(SYS_GETPGID, (syscall_fn_t)sys_getpgid, 1);
syscall_register(SYS_GETPGRP, (syscall_fn_t)sys_getpgrp, 0);
syscall_register(SYS_SETPGID, (syscall_fn_t)sys_setpgid, 2);
}
/*
* Called once to initialize data structures...
*/
static int
nfssvc_modevent(module_t mod, int type, void *data)
{
static int registered;
int error = 0;
switch (type) {
case MOD_LOAD:
error = syscall_register(&nfssvc_offset, &nfssvc_sysent,
&nfssvc_prev_sysent, SY_THR_STATIC_KLD);
if (error)
break;
registered = 1;
break;
case MOD_UNLOAD:
if (nfsd_call_nfsserver != NULL || nfsd_call_nfscommon != NULL
|| nfsd_call_nfscl != NULL || nfsd_call_nfsd != NULL) {
error = EBUSY;
break;
}
if (registered)
syscall_deregister(&nfssvc_offset, &nfssvc_prev_sysent);
registered = 0;
break;
default:
error = EOPNOTSUPP;
break;
}
return error;
}
int
afs_init(struct vfsconf *vfc)
{
int code;
int offset = AFS_SYSCALL;
#if defined(AFS_FBSD90_ENV) || defined(AFS_FBSD82_ENV)
code = syscall_register(&offset, &afs_sysent, &old_sysent);
if (code) {
printf("AFS_SYSCALL in use, error %i. aborting\n", code);
return code;
}
#else
if (sysent[AFS_SYSCALL].sy_call != (sy_call_t *)nosys
&& sysent[AFS_SYSCALL].sy_call != (sy_call_t *)lkmnosys) {
printf("AFS_SYSCALL in use. aborting\n");
return EBUSY;
}
#endif
osi_Init();
afs_pbuf_freecnt = nswbuf / 2 + 1;
#if !defined(AFS_FBSD90_ENV) && !defined(AFS_FBSD82_ENV)
old_handler = sysent[AFS_SYSCALL].sy_call;
sysent[AFS_SYSCALL].sy_call = afs3_syscall;
sysent[AFS_SYSCALL].sy_narg = 5;
#endif
return 0;
}
int
syscall_helper_register(struct syscall_helper_data *sd, int flags)
{
struct syscall_helper_data *sd1;
int error;
for (sd1 = sd; sd1->syscall_no != NO_SYSCALL; sd1++) {
error = syscall_register(&sd1->syscall_no, &sd1->new_sysent,
&sd1->old_sysent, flags);
if (error != 0) {
syscall_helper_unregister(sd);
return (error);
}
sd1->registered = 1;
}
return (0);
}
int
syscall_module_handler(struct module *mod, int what, void *arg)
{
struct syscall_module_data *data = arg;
modspecific_t ms;
int error;
switch (what) {
case MOD_LOAD:
error = syscall_register(data->offset, data->new_sysent,
&data->old_sysent, data->flags);
if (error) {
/* Leave a mark so we know to safely unload below. */
data->offset = NULL;
return (error);
}
ms.intval = *data->offset;
MOD_XLOCK;
module_setspecific(mod, &ms);
MOD_XUNLOCK;
if (data->chainevh)
error = data->chainevh(mod, what, data->chainarg);
return (error);
case MOD_UNLOAD:
/*
* MOD_LOAD failed, so just return without calling the
* chained handler since we didn't pass along the MOD_LOAD
* event.
*/
if (data->offset == NULL)
return (0);
if (data->chainevh) {
error = data->chainevh(mod, what, data->chainarg);
if (error)
return error;
}
error = syscall_deregister(data->offset, &data->old_sysent);
return (error);
default:
if (data->chainevh)
return (data->chainevh(mod, what, data->chainarg));
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
/**
* Initialize the Palacios hypervisor.
*/
static int
palacios_init(void)
{
printk(KERN_INFO "---- Initializing Palacios hypervisor support\n");
printk(KERN_INFO "cpus_weight(cpu_online_map)=0x%x\n",cpus_weight(cpu_online_map));
Init_V3(&palacios_os_hooks, NULL, cpus_weight(cpu_online_map), options);
irq_request(
IRQ1_VECTOR,
&palacios_keyboard_interrupt,
0,
"keyboard",
NULL
);
syscall_register(__NR_v3_start_guest, (syscall_ptr_t) sys_v3_start_guest);
return 0;
}
