tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc:
sparc: Add alignment flag to PCI expansion resources
sparc: Avoid calling sigprocmask()
sparc: Use set_current_blocked()
sparc32,leon: SRMMU MMU Table probe fix

Linus Torvalds fd11e153 505f48b5

+37 -55
+1 -1
arch/sparc/include/asm/pgtsrmmu.h
··· 280 280 return retval; 281 281 } 282 282 #else 283 - #define srmmu_hwprobe(addr) (srmmu_swprobe(addr, 0) & SRMMU_PTE_PMASK) 283 + #define srmmu_hwprobe(addr) srmmu_swprobe(addr, 0) 284 284 #endif 285 285 286 286 static inline int
+2 -1
arch/sparc/kernel/pci.c
··· 230 230 res = &dev->resource[(i - PCI_BASE_ADDRESS_0) >> 2]; 231 231 } else if (i == dev->rom_base_reg) { 232 232 res = &dev->resource[PCI_ROM_RESOURCE]; 233 - flags |= IORESOURCE_READONLY | IORESOURCE_CACHEABLE; 233 + flags |= IORESOURCE_READONLY | IORESOURCE_CACHEABLE 234 + | IORESOURCE_SIZEALIGN; 234 235 } else { 235 236 printk(KERN_ERR "PCI: bad cfg reg num 0x%x\n", i); 236 237 continue;
+7 -14
arch/sparc/kernel/signal32.c
··· 273 273 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32); 274 274 } 275 275 sigdelsetmask(&set, ~_BLOCKABLE); 276 - spin_lock_irq(&current->sighand->siglock); 277 - current->blocked = set; 278 - recalc_sigpending(); 279 - spin_unlock_irq(&current->sighand->siglock); 276 + set_current_blocked(&set); 280 277 return; 281 278 282 279 segv: ··· 374 377 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32); 375 378 } 376 379 sigdelsetmask(&set, ~_BLOCKABLE); 377 - spin_lock_irq(&current->sighand->siglock); 378 - current->blocked = set; 379 - recalc_sigpending(); 380 - spin_unlock_irq(&current->sighand->siglock); 380 + set_current_blocked(&set); 381 381 return; 382 382 segv: 383 383 force_sig(SIGSEGV, current); ··· 776 782 siginfo_t *info, 777 783 sigset_t *oldset, struct pt_regs *regs) 778 784 { 785 + sigset_t blocked; 779 786 int err; 780 787 781 788 if (ka->sa.sa_flags & SA_SIGINFO) ··· 787 792 if (err) 788 793 return err; 789 794 790 - spin_lock_irq(&current->sighand->siglock); 791 - sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask); 795 + sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask); 792 796 if (!(ka->sa.sa_flags & SA_NOMASK)) 793 - sigaddset(&current->blocked,signr); 794 - recalc_sigpending(); 795 - spin_unlock_irq(&current->sighand->siglock); 797 + sigaddset(&blocked, signr); 798 + set_current_blocked(&blocked); 796 799 797 800 tracehook_signal_handler(signr, info, ka, regs, 0); 798 801 ··· 874 881 */ 875 882 if (current_thread_info()->status & TS_RESTORE_SIGMASK) { 876 883 current_thread_info()->status &= ~TS_RESTORE_SIGMASK; 877 - sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL); 884 + set_current_blocked(&current->saved_sigmask); 878 885 } 879 886 } 880 887
+13 -19
arch/sparc/kernel/signal_32.c
··· 62 62 63 63 static int _sigpause_common(old_sigset_t set) 64 64 { 65 - set &= _BLOCKABLE; 66 - spin_lock_irq(&current->sighand->siglock); 65 + sigset_t blocked; 66 + 67 67 current->saved_sigmask = current->blocked; 68 - siginitset(&current->blocked, set); 69 - recalc_sigpending(); 70 - spin_unlock_irq(&current->sighand->siglock); 68 + 69 + set &= _BLOCKABLE; 70 + siginitset(&blocked, set); 71 + set_current_blocked(&blocked); 71 72 72 73 current->state = TASK_INTERRUPTIBLE; 73 74 schedule(); ··· 140 139 goto segv_and_exit; 141 140 142 141 sigdelsetmask(&set, ~_BLOCKABLE); 143 - spin_lock_irq(&current->sighand->siglock); 144 - current->blocked = set; 145 - recalc_sigpending(); 146 - spin_unlock_irq(&current->sighand->siglock); 142 + set_current_blocked(&set); 147 143 return; 148 144 149 145 segv_and_exit: ··· 207 209 } 208 210 209 211 sigdelsetmask(&set, ~_BLOCKABLE); 210 - spin_lock_irq(&current->sighand->siglock); 211 - current->blocked = set; 212 - recalc_sigpending(); 213 - spin_unlock_irq(&current->sighand->siglock); 212 + set_current_blocked(&set); 214 213 return; 215 214 segv: 216 215 force_sig(SIGSEGV, current); ··· 465 470 handle_signal(unsigned long signr, struct k_sigaction *ka, 466 471 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs) 467 472 { 473 + sigset_t blocked; 468 474 int err; 469 475 470 476 if (ka->sa.sa_flags & SA_SIGINFO) ··· 476 480 if (err) 477 481 return err; 478 482 479 - spin_lock_irq(&current->sighand->siglock); 480 - sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask); 483 + sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask); 481 484 if (!(ka->sa.sa_flags & SA_NOMASK)) 482 - sigaddset(&current->blocked, signr); 483 - recalc_sigpending(); 484 - spin_unlock_irq(&current->sighand->siglock); 485 + sigaddset(&blocked, signr); 486 + set_current_blocked(&blocked); 485 487 486 488 tracehook_signal_handler(signr, info, ka, regs, 0); 487 489 ··· 575 581 */ 576 582 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 577 583 clear_thread_flag(TIF_RESTORE_SIGMASK); 578 - sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL); 584 + set_current_blocked(&current->saved_sigmask); 579 585 } 580 586 } 581 587
+13 -19
arch/sparc/kernel/signal_64.c
··· 70 70 goto do_sigsegv; 71 71 } 72 72 sigdelsetmask(&set, ~_BLOCKABLE); 73 - spin_lock_irq(&current->sighand->siglock); 74 - current->blocked = set; 75 - recalc_sigpending(); 76 - spin_unlock_irq(&current->sighand->siglock); 73 + set_current_blocked(&set); 77 74 } 78 75 if (test_thread_flag(TIF_32BIT)) { 79 76 pc &= 0xffffffff; ··· 239 242 240 243 static long _sigpause_common(old_sigset_t set) 241 244 { 242 - set &= _BLOCKABLE; 243 - spin_lock_irq(&current->sighand->siglock); 245 + sigset_t blocked; 246 + 244 247 current->saved_sigmask = current->blocked; 245 - siginitset(&current->blocked, set); 246 - recalc_sigpending(); 247 - spin_unlock_irq(&current->sighand->siglock); 248 + 249 + set &= _BLOCKABLE; 250 + siginitset(&blocked, set); 251 + set_current_blocked(&blocked); 248 252 249 253 current->state = TASK_INTERRUPTIBLE; 250 254 schedule(); ··· 325 327 pt_regs_clear_syscall(regs); 326 328 327 329 sigdelsetmask(&set, ~_BLOCKABLE); 328 - spin_lock_irq(&current->sighand->siglock); 329 - current->blocked = set; 330 - recalc_sigpending(); 331 - spin_unlock_irq(&current->sighand->siglock); 330 + set_current_blocked(&set); 332 331 return; 333 332 segv: 334 333 force_sig(SIGSEGV, current); ··· 479 484 siginfo_t *info, 480 485 sigset_t *oldset, struct pt_regs *regs) 481 486 { 487 + sigset_t blocked; 482 488 int err; 483 489 484 490 err = setup_rt_frame(ka, regs, signr, oldset, 485 491 (ka->sa.sa_flags & SA_SIGINFO) ? info : NULL); 486 492 if (err) 487 493 return err; 488 - spin_lock_irq(&current->sighand->siglock); 489 - sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask); 494 + sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask); 490 495 if (!(ka->sa.sa_flags & SA_NOMASK)) 491 - sigaddset(&current->blocked,signr); 492 - recalc_sigpending(); 493 - spin_unlock_irq(&current->sighand->siglock); 496 + sigaddset(&blocked, signr); 497 + set_current_blocked(&blocked); 494 498 495 499 tracehook_signal_handler(signr, info, ka, regs, 0); 496 500 ··· 595 601 */ 596 602 if (current_thread_info()->status & TS_RESTORE_SIGMASK) { 597 603 current_thread_info()->status &= ~TS_RESTORE_SIGMASK; 598 - sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL); 604 + set_current_blocked(&current->saved_sigmask); 599 605 } 600 606 } 601 607
+1 -1
arch/sparc/mm/leon_mm.c
··· 162 162 printk(KERN_INFO "swprobe: padde %x\n", paddr_calc); 163 163 if (paddr) 164 164 *paddr = paddr_calc; 165 - return paddrbase; 165 + return pte; 166 166 } 167 167 168 168 void leon_flush_icache_all(void)