[PATCH] signal locking update

Accomodate the signal locking moving from "tsk->sig" to "tsk->sighand".

diff --git a/arch/alpha/kernel/signal.c b/arch/alpha/kernel/signal.c
index a986bc9a2db8543d5084849a59495ae318f11822..c17cb0f62c69d51241f8213d0679cbe98208940b 100644 (file)
--- a/arch/alpha/kernel/signal.c
+++ b/arch/alpha/kernel/signal.c
@@ -63,7 +63,7 @@ osf_sigprocmask(int how, unsigned long newmask, long a2, long a3,
                unsigned long block, unblock;
 
                newmask &= _BLOCKABLE;
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                oldmask = current->blocked.sig[0];
 
                unblock = oldmask & ~newmask;
@@ -76,7 +76,7 @@ osf_sigprocmask(int how, unsigned long newmask, long a2, long a3,
                        sigemptyset(&current->blocked);
                current->blocked.sig[0] = newmask;
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
 
                (&regs)->r0 = 0;                /* special no error return */
        }
@@ -150,11 +150,11 @@ do_sigsuspend(old_sigset_t mask, struct pt_regs *reg, struct switch_stack *sw)
        sigset_t oldset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        oldset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        while (1) {
                current->state = TASK_INTERRUPTIBLE;
@@ -177,11 +177,11 @@ do_rt_sigsuspend(sigset_t *uset, size_t sigsetsize,
                return -EFAULT;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        oldset = current->blocked;
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        while (1) {
                current->state = TASK_INTERRUPTIBLE;
@@ -284,10 +284,10 @@ do_sigreturn(struct sigframe *frame, struct pt_regs *regs,
                goto give_sigsegv;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigcontext(&frame->sc, regs, sw))
                goto give_sigsegv;
@@ -323,10 +323,10 @@ do_rt_sigreturn(struct rt_sigframe *frame, struct pt_regs *regs,
                goto give_sigsegv;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
                goto give_sigsegv;
@@ -562,11 +562,11 @@ handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 

diff --git a/arch/arm/kernel/signal.c b/arch/arm/kernel/signal.c
index 51f8711be5d096f41a29714f30367131e270bbc8..c70ebebb1eb15e6d5d8c9214e8400d50d2ec103b 100644 (file)
--- a/arch/arm/kernel/signal.c
+++ b/arch/arm/kernel/signal.c
@@ -59,11 +59,11 @@ asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, old_sigset_t m
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        regs->ARM_r0 = -EINTR;
 
        while (1) {
@@ -87,11 +87,11 @@ sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, struct pt_regs *regs)
                return -EFAULT;
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        regs->ARM_r0 = -EINTR;
 
        while (1) {
@@ -207,10 +207,10 @@ asmlinkage int sys_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigcontext(regs, &frame->sc))
                goto badframe;
@@ -247,10 +247,10 @@ asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
                goto badframe;
@@ -477,12 +477,12 @@ handle_signal(unsigned long sig, struct k_sigaction *ka,
                        ka->sa.sa_handler = SIG_DFL;
 
                if (!(ka->sa.sa_flags & SA_NODEFER)) {
-                       spin_lock_irq(&tsk->sig->siglock);
+                       spin_lock_irq(&tsk->sighand->siglock);
                        sigorsets(&tsk->blocked, &tsk->blocked,
                                  &ka->sa.sa_mask);
                        sigaddset(&tsk->blocked, sig);
                        recalc_sigpending();
-                       spin_unlock_irq(&tsk->sig->siglock);
+                       spin_unlock_irq(&tsk->sighand->siglock);
                }
                return;
        }
@@ -521,9 +521,9 @@ static int do_signal(sigset_t *oldset, struct pt_regs *regs, int syscall)
                unsigned long signr = 0;
                struct k_sigaction *ka;
 
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                signr = dequeue_signal(&current->blocked, &info);
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
 
                if (!signr)
                        break;

diff --git a/arch/ia64/ia32/ia32_signal.c b/arch/ia64/ia32/ia32_signal.c
index f2d006240df2ecbd098cc0086c5ffac7186d6af9..de4213cf1a5aad767f39eaa57e061665aae55f3e 100644 (file)
--- a/arch/ia64/ia32/ia32_signal.c
+++ b/arch/ia64/ia32/ia32_signal.c
@@ -479,13 +479,13 @@ ia32_rt_sigsuspend (compat_sigset_t *uset, unsigned int sigsetsize, struct sigsc
 
        sigdelsetmask(&set, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        {
                oldset = current->blocked;
                current->blocked = set;
                recalc_sigpending();
        }
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /*
         * The return below usually returns to the signal handler.  We need to pre-set the
@@ -1007,10 +1007,10 @@ sys32_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = (sigset_t) set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigcontext_ia32(regs, &frame->sc, &eax))
                goto badframe;
@@ -1038,10 +1038,10 @@ sys32_rt_sigreturn (int arg0, int arg1, int arg2, int arg3, int arg4, int arg5,
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked =  set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigcontext_ia32(regs, &frame->uc.uc_mcontext, &eax))
                goto badframe;

diff --git a/arch/ia64/kernel/signal.c b/arch/ia64/kernel/signal.c
index 8ff4fe33902a7806d0583df055dc05a1013a0138..626725da43f74341b181f7af3011be94d0b9e5d6 100644 (file)
--- a/arch/ia64/kernel/signal.c
+++ b/arch/ia64/kernel/signal.c
@@ -68,13 +68,13 @@ ia64_rt_sigsuspend (sigset_t *uset, size_t sigsetsize, struct sigscratch *scr)
 
        sigdelsetmask(&set, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        {
                oldset = current->blocked;
                current->blocked = set;
                recalc_sigpending();
        }
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /*
         * The return below usually returns to the signal handler.  We need to
@@ -274,12 +274,12 @@ ia64_rt_sigreturn (struct sigscratch *scr)
 
        sigdelsetmask(&set, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        {
                current->blocked = set;
                recalc_sigpending();
        }
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigcontext(sc, scr))
                goto give_sigsegv;
@@ -465,13 +465,13 @@ handle_signal (unsigned long sig, struct k_sigaction *ka, siginfo_t *info, sigse
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                {
                        sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
                        sigaddset(&current->blocked, sig);
                        recalc_sigpending();
                }
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
        return 1;
 }

diff --git a/arch/m68knommu/kernel/signal.c b/arch/m68knommu/kernel/signal.c
index 3b9d312da5839c812847e1e71cf334ac3d11db3f..2d51c175074e3d4789022b28bb5cd7f820ba25a4 100644 (file)
--- a/arch/m68knommu/kernel/signal.c
+++ b/arch/m68knommu/kernel/signal.c
@@ -63,11 +63,11 @@ asmlinkage int do_sigsuspend(struct pt_regs *regs)
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->d0 = -EINTR;
        while (1) {
@@ -93,11 +93,11 @@ do_rt_sigsuspend(struct pt_regs *regs)
                return -EFAULT;
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->d0 = -EINTR;
        while (1) {
@@ -370,10 +370,10 @@ asmlinkage int do_sigreturn(unsigned long __unused)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        if (restore_sigcontext(regs, &frame->sc, frame + 1, &d0))
                goto badframe;
@@ -399,10 +399,10 @@ asmlinkage int do_rt_sigreturn(unsigned long __unused)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        if (rt_restore_ucontext(regs, sw, &frame->uc, &d0))
                goto badframe;
@@ -738,11 +738,11 @@ handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 

diff --git a/arch/parisc/kernel/signal.c b/arch/parisc/kernel/signal.c
index 0fd3582856531a5e9b183bcba3090d9d32d5e64b..47c9c81ad69f62a6de61993f77280cf321900398 100644 (file)
--- a/arch/parisc/kernel/signal.c
+++ b/arch/parisc/kernel/signal.c
@@ -118,11 +118,11 @@ sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, struct pt_regs *regs)
 #endif
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->gr[28] = -EINTR;
        while (1) {
@@ -177,10 +177,10 @@ sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
                goto give_sigsegv;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /* Good thing we saved the old gr[30], eh? */
        if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
@@ -407,11 +407,11 @@ handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
        return 1;
 }

diff --git a/arch/ppc/kernel/signal.c b/arch/ppc/kernel/signal.c
index fddae70728fdd5264c7f601f4fd0374500b5fce0..0878aed667211de52bf7e15828638660318e8b78 100644 (file)
--- a/arch/ppc/kernel/signal.c
+++ b/arch/ppc/kernel/signal.c
@@ -65,11 +65,11 @@ sys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7,
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->result = -EINTR;
        regs->ccr |= 0x10000000;
@@ -96,11 +96,11 @@ sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, int p3, int p4, int p6,
                return -EFAULT;
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->result = -EINTR;
        regs->ccr |= 0x10000000;
@@ -208,10 +208,10 @@ int sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
            || copy_from_user(&st, &rt_sf->uc.uc_stack, sizeof(st)))
                goto badframe;
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        if (regs->msr & MSR_FP)
                giveup_fpu(current);
 
@@ -311,10 +311,10 @@ int sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
        set.sig[1] = sigctx._unused[3];
 #endif
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        if (regs->msr & MSR_FP )
                giveup_fpu(current);
 
@@ -450,11 +450,11 @@ handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
        return;
 

diff --git a/arch/ppc64/kernel/signal.c b/arch/ppc64/kernel/signal.c
index acb5577269f69c01dc9d57db95fde80ae32d6b57..c07f30d4ccac46826d7401be56e9a074dc8dcce5 100644 (file)
--- a/arch/ppc64/kernel/signal.c
+++ b/arch/ppc64/kernel/signal.c
@@ -112,11 +112,11 @@ long sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, int p3, int p4, int
                return -EFAULT;
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->result = -EINTR;
        regs->gpr[3] = EINTR;
@@ -164,10 +164,10 @@ int sys_rt_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5,
            || copy_from_user(&st, &rt_sf->uc.uc_stack, sizeof(st)))
                goto badframe;
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        if (regs->msr & MSR_FP)
                giveup_fpu(current);
 
@@ -333,11 +333,11 @@ static void handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
        return;
 

diff --git a/arch/ppc64/kernel/signal32.c b/arch/ppc64/kernel/signal32.c
index 8dd332ded5ffb6e1cafedee9a77ee88d7a2acc28..3999fd4ea35fda8e1cf904a7a91592e42e1b79ca 100644 (file)
--- a/arch/ppc64/kernel/signal32.c
+++ b/arch/ppc64/kernel/signal32.c
@@ -126,11 +126,11 @@ long sys32_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6,
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->result = -EINTR;
        regs->gpr[3] = EINTR;
@@ -268,10 +268,10 @@ long sys32_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5,
         */
        set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        if (regs->msr & MSR_FP )
                giveup_fpu(current);
        /* Last stacked signal - restore registers */
@@ -487,10 +487,10 @@ long sys32_rt_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5,
         */
        sigdelsetmask(&set, ~_BLOCKABLE); 
        /* update the current based on the sigmask found in the rt_stackframe */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /* If currently owning the floating point - give them up */
        if (regs->msr & MSR_FP)
@@ -863,11 +863,11 @@ int sys32_rt_sigsuspend(sigset32_t* unewset, size_t sigsetsize, int p3,
 
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->result = -EINTR;
        regs->gpr[3] = EINTR;
@@ -1055,11 +1055,11 @@ static void handle_signal32(unsigned long sig, siginfo_t *info,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
        return;
 

diff --git a/arch/s390/kernel/signal.c b/arch/s390/kernel/signal.c
index 1f2b732fb96a3cc9b59bb214d5dcf950face50c0..8c69d545b82fa045f019c19db927499b6b6432ca 100644 (file)
--- a/arch/s390/kernel/signal.c
+++ b/arch/s390/kernel/signal.c
@@ -61,11 +61,11 @@ sys_sigsuspend(struct pt_regs * regs, int history0, int history1,
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        regs->gprs[2] = -EINTR;
 
        while (1) {
@@ -89,11 +89,11 @@ sys_rt_sigsuspend(struct pt_regs * regs,sigset_t *unewset, size_t sigsetsize)
                return -EFAULT;
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        regs->gprs[2] = -EINTR;
 
        while (1) {
@@ -194,10 +194,10 @@ asmlinkage long sys_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigregs(regs, &frame->sregs))
                goto badframe;
@@ -220,10 +220,10 @@ asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigregs(regs, &frame->uc.uc_mcontext))
                goto badframe;
@@ -427,11 +427,11 @@ handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 

diff --git a/arch/s390x/kernel/linux32.c b/arch/s390x/kernel/linux32.c
index ee1dcc5d8f6163ab3fa457644faf4f1c573b88ea..298c903a2d7c6e86fad9099755d4f32b6f0a0631 100644 (file)
--- a/arch/s390x/kernel/linux32.c
+++ b/arch/s390x/kernel/linux32.c
@@ -1725,7 +1725,7 @@ sys32_rt_sigtimedwait(compat_sigset_t *uthese, siginfo_t32 *uinfo,
                        return -EINVAL;
        }
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sig = dequeue_signal(&these, &info);
        if (!sig) {
                /* None ready -- temporarily unblock those we're interested
@@ -1733,7 +1733,7 @@ sys32_rt_sigtimedwait(compat_sigset_t *uthese, siginfo_t32 *uinfo,
                current->real_blocked = current->blocked;
                sigandsets(&current->blocked, &current->blocked, &these);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
 
                timeout = MAX_SCHEDULE_TIMEOUT;
                if (uts)
@@ -1743,13 +1743,13 @@ sys32_rt_sigtimedwait(compat_sigset_t *uthese, siginfo_t32 *uinfo,
                current->state = TASK_INTERRUPTIBLE;
                timeout = schedule_timeout(timeout);
 
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sig = dequeue_signal(&these, &info);
                current->blocked = current->real_blocked;
                siginitset(&current->real_blocked, 0);
                recalc_sigpending();
        }
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (sig) {
                ret = sig;

diff --git a/arch/s390x/kernel/signal.c b/arch/s390x/kernel/signal.c
index bb9291563f5ffdeaea3a33e0e5776e58fac5a2e2..957197b9b35c8e684556dee1c14de35dc4a06ed9 100644 (file)
--- a/arch/s390x/kernel/signal.c
+++ b/arch/s390x/kernel/signal.c
@@ -60,11 +60,11 @@ sys_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t ma
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        regs->gprs[2] = -EINTR;
 
        while (1) {
@@ -88,11 +88,11 @@ sys_rt_sigsuspend(struct pt_regs * regs,sigset_t *unewset, size_t sigsetsize)
                return -EFAULT;
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        regs->gprs[2] = -EINTR;
 
        while (1) {
@@ -188,10 +188,10 @@ asmlinkage long sys_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigregs(regs, &frame->sregs))
                goto badframe;
@@ -214,10 +214,10 @@ asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigregs(regs, &frame->uc.uc_mcontext))
                goto badframe;
@@ -421,11 +421,11 @@ handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 

diff --git a/arch/s390x/kernel/signal32.c b/arch/s390x/kernel/signal32.c
index 11f5e3baed073a0a76ee0ba048d5c8299b018b68..9757d092bbfb28fe4f67b075bdbacb1bdb509dac 100644 (file)
--- a/arch/s390x/kernel/signal32.c
+++ b/arch/s390x/kernel/signal32.c
@@ -112,11 +112,11 @@ sys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        regs->gprs[2] = -EINTR;
 
        while (1) {
@@ -147,11 +147,11 @@ sys32_rt_sigsuspend(struct pt_regs * regs,compat_sigset_t *unewset, size_t sigse
        }
         sigdelsetmask(&newset, ~_BLOCKABLE);
 
-        spin_lock_irq(&current->sig->siglock);
+        spin_lock_irq(&current->sighand->siglock);
         saveset = current->blocked;
         current->blocked = newset;
         recalc_sigpending();
-        spin_unlock_irq(&current->sig->siglock);
+        spin_unlock_irq(&current->sighand->siglock);
         regs->gprs[2] = -EINTR;
 
         while (1) {
@@ -345,10 +345,10 @@ asmlinkage long sys32_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigregs32(regs, &frame->sregs))
                goto badframe;
@@ -375,10 +375,10 @@ asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
                goto badframe;
@@ -588,11 +588,11 @@ handle_signal32(unsigned long sig, siginfo_t *info, sigset_t *oldset,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 

diff --git a/arch/sparc/kernel/signal.c b/arch/sparc/kernel/signal.c
index 9ea6c0e50af451600a71fc33152bf14599667e69..afaa3df1b6c06be3c29398a08ffcf6d105c0f906 100644 (file)
--- a/arch/sparc/kernel/signal.c
+++ b/arch/sparc/kernel/signal.c
@@ -104,11 +104,11 @@ asmlinkage void _sigpause_common(old_sigset_t set, struct pt_regs *regs)
        sigset_t saveset;
 
        set &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, set);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->pc = regs->npc;
        regs->npc += 4;
@@ -161,11 +161,11 @@ asmlinkage void do_rt_sigsuspend(sigset_t *uset, size_t sigsetsize,
        }
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        oldset = current->blocked;
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->pc = regs->npc;
        regs->npc += 4;
@@ -267,10 +267,10 @@ static inline void do_new_sigreturn (struct pt_regs *regs)
                goto segv_and_exit;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return;
 
 segv_and_exit:
@@ -314,10 +314,10 @@ asmlinkage void do_sigreturn(struct pt_regs *regs)
                goto segv_and_exit;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->pc = pc;
        regs->npc = npc;
@@ -384,10 +384,10 @@ asmlinkage void do_rt_sigreturn(struct pt_regs *regs)
        do_sigaltstack(&st, NULL, (unsigned long)sf);
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return;
 segv:
        send_sig(SIGSEGV, current, 1);
@@ -967,10 +967,10 @@ asmlinkage int svr4_setcontext (svr4_ucontext_t *c, struct pt_regs *regs)
                set.sig[3] = setv.sigbits[3];
        }
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        regs->pc = pc;
        regs->npc = npc | 1;
        err |= __get_user(regs->y, &((*gr) [SVR4_Y]));
@@ -1007,11 +1007,11 @@ handle_signal(unsigned long signr, struct k_sigaction *ka,
        if(ka->sa.sa_flags & SA_ONESHOT)
                ka->sa.sa_handler = SIG_DFL;
        if(!(ka->sa.sa_flags & SA_NOMASK)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked, signr);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 
@@ -1066,9 +1066,9 @@ asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
                sigset_t *mask = &current->blocked;
                unsigned long signr = 0;
 
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                signr = dequeue_signal(mask, &info);
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
 
                if (!signr)
                        break;

diff --git a/arch/sparc/kernel/sys_sunos.c b/arch/sparc/kernel/sys_sunos.c
index a81ca49787023d876f5201c05020f578e1ffaa4f..383012ad6d90a7d9ee186d57254c41934acb7236 100644 (file)
--- a/arch/sparc/kernel/sys_sunos.c
+++ b/arch/sparc/kernel/sys_sunos.c
@@ -281,11 +281,11 @@ asmlinkage unsigned long sunos_sigblock(unsigned long blk_mask)
 {
        unsigned long old;
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        old = current->blocked.sig[0];
        current->blocked.sig[0] |= (blk_mask & _BLOCKABLE);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return old;
 }
 
@@ -293,11 +293,11 @@ asmlinkage unsigned long sunos_sigsetmask(unsigned long newmask)
 {
        unsigned long retval;
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        retval = current->blocked.sig[0];
        current->blocked.sig[0] = (newmask & _BLOCKABLE);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return retval;
 }
 

diff --git a/arch/sparc64/kernel/power.c b/arch/sparc64/kernel/power.c
index e0da1f38b54ae36bf1ad806ad13c7f3ac0eb6b46..042bb08bbb212630605a64a4dd846c62f6ccac09 100644 (file)
--- a/arch/sparc64/kernel/power.c
+++ b/arch/sparc64/kernel/power.c
@@ -70,9 +70,9 @@ static int powerd(void *__unused)
 
 again:
        while (button_pressed == 0) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                flush_signals(current);
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
                interruptible_sleep_on(&powerd_wait);
        }
 

diff --git a/arch/sparc64/kernel/signal.c b/arch/sparc64/kernel/signal.c
index d90f860410b2a0a46ba655872f4dcdaa6ef91cc8..fc16c629e2b74ae1691b21e3495da7f5fef7eba7 100644 (file)
--- a/arch/sparc64/kernel/signal.c
+++ b/arch/sparc64/kernel/signal.c
@@ -70,10 +70,10 @@ asmlinkage void sparc64_set_context(struct pt_regs *regs)
                                goto do_sigsegv;
                }
                sigdelsetmask(&set, ~_BLOCKABLE);
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                current->blocked = set;
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
        if (test_thread_flag(TIF_32BIT)) {
                pc &= 0xffffffff;
@@ -257,11 +257,11 @@ asmlinkage void _sigpause_common(old_sigset_t set, struct pt_regs *regs)
        }
 #endif
        set &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, set);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        if (test_thread_flag(TIF_32BIT)) {
                regs->tpc = (regs->tnpc & 0xffffffff);
@@ -317,11 +317,11 @@ asmlinkage void do_rt_sigsuspend(sigset_t *uset, size_t sigsetsize, struct pt_re
        }
                                                                 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        oldset = current->blocked;
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        if (test_thread_flag(TIF_32BIT)) {
                regs->tpc = (regs->tnpc & 0xffffffff);
@@ -428,10 +428,10 @@ void do_rt_sigreturn(struct pt_regs *regs)
        set_fs(old_fs);
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return;
 segv:
        send_sig(SIGSEGV, current, 1);
@@ -564,11 +564,11 @@ static inline void handle_signal(unsigned long signr, struct k_sigaction *ka,
        if (ka->sa.sa_flags & SA_ONESHOT)
                ka->sa.sa_handler = SIG_DFL;
        if (!(ka->sa.sa_flags & SA_NOMASK)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,signr);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 
@@ -619,9 +619,9 @@ static int do_signal(sigset_t *oldset, struct pt_regs * regs,
                sigset_t *mask = &current->blocked;
                unsigned long signr = 0;
 
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                signr = dequeue_signal(mask, &info);
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
                
                if (!signr)
                        break;

diff --git a/arch/sparc64/kernel/signal32.c b/arch/sparc64/kernel/signal32.c
index b2a6edc8ed8d59aa8d8987b1dcc74089c826556a..8b5de881a810461ba6dc12247c6e8138fca68b9e 100644 (file)
--- a/arch/sparc64/kernel/signal32.c
+++ b/arch/sparc64/kernel/signal32.c
@@ -144,11 +144,11 @@ asmlinkage void _sigpause32_common(compat_old_sigset_t set, struct pt_regs *regs
        sigset_t saveset;
 
        set &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, set);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        regs->tpc = regs->tnpc;
        regs->tnpc += 4;
@@ -199,11 +199,11 @@ asmlinkage void do_rt_sigsuspend32(u32 uset, size_t sigsetsize, struct pt_regs *
        case 1: set.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
        }
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        oldset = current->blocked;
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        regs->tpc = regs->tnpc;
        regs->tnpc += 4;
@@ -312,10 +312,10 @@ void do_new_sigreturn32(struct pt_regs *regs)
                case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
        }
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return;
 
 segv:
@@ -359,10 +359,10 @@ asmlinkage void do_sigreturn32(struct pt_regs *regs)
                case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
        }
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        if (test_thread_flag(TIF_32BIT)) {
                pc &= 0xffffffff;
@@ -461,10 +461,10 @@ asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
                case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
        }
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return;
 segv:
        do_exit(SIGSEGV);
@@ -1059,10 +1059,10 @@ asmlinkage int svr4_setcontext(svr4_ucontext_t *c, struct pt_regs *regs)
        set_fs(old_fs);
        
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        regs->tpc = pc;
        regs->tnpc = npc | 1;
        if (test_thread_flag(TIF_32BIT)) {
@@ -1241,11 +1241,11 @@ static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
        if (ka->sa.sa_flags & SA_ONESHOT)
                ka->sa.sa_handler = SIG_DFL;
        if (!(ka->sa.sa_flags & SA_NOMASK)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,signr);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 
@@ -1288,9 +1288,9 @@ int do_signal32(sigset_t *oldset, struct pt_regs * regs,
                sigset_t *mask = &current->blocked;
                unsigned long signr = 0;
 
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                signr = dequeue_signal(mask, &info);
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
                
                if (!signr)
                        break;

diff --git a/arch/sparc64/kernel/sys_sparc32.c b/arch/sparc64/kernel/sys_sparc32.c
index 62e4753a5eca808cd1030f73d609efb3ec5387f6..b01db9baf0d69e4cd2857a833e63f65e2091a67a 100644 (file)
--- a/arch/sparc64/kernel/sys_sparc32.c
+++ b/arch/sparc64/kernel/sys_sparc32.c
@@ -1812,7 +1812,7 @@ sys32_rt_sigtimedwait(compat_sigset_t *uthese, siginfo_t32 *uinfo,
                        return -EINVAL;
        }
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sig = dequeue_signal(&these, &info);
        if (!sig) {
                timeout = MAX_SCHEDULE_TIMEOUT;
@@ -1827,19 +1827,19 @@ sys32_rt_sigtimedwait(compat_sigset_t *uthese, siginfo_t32 *uinfo,
                        current->real_blocked = current->blocked;
                        sigandsets(&current->blocked, &current->blocked, &these);
                        recalc_sigpending();
-                       spin_unlock_irq(&current->sig->siglock);
+                       spin_unlock_irq(&current->sighand->siglock);
 
                        current->state = TASK_INTERRUPTIBLE;
                        timeout = schedule_timeout(timeout);
 
-                       spin_lock_irq(&current->sig->siglock);
+                       spin_lock_irq(&current->sighand->siglock);
                        sig = dequeue_signal(&these, &info);
                        current->blocked = current->real_blocked;
                        siginitset(&current->real_blocked, 0);
                        recalc_sigpending();
                }
        }
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (sig) {
                ret = sig;

diff --git a/arch/sparc64/kernel/sys_sunos32.c b/arch/sparc64/kernel/sys_sunos32.c
index 8d0b518b322763389e07c86f0e87f60f4e7742d0..b3341bbbd2fe27cb4a03aa09e097d6b80b354210 100644 (file)
--- a/arch/sparc64/kernel/sys_sunos32.c
+++ b/arch/sparc64/kernel/sys_sunos32.c
@@ -238,11 +238,11 @@ asmlinkage u32 sunos_sigblock(u32 blk_mask)
 {
        u32 old;
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        old = (u32) current->blocked.sig[0];
        current->blocked.sig[0] |= (blk_mask & _BLOCKABLE);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return old;
 }
 
@@ -250,11 +250,11 @@ asmlinkage u32 sunos_sigsetmask(u32 newmask)
 {
        u32 retval;
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        retval = (u32) current->blocked.sig[0];
        current->blocked.sig[0] = (newmask & _BLOCKABLE);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return retval;
 }
 

diff --git a/arch/sparc64/solaris/signal.c b/arch/sparc64/solaris/signal.c
index bb2d2b30c645175793ec573cd762ea432bc7e8bc..72f126c3dcaef7d22cc997f80cf6ee05ab10856c 100644 (file)
--- a/arch/sparc64/solaris/signal.c
+++ b/arch/sparc64/solaris/signal.c
@@ -99,16 +99,16 @@ static inline long solaris_signal(int sig, u32 arg)
 static long solaris_sigset(int sig, u32 arg)
 {
        if (arg != 2) /* HOLD */ {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigdelsetmask(&current->blocked, _S(sig));
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
                return sig_handler (sig, arg, 0);
        } else {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigaddsetmask(&current->blocked, (_S(sig) & ~_BLOCKABLE));
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
                return 0;
        }
 }
@@ -120,10 +120,10 @@ static inline long solaris_sighold(int sig)
 
 static inline long solaris_sigrelse(int sig)
 {
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sigdelsetmask(&current->blocked, _S(sig));
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        return 0;
 }
 
@@ -311,10 +311,10 @@ asmlinkage int solaris_sigpending(int which, u32 set)
        u32 tmp[4];
        switch (which) {
        case 1: /* sigpending */
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigandsets(&s, &current->blocked, &current->pending.signal);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
                break;
        case 2: /* sigfillset - I just set signals which have linux equivalents */
                sigfillset(&s);

diff --git a/arch/um/kernel/signal_kern.c b/arch/um/kernel/signal_kern.c
index bd4572688650368c8ecf2883dfc89317320208d3..d640ff441ff8e19af66da750e750c44f23d4aa57 100644 (file)
--- a/arch/um/kernel/signal_kern.c
+++ b/arch/um/kernel/signal_kern.c
@@ -95,12 +95,12 @@ static int handle_signal(struct pt_regs *regs, unsigned long signr,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked, &current->blocked, 
                          &ka->sa.sa_mask);
                sigaddset(&current->blocked, signr);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 
        sp = PT_REGS_SP(regs);
@@ -186,11 +186,11 @@ int sys_sigsuspend(int history0, int history1, old_sigset_t mask)
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        while (1) {
                current->state = TASK_INTERRUPTIBLE;
@@ -212,11 +212,11 @@ int sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize)
                return -EFAULT;
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        while (1) {
                current->state = TASK_INTERRUPTIBLE;
@@ -242,13 +242,13 @@ int sys_sigreturn(struct pt_regs regs)
        void *mask = sp_to_mask(PT_REGS_SP(&current->thread.regs));
        int sig_size = (_NSIG_WORDS - 1) * sizeof(unsigned long);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        copy_from_user(&current->blocked.sig[0], sc_sigmask(sc), 
                       sizeof(current->blocked.sig[0]));
        copy_from_user(&current->blocked.sig[1], mask, sig_size);
        sigdelsetmask(&current->blocked, ~_BLOCKABLE);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        copy_sc_from_user(&current->thread.regs, sc, 
                          &signal_frame_sc.common.arch);
        return(PT_REGS_SYSCALL_RET(&current->thread.regs));
@@ -260,11 +260,11 @@ int sys_rt_sigreturn(struct pt_regs regs)
        void *fp;
        int sig_size = _NSIG_WORDS * sizeof(unsigned long);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        copy_from_user(&current->blocked, &uc->uc_sigmask, sig_size);
        sigdelsetmask(&current->blocked, ~_BLOCKABLE);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        fp = (void *) (((unsigned long) uc) + sizeof(struct ucontext));
        copy_sc_from_user(&current->thread.regs, &uc->uc_mcontext,
                          &signal_frame_si.common.arch);

diff --git a/arch/v850/kernel/signal.c b/arch/v850/kernel/signal.c
index d7ec3892e84830f142ffdcf546603f831e31b318..324a2fe2fe21c0dee7a1c3f015d36239daeaf10d 100644 (file)
--- a/arch/v850/kernel/signal.c
+++ b/arch/v850/kernel/signal.c
@@ -50,11 +50,11 @@ sys_sigsuspend(old_sigset_t mask, struct pt_regs *regs)
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->gpr[GPR_RVAL] = -EINTR;
        while (1) {
@@ -78,11 +78,11 @@ sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
        if (copy_from_user(&newset, unewset, sizeof(newset)))
                return -EFAULT;
        sigdelsetmask(&newset, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs->gpr[GPR_RVAL] = -EINTR;
        while (1) {
@@ -188,10 +188,10 @@ asmlinkage int sys_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigcontext(regs, &frame->sc, &rval))
                goto badframe;
@@ -216,10 +216,10 @@ asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &rval))
                goto badframe;
@@ -472,11 +472,11 @@ handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 

diff --git a/arch/x86_64/ia32/ia32_signal.c b/arch/x86_64/ia32/ia32_signal.c
index c3d9c99d760ea101a892da384eff1b1e3ed610ad..a638bc480cff5270544fbb59e4ed740c2e9488b1 100644 (file)
--- a/arch/x86_64/ia32/ia32_signal.c
+++ b/arch/x86_64/ia32/ia32_signal.c
@@ -83,11 +83,11 @@ sys32_sigsuspend(int history0, int history1, old_sigset_t mask, struct pt_regs r
        sigset_t saveset;
 
        mask &= _BLOCKABLE;
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        siginitset(&current->blocked, mask);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        regs.rax = -EINTR;
        while (1) {
@@ -243,10 +243,10 @@ asmlinkage long sys32_sigreturn(struct pt_regs regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        if (ia32_restore_sigcontext(&regs, &frame->sc, &eax))
                goto badframe;
@@ -270,10 +270,10 @@ asmlinkage long sys32_rt_sigreturn(struct pt_regs regs)
                goto badframe;
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        if (ia32_restore_sigcontext(&regs, &frame->uc.uc_mcontext, &eax))
                goto badframe;

diff --git a/arch/x86_64/kernel/signal.c b/arch/x86_64/kernel/signal.c
index a2c0878a1c161787929c47ff39cbea086a3e6957..3f3582cd270b871942cfd5659101a3fead4cfe04 100644 (file)
--- a/arch/x86_64/kernel/signal.c
+++ b/arch/x86_64/kernel/signal.c
@@ -52,11 +52,11 @@ sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, struct pt_regs regs)
                return -EFAULT;
        sigdelsetmask(&newset, ~_BLOCKABLE);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        saveset = current->blocked;
        current->blocked = newset;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 #if DEBUG_SIG
        printk("rt_sigsuspend savset(%lx) newset(%lx) regs(%p) rip(%lx)\n",
                saveset, newset, &regs, regs.rip);
@@ -155,10 +155,10 @@ asmlinkage long sys_rt_sigreturn(struct pt_regs regs)
        } 
 
        sigdelsetmask(&set, ~_BLOCKABLE);
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = set;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        if (restore_sigcontext(&regs, &frame->uc.uc_mcontext, &eax)) { 
                goto badframe;
@@ -401,11 +401,11 @@ handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
                ka->sa.sa_handler = SIG_DFL;
 
        if (!(ka->sa.sa_flags & SA_NODEFER)) {
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
                sigaddset(&current->blocked,sig);
                recalc_sigpending();
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 

diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 0f9f7a9de7ba361cc2405e2af4ef323e3ef8f700..d765900b200b1f5f36946bb320fd7e52bad2bd96 100644 (file)
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -118,12 +118,12 @@ static int nbd_xmit(int send, struct socket *sock, char *buf, int size, int msg_
        set_fs(get_ds());
        /* Allow interception of SIGKILL only
         * Don't allow other signals to interrupt the transmission */
-       spin_lock_irqsave(&current->sig->siglock, flags);
+       spin_lock_irqsave(&current->sighand->siglock, flags);
        oldset = current->blocked;
        sigfillset(&current->blocked);
        sigdelsetmask(&current->blocked, sigmask(SIGKILL));
        recalc_sigpending();
-       spin_unlock_irqrestore(&current->sig->siglock, flags);
+       spin_unlock_irqrestore(&current->sighand->siglock, flags);
 
 
        do {
@@ -146,11 +146,11 @@ static int nbd_xmit(int send, struct socket *sock, char *buf, int size, int msg_
 
                if (signal_pending(current)) {
                        siginfo_t info;
-                       spin_lock_irqsave(&current->sig->siglock, flags);
+                       spin_lock_irqsave(&current->sighand->siglock, flags);
                        printk(KERN_WARNING "NBD (pid %d: %s) got signal %d\n",
                                current->pid, current->comm, 
                                dequeue_signal(&current->blocked, &info));
-                       spin_unlock_irqrestore(&current->sig->siglock, flags);
+                       spin_unlock_irqrestore(&current->sighand->siglock, flags);
                        result = -EINTR;
                        break;
                }
@@ -166,10 +166,10 @@ static int nbd_xmit(int send, struct socket *sock, char *buf, int size, int msg_
                buf += result;
        } while (size > 0);
 
-       spin_lock_irqsave(&current->sig->siglock, flags);
+       spin_lock_irqsave(&current->sighand->siglock, flags);
        current->blocked = oldset;
        recalc_sigpending();
-       spin_unlock_irqrestore(&current->sig->siglock, flags);
+       spin_unlock_irqrestore(&current->sighand->siglock, flags);
 
        set_fs(oldfs);
        return result;

diff --git a/drivers/bluetooth/bt3c_cs.c b/drivers/bluetooth/bt3c_cs.c
index e959f78142250faa00335401a6e6e537cfc42eaf..de14aeafa20cd4e1732f145e4abfb227226c32c2 100644 (file)
--- a/drivers/bluetooth/bt3c_cs.c
+++ b/drivers/bluetooth/bt3c_cs.c
@@ -528,19 +528,19 @@ static int bt3c_firmware_load(bt3c_info_t *info)
        }
 
        /* Block signals, everything but SIGKILL/SIGSTOP */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        tmpsig = current->blocked;
        siginitsetinv(&current->blocked, sigmask(SIGKILL) | sigmask(SIGSTOP));
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        result = waitpid(pid, NULL, __WCLONE);
 
        /* Allow signals again */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = tmpsig;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        if (result != pid) {
                printk(KERN_WARNING "bt3c_cs: Waiting for pid %d failed (errno=%d).\n", pid, -result);

diff --git a/drivers/char/ftape/lowlevel/fdc-io.c b/drivers/char/ftape/lowlevel/fdc-io.c
index c58ea6f76c7211682d96785e9abe626e415b5b9d..99e4b8fb8b7bbe9d62a6177fdf7ca48482087aeb 100644 (file)
--- a/drivers/char/ftape/lowlevel/fdc-io.c
+++ b/drivers/char/ftape/lowlevel/fdc-io.c
@@ -386,11 +386,11 @@ int fdc_interrupt_wait(unsigned int time)
        /* timeout time will be up to USPT microseconds too long ! */
        timeout = (1000 * time + FT_USPT - 1) / FT_USPT;
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        old_sigmask = current->blocked;
        sigfillset(&current->blocked);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        current->state = TASK_INTERRUPTIBLE;
        add_wait_queue(&ftape_wait_intr, &wait);
@@ -398,10 +398,10 @@ int fdc_interrupt_wait(unsigned int time)
                timeout = schedule_timeout(timeout);
         }
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = old_sigmask;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        
        remove_wait_queue(&ftape_wait_intr, &wait);
        /*  the following IS necessary. True: as well

diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 3dace64562093512ab748953ade6f443391959a5..6e994acf13b6f6fbb57271a0a9fa2e07bbe25e53 100644 (file)
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -246,10 +246,10 @@ adb_probe_task(void *x)
 {
        strcpy(current->comm, "kadbprobe");
        
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sigfillset(&current->blocked);
        flush_signals(current);
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        printk(KERN_INFO "adb: starting probe task...\n");
        do_adb_reset_bus();

diff --git a/drivers/md/md.c b/drivers/md/md.c
index e05f1b3daeba901c772eb51b044af2502dfa22d1..9f1d5d0878e56534f9b6e5fdc8cbbd6e7c68ba63 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2444,9 +2444,9 @@ static struct block_device_operations md_fops =
 
 static inline void flush_curr_signals(void)
 {
-       spin_lock(&current->sig->siglock);
+       spin_lock(&current->sighand->siglock);
        flush_signals(current);
-       spin_unlock(&current->sig->siglock);
+       spin_unlock(&current->sighand->siglock);
 }
 
 int md_thread(void * arg)

diff --git a/drivers/media/video/saa5249.c b/drivers/media/video/saa5249.c
index 30041f6122151a4830141f3fffaf5ed3448fe84e..897b3382d0d96cea6544fdbd6f432f9193a87dcf 100644 (file)
--- a/drivers/media/video/saa5249.c
+++ b/drivers/media/video/saa5249.c
@@ -280,17 +280,17 @@ static void jdelay(unsigned long delay)
 {
        sigset_t oldblocked = current->blocked;
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sigfillset(&current->blocked);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        current->state = TASK_INTERRUPTIBLE;
        schedule_timeout(delay);
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        current->blocked = oldblocked;
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 }
 
 

diff --git a/drivers/mtd/devices/blkmtd.c b/drivers/mtd/devices/blkmtd.c
index d609dfc4f8effac4923fecaef2a37c575e23e5e2..7d738397f667d5ca1921292f54b6a4237612961a 100644 (file)
--- a/drivers/mtd/devices/blkmtd.c
+++ b/drivers/mtd/devices/blkmtd.c
@@ -305,10 +305,10 @@ static int write_queue_task(void *data)
   DEBUG(1, "blkmtd: writetask: starting (pid = %d)\n", tsk->pid);
   daemonize();
   strcpy(tsk->comm, "blkmtdd");
-  spin_lock_irq(&tsk->sig->siglock);
+  spin_lock_irq(&tsk->sighand->siglock);
   sigfillset(&tsk->blocked);
   recalc_sigpending();
-  spin_unlock_irq(&tsk->sig->siglock);
+  spin_unlock_irq(&tsk->sighand->siglock);
 
   if(alloc_kiovec(1, &iobuf)) {
     printk("blkmtd: write_queue_task cant allocate kiobuf\n");

diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index bec639985ebce448d532d567ed3b6fe511fdc441..0aec2e6709e73b741167a706f371e4f412a769f1 100644 (file)
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -453,10 +453,10 @@ int mtdblock_thread(void *dummy)
        /* we might get involved when memory gets low, so use PF_MEMALLOC */
        tsk->flags |= PF_MEMALLOC;
        strcpy(tsk->comm, "mtdblockd");
-       spin_lock_irq(&tsk->sig->siglock);
+       spin_lock_irq(&tsk->sighand->siglock);
        sigfillset(&tsk->blocked);
        recalc_sigpending();
-       spin_unlock_irq(&tsk->sig->siglock);
+       spin_unlock_irq(&tsk->sighand->siglock);
        daemonize();
 
        while (!leaving) {

diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index 8fcf0527a01d5b5f305c1ef831c4f99a33bf43cc..e1e8d997983e332e1756a655aad20ad3d1ae2507 100644 (file)
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -1589,10 +1589,10 @@ static int rtl8139_thread (void *data)
        unsigned long timeout;
 
        daemonize();
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sigemptyset(&current->blocked);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        strncpy (current->comm, dev->name, sizeof(current->comm) - 1);
        current->comm[sizeof(current->comm) - 1] = '\0';
@@ -1604,9 +1604,9 @@ static int rtl8139_thread (void *data)
                } while (!signal_pending (current) && (timeout > 0));
 
                if (signal_pending (current)) {
-                       spin_lock_irq(&current->sig->siglock);
+                       spin_lock_irq(&current->sighand->siglock);
                        flush_signals(current);
-                       spin_unlock_irq(&current->sig->siglock);
+                       spin_unlock_irq(&current->sighand->siglock);
                }
 
                if (tp->time_to_die)

diff --git a/drivers/net/irda/sir_kthread.c b/drivers/net/irda/sir_kthread.c
index 80fd4a07183695ebcf98dc4d56a5f58f5ed4e2d3..3f2a538981d904549d87eaec9251671cd1ebdff0 100644 (file)
--- a/drivers/net/irda/sir_kthread.c
+++ b/drivers/net/irda/sir_kthread.c
@@ -116,10 +116,10 @@ static int irda_thread(void *startup)
        daemonize();
        strcpy(current->comm, "kIrDAd");
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sigfillset(&current->blocked);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        set_fs(KERNEL_DS);
 

diff --git a/fs/afs/cmservice.c b/fs/afs/cmservice.c
index b3eca7db8051dd1f626321af41ad9b16bba59b4b..99960d0020260f1b34fdfb4059ef6490b91807ea 100644 (file)
--- a/fs/afs/cmservice.c
+++ b/fs/afs/cmservice.c
@@ -127,10 +127,10 @@ static int kafscmd(void *arg)
        complete(&kafscmd_alive);
 
        /* only certain signals are of interest */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        siginitsetinv(&current->blocked,0);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /* loop around looking for things to attend to */
        do {

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index a875684e3d4be9604368efb7fcd741a672e1581b..7de072e495c08c86eef89bf0c15b56313b036238 100644 (file)
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -46,9 +46,9 @@ static inline void afs_discard_my_signals(void)
        while (signal_pending(current)) {
                siginfo_t sinfo;
 
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                dequeue_signal(&current->blocked,&sinfo);
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 

diff --git a/fs/afs/kafsasyncd.c b/fs/afs/kafsasyncd.c
index caedebc20095fb4e35fde1960e079d614d8cfe44..e546a6da501531a806eeaa79d8136fcb6824865c 100644 (file)
--- a/fs/afs/kafsasyncd.c
+++ b/fs/afs/kafsasyncd.c
@@ -101,10 +101,10 @@ static int kafsasyncd(void *arg)
        complete(&kafsasyncd_alive);
 
        /* only certain signals are of interest */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        siginitsetinv(&current->blocked,0);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /* loop around looking for things to attend to */
        do {

diff --git a/fs/afs/kafstimod.c b/fs/afs/kafstimod.c
index 0d3f30a736570876e3ecd5da7e259626af4c8fce..2b0f5a9d84e9e5fe697a2b5918c543248a9cbf4a 100644 (file)
--- a/fs/afs/kafstimod.c
+++ b/fs/afs/kafstimod.c
@@ -78,10 +78,10 @@ static int kafstimod(void *arg)
        complete(&kafstimod_alive);
 
        /* only certain signals are of interest */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        siginitsetinv(&current->blocked,0);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /* loop around looking for things to attend to */
  loop:

diff --git a/fs/jffs/intrep.c b/fs/jffs/intrep.c
index d5b053e5b73a021cb7e80aff65750a3be58e006b..6cf3d86a5d7938535a1e1ede84df3e902bd894a2 100644 (file)
--- a/fs/jffs/intrep.c
+++ b/fs/jffs/intrep.c
@@ -3347,10 +3347,10 @@ jffs_garbage_collect_thread(void *ptr)
        current->session = 1;
        current->pgrp = 1;
        init_completion(&c->gc_thread_comp); /* barrier */ 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        siginitsetinv (&current->blocked, sigmask(SIGHUP) | sigmask(SIGKILL) | sigmask(SIGSTOP) | sigmask(SIGCONT));
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
        strcpy(current->comm, "jffs_gcd");
 
        D1(printk (KERN_NOTICE "jffs_garbage_collect_thread(): Starting infinite loop.\n"));
@@ -3378,9 +3378,9 @@ jffs_garbage_collect_thread(void *ptr)
                        siginfo_t info;
                        unsigned long signr = 0;
 
-                       spin_lock_irq(&current->sig->siglock);
+                       spin_lock_irq(&current->sighand->siglock);
                        signr = dequeue_signal(&current->blocked, &info);
-                       spin_unlock_irq(&current->sig->siglock);
+                       spin_unlock_irq(&current->sighand->siglock);
 
                        switch(signr) {
                        case SIGSTOP:

diff --git a/fs/jffs2/os-linux.h b/fs/jffs2/os-linux.h
index b1654cff562b93ad5dac32529c0b6881b0a59378..a5c35fdb51c8f3bb6c0af299341dac0408f3d572 100644 (file)
--- a/fs/jffs2/os-linux.h
+++ b/fs/jffs2/os-linux.h
@@ -54,7 +54,7 @@
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,40)
 #define current_sig_lock current->sigmask_lock
 #else
-#define current_sig_lock current->sig->siglock
+#define current_sig_lock current->sighand->siglock
 #endif
 
 static inline void jffs2_init_inode_info(struct jffs2_inode_info *f)

diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index e3d931ff7ca29307560b81a039494ceba484bf64..360139794557c6c91fd89d9c7f81b92490f32746 100644 (file)
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -2139,10 +2139,10 @@ int jfsIOWait(void *arg)
 
        unlock_kernel();
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sigfillset(&current->blocked);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        complete(&jfsIOwait);
 

diff --git a/fs/jfs/jfs_txnmgr.c b/fs/jfs/jfs_txnmgr.c
index f85bb58be45b3f62f057a11204d980f51156da48..6af148d0387ca39f64d98f8ae37461963ac2f926 100644 (file)
--- a/fs/jfs/jfs_txnmgr.c
+++ b/fs/jfs/jfs_txnmgr.c
@@ -2780,10 +2780,10 @@ int jfs_lazycommit(void *arg)
 
        jfsCommitTask = current;
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sigfillset(&current->blocked);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        LAZY_LOCK_INIT();
        TxAnchor.unlock_queue = TxAnchor.unlock_tail = 0;
@@ -2985,10 +2985,10 @@ int jfs_sync(void *arg)
 
        unlock_kernel();
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sigfillset(&current->blocked);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        complete(&jfsIOwait);
 

diff --git a/fs/ncpfs/sock.c b/fs/ncpfs/sock.c
index 93ba7610dde07c9f522c91abdc99d9a564f3cb6d..f01c538eb2822feb5984cc6a8ce2f1bf66af42e3 100644 (file)
--- a/fs/ncpfs/sock.c
+++ b/fs/ncpfs/sock.c
@@ -745,7 +745,7 @@ static int ncp_do_request(struct ncp_server *server, int size,
                sigset_t old_set;
                unsigned long mask, flags;
 
-               spin_lock_irqsave(&current->sig->siglock, flags);
+               spin_lock_irqsave(&current->sighand->siglock, flags);
                old_set = current->blocked;
                if (current->flags & PF_EXITING)
                        mask = 0;
@@ -764,7 +764,7 @@ static int ncp_do_request(struct ncp_server *server, int size,
                }
                siginitsetinv(&current->blocked, mask);
                recalc_sigpending();
-               spin_unlock_irqrestore(&current->sig->siglock, flags);
+               spin_unlock_irqrestore(&current->sighand->siglock, flags);
                
                fs = get_fs();
                set_fs(get_ds());
@@ -773,10 +773,10 @@ static int ncp_do_request(struct ncp_server *server, int size,
 
                set_fs(fs);
 
-               spin_lock_irqsave(&current->sig->siglock, flags);
+               spin_lock_irqsave(&current->sighand->siglock, flags);
                current->blocked = old_set;
                recalc_sigpending();
-               spin_unlock_irqrestore(&current->sig->siglock, flags);
+               spin_unlock_irqrestore(&current->sighand->siglock, flags);
        }
 
        DDPRINTK("do_ncp_rpc_call returned %d\n", result);

diff --git a/fs/smbfs/smbiod.c b/fs/smbfs/smbiod.c
index 5f7d1d5969fecbf8f060a129460ac4789045f9e7..41d5bbd8a3347b7ccf6e3c199f45843c5269fadc 100644 (file)
--- a/fs/smbfs/smbiod.c
+++ b/fs/smbfs/smbiod.c
@@ -285,10 +285,10 @@ static int smbiod(void *unused)
        MOD_INC_USE_COUNT;
        daemonize();
 
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        siginitsetinv(&current->blocked, sigmask(SIGKILL));
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        strcpy(current->comm, "smbiod");
 

diff --git a/fs/xfs/pagebuf/page_buf.c b/fs/xfs/pagebuf/page_buf.c
index 4c60a8799fcb77532656eb8bf84c91a8e5a13652..d6b027eb202211817613f05260f825c4452f5058 100644 (file)
--- a/fs/xfs/pagebuf/page_buf.c
+++ b/fs/xfs/pagebuf/page_buf.c
@@ -1581,10 +1581,10 @@ pagebuf_daemon(
        daemonize();
 
        /* Avoid signals */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        sigfillset(&current->blocked);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        strcpy(current->comm, "pagebufd");
        current->flags |= PF_MEMALLOC;

diff --git a/include/linux/sched.h b/include/linux/sched.h
index ea5d949f946cc1b5c9bc6fa9fa9b6452f6838e93..975dd5dca713c9264cd1d28ffe7ee2ad642c1364 100644 (file)
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -778,7 +778,7 @@ static inline void cond_resched_lock(spinlock_t * lock)
 
 /* Reevaluate whether the task has signals pending delivery.
    This is required every time the blocked sigset_t changes.
-   callers must hold sig->siglock.  */
+   callers must hold sighand->siglock.  */
 
 extern FASTCALL(void recalc_sigpending_tsk(struct task_struct *t));
 extern void recalc_sigpending(void);

diff --git a/kernel/suspend.c b/kernel/suspend.c
index 40efb8d02db69f76d355c5365ae3cb7af0b3edde..8ed7bde5aa18caa27127875df03fe4c70ed4a9d9 100644 (file)
--- a/kernel/suspend.c
+++ b/kernel/suspend.c
@@ -218,9 +218,9 @@ int freeze_processes(void)
                        /* FIXME: smp problem here: we may not access other process' flags
                           without locking */
                        p->flags |= PF_FREEZE;
-                       spin_lock_irqsave(&p->sig->siglock, flags);
+                       spin_lock_irqsave(&p->sighand->siglock, flags);
                        signal_wake_up(p, 0);
-                       spin_unlock_irqrestore(&p->sig->siglock, flags);
+                       spin_unlock_irqrestore(&p->sighand->siglock, flags);
                        todo++;
                } while_each_thread(g, p);
                read_unlock(&tasklist_lock);

diff --git a/net/rxrpc/internal.h b/net/rxrpc/internal.h
index 9e4553cc1aea5baa7a5df0e1a79cc729366018fa..b0ee06b71a7ec5b07eef35c4e3de91ed7db5a4bc 100644 (file)
--- a/net/rxrpc/internal.h
+++ b/net/rxrpc/internal.h
@@ -54,9 +54,9 @@ static inline void rxrpc_discard_my_signals(void)
        while (signal_pending(current)) {
                siginfo_t sinfo;
 
-               spin_lock_irq(&current->sig->siglock);
+               spin_lock_irq(&current->sighand->siglock);
                dequeue_signal(&current->blocked,&sinfo);
-               spin_unlock_irq(&current->sig->siglock);
+               spin_unlock_irq(&current->sighand->siglock);
        }
 }
 

diff --git a/net/rxrpc/krxiod.c b/net/rxrpc/krxiod.c
index d246585b8f078d06459a97d497ed1b60ab04b6bc..ae9987d6155fa6031cf6a2c629374933030fc5a8 100644 (file)
--- a/net/rxrpc/krxiod.c
+++ b/net/rxrpc/krxiod.c
@@ -47,10 +47,10 @@ static int rxrpc_krxiod(void *arg)
        daemonize();
 
        /* only certain signals are of interest */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        siginitsetinv(&current->blocked,0);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /* loop around waiting for work to do */
        do {

diff --git a/net/rxrpc/krxsecd.c b/net/rxrpc/krxsecd.c
index 4e35bd3514125d15094ee22a717b1f18e70fb488..39f4eac9f224b6577a4414f8f8a490e57e812f61 100644 (file)
--- a/net/rxrpc/krxsecd.c
+++ b/net/rxrpc/krxsecd.c
@@ -59,10 +59,10 @@ static int rxrpc_krxsecd(void *arg)
        daemonize();
 
        /* only certain signals are of interest */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        siginitsetinv(&current->blocked,0);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /* loop around waiting for work to do */
        do {

diff --git a/net/rxrpc/krxtimod.c b/net/rxrpc/krxtimod.c
index 8eb61e64fa5516c20527fb9facb79d558d2f2d6a..c6df1edf38fffd120615baeea6779fbaae465cf5 100644 (file)
--- a/net/rxrpc/krxtimod.c
+++ b/net/rxrpc/krxtimod.c
@@ -77,10 +77,10 @@ static int krxtimod(void *arg)
        complete(&krxtimod_alive);
 
        /* only certain signals are of interest */
-       spin_lock_irq(&current->sig->siglock);
+       spin_lock_irq(&current->sighand->siglock);
        siginitsetinv(&current->blocked,0);
        recalc_sigpending();
-       spin_unlock_irq(&current->sig->siglock);
+       spin_unlock_irq(&current->sighand->siglock);
 
        /* loop around looking for things to attend to */
  loop: