WebSVN - shark - Blame - Rev 2 - /shark/branches/pj/kernel/signal.c

Rev	Author	Line No.	Line
2	pj	1	/*
		2	* Project: S.Ha.R.K.
		3	*
		4	* Coordinators:
		5	* Giorgio Buttazzo <giorgio@sssup.it>
		6	* Paolo Gai <pj@gandalf.sssup.it>
		7	*
		8	* Authors :
		9	* Paolo Gai <pj@gandalf.sssup.it>
		10	* (see the web pages for full authors list)
		11	*
		12	* ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)
		13	*
		14	* http://www.sssup.it
		15	* http://retis.sssup.it
		16	* http://shark.sssup.it
		17	*/
		18
		19	/**
		20	------------
		21	CVS : $Id: signal.c,v 1.1.1.1 2002-03-29 14:12:52 pj Exp $
		22
		23	File: $File$
		24	Revision: $Revision: 1.1.1.1 $
		25	Last update: $Date: 2002-03-29 14:12:52 $
		26	------------
		27
		28	This file contains:
		29
		30	Signal Handling
		31
		32	- Data structures
		33	- sigset_t handling functions
		34
		35	**/
		36
		37	/*
		38	* Copyright (C) 2000 Paolo Gai
		39	*
		40	* This program is free software; you can redistribute it and/or modify
		41	* it under the terms of the GNU General Public License as published by
		42	* the Free Software Foundation; either version 2 of the License, or
		43	* (at your option) any later version.
		44	*
		45	* This program is distributed in the hope that it will be useful,
		46	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		47	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		48	* GNU General Public License for more details.
		49	*
		50	* You should have received a copy of the GNU General Public License
		51	* along with this program; if not, write to the Free Software
		52	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		53	*
		54	*/
		55
		56	/*
		57	* some functions are inspired on the implementation of OsKit..
		58	*
		59	* Copyright (c) 1997, 1998, 1999 University of Utah and the Flux Group.
		60	* All rights reserved.
		61	*
		62	* [...] The OSKit is free software, also known
		63	* as "open source;" you can redistribute it and/or modify it under the terms
		64	* of the GNU General Public License (GPL), version 2, as published by the Free
		65	* Software Foundation (FSF). To explore alternate licensing terms, contact
		66	* the University of Utah at csl-dist@cs.utah.edu or +1-801-585-3271.
		67	*
		68	* The OSKit is distributed in the hope that it will be useful, but WITHOUT ANY
		69	* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
		70	* FOR A PARTICULAR PURPOSE. See the GPL for more details. You should have
		71	* received a copy of the GPL along with the OSKit; see the file COPYING. If
		72	* not, write to the FSF, 59 Temple Place #330, Boston, MA 02111-1307, USA.
		73	*/
		74
		75
		76
		77	#include <ll/ll.h>
		78	#include <ll/stdlib.h>
		79	#include <ll/stdio.h>
		80	#include <ll/i386/pic.h>
		81	#include <signal.h>
		82	#include <errno.h>
		83	#include <kernel/descr.h>
		84	#include <kernel/var.h>
		85	#include <kernel/func.h>
		86	#include <kernel/trace.h>
		87
		88	/* look at nanoslp.c */
		89	int nanosleep_interrupted_by_signal(PID i);
		90
		91
		92	/---------------------------------------------------------------------/
		93	/* Data structures */
		94	/---------------------------------------------------------------------/
		95
		96	/+ A flag, see kern_raise +/
		97	static int active_exc = 0;
		98
		99	/+ The signal table... +/
		100	static struct sigaction sigactions[SIG_MAX];
		101
		102	/*+ There is a global (or "process") set of pending signals.
		103	kill() and sigqueue() affect the process pending set.
		104	+*/
		105	static sigset_t procsigpending;
		106
		107	/*
		108	* A queue of all threads waiting in sigwait.
		109	* It is not static because it is used into the task_kill...�
		110	*/
		111	static QUEUE sigwaiters;
		112
		113
		114	/+ An array of queues of pending signals posted with sigqueue(). +/
		115	static SIGQ sigqueued[SIG_MAX];
		116
		117	/*+ We avoid malloc in interrupt handlers by preallocating the queue
		118	entries for sig_queued above.
		119	it is used also in kernel/time.c +*/
		120	SIGQ sigqueue_free;
		121
		122	/+ this is the signal queue... +/
		123	sig_queue_entry sig_queue[SIGQUEUE_MAX];
		124
		125	/+ alarm stuffs +/
		126	static struct timespec alarm_time;
		127	static int alarm_timer;
		128
		129
		130	/* returns the first non-zero bit... */
		131	static int ffs(int value)
		132	{
		133	int x;
		134
		135	for (x=0; value; x++, value = value>>1)
		136	if (value & 1)
		137	return x;
		138	return 0;
		139	}
		140
		141	/---------------------------------------------------------------------/
		142	/* interruptable function registration... */
		143	/---------------------------------------------------------------------/
		144
		145
		146	/*+ this structure contains the functions to be called to test if a
		147	task is blocked on a cancellation point +*/
		148	static struct {
		149	int (test)(PID p, void arg);
		150	void *arg;
		151	} interruptable_table[MAX_SIGINTPOINTS];
		152
		153	static int interruptable_points = 0;
		154
		155
		156	/*+ This function register a cancellation point into the system.
		157	Be careful!!! no check are performed... +*/
		158	void register_interruptable_point(int (func)(PID p, void arg), void *arg)
		159	{
		160	interruptable_table[interruptable_points].test = func;
		161	interruptable_table[interruptable_points].arg = arg;
		162	interruptable_points++;
		163	}
		164
		165	static void test_interruptable_points(PID i)
		166	{
		167	int j;
		168
		169	/* check if the task is blocked on a cancellation point */
		170	for (j=0; j<interruptable_points; j++)
		171	if (interruptable_table[j].test(i,interruptable_table[j].arg))
		172	break;
		173	}
		174
		175
		176	/---------------------------------------------------------------------/
		177	/* sigset_t handling functions */
		178	/---------------------------------------------------------------------/
		179
		180	/* These functions will become soon macros... */
		181	int sigemptyset(sigset_t *set)
		182	{
		183	*set = 0;
		184
		185	return 0;
		186	}
		187
		188	int sigfillset(sigset_t *set)
		189	{
		190	*set=0xFFFFFFFFUL;
		191
		192	return 0;
		193	}
		194
		195	int sigaddset(sigset_t *set, int signo)
		196	{
		197	if (signo < 0 \|\| signo >= SIG_MAX)
		198	{
		199	errno = EINVAL;
		200	return -1;
		201	}
		202
		203	*set \|= 1 << signo;
		204	return 0;
		205	}
		206
		207
		208	int sigdelset(sigset_t *set, int signo)
		209	{
		210	if (signo < 0 \|\| signo >= SIG_MAX)
		211	{
		212	errno = EINVAL;
		213	return -1;
		214	}
		215
		216	*set &= ~(1 << signo);
		217	return 0;
		218	}
		219
		220	int sigismember(const sigset_t *set, int signo)
		221	{
		222	if (signo < 0 \|\| signo >= SIG_MAX)
		223	{
		224	errno = EINVAL;
		225	return -1;
		226	}
		227
		228	return *set & (1 << signo );
		229	}
		230
		231
		232	/---------------------------------------------------------------------/
		233	/* Finally, the public functions */
		234	/---------------------------------------------------------------------/
		235
		236	/*
		237	* Prototypes.
		238	*/
		239	void really_deliver_signal(int sig, siginfo_t *code);
		240	void kern_deliver_async_signal(int sig);
		241	void kern_deliver_process_signal(int sig);
		242
		243	int task_sigmask(int how, const sigset_t set, sigset_t oset)
		244	{
		245	proc_des task; / current executing task... */
		246	int err = 0;
		247
		248	kern_cli();
		249
		250	task = &proc_table[exec_shadow];
		251
		252	if (oset)
		253	*oset = task->sigmask;
		254
		255	if (set) {
		256	switch (how) {
		257	case SIG_BLOCK:
		258	task->sigmask \|= *set;
		259	break;
		260	case SIG_UNBLOCK:
		261	task->sigmask &= ~*set;
		262	break;
		263	case SIG_SETMASK:
		264	task->sigmask = *set;
		265	break;
		266	default:
		267	err = EINVAL;
		268	}
		269	}
		270
		271	/*
		272	* Look for process pending signals that are unblocked, and deliver.
		273	*/
		274	while (procsigpending & ~task->sigmask) {
		275	int sig = ffs(procsigpending & ~task->sigmask);
		276	kern_deliver_process_signal(sig);
		277	}
		278
		279	/*
		280	* Look for task pending signals that are unblocked, and deliver.
		281	*/
		282	while (task->sigpending & ~task->sigmask) {
		283	int sig = ffs(task->sigpending & ~task->sigmask);
		284	kern_deliver_async_signal(sig);
		285	}
		286
		287	kern_sti();
		288	return err;
		289	}
		290
		291	/*
		292	* This can be called out of an interrupt handler, say from an alarm
		293	* expiration.
		294	*/
		295	int
		296	task_signal(PID p, int signo)
		297	{
		298	// int enabled;
		299
		300	/* Error check? Sure! */
		301	if (!signo)
		302	return 0;
		303
		304	if (signo < 0 \|\| signo >= SIG_MAX)
		305	return EINVAL;
		306
		307	if (proc_table[p].status == FREE)
		308	return EINVAL;
		309
		310	kern_cli();
		311
		312	/*
		313	* Look at the process sigactions. If the "process" is ignoring
		314	* the signal, then the signal is not placed in the pending list.
		315	*/
		316	if (!(sigactions[signo].sa_flags & SA_SIGINFO) &&
		317	sigactions[signo].sa_handler == SIG_IGN) {
		318	kern_sti();
		319	return 0;
		320	}
		321
		322	/*
		323	* Add the signal to list of pending signals for the target task.
		324	*/
		325	sigaddset(&proc_table[p].sigpending, signo);
		326
		327	/* check for an interruptable function!!! */
		328	test_interruptable_points(p);
		329
		330	if (proc_table[p].status == WAIT_SIGSUSPEND) {
		331	LEVEL l;
		332
		333	/* Reactivate the task... */
		334	q_extract(p, &sigwaiters);
		335
		336	l = proc_table[p].task_level;
		337	level_table[l]->task_insert(l,p);
		338
		339	}
		340
		341
		342	/*
		343	* If not in an interrupt, use this opportunity to deliver
		344	* pending unblocked signals to the current thread.
		345	*/
		346	if (!ll_ActiveInt()) {
		347	kern_deliver_pending_signals();
		348	}
		349
		350	kern_sti();
		351	return 0;
		352	}
		353
		354	/*
		355	* sigaction
		356	*/
		357	int
		358	sigaction(int sig, const struct sigaction act, struct sigaction oact)
		359	{
		360	int sos; /* used to empty the sigqueue... */
		361	SYS_FLAGS f;
		362
		363
		364	if (sig < 0 \|\| sig >= SIG_MAX)
		365	return errno = EINVAL, -1;
		366
		367	f = kern_fsave();
		368
		369	if (oact)
		370	*oact = sigactions[sig];
		371	if (act)
		372	sigactions[sig] = *act;
		373
		374	/*
		375	* If the action for this signal is being set to SIG_IGN or SIG_DFL,
		376	* and that signal is process pending, then clear it.
		377	*/
		378	if (act && !(act->sa_flags & SA_SIGINFO) &&
		379	(act->sa_handler == SIG_IGN \|\| act->sa_handler == SIG_DFL)) {
		380	sos = sigqueued[sig];
		381	while (sos != -1) {
		382	/* Remove the first entry and put it to the free
		383	queue */
		384	sos = sig_queue[sigqueued[sig]].next;
		385
		386	if (sig_queue[sigqueued[sig]].flags & USED_FOR_TIMER)
		387	sig_queue[sigqueued[sig]].flags &= ~SIGNAL_POSTED;
		388	else {
		389	sig_queue[sigqueued[sig]].next = sigqueue_free;
		390	sigqueue_free = sigqueued[sig];
		391	}
		392	}
		393	sigqueued[sig] = -1;
		394	sigdelset(&procsigpending, sig);
		395	}
		396
		397	kern_frestore(f);
		398	return 0;
		399	}
		400
		401	/*
		402	* sigprocmask. this is just task_sigmask
		403	*/
		404	int
		405	sigprocmask(int how, const sigset_t set, sigset_t oset)
		406	{
		407	return task_sigmask(how, set, oset);
		408	}
		409
		410	/*
		411	* raise. this is just task_signal on itself.
		412	*/
		413	int
		414	raise(int sig)
		415	{
		416	return task_signal(exec_shadow, sig);
		417	}
		418
		419	/*
		420	* kill. What does it mean to kill() in a multithreaded program? The POSIX
		421	* spec says that a signal sent to a "process" shall be delivered to only
		422	* one task. If no task has that signal unblocked, then the first
		423	* task to unblock the signal is the lucky winner. Well, that means we
		424	* need to have a global procsigpending to record process pending signals.
		425	*/
		426	int
		427	kill(pid_t pid, int signo)
		428	{
		429	PID task;
		430	PID i;
		431	SYS_FLAGS f;
		432	struct sigaction act;
		433
		434	/* Error check? Sure! */
		435	if (!signo)
		436	return 0;
		437
		438	if (signo < 0 \|\| signo >= SIG_MAX)
		439	return EINVAL;
		440
		441
		442	f = kern_fsave();
		443
		444	act = sigactions[signo];
		445
		446	if (!(act.sa_flags & SA_SIGINFO) && act.sa_handler == SIG_IGN) {
		447	kern_frestore(f);
		448	return 0;
		449	}
		450
		451	/*
		452	* Kill does not queue. If the signal is already pending, this
		453	* one is tossed.
		454	*/
		455	if (sigismember(&procsigpending, signo)) {
		456	kern_frestore(f);
		457	return 0;
		458	}
		459
		460	/*
		461	* Make the signal process pending.
		462	*/
		463	sigaddset(&procsigpending, signo);
		464
		465	/*
		466	* Look through the threads in sigwait to see if any of them
		467	* is waiting for the signal. This is done as a separate pass
		468	* since the value of the pthread sigmask is ignored (threads
		469	* in sigwait will have blocked the signals being waited for).
		470	*/
		471
		472	for (task = sigwaiters;
		473	task != NIL;
		474	task = proc_table[task].next) {
		475	if (sigismember(&proc_table[task].sigwaiting, signo)) {
		476	LEVEL l;
		477
		478	if (proc_table[task].status == WAIT_SIGSUSPEND)
		479	sigaddset(&proc_table[task].sigpending, signo);
		480
		481	/* Reactivate the task... */
		482	q_extract(task, &sigwaiters);
		483	l = proc_table[task].task_level;
		484	level_table[l]->task_insert(l,task);
		485
		486	if (proc_table[task].delay_timer != -1) {
		487	event_delete(proc_table[task].delay_timer);
		488	proc_table[task].delay_timer = -1;
		489	}
		490
		491	kern_frestore(f);
		492	return 0;
		493	}
		494	}
		495
		496	/*
		497	* No threads in sigwait. Too bad. Must find another thread to
		498	* deliver it to.
		499	*/
		500	for (i = 1; i < MAX_PROC; i++) {
		501	if (proc_table[i].status != FREE) {
		502	if (! sigismember(&proc_table[i].sigmask, signo)) {
		503	/* Add the signal to list of pending
		504	signals for the target task. */
		505	sigaddset(&proc_table[i].sigpending, signo);
		506
		507	/* check for an interruptable function!!! */
		508	test_interruptable_points(i);
		509	break;
		510	}
		511	}
		512	}
		513
		514	/*
		515	* If not in an interrupt, use this opportunity to deliver
		516	* pending unblocked signals to the current thread.
		517	*/
		518	if (! ll_ActiveInt()) {
		519	kern_deliver_pending_signals();
		520	}
		521
		522	kern_frestore(f);
		523	return 0;
		524	}
		525
		526	/*
		527	* sigqueue internal: accept also the SI_XXX value
		528	*/
		529	int
		530	sigqueue_internal(pid_t pid, int signo, const union sigval value, int si_code)
		531	{
		532	PID task;
		533	SYS_FLAGS f;
		534	int i;
		535
		536	int thingie; /* an element of the signal queue */
		537	int sos; /* used when inserting thinghie in
		538	the signal queue */
		539	struct sigaction act;
		540
		541	/* Error check? Sure! */
		542	if (!signo)
		543	return 0;
		544
		545	if (signo < 0 \|\| signo >= SIG_MAX)
		546	return EINVAL;
		547
		548
		549	f = kern_fsave();
		550	/*
		551	* Look at the process sigactions. If the "process" is ignoring
		552	* the signal, then the signal is not placed in the pending list.
		553	*/
		554	act = sigactions[signo];
		555
		556	if (!(act.sa_flags & SA_SIGINFO) && act.sa_handler == SIG_IGN) {
		557	kern_frestore(f);
		558	return 0;
		559	}
		560
		561
		562	/*
		563	* If the flags does not include SA_SIGINFO, and there is already
		564	* a signal pending, this new one is dropped.
		565	*/
		566	if ((! (act.sa_flags & SA_SIGINFO)) &&
		567	sigismember(&procsigpending, signo)) {
		568	kern_frestore(f);
		569	return 0;
		570	}
		571
		572	/*
		573	* Gotta have space for the new signal.
		574	*/
		575	if (sigqueue_free == -1) {
		576	kern_frestore(f);
		577	return EAGAIN;
		578	}
		579
		580	/*
		581	* Create a queue entry.
		582	*/
		583	thingie = sigqueue_free;
		584	sigqueue_free = sig_queue[sigqueue_free].next;
		585
		586	sig_queue[thingie].info.si_signo = signo;
		587	sig_queue[thingie].info.si_code = si_code;
		588	sig_queue[thingie].info.si_value = value;
		589	sig_queue[thingie].info.si_task = exec_shadow;
		590	sig_queue[thingie].next = -1;
		591
		592	/*
		593	* Queue the signal on the process.
		594	*/
		595
		596	/* we insert the signal at the queue's tail */
		597	if (sigqueued[signo] == -1)
		598	sigqueued[signo] = thingie;
		599	else {
		600	sos = sigqueued[signo];
		601	while (sig_queue[sos].next != -1) sos = sig_queue[sos].next;
		602	sig_queue[sos].next = thingie;
		603	}
		604	sigaddset(&procsigpending, signo);
		605
		606	/*
		607	* Look through the threads in sigwait to see if any of them
		608	* is waiting for the signal. This is done as a separate pass
		609	* since the value of the pthread sigmask is ignored (threads
		610	* in sigwait will have blocked the signals being waited for).
		611	* If we find one, wakeup that thread. Note that POSIX says that
		612	* if multiple threads are sigwaiting for the same signal number,
		613	* exactly one thread is woken up. The problem is how to maintain
		614	* the FIFO order, and how to prevent lost signals in the case that
		615	* a thread calls sigwait before the woken thread runs and gets it.
		616	*/
		617	for (task = sigwaiters;
		618	task != NIL;
		619	task = proc_table[task].next) {
		620	if (sigismember(&proc_table[task].sigwaiting, signo)) {
		621	LEVEL l;
		622
		623	if (proc_table[task].status == WAIT_SIGSUSPEND)
		624	sigaddset(&proc_table[task].sigpending, signo);
		625
		626	/* Reactivate the task... */
		627	q_extract(task, &sigwaiters);
		628
		629	l = proc_table[task].task_level;
		630	level_table[l]->task_insert(l,task);
		631
		632	if (proc_table[task].delay_timer != -1) {
		633	event_delete(proc_table[task].delay_timer);
		634	proc_table[task].delay_timer = -1;
		635	}
		636
		637	kern_frestore(f);
		638	return 0;
		639
		640	}
		641	}
		642
		643	/*
		644	* Need to find a thread to deliver the signal to. Look for the
		645	* first thread that is not blocking the signal, and send it the
		646	* signal. It is my opinion that any program that is using sigwait,
		647	* and has not blocked signals in all of its threads, is bogus. The
		648	* same is true if the program is not using sigwait, and has the
		649	* signal unblocked in more than one thread.
		650	* Why? You might wake up a thread, but not have an actual queue
		651	* entry left by the time it runs again and looks, since another
		652	* thread could call sigwait and get that queue entry, or if there
		653	* are multiple threads that can take the signal, one thread could
		654	* get all the entries. This could result in an interrupted thread,
		655	* but with no signal to deliver. Well, not much to do about it.
		656	* Lets just queue the signal for the process, and let the chips
		657	* fall where they may.
		658	*/
		659	for (i = 1; i < MAX_PROC; i++) {
		660	if (proc_table[i].status != FREE) {
		661	if (! sigismember(&proc_table[i].sigmask, signo)) {
		662	/* Add the signal to list of pending
		663	signals for the target task. */
		664	sigaddset(&proc_table[i].sigpending, signo);
		665
		666	/* check for an interruptable function!!! */
		667	test_interruptable_points(i);
		668
		669	break;
		670	}
		671	}
		672	}
		673
		674	/*
		675	* If not in an interrupt, use this opportunity to deliver
		676	* pending unblocked signals to the current thread.
		677	* (NB: a discussion on the flag active_exc is near the function
		678	* kern_raise() )
		679	*/
		680	if (! ll_ActiveInt() && active_exc == 0) {
		681	kern_deliver_pending_signals();
		682	}
		683
		684	kern_frestore(f);
		685	return 0;
		686	}
		687
		688	static void sigwait_timer(void *arg)
		689	{
		690	PID p = (PID)arg;
		691	LEVEL l;
		692
		693	/* reset the event timer */
		694	proc_table[p].delay_timer = -1;
		695
		696	/* set the timeout flag */
		697	proc_table[p].control \|= SIGTIMEOUT_EXPIRED;
		698
		699	/* insert the task into the ready queue and extract it from the waiters */
		700	q_extract(p, &sigwaiters);
		701
		702	l = proc_table[p].task_level;
		703	level_table[l]->task_insert(l,p);
		704
		705	event_need_reschedule();
		706	}
		707
		708	/*
		709	* Sigwait. Sigwait overrides the state of the pthread sigmask and the global
		710	* sigactions. The caller must block the set of signals in "set", before
		711	* calling sigwait, otherwise the behaviour is undefined (which means that
		712	* the caller will take an async signal anyway, and sigwait will return EINTR.
		713	*/
		714	int
		715	kern_sigwait_internal(const sigset_t *set,
		716	siginfo_t info, const struct timespec timeout)
		717	{
		718	proc_des *pthread = &proc_table[exec_shadow];
		719	int thissig;
		720
		721	struct timespec ty;
		722	TIME tx;
		723	LEVEL l;
		724
		725	task_testcancel();
		726
		727	/* siglock and pthread siglock are taken from an interrupt handler */
		728	kern_cli();
		729
		730	/*
		731	* First check for process pending signals. Must take and hold
		732	* the global siglock to prevent races with kill() and sigqueue().
		733	*/
		734	if (procsigpending & *set) {
		735	int sos;
		736
		737	thissig = ffs(procsigpending & *set);
		738
		739	/*
		740	* Sent with kill(). Using sigwait and kill is Bogus!
		741	*/
		742	if (sigqueued[thissig] == -1) {
		743	info->si_signo = thissig;
		744	info->si_code = SI_USER;
		745	info->si_value.sival_int = 0;
		746
		747	sigdelset(&pthread->sigpending, thissig);
		748	sigdelset(&procsigpending, thissig);
		749	kern_sti();
		750	return 0;
		751	}
		752
		753	/*
		754	* Grab the first queue entry.
		755	*/
		756	sos = sigqueued[thissig];
		757	sigqueued[thissig] = sig_queue[sigqueued[thissig]].next;
		758
		759	/*
		760	* If that was the last one, reset the process procsigpending.
		761	*/
		762	if (sigqueued[thissig] == -1)
		763	sigdelset(&procsigpending, thissig);
		764	sigdelset(&pthread->sigpending, thissig);
		765
		766	/*
		767	* Copy the information and free the queue entry.
		768	*/
		769	info->si_signo = sig_queue[sos].info.si_signo;
		770	info->si_code = sig_queue[sos].info.si_code;
		771	info->si_value.sival_int = sig_queue[sos].info.si_value.sival_int;
		772
		773	if (sig_queue[sos].flags & USED_FOR_TIMER)
		774	sig_queue[sos].flags &= ~SIGNAL_POSTED;
		775	else {
		776	sig_queue[sos].next = sigqueue_free;
		777	sigqueue_free = sos;
		778	}
		779	kern_sti();
		780	return 0;
		781	}
		782
		783	/*
		784	* Now check for pthread pending signals.
		785	*/
		786	if (pthread->sigpending & *set) {
		787	thissig = ffs(pthread->sigpending & *set);
		788	info->si_signo = thissig;
		789	info->si_code = SI_USER;
		790	info->si_value.sival_int = 0;
		791	sigdelset(&pthread->sigpending, thissig);
		792	kern_sti();
		793	return 0;
		794	}
		795
		796	/*
		797	* For timed wait, if nothing is available and the timeout value
		798	* is zero, its an error.
		799	*/
		800	if (timeout && timeout->tv_sec == 0 && timeout->tv_nsec == 0) {
		801	kern_sti();
		802	return EAGAIN;
		803	}
		804
		805	/*
		806	* Grab the wait lock and set the sigwaiting mask. Once that is done,
		807	* release the thread siglock; Another thread can try and wake this
		808	* thread up as a result of seeing it in sigwait, but the actual
		809	* wakeup will be delayed until the waitlock is released in the switch
		810	* code.
		811	*/
		812	pthread->sigwaiting = *set;
		813
		814	/* now, we really block the task... */
		815	proc_table[exec_shadow].context = kern_context_save();
		816
		817	/* SAME AS SCHEDULER... manage the capacity event and the load_info */
		818	ll_gettime(TIME_EXACT, &schedule_time);
		819	SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
		820	tx = TIMESPEC2USEC(&ty);
		821	proc_table[exec_shadow].avail_time -= tx;
		822	jet_update_slice(tx);
		823	if (cap_timer != NIL) {
		824	event_delete(cap_timer);
		825	cap_timer = NIL;
		826	}
		827	l = proc_table[exec_shadow].task_level;
		828	level_table[l]->task_extract(l,exec_shadow);
		829
		830	/*
		831	* Add this thread to the list of threads in sigwait. Once that is
		832	* done, it is safe to release the global siglock, which will allow
		833	* another thread to scan the sigwaiters list. As above, it might
		834	* find a thread in sigwait, but it will not be able to wake it up
		835	* until the waitlock is released in the switch code.
		836	*/
		837	q_insertfirst(exec_shadow, &sigwaiters);
		838	proc_table[exec_shadow].status = WAIT_SIG;
		839
		840	if (timeout) {
		841	/* we can use the delaytimer because if we are here we are not in a
		842	task_delay */
		843	struct timespec t, abstime;
		844	ll_gettime(TIME_EXACT, &t);
		845	ADDTIMESPEC(&t, timeout, &abstime);
		846
		847	proc_table[exec_shadow].delay_timer =
		848	kern_event_post(&abstime,sigwait_timer,(void *)exec_shadow);
		849	}
		850
		851	/* and finally we reschedule */
		852	exec = exec_shadow = -1;
		853	scheduler();
		854	ll_context_to(proc_table[exec_shadow].context);
		855
		856	task_testcancel();
		857
		858	pthread->sigwaiting = 0;
		859
		860	/*
		861	* Look for timeout.
		862	*/
		863	if (proc_table[exec_shadow].control & SIGTIMEOUT_EXPIRED) {
		864	kern_sti();
		865	return EAGAIN;
		866	}
		867
		868	/*
		869	* Look for a wakeup to deliver a queued signal. This would come
		870	* either from kill() or from sigqueue().
		871	*/
		872	if (procsigpending & *set) {
		873	int sos;
		874
		875	thissig = ffs(procsigpending & *set);
		876
		877	/*
		878	* Sent with kill(). Using sigwait and kill is Bogus!
		879	*/
		880	if (sigqueued[thissig] == -1) {
		881	info->si_signo = thissig;
		882	info->si_code = SI_USER;
		883	info->si_value.sival_int = 0;
		884
		885	sigdelset(&procsigpending, thissig);
		886	kern_sti();
		887	return 0;
		888	}
		889
		890	/*
		891	* Grab the first queue entry.
		892	*/
		893	sos = q_getfirst(&sigqueued[thissig]);
		894
		895	/*
		896	* If that was the last one, reset the process procsigpending.
		897	*/
		898	if (sigqueued[thissig] == -1)
		899	sigdelset(&procsigpending, thissig);
		900
		901	/*
		902	* Copy the information and free the queue entry.
		903	*/
		904	info->si_signo = sig_queue[sos].info.si_signo;
		905	info->si_code = sig_queue[sos].info.si_code;
		906	info->si_value.sival_int = sig_queue[sos].info.si_value.sival_int;
		907
		908	if (sig_queue[sos].flags & USED_FOR_TIMER)
		909	sig_queue[sos].flags &= ~SIGNAL_POSTED;
		910	else {
		911	sig_queue[sos].next = sigqueue_free;
		912	sigqueue_free = sos;
		913	}
		914
		915	kern_sti();
		916	return 0;
		917	}
		918
		919	/*
		920	* Well, at the moment I am going to assume that if this thread
		921	* wakes up, and there is no signal pending in the waitset, the
		922	* thread wait was interrupted for some other reason. Return EINTR.
		923	*/
		924	if (! (pthread->sigpending & *set)) {
		925	kern_sti();
		926	return EINTR;
		927	}
		928
		929	/*
		930	* Otherwise, get the first signal and return it.
		931	*/
		932	thissig = ffs(pthread->sigpending & *set);
		933	info->si_signo = thissig;
		934	info->si_code = SI_USER;
		935	info->si_value.sival_int = 0;
		936	sigdelset(&pthread->sigpending, thissig);
		937	kern_sti();
		938	return 0;
		939	}
		940
		941	/*
		942	* Sigwait.
		943	*/
		944	int
		945	sigwait(const sigset_t set, int sig)
		946	{
		947	siginfo_t info;
		948	int rc;
		949
		950	memset(&info, 0, sizeof(info));
		951
		952	rc = kern_sigwait_internal(set, &info, 0);
		953
		954	if (rc)
		955	return rc;
		956
		957	*sig = info.si_signo;
		958	return 0;
		959	}
		960
		961	/*
		962	* Sigwaitinfo.
		963	*/
		964	int
		965	sigwaitinfo(const sigset_t set, siginfo_t info)
		966	{
		967	return kern_sigwait_internal(set, info, 0);
		968	}
		969
		970	/*
		971	* Sigtimedwait.
		972	*/
		973	int
		974	sigtimedwait(const sigset_t *set,
		975	siginfo_t info, const struct timespec timeout)
		976	{
		977	if (! timeout)
		978	return EINVAL;
		979
		980	return kern_sigwait_internal(set, info, timeout);
		981	}
		982
		983	/*
		984	* Signal
		985	*/
		986	void (signal(int signum, void (handler)(int)))(int)
		987	{
		988	struct sigaction act, oact;
		989	int olderrno;
		990	void (*retvalue)(int);
		991
		992	act.sa_handler = handler;
		993	sigemptyset(&act.sa_mask);
		994	act.sa_flags = 0;
		995
		996	olderrno = errno;
		997	if (sigaction(signum, &act, &oact))
		998	retvalue = SIG_ERR;
		999	else
		1000	if (oact.sa_flags & SA_SIGINFO)
		1001	retvalue = SIG_ERR;
		1002	else
		1003	retvalue = oact.sa_handler;
		1004
		1005	errno = olderrno;
		1006
		1007	return retvalue;
		1008
		1009	}
		1010
		1011
		1012	/*
		1013	* sigpending
		1014	*/
		1015	int sigpending(sigset_t *set)
		1016	{
		1017	*set = procsigpending \| proc_table[exec_shadow].sigpending;
		1018	return 0;
		1019	}
		1020
		1021
		1022	/*
		1023	* sigsuspend
		1024	*/
		1025	int sigsuspend(const sigset_t *set)
		1026	{
		1027	proc_des *pthread = &proc_table[exec_shadow];
		1028
		1029	struct timespec ty;
		1030	TIME tx;
		1031	LEVEL l;
		1032
		1033	task_testcancel();
		1034
		1035	kern_cli();
		1036
		1037	/*
		1038	* Now check for pthread pending signals.
		1039	*/
		1040	if (pthread->sigpending & *set) {
		1041	kern_deliver_pending_signals();
		1042	kern_sti();
		1043	return 0;
		1044	}
		1045
		1046	/*
		1047	* Grab the wait lock and set the sigwaiting mask. Once that is done,
		1048	* release the thread siglock; Another thread can try and wake this
		1049	* thread up as a result of seeing it in sigwait, but the actual
		1050	* wakeup will be delayed until the waitlock is released in the switch
		1051	* code.
		1052	*/
		1053	pthread->sigwaiting = *set;
		1054
		1055	/* now, we really block the task... */
		1056	proc_table[exec_shadow].context = kern_context_save();
		1057
		1058	/* SAME AS SCHEDULER... manage the capacity event and the load_info */
		1059	ll_gettime(TIME_EXACT, &schedule_time);
		1060	SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);
		1061	tx = TIMESPEC2USEC(&ty);
		1062	proc_table[exec_shadow].avail_time -= tx;
		1063	jet_update_slice(tx);
		1064	if (cap_timer != NIL) {
		1065	event_delete(cap_timer);
		1066	cap_timer = NIL;
		1067	}
		1068	l = proc_table[exec_shadow].task_level;
		1069	level_table[l]->task_extract(l,exec_shadow);
		1070
		1071	q_insertfirst(exec_shadow, &sigwaiters);
		1072	proc_table[exec_shadow].status = WAIT_SIGSUSPEND;
		1073
		1074	/* and finally we reschedule */
		1075	exec = exec_shadow = -1;
		1076	scheduler();
		1077	ll_context_to(proc_table[exec_shadow].context);
		1078
		1079	task_testcancel();
		1080
		1081	/*
		1082	* Well, at the moment I am going to assume that if this thread
		1083	* wakes up, and there is no signal pending in the waitset, the
		1084	* thread wait was interrupted for some other reason. Return EINTR.
		1085	*/
		1086	if (! (pthread->sigpending & *set)) {
		1087	kern_sti();
		1088	return EINTR;
		1089	}
		1090
		1091	/*
		1092	* Otherwise, deliver the signals.
		1093	*/
		1094	kern_deliver_pending_signals();
		1095	kern_sti();
		1096	return 0;
		1097	}
		1098
		1099
		1100	void timer_alarmfire(void *arg)
		1101	{
		1102	alarm_timer = -1;
		1103
		1104	kill(0, SIGALRM);
		1105
		1106	event_need_reschedule();
		1107	}
		1108
		1109	/*
		1110	* alarm
		1111	*/
		1112	unsigned int alarm(unsigned int seconds)
		1113	{
		1114	struct timespec returnvalue, temp;
		1115
		1116	kern_cli();
		1117
		1118	ll_gettime(TIME_EXACT, &temp);
		1119
		1120	if (alarm_timer == -1)
		1121	returnvalue.tv_sec = 0;
		1122	else {
		1123	SUBTIMESPEC(&alarm_time, &temp, &returnvalue);
		1124
		1125	event_delete(alarm_timer);
		1126	}
		1127
		1128	if (seconds) {
		1129	temp.tv_sec += seconds;
		1130	TIMESPEC_ASSIGN(&alarm_time, &temp);
		1131	alarm_timer = kern_event_post(&temp, timer_alarmfire, NULL);
		1132	}
		1133	else
		1134	alarm_timer = -1;
		1135
		1136	kern_sti();
		1137
		1138	return returnvalue.tv_sec;
		1139	}
		1140
		1141	int pause(void)
		1142	{
		1143	sigset_t set;
		1144
		1145	sigfillset(&set);
		1146	return sigsuspend(&set);
		1147	}
		1148
		1149	/*
		1150	* Internal stuff.
		1151	*/
		1152
		1153	/*
		1154	* Deliver an asynchronous signal. This must be called with interrupts
		1155	* blocked and the pthread siglock held.
		1156	*/
		1157	void
		1158	kern_deliver_async_signal(int sig)
		1159	{
		1160	siginfo_t siginfo;
		1161
		1162	siginfo.si_signo = sig;
		1163	siginfo.si_code = SI_USER;
		1164	siginfo.si_value.sival_int = 0;
		1165	siginfo.si_task = exec_shadow;
		1166
		1167	really_deliver_signal(sig, &siginfo);
		1168	}
		1169
		1170	/*
		1171	* Deliver a process signals. This must be called with interrupts
		1172	* blocked and the siglock and pthread siglock held.
		1173	*/
		1174	void
		1175	kern_deliver_process_signal(int sig)
		1176	{
		1177	siginfo_t siginfo;
		1178	int thingie;
		1179
		1180	/*
		1181	* Sent with kill(). Using sigwait and kill is Bogus!
		1182	*/
		1183	if (sigqueued[sig] == -1) {
		1184	siginfo.si_signo = sig;
		1185	siginfo.si_code = SI_USER;
		1186	siginfo.si_value.sival_int = 0;
		1187	siginfo.si_task = exec_shadow;
		1188
		1189	sigdelset(&procsigpending, sig);
		1190	goto deliver;
		1191	}
		1192
		1193	/*
		1194	* Grab the first queue entry.
		1195	*/
		1196	thingie = sigqueued[sig];
		1197	sigqueued[sig] = sig_queue[sigqueued[sig]].next;
		1198
		1199	/*
		1200	* If that was the last one, reset the process sigpending.
		1201	*/
		1202	if (sigqueued[sig] == -1)
		1203	sigdelset(&procsigpending, sig);
		1204
		1205	/*
		1206	* Copy the information and free the queue entry.
		1207	*/
		1208	siginfo.si_signo = sig_queue[thingie].info.si_signo;
		1209	siginfo.si_code = sig_queue[thingie].info.si_code;
		1210	siginfo.si_value.sival_int = sig_queue[thingie].info.si_value.sival_int;
		1211	siginfo.si_task = sig_queue[thingie].info.si_task;
		1212
		1213	if (sig_queue[thingie].flags & USED_FOR_TIMER)
		1214	sig_queue[thingie].flags &= ~SIGNAL_POSTED;
		1215	else {
		1216	sig_queue[thingie].next = sigqueue_free;
		1217	sigqueue_free = thingie;
		1218	}
		1219
		1220	deliver:
		1221	really_deliver_signal(sig, &siginfo);
		1222
		1223	}
		1224
		1225	/*
		1226	* Deliver any pending signals. Called out of the context switch code
		1227	* when a task switches in, and there are pending signals.
		1228	*
		1229	* Interrupts are blocked...
		1230	*/
		1231	void
		1232	kern_deliver_pending_signals(void)
		1233	{
		1234	proc_des task; / current executing task... */
		1235
		1236	task = &proc_table[exec_shadow];
		1237
		1238	/* we have to check if the task was descheduled while serving
		1239	signals... if so, it is useless the call to this function...
		1240	because the task is already in it!!! (NB: the task can be
		1241	descheduled because the signal handlers are executed with
		1242	interrupts enabled...) */
		1243	if (task->control & TASK_DOING_SIGNALS)
		1244	return;
		1245
		1246	task->control \|= TASK_DOING_SIGNALS;
		1247
		1248	/*
		1249	* Look for process pending signals that are unblocked, and deliver.
		1250	*/
		1251	while (procsigpending & ~task->sigmask) {
		1252	/* NB: the while test should be indipendent from any local
		1253	variable... because when we process signals there can be
		1254	some context_change before we return from the
		1255	kern_deliver-signals...
		1256	*/
		1257	int sig = ffs(procsigpending & ~task->sigmask);
		1258
		1259	/* Call with siglock and thread siglock locked */
		1260	kern_deliver_process_signal(sig);
		1261	}
		1262
		1263	/*
		1264	* Now deliver any pthread pending signals that are left.
		1265	* NB: the pthread pending signals are NOT sent via sigqueue!!!
		1266	*/
		1267	while (task->sigpending & ~task->sigmask) {
		1268	int sig = ffs(task->sigpending & ~task->sigmask);
		1269
		1270	/* Call at splhigh and thread locked */
		1271	kern_deliver_async_signal(sig);
		1272	}
		1273	task->control &= ~TASK_DOING_SIGNALS;
		1274	}
		1275
		1276	/*
		1277	* Actually deliver the signal to the task. At this point the signal
		1278	* is going to be delivered, so it no longer matters if it is blocked.
		1279	*/
		1280	void
		1281	really_deliver_signal(int sig, siginfo_t *info)
		1282	{
		1283	proc_des task; / current executing task... */
		1284
		1285	sigset_t sigmask, oldmask;
		1286	struct sigaction act;
		1287	SYS_FLAGS f;
		1288
		1289	f = kern_fsave();
		1290
		1291	task = &proc_table[exec_shadow];
		1292
		1293	act = sigactions[sig];
		1294
		1295	//kern_printf("Ci sono!!!flags=%d hand=%d sigaction=%d mask=%d",act.sa_flags,
		1296	// (int)act.sa_handler, (int)act.sa_sigaction, (int)act.sa_mask);
		1297
		1298	/*
		1299	* Ignored?
		1300	*/
		1301	if (!(act.sa_flags & SA_SIGINFO) && (act.sa_handler == SIG_IGN \|\|
		1302	act.sa_handler == SIG_ERR) )
		1303	return;
		1304
		1305	if (!(act.sa_flags & SA_SIGINFO) && act.sa_handler == SIG_DFL) {
		1306	/* Default action for all signals is termination */
		1307	kern_printf("\nSignal number %d...\n",sig);
		1308	if (act.sa_flags & SA_SIGINFO)
		1309	kern_printf("with value : %d\n",info->si_value.sival_int);
		1310	sys_abort(ASIG_DEFAULT_ACTION);
		1311	}
		1312
		1313	/*
		1314	* Set the signal mask for calling the handler.
		1315	*/
		1316	oldmask = sigmask = task->sigmask;
		1317	sigaddset(&sigmask, sig);
		1318	sigmask \|= act.sa_mask;
		1319	sigdelset(&task->sigpending, sig);
		1320	task->sigmask = sigmask;
		1321	kern_sti();
		1322
		1323	/*
		1324	* and call the handler ...
		1325	*/
		1326	if (act.sa_flags & SA_SIGINFO)
		1327	act.sa_sigaction(sig, info, NULL);
		1328	else
		1329	((void ()(int, int, void ))act.sa_handler)
		1330	(sig, info->si_value.sival_int, NULL);
		1331
		1332	/* NB: when we pass the kern_cli(), there can be the case that
		1333	an irq (and/or a timer...) fired... and do a context change.
		1334	so, we return here after an indefinite time... */
		1335	kern_cli();
		1336	task->sigmask = oldmask;
		1337
		1338	kern_frestore(f);
		1339	}
		1340
		1341
		1342	/---------------------------------------------------------------------/
		1343	/* S.HA.R.K. exceptions handling */
		1344	/---------------------------------------------------------------------/
		1345
		1346	void kern_raise(int n, PID p)
		1347	{
		1348	union sigval v;
		1349	PID sos; /* temp. PID */
		1350
		1351	v.sival_int = n;
		1352	// kern_printf("RAISE");
		1353
		1354	/* sigqueue set the p field to exec_shadow... so whe change it for a
		1355	little... because sigqueue fill descriptor with exec_shadow... */
		1356	kern_cli();
		1357	sos = exec_shadow;
		1358	exec_shadow = p;
		1359
		1360	active_exc = 1; // see (*)
		1361	sigqueue(0, SIGHEXC, v);
		1362	active_exc = 0;
		1363
		1364	exec_shadow = sos;
		1365	kern_sti();
		1366
		1367	/* (*)
		1368	when we are in an exception, we don't have to call the
		1369	really_deliver signal.
		1370	For example, when the capacity of a task is exausted, an event is
		1371	called. this event simply call scheduler, that call the task_epilogue.
		1372
		1373	the task_epilogue checks the capacity and raise an exception, BUT
		1374	we don't have to deliver this exception immediately.
		1375
		1376	Why? because the task pointed by exec_shadow was extracted from the
		1377	ready queue (as sigqueue do normally...) and the exception does not have
		1378	to be delivered to that task. It must be delivered
		1379	only after we exit from the kern_raise (because the signal handler
		1380	in SIGHEXC may be long and another timer interrupt can fire...), to
		1381	another task...
		1382	*/
		1383
		1384	}
		1385
		1386
		1387	/---------------------------------------------------------------------/
		1388	/* S.Ha.R.K. interrupts handling */
		1389	/---------------------------------------------------------------------/
		1390
		1391	/----------------------------------------------------------------------/
		1392	/* Interrupt table management. The following function install the fast */
		1393	/* handler and the sporadic task linked to the interrupt no. */
		1394	/* If the fast parameter is NULL, no handler is called. */
		1395	/* If the pi parameter is NIL no task is installed */
		1396	/----------------------------------------------------------------------/
		1397
		1398	/* Interrupt handling table */
		1399	static struct int_des {
		1400	void (*fast)(int n);
		1401	PID proc_index;
		1402	BYTE isUsed;
		1403	} int_table[16];
		1404
		1405	/* Warning the interrupt can cause a preemption! */
		1406	/* The fast handler is a standard piece of code which runs with */
		1407	/* interrupts enabled to allow interrupt nesting */
		1408
		1409	void irq_fasthandler(void *n)
		1410	{
		1411	int no = (int )n;
		1412	PID p;
		1413
		1414	/* tracer stuff */
		1415	trc_logevent(TRC_INTR,&no);
		1416
		1417	if (int_table[no].fast != NULL) {
		1418	kern_sti();
		1419	(int_table[no].fast)(no);
		1420	kern_cli();
		1421	}
		1422
		1423	/* If a sporadic process is linked,activate it */
		1424	p = int_table[no].proc_index;
		1425	task_activate(p); // no problem if p == nil
		1426	}
		1427
		1428	/----------------------------------------------------------------------/
		1429	/* Interrupt table management. The following function install the fast */
		1430	/* handler and the sporadic task linked to the interrupt no. */
		1431	/* If the fast parameter is NULL, no handler is called. */
		1432	/* If the pi parameter is NIL no task is installed */
		1433	/----------------------------------------------------------------------/
		1434	int handler_set(int no, void (*fast)(int n), PID pi)
		1435	{
		1436	SYS_FLAGS f;
		1437
		1438	if ((no < 1) \|\| (no > 15)) {
		1439	errno = EWRONG_INT_NO;
		1440	return -1;
		1441	}
		1442
		1443	f = kern_fsave();
		1444	//kern_printf("handler_set: no %d pid %d\n",no, pi);
		1445	if (int_table[no].isUsed == TRUE) {
		1446	kern_frestore(f);
		1447	errno = EUSED_INT_NO;
		1448	return -1;
		1449	}
		1450	int_table[no].fast = fast;
		1451	int_table[no].proc_index = pi;
		1452	int_table[no].isUsed = TRUE;
		1453
		1454	irq_bind(no, irq_fasthandler, INT_FORCE);
		1455	irq_unmask(no);
		1456	kern_frestore(f);
		1457
		1458	return 1;
		1459	}
		1460
		1461	int handler_remove(int no)
		1462	{
		1463	SYS_FLAGS f;
		1464	return 0;
		1465
		1466	if (no < 1 \|\| no > 15) {
		1467	errno = EWRONG_INT_NO;
		1468	return -1;
		1469	}
		1470
		1471	f = kern_fsave();
		1472	if (int_table[no].isUsed == FALSE) {
		1473	kern_frestore(f);
		1474	errno = EUNUSED_INT_NO;
		1475	return -1;
		1476	}
		1477
		1478	int_table[no].fast = NULL;
		1479	int_table[no].proc_index = NIL;
		1480	int_table[no].isUsed = FALSE;
		1481
		1482	irq_bind(no,NULL, INT_PREEMPTABLE);
		1483	irq_mask(no);
		1484	kern_frestore(f);
		1485
		1486	return 1;
		1487
		1488	}
		1489
		1490	/* this is the test that is done when a task is being killed
		1491	and it is waiting on a sigwait */
		1492	static int signal_cancellation_point(PID i, void *arg)
		1493	{
		1494	LEVEL l;
		1495
		1496	if (proc_table[i].status == WAIT_SIG) {
		1497
		1498	if (proc_table[i].delay_timer != -1) {
		1499	event_delete(proc_table[i].delay_timer);
		1500	proc_table[i].delay_timer = -1;
		1501	}
		1502
		1503	q_extract(i, &sigwaiters);
		1504
		1505	l = proc_table[i].task_level;
		1506	level_table[l]->task_insert(l,i);
		1507
		1508	return 1;
		1509	}
		1510	else if (proc_table[i].status == WAIT_SIGSUSPEND) {
		1511
		1512	l = proc_table[i].task_level;
		1513	level_table[l]->task_insert(l,i);
		1514
		1515	return 1;
		1516	}
		1517
		1518
		1519	return 0;
		1520	}
		1521
		1522	void signals_init()
		1523	{
		1524	int i;
		1525
		1526	/* Initialize the default signal actions and the signal
		1527	queue headers. */
		1528	for (i = 0; i < SIG_MAX; i++) {
		1529	sigactions[i].sa_handler = SIG_DFL;
		1530	sigactions[i].sa_flags = 0;
		1531	sigactions[i].sa_mask = 0;
		1532	sigactions[i].sa_sigaction = 0;
		1533	sigqueued[i] = -1;
		1534	}
		1535
		1536	/* Initialize the signal queue */
		1537	for (i=0; i < SIGQUEUE_MAX-1; i++) {
		1538	sig_queue[i].next = i+1;
		1539	sig_queue[i].flags = 0;
		1540	}
		1541	sig_queue[SIGQUEUE_MAX-1].next = NIL;
		1542	sig_queue[SIGQUEUE_MAX-1].flags = 0;
		1543	sigqueue_free = 0;
		1544
		1545	procsigpending = 0;
		1546
		1547	sigwaiters = NIL;
		1548	alarm_timer = -1;
		1549
		1550	/* Interrupt handling init */
		1551	for (i=0; i<16; i++) {
		1552	int_table[i].fast = NULL;
		1553	int_table[i].proc_index = NIL;
		1554	int_table[i].isUsed = FALSE;
		1555	}
		1556
		1557	register_cancellation_point(signal_cancellation_point, NULL);
		1558	}
		1559
		1560

Subversion Repositories shark

(root)/shark/branches/pj/kernel/signal.c - Rev 2