haiku.git

/*
 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2003-2008, Axel Dörfler, axeld@pinc-software.de.
 * All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef _KERNEL_SIGNAL_H
#define _KERNEL_SIGNAL_H


#include <signal.h>

#include <KernelExport.h>

#include <signal_defs.h>

#include <heap.h>
#include <util/DoublyLinkedList.h>
#include <util/KernelReferenceable.h>


namespace BKernel {
	struct ProcessGroup;
	struct Team;
	struct Thread;
}

using BKernel::ProcessGroup;
using BKernel::Team;
using BKernel::Thread;


#define KILL_SIGNALS	\
	(((sigset_t)1 << (SIGKILL - 1)) | ((sigset_t)1 << (SIGKILLTHR - 1)))

#define SYSCALL_RESTART_PARAMETER_SIZE	32

// kernel-internal signals
#define SIGNAL_DEBUG_THREAD		62
	// Debug a thread. Used together with the B_THREAD_DEBUG_STOP thread debug
	// flag. Continues the thread, if suspended, but has no effect otherwise.
	// Non-blockable.
#define SIGNAL_CANCEL_THREAD	63
	// Cancel a thread. Non-blockable.
#define SIGNAL_CONTINUE_THREAD	64
	// Continue a thread. Used by resume_thread(). Non-blockable, prevents
	// syscall restart.


struct signal_frame_data {
	siginfo_t	info;
	ucontext_t	context;
	void*		user_data;
	void*		handler;
	bool		siginfo_handler;
	int32		thread_flags;
	uint64		syscall_restart_return_value;
	uint8		syscall_restart_parameters[SYSCALL_RESTART_PARAMETER_SIZE];
	void*		commpage_address;
};


namespace BKernel {


struct QueuedSignalsCounter : BReferenceable {
								QueuedSignalsCounter(int32 limit);

			bool				Increment();
			void				Decrement()		{ ReleaseReference(); }

private:
			int32				fLimit;
};


struct Signal : KernelReferenceable, DoublyLinkedListLinkImpl<Signal> {
public:
								Signal();
									// cheap no-init constructor
								Signal(const Signal& other);
								Signal(uint32 number, int32 signalCode,
									int32 errorCode, pid_t sendingProcess);
	virtual						~Signal();

	static	status_t			CreateQueuable(const Signal& signal,
									bool queuingRequired,
									Signal*& _signalToQueue);

			void				SetTo(uint32 number);

			uint32				Number() const { return fNumber; }
			void				SetNumber(uint32 number)
									{ fNumber = number; }

			int32				Priority() const;

			int32				SignalCode() const
									{ return fSignalCode; }
			int32				ErrorCode() const
									{ return fErrorCode; }
 			pid_t				SendingProcess() const
 									{ return fSendingProcess; }

 			uid_t				SendingUser() const
 									{ return fSendingUser; }
 			void				SetSendingUser(uid_t user)
 									{ fSendingUser = user; }

			int32				Status() const
									{ return fStatus; }
			void				SetStatus(int32 status)
									{ fStatus = status; }

			int32				PollBand() const
									{ return fPollBand; }
			void				SetPollBand(int32 pollBand)
									{ fPollBand = pollBand; }

			void*				Address() const
									{ return fAddress; }
			void				SetAddress(void* address)
									{ fAddress = address; }

			union sigval		UserValue() const
									{ return fUserValue; }
			void				SetUserValue(union sigval userValue)
									{ fUserValue = userValue; }

			bool				IsPending() const
									{ return fPending; }
			void				SetPending(bool pending)
									{ fPending = pending; }

	virtual	void				Handled();

protected:
	virtual	void				LastReferenceReleased();

private:
			QueuedSignalsCounter* fCounter;
			uint32				fNumber;
			int32				fSignalCode;
			int32				fErrorCode;	// error code associated with the
											// signal
			pid_t				fSendingProcess;
			uid_t				fSendingUser;
			int32				fStatus;	// exit value
			int32				fPollBand;	// for SIGPOLL
			void*				fAddress;
			union sigval		fUserValue;
			bool				fPending;
};


struct PendingSignals {
								PendingSignals();
								~PendingSignals();

			sigset_t			AllSignals() const
									{ return fQueuedSignalsMask
										| fUnqueuedSignalsMask; }

			int32				HighestSignalPriority(sigset_t nonBlocked)
									const;

			void				Clear();
			void				AddSignal(int32 signal)
									{ fUnqueuedSignalsMask
										|= SIGNAL_TO_MASK(signal); }
			void				AddSignal(Signal* signal);
			void				RemoveSignal(int32 signal)
									{ RemoveSignals(SIGNAL_TO_MASK(signal)); }
			void				RemoveSignal(Signal* signal);
			void				RemoveSignals(sigset_t mask);

			Signal*				DequeueSignal(sigset_t nonBlocked,
									Signal& buffer);

private:
			typedef DoublyLinkedList<Signal> SignalList;

private:
			int32				_GetHighestPrioritySignal(sigset_t nonBlocked,
									Signal*& _queuedSignal,
									int32& _unqueuedSignal) const;
			void				_UpdateQueuedSignalMask();

private:
			sigset_t			fQueuedSignalsMask;
			sigset_t			fUnqueuedSignalsMask;
			SignalList			fQueuedSignals;
};


}	// namespace BKernel


using BKernel::PendingSignals;
using BKernel::QueuedSignalsCounter;
using BKernel::Signal;


#ifdef __cplusplus
extern "C" {
#endif

void handle_signals(Thread* thread);
bool is_team_signal_blocked(Team* team, int signal);
void signal_get_user_stack(addr_t address, stack_t* stack);

status_t send_signal_to_thread_locked(Thread* thread, uint32 signalNumber,
	Signal* signal, uint32 flags);
status_t send_signal_to_thread(Thread* thread, const Signal& signal,
	uint32 flags);
status_t send_signal_to_thread_id(thread_id threadID, const Signal& signal,
	uint32 flags);

status_t send_signal_to_team_locked(Team* team, uint32 signalNumber,
	Signal* signal, uint32 flags);
status_t send_signal_to_team(Team* team, const Signal& signal, uint32 flags);
status_t send_signal_to_team_id(team_id teamID, const Signal& signal,
	uint32 flags);

status_t send_signal_to_process_group_locked(ProcessGroup* group,
	const Signal& signal, uint32 flags);
status_t send_signal_to_process_group(pid_t groupID, const Signal& signal,
	uint32 flags);

status_t _user_send_signal(int32 id, uint32 signal,
	const union sigval* userValue, uint32 flags);
status_t _user_set_signal_mask(int how, const sigset_t *set, sigset_t *oldSet);
status_t _user_sigaction(int sig, const struct sigaction *newAction,
	struct sigaction *oldAction);
bigtime_t _user_set_alarm(bigtime_t time, uint32 mode);
status_t _user_sigwait(const sigset_t *set, siginfo_t *info, uint32 flags,
	bigtime_t timeout);
status_t _user_sigsuspend(const sigset_t *mask);
status_t _user_sigpending(sigset_t *set);
status_t _user_set_signal_stack(const stack_t *newUserStack,
	stack_t *oldUserStack);
int64 _user_restore_signal_frame(struct signal_frame_data* signalFrameData);

#ifdef __cplusplus
}
#endif

#endif	/* _KERNEL_SIGNAL_H */