gh0s7/mckernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a5889fb5df4f404d6d4fa29abde3302393232ef3
mckernel/arch/x86/kernel/syscall.c
Tomoki Shirasawa a5889fb5df sigaction check signal number (LTP sigaction02)
2014-12-04 11:31:50 +09:00

823 lines
22 KiB
C
Raw Blame History

/**
* \file syscall.c
* License details are found in the file LICENSE.
* \brief
* archtecture depended system call handlers
* \author Gou Nakamura <go.nakamura.yw@hitachi-solutions.com> \par
* Copyright (C) 2013 Hitachi, Ltd.
* \author Masamichi Takagi <m-takagi@ab.jp.nec.com> \par
* Copyright (C) 2013 NEC Corporation
* \author Tomoki Shirasawa <tomoki.shirasawa.kk@hitachi-solutions.com> \par
* Copyright (C) 2013 Hitachi, Ltd.
*/
/*
* HISTORY:
*/
#include <ihk/cpu.h>
#include <ihk/debug.h>
#include <cls.h>
#include <cpulocal.h>
#include <syscall.h>
#include <process.h>
#include <string.h>
#include <errno.h>
#include <kmalloc.h>
void terminate(int, int, ihk_mc_user_context_t *);
int copy_from_user(struct process *proc, void *dst, const void *src, size_t siz);
int copy_to_user(struct process *proc, void *dst, const void *src, size_t siz);
long do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact);
//#define DEBUG_PRINT_SC
#ifdef DEBUG_PRINT_SC
#define dkprintf kprintf
#else
#define dkprintf(...)
#endif
/*
See dkprintf("BSP HW ID = %d, ", bsp_hw_id); (in ./mcos/kernel/ap.c)
Core with BSP HW ID 224 is 1st logical core of last physical core.
It boots first and is given SW-ID of 0
Core with BSP HW ID 0 is 1st logical core of 1st physical core.
It boots next and is given SW-ID of 1.
Core with BSP HW ID 1 boots next and is given SW-ID of 2.
Core with BSP HW ID 2 boots next and is given SW-ID of 3.
Core with BSP HW ID 3 boots next and is given SW-ID of 4.
...
Core with BSP HW ID 220 is 1st logical core of 56-th physical core.
It boots next and is given SW-ID of 221.
Core with BSP HW ID 221 boots next and is given SW-ID of 222.
Core with BSP HW ID 222 boots next and is given SW-ID of 223.
Core with BSP HW ID 223 boots next and is given SW-ID of 224.
Core with BSP HW ID 225 is 2nd logical core of last physical core.
It boots next and is given SW-ID of 225.
Core with BSP HW ID 226 boots next and is given SW-ID of 226.
Core with BSP HW ID 227 boots next and is given SW-ID of 227.
*/
static ihk_spinlock_t cpuid_head_lock = 0;
static int cpuid_head = 1;
/* archtecture-depended syscall handlers */
int obtain_clone_cpuid() {
/* see above on BSP HW ID */
struct ihk_mc_cpu_info *cpu_info = ihk_mc_get_cpu_info();
int cpuid, nretry = 0;
ihk_mc_spinlock_lock_noirq(&cpuid_head_lock);
retry:
/* Try to obtain next physical core */
cpuid = cpuid_head;
/* A hyper-threading core on the same physical core as
the parent process might be chosen. Use sched_setaffinity
if you want to skip that kind of busy physical core for
performance reason. */
cpuid_head += 1;
if(cpuid_head >= cpu_info->ncpus) {
cpuid_head = 0;
}
/* A hyper-threading core whose parent physical core has a
process on one of its hyper-threading core might
be chosen. Use sched_setaffinity if you want to skip that
kind of busy physical core for performance reason. */
if(get_cpu_local_var(cpuid)->status != CPU_STATUS_IDLE) {
nretry++;
if(nretry >= cpu_info->ncpus) {
cpuid = -1;
ihk_mc_spinlock_unlock_noirq(&cpuid_head_lock);
goto out;
}
goto retry;
}
ihk_mc_spinlock_unlock_noirq(&cpuid_head_lock);
out:
return cpuid;
}
SYSCALL_DECLARE(rt_sigaction)
{
struct process *proc = cpu_local_var(current);
int sig = ihk_mc_syscall_arg0(ctx);
const struct sigaction *act = (const struct sigaction *)ihk_mc_syscall_arg1(ctx);
struct sigaction *oact = (struct sigaction *)ihk_mc_syscall_arg2(ctx);
size_t sigsetsize = ihk_mc_syscall_arg3(ctx);
struct k_sigaction new_sa, old_sa;
int rc;
if(sig == SIGKILL || sig == SIGSTOP || sig <= 0 || sig > 64)
return -EINVAL;
if (sigsetsize != sizeof(sigset_t))
return -EINVAL;
if(act)
if(copy_from_user(proc, &new_sa.sa, act, sizeof new_sa.sa)){
goto fault;
}
rc = do_sigaction(sig, act? &new_sa: NULL, oact? &old_sa: NULL);
if(rc == 0 && oact)
if(copy_to_user(proc, oact, &old_sa.sa, sizeof old_sa.sa)){
goto fault;
}
return rc;
fault:
return -EFAULT;
}
struct sigsp {
struct x86_regs regs;
unsigned long sigrc;
unsigned long sigmask;
int ssflags;
siginfo_t info;
};
SYSCALL_DECLARE(rt_sigreturn)
{
struct process *proc = cpu_local_var(current);
struct x86_regs *regs;
struct sigsp *sigsp;
long rc = -EFAULT;
asm("movq %%gs:132, %0" : "=r" (regs));
--regs;
sigsp = (struct sigsp *)regs->rsp;
proc->sigmask.__val[0] = sigsp->sigmask;
proc->sigstack.ss_flags = sigsp->ssflags;
if(copy_from_user(proc, regs, &sigsp->regs, sizeof(struct x86_regs)))
return rc;
copy_from_user(proc, &rc, &sigsp->sigrc, sizeof(long));
return rc;
}
extern struct cpu_local_var *clv;
extern unsigned long do_kill(int pid, int tid, int sig, struct siginfo *info);
extern void interrupt_syscall(int all, int pid);
extern int num_processors;
void
do_setpgid(int pid, int pgid)
{
struct cpu_local_var *v;
struct process *p;
struct process *proc = cpu_local_var(current);
int i;
unsigned long irqstate;
if(pid == 0)
pid = proc->ftn->pid;
if(pgid == 0)
pgid = pid;
for(i = 0; i < num_processors; i++){
v = get_cpu_local_var(i);
irqstate = ihk_mc_spinlock_lock(&(v->runq_lock));
list_for_each_entry(p, &(v->runq), sched_list){
if(p->ftn->pid <= 0)
continue;
if(p->ftn->pid == pid){
p->ftn->pgid = pgid;
}
}
ihk_mc_spinlock_unlock(&(v->runq_lock), irqstate);
}
}
void
pokeuser(struct process *proc, void *regs0)
{
struct x86_regs *regs = regs0;
if(regs == NULL){
asm("movq %%gs:132, %0" : "=r" (regs));
--regs;
}
asm("mov %0, %%db0" ::"r" (proc->userp->u_debugreg[0]));
asm("mov %0, %%db1" ::"r" (proc->userp->u_debugreg[1]));
asm("mov %0, %%db2" ::"r" (proc->userp->u_debugreg[2]));
asm("mov %0, %%db3" ::"r" (proc->userp->u_debugreg[3]));
// asm("mov %0, %%db4" ::"r" (proc->userp->u_debugreg[4]));
// asm("mov %0, %%db5" ::"r" (proc->userp->u_debugreg[5]));
asm("mov %0, %%db6" ::"r" (proc->userp->u_debugreg[6]));
asm("mov %0, %%db7" ::"r" (proc->userp->u_debugreg[7]));
regs->r15 = proc->userp->regs.r15;
regs->r14 = proc->userp->regs.r14;
regs->r13 = proc->userp->regs.r13;
regs->r12 = proc->userp->regs.r12;
regs->rbp = proc->userp->regs.rbp;
regs->rbx = proc->userp->regs.rbx;
regs->r11 = proc->userp->regs.r11;
regs->r10 = proc->userp->regs.r10;
regs->r9 = proc->userp->regs.r9;
regs->r8 = proc->userp->regs.r8;
regs->rax = proc->userp->regs.rax;
regs->rcx = proc->userp->regs.rcx;
regs->rdx = proc->userp->regs.rdx;
regs->rsi = proc->userp->regs.rsi;
regs->rdi = proc->userp->regs.rdi;
regs->rip = proc->userp->regs.rip;
regs->cs = proc->userp->regs.cs;
regs->rflags = proc->userp->regs.eflags;
regs->rsp = proc->userp->regs.rsp;
regs->ss = proc->userp->regs.ss;
}
void
peekuser(struct process *proc, void *regs0)
{
struct x86_regs *regs = regs0;
if(regs == NULL){
asm("movq %%gs:132, %0" : "=r" (regs));
--regs;
}
if(proc->userp == NULL){
proc->userp = kmalloc(sizeof(struct user), IHK_MC_AP_NOWAIT);
memset(proc->userp, '\0', sizeof(struct user));
}
asm("mov %%db0, %0" :"=r" (proc->userp->u_debugreg[0]));
asm("mov %%db1, %0" :"=r" (proc->userp->u_debugreg[1]));
asm("mov %%db2, %0" :"=r" (proc->userp->u_debugreg[2]));
asm("mov %%db3, %0" :"=r" (proc->userp->u_debugreg[3]));
// asm("mov %%db4, %0" :"=r" (proc->userp->u_debugreg[4]));
// asm("mov %%db5, %0" :"=r" (proc->userp->u_debugreg[5]));
asm("mov %%db6, %0" :"=r" (proc->userp->u_debugreg[6]));
asm("mov %%db7, %0" :"=r" (proc->userp->u_debugreg[7]));
proc->userp->regs.r15 = regs->r15;
proc->userp->regs.r14 = regs->r14;
proc->userp->regs.r13 = regs->r13;
proc->userp->regs.r12 = regs->r12;
proc->userp->regs.rbp = regs->rbp;
proc->userp->regs.rbx = regs->rbx;
proc->userp->regs.r11 = regs->r11;
proc->userp->regs.r10 = regs->r10;
proc->userp->regs.r9 = regs->r9;
proc->userp->regs.r8 = regs->r8;
proc->userp->regs.rax = regs->rax;
proc->userp->regs.rcx = regs->rcx;
proc->userp->regs.rdx = regs->rdx;
proc->userp->regs.rsi = regs->rsi;
proc->userp->regs.rdi = regs->rdi;
proc->userp->regs.rip = regs->rip;
proc->userp->regs.cs = regs->cs;
proc->userp->regs.eflags = regs->rflags;
proc->userp->regs.rsp = regs->rsp;
proc->userp->regs.ss = regs->ss;
asm("mov %%es, %0" :"=r" (proc->userp->regs.es));
asm("mov %%fs, %0" :"=r" (proc->userp->regs.fs));
asm("mov %%gs, %0" :"=r" (proc->userp->regs.gs));
}
extern void coredump(struct process *proc, void *regs);
void
do_signal(unsigned long rc, void *regs0, struct process *proc, struct sig_pending *pending)
{
struct x86_regs *regs = regs0;
struct k_sigaction *k;
int sig;
__sigset_t w;
int irqstate;
struct fork_tree_node *ftn = proc->ftn;
for(w = pending->sigmask.__val[0], sig = 0; w; sig++, w >>= 1);
dkprintf("do_signal,pid=%d,sig=%d\n", proc->ftn->pid, sig);
if(regs == NULL){ /* call from syscall */
asm("movq %%gs:132, %0" : "=r" (regs));
--regs;
}
else{
rc = regs->rax;
}
irqstate = ihk_mc_spinlock_lock(&proc->sighandler->lock);
k = proc->sighandler->action + sig - 1;
if(k->sa.sa_handler == SIG_IGN){
kfree(pending);
ihk_mc_spinlock_unlock(&proc->sighandler->lock, irqstate);
return;
}
else if(k->sa.sa_handler){
unsigned long *usp; /* user stack */
struct sigsp *sigsp;
int ssflags = proc->sigstack.ss_flags;
unsigned long mask = (unsigned long)proc->sigmask.__val[0];
if((k->sa.sa_flags & SA_ONSTACK) &&
!(proc->sigstack.ss_flags & SS_DISABLE) &&
!(proc->sigstack.ss_flags & SS_ONSTACK)){
unsigned long lsp;
lsp = ((unsigned long)(((char *)proc->sigstack.ss_sp) + proc->sigstack.ss_size)) & 0xfffffffffffffff8UL;
usp = (unsigned long *)lsp;
proc->sigstack.ss_flags |= SS_ONSTACK;
}
else{
usp = (unsigned long *)regs->rsp;
}
sigsp = ((struct sigsp *)usp) - 1;
if(copy_to_user(proc, &sigsp->regs, regs, sizeof(struct x86_regs)) ||
copy_to_user(proc, &sigsp->sigrc, &rc, sizeof(long))){
kfree(pending);
ihk_mc_spinlock_unlock(&proc->sighandler->lock, irqstate);
kprintf("do_signal,copy_to_user failed\n");
terminate(0, sig, (ihk_mc_user_context_t *)regs->rsp);
return;
}
sigsp->sigmask = mask;
sigsp->ssflags = ssflags;
memcpy(&sigsp->info, &pending->info, sizeof(siginfo_t));
usp = (unsigned long *)sigsp;
usp--;
*usp = (unsigned long)k->sa.sa_restorer;
regs->rdi = (unsigned long)sig;
if(k->sa.sa_flags & SA_SIGINFO){
regs->rsi = (unsigned long)&sigsp->info;
regs->rdx = 0;
}
regs->rip = (unsigned long)k->sa.sa_handler;
regs->rsp = (unsigned long)usp;
proc->sigmask.__val[0] |= pending->sigmask.__val[0];
kfree(pending);
ihk_mc_spinlock_unlock(&proc->sighandler->lock, irqstate);
}
else {
int coredumped = 0;
kfree(pending);
ihk_mc_spinlock_unlock(&proc->sighandler->lock, irqstate);
switch (sig) {
case SIGSTOP:
case SIGTSTP:
case SIGTTIN:
case SIGTTOU:
dkprintf("do_signal,SIGSTOP,changing state\n");
/* Update process state in fork tree */
ihk_mc_spinlock_lock_noirq(&ftn->lock);
ftn->group_exit_status = SIGSTOP;
/* Reap and set new signal_flags */
ftn->signal_flags = SIGNAL_STOP_STOPPED;
ftn->status = PS_STOPPED;
ihk_mc_spinlock_unlock_noirq(&proc->ftn->lock);
/* Wake up the parent who tried wait4 and sleeping */
waitq_wakeup(&proc->ftn->parent->waitpid_q);
dkprintf("do_signal,SIGSTOP,sleeping\n");
/* Sleep */
proc->ftn->status = PS_STOPPED;
schedule();
dkprintf("SIGSTOP(): woken up\n");
break;
case SIGTRAP:
dkprintf("do_signal,SIGTRAP\n");
if(!(ftn->ptrace & PT_TRACED)) {
goto core;
}
/* Update process state in fork tree */
ihk_mc_spinlock_lock_noirq(&ftn->lock);
ftn->exit_status = SIGTRAP;
ftn->status = PS_TRACED;
ihk_mc_spinlock_unlock_noirq(&proc->ftn->lock);
/* Wake up the parent who tried wait4 and sleeping */
waitq_wakeup(&proc->ftn->parent->waitpid_q);
/* Sleep */
dkprintf("do_signal,SIGTRAP,sleeping\n");
schedule();
dkprintf("SIGTRAP(): woken up\n");
break;
case SIGCONT:
dkprintf("do_signal,SIGCONT,do nothing\n");
break;
case SIGQUIT:
case SIGILL:
case SIGABRT:
case SIGFPE:
case SIGSEGV:
case SIGBUS:
core:
dkprintf("do_signal,default,core,sig=%d\n", sig);
coredump(proc, regs);
coredumped = 0x80;
terminate(0, sig | coredumped, (ihk_mc_user_context_t *)regs->rsp);
break;
case SIGHUP:
case SIGINT:
case SIGKILL:
case SIGPIPE:
case SIGALRM:
case SIGTERM:
case SIGUSR1:
case SIGUSR2:
dkprintf("do_signal,default,terminate,sig=%d\n", sig);
terminate(0, sig, (ihk_mc_user_context_t *)regs->rsp);
break;
case SIGCHLD:
case SIGURG:
default:
break;
}
}
}
static int ptrace_report_signal(struct process *proc, struct x86_regs *regs, struct sig_pending *pending)
{
int sig;
__sigset_t w;
long rc;
dkprintf("ptrace_report_signal,pid=%d\n", proc->ftn->pid);
/* Save reason why stopped and process state for wait to reap */
for (w = pending->sigmask.__val[0], sig = 0; w; sig++, w >>= 1);
ihk_mc_spinlock_lock_noirq(&proc->ftn->lock);
proc->ftn->exit_status = sig;
/* Transition process state */
proc->ftn->status = PS_TRACED;
ihk_mc_spinlock_unlock_noirq(&proc->ftn->lock);
if (proc->ftn->parent) {
/* kill SIGCHLD */
ihk_mc_spinlock_lock_noirq(&proc->ftn->parent->lock);
if (proc->ftn->parent->owner) {
struct siginfo info;
memset(&info, '\0', sizeof info);
info.si_signo = SIGCHLD;
info.si_code = CLD_TRAPPED;
info._sifields._sigchld.si_pid = proc->ftn->pid;
info._sifields._sigchld.si_status = proc->ftn->exit_status;
rc = do_kill(proc->ftn->parent->pid, -1, SIGCHLD, &info);
if (rc < 0) {
kprintf("ptrace_report_signal,do_kill failed\n");
}
}
ihk_mc_spinlock_unlock_noirq(&proc->ftn->parent->lock);
/* Wake parent (if sleeping in wait4()) */
waitq_wakeup(&proc->ftn->parent->waitpid_q);
}
peekuser(proc, regs);
dkprintf("ptrace_report_signal,sleeping\n");
/* Sleep */
schedule();
dkprintf("ptrace_report_signal,wake up\n");
return sig;
}
void
check_signal(unsigned long rc, void *regs0)
{
struct x86_regs *regs = regs0;
struct process *proc;
struct sig_pending *pending;
struct sig_pending *next;
struct list_head *head;
ihk_spinlock_t *lock;
__sigset_t w, sig_bv;
int irqstate;
int sig;
if(clv == NULL)
return;
proc = cpu_local_var(current);
if(proc == NULL || proc->ftn->pid == 0)
return;
if(regs != NULL && (regs->rsp & 0x8000000000000000)) {
return;
}
for(;;){
w = proc->sigmask.__val[0];
lock = &proc->sigshared->lock;
head = &proc->sigshared->sigpending;
pending = NULL;
irqstate = ihk_mc_spinlock_lock(lock);
list_for_each_entry_safe(pending, next, head, list){
if(!(pending->sigmask.__val[0] & w)){
list_del(&pending->list);
break;
}
}
if(&pending->list == head)
pending = NULL;
ihk_mc_spinlock_unlock(lock, irqstate);
if(!pending){
lock = &proc->sigpendinglock;
head = &proc->sigpending;
irqstate = ihk_mc_spinlock_lock(lock);
list_for_each_entry_safe(pending, next, head, list){
if(!(pending->sigmask.__val[0] & w)){
list_del(&pending->list);
break;
}
}
if(&pending->list == head)
pending = NULL;
ihk_mc_spinlock_unlock(lock, irqstate);
}
if(!pending) {
dkprintf("check_signal,queue is empty\n");
return;
}
for(sig_bv = pending->sigmask.__val[0], sig = 0; sig_bv; sig++, sig_bv >>= 1);
if((proc->ftn->ptrace & PT_TRACED) && sig != SIGKILL) {
sig = ptrace_report_signal(proc, regs, pending);
/* TODO: Tracing process could overwrite signal, so handle the case here. */
}
do_signal(rc, regs, proc, pending);
}
}
unsigned long
do_kill(int pid, int tid, int sig, siginfo_t *info)
{
dkprintf("do_kill,pid=%d,tid=%d,sig=%d\n", pid, tid, sig);
struct cpu_local_var *v;
struct process *p;
struct process *proc = cpu_local_var(current);
struct process *tproc = NULL;
int i;
__sigset_t mask;
struct list_head *head;
int rc;
unsigned long irqstate = 0;
struct k_sigaction *k;
int doint;
ihk_spinlock_t *savelock = NULL;
int found = 0;
if(sig > 64 || sig < 0)
return -EINVAL;
if(tid == -1 && pid <= 0){
int pgid = -pid;
int rc = -ESRCH;
int *pids;
int i;
int n = 0;
int sendme = 0;
if(pid == 0){
if(proc == NULL || proc->ftn->pid <= 0)
return -ESRCH;
pgid = proc->ftn->pgid;
}
pids = kmalloc(sizeof(int) * num_processors, IHK_MC_AP_NOWAIT);
if(!pids)
return -ENOMEM;
for(i = 0; i < num_processors; i++){
v = get_cpu_local_var(i);
irqstate = ihk_mc_spinlock_lock(&(v->runq_lock));
list_for_each_entry(p, &(v->runq), sched_list){
if(p->ftn->pid <= 0)
continue;
if(proc && p->ftn->pid == proc->ftn->pid){
sendme = 1;
continue;
}
if(pgid == 1 || p->ftn->pgid == pgid){
int j;
for(j = 0; j < n; j++)
if(pids[j] == p->ftn->pid)
break;
if(j == n){
pids[n] = p->ftn->pid;
n++;
}
}
}
ihk_mc_spinlock_unlock(&(v->runq_lock), irqstate);
}
for(i = 0; i < n; i++)
rc = do_kill(pids[i], -1, sig, info);
if(sendme)
rc = do_kill(proc->ftn->pid, -1, sig, info);
kfree(pids);
return rc;
}
irqstate = cpu_disable_interrupt_save();
mask = __sigmask(sig);
if(tid == -1){
struct process *tproc0 = NULL;
ihk_spinlock_t *savelock0 = NULL;
for(i = 0; i < num_processors; i++){
v = get_cpu_local_var(i);
found = 0;
ihk_mc_spinlock_lock_noirq(&(v->runq_lock));
list_for_each_entry(p, &(v->runq), sched_list){
if(p->ftn->pid == pid){
if(p->ftn->tid == pid || tproc == NULL){
if(!(mask & p->sigmask.__val[0])){
tproc = p;
if(!found && savelock) {
ihk_mc_spinlock_unlock_noirq(savelock);
}
found = 1;
savelock = &(v->runq_lock);
if(savelock0 && savelock0 != savelock){
ihk_mc_spinlock_unlock_noirq(savelock0);
savelock0 = NULL;
}
}
else if(tproc == NULL && tproc0 == NULL){
tproc0 = p;
found = 1;
savelock0 = &(v->runq_lock);
}
}
if(!(mask & p->sigmask.__val[0])){
if(p->ftn->tid == pid || tproc == NULL){
}
}
}
}
if(!found) {
ihk_mc_spinlock_unlock_noirq(&(v->runq_lock));
}
}
if(tproc == NULL){
tproc = tproc0;
savelock = savelock0;
}
}
else if(pid == -1){
for(i = 0; i < num_processors; i++){
v = get_cpu_local_var(i);
found = 0;
ihk_mc_spinlock_lock_noirq(&(v->runq_lock));
list_for_each_entry(p, &(v->runq), sched_list){
if(p->ftn->pid > 0 &&
p->ftn->tid == tid){
savelock = &(v->runq_lock);
found = 1;
tproc = p;
break;
}
}
if(!found)
ihk_mc_spinlock_unlock_noirq(&(v->runq_lock));
}
}
else{
for(i = 0; i < num_processors; i++){
v = get_cpu_local_var(i);
found = 0;
ihk_mc_spinlock_lock_noirq(&(v->runq_lock));
list_for_each_entry(p, &(v->runq), sched_list){
if(p->ftn->pid == pid &&
p->ftn->tid == tid){
savelock = &(v->runq_lock);
found = 1;
tproc = p;
break;
}
}
if(found)
break;
ihk_mc_spinlock_unlock_noirq(&(v->runq_lock));
}
}
if(!tproc){
cpu_restore_interrupt(irqstate);
return -ESRCH;
}
if(sig == 0){
ihk_mc_spinlock_unlock_noirq(savelock);
cpu_restore_interrupt(irqstate);
return 0;
}
doint = 0;
if(tid == -1){
ihk_mc_spinlock_lock_noirq(&tproc->sigshared->lock);
head = &tproc->sigshared->sigpending;
}
else{
ihk_mc_spinlock_lock_noirq(&tproc->sigpendinglock);
head = &tproc->sigpending;
}
/* Put signal event even when handler is SIG_IGN or SIG_DFL
because target ptraced process must call ptrace_report_signal
in check_signal */
rc = 0;
k = tproc->sighandler->action + sig - 1;
if(k->sa.sa_handler != (void *)1 &&
(k->sa.sa_handler != NULL ||
(sig != SIGCHLD && sig != SIGURG))){
struct sig_pending *pending = NULL;
if (sig < 33) { // SIGRTMIN - SIGRTMAX
list_for_each_entry(pending, head, list){
if(pending->sigmask.__val[0] == mask)
break;
}
if(&pending->list == head)
pending = NULL;
}
if(pending == NULL){
doint = 1;
pending = kmalloc(sizeof(struct sig_pending), IHK_MC_AP_NOWAIT);
if(!pending){
rc = -ENOMEM;
}
else{
pending->sigmask.__val[0] = mask;
memcpy(&pending->info, info, sizeof(siginfo_t));
if(sig == SIGKILL || sig == SIGSTOP)
list_add(&pending->list, head);
else
list_add_tail(&pending->list, head);
tproc->sigevent = 1;
}
}
}
if(tid == -1){
ihk_mc_spinlock_unlock_noirq(&tproc->sigshared->lock);
}
else{
ihk_mc_spinlock_unlock_noirq(&tproc->sigpendinglock);
}
if (doint && !(mask & tproc->sigmask.__val[0])) {
int cpuid = tproc->cpu_id;
int pid = tproc->ftn->pid;
int status = tproc->ftn->status;
if (proc != tproc) {
dkprintf("do_kill,ipi,pid=%d,cpu_id=%d\n",
tproc->ftn->pid, tproc->cpu_id);
ihk_mc_interrupt_cpu(get_x86_cpu_local_variable(tproc->cpu_id)->apic_id, 0xd0);
}
ihk_mc_spinlock_unlock_noirq(savelock);
cpu_restore_interrupt(irqstate);
if(!tproc->nohost)
interrupt_syscall(pid, cpuid);
if (status != PS_RUNNING) {
switch(sig) {
case SIGKILL:
/* Wake up the target only when stopped by ptrace-reporting */
sched_wakeup_process(tproc, PS_TRACED | PS_STOPPED);
break;
case SIGCONT:
/* Wake up the target only when stopped by SIGSTOP */
sched_wakeup_process(tproc, PS_STOPPED);
break;
}
}
}
else {
ihk_mc_spinlock_unlock_noirq(savelock);
cpu_restore_interrupt(irqstate);
}
return rc;
}
void
set_signal(int sig, void *regs0, siginfo_t *info)
{
struct x86_regs *regs = regs0;
struct process *proc = cpu_local_var(current);
if(proc == NULL || proc->ftn->pid == 0)
return;
if((__sigmask(sig) & proc->sigmask.__val[0]) ||
(regs->rsp & 0x8000000000000000)){
coredump(proc, regs0);
terminate(0, sig | 0x80, (ihk_mc_user_context_t *)regs->rsp);
}
else
do_kill(proc->ftn->pid, proc->ftn->tid, sig, info);
}
Reference in New Issue View Git Blame Copy Permalink