• Jim Houston's avatar
    [PATCH] preallocate signal queue resource - Posix timers · d1791d31
    Jim Houston authored
    This adds a new interface to kernel/signal.c which allows signals to be
    sent using preallocated sigqueue structures.  It also modifies
    kernel/posix-timers.c to use this interface.
    
    The current timer code may fail to deliver a timer expiry signal if
    there are no sigqueue structures available at the time of the expiry.
    The Posix specification is clear that the signal queuing resource should
    be allocated at timer_create time.  This allows the error to be returned
    to the application rather than silently losing the signal.
    
    This patch does not change the sigqueue structure allocation policy.  I
    hope to revisit that in another patch.
    
    Here is the definition for the new interface:
    
    struct sigqueue *sigqueue_alloc(void)
    	Preallocate a sigqueue structure for use with the functions
    	described below.
    
    void sigqueue_free(struct sigqueue *q)
    	Free a preallocated sigqueue structure.  If the sigqueue
    	structure being freed is still queued, it will be removed
    	from the queue.  I currently leave the signal pending.
    	It may be delivered without the siginfo structure.
    
    int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
    	This function is equivalent to send_sig_info().  It queues
    	a signal to the specified thread using  the supplied sigqueue
    	structure.  The caller is expected to fill in the siginfo_t
    	which is part of the sigqueue structure.
    
    int send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
    	This function is equivalent to send_group_sig_info().  It queues
    	the signal to a process allowing the system to select which thread
    	will receive the signal in a multi-threaded process.
    	Again, the sigqueue structure is used to queue the signal.
    
    Both send_sigqueue() and send_group_sigqueue() return 0 if the signal
    is queued. They return 1 if the signal was not queued because the
    process is ignoring the signal.
    
    Both versions include code to increment the si_overrun count if the
    sigqueue entry is for a Posix timer and they are called while the
    sigqueue entry is still queued.  Yes, I know that the current code
    doesn't rearm the timer until the signal is delivered.  Having this
    extra bit of code doesn't do any harm, and I plan to use it.
    
    These routines do not check if there already is a legacy (non-realtime)
    signal pending.  They always queue the signal.  This requires that
    collect_signal() always checks if there is another matching siginfo
    before clearing the signal bit.
    d1791d31
signal.c 60.9 KB