Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 57d7f939 authored by Martin Schwidefsky's avatar Martin Schwidefsky
Browse files

s390: add no-execute support 



Bit 0x100 of a page table, segment table of region table entry
can be used to disallow code execution for the virtual addresses
associated with the entry.

There is one tricky bit, the system call to return from a signal
is part of the signal frame written to the user stack. With a
non-executable stack this would stop working. To avoid breaking
things the protection fault handler checks the opcode that caused
the fault for 0x0a77 (sys_sigreturn) and 0x0aad (sys_rt_sigreturn)
and injects a system call. This is preferable to the alternative
solution with a stub function in the vdso because it works for
vdso=off and statically linked binaries as well.

Signed-off-by: default avatarMartin Schwidefsky <schwidefsky@de.ibm.com>
parent 2583b848

arch/s390/include/asm/cacheflush.h

+26 −4
Original line number Diff line number Diff line
@@ -4,9 +4,31 @@ 
/* Caches aren't brain-dead on the s390. */

#include <asm-generic/cacheflush.h>



int set_memory_ro(unsigned long addr, int numpages);

int set_memory_rw(unsigned long addr, int numpages);

int set_memory_nx(unsigned long addr, int numpages);

int set_memory_x(unsigned long addr, int numpages);

#define SET_MEMORY_RO	1UL

#define SET_MEMORY_RW	2UL

#define SET_MEMORY_NX	4UL

#define SET_MEMORY_X	8UL



int __set_memory(unsigned long addr, int numpages, unsigned long flags);



static inline int set_memory_ro(unsigned long addr, int numpages)

{

	return __set_memory(addr, numpages, SET_MEMORY_RO);

}



static inline int set_memory_rw(unsigned long addr, int numpages)

{

	return __set_memory(addr, numpages, SET_MEMORY_RW);

}



static inline int set_memory_nx(unsigned long addr, int numpages)

{

	return __set_memory(addr, numpages, SET_MEMORY_NX);

}



static inline int set_memory_x(unsigned long addr, int numpages)

{

	return __set_memory(addr, numpages, SET_MEMORY_X);

}



#endif /* _S390_CACHEFLUSH_H */

arch/s390/include/asm/pgtable.h

+61 −34
Original line number Diff line number Diff line
@@ -200,6 +200,7 @@ static inline int is_module_addr(void *addr) 
 */



/* Hardware bits in the page table entry */

#define _PAGE_NOEXEC	0x100		/* HW no-execute bit  */

#define _PAGE_PROTECT	0x200		/* HW read-only bit  */

#define _PAGE_INVALID	0x400		/* HW invalid bit    */

#define _PAGE_LARGE	0x800		/* Bit to mark a large pte */
@@ -277,6 +278,7 @@ static inline int is_module_addr(void *addr) 
/* Bits in the region table entry */

#define _REGION_ENTRY_ORIGIN	~0xfffUL/* region/segment table origin	    */

#define _REGION_ENTRY_PROTECT	0x200	/* region protection bit	    */

#define _REGION_ENTRY_NOEXEC	0x100	/* region no-execute bit	    */

#define _REGION_ENTRY_OFFSET	0xc0	/* region table offset		    */

#define _REGION_ENTRY_INVALID	0x20	/* invalid region table entry	    */

#define _REGION_ENTRY_TYPE_MASK	0x0c	/* region/segment table type mask   */
@@ -316,6 +318,7 @@ static inline int is_module_addr(void *addr) 
#define _SEGMENT_ENTRY_ORIGIN_LARGE ~0xfffffUL /* large page address	    */

#define _SEGMENT_ENTRY_ORIGIN	~0x7ffUL/* segment table origin		    */

#define _SEGMENT_ENTRY_PROTECT	0x200	/* page protection bit		    */

#define _SEGMENT_ENTRY_NOEXEC	0x100	/* region no-execute bit	    */

#define _SEGMENT_ENTRY_INVALID	0x20	/* invalid segment table entry	    */



#define _SEGMENT_ENTRY		(0)
@@ -385,17 +388,23 @@ static inline int is_module_addr(void *addr) 
 * Page protection definitions.

 */

#define PAGE_NONE	__pgprot(_PAGE_PRESENT | _PAGE_INVALID | _PAGE_PROTECT)

#define PAGE_READ	__pgprot(_PAGE_PRESENT | _PAGE_READ | \

#define PAGE_RO		__pgprot(_PAGE_PRESENT | _PAGE_READ | \

				 _PAGE_NOEXEC  | _PAGE_INVALID | _PAGE_PROTECT)

#define PAGE_RX		__pgprot(_PAGE_PRESENT | _PAGE_READ | \

				 _PAGE_INVALID | _PAGE_PROTECT)

#define PAGE_WRITE	__pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \

#define PAGE_RW		__pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \

				 _PAGE_NOEXEC  | _PAGE_INVALID | _PAGE_PROTECT)

#define PAGE_RWX	__pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \

				 _PAGE_INVALID | _PAGE_PROTECT)



#define PAGE_SHARED	__pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \

				 _PAGE_YOUNG | _PAGE_DIRTY)

				 _PAGE_YOUNG | _PAGE_DIRTY | _PAGE_NOEXEC)

#define PAGE_KERNEL	__pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \

				 _PAGE_YOUNG | _PAGE_DIRTY)

				 _PAGE_YOUNG | _PAGE_DIRTY | _PAGE_NOEXEC)

#define PAGE_KERNEL_RO	__pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_YOUNG | \

				 _PAGE_PROTECT)

				 _PAGE_PROTECT | _PAGE_NOEXEC)

#define PAGE_KERNEL_EXEC __pgprot(_PAGE_PRESENT | _PAGE_READ | _PAGE_WRITE | \

				  _PAGE_YOUNG |	_PAGE_DIRTY)



/*

 * On s390 the page table entry has an invalid bit and a read-only bit.
@@ -404,43 +413,51 @@ static inline int is_module_addr(void *addr) 
 */

         /*xwr*/

#define __P000	PAGE_NONE

#define __P001	PAGE_READ

#define __P010	PAGE_READ

#define __P011	PAGE_READ

#define __P100	PAGE_READ

#define __P101	PAGE_READ

#define __P110	PAGE_READ

#define __P111	PAGE_READ

#define __P001	PAGE_RO

#define __P010	PAGE_RO

#define __P011	PAGE_RO

#define __P100	PAGE_RX

#define __P101	PAGE_RX

#define __P110	PAGE_RX

#define __P111	PAGE_RX



#define __S000	PAGE_NONE

#define __S001	PAGE_READ

#define __S010	PAGE_WRITE

#define __S011	PAGE_WRITE

#define __S100	PAGE_READ

#define __S101	PAGE_READ

#define __S110	PAGE_WRITE

#define __S111	PAGE_WRITE

#define __S001	PAGE_RO

#define __S010	PAGE_RW

#define __S011	PAGE_RW

#define __S100	PAGE_RX

#define __S101	PAGE_RX

#define __S110	PAGE_RWX

#define __S111	PAGE_RWX



/*

 * Segment entry (large page) protection definitions.

 */

#define SEGMENT_NONE	__pgprot(_SEGMENT_ENTRY_INVALID | \

				 _SEGMENT_ENTRY_PROTECT)

#define SEGMENT_READ	__pgprot(_SEGMENT_ENTRY_PROTECT | \

#define SEGMENT_RO	__pgprot(_SEGMENT_ENTRY_PROTECT | \

				 _SEGMENT_ENTRY_READ | \

				 _SEGMENT_ENTRY_NOEXEC)

#define SEGMENT_RX	__pgprot(_SEGMENT_ENTRY_PROTECT | \

				 _SEGMENT_ENTRY_READ)

#define SEGMENT_WRITE	__pgprot(_SEGMENT_ENTRY_READ | \

#define SEGMENT_RW	__pgprot(_SEGMENT_ENTRY_READ | \

				 _SEGMENT_ENTRY_WRITE | \

				 _SEGMENT_ENTRY_NOEXEC)

#define SEGMENT_RWX	__pgprot(_SEGMENT_ENTRY_READ | \

				 _SEGMENT_ENTRY_WRITE)

#define SEGMENT_KERNEL	__pgprot(_SEGMENT_ENTRY |	\

				 _SEGMENT_ENTRY_LARGE |	\

				 _SEGMENT_ENTRY_READ |	\

				 _SEGMENT_ENTRY_WRITE | \

				 _SEGMENT_ENTRY_YOUNG | \

				 _SEGMENT_ENTRY_DIRTY)

				 _SEGMENT_ENTRY_DIRTY | \

				 _SEGMENT_ENTRY_NOEXEC)

#define SEGMENT_KERNEL_RO __pgprot(_SEGMENT_ENTRY |	\

				 _SEGMENT_ENTRY_LARGE |	\

				 _SEGMENT_ENTRY_READ |	\

				 _SEGMENT_ENTRY_YOUNG |	\

				 _SEGMENT_ENTRY_PROTECT)

				 _SEGMENT_ENTRY_PROTECT | \

				 _SEGMENT_ENTRY_NOEXEC)



/*

 * Region3 entry (large page) protection definitions.
@@ -451,12 +468,14 @@ static inline int is_module_addr(void *addr) 
				 _REGION3_ENTRY_READ |	 \

				 _REGION3_ENTRY_WRITE |	 \

				 _REGION3_ENTRY_YOUNG |	 \

				 _REGION3_ENTRY_DIRTY)

				 _REGION3_ENTRY_DIRTY | \

				 _REGION_ENTRY_NOEXEC)

#define REGION3_KERNEL_RO __pgprot(_REGION_ENTRY_TYPE_R3 | \

				   _REGION3_ENTRY_LARGE |  \

				   _REGION3_ENTRY_READ |   \

				   _REGION3_ENTRY_YOUNG |  \

				   _REGION_ENTRY_PROTECT)

				   _REGION_ENTRY_PROTECT | \

				   _REGION_ENTRY_NOEXEC)



static inline int mm_has_pgste(struct mm_struct *mm)

{
@@ -801,14 +820,14 @@ static inline pte_t pte_modify(pte_t pte, pgprot_t newprot) 
	pte_val(pte) &= _PAGE_CHG_MASK;

	pte_val(pte) |= pgprot_val(newprot);

	/*

	 * newprot for PAGE_NONE, PAGE_READ and PAGE_WRITE has the

	 * invalid bit set, clear it again for readable, young pages

	 * newprot for PAGE_NONE, PAGE_RO, PAGE_RX, PAGE_RW and PAGE_RWX

	 * has the invalid bit set, clear it again for readable, young pages

	 */

	if ((pte_val(pte) & _PAGE_YOUNG) && (pte_val(pte) & _PAGE_READ))

		pte_val(pte) &= ~_PAGE_INVALID;

	/*

	 * newprot for PAGE_READ and PAGE_WRITE has the page protection

	 * bit set, clear it again for writable, dirty pages

	 * newprot for PAGE_RO, PAGE_RX, PAGE_RW and PAGE_RWX has the page

	 * protection bit set, clear it again for writable, dirty pages

	 */

	if ((pte_val(pte) & _PAGE_DIRTY) && (pte_val(pte) & _PAGE_WRITE))

		pte_val(pte) &= ~_PAGE_PROTECT;
@@ -1029,6 +1048,8 @@ int get_guest_storage_key(struct mm_struct *mm, unsigned long addr, 
static inline void set_pte_at(struct mm_struct *mm, unsigned long addr,

			      pte_t *ptep, pte_t entry)

{

	if (!MACHINE_HAS_NX)

		pte_val(entry) &= ~_PAGE_NOEXEC;

	if (mm_has_pgste(mm))

		ptep_set_pte_at(mm, addr, ptep, entry);

	else
@@ -1173,14 +1194,18 @@ static inline pud_t pud_mkdirty(pud_t pud) 
static inline unsigned long massage_pgprot_pmd(pgprot_t pgprot)

{

	/*

	 * pgprot is PAGE_NONE, PAGE_READ, or PAGE_WRITE (see __Pxxx / __Sxxx)

	 * Convert to segment table entry format.

	 * pgprot is PAGE_NONE, PAGE_RO, PAGE_RX, PAGE_RW or PAGE_RWX

	 * (see __Pxxx / __Sxxx). Convert to segment table entry format.

	 */

	if (pgprot_val(pgprot) == pgprot_val(PAGE_NONE))

		return pgprot_val(SEGMENT_NONE);

	if (pgprot_val(pgprot) == pgprot_val(PAGE_READ))

		return pgprot_val(SEGMENT_READ);

	return pgprot_val(SEGMENT_WRITE);

	if (pgprot_val(pgprot) == pgprot_val(PAGE_RO))

		return pgprot_val(SEGMENT_RO);

	if (pgprot_val(pgprot) == pgprot_val(PAGE_RX))

		return pgprot_val(SEGMENT_RX);

	if (pgprot_val(pgprot) == pgprot_val(PAGE_RW))

		return pgprot_val(SEGMENT_RW);

	return pgprot_val(SEGMENT_RWX);

}



static inline pmd_t pmd_mkyoung(pmd_t pmd)
@@ -1315,6 +1340,8 @@ static inline int pmdp_clear_flush_young(struct vm_area_struct *vma, 
static inline void set_pmd_at(struct mm_struct *mm, unsigned long addr,

			      pmd_t *pmdp, pmd_t entry)

{

	if (!MACHINE_HAS_NX)

		pmd_val(entry) &= ~_SEGMENT_ENTRY_NOEXEC;

	*pmdp = entry;

}

arch/s390/include/asm/setup.h

+2 −0
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#define MACHINE_FLAG_TLB_LC	_BITUL(12)

#define MACHINE_FLAG_VX		_BITUL(13)

#define MACHINE_FLAG_CAD	_BITUL(14)

#define MACHINE_FLAG_NX		_BITUL(15)



#define LPP_MAGIC		_BITUL(31)

#define LPP_PFAULT_PID_MASK	_AC(0xffffffff, UL)
@@ -71,6 +72,7 @@ extern void detect_memory_memblock(void); 
#define MACHINE_HAS_TLB_LC	(S390_lowcore.machine_flags & MACHINE_FLAG_TLB_LC)

#define MACHINE_HAS_VX		(S390_lowcore.machine_flags & MACHINE_FLAG_VX)

#define MACHINE_HAS_CAD		(S390_lowcore.machine_flags & MACHINE_FLAG_CAD)

#define MACHINE_HAS_NX		(S390_lowcore.machine_flags & MACHINE_FLAG_NX)



/*

 * Console mode. Override with conmode=

arch/s390/kernel/early.c

+19 −0
Original line number Diff line number Diff line
@@ -354,6 +354,10 @@ static __init void detect_machine_facilities(void) 
		S390_lowcore.machine_flags |= MACHINE_FLAG_VX;

		__ctl_set_bit(0, 17);

	}

	if (test_facility(130)) {

		S390_lowcore.machine_flags |= MACHINE_FLAG_NX;

		__ctl_set_bit(0, 20);

	}

}



static inline void save_vector_registers(void)
@@ -384,6 +388,21 @@ static int __init disable_vector_extension(char *str) 
}

early_param("novx", disable_vector_extension);



static int __init noexec_setup(char *str)

{

	bool enabled;

	int rc;



	rc = kstrtobool(str, &enabled);

	if (!rc && !enabled) {

		/* Disable no-execute support */

		S390_lowcore.machine_flags &= ~MACHINE_FLAG_NX;

		__ctl_clear_bit(0, 20);

	}

	return rc;

}

early_param("noexec", noexec_setup);



static int __init cad_setup(char *str)

{

	int val;

arch/s390/kernel/entry.S

+6 −6
Original line number Diff line number Diff line
@@ -380,13 +380,11 @@ ENTRY(system_call) 
	brasl	%r14,do_signal

	TSTMSK	__PT_FLAGS(%r11),_PIF_SYSCALL

	jno	.Lsysc_return

.Lsysc_do_syscall:

	lghi	%r13,__TASK_thread

	lmg	%r2,%r7,__PT_R2(%r11)	# load svc arguments

	lghi	%r8,0			# svc 0 returns -ENOSYS

	llgh	%r1,__PT_INT_CODE+2(%r11)	# load new svc number

	cghi	%r1,NR_syscalls

	jnl	.Lsysc_nr_ok		# invalid svc number -> do svc 0

	slag	%r8,%r1,2

	j	.Lsysc_nr_ok		# restart svc

	lghi	%r1,0			# svc 0 returns -ENOSYS

	j	.Lsysc_do_svc



#

# _TIF_NOTIFY_RESUME is set, call do_notify_resume
@@ -528,6 +526,8 @@ ENTRY(pgm_check_handler) 
	LOCKDEP_SYS_EXIT

	tm	__PT_PSW+1(%r11),0x01	# returning to user ?

	jno	.Lsysc_restore

	TSTMSK	__PT_FLAGS(%r11),_PIF_SYSCALL

	jo	.Lsysc_do_syscall

	j	.Lsysc_tif



#