Release 4.14 arch/um/os-Linux/signal.c

Directory: arch/um/os-Linux
/*
 * Copyright (C) 2015 Anton Ivanov (aivanov@{brocade.com,kot-begemot.co.uk})
 * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de)
 * Copyright (C) 2004 PathScale, Inc
 * Copyright (C) 2004 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 * Licensed under the GPL
 */

#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>
#include <signal.h>
#include <strings.h>
#include <as-layout.h>
#include <kern_util.h>
#include <os.h>
#include <sysdep/mcontext.h>
#include <um_malloc.h>


void (*sig_info[NSIG])(int, struct siginfo *, struct uml_pt_regs *) = {
	[SIGTRAP]	= relay_signal,
	[SIGFPE]	= relay_signal,
	[SIGILL]	= relay_signal,
	[SIGWINCH]	= winch,
	[SIGBUS]	= bus_handler,
	[SIGSEGV]	= segv_handler,
	[SIGIO]		= sigio_handler,
	[SIGALRM]	= timer_handler
};



static void sig_handler_common(int sig, struct siginfo *si, mcontext_t *mc)
{
	struct uml_pt_regs *r;
	int save_errno = errno;

	r = uml_kmalloc(sizeof(struct uml_pt_regs), UM_GFP_ATOMIC);
	if (!r)
		panic("out of memory");

	r->is_user = 0;
	if (sig == SIGSEGV) {
		/* For segfaults, we want the data from the sigcontext. */
		get_regs_from_mc(r, mc);
		GET_FAULTINFO_FROM_MC(r->faultinfo, mc);
	}

	/* enable signals if sig isn't IRQ signal */
	if ((sig != SIGIO) && (sig != SIGWINCH) && (sig != SIGALRM))
		unblock_signals();

	(*sig_info[sig])(sig, si, r);

	errno = save_errno;

	free(r);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Dike 85 65.38% 2 22.22%
Eli Cooper 28 21.54% 1 11.11%
Al Viro 6 4.62% 2 22.22%
Richard Weinberger 5 3.85% 2 22.22%
Martin Pärtel 5 3.85% 1 11.11%
Anton Ivanov 1 0.77% 1 11.11%
Total 130 100.00% 9 100.00%

/*
 * These are the asynchronous signals.  SIGPROF is excluded because we want to
 * be able to profile all of UML, not just the non-critical sections.  If
 * profiling is not thread-safe, then that is not my problem.  We can disable
 * profiling when SMP is enabled in that case.
 */

#define SIGIO_BIT 0

#define SIGIO_MASK (1 << SIGIO_BIT)


#define SIGALRM_BIT 1

#define SIGALRM_MASK (1 << SIGALRM_BIT)


static int signals_enabled;

static unsigned int signals_pending;

static unsigned int signals_active = 0;



void sig_handler(int sig, struct siginfo *si, mcontext_t *mc)
{
	int enabled;

	enabled = signals_enabled;
	if (!enabled && (sig == SIGIO)) {
		signals_pending |= SIGIO_MASK;
		return;
	}

	block_signals();

	sig_handler_common(sig, si, mc);

	set_signals(enabled);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Dike 49 83.05% 6 66.67%
Martin Pärtel 5 8.47% 1 11.11%
Al Viro 3 5.08% 1 11.11%
Richard Weinberger 2 3.39% 1 11.11%
Total 59 100.00% 9 100.00%



static void timer_real_alarm_handler(mcontext_t *mc)
{
	struct uml_pt_regs *regs;

	regs = uml_kmalloc(sizeof(struct uml_pt_regs), UM_GFP_ATOMIC);
	if (!regs)
		panic("out of memory");

	if (mc != NULL)
		get_regs_from_mc(regs, mc);
	timer_handler(SIGALRM, NULL, regs);

	free(regs);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Dike 27 41.54% 4 40.00%
Eli Cooper 26 40.00% 1 10.00%
Al Viro 5 7.69% 2 20.00%
Richard Weinberger 3 4.62% 1 10.00%
Anton Ivanov 2 3.08% 1 10.00%
Martin Pärtel 2 3.08% 1 10.00%
Total 65 100.00% 10 100.00%



void timer_alarm_handler(int sig, struct siginfo *unused_si, mcontext_t *mc)
{
	int enabled;

	enabled = signals_enabled;
	if (!signals_enabled) {
		signals_pending |= SIGALRM_MASK;
		return;
	}

	block_signals();

	signals_active |= SIGALRM_MASK;

	timer_real_alarm_handler(mc);

	signals_active &= ~SIGALRM_MASK;

	set_signals(enabled);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Dike 38 65.52% 3 42.86%
Anton Ivanov 12 20.69% 2 28.57%
Martin Pärtel 5 8.62% 1 14.29%
Al Viro 3 5.17% 1 14.29%
Total 58 100.00% 7 100.00%



void deliver_alarm(void) {
    timer_alarm_handler(SIGALRM, NULL, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
Anton Ivanov 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%



void timer_set_signal_handler(void)
{
	set_handler(SIGALRM);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Dike 10 83.33% 1 50.00%
Anton Ivanov 2 16.67% 1 50.00%
Total 12 100.00% 2 100.00%



void set_sigstack(void *sig_stack, int size)
{
	stack_t stack = {
		.ss_flags = 0,
		.ss_sp = sig_stack,
		.ss_size = size - sizeof(void *)
	};

	if (sigaltstack(&stack, NULL) != 0)
		panic("enabling signal stack failed, errno = %d\n", errno);
}

Contributors
Person Tokens Prop Commits CommitProp
Gennady Sharapov 57 100.00% 1 100.00%
Total 57 100.00% 1 100.00%


static void (*handlers[_NSIG])(int sig, struct siginfo *si, mcontext_t *mc) = {
	[SIGSEGV] = sig_handler,
	[SIGBUS] = sig_handler,
	[SIGILL] = sig_handler,
	[SIGFPE] = sig_handler,
	[SIGTRAP] = sig_handler,

	[SIGIO] = sig_handler,
	[SIGWINCH] = sig_handler,
	[SIGALRM] = timer_alarm_handler
};



static void hard_handler(int sig, siginfo_t *si, void *p)
{
	struct ucontext *uc = p;
	mcontext_t *mc = &uc->uc_mcontext;
	unsigned long pending = 1UL << sig;

	do {
		int nested, bail;

		/*
                 * pending comes back with one bit set for each
                 * interrupt that arrived while setting up the stack,
                 * plus a bit for this interrupt, plus the zero bit is
                 * set if this is a nested interrupt.
                 * If bail is true, then we interrupted another
                 * handler setting up the stack.  In this case, we
                 * have to return, and the upper handler will deal
                 * with this interrupt.
                 */
		bail = to_irq_stack(&pending);
		if (bail)
			return;

		nested = pending & 1;
		pending &= ~1;

		while ((sig = ffs(pending)) != 0){
			sig--;
			pending &= ~(1 << sig);
			(*handlers[sig])(sig, (struct siginfo *)si, mc);
		}

		/*
                 * Again, pending comes back with a mask of signals
                 * that arrived while tearing down the stack.  If this
                 * is non-zero, we just go back, set up the stack
                 * again, and handle the new interrupts.
                 */
		if (!nested)
			pending = from_irq_stack(nested);
	} while (pending);
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Dike 107 76.98% 3 42.86%
Al Viro 24 17.27% 2 28.57%
Richard Weinberger 5 3.60% 1 14.29%
Martin Pärtel 3 2.16% 1 14.29%
Total 139 100.00% 7 100.00%



void set_handler(int sig)
{
	struct sigaction action;
	int flags = SA_SIGINFO | SA_ONSTACK;
	sigset_t sig_mask;

	action.sa_sigaction = hard_handler;

	/* block irq ones */
	sigemptyset(&action.sa_mask);
	sigaddset(&action.sa_mask, SIGIO);
	sigaddset(&action.sa_mask, SIGWINCH);
	sigaddset(&action.sa_mask, SIGALRM);

	if (sig == SIGSEGV)
		flags |= SA_NODEFER;

	if (sigismember(&action.sa_mask, sig))
		flags |= SA_RESTART; /* if it's an irq signal */

	action.sa_flags = flags;
	action.sa_restorer = NULL;
	if (sigaction(sig, &action, NULL) < 0)
		panic("sigaction failed - errno = %d\n", errno);

	sigemptyset(&sig_mask);
	sigaddset(&sig_mask, sig);
	if (sigprocmask(SIG_UNBLOCK, &sig_mask, NULL) < 0)
		panic("sigprocmask failed - errno = %d\n", errno);
}

Contributors
Person Tokens Prop Commits CommitProp
Gennady Sharapov 67 41.36% 1 14.29%
Jeff Dike 56 34.57% 3 42.86%
Al Viro 36 22.22% 2 28.57%
Anton Ivanov 3 1.85% 1 14.29%
Total 162 100.00% 7 100.00%



int change_sig(int signal, int on)
{
	sigset_t sigset;

	sigemptyset(&sigset);
	sigaddset(&sigset, signal);
	if (sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, NULL) < 0)
		return -errno;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Gennady Sharapov 42 79.25% 1 33.33%
Américo Wang 9 16.98% 1 33.33%
Jeff Dike 2 3.77% 1 33.33%
Total 53 100.00% 3 100.00%



void block_signals(void)
{
	signals_enabled = 0;
	/*
         * This must return with signals disabled, so this barrier
         * ensures that writes are flushed out before the return.
         * This might matter if gcc figures out how to inline this and
         * decides to shuffle this code into the caller.
         */
	barrier();
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Dike 15 100.00% 4 100.00%
Total 15 100.00% 4 100.00%



void unblock_signals(void)
{
	int save_pending;

	if (signals_enabled == 1)
		return;

	/*
         * We loop because the IRQ handler returns with interrupts off.  So,
         * interrupts may have arrived and we need to re-enable them and
         * recheck signals_pending.
         */
	while (1) {
		/*
                 * Save and reset save_pending after enabling signals.  This
                 * way, signals_pending won't be changed while we're reading it.
                 */
		signals_enabled = 1;

		/*
                 * Setting signals_enabled and reading signals_pending must
                 * happen in this order.
                 */
		barrier();

		save_pending = signals_pending;
		if (save_pending == 0)
			return;

		signals_pending = 0;

		/*
                 * We have pending interrupts, so disable signals, as the
                 * handlers expect them off when they are called.  They will
                 * be enabled again above.
                 */

		signals_enabled = 0;

		/*
                 * Deal with SIGIO first because the alarm handler might
                 * schedule, leaving the pending SIGIO stranded until we come
                 * back here.
                 *
                 * SIGIO's handler doesn't use siginfo or mcontext,
                 * so they can be NULL.
                 */
		if (save_pending & SIGIO_MASK)
			sig_handler_common(SIGIO, NULL, NULL);

		/* Do not reenter the handler */

		if ((save_pending & SIGALRM_MASK) && (!(signals_active & SIGALRM_MASK)))
			timer_real_alarm_handler(NULL);

		/* Rerun the loop only if there is still pending SIGIO and not in TIMER handler */

		if (!(signals_pending & SIGIO_MASK) && (signals_active & SIGALRM_MASK))
			return;

	}
}

Contributors
Person Tokens Prop Commits CommitProp
Jeff Dike 55 50.46% 7 63.64%
Anton Ivanov 31 28.44% 2 18.18%
Gennady Sharapov 20 18.35% 1 9.09%
Martin Pärtel 3 2.75% 1 9.09%
Total 109 100.00% 11 100.00%



int get_signals(void)
{
	return signals_enabled;
}

Contributors
Person Tokens Prop Commits CommitProp
Gennady Sharapov 9 90.00% 1 50.00%
Jeff Dike 1 10.00% 1 50.00%
Total 10 100.00% 2 100.00%



int set_signals(int enable)
{
	int ret;
	if (signals_enabled == enable)
		return enable;

	ret = signals_enabled;
	if (enable)
		unblock_signals();
	else block_signals();

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Gennady Sharapov 28 73.68% 1 50.00%
Jeff Dike 10 26.32% 1 50.00%
Total 38 100.00% 2 100.00%



int os_is_signal_stack(void)
{
	stack_t ss;
	sigaltstack(NULL, &ss);

	return ss.ss_flags & SS_ONSTACK;
}
Contributors
Person Tokens Prop Commits CommitProp
Richard Weinberger 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
Jeff Dike 555 49.25% 17 50.00%
Gennady Sharapov 235 20.85% 1 2.94%
Al Viro 117 10.38% 6 17.65%
Anton Ivanov 81 7.19% 2 5.88%
Eli Cooper 54 4.79% 1 2.94%
Richard Weinberger 45 3.99% 3 8.82%
Martin Pärtel 28 2.48% 1 2.94%
Américo Wang 10 0.89% 2 5.88%
Sergei Trofimovich 2 0.18% 1 2.94%
Total 1127 100.00% 34 100.00%
Directory: arch/um/os-Linux

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Jeff Dike	85	65.38%	2	22.22%
Eli Cooper	28	21.54%	1	11.11%
Al Viro	6	4.62%	2	22.22%
Richard Weinberger	5	3.85%	2	22.22%
Martin Pärtel	5	3.85%	1	11.11%
Anton Ivanov	1	0.77%	1	11.11%
Total	130	100.00%	9	100.00%
cregit-Linux how code gets into the kernel

Release 4.14 arch/um/os-Linux/signal.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
